Ready to put Photon Fusion 2 into practice? In this final part of our series, you’ll learn how to implement real multiplayer features step by step in a simple Unity game. We’ll skip the non-networking stuff and focus on essential multiplayer systems. Session setup, player management, object synchronisation, reconnect logic, and more. By following this guide, you’ll build a solid foundation for scalable, production-ready multiplayer games in Unity.

Introduction

Welcome to the final article in our Photon Fusion 2 beginner series! Here, we’ll take a practical approach – step by step, you’ll learn how to build the multiplayer part of a simple Unity game using Photon Fusion 2. This article won’t give you a complete game, but you’ll focus only on features directly tied to Fusion 2 networking. To keep things clear, we’ll skip unrelated mechanics like UI, loading screens, or single-player logic. Every code sample below delivers a real networking function you can use as a foundation for your own projects. We’ll work with Unity’s basic primitives – planes, cubes and spheres – and supplement them with free assets from the Unity Asset Store.

Game Description

This project focuses on a small part of a larger game to help you learn core multiplayer mechanics you can expand later. You won’t see a complete game loop, but you’ll get a solid foundation for your own projects.

The game is a 3D top-down shooter where you work with up to 4 players in classic co-op mode. Each player drives a unique vehicle using the W, S, A, D keys and the mouse. At the start of each session, players choose from three predefined vehicles. Every vehicle has a weapon mounted on its roof – you aim and shoot using the mouse. Missions include red objects as required targets – you must destroy all of them to win. Yellow objects are optional – you can destroy them, but they aren’t needed to finish the mission. Automated turrets on the map shoot at player vehicles and deal damage.

Project Setup

Before you start with Photon Fusion 2, make sure you have everything set up. We explained all the details in the first article of this series, so if you need a refresher, click here.

Photon Dashboard

First, create a Photon Engine account. If you don’t have one yet, go to the Photon website and sign up.

Next, open the Photon Dashboard and create a new Fusion 2 application. This will generate a dedicated App ID for your game. You can reuse the same App ID from previous articles if you want, but remember: network traffic from both projects will mix. This is fine for personal test projects.

Once you’ve set up your “My Awesome Game”, copy its App ID from the location shown in the image below. Now you’re ready to configure your Unity project.

Unity Project

At the time of writing this post, the latest Photon Fusion 2 SDK is 2.0.12 Stable Build 1861, released March 19, 2026. The minimum Unity version required for Photon Fusion 2 is 2021.3.45/2022.3.x/6.0.x or newer.

Create a new Unity project and import the Fusion 2 SDK. Download the latest Fusion 2 .unitypackage from this link, then import it using Assets > Import Package > Custom Package. After the import, you’ll see the Photon Fusion 2 Hub – your main management panel. If it doesn’t appear automatically, find it in the top menu under Tools > Fusion > Fusion Hub.

Paste the App ID you copied earlier from the Dashboard into the appropriate field. If the App ID is valid, the icon will turn green. Now your setup is complete – you’re ready to start building with Fusion 2!

Scene Management

In this section, you’ll create a SceneLoader class to manage scene transitions during the game. Your project uses three main scenes: Splash_Screen, Main_Menu, and Mission_x. You can add more mission scenes later if you want to expand the project, but for this tutorial, you’ll work with just one. Make sure to include every scene you plan to use in the Build Settings window.

The Splash_Screen scene initialises core game systems. It loads only once when the app starts and creates singleton objects that remain active throughout the session. This scene has its own controller, which moves the game to Main_Menu automatically once all required systems are ready. On Splash_Screen, you’ll set up the Network Manager (explained in the next section), the Missions Manager (handles available mission info), and the SceneLoader itself. You’ll also initialise shared UI elements here, such as pop-up controllers and the loading screen shown when switching scenes.

The Main_Menu scene is where players choose the game mode – for example, Singleplayer or Multiplayer – and adjust settings. Here, players can host a game, join existing sessions, or configure the match before starting. The Host can launch the mission only after every player has picked a vehicle and set their status to Ready. At that point, the SceneLoader switches to the Mission_x scene.

The Mission_x scene is the specific mission chosen by the Host. In this scene, players control their vehicles and work together to complete mission objectives.

Below is the SceneLoader class, which extends the default NetworkSceneManagerDefault controller from Photon Fusion 2. This custom SceneLoader adds support for loading screens, lets you respond to scene loading progress, and gives you a place to add any extra logic your game needs.

In the code below, you’ll find a tutorial-only section that introduces a fake loading time. This part simulates large data loads and longer system initialisation; you can safely remove it from your own project.

This code assumes Splash_Screen and Main_Menu have scene indexes 0 and 1, and that mission scenes start from index 2. That’s why the LoadMission method uses GetMissionSceneIndex, which calculates the correct scene index for the chosen mission ID. In this tutorial, every scene loads in Single mode, but check the documentation for info on additive scene loading and how to write a custom scene controller using the Fusion 2 INetworkSceneManager interface.

SceneLoader.cs

using Fusion;
using ProtoGDM.Networking;
using ProtoGDM.UI;
using System.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace ProtoGDM.ScenesManagement
{
    public class SceneLoader : NetworkSceneManagerDefault
    {
        #region Variables

        public const int SPLASH_SCREEN_SCENE = 0;
        public const int MAIN_MENU_SCENE = 1;

        [SerializeField]
        private float minimumLoadingTime = 2f;

        #endregion Variables

        #region Public methods

        public void LoadScene(int index, bool noRunner = false)
        {
            if (!noRunner && Runner)
            {
                Runner.LoadScene(SceneRef.FromIndex(index));
            }
            else
            {
                StartCoroutine(LoadSceneAsync(index));
            }
        }

        public void LoadMission(Mission mission)
        {
            if (Runner)
            {
                Runner.LoadScene(SceneRef.FromIndex(GetMissionSceneIndex(mission.ID)), LoadSceneMode.Single);
            }
        }

        #endregion Public methods

        #region Private methods

        protected override IEnumerator LoadSceneCoroutine(SceneRef sceneRef, NetworkLoadSceneParameters sceneParams)
        {
            PreLoadScene(sceneRef.AsIndex);

            yield return base.LoadSceneCoroutine(sceneRef, sceneParams);

            // Delay one frame, so we're sure level objects has spawned locally
            yield return null;

            if (sceneRef.AsIndex > MAIN_MENU_SCENE)
            {
                if (Runner.IsServer && (Runner.GameMode == GameMode.Single || Runner.GameMode == GameMode.Host))
                {
                    if (Runner.CanSpawn)
                    {
                        foreach (RoomPlayer roomPlayer in RoomPlayer.RoomPlayers)
                        {
                            MissionController.Instance.SpawnPlayerVehicle(Runner, roomPlayer);
                        }
                    }
                }
            }

            PostLoadScene();
        }

        protected override void OnLoadSceneProgress(SceneRef sceneRef, float progress)
        {
            base.OnLoadSceneProgress(sceneRef, progress);

            // TODO: Loading Progress logic here.
        }

        protected override IEnumerator OnSceneLoaded(SceneRef sceneRef, Scene scene, NetworkLoadSceneParameters sceneParams)
        {
            // TODO: Scene Loaded logic here.

            yield return base.OnSceneLoaded(sceneRef, scene, sceneParams);
        }

        private void PreLoadScene(int index)
        {
            LoadingScreenUIManager.Instance.ShowLoadingScreen(1.5f);
        }

        private void PostLoadScene()
        {
            LoadingScreenUIManager.Instance.HideLoadingScreen();

            PopupsUIManager.Instance.HideLastPopup();
        }

        private int GetMissionSceneIndex(int missionIndex)
        {
            int offset = 2;

            return missionIndex + offset;
        }

        private IEnumerator LoadSceneAsync(int index)
        {
            PreLoadScene(index);

            float startTime = Time.time;

            AsyncOperation asyncOperation = SceneManager.LoadSceneAsync(index);

            asyncOperation.allowSceneActivation = false;

            while (asyncOperation.progress < 0.9f)
            {
                yield return null;
            }

            float elapsedTime = Time.time - startTime;

            //Simulated loading delay (minimumLoadingTime) to mimic the loading of larger data assets.
            if (elapsedTime < minimumLoadingTime)
            {
                yield return new WaitForSeconds(minimumLoadingTime - elapsedTime);
            }

            asyncOperation.allowSceneActivation = true;

            while (!asyncOperation.isDone)
            {
                yield return null;
            }

            PostLoadScene();
        }

        #endregion Private methods
    }
}

Below is the ready-to-use code for the MissionManager and Mission classes. Add a MissionManager component to an object in the Splash_Screen scene. Be sure to set up at least one mission. The first mission should have an ID of 0 and a valid scene name, such as Mission_1.

MissionsManager.cs

using ProtoGDM.Utilities;
using System.Collections.Generic;
using UnityEngine;

namespace ProtoGDM
{
    public class MissionsManager : Singleton<MissionsManager>
    {
        #region Properties

        [SerializeField]
        private List<Mission> missions;

        #endregion

        #region Unity methods

        protected override void Awake()
        {
            base.Awake();

            DontDestroyOnLoad(gameObject);
        }

        #endregion Unity methods

        #region Public methods

        public Mission GetMission(int id)
        {
            Mission mission = null;

            foreach (var item in missions)
            {
                if (item.ID == id)
                {
                    mission = item;

                    break;
                }
            }

            return mission;
        }

        public List<Mission> GetMissions()
        {
            if (missions != null)
            {
                return new List<Mission>(missions);
            }
            else
            {
                return new List<Mission>();
            }
        }

        #endregion Public methods
    }
}

Mission.cs

using System;
using UnityEngine;

namespace ProtoGDM
{
    [Serializable]
    public class Mission
    {
        #region Properties

        [SerializeField]
        private int id;

        public int ID
        {
            get
            {
                return id;
            }
        }

        [SerializeField]
        private string title;

        public string Title
        {
            get
            {
                return title;
            }
        }

        [SerializeField]
        private string description;

        public string Description
        {
            get
            {
                return description;
            }
        }

        [SerializeField]
        private Sprite sprite;

        public Sprite Sprite
        {
            get
            {
                return sprite;
            }
        }

        [SerializeField]
        private string scene;

        public string Scene
        {
            get
            {
                return scene;
            }
        }

        #endregion
    }
}

Here’s an example of a correct test mission definition in the Splash_Screen scene.

Network Management

You need to implement the NetworkManager class to manage player sessions and handle network events. NetworkManager implements the INetworkRunnerCallbacks interface, which gives you callbacks for events such as player connections and disconnections, gathering player input, session data updates, data transmission, and host migration. The class lets you start sessions for a single player or host and join multiplayer games as a Host or Client. It also includes a basic matchmaking mechanic.

We already covered session management in detail in a previous article of this series. If you need a refresher or want more details, check out the article Photon Fusion 2 – Sessions Management. In this article, we’ll focus on the basic methods for creating and joining sessions. The next section will cover the mechanics of reconnect.

NetworkManager is a singleton placed in the Splash_Screen scene. The application creates it at startup and manages all sessions throughout the app’s lifetime. You need to assign four key references in the Inspector.

Reference to sceneLoader – the controller from the previous chapter, responsible for scene loading.

Prefab networkRunnerPrefab – the core Photon Fusion 2 prefab for network communication. Since this demo includes physics, your prefab should have both NetworkRunner and RunnerSimulatePhysics3D components.

Prefab missionSettingsPrefab – synchronises mission data selected by the Host.

MissionSettings.cs

using Fusion;
using System;

namespace ProtoGDM.Networking
{
    public class MissionSettings : NetworkBehaviour
    {
        #region Events

        public static event Action<MissionSettings> OnMissionSettingsUpdated;

        #endregion Events

        #region Variables

        private ChangeDetector changeDetector;

        #endregion Variables

        #region Properties

        public static MissionSettings Instance
        {
            get;
            private set;
        }

        [Networked]
        public int MissionIndex
        {
            get;
            set;
        }

        [Networked]
        public int DifficultyIndex
        {
            get;
            set;
        }

        #endregion Properties

        #region Unity methods

        private void Awake()
        {
            if (Instance)
            {
                Destroy(gameObject);

                return;
            }

            Instance = this;

            DontDestroyOnLoad(gameObject);
        }

        #endregion Unity methods

        #region Public methods

        public override void Spawned()
        {
            changeDetector = GetChangeDetector(ChangeDetector.Source.SimulationState);

            if (Object.HasStateAuthority)
            {
                MissionIndex = 0;

                DifficultyIndex = 1;
            }
        }

        public float GetDifficultyFactor()
        {
            switch (DifficultyIndex)
            {
                case 0:
                    return 0.5f;
                case 1:
                    return 1f;
                case 2:
                    return 1.5f;
                default:
                    return 1f;
            }
        }

        public override void Render()
        {
            foreach (var change in changeDetector.DetectChanges(this))
            {
                switch (change)
                {
                    case nameof(MissionIndex):
                    case nameof(DifficultyIndex):
                        OnMissionSettingsChangedCallback(this);
                        break;
                }
            }
        }

        #endregion Public methods

        #region Private methods

        private void OnMissionSettingsChangedCallback(MissionSettings gameManager)
        {
            OnMissionSettingsUpdated?.Invoke(gameManager);
        }

        #endregion Private methods
    }
}

Prefab roomPlayerPrefab – represents each player in a session, synchronises player data, and supports the reconnect mechanic. You’ll learn more about RoomPlayer in later chapters.

This tutorial uses a Host-Client topology. One of the Clients acts as the Server and has authority over all other players. Players can create their own sessions, set a custom name, choose the number of players (2, 3, or 4), and protect the session with a password if needed.

Below you’ll find the full code for the NetworkManager class. The code is long, but understanding each method will help you write and modify your own multiplayer logic. In this example, you won’t see every callback from the INetworkRunnerCallbacks interface. The unused callbacks are grouped in a separate region.

NetworkManager.cs

using Fusion;
using Fusion.Photon.Realtime;
using Fusion.Sockets;
using ProtoGDM.ScenesManagement;
using ProtoGDM.Utilities;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace ProtoGDM.Networking
{
    public class NetworkManager : Singleton<NetworkManager>, INetworkRunnerCallbacks
    {
        #region Events

        public event Action<List<SessionInfo>> OnNetworkRunnerSessionListUpdated;

        public event Action<ShutdownReason> OnNetworkRunnerShutdown;

        #endregion Events

        #region Consts

        public const string SESSION_NAME_KEY = "sessionName";
        public const string SESSION_PASSWORD_REQUIRED_KEY = "sessionPasswordRequired";

        #endregion Consts

        #region Variables

        [SerializeField]
        private SceneLoader sceneLoader;

        [SerializeField]
        private NetworkRunner networkRunnerPrefab;

        [SerializeField]
        private MissionSettings missionSettingsPrefab;

        [SerializeField]
        private RoomPlayer roomPlayerPrefab;

        private MissionSettings missionSettings;

        private bool currentSessionPasswordRequired;

        private string currentSessionPassword;

        private Dictionary<string, RoomPlayer> roomPlayerMap;

        #endregion Variables

        #region Properties

        private NetworkRunner networkRunner;

        public NetworkRunner NetworkRunner
        {
            get
            {
                return networkRunner;
            }

            private set
            {
                networkRunner = value;
            }
        }

        [SerializeField]
        private GameMode gameMode;

        public GameMode GameMode
        {
            get
            {
                return gameMode;
            }

            private set
            {
                gameMode = value;
            }
        }

        #endregion

        #region Unity methods

        protected override void Awake()
        {
            base.Awake();

            roomPlayerMap = new Dictionary<string, RoomPlayer>();

            DontDestroyOnLoad(gameObject);
        }

        private void Start()
        {
            //RoomPlayer.RemovePlayerData();

            if (!RoomPlayer.LoadPlayerData())
            {
                RoomPlayer.CreatePlayerData("Player_" + UnityEngine.Random.Range(0, 1000), null);
            }
        }

        #endregion Unity methods

        #region Public methods

        #region INetworkRunnerCallbacks

        public void OnSessionListUpdated(NetworkRunner networkRunner, List<SessionInfo> sessionList)
        {
            OnNetworkRunnerSessionListUpdated?.Invoke(sessionList);
        }

        public void OnConnectRequest(NetworkRunner networkRunner, NetworkRunnerCallbackArgs.ConnectRequest request, byte[] token)
        {
            string password = string.Empty;

            if (token != null)
            {
                ConnectionToken connectionToken = ConnectionToken.FromBytes(token);

                if (connectionToken != null)
                {
                    password = connectionToken.password;

                    string reconnectGuid = connectionToken.reconnectGuid;

                    if (roomPlayerMap.ContainsKey(reconnectGuid))
                    {
                        RoomPlayer roomPlayer = roomPlayerMap[reconnectGuid];

                        if (roomPlayer == null)
                        {
                            roomPlayerMap.Remove(reconnectGuid);

                            request.Refuse();

                            return;
                        }
                    }
                }
            }

            if (currentSessionPasswordRequired)
            {
                if (currentSessionPassword.Equals(password))
                {
                    request.Accept();
                }
                else
                {
                    request.Refuse();
                }
            }
            else
            {
                request.Accept();
            }
        }

        public void OnPlayerJoined(NetworkRunner networkRunner, PlayerRef player)
        {
            if (networkRunner.CanSpawn)
            {
                byte[] playerConnectionToken = networkRunner.GetPlayerConnectionToken(player);

                ConnectionToken connectionToken = ConnectionToken.FromBytes(playerConnectionToken);

                string reconnectGuid = string.Empty;

                if (connectionToken != null)
                {
                    reconnectGuid = connectionToken.reconnectGuid;
                }

                if (!missionSettings)
                {
                    missionSettings = networkRunner.Spawn(missionSettingsPrefab, Vector3.zero, Quaternion.identity);
                }

                RoomPlayer roomPlayer = null;

                if (roomPlayerMap.TryGetValue(reconnectGuid, out roomPlayer) == false || roomPlayer == null)
                {
                    roomPlayer = networkRunner.Spawn(roomPlayerPrefab, Vector3.zero, Quaternion.identity, player, (networkRunner, networkObject) =>
                    {
                        networkObject.GetBehaviour<RoomPlayer>().ReconnectGuid = reconnectGuid;
                    });
                }

                if (connectionToken != null)
                {
                    roomPlayerMap[reconnectGuid] = roomPlayer;
                }

                roomPlayer.AssignInputAuthority(player);
                roomPlayer.IsDisconnected = false;
                roomPlayer.DisconnectTick = 0;

                networkRunner.SetPlayerObject(player, roomPlayer.Object);
            }
        }

        public void OnPlayerLeft(NetworkRunner networkRunner, PlayerRef player)
        {
            RoomPlayer roomPlayer = RoomPlayer.GetPlayer(player);

            if (roomPlayer != null)
            {
                roomPlayer.IsDisconnected = true;

                roomPlayer.DisconnectTick = networkRunner.Tick;
            }
        }

        public void OnInput(NetworkRunner networkRunner, NetworkInput networkInput)
        {
            NetworkInputData networkedInputData = new NetworkInputData();

            networkedInputData.acceleration = PlayerInput.GetAxis("Vertical");
            networkedInputData.braking = PlayerInput.GetKey(KeyCode.Space) ? 1f : 0f;
            networkedInputData.steering = PlayerInput.GetAxis("Horizontal");
            networkedInputData.shooting = PlayerInput.GetMouseButton(0);

            networkedInputData.networkButtons.Set(NetworkInputData.ButtonTypes.Reload, PlayerInput.GetKey(KeyCode.R));
            networkedInputData.networkButtons.Set(NetworkInputData.ButtonTypes.Reset, PlayerInput.GetKey(KeyCode.P));

            Ray ray = Camera.main.ScreenPointToRay(PlayerInput.MousePosition);

            Plane groundPlane = new Plane(Vector3.up, 0.5f * Vector3.up);

            if (groundPlane.Raycast(ray, out float rayDistance))
            {
                Vector3 targetPoint = ray.GetPoint(rayDistance);

                networkedInputData.targetPoint = targetPoint;
            }

            networkInput.Set(networkedInputData);
        }

        public void OnShutdown(NetworkRunner networkRunner, ShutdownReason shutdownReason)
        {
            if (SceneManager.GetActiveScene().buildIndex > SceneLoader.MAIN_MENU_SCENE)
            {
                sceneLoader.LoadScene(SceneLoader.MAIN_MENU_SCENE, true);
            }

            OnNetworkRunnerShutdown?.Invoke(shutdownReason);
        }

        public void OnDisconnectedFromServer(NetworkRunner networkRunner, NetDisconnectReason reason)
        {
            ShutdownSession();
        }

        #region NOT USED
        public void OnConnectedToServer(NetworkRunner networkRunner) { }
        public void OnObjectExitAOI(NetworkRunner networkRunner, NetworkObject obj, PlayerRef player) { }
        public void OnObjectEnterAOI(NetworkRunner networkRunner, NetworkObject obj, PlayerRef player) { }
        public void OnInputMissing(NetworkRunner networkRunner, PlayerRef player, NetworkInput input) { }
        public void OnConnectFailed(NetworkRunner networkRunner, NetAddress remoteAddress, NetConnectFailedReason reason) { }
        public void OnUserSimulationMessage(NetworkRunner networkRunner, SimulationMessagePtr message) { }
        public void OnCustomAuthenticationResponse(NetworkRunner runner, Dictionary<string, object> data) { }
        public void OnHostMigration(NetworkRunner networkRunner, HostMigrationToken hostMigrationToken) { }
        public void OnReliableDataProgress(NetworkRunner networkRunner, PlayerRef player, ReliableKey reliableKey, float progress) { }
        public void OnReliableDataReceived(NetworkRunner networkRunner, PlayerRef player, ReliableKey reliableKey, ArraySegment<byte> data) { }
        public void OnSceneLoadStart(NetworkRunner networkRunner) { }
        public void OnSceneLoadDone(NetworkRunner networkRunner) { }
        #endregion NOT USED

        #endregion INetworkRunnerCallbacks

        public async Task StartSingle(string sessionName, Action onSuccess, Action<string> onFailure)
        {
            GameMode = GameMode.Single;

            if (NetworkRunner == null)
            {
                CreateNetworkRunner();
            }

            currentSessionPasswordRequired = false;
            currentSessionPassword = null;

            Dictionary<string, SessionProperty> sessionProperties = new Dictionary<string, SessionProperty>
            {
                { SESSION_NAME_KEY, sessionName },
                { SESSION_PASSWORD_REQUIRED_KEY, currentSessionPasswordRequired },
            };

            ConnectionToken connectionToken = new ConnectionToken(null, SessionID.GuidString);

            StartGameArgs startGameArgs = new StartGameArgs()
            {
                GameMode = GameMode,
                PlayerCount = 1,
                SessionProperties = sessionProperties,
                SceneManager = sceneLoader,
                ConnectionToken = ConnectionToken.ToBytes(connectionToken)
            };

            StartGameResult result = await NetworkRunner.StartGame(startGameArgs);

            if (result.Ok)
            {
                Debug.Log($"StartSingle Mode {NetworkRunner.Mode} {NetworkRunner.IsServer} {NetworkRunner.IsClient}");

                onSuccess?.Invoke();
            }
            else
            {
                Debug.LogError($"StartHost Failure {result.ShutdownReason}");

                currentSessionPassword = string.Empty;

                onFailure?.Invoke(result.ShutdownReason.ToString());
            }
        }

        public async Task StartHost(string sessionName, string password, int maxPlayers, Action onSuccess, Action<string> onFailure)
        {
            GameMode = GameMode.Host;

            if (NetworkRunner == null)
            {
                CreateNetworkRunner();
            }

            currentSessionPasswordRequired = !string.IsNullOrEmpty(password);
            currentSessionPassword = password;

            Dictionary<string, SessionProperty> sessionProperties = new Dictionary<string, SessionProperty>
            {
                { SESSION_NAME_KEY, sessionName },
                { SESSION_PASSWORD_REQUIRED_KEY, currentSessionPasswordRequired },
            };

            var sceneRef = SceneRef.FromIndex(SceneManager.GetActiveScene().buildIndex);
            NetworkSceneInfo info = new NetworkSceneInfo();
            info.AddSceneRef(sceneRef, LoadSceneMode.Single);

            ConnectionToken connectionToken = new ConnectionToken(password, SessionID.GuidString);

            StartGameArgs startGameArgs = new StartGameArgs()
            {
                Scene = info,
                GameMode = GameMode,
                SessionName = sessionName,
                PlayerCount = maxPlayers,
                SessionProperties = sessionProperties,
                SceneManager = sceneLoader
            };

            StartGameResult result = await NetworkRunner.StartGame(startGameArgs);

            if (result.Ok)
            {
                Debug.Log($"StartHost Mode {NetworkRunner.Mode} {NetworkRunner.IsServer} {NetworkRunner.IsClient}");

                onSuccess?.Invoke();
            }
            else
            {
                Debug.LogError($"StartHost Failure {result.ShutdownReason}");

                currentSessionPassword = string.Empty;

                onFailure?.Invoke(result.ShutdownReason.ToString());
            }
        }

        public async Task JoinLobby(Action onSuccess, Action<string> onFailure)
        {
            if (NetworkRunner == null)
            {
                CreateNetworkRunner();
            }

            StartGameResult result = await NetworkRunner.JoinSessionLobby(SessionLobby.ClientServer);

            if (result.Ok)
            {
                // all ok
                onSuccess?.Invoke();
            }
            else
            {
                // log error
                Debug.LogError($"JoinLobby failure {result.ShutdownReason}");

                onFailure?.Invoke(result.ShutdownReason.ToString());
            }
        }

        public async Task JoinSession(string sessionName, string password, Action onSuccess, Action<string> onFailure)
        {
            GameMode = GameMode.Client;

            if (NetworkRunner == null)
            {
                CreateNetworkRunner();
            }

            var sceneRef = SceneRef.FromIndex(SceneManager.GetActiveScene().buildIndex);
            NetworkSceneInfo info = new NetworkSceneInfo();
            info.AddSceneRef(sceneRef, LoadSceneMode.Single);

            ConnectionToken connectionToken = new ConnectionToken(password, SessionID.GuidString);

            StartGameArgs startGameArgs = new StartGameArgs
            {
                Scene = info,
                GameMode = GameMode,
                SessionName = sessionName,
                SceneManager = sceneLoader,
                ConnectionToken = ConnectionToken.ToBytes(connectionToken)
            };

            StartGameResult result = await NetworkRunner.StartGame(startGameArgs);

            if (result.Ok)
            {
                Debug.Log($"JoinSession Mode {NetworkRunner.Mode} {NetworkRunner.IsServer} {NetworkRunner.IsClient}");

                PlayerPrefs.SetString("CURRENT_SESSION_NAME", sessionName);
                PlayerPrefs.SetString("CURRENT_CONNECTION_TOKEN", Convert.ToBase64String(ConnectionToken.ToBytes(connectionToken)));
                PlayerPrefs.Save();

                onSuccess?.Invoke();
            }
            else
            {
                Debug.LogError($"JoinSession Failure {result.ShutdownReason}");

                onFailure?.Invoke(result.ShutdownReason.ToString());
            }
        }

        public async Task StartMatchmake(string sessionName, int maxPlayers, Action onSuccess, Action<string> onFailure)
        {
            GameMode = GameMode.AutoHostOrClient;

            if (NetworkRunner == null)
            {
                CreateNetworkRunner();
            }

            currentSessionPasswordRequired = false;
            currentSessionPassword = string.Empty;

            Dictionary<string, SessionProperty> sessionProperties = new Dictionary<string, SessionProperty>
            {
                { SESSION_NAME_KEY, sessionName },
                { SESSION_PASSWORD_REQUIRED_KEY, currentSessionPasswordRequired },
            };

            ConnectionToken connectionToken = new ConnectionToken(string.Empty, SessionID.GuidString);

            StartGameArgs startGameArgs = new StartGameArgs
            {
                GameMode = GameMode,
                PlayerCount = maxPlayers,
                SessionProperties = sessionProperties,
                SceneManager = sceneLoader,
                MatchmakingMode = MatchmakingMode.RandomMatching,
                ConnectionToken = ConnectionToken.ToBytes(connectionToken)
            };

            StartGameResult result = await NetworkRunner.StartGame(startGameArgs);

            if (result.Ok)
            {
                Debug.Log($"JoinSessionMatchmake Mode {NetworkRunner.Mode} {NetworkRunner.IsServer} {NetworkRunner.IsClient}");

                onSuccess?.Invoke();
            }
            else
            {
                Debug.LogError($"JoinSessionMatchmake Failure {result.ShutdownReason}");

                onFailure?.Invoke(result.ShutdownReason.ToString());
            }
        }

        public void ShowSession()
        {
            if (!NetworkRunner.IsServer)
            {
                return;
            }

            NetworkRunner.SessionInfo.IsVisible = true;
        }

        public void HideSession()
        {
            if (!NetworkRunner.IsServer)
            {
                return;
            }

            NetworkRunner.SessionInfo.IsVisible = false;
        }

        public void ShutdownSession()
        {
            if (NetworkRunner != null)
            {
                NetworkRunner.Shutdown();
            }

            GameMode = 0;
        }

        #endregion Public methods

        #region Private methods

        private void CreateNetworkRunner()
        {
            NetworkRunner = Instantiate(networkRunnerPrefab);

            NetworkRunner.AddCallbacks(this);
        }

        #endregion Private methods
    }
}

Singleton.cs

using UnityEngine;

namespace ProtoGDM.Utilities
{
    public abstract class Singleton<T> : MonoBehaviour where T : Singleton<T>
    {
        [Header("Singleton")]

        [SerializeField]
        [Tooltip("Automatically sets this script as the instance")]
        private bool automaticallyAssignAsInstance = true;

        [SerializeField]
        [Tooltip("Debug this singleton")]
        private bool singletonDebug = false;

        private static T instance;

        public static T Instance
        {
            get
            {
                if (instance == null)
                {
                    Debug.LogError($"Inst doesn't exist!");
                    return null;
                }

                if (instance.singletonDebug)
                {
                    Debug.Log($"Retreiving singleton.");
                }

                return instance;
            }

            set
            {
                if (instance != null && instance.singletonDebug)
                {
                    Debug.Log($"Changing singleton instance to {instance?.GetInstanceID()}");
                }

                instance = value;

                if (instance != null && instance.singletonDebug)
                {
                    Debug.Log($"Changed singleton instance");
                }
            }
        }

        public static bool InstExists => (instance != null);

        protected virtual void Awake()
        {
            if (automaticallyAssignAsInstance)
            {
                Instance = (T)this;
            }
        }

        protected virtual void OnDestroy()
        {
            Instance = null;
        }
    }
}

NetworkManager works as a singleton. This approach makes implementation easier, but be mindful not to overuse global access. If you prefer, you can use explicit references instead of the singleton pattern.

The class exposes a NetworkRunner property. The whole application uses just one NetworkRunner to manage network communication, so NetworkManager serves as a central reference point for this component.

NetworkManager offers several key public methods:

StartSingle – Starts a single-player session. You still get all Fusion 2 features, but without any internet connection. This is great for small projects that share logic between single and multiplayer modes.

StartHost – Creates a new session as the Host. You set the session name, player limit, and password protection if needed. You join as the first player and act as the Host.

JoinLobby – Joins a Fusion 2 Lobby. A Lobby is tied to a specific region and lists all active sessions in that region.

JoinSession – Lets you join a session by name and password (if required). You join as a Client in the selected session.

ShowSession and HideSession – These methods control session visibility in the region’s Lobby. Use them as the Host to hide the session during gameplay or show it when waiting for players for the next round.

ShutdownSession – Shuts down the NetworkRunner and closes the network connection.

Network Objects

In this section, you’ll learn about the core networked objects that enable multiplayer gameplay. First, you’ll see how the RoomPlayer object represents each player who joins a session and gets ready for the game. Every player has a unique RoomPlayer instance that keeps their data synchronised across all peers.

After that, you’ll explore the main objects present in the gameplay scene. The MissionController class handles spawning player vehicles at the start of a mission and manages mission objectives and rewards. You’ll also discover how destructible elements work, starting with the base DestructibleObject class, followed by TurretWeaponController, VehicleController, and PlayerVehicleController.

Room Player

When a player joins a session as a Client, the Host triggers the OnConnectRequest callback. The Host decides in this method whether to let the player join the session. You’ll learn more about this method when we discuss reconnecting players later in the tutorial. If the Host accepts the join request, Fusion 2 assigns the player to the session and then calls the OnPlayerJoined callback. In this callback, the Host spawns a RoomPlayer object for the new player and gives them InputAuthority.

RoomPlayer stores and synchronises key player data, including the player’s name, current status (showing their current location), resources such as Coins and Titanium, the selected vehicle (VehiclePresetID), and the player’s ready status (IsReady).

You can also use RoomPlayer to save and load player data. In this demo, the system uses PlayerPrefs to store data locally. For real-world projects, you should replace this approach with a cloud-based service that securely saves data and protects against cheating.

RoomPlayer.cs

using Fusion;
using MemoryPack;
using ProtoGDM.Data;
using ProtoGDM.Data.Presets;
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace ProtoGDM.Networking
{
    public class RoomPlayer : NetworkBehaviour
    {
        #region Events

        public static event Action<RoomPlayer> OnPlayerJoined;
        public static event Action<RoomPlayer> OnPlayerLeft;

        #endregion Events

        #region Variables

        private const string PLAYER_DATA_KEY = "playerData";

        public static readonly List<RoomPlayer> RoomPlayers = new List<RoomPlayer>();

        public static RoomPlayer LocalRoomPlayer;

        public static PlayerData LocalPlayerData;

        public PlayerVehicleController PlayerVehicleController
        {
            get;
            set;
        }

        private ChangeDetector changeDetector;

        #endregion Variables

        #region Properties

        [Networked]
        public NetworkBool IsInitialized
        {
            get;
            set;
        }

        [Networked]
        public NetworkBool IsDisconnected
        {
            get;
            set;
        }

        [Networked]
        public NetworkString<_64> ReconnectGuid
        {
            get;
            set;
        }

        [Networked]
        public float DisconnectTick
        {
            get;
            set;
        }

        [Networked]
        public NetworkString<_32> Name
        {
            get;
            set;
        }

        [Networked]
        public int Coins
        {
            get;
            set;
        }

        [Networked]
        public int Titanium
        {
            get;
            set;
        }

        [Networked]
        public int VehiclePresetID
        {
            get;
            set;
        }

        [Networked]
        public NetworkString<_32> Status
        {
            get;
            set;
        }

        [Networked]
        public NetworkBool IsReady
        {
            get;
            set;
        }

        #endregion Properties

        #region Unity methods

        private void OnDestroy()
        {
            OnPlayerLeft?.Invoke(this);

            RoomPlayers.Remove(this);
        }

        public override void FixedUpdateNetwork()
        {
            if (IsDisconnected && Runner.IsServer)
            {
                float secondsDisconnected = (Runner.Tick - DisconnectTick) * Runner.DeltaTime;

                if (secondsDisconnected > 30f)
                {
                    if (PlayerVehicleController)
                    {
                        Runner.Despawn(PlayerVehicleController.Object);
                    }

                    Runner.Despawn(Object);
                }
            }
        }

        #endregion Unity methods

        #region Public methods

        #region RPC

        [Rpc(RpcSources.InputAuthority, RpcTargets.StateAuthority, HostMode = RpcHostMode.SourceIsHostPlayer)]
        public void RPC_ChangeIsInitialized(NetworkBool isInitialized, RpcInfo info = default)
        {
            IsInitialized = isInitialized;
        }

        [Rpc(RpcSources.InputAuthority, RpcTargets.StateAuthority)]
        public void RPC_SetPlayerName(NetworkString<_32> name, RpcInfo info = default)
        {
            Name = name;
        }

        [Rpc(RpcSources.InputAuthority, RpcTargets.StateAuthority)]
        public void RPC_SetPlayerStatus(NetworkString<_32> status, RpcInfo info = default)
        {
            Status = status;
        }

        [Rpc(RpcSources.InputAuthority, RpcTargets.StateAuthority)]
        public void RPC_ChangeCoins(int coins, RpcInfo info = default)
        {
            Coins = coins;
        }

        [Rpc(RpcSources.InputAuthority, RpcTargets.StateAuthority)]
        public void RPC_ChangeTitanium(int titanium, RpcInfo info = default)
        {
            Titanium = titanium;
        }

        [Rpc(RpcSources.InputAuthority, RpcTargets.StateAuthority)]
        public void RPC_ChangeVehiclePresetID(int vehiclePresetID, RpcInfo info = default)
        {
            VehiclePresetID = vehiclePresetID;
        }

        [Rpc(RpcSources.InputAuthority, RpcTargets.StateAuthority, HostMode = RpcHostMode.SourceIsHostPlayer)]
        public void RPC_ChangeIsReady(NetworkBool isReady, RpcInfo info = default)
        {
            IsReady = isReady;
        }

        #endregion RPC

        public override void Spawned()
        {
            changeDetector = GetChangeDetector(ChangeDetector.Source.SimulationState);

            if (Object.HasInputAuthority)
            {
                LocalRoomPlayer = this;

                if (!IsInitialized && LocalPlayerData != null)
                {
                    LocalRoomPlayer.RPC_SetPlayerName(LocalPlayerData.name);
                    LocalRoomPlayer.RPC_SetPlayerStatus("Lobby");
                    LocalRoomPlayer.RPC_ChangeCoins(LocalPlayerData.coins);
                    LocalRoomPlayer.RPC_ChangeTitanium(LocalPlayerData.titanium);

                    if (LocalPlayerData.vehicle != null)
                    {
                        LocalRoomPlayer.RPC_ChangeVehiclePresetID(LocalPlayerData.vehicle.presetId);

                        if (Runner.GameMode == GameMode.Single)
                        {
                            LocalRoomPlayer.RPC_ChangeIsReady(true);
                        }
                    }
                    else
                    {
                        LocalRoomPlayer.RPC_ChangeVehiclePresetID(-1);
                        LocalRoomPlayer.RPC_ChangeIsReady(false);
                    }

                    LocalRoomPlayer.RPC_ChangeIsInitialized(true);
                }
            }

            RoomPlayers.Add(this);

            OnPlayerJoined?.Invoke(this);

            DontDestroyOnLoad(gameObject);
        }

        public override void Render()
        {
            foreach (var change in changeDetector.DetectChanges(this))
            {
                switch (change)
                {
                    case nameof(Name):
                    case nameof(Coins):
                    case nameof(Titanium):
                    case nameof(VehiclePresetID):
                    case nameof(IsReady):

                        if (Object.HasInputAuthority)
                        {
                            LocalPlayerData.name = Name.ToString();
                            LocalPlayerData.coins = Coins;
                            LocalPlayerData.titanium = Titanium;

                            SavePlayerData();
                        }

                        break;
                }
            }
        }

        public void AssignInputAuthority(PlayerRef playerRef)
        {
            Object.AssignInputAuthority(playerRef);

            if (PlayerVehicleController)
            {
                PlayerVehicleController.AssignInputAuthority(playerRef);
            }
        }

        public static RoomPlayer GetPlayer(PlayerRef playerRef)
        {
            return RoomPlayers.FirstOrDefault(x => x.Object.InputAuthority == playerRef);
        }

        public static void RemovePlayer(NetworkRunner networkRunner, PlayerRef playerRef)
        {
            RoomPlayer roomPlayer = GetPlayer(playerRef);

            if (roomPlayer != null)
            {
                RoomPlayers.Remove(roomPlayer);

                networkRunner.Despawn(roomPlayer.Object);
            }
        }

        public static bool CreatePlayerData(string name, VehicleSO vehicleSO)
        {
            VehicleData vehicleData = null;

            if (vehicleSO != null)
            {
                vehicleData = new VehicleData(vehicleSO);
            }

            LocalPlayerData = new PlayerData(name, 0, 0, vehicleData);

            LocalPlayerData.AddToInventory(new VehicleData(PresetsManager.Instance.GetVehicleById(0)));
            LocalPlayerData.AddToInventory(new VehicleData(PresetsManager.Instance.GetVehicleById(1)));

            return SavePlayerData();
        }

        public static bool SavePlayerData()
        {
            if (LocalPlayerData != null)
            {
                byte[] data = MemoryPackSerializer.Serialize(LocalPlayerData);

                string base64Data = Convert.ToBase64String(data);

                PlayerPrefs.SetString(PLAYER_DATA_KEY, base64Data);

                PlayerPrefs.Save();

                return true;
            }
            else
            {
                return false;
            }
        }

        public static bool LoadPlayerData()
        {
            if (PlayerPrefs.HasKey(PLAYER_DATA_KEY))
            {
                string base64Data = PlayerPrefs.GetString(PLAYER_DATA_KEY);

                byte[] data = Convert.FromBase64String(base64Data);

                LocalPlayerData = MemoryPackSerializer.Deserialize<PlayerData>(data);

                return LocalPlayerData != null;
            }
            else
            {
                return false;
            }
        }

        public static bool RemovePlayerData()
        {
            if (PlayerPrefs.HasKey(PLAYER_DATA_KEY))
            {
                PlayerPrefs.DeleteKey(PLAYER_DATA_KEY);

                return true;
            }
            else
            {
                return false;
            }
        }

        #endregion Public methods
    }
}

Mission Controller

MissionController manages victory conditions in each mission. The class also handles creating and destroying player vehicles. For demo purposes, it provides basic UI control during missions, but in a real project, you should move this logic to a dedicated UI controller. In this demo, victory conditions are a simple list of objects that players must destroy to win. You can expand or customise these conditions for each mission as your game evolves.

Pay special attention to the SpawnPlayerVehicle method. This method selects a predefined spawn point using the player’s index, then chooses the right vehicle prefab using the VehiclePresetID from RoomPlayer. It creates the vehicle instance in the scene and assigns it to the roomPlayer.PlayerVehicleController. This reference is important for implementing reconnect features later on.

MissionController listens for events when a player’s vehicle is destroyed. The class tracks the number of active vehicles and displays a message when the last player is eliminated. The DestructibleObject_OnDestructibleDestroy callback checks if all mission targets are destroyed. If so, the Host sees a message about mission completion and rewards, and has the option to return everyone to the Session Lobby. Clients see a similar message about mission completion and rewards, but can only leave the session. Only the Host can bring the whole team back to the Lobby. Individual Clients can quit the session if they choose.

MissionController.cs

using Fusion;
using ProtoGDM.Data;
using ProtoGDM.Networking;
using ProtoGDM.ScenesManagement;
using ProtoGDM.UI;
using ProtoGDM.Utilities;
using System;
using System.Collections.Generic;
using UnityEngine;

namespace ProtoGDM
{
    public class MissionController : NetworkBehaviour
    {
        #region Variables

        [Tooltip("Check in Inspector when scene is not ready and is during development.")]
        [SerializeField]
        private bool notReady = false;

        [SerializeField]
        private List<Transform> spawnPoints;

        private Dictionary<RoomPlayer, (PlayerVehicleController, NetworkObject)> players = new Dictionary<RoomPlayer, (PlayerVehicleController, NetworkObject)>();

        [Header("Objectives")]

        [SerializeField]
        private List<DestructibleObject> objectsToDestroy;

        [Header("Rewards")]

        [SerializeField]
        private int coins;

        [SerializeField]
        private int titanium;

        #endregion Variables

        #region Properties

        public static MissionController Instance
        {
            get;
            private set;
        }

        public bool ObjectivesFulfilled
        {
            get
            {
                return objectsToDestroy.Count == 0;
            }
        }

        #endregion Properties

        #region Unity methods 

        private void Awake()
        {
            if (Instance)
            {
                Destroy(gameObject);

                return;
            }

            Instance = this;
        }

        private void Update()
        {
            if (PlayerInput.Enabled && Input.GetKeyUp(KeyCode.Escape))
            {
                PlayerInput.Enabled = false;

                PopupsUIManager.Instance.ShowDecisionPopup(
                    "Surrender?",
                    "Yes",
                    () =>
                    {
                        PopupsUIManager.Instance.HideLastPopup();

                        PopupsUIManager.Instance.ShowInfoPopup(
                            "Mission Failed!",
                            "Ok",
                            () =>
                            {
                                PopupsUIManager.Instance.HideLastPopup();

                                EndMission();
                            });
                    },
                    "No",
                    () =>
                    {
                        PlayerInput.Enabled = true;

                        PopupsUIManager.Instance.HideLastPopup();
                    });
            }
        }

        private void OnDestroy()
        {
            if (notReady)
            {
                return;
            }

            Instance = null;
        }

        #endregion Unity methods

        #region Public methods

        public override void Spawned()
        {
            RegisterObjectives();

            PlayerInput.Enabled = true;
        }

        public override void Despawned(NetworkRunner runner, bool hasState)
        {
            UnregisterObjectives();

            PlayerInput.Enabled = false;
        }

        public void SpawnPlayerVehicle(NetworkRunner networkRunner, RoomPlayer roomPlayer)
        {
            if (!networkRunner)
            {
                throw new NullReferenceException("NetworkRunner is null!");
            }

            if (!roomPlayer)
            {
                throw new NullReferenceException("RoomPlayer is null!");
            }

            int index = RoomPlayer.RoomPlayers.IndexOf(roomPlayer);

            if (index >= 0 && index < spawnPoints.Count)
            {
                Transform spawnPointTransform = spawnPoints[index];

                NetworkObject vehicleNetworkObject = networkRunner.Spawn(PresetsManager.Instance.GetVehicleById(roomPlayer.VehiclePresetID).Prefab, spawnPointTransform.position, spawnPointTransform.rotation, roomPlayer.Object.InputAuthority);

                PlayerVehicleController playerVehicleController = vehicleNetworkObject.GetComponent<PlayerVehicleController>();

                if (playerVehicleController)
                {
                    roomPlayer.PlayerVehicleController = playerVehicleController;

                    playerVehicleController.OnDestructibleDestroy += PlayerVehicleController_OnDestructibleDestroy;

                    if (!players.ContainsKey(roomPlayer))
                    {
                        players.Add(roomPlayer, (playerVehicleController, vehicleNetworkObject));
                    }
                }
            }
        }

        public void DespawnPlayerVehicle(NetworkRunner networkRunner, RoomPlayer roomPlayer)
        {
            if (players.ContainsKey(roomPlayer))
            {
                PlayerVehicleController playerVehicleController = players[roomPlayer].Item1;

                NetworkObject networkObject = players[roomPlayer].Item2;

                if (playerVehicleController)
                {
                    playerVehicleController.OnDestructibleDestroy -= PlayerVehicleController_OnDestructibleDestroy;
                }

                players.Remove(roomPlayer);

                networkRunner.Despawn(networkObject);
            }
        }

        public void EndMission()
        {
            SceneLoader sceneLoader = FindObjectOfType<SceneLoader>();

            if (sceneLoader.Runner)
            {
                if (HasStateAuthority)
                {
                    sceneLoader.LoadScene(SceneLoader.MAIN_MENU_SCENE);
                }
                else
                {
                    NetworkManager.Instance.ShutdownSession();
                }
            }
            else
            {
                sceneLoader.LoadScene(SceneLoader.MAIN_MENU_SCENE);
            }
        }

        #endregion Public methods

        #region Private methods

        #region Event callbacks

        private void PlayerVehicleController_OnDestructibleDestroy(DestructibleObject destructibleObject)
        {
            RoomPlayer roomPlayer = null;

            int livingPlayers = 0;

            foreach (var item in players)
            {
                if (item.Value.Item1)
                {
                    if (item.Value.Item1 == destructibleObject)
                    {
                        roomPlayer = item.Key;
                    }
                    else
                    {
                        livingPlayers++;
                    }
                }
            }

            players[roomPlayer] = (null, null);

            if (livingPlayers == 0)
            {
                UnregisterObjectives();

                PlayerInput.Enabled = false;

                PopupsUIManager.Instance.ShowInfoPopup(
                "Mission Failed!",
                "Ok",
                () =>
                {
                    PopupsUIManager.Instance.HideLastPopup();

                    PlayerInput.Enabled = true;

                    EndMission();
                });
            }
        }

        private void DestructibleObject_OnDestructibleDestroy(DestructibleObject destructibleObject)
        {
            if (destructibleObject != null)
            {
                if (objectsToDestroy.Contains(destructibleObject))
                {
                    objectsToDestroy.Remove(destructibleObject);
                }

                if (ObjectivesFulfilled)
                {
                    UnregisterObjectives();

                    PlayerInput.Enabled = false;

                    ClaimRewards();

                    if (HasStateAuthority)
                    {
                        PopupsUIManager.Instance.ShowRewardsPopup(
                        "Mission accomplished successfully!",
                        "Go to Lobby",
                        () =>
                        {
                            PopupsUIManager.Instance.HideLastPopup();

                            PlayerInput.Enabled = true;

                            EndMission();
                        });
                    }
                    else
                    {
                        PopupsUIManager.Instance.ShowRewardsPopup(
                        "Mission accomplished successfully! Please wait for host action or exit session.",
                        "Exit Session",
                        () =>
                        {
                            PopupsUIManager.Instance.HideLastPopup();

                            PlayerInput.Enabled = true;

                            EndMission();
                        });
                    }
                }
            }
        }

        #endregion Event callbacks

        private void RegisterObjectives()
        {
            for (int i = 0; i < objectsToDestroy.Count; i++)
            {
                DestructibleObject destructibleObject = objectsToDestroy[i];

                if (destructibleObject != null)
                {
                    destructibleObject.OnDestructibleDestroy += DestructibleObject_OnDestructibleDestroy;
                }
            }
        }

        private void UnregisterObjectives()
        {
            for (int i = 0; i < objectsToDestroy.Count; i++)
            {
                DestructibleObject destructibleObject = objectsToDestroy[i];

                if (destructibleObject != null)
                {
                    destructibleObject.OnDestructibleDestroy -= DestructibleObject_OnDestructibleDestroy;
                }
            }
        }

        private void ClaimRewards()
        {
            RoomPlayer.LocalPlayerData.coins += coins;
            RoomPlayer.LocalPlayerData.titanium += titanium;
        }

        #endregion Private methods
    }
}

Destructible

The DestructibleObject class handles all networked objects that can take damage and be destroyed during missions. It defines network-synced properties like CurrentHP, MaxHP, Regeneration, and Armor to set each object’s stats. The class uses OnChangedRender to react immediately whenever a property changes. For example, you can update the UI when HP changes or despawn the object when its HP reaches zero.

DestructibleObject acts as the base class for all destructible objects. To keep things simple in the tutorial demo, it also manages UI elements, such as health bars attached above player vehicles. The class automatically updates the UI every time the HP value changes.

DestructibleObject.cs

using Fusion;
using ProtoGDM.Networking;
using ProtoGDM.UI;
using System;
using UnityEngine;

namespace ProtoGDM
{
    public class DestructibleObject : NetworkBehaviour
    {
        #region Events

        public event Action<float> OnCurrentHPChange;

        public event Action<float> OnMaxHPChange;

        public event Action<float> OnCurrentRegenerationChange;

        public event Action<float> OnCurrentArmorChange;

        public event Action<DestructibleObject> OnDestructibleDestroy;

        #endregion Events

        #region Variables

        [SerializeField]
        protected UnitWorldUI unitWorldUI;

        #endregion Variables

        #region Properties

        [Networked, OnChangedRender(nameof(CurrentHPChanged))]
        public float CurrentHP
        {
            get;
            set;
        }

        [Networked, OnChangedRender(nameof(MaxHPChanged))]
        public float MaxHP
        {
            get;
            set;
        }

        [Networked, OnChangedRender(nameof(RegenerationChanged))]
        public float Regeneration
        {
            get;
            set;
        }

        [Networked, OnChangedRender(nameof(ArmorChanged))]
        public int Armor
        {
            get;
            set;
        }

        #endregion Properties

        #region Unity methods

        protected virtual void OnDestroy()
        {
            if (unitWorldUI)
            {
                unitWorldUI.UnregisterEvents(this);

                Destroy(unitWorldUI.gameObject);
            }
        }

        #endregion Unity methods

        #region Photon methods

        public override void FixedUpdateNetwork()
        {
            if (!HasStateAuthority)
            {
                return;
            }

            if (CurrentHP > 0f && Regeneration > 0f)
            {
                HandleRegeneration(Runner.DeltaTime);
            }
        }

        public override void Spawned()
        {
            if (!HasStateAuthority)
            {
                Runner.SetIsSimulated(Object, false);
            }

            if (unitWorldUI)
            {
                string name = gameObject.name;

                RoomPlayer roomPlayer = RoomPlayer.GetPlayer(Object.InputAuthority);

                if (roomPlayer != null && this is PlayerVehicleController)
                {
                    name = roomPlayer.Name.ToString();
                }

                unitWorldUI.RegisterEvents(this, name);
            }
        }

        public override void Despawned(NetworkRunner runner, bool hasState)
        {
            if (CurrentHP == 0f)
            {
                OnDestructibleDestroy?.Invoke(this);
            }

            if (unitWorldUI)
            {
                unitWorldUI.UnregisterEvents(this);
            }
        }

        #endregion Photon methods

        #region Public methods

        public void SetCurrentHP(float hp)
        {
            if (hp > MaxHP)
            {
                hp = MaxHP;
            }

            if (hp < 0f)
            {
                hp = 0f;
            }

            if (hp != CurrentHP)
            {
                CurrentHP = hp;
            }
        }

        public void SetMaxHP(float hp)
        {
            if (hp != MaxHP)
            {
                MaxHP = hp;

                if (MaxHP < CurrentHP)
                {
                    SetCurrentHP(MaxHP);
                }
            }
        }

        public void TakeDamage(float damage)
        {
            damage -= Armor;

            if (damage < 0)
            {
                damage = 0;
            }

            SetCurrentHP(CurrentHP - damage);
        }

        #endregion Public methods

        #region Protected methods

        protected virtual void HandleRegeneration(float deltaTime)
        {
            if (CurrentHP < MaxHP)
            {
                SetCurrentHP(CurrentHP + Regeneration * deltaTime);
            }
        }

        #endregion Protected methods

        #region Private methods

        private void CurrentHPChanged(NetworkBehaviourBuffer previous)
        {
            float prevValue = GetPropertyReader<float>(nameof(CurrentHP)).Read(previous);

            if (HasStateAuthority)
            {
                if (CurrentHP == 0f)
                {
                    NetworkManager.Instance.NetworkRunner.Despawn(Object);
                }
            }

            OnCurrentHPChange?.Invoke(CurrentHP);
        }

        private void MaxHPChanged()
        {
            OnMaxHPChange?.Invoke(MaxHP);
        }

        private void RegenerationChanged()
        {
            OnCurrentRegenerationChange?.Invoke(Regeneration);
        }

        private void ArmorChanged()
        {
            OnCurrentArmorChange?.Invoke(Armor);
        }

        #endregion Private methods
    }
}

Player Vehicle

The player vehicle in this demo uses free assets from the Unity Asset Store (link). It moves with real physics, relying on Rigidbody and Wheel Colliders. The VehicleController class provides the core driving logic for all vehicles. Each vehicle also features a mounted weapon that you control with the mouse. You’ll find more about the weapon controller later in this article.

From the networking side, the vehicle uses standard Photon Fusion 2 components. The main vehicle object, Sport Car 1, includes a NetworkObject, which enables networking. NetworkRigidbody3D synchronises all Rigidbody and physics data. The Player component handles player input. PlayerVehicleController extends VehicleController, adding the following camera and letting you control the car with your input.

The prefab’s Wheels section splits into Meshes and Colliders. Meshes show the visual rotation and turning of each wheel. NetworkTransform components replicate their movement across the network.

In this demo, only the Host calculates physics. The Host computes wheel movement and sends the result to the Clients. Clients do not run any local wheel physics; they just display the networked position and rotation for each wheel.

VehicleController.cs

using Fusion;
using Fusion.Addons.Physics;
using UnityEngine;

namespace ProtoGDM
{
    public class VehicleController : DestructibleObject
    {
        #region Variables

        [Header("Configuration")]

        [SerializeField]
        private NetworkRigidbody3D networkRigidbody3D;

        [SerializeField]
        private WheelCollider frontLeftWheelCollider;

        [SerializeField]
        private WheelCollider frontRightWheelCollider;

        [SerializeField]
        private WheelCollider rearLeftWheelCollider;

        [SerializeField]
        private WheelCollider rearRightWheelCollider;

        [SerializeField]
        private Transform frontLeftTransform;

        [SerializeField]
        private Transform frontRightTransform;

        [SerializeField]
        private Transform rearLeftTransform;

        [SerializeField]
        private Transform rearRightTransform;

        [Header("Settings")]

        [SerializeField]
        private DriveTypes driveType = DriveTypes.FWD;

        [SerializeField]
        private bool frontSteering = true;

        [SerializeField]
        private bool rearSteering = false;

        [SerializeField]
        private float rearSteeringFactor = 0.15f;

        [SerializeField]
        protected float maxAccelerationForce = 500f;

        [SerializeField]
        protected float maxBreakingForce = 500f;

        [SerializeField]
        protected float maxSteerAngle = 20f;

        [SerializeField]
        protected float minSteerAngle = 20f;

        [SerializeField]
        protected Vector3 centerOfMass;

        #endregion Variables

        #region Properties

        [SerializeField]
        private WeaponController weaponController;

        public WeaponController WeaponController
        {
            get
            {
                return weaponController;
            }

            set
            {
                weaponController = value;
            }
        }

        [SerializeField]
        private Collider hitCollider;

        public Collider HitCollider
        {
            get
            {
                return hitCollider;
            }
        }

        #endregion Properties

        #region Unity methods

        protected virtual void Start()
        {
            Rigidbody rigidbody = GetComponent<Rigidbody>();

            if (rigidbody)
            {
                rigidbody.automaticCenterOfMass = false;

                rigidbody.centerOfMass = centerOfMass;
            }
        }

        #endregion Unity methods

        #region Public methods

        public override void FixedUpdateNetwork()
        {
            base.FixedUpdateNetwork();

            if (!HasStateAuthority)
            {
                return;
            }

            AnimateWheel(frontLeftWheelCollider, frontLeftTransform);
            AnimateWheel(frontRightWheelCollider, frontRightTransform);

            AnimateWheel(rearLeftWheelCollider, rearLeftTransform);
            AnimateWheel(rearRightWheelCollider, rearRightTransform);
        }

        public void AssignInputAuthority(PlayerRef playerRef)
        {
            Object.AssignInputAuthority(playerRef);

            if (WeaponController)
            {
                WeaponController.Object.AssignInputAuthority(playerRef);
            }
        }

        public virtual void HandleAcceleration(float value)
        {
            switch (driveType)
            {
                case DriveTypes.FWD:

                    frontLeftWheelCollider.motorTorque = value;
                    frontRightWheelCollider.motorTorque = value;

                    break;
                case DriveTypes.RWD:

                    rearLeftWheelCollider.motorTorque = value;
                    rearRightWheelCollider.motorTorque = value;

                    break;
                case DriveTypes.AWD:

                    frontLeftWheelCollider.motorTorque = value;
                    frontRightWheelCollider.motorTorque = value;
                    rearLeftWheelCollider.motorTorque = value;
                    rearRightWheelCollider.motorTorque = value;

                    break;
            }
        }

        public virtual void HandleBraking(float value)
        {
            frontLeftWheelCollider.brakeTorque = value;
            frontRightWheelCollider.brakeTorque = value;
            rearLeftWheelCollider.brakeTorque = value;
            rearRightWheelCollider.brakeTorque = value;
        }

        public virtual void HandleSteering(float value)
        {
            if (frontSteering)
            {
                frontLeftWheelCollider.steerAngle = value;
                frontRightWheelCollider.steerAngle = value;
            }

            if (rearSteering)
            {
                rearLeftWheelCollider.steerAngle = -value * rearSteeringFactor;
                rearRightWheelCollider.steerAngle = -value * rearSteeringFactor;
            }
        }

        #endregion Public methods

        #region Private methods

        private void AnimateWheel(WheelCollider wheelCollider, Transform transform)
        {
            Vector3 position;
            Quaternion quaternion;

            wheelCollider.GetWorldPose(out position, out quaternion);

            transform.position = position;
            transform.rotation = quaternion;
        }

        #endregion Private methods
    }
}

PlayerVehicleController.cs

using Fusion;
using ProtoGDM.CameraManagement;
using ProtoGDM.UI;

namespace ProtoGDM
{
    public class PlayerVehicleController : VehicleController
    {
        public override void Spawned()
        {
            base.Spawned();

            CamerasManager.Instance.AddTarget(this);

            if (HasInputAuthority)
            {
                CamerasManager.Instance.SetFollow(this);

                GameplayUIManager.Instance.RegisterVehicleControllerEvents(this);
            }
        }

        public override void Despawned(NetworkRunner runner, bool hasState)
        {
            base.Despawned(runner, hasState);

            if (CamerasManager.InstExists)
            {
                CamerasManager.Instance.RemoveTarget(this);
            }

            if (HasInputAuthority)
            {
                if (CamerasManager.InstExists)
                {
                    CamerasManager.Instance.SetFollow(null);

                    CamerasManager.Instance.SetCameraMode(CamerasManager.CameraModeTypes.Free);
                }

                if (GameplayUIManager.InstExists)
                {
                    GameplayUIManager.Instance.UnregisterVehicleControllersEvents(this);
                }
            }
        }

        public override void HandleAcceleration(float value)
        {
            float finalAcceleration = maxAccelerationForce * value;

            base.HandleAcceleration(finalAcceleration);
        }

        public override void HandleBraking(float value)
        {
            float finalBraking = maxBreakingForce * value;

            base.HandleBraking(finalBraking);
        }

        public override void HandleSteering(float value)
        {
            float finalSteering = maxSteerAngle * value;

            base.HandleSteering(finalSteering);
        }
    }
}

Player.cs

using Fusion;
using ProtoGDM.UI;
using UnityEngine;

namespace ProtoGDM.Networking
{
    public class Player : NetworkBehaviour
    {
        #region Variables

        [SerializeField]
        private PlayerVehicleController playerVehicleController;

        [Networked]
        public NetworkButtons NetworkButtonsPrevious
        {
            get;
            set;
        }

        #endregion Variables

        #region Photon methods

        public override void FixedUpdateNetwork()
        {
            if (!HasStateAuthority)
            {
                return;
            }

            if (playerVehicleController)
            {
                if (GetInput(out NetworkInputData input))
                {
                    // Acceleration
                    playerVehicleController.HandleAcceleration(input.acceleration);

                    // Braking
                    playerVehicleController.HandleBraking(input.braking);

                    // Steering
                    playerVehicleController.HandleSteering(input.steering);

                    // Weapon
                    var pressed = input.networkButtons.GetPressed(NetworkButtonsPrevious);

                    NetworkButtonsPrevious = input.networkButtons;

                    // Shooting
                    if (playerVehicleController.WeaponController)
                    {
                        playerVehicleController.WeaponController.HandleWeaponAimingWorldPoint(input.targetPoint);

                        playerVehicleController.WeaponController.HandleWeaponShooting(Runner, input.shooting);

                        if (pressed.IsSet(NetworkInputData.ButtonTypes.Reload))
                        {
                            playerVehicleController.WeaponController.Reload();
                        }
                    }
                }
            }
        }

        public override void Spawned()
        {
            if (HasInputAuthority)
            {
                GameplayUIManager.Instance.ShowGameplayInfo();
                GameplayUIManager.Instance.HideFreeCameraInfo();
            }
        }

        public override void Despawned(NetworkRunner runner, bool hasState)
        {
            if (HasInputAuthority)
            {
                if (GameplayUIManager.InstExists)
                {
                    GameplayUIManager.Instance.HideGameplayInfo();
                    GameplayUIManager.Instance.ShowFreeCameraInfo();
                }
            }
        }

        #endregion Photon methods
    }
}

Now let’s talk about the vehicle’s weapon. The weapon uses its own prefab and acts as an independent networked object, which you nest in the vehicle’s hierarchy. Correctly replicating these nested objects is essential for multiplayer games – review this process in the previous article if you need a refresher (link).

The roof-mounted weapon uses the WeaponController component. This component acts as a networked object with a state. It controls all fired projectiles and maintains a collection of projectiles currently flying toward their targets. Each projectile has a lifetime, a flight speed, and its own visual prefab. Unlike vehicles and weapons, each projectile exists only locally – it is not a networked object. Only the local player sees its visuals. The weapon keeps a list of projectiles and simulates their state on the Host, which owns StateAuthority. The Host then replicates this simulation to all Clients. Both Host and Clients use the synchronised state to visualise the projectiles with the same prefabs.

The base class NetworkBehaviourWithState<T> simplifies synchronisation. It stores all networked properties in a dedicated structure, NetworkState. Here, NetworkState holds a NetworkArray<ShotState>, which describes all active projectiles. Each ShotState implements ISparseState, allowing local prediction (extrapolation) of projectile paths without sending every update over the network.

This approach perfectly separates the visual and logical layers. Only the Host, which has StateAuthority, runs gameplay logic such as collision detection, damage calculation, and projectile destruction. The BulletProcessor method, running in FixedUpdateNetwork(), handles this logic on the Host. Clients do not run logic or have authority over projectiles. Instead, they visualise the state they receive by rendering projectiles with their local prefabs. The Projectile class, which implements ISparseVisual, handles this rendering.

SparseCollection connects logic to visuals. It links ShotState data with Projectile prefabs and manages their lifecycle, updates, and synchronisation. This approach allows you to create and synchronise hundreds of projectiles efficiently, using very little network bandwidth. Even better, you can completely decouple visuals from logic. For example, you can run the game in headless mode without any visuals, or add advanced effects like muzzle flashes and hit particles – none of this affects the game logic or network synchronisation.

WeaponController.cs

using Fusion;
using FusionHelpers;
using ProtoGDM.Networking;
using System;
using UnityEngine;

namespace ProtoGDM
{
    public abstract class WeaponController : NetworkBehaviourWithState<NetworkState>
    {
        [Networked]
        public override ref NetworkState State => ref MakeRef<NetworkState>();

        #region Events

        public event Action<int> OnCurrentAmmoChange;

        public event Action<int> OnMaxAmmoChange;

        public event Action<float> OnCooldownStart;

        public event Action OnCooldownComplete;

        public event Action<float> OnCooldownChange;

        public event Action<float> OnReloadStart;

        public event Action OnReloadComplete;

        public event Action<float> OnReloadChange;

        #endregion Events

        #region Variables

        [Header("Weapon Configuration")]

        [SerializeField]
        protected Transform baseTransform;

        [SerializeField]
        protected Projectile projectilePrefab;

        [SerializeField]
        protected float damageFactor = 1f;

        protected SparseCollection<ShotState, Projectile> bullets;

        protected float cooldownTime;

        protected float reloadTime;

        #endregion Variables

        #region Properties

        public bool IsReady
        {
            get
            {
                return !IsReloading && !IsCooldown && CurrentAmmo > 0;
            }
        }

        [Networked, OnChangedRender(nameof(IsReloadingChanged))]
        public bool IsReloading
        {
            get;
            set;
        }

        [Networked, OnChangedRender(nameof(ReloadProgressChanged))]
        public float ReloadProgress
        {
            get;
            set;
        }

        [Networked, OnChangedRender(nameof(IsCooldownChanged))]
        public bool IsCooldown
        {
            get;
            set;
        }

        [Networked, OnChangedRender(nameof(CooldownProgressChanged))]
        public float CooldownProgress
        {
            get;
            set;
        }

        [Networked, OnChangedRender(nameof(CurrentAmmoChanged))]
        public int CurrentAmmo
        {
            get;
            set;
        }

        [Networked, OnChangedRender(nameof(MaxAmmoChanged))]
        public int MaxAmmo
        {
            get;
            set;
        }

        [SerializeField]
        private float reloadInterval = 1f;

        public float ReloadInterval
        {
            get
            {
                return reloadInterval;
            }

            protected set
            {
                if (reloadInterval != value)
                {
                    reloadInterval = value;
                }
            }
        }

        [SerializeField]
        private float fireInterval = 1f;

        public float FireInterval
        {
            get
            {
                return fireInterval;
            }

            protected set
            {
                if (fireInterval != value)
                {
                    fireInterval = value;
                }
            }
        }

        [SerializeField]
        private bool autoReload = true;

        public bool AutoReload
        {
            get
            {
                return autoReload;
            }

            protected set
            {
                if (autoReload != value)
                {
                    autoReload = value;
                }
            }
        }

        #endregion Properties

        #region Abstract methods

        public abstract void HandleWeaponAimingWorldPoint(Vector3 target);

        public abstract void HandleWeaponShooting(NetworkRunner networkRunner, bool input);

        #endregion Abstract methods

        #region Public methods

        public override void Spawned()
        {
            CurrentAmmo = MaxAmmo;

            bullets = new SparseCollection<ShotState, Projectile>(State.bulletStates, projectilePrefab);
        }

        public override void Despawned(NetworkRunner runner, bool hasState)
        {
            if (bullets != null)
            {
                bullets.Clear();
            }
        }

        public override void FixedUpdateNetwork()
        {
            if (!HasStateAuthority)
            {
                return;
            }

            if (bullets != null)
            {
                bullets.Process(this, BulletProcessor);
            }

            if (IsReloading)
            {
                reloadTime -= Runner.DeltaTime;

                if (reloadTime < 0f)
                {
                    reloadTime = 0f;
                }

                ReloadProgress = 1f - reloadTime / ReloadInterval;

                if (ReloadProgress == 1f)
                {
                    CurrentAmmo = MaxAmmo;

                    IsReloading = false;
                }
            }

            if (IsCooldown)
            {
                cooldownTime -= Runner.DeltaTime;

                if (cooldownTime < 0f)
                {
                    cooldownTime = 0f;
                }

                CooldownProgress = 1f - cooldownTime / FireInterval;

                if (CooldownProgress == 1f)
                {
                    IsCooldown = false;
                }
            }
        }

        public override void Render()
        {
            NetworkState from;
            NetworkState to;

            if (TryGetStateChanges(out from, out to))
            {
                int len = Mathf.Min(from.bulletStates.Length, to.bulletStates.Length);

                for (int i = 0; i < len; i++)
                {
                    ShotState oldState = from.bulletStates[i];

                    ShotState newState = to.bulletStates[i];

                    if (oldState.StartTick != newState.StartTick)
                    {
                        // TODO: Shot sound effect & visual effect.
                    }
                    else if (oldState.EndTick != newState.EndTick)
                    {
                        if (newState.Position.y < -0.15f)
                        {
                            // TODO: Miss sound effect & visual effect.
                        }
                        else
                        {
                            // TODO: Hit sound effect & visual effect.
                        }
                    }
                }
            }
            else
            {
                Tick fromTick;
                Tick toTick;
                float alpha;

                TryGetStateSnapshots(out from, out fromTick, out to, out toTick, out alpha);
            }

            if (bullets != null)
            {
                bullets.Render(this, from.bulletStates);
            }
        }

        public void SetDamageFactor(float value)
        {
            damageFactor = value;
        }

        public void Cooldown(float progress = 0f)
        {
            cooldownTime = FireInterval;

            CooldownProgress = progress;

            IsCooldown = true;
        }

        public void Reload(float progress = 0f)
        {
            reloadTime = ReloadInterval;

            ReloadProgress = progress;

            IsReloading = true;
        }

        #endregion Public methods

        #region Private methods

        private void IsCooldownChanged()
        {
            if (IsCooldown)
            {
                OnCooldownStart?.Invoke(0f);
            }
            else
            {
                OnCooldownComplete?.Invoke();
            }
        }

        private void CooldownProgressChanged()
        {
            OnCooldownChange?.Invoke(CooldownProgress);
        }

        private void IsReloadingChanged()
        {
            if (IsReloading)
            {
                OnReloadStart?.Invoke(0f);
            }
            else
            {
                OnReloadComplete?.Invoke();
            }
        }

        private void ReloadProgressChanged()
        {
            OnReloadChange?.Invoke(ReloadProgress);
        }

        private void CurrentAmmoChanged()
        {
            OnCurrentAmmoChange?.Invoke(CurrentAmmo);
        }

        private void MaxAmmoChanged()
        {
            OnMaxAmmoChange?.Invoke(MaxAmmo);
        }

        /// <summary>
        /// Method processing single <see cref="ShotState"/>.
        /// </summary>
        /// <param name="shotState"></param>
        /// <param name="tick"></param>
        /// <returns>True if state was modified.</returns>
        private bool BulletProcessor(ref ShotState shotState, int tick)
        {
            if (shotState.Position.y < -0.15f)
            {
                shotState.EndTick = Runner.Tick;

                return true;
            }

            if (shotState.EndTick > Runner.Tick)
            {
                Vector3 normalizedDirection = shotState.Direction.normalized;

                float step = projectilePrefab.Speed * Runner.DeltaTime;

                if (Physics.Raycast(
                        shotState.Position - normalizedDirection * step,
                        normalizedDirection,
                        out var hit,
                        step,
                        projectilePrefab.HitMask.value,
                        QueryTriggerInteraction.Ignore))
                {
                    shotState.Position = hit.point;
                    shotState.EndTick = Runner.Tick;

                    if (hit.collider)
                    {
                        DestructibleObject destructibleObject = hit.collider.GetComponentInParent<DestructibleObject>();

                        if (destructibleObject != null)
                        {
                            destructibleObject.TakeDamage(projectilePrefab.Damage * damageFactor);
                        }
                    }

                    return true;
                }
            }

            return false;
        }

        #endregion Private methods
    }
}

NetworkBehaviourWithState.cs (Photon Fusion 2)

using Fusion;

namespace FusionHelpers
{
    /// <summary>
    /// Baseclass for Network Behaviours that follow a pattern of keeping all networked properties in its own struct.
    /// This reduces the amount of boilerplate needed to manage snapshots and change detection, at the cost of some flexibility.
    /// For example, you can check for changes and get both previous and current states with a single call, but you won't know exactly which properties changed.
    /// You can also acquire previous and current snapshots without dealing with property readers.
    /// Networked data is accessed via the `State` property which can be a useful visual hint when reading (and writing) code.
    /// (Note that while you *can* add networked state outside of the provided struct,
    /// it is not recommended since it most likely leads to extra calls to change detectors and is just generally confusing)
    /// </summary>
    /// <typeparam name="T">The struct that declares the networked state of this behaviour</typeparam>

    public abstract class NetworkBehaviourWithState<T> : NetworkBehaviour where T : unmanaged, INetworkStruct
    {
        public abstract ref T State { get; }

        private ChangeDetector _changesSimulation;
        private ChangeDetector _changesFrom;
        private ChangeDetector _changesTo;

        protected bool TryGetStateChanges(out T previous, out T current, ChangeDetector.Source source = ChangeDetector.Source.SimulationState)
        {
            switch (source)
            {
                default:
                case ChangeDetector.Source.SimulationState:
                    return TryGetStateChanges(source, ref _changesSimulation, out previous, out current);
                case ChangeDetector.Source.SnapshotFrom:
                    return TryGetStateChanges(source, ref _changesFrom, out previous, out current);
                case ChangeDetector.Source.SnapshotTo:
                    return TryGetStateChanges(source, ref _changesTo, out previous, out current);
            }
        }

        private bool TryGetStateChanges(ChangeDetector.Source source, ref ChangeDetector changes, out T previous, out T current)
        {
            if (changes == null)
                changes = GetChangeDetector(source);

            if (changes != null)
            {
                foreach (var change in changes.DetectChanges(this, out var previousBuffer, out var currentBuffer))
                {
                    switch (change)
                    {
                        case nameof(State):
                            var reader = GetPropertyReader<T>(change);
                            current = currentBuffer.Read(reader);
                            previous = previousBuffer.Read(reader);
                            return true;
                    }
                }
            }
            current = default;
            previous = default;
            return false;
        }

        protected bool TryGetStateSnapshots(out T from, out Tick fromTick, out T to, out Tick toTick, out float alpha)
        {
            if (TryGetSnapshotsBuffers(out var fromBuffer, out var toBuffer, out alpha))
            {
                var reader = GetPropertyReader<T>(nameof(State));
                from = fromBuffer.Read(reader);
                to = toBuffer.Read(reader);
                fromTick = fromBuffer.Tick;
                toTick = toBuffer.Tick;
                return true;
            }

            from = default;
            to = default;
            fromTick = default;
            toTick = default;
            return false;
        }
    }
}

SparseCollection.cs (Photon Fusion 2)

using Fusion;
using UnityEngine;
using Object = UnityEngine.Object;

namespace FusionHelpers
{
    /// <summary>
    /// ISparseState represents the networked part of a simple object that require infrequent (network) updates,
    /// but still needs a visual game object rendered every frame on all clients.
    /// For example, a bullet following a straight line can be rendered just knowing its start location and velocity.
    /// </summary>
    /// <typeparam name="P">The MonoBehaviour that represents this state visually</typeparam>
    public interface ISparseState<P> : INetworkStruct where P : MonoBehaviour
    {
        public int StartTick { get; set; }
        public int EndTick { get; set; }

        /// <summary>
        /// The extrapolate method should update properties on the state struct using the given local time t
        /// (local time is the offset in seconds from StartTick).
        /// Note that these changes are just local predictions/extrapolations - they will not automatically be networked.
        /// (See the SparseCollection.Process method if you need to update state on State Authority)
        /// </summary>
        /// <param name="t">Local time in seconds to extrapolate to (t is 0 at Runner.Tick==StartTick)</param>
        /// <param name="prefab">Prefab used to create the visual (handy for accessing visual object configuration -
        /// Keep in mind that this is the prefab, it is *NOT* (guaranteed to be) the actual game object used to visualize this state)</param>
        public void Extrapolate(float t, P prefab);
    }

    /// <summary>
    /// ISparseVisual is implemented by local game objects that "visualize" an ISparseState.
    /// </summary>
    /// <typeparam name="T">The actual type of the sparse state</typeparam>
    /// <typeparam name="P">The MonoBehaviour used to visualise the sparse state</typeparam>
    public interface ISparseVisual<T, P> where T : unmanaged, ISparseState<P> where P : MonoBehaviour, ISparseVisual<T, P>
    {
        /// <summary>
        /// This method is called every frame to update the visual game object to match the current render state.
        /// </summary>
        /// <param name="owner">The NB that owns the collection of sparse states</param>
        /// <param name="state">The current render state of this particular visual</param>
        /// <param name="t">The current local time that the state represents</param>
        /// <param name="isFirstRender">True the first time this is called for a new visual</param>
        /// <param name="isLastRender">True the last time this is called for a given visual</param>
        public void ApplyStateToVisual(NetworkBehaviour owner, T state, float t, bool isFirstRender, bool isLastRender);
    }

    /// <summary>
    /// The sparse collection maps sparse states to sparse visuals and keeps track of the somewhat complex timing involved
    /// </summary>
    /// <typeparam name="T">The actual type of the sparse state</typeparam>
    /// <typeparam name="P">The MonoBehaviour used to visualise the sparse state</typeparam>
    public class SparseCollection<T, P> where T : unmanaged, ISparseState<P> where P : MonoBehaviour, ISparseVisual<T, P>
    {
        // Internal struct for keeping track of matching states and visuals
        private struct Entry
        {
            public P visual;
            public bool enabled;
        }

        // To give proxies a chance to disable the local GO before it's re-used, we wait a few additional ticks before re-using a state.
        private const int REUSE_DELAY_TICKS = 24;

        // Reference to the raw networked state data
        private NetworkArray<T> _states;

        // State to visual map
        private Entry[] _entries;

        // Prefab used for visuals
        private readonly P _prefab;

        // Last time render was called - used to make sure we don't miss updates if framerate is low
        private float _nextRenderTime;

        /// <summary>
        /// The sparse collection itself is not a networked object, so you need to create its backing data elsewhere (in a NB)
        /// and pass it to the constructor along with a reference to the prefab to use for the associated visuals.
        /// Once created, call
        /// * Render() from the NetworkBehaviour's Render() method, passing in the relevant snapshot
        /// * Process() from the NetworkBehaviour's FixedUpdateNetwork() method if you want to alter state, and
        /// * Add() from Input or State auth to "spawn" a new object.
        /// </summary>
        /// <param name="states">Networked array of sparse state structs</param>
        /// <param name="prefab">Prefab to use for visuals</param>
        public SparseCollection(NetworkArray<T> states, P prefab)
        {
            _entries = new Entry[states.Length];
            _states = states;
            _prefab = prefab;
        }

        /// <summary>
        /// Call Render() every frame to update visuals to their associated sparse state.
        /// </summary>
        /// <param name="owner">The <see cref="NetworkBehaviour"/> that contains the networked state objects</param>
        public void Render(NetworkBehaviour owner, NetworkArray<T> states)
        {
            NetworkRunner runner = owner.Runner;

            float renderTime = owner.Object.RenderTime;

            for (int i = 0; i < _entries.Length; i++)
            {
                Entry entry = _entries[i];

                T state = states[i];

                if (!entry.enabled && entry.visual && entry.visual.gameObject.activeSelf)
                {
                    entry.visual.gameObject.SetActive(false);
                }

                // Note: t may be less than zero if we're rendering across several ticks and StartTick is somewhere in-between.
                // (E.g. from=100, to=102 with start=101 and alpha=0.25 will place us ahead of the start tick)
                float t = renderTime - state.StartTick * runner.DeltaTime;
                float t1 = (state.EndTick - state.StartTick) * runner.DeltaTime;

                bool isLastRender = t >= t1 && entry.enabled;
                bool isFirstRender = false;

                // We delay disabling of the object one frame since "last render" isn't really a last render if the object is immediately hidden.
                entry.enabled = t >= 0 && t < t1;

                // Make sure we have a valid enabled GameObject if this state represents an active instance
                if (entry.enabled || isLastRender)
                {
                    if (!entry.visual)
                    {
                        entry.visual = Object.Instantiate(_prefab);
                        isFirstRender = true;
                    }

                    if (!entry.visual.gameObject.activeSelf)
                    {
                        entry.visual.gameObject.SetActive(true);
                        isFirstRender = true;
                    }

                    if (isFirstRender)
                    {
                        ApplyState(state, entry, 0, true, false);
                    }

                    if (!isFirstRender && !isLastRender)
                    {
                        ApplyState(state, entry, t, false, false);
                    }

                    if (isLastRender)
                    {
                        ApplyState(state, entry, t1, false, true);
                    }
                }
                // Done modifying the entry struct, copy it back to the array
                _entries[i] = entry;
            }

            void ApplyState(T state, Entry e, float t, bool isFirstRender, bool isLastRender)
            {
                // Update state to t
                state.Extrapolate(t, _prefab);

                // Update visual to match the state
                e.visual.ApplyStateToVisual(owner, state, t, isFirstRender, isLastRender);
            }
        }

        public delegate bool Processor(ref T state, int tick);

        /// <summary>
        /// Call process every tick if you want to adjust *networked* properties on the sparse state.
        /// As the name suggests, these updates should be infrequent, so if you *do* change the state
        /// you must return true from the delegate to update the backing array.
        /// </summary>
        /// <param name="owner">The <see cref="NetworkBehaviour"/> that owns the sparse state list</param>
        /// <param name="processor">A delegate that will process each (active) sparse state</param>
        public void Process(NetworkBehaviour owner, Processor processor)
        {
            if (owner.IsProxy)
                return;

            NetworkRunner runner = owner.Runner;

            int simTtick = runner.Tick;

            for (int i = 0; i < _states.Length; i++)
            {
                T state = _states[i];

                float t = (simTtick - state.StartTick) * runner.DeltaTime;

                if (simTtick <= state.EndTick)
                {
                    state.Extrapolate(t, _prefab);

                    if (processor(ref state, simTtick))
                    {
                        // Since we're storing the extrapolated state, we must also update the start tick, as this is our new starting point going forward.
                        state.StartTick = simTtick;
                        // Update the networked backing storage so the change is propagated
                        _states[i] = state;
                    }
                }
            }
        }

        /// <summary>
        /// Call Add to "instantiate" (or rather, "activate") a new sparse state. Note that this will not allocate
        /// but simply select the next in-active sparse state in the array. It will do nothing if none is found.
        /// </summary>
        /// <param name="runner"></param>
        /// <param name="state">The initial state to add</param>
        /// <param name="secondsToLive">Initial number of ticks for the sparse state to be alive</param>
        public void Add(NetworkRunner runner, T state, float secondsToLive)
        {
            state.StartTick = runner.Tick;
            state.EndTick = state.StartTick + Mathf.Max(1, (int)(secondsToLive / runner.DeltaTime));

            for (int i = 0; i < _states.Length; i++)
            {
                if (runner.Tick > _states[i].EndTick + REUSE_DELAY_TICKS)
                {
                    _states[i] = state;

                    return;
                }
            }

            Debug.LogWarning("No free slots in state array!");
        }

        /// <summary>
        /// Call Clear to destroy all visuals for this sparse set.
        /// </summary>
        public void Clear()
        {
            for (int i = 0; i < _entries.Length; i++)
            {
                Entry entry = _entries[i];

                if (entry.visual)
                {
                    Object.Destroy(entry.visual.gameObject);
                }

                _entries[i] = default;
            }
        }
    }
}

NetworkState.cs

using Fusion;

namespace ProtoGDM.Networking
{
    public struct NetworkState : INetworkStruct
    {
        #region Properties

        [Networked, Capacity(64)]
        public NetworkArray<ShotState> bulletStates
        {
            get
            {
                return default;
            }
        }

        #endregion Properties
    }
}

ShotState.cs

using FusionHelpers;
using UnityEngine;

namespace ProtoGDM.Networking
{
    public struct ShotState : ISparseState<Projectile>
    {
        #region Properties

        public Vector3 Position
        {
            get;
            set;
        }

        public Vector3 Direction
        {
            get;
            set;
        }

        public int StartTick
        {
            get;
            set;
        }

        public int EndTick
        {
            get;
            set;
        }

        #endregion Properties

        #region Constructors

        public ShotState(Vector3 startPosition, Vector3 direction)
        {
            StartTick = 0;
            EndTick = 0;
            Position = startPosition;
            Direction = direction;
        }

        #endregion Constructors

        #region Public methods

        public void Extrapolate(float time, Projectile projectile)
        {
            Position = GetPositionAt(time, projectile);
            Direction = GetDirectionAt(time, projectile);
        }

        public Vector3 GetTargetPosition(Projectile projectile)
        {
            float a = 0.5f * projectile.Gravity.y;
            float b = projectile.Speed * Direction.y;
            float c = Position.y;
            float d = b * b - 4 * a * c;
            float t = (-b - Mathf.Sqrt(d)) / (2 * a);
            Vector3 p = GetPositionAt(t, projectile);
            p.y = 0.05f; // Return the position with a slight y offset to avoid placing target where it will end up z-fighting with the ground;

            return p;
        }

        #endregion Public methods

        #region Private methods

        private Vector3 GetPositionAt(float time, Projectile projectile)
        {
            return Position + time * (projectile.Speed * Direction + 0.5f * time * projectile.Gravity);
        }

        private Vector3 GetDirectionAt(float time, Projectile projectile)
        {
            return projectile.Speed == 0 ? Direction : (projectile.Speed * Direction + time * projectile.Gravity).normalized;
        }

        #endregion Private methods
    }
}

Projectile.cs

using Fusion;
using FusionHelpers;
using ProtoGDM.Networking;
using UnityEngine;

namespace ProtoGDM
{
    public class Projectile : MonoBehaviour, ISparseVisual<ShotState, Projectile>
    {
        private Transform locTransform;

        #region Properties

        [SerializeField]
        private Vector3 gravity;

        public Vector3 Gravity
        {
            get
            {
                return gravity;
            }
        }

        [SerializeField]
        private float timeOfLife = 2f;

        public float TimeOfLife
        {
            get
            {
                return timeOfLife;
            }
        }

        [SerializeField]
        private LayerMask hitMask;

        public LayerMask HitMask
        {
            get
            {
                return hitMask;
            }
        }

        [SerializeField]
        private float speed = 50f;

        public float Speed
        {
            get
            {
                return speed;
            }
        }

        [SerializeField]
        private float damage = 10f;

        public float Damage
        {
            get
            {
                return damage;
            }
        }

        #endregion Properties

        private void Awake()
        {
            locTransform = transform;
        }

        #region Public methods

        public void ApplyStateToVisual(NetworkBehaviour owner, ShotState shotState, float time, bool isFirstRender, bool isLastRender)
        {
            locTransform.forward = shotState.Direction;
            locTransform.position = shotState.Position;
        }

        #endregion Public methods
    }
}

Turret

Turrets are another key part of this demo. Each turret is a stationary object with its own health and specific shooting parameters. A trigger collider defines the turret’s detection area. When a player vehicle enters this area, the turret rotates to face it and begins firing. The turret checks if an obstacle blocks its target. If it can’t get a clear shot, it looks for another player’s vehicle.

All logic for aiming, targeting, and controlling the turret runs on the Host – the side with State Authority. The turret’s rotation and barrel angles are synchronised with all Clients. When no player vehicles are in range, the turret enters search mode and spins on its axis to find a new target.

Projectile shooting, synchronisation, and visualisation work just like they do for the player vehicle. The system synchronises only the projectile states. Both the Host and Clients handle projectile visualisation locally whenever the state changes.

TurretController.cs

using Fusion;
using FusionHelpers;
using ProtoGDM.Networking;
using System.Collections.Generic;
using UnityEngine;

namespace ProtoGDM
{
    public class TurretController : NetworkBehaviourWithState<NetworkState>
    {
        [Networked]
        public override ref NetworkState State => ref MakeRef<NetworkState>();

        #region Variables

        [Header("Configuration")]

        [SerializeField]
        protected Transform baseTransform;

        [SerializeField]
        protected Transform barrelTransform;

        [SerializeField]
        private Transform raycastPoint;

        [SerializeField]
        private Transform projectileSpawnPoint;

        [Header("Settings")]

        [SerializeField]
        private Projectile projectilePrefab;

        [SerializeField]
        private float agroRange = 10f;

        [SerializeField]
        private LayerMask layerMask;

        [SerializeField]
        protected float rotationSpeed = 5f;

        [SerializeField]
        protected float minPitchAngle = 0f;

        [SerializeField]
        protected float maxPitchAngle = 20f;

        [SerializeField]
        private SphereCollider detectionCollider;

        [SerializeField]
        private float searchRotationSpeed = 10f;

        [SerializeField]
        private float searchPitchSpeed = 1f;

        [SerializeField]
        private float fireInterval = 2f;

        [SerializeField]
        private List<PlayerVehicleController> targetsInRange = new List<PlayerVehicleController>();

        private float searchTime = 0f;

        protected SparseCollection<ShotState, Projectile> bullets;

        #endregion Variables

        #region Properties

        [Networked]
        public TurretStateTypes CurrentState
        {
            get;
            set;
        }

        [Networked]
        public float Cooldown
        {
            get;
            set;
        }

        #endregion Properties

        #region Unity methods

        public override void Spawned()
        {
            bullets = new SparseCollection<ShotState, Projectile>(State.bulletStates, projectilePrefab);

            if (detectionCollider != null)
            {
                detectionCollider.isTrigger = true;

                detectionCollider.radius = agroRange;
            }
            else
            {
                Debug.LogWarning("Detection Collider is not set on " + gameObject.name);
            }
        }

        public override void Despawned(NetworkRunner runner, bool hasState)
        {
            bullets.Clear();

            base.Despawned(runner, hasState);
        }

        public override void FixedUpdateNetwork()
        {
            if (!HasStateAuthority)
            {
                return;
            }

            bullets.Process(this, BulletProcessor);

            float deltaTime = Runner.DeltaTime;

            if (Cooldown > 0f)
            {
                Cooldown -= deltaTime;

                if (Cooldown < 0f)
                {
                    Cooldown = 0f;
                }
            }

            PlayerVehicleController currentTarget = null;

            for (int i = 0; i < targetsInRange.Count; i++)
            {
                if (targetsInRange[i])
                {
                    if (IsTargetVisible(targetsInRange[i]))
                    {
                        currentTarget = targetsInRange[i];

                        break;
                    }
                }
            }

            if (currentTarget)
            {
                CurrentState = TurretStateTypes.Tracking;

                AimAtTarget(currentTarget.transform.position);

                if (Cooldown == 0f)
                {
                    Shoot(Runner);

                    Cooldown = fireInterval;
                }
            }
            else
            {
                CurrentState = TurretStateTypes.Searching;

                SearchForTarget(deltaTime);
            }
        }

        public override void Render()
        {
            if (TryGetStateChanges(out var from, out var to))
            {

            }
            else
            {
                TryGetStateSnapshots(out from, out _, out _, out _, out _);
            }

            bullets.Render(this, from.bulletStates);
        }

        private void OnTriggerEnter(Collider other)
        {
            PlayerVehicleController vehicle = other.GetComponentInParent<PlayerVehicleController>();

            if (vehicle != null && !targetsInRange.Contains(vehicle))
            {
                targetsInRange.Add(vehicle);
            }
        }

        private void OnTriggerExit(Collider other)
        {
            PlayerVehicleController vehicle = other.GetComponentInParent<PlayerVehicleController>();

            if (vehicle != null)
            {
                targetsInRange.Remove(vehicle);
            }
        }

        private void OnDrawGizmosSelected()
        {
            if (targetsInRange == null)
            {
                return;
            }

            foreach (PlayerVehicleController vehicleController in targetsInRange)
            {
                if (vehicleController == null)
                {
                    continue;
                }

                Vector3 direction = (vehicleController.transform.position + Vector3.up) - raycastPoint.position;

                Ray ray = new Ray(raycastPoint.position, direction);

                RaycastHit raycastHit;

                if (Physics.Raycast(ray, out raycastHit, agroRange, layerMask, QueryTriggerInteraction.Ignore))
                {
                    if (vehicleController.HitCollider == raycastHit.collider)
                    {
                        Gizmos.color = Color.green;
                    }
                    else
                    {
                        Gizmos.color = Color.red;
                    }

                    Gizmos.DrawLine(raycastPoint.position, raycastHit.point);
                }
                else
                {
                    Gizmos.color = Color.red;
                    Gizmos.DrawLine(raycastPoint.position, raycastPoint.position + direction.normalized * agroRange);
                }
            }
        }

        #endregion Unity methods

        #region Private methods

        private bool IsTargetVisible(PlayerVehicleController vehicleController)
        {
            Vector3 direction = (vehicleController.transform.position + Vector3.up) - raycastPoint.position;

            Ray ray = new Ray(raycastPoint.position, direction);

            RaycastHit raycastHit;

            if (Physics.Raycast(ray, out raycastHit, agroRange, layerMask, QueryTriggerInteraction.Ignore))
            {
                if (vehicleController.HitCollider == raycastHit.collider)
                {
                    return true;
                }
            }

            return false;
        }

        private void SearchForTarget(float deltaTime)
        {
            baseTransform.Rotate(Vector3.up, searchRotationSpeed * deltaTime);

            searchTime += deltaTime * searchPitchSpeed;

            float pitchAngle = Mathf.Lerp(minPitchAngle, maxPitchAngle, (Mathf.Sin(searchTime) + 1f) * 0.5f);

            barrelTransform.localRotation = Quaternion.Euler(-pitchAngle, 0, 0);
        }

        private void AimAtTarget(Vector3 targetPosition)
        {
            Vector3 directionToTarget = targetPosition - baseTransform.position;

            Vector3 flatDirection = new Vector3(directionToTarget.x, 0, directionToTarget.z);

            if (flatDirection.sqrMagnitude > 0.001f)
            {
                Quaternion baseRotation = Quaternion.LookRotation(flatDirection);

                baseTransform.rotation = Quaternion.Euler(0, baseRotation.eulerAngles.y, 0);
            }

            Vector3 localTargetPosition = baseTransform.InverseTransformPoint(targetPosition);

            float distance = Mathf.Sqrt(localTargetPosition.z * localTargetPosition.z + localTargetPosition.x * localTargetPosition.x);

            float pitchAngle = Mathf.Atan2(localTargetPosition.y, distance) * Mathf.Rad2Deg;

            pitchAngle = Mathf.Clamp(pitchAngle, minPitchAngle, maxPitchAngle);

            barrelTransform.localRotation = Quaternion.Euler(-pitchAngle, 0, 0);
        }

        private void Shoot(NetworkRunner networkRunner)
        {
            if (Object.HasStateAuthority)
            {
                bullets.Add(networkRunner, new ShotState(projectileSpawnPoint.position, projectileSpawnPoint.forward), projectilePrefab.TimeOfLife);
            }
        }

        /// <summary>
        /// Method processing single <see cref="ShotState"/>.
        /// </summary>
        /// <param name="shotState"></param>
        /// <param name="tick"></param>
        /// <returns>True if state was modified.</returns>
        private bool BulletProcessor(ref ShotState shotState, int tick)
        {
            if (shotState.Position.y < -0.15f)
            {
                shotState.EndTick = Runner.Tick;

                return true;
            }

            if (shotState.EndTick > Runner.Tick)
            {
                Vector3 normalizedDirection = shotState.Direction.normalized;

                float step = projectilePrefab.Speed * Runner.DeltaTime;

                if (Physics.Raycast(
                        shotState.Position - normalizedDirection * step,
                        normalizedDirection,
                        out var hit,
                        step,
                        projectilePrefab.HitMask.value,
                        QueryTriggerInteraction.Ignore))
                {
                    shotState.Position = hit.point;
                    shotState.EndTick = Runner.Tick;

                    if (hit.collider)
                    {
                        DestructibleObject destructibleObject = hit.collider.GetComponentInParent<DestructibleObject>();

                        if (destructibleObject != null)
                        {
                            destructibleObject.TakeDamage(projectilePrefab.Damage * MissionSettings.Instance.GetDifficultyFactor());
                        }
                    }

                    return true;
                }
            }

            return false;
        }

        #endregion Private methods
    }
}

Reconnect

Every real-time multiplayer game is vulnerable to connection issues. At any moment, a Client can lose the connection to the Server or Host.

To ensure a good experience, your game should include reconnection mechanisms. These systems should automatically try to restore the connection if the problem is temporary. It’s also useful to let players return to a session after events like a PC restart, sudden crash, or power outage.

In our demo, we focus on the Host-Client topology. One player acts as the Host and knows the current state of the game. Only the Host can help a reconnecting Client recover the latest game state.

What is reconnect?
Reconnect means the player restores a stable connection after losing it. The game also has to rebuild the player’s knowledge of the current world state. While the player was offline, other participants kept playing and changed the world. Only the Host can decide if the player can rejoin and is responsible for sending the most up-to-date state.

If your game does not support reconnect, the Host assumes every disconnect is intentional. The game despawns the player’s objects and forgets their state. Supporting reconnect makes things more complex. The Host must decide whether the disconnect was intentional or not. They also need to save the player’s data for a while and identify if a reconnecting player is really the same person.

As described in the previous article, joining a Fusion 2 session is simple if you know the session name. The Host receives a callback and chooses to accept or reject the request. Fusion 2 does not have a built-in reconnect system. For the Host, a reconnecting player looks like a new player. The Host must check if the player is new or someone who lost connection earlier. To do this, use the ConnectionToken from StartGameArgs. See the NetworkManager class and JoinSession method in this article. The ConnectionToken allows the Host to recognize returning players. Here’s how the flow works:

1. The Host creates a session.
2. Player A joins and sends a unique ConnectionToken.
3. The Host accepts Player A and saves their ConnectionToken.
4. Player B joins and sends a unique ConnectionToken.
5. The Host accepts Player B and saves their ConnectionToken.
6. The Host starts the game. All players are in the session. Suddenly, Player A’s computer freezes. After restarting, they want to return.
7. Player A remembers the session name and their ConnectionToken. They request to rejoin using NetworkManager.JoinSession.
8. The Host receives OnConnectRequest and checks if the ConnectionToken matches a known player.
9. If it matches, the Host knows it’s Player A.
10. The Host accepts the player. Since this is not a new player, the Host does not spawn new objects. Instead, the Host restores Input Authority to Player A’s previous objects. This lets Player A regain control and synchronizes the current state.

This is the basic reconnect workflow. Here are a few common problems you may face.

Session slot reservation
Fusion 2 does not reserve session slots for reconnecting players. If a player disconnects unexpectedly, the Fusion backend eventually removes them from the session. Meanwhile, another player might see a free slot and try to join. Only your Host can check if the slot is really free, or if you’re waiting for a reconnect. There’s also another problem. The Fusion backend may be slower to detect disconnects than the Host. The Host checks client status more often. As a result, a reconnecting player might see a “session full” error even if the Host already knows they left. The backend still thinks the slot is occupied.

Password-protected sessions
You might use ConnectionToken to send a session password, but now you also need to use it to identify the player. Fusion 2 does not offer separate fields for passwords and reconnects, so you have to combine them. In this example, create a structure with both the player’s ID and password, serialize it to JSON, convert it to byte[], and use that as the ConnectionToken.

ConnectionToken.cs

namespace ProtoGDM.Networking
{
    [Serializable]
    public class ConnectionToken
    {
        public string password;
        public string reconnectGuid;

        public ConnectionToken(string password, string reconnectGuid)
        {
            this.password = password;
            this.reconnectGuid = reconnectGuid;
        }

        public static byte[] ToBytes(ConnectionToken token)
        {
            string json = JsonUtility.ToJson(token);

            return Encoding.UTF8.GetBytes(json);
        }

        public static ConnectionToken FromBytes(byte[] data)
        {
            if (data == null || data.Length == 0)
            {
                return null;
            }

            string json = Encoding.UTF8.GetString(data);

            return JsonUtility.FromJson<ConnectionToken>(json);
        }
    }
}

The Host should not wait indefinitely for a disconnected player. Most games set a reconnect window of several seconds or a few minutes. After this time, the Host considers the player gone, removes their state, and deletes their ConnectionToken. If the player tries to reconnect after this period, Host treats them as a new participant and does not restore their previous state.

In our demo, you’ll find the roomPlayerMap dictionary in the NetworkManager class. This dictionary links each RoomPlayer object to the player’s unique identifier (string). When a player joins the game, the Host checks this dictionary in both OnConnectRequest and OnPlayerJoined.

• In OnConnectRequest, the Host verifies whether the player’s identifier is still mapped to a RoomPlayer. If not, the reconnect window has expired and the connection cannot be restored.
• In OnPlayerJoined, the Host tries to fetch the RoomPlayer object. If successful, the Host assigns InputAuthority and returns control to the player without creating new objects.

The RoomPlayer class also contains a networked property called IsDisconnected. This property lets other players know when someone has connection issues. For example, you can display a “Disconnected” message above the player’s vehicle.

Summary

This article wrapped up our Photon Fusion 2 series with a complete but very simple project. You learned how to structure a Unity project for multiplayer, set up and manage sessions, handle player data, synchronize gameplay objects, and implement reconnection logic for real-time games. We explored practical code examples, explained core networking concepts, and showed you how to combine all these systems in a working demo.

With this knowledge, you’re ready to design your own multiplayer mechanics, expand on the sample game, and take full advantage of Photon Fusion 2 in future projects. If you missed any previous articles, check out the earlier parts of the series. Good luck, and happy coding!

The post Photon Fusion 2 – Game Tutorial – Part 4/4 appeared first on The Knights of U.

Data synchronisation is the most important part of every multiplayer game. In Photon Fusion 2, you have all the tools you need to keep players, objects, and game logic in perfect sync across the network. In this article, you’ll learn how authority works, how to use networked properties and RPCs, how to synchronise object transforms and physics, and how to handle player input. Whether you’re syncing basic values or building advanced mechanics, this guide gives you the essentials to make your multiplayer game feel seamless.

Introduction

You already understand the basics of Photon Fusion 2 and know how to choose the best network topology for your game. You can manage sessions, create new ones, join as a Client, and set up private or password-protected sessions.

Now you’re ready for the most exciting part – syncing game data in real time. This article teaches you the core methods of data synchronisation in Photon Fusion 2. With these skills, you can finally start building your game’s main mechanics.

You will learn how to synchronise property values, use built-in components to sync the position, rotation, and scale of objects, and manage physics across the network. You’ll handle player input, respond to parameter changes, build your first RPCs, and spawn networked objects.

Synchronization

When you play a single-player game, you can freely modify the world without any communication required, because you are the only entity that is affected by it. With multiplayer games, when you want to modify the world, you have to notify other players so they can also modify their world accordingly. Otherwise, the changes would be local only, and other players wouldn’t know about it. There are even cases when your attempt at modification is straight-up denied because of a conflict with other changes you haven’t registered yet. This is a very complex process called data synchronisation, and getting it right is the key to a good player experience.

Not everything needs to be synchronised. For instance, in a game that allows you to customise the HUD, there is no point in synchronising it. There is also no point in synchronising static level elements. The GameObjects that are synchronised are called Networked Objects.

Authority

In multiplayer games – especially those built with the Host-Client topology – it’s crucial to define which peer can modify the in-game object. Photon Fusion 2 handles this with a clear authority system. Understanding how authority works helps you prevent conflicting updates, cheating, and synchronisation errors.

Authority determines which player or device controls a specific object or game system. In Photon Fusion 2, there are two types of authority: State Authority and Input Authority.

State Authority

State Authority gives a peer the right to update and synchronise the state of a networked object. In the Host-Client model, the Host always has State Authority over all networked objects. Only the Host can make decisions that affect the state of the game world – such as player positions, health values, spawning objects, and resolving gameplay actions.

Other clients receive updates from the Host about the state of every networked object, but they cannot change the state themselves. If a client tries to update a networked property of an object without State Authority, Fusion ignores the change or overwrites it with the Host’s data on the next tick.

State Authority is critical for:

• Preventing cheating by ensuring only the trusted Host can modify critical data.
• Providing a single source of truth for the game world, thus eliminating the risk of conflicting changes.
• Ensuring all clients see the same state as determined by the Host.

Input Authority

Input Authority controls which Client can provide input – usually the player’s own character. In the Host-Client topology, each Client holds Input Authority over its own player object. This allows the client to send movement, action, or control inputs to the Host for their character, and for the Host to react to the Client’s input.

The Host reads received input from the clients, processes the data, and updates the authoritative game state. Fusion then replicates the updated state to all clients.

Input Authority is important for:

• Letting each player control their character.
• Keeping input collection (client-side) separate from state validation (host-side).
• Supporting client-side prediction, so Clients can simulate their actions instantly.

Replication

Photon Fusion 2 synchronises game state between Clients through the Networked Simulation Loop. The engine splits gameplay into simulation ticks. A simulation tick is a fixed, regular step in the simulation. Every action, update, and network event occurs on these ticks, ensuring all Clients process the same events in the same order. This approach helps to keep every Client in sync, regardless of frame rate or hardware differences. You can set the tick rate in your project settings and adjust it for your game’s needs.

Replication Mechanisms in Photon Fusion 2

Networked Properties – You synchronise object properties, like health or gold, by using the [Networked] attribute. The client or server with State Authority sends property changes to other clients. When a client changes a property without authority, the update is local. On the next tick, Fusion overwrites it with the value from the State Authority.

Remote Procedure Calls (RPCs) – You mark methods with the [Rpc] attribute to call functions on other clients or the server. You call the method like any other local method, but behind the scenes, Photon synchronises the call to the method according to the attribute parameters.

NetworkTransform – this component synchronises the position, rotation, scale, and parent object of a game object. Fusion uses this component to deliver smooth and efficient synchronisation across all clients.

Player Input – In Host-Client Mode, the player with Input Authority collects input every tick. The Host synchronises and buffers this data, then uses it in each simulation step to simulate movement and actions.

Replication Control Mechanisms in Photon Fusion 2

Interest Management (Area of Interest, AoI) – Fusion decides which objects to synchronise for each player. It only sends relevant data to each client, reducing network load and improving performance.

FixedUpdateNetwork method – Fusion calls this method every simulation tick, so you can update object states. The system then synchronises these changes to all clients.

Render method – Fusion calls the Render method after each simulation step to interpolate and display the current game state on the player’s screen.

Change Detection – Fusion tracks property changes in game objects. You can react to these changes by updating the visuals or other aspects of your game.

These tools give you full control over replication and help you keep your multiplayer game synchronised.

Networked Properties (NP)

The first mechanism for state synchronisation in Photon Fusion 2 is Networked Properties. The peer with State Authority sets the values, and Fusion replicates them to all other peers in the session. This approach lets you continuously synchronise changes to the game state.

To start replicating a property in Photon Fusion 2, follow these three steps. For more details, see the official documentation here.

• Declare the property in a class that inherits from NetworkBehaviour.
• Use an auto-property because Fusion 2 supports only auto-properties. Fusion’s IL-Weaver injects code for serialisation, compression, validation, and network transport.
• Add the [Networked] attribute to your property.

Photon Fusion 2 can replicate some types directly, such as byte, int, and float. For others, you must use special network types, like NetworkBool instead of the standard bool. Always keep your networked properties as auto-properties and don’t implement custom logic inside them. If you need additional logic, wrap the auto-property in another property or use Change Detection.

Networked Properties run inside the Fusion 2 simulation loop, which works on fixed ticks. On every tick, Fusion calls the FixedUpdateNetwork method, just like Unity’s FixedUpdate. Fusion collects the values of all properties with the [Networked] attribute and creates a snapshot on the side with State Authority. Fusion then synchronises this snapshot with other peers.

Keep in mind that Networked Properties synchronisation also connects with the Area of Interest (AoI) system, although this article does not cover AoI in detail. With AoI, you can reduce network traffic and focus on syncing only the data your players really need – for example, objects within their view or interaction range. With AoI enabled, objects outside a client’s area of interest are simulated only on the authoritative side and their state is not sent to clients unless they become relevant. AoI is disabled by default.

Change Detection

You need to detect changes in Networked Properties in almost every game. For example, when the HP value changes, you might want to update the UI or destroy the object if HP reaches zero.

The OnChangedRender attribute provides the easiest and most popular way to respond to property changes. You use this attribute to specify the name of the method that Photon Fusion 2 should call when the property changes. Fusion automatically generates code to call your chosen method whenever the value updates.

Fusion always calls your method after updating the property value. In the example, you can also read the previous value from the buffer.

Remote Procedure Call (RPC)

Almost every game needs systems for triggering single or complex actions on demand. For example, players may set a nickname, pick up an item, or open a door. These one-time events do not need constant synchronisation, so you can reduce network traffic. By default, Photon Fusion delivers RPC calls reliably, but you can also use unreliable mode. Photon ensures the packets arrive and runs the procedure on the receiver.

Here’s how to declare a custom RPC to set the player’s ready status. The Host can only start the match when all players are ready.

How to define an RPC?

• Declare the RPC in a class that inherits from NetworkBehaviour.
• Use a ‘rpc’ prefix or postfix.
• Add the [Rpc] attribute.
• Set RpcSources to control who can call the RPC. For example, every player with InputAuthority.
• Set RpcTargets to control who receives the RPC. In most cases, only the Host, since only the Host with StateAuthority can update the networked state.
• Optionally, set HostMode to control how Photon treats the Host. By default, Photon treats the Host as a server, so RpcInfo.Source will be None. To treat the Host like any other client, set SourceIsHostPlayer.

How does this work in practice?

• Player B (Client) calls RPC_ChangeIsReady(true) to confirm readiness.
• Photon checks if Player B can receive the RPC. Since B lacks StateAuthority, Photon only sends the call to valid targets (the Host, Player A). The method is not called on the Client.
• Player A receives the RPC and runs the method RPC_ChangeIsReady(true). Player A as a Host updates the IsReady property.
• The IsReady property synchronises to all clients using the [Networked] attribute.
• Both players react to the property change and update the status on screen.

Important note

RPCs are one-time events. They only reach players at the moment of execution. If your game logic depends on RPCs, remember to handle new players joining or reconnecting. For example, if you open a door via an RPC and don’t continuously synchronise its state, send the door’s status to new clients when they join. Otherwise, the door state will be out of sync.

Data Streaming

Sometimes you need to transfer much more data than a simple variable or an RPC parameter. Some games allow players to create custom maps, share images and videos, or exchange configuration and save data.

Photon Fusion 2 offers an easy-to-use data streaming system. You can send large byte arrays from the client to the server or host, and in the other direction as well. The high-level API lets you send and receive data without managing packet fragmentation or order. As the sender, you call a method to reliably send data. The receiver listens for events that report transfer progress and confirms when the whole package arrives. Fusion 2 does not inform the sender about delivery status or completion. If you need this feedback, use RPCs to notify the sender.

Data streaming does not depend on State Authority or Input Authority. To send data to a player, use a NetworkRunner in Host or Server mode. When you want to send data to the server, use the NetworkRunner in Client mode. To receive data or progress info, implement the methods OnReliableDataProgress and OnReliableDataReceived from the INetworkRunnerCallbacks interface.

Sending

Receiving

Sync Components

Now you’ll learn about the main components that let you easily synchronise basic properties of scene objects – such as position, rotation, scale, and even object hierarchy, meaning parent-child relationships. I’ll also introduce you to the component for syncing Rigidbodies, so you can use physics in your multiplayer game.

NetworkTransform

The NetworkTransform component allows you to synchronise an object’s position and rotation by default. You can place it either at the root of your object hierarchy, next to the NetworkObject component, or on any nested child object. You don’t need to do anything else to start using this basic functionality.

For objects with a hierarchy, add a NetworkTransform to every object whose position and rotation relative to its parent should be synchronised. If your game requires it, you can also enable localScale synchronisation by checking the Sync Scale option.

A very important aspect of synchronising objects and their hierarchies in games is managing parenting and changing the parent of an object. Some of the most common examples include a player character picking up an item and holding it in their hand, or a character entering a vehicle and moving with it. Usually, you handle such operations by changing the object hierarchy – nesting one object inside another. For instance, a seat in a vehicle becomes the parent of a player character’s object when you call playerTransform.SetParent(vehicleSeatTransform) and set the appropriate local position and rotation. Photon Fusion 2 also needs to correctly handle changes to the hierarchy so that the scene state on the Client matches that on the Host.

To explain how this works, let’s look at an example where you mount a weapon on a vehicle in a sample game. Below, you can see the hierarchy of a vehicle controlled by the player. The vehicle contains a nested structure of objects, and one of them is called Weapon Slot, marking the place on the roof where you can attach a weapon.

The weapon object is defined as a prefab consisting of a gun base and a barrel. Once mounted on the vehicle, the gun base can rotate relative to the vehicle, and the barrel can move up and down relative to the base.

How do you set up the hierarchy so that a call to basicGunTransform.SetParent(sportCar1Transform) works and replicates across all peers while still allowing the weapon to perform the movements described above? The key is the Sync Parent option, which you enable on the NetworkTransform component. Sync Parent works upwards – the component with this option enabled will synchronise the identifier of its parent object.

• Basic Gun: Add NetworkObject (as the root) and NetworkTransform with Sync Parent enabled. This object will be nested inside the Weapon Slot.
• Barrel Mount: Add NetworkTransform, but don’t enable Sync Parent. The hierarchy doesn’t change here, but the barrel still moves relative to the base.
• Sport Car 1: Add NetworkObject (root) and NetworkRigidbody3D (explained in the next section).
• Weapon Slot: Add NetworkTransform (without Sync Parent), even if its position and rotation won’t change relative to the vehicle. Each NetworkTransform has a unique NetworkTransformId, which Fusion 2 uses to identify the parent during synchronisation.

After this simple setup, with no code required, your objects are ready for logic like mounting weapons on vehicles. You can now focus on your game mechanics and let Fusion 2 handle the network replication.

NetworkRigidbody3D

NetworkRigidbody3D is part of the Physics add-on for Photon Fusion 2. You need to download and import this package separately (see the link). This component lets you synchronise Unity’s Rigidbody over the network. To control networked physics, you also need to add the RunnerSimulatePhysics3D component to the object with NetworkRunner. If you need a reminder, check the earlier article in this series – especially the part about the NetworkRunner component. RunnerSimulatePhysics3D lets you decide how Fusion 2 should work with Unity’s physics engine. Fusion takes Physics Authority, managing all calls to Physics.SyncTransforms() and Physics.Simulate(). The Physics Timing setting lets you choose if these calls run inside Fusion’s FixedUpdateNetwork loop or in Unity’s own Update or FixedUpdate methods.

You can configure exactly how the physics simulation runs on each client.

Key Client Physics Simulation Settings

• Disabled – By default, client-side simulation is turned off. Only the Host or Server simulates physics. Clients simply replicate object positions and rotations after the simulation. In this mode, Fusion does not call SyncTransforms(), so any interaction with physics objects won’t work on the client.
• Sync Transforms – In this mode, clients do not run a full physics simulation. However, Fusion calls SyncTransforms() every tick. This allows physics interactions to work as expected, because the physics engine always has the correct object positions, rotations and proper Rigidbody configurations.
• Simulate Forward – The client runs Simulate() for each forward tick. Players immediately see feedback from their actions, without waiting for the server. When the server’s authoritative state arrives, Fusion 2 corrects the local predicted state to match the server. If the difference is minor, you can interpolate smoothly to prevent sudden jumps.
• Simulate Always – This is the most accurate, but also the most performance-intensive mode. Fusion runs a local physics simulation for every forward tick and every resimulation. The Client’s state always stays as close as possible to the server.

Player Input

Players interact with the game by sending input. They move characters, drive vehicles, shoot, and use items. Each action generates input data, which players use to affect the game world. In a Host-Client topology, the Client cannot modify the game state directly. Clients only have InputAuthority; only Host holds StateAuthority. You need a system where Clients collect their input, send it to the Host, and the Host updates the game world. Then Photon Fusion 2 replicates these changes to all Clients.

Fusion 2 collects player input every simulation tick and sends it to the Host. Fusion supports client-side prediction. This feature lets the client instantly simulate the results of its own inputs, without waiting for the authoritative Host’s response. If the local prediction does not match the authoritative state from the Host, Fusion automatically rewinds the simulation and replays it with the correct data – a process called rollback and reconciliation. As a result, players experience smooth and responsive controls, even if there is a network delay.

NetworkInputData structure

Define a structure to store player input by implementing the INetworkInput interface. In the example shown below, the code uses the NetworkButtons structure to track which buttons the player presses. NetworkButtons makes it easy to check if a button is currently pressed, but it does not store previous states. If you need to compare the current and previous input values – such as detecting when a button is pressed, released, or held – you should store the previous state yourself.

How to read and use Input?

Use the OnInput method, part of the INetworkRunnerCallbacks interface, to collect input each simulation tick. Fusion calls this method on every tick. Avoid spreading input collection across many components. If you do, multiple OnInput calls can overwrite data. The best practice is to use a single component to aggregate all player input, so only one OnInput call runs per tick.

In the example above, OnInput collects vehicle controls, key presses, and mouse position for aiming. Store all collected input in NetworkInput with the Set method. If you call Set from multiple places without aggregating, input can be overwritten.

After Fusion 2 collects and synchronises player input, the Host uses it to update the game world. Unlike input collection, which should happen in only one place, you can process player input in as many systems as your game requires. For example, different gameplay systems – such as character control, weapon handling, or UI – can all read and use the same input data. You typically retrieve player input using the GetInput(…) method, which you call inside FixedUpdateNetwork().

For local co-op games, Photon Fusion 2 treats multiple local players as one peer. If two players share a device in split-screen, handle their inputs in your own structure. Design your input structure to separate each player’s data.

Object Spawning

Let’s look at a key multiplayer feature: spawning new networked objects. You’ll almost always need to create objects dynamically during gameplay. For example, when a character drops an item, throws a grenade, or crafts a potion and sets the flask on a table. All these objects need to be replicated across all clients in a multiplayer environment.

To make an object networked, you must register it with Photon Fusion 2. Never create these objects using GameObject.Instantiate(). That method only creates a local instance without a network connection. Always use NetworkRunner.Spawn(). This method creates a networked instance, assigns a unique ID, and ensures Fusion 2 replicates the object correctly for all Clients, even those that join the session after the creation.

When you call NetworkRunner.Spawn(), you must provide a prefab of type NetworkObject. You can also specify a position, rotation, or a PlayerRef to decide which player gets InputAuthority over the object.

Remember: the position and rotation you set affect only the local state on the side responsible for spawning the object – usually the Host or Server. To synchronise positions across all clients, use data synchronisation mechanisms such as NetworkTransform, as covered in the previous sections. The same principle applies if you want to parent the new object under another object.

NetworkRunner.Spawn() also accepts an OnBeforeSpawned callback, which runs just before the object is replicated. Use this callback to handle custom configuration.

Every NetworkBehaviour implements the ISpawned and IDespawned interfaces, which provide Spawned and Despawned methods. Override these methods to handle initialisation and cleanup, just like Unity’s Awake, Start, or Destroy.

If you need extra control, you can implement the IAfterSpawned interface. This gives you an AfterSpawned method, called immediately after the networked object is created. Fusion 2 calls these interface methods both for objects created at runtime and for any objects that already exist in the scene and have a networked representation.

Fusion calls the Spawned and Despawned methods on both the Host and Client. Both sides can execute logic as needed for your game. To find out if code is running on the Host or Client, check NetworkRunner.IsServer or NetworkRunner.IsClient, or use Object.HasStateAuthority and Object.HasInputAuthority to verify the object’s authority.

Keep in mind that Fusion calls OnBeforeSpawned exclusively on the Host. On the Client, Fusion only executes the Spawned and AfterSpawned methods. This distinction is important when you need to run pre-spawn configuration or custom logic. Make sure to implement it on the Host side.

Host

• OnBeforeSpawned callback from NetworkManager.Spawn(…).
• Spawned.
• AfterSpawned.

Client

• Spawned.
• AfterSpawned.

Summary and what’s next?

In previous articles, you created accounts, discovered the basics of networking topologies, the main use cases for Photon Fusion 2, and learned how to manage user sessions. If you missed any of these topics, be sure to check out the earlier posts in this series – they provide the foundation for everything covered here:
Photon Fusion 2 – Introduction – Part 1/4
Photon Fusion 2 – Sessions Management – Part 2/4

You’ve just learned the core techniques for data synchronisation in Photon Fusion 2: how authority works, how to use networked properties and RPCs, how to sync object transforms and physics, and how to handle player input for smooth gameplay. With these skills, you can now build reliable multiplayer features and keep your game state consistent for all players.

Next, you’ll take your project further by exploring advanced synchronisation strategies, optimising network performance, and managing session state and players. Stay tuned to unlock the full potential of Photon Fusion 2 and create seamless multiplayer experiences.

Continue reading: Photon Fusion 2 – Game Tutorial – Part 4/4.

The post Photon Fusion 2 – Data Synchronisation – Part 3/4 appeared first on The Knights of U.

Want to learn how to create, join, and manage multiplayer sessions in Photon Fusion 2? In this article, we’ll walk you through everything you need to know about working with sessions using the Host-Client topology. You’ll discover how to set up public, private, and password-protected sessions, use matchmaking effectively, and handle key callbacks such as OnConnectedToServer, OnSessionListUpdated, and OnConnectRequest. Whether you’re just starting out or looking to improve your session flow, this guide will give you a clear, practical foundation.

Introduction

In the previous post, we explored what Photon Fusion 2 is, what network topologies it supports, and what it’s generally capable of. You’ve already created your first project, configured the plugin inside Unity, and now you’re ready to start working on your first real multiplayer logic.

In this post, you’ll learn how to create new Photon Fusion 2 sessions, find and join existing ones, and even set up a private session protected by a password. You’ll become familiar with NetworkRunner, learn about its core configuration options, and explore essential session-management callbacks. We’ll be using the Host-Client topology throughout this post to keep things simple and cost-effective during the learning process. No need to worry about dedicated server infrastructure just yet.

Network Runner

Photon Engine documentation here: Network Runner.

Before diving into multiplayer logic with Photon Fusion 2 Sessions, you should first understand what the NetworkRunner actually is. At the heart of Fusion 2 is a mission to let developers focus on building gameplay, not on rewriting the same networking logic for every project.

NetworkRunner is the central component that represents a player-controlled peer in the game. It wraps most of the core multiplayer functionality, like session connection, matchmaking, input handling or spawning and despawning of objects into one user-friendly component. Simply put, it’s the most important part of the Fusion 2 system.

Most games use a single NetworkRunner in one app, but Fusion 2 also offers a more advanced multi-peer mode where multiple NetworkRunners can coexist in one app. We’ll stick to the single runner setup in this article.

The NetworkRunner is also responsible for regularly executing the FixedUpdateNetwork() and Render() methods, as well as invoking callbacks that notify about key events during connection setup, player joining, and general network communication.

Upon creation, the NetworkRunner automatically scans its child components in the hierarchy and registers any that inherit from SimulationBehaviour or implement the INetworkRunnerCallbacks interface.

If you want to register an INetworkRunnerCallbacks component that isn’t part of the NetworkRunner’s hierarchy at the time it’s created, you’ll need to call NetworkRunner.AddCallbacks(…) manually and pass in a reference to the target callback instance.

Creating NetworkRunner

There are three ways to create a NetworkRunner instance.

• Using a prefab. This approach allows you to preconfigure the NetworkRunner, add components for callback handling, or display debug data.
• Placing it directly in the scene. If your scene structure allows it, you can place a runner directly in the Unity Editor and reference it when needed.
• Creating it dynamically in code. You can instantiate a GameObject at runtime and add the NetworkRunner component via AddComponent().

Once you’ve got your NetworkRunner reference, you’re ready to start creating or joining sessions. But before we move on to that, let’s talk about GameMode and Callbacks Fusion 2 provides. These are essential for understanding how sessions work and for monitoring key multiplayer processes.

GameMode

In this section, we’ll revisit some familiar concepts from the previous post – but this time from a new perspective. While the previous article focused on Photon Fusion 2 network topologies and their pros and cons, here we’ll examine the same topic from the perspective of a single application. Photon needs to know whether the application is supposed to run as a Dedicated Server or a Client. This is what the GameMode is used for. What is important to point out is that topology limits the GameModes you can use. Let’s take a closer look at available options for each topology.

Host-Client

GameMode.Host is used for a player acting simultaneously as both the Server and a Client. GameMode.Client is used for players joining the host. Fusion 2 also offers a hybrid mode GameMode.AutoHostOrClient. It first tries to join an existing session as a Client. If none is found, a new session is started, and the player becomes the Host. It can simplify the code and testing as you can use one method to both create a session and join it.

Dedicated Server

GameMode.Server is used for the server. GameMode.Client is used for clients. Note that there is no auto mode.

Shared

There is only one mode for all of the clients – it is GameMode.Shared.

GameMode.Single

One of Fusion 2’s most practical features is its ability to run in Singleplayer mode with almost no changes to your existing multiplayer logic. If your multiplayer game is designed in a way that can function with just one player, Fusion makes it easy to support offline play.

All you have to do is start a session using GameMode.Single. This tells Fusion that the session will run entirely offline – no clients can join, and Photon Cloud services are disabled. The key benefit is that all the multiplayer systems – object spawning, state replication, event handling, simulation ticks – still work.

The player in this mode behaves exactly like a Host. They act as both the server and the client, but in a self-contained, local-only session.

Session Callbacks

Below is a list of callbacks from the INetworkRunnerCallbacks interface relevant to session management. While not every project will need to implement all of them, it’s useful to be aware of these options to better understand what Photon Fusion 2 provides.

• OnConnectedToServer(NetworkRunner runner). This callback is triggered when a connection to the server or host is successfully established. You can use it to initialise the game state or notify the player that the connection has succeeded.
• OnConnectFailed(NetworkRunner runner, NetAddress remoteAddress, NetConnectFailedReason reason). Triggered when a connection attempt to a server or host fails. It provides details about the target address and the failure reason, allowing the application to display error messages or retry the connection.
• OnConnectRequest(NetworkRunner runner, NetworkRunnerCallbackArgs.ConnectRequest request, byte[] token). Triggered when the server receives a connection request from a remote client. This allows you to validate the request and either accept or reject it, useful for implementing custom authentication or access control systems.
• OnDisconnectedFromServer(NetworkRunner runner). Triggered when the connection to the server or host is lost. You can use this to handle disconnection logic, such as saving progress, informing the player, or initiating a reconnection attempt.
• OnSessionListUpdated(NetworkRunner runner, List<SessionInfo> sessionList). Called when the Photon Cloud returns an updated list of visible and joinable sessions in the connected lobby. You can use this data to populate a session browser UI for players.
• OnShutdown(NetworkRunner runner, ShutdownReason shutdownReason). Triggered when the NetworkRunner is shutting down. It provides the reason for the shutdown and can be used to finalise the session, save progress, or clean up resources.
• OnCustomAuthenticationResponse(NetworkRunner runner, Dictionary<string, object> data). Called after receiving a response from the authentication server. You can use the returned data to configure the session, adjust permissions, or customise gameplay based on user identity.
• OnHostMigration(NetworkRunner runner, HostMigrationToken hostMigrationToken). Triggered when host migration begins, typically in Host-Client mode. It provides a migration token containing all necessary data to resume the session on a new host after a disconnection or crash.

To register callbacks, use NetworkRunner.AddCallbacks or the NetworkEvents component.

Create and Join Session

Create session

Let’s move on to your first real implementation – creating a session so others can join!

Photon Fusion 2 uses the NetworkRunner.StartGame(…) method to either create a new session or join an existing one, based on the parameters you provide. To create a new session, set the GameMode to Host.

This is a simple way to start a new session without providing any extra details. If you don’t set the PlayerCount parameter, Fusion 2 will use the default value from the config file located at:
Assets/Photon/Fusion/Resources/NetworkProjectConfig.fusion.

StartGameArgs

The StartGameArgs structure is used to provide data when creating or joining a session. Here are a few important parameters you should be aware of.

• SessionName – A custom name for your session. It must be unique within the region and serve as the session’s identifier. If left empty, Fusion will generate a GUID.
• SessionProperties – A list of key-value pairs used during matchmaking as filters.
• CustomLobbyName – By default, Fusion creates a separate lobby per GameMode. You can override this behaviour and define your own lobby names to organise different types of sessions.
• IsOpen – Determines whether new players can join the session. It can be changed after the session has started.
• IsVisible – Controls whether the session is visible in matchmaking. If set to false, the Matchmaker won’t assign players to it, and it won’t appear in public session lists. This can also be changed later.

Join the Session directly

The most direct way to join sessions in Photon Fusion 2 is by using a specific SessionName. In Fusion, the session name serves as a unique ID within the region and cannot be duplicated. When creating a session, you can define its name via the SessionName property in StartGameArgs. If left empty, a GUID will be automatically generated as the SessionName.

This approach is particularly useful for direct player invites. For example, you can create a private session and hide it from public matchmaking by setting StartGameArgs.IsVisible to false. Players can still join it by providing the correct SessionName.

Keep in mind that when a SessionName is specified, it overrides all matchmaking filters. For instance, if you define a map type in SessionProperties, the system ignores it when you join a session by SessionName.

In the example above, you call StartGame with GameMode set to Client, which means you join a session named “MyFirstSession” as a Client. If the session doesn’t exist or a connection error occurs, the StartGameResult will indicate the failure and include relevant error details.

Matchmaking

The most commonly recommended approach to joining sessions in Photon Fusion 2 is Matchmaking, which looks for an open session that hasn’t reached its player limit. If you use GameMode.AutoHostOrClient in StartGameArgs and no matching session exists, Photon Fusion 2 automatically creates a new one and makes the first player the Host.

Matchmaking in Fusion 2 can operate in one of three modes, each with different matching behaviour. You can configure this using StartGameArgs:

• FillRoom – The default mode. It fills up the oldest available sessions first to average out waiting times. This mode ignores SessionProperties filters.
• SerialMatching – Distributes players more evenly between sessions and respects the SessionProperties filters.
• RandomMatching – Selects sessions at random but also respects the SessionProperties filters.

Now, let’s explain what these SessionProperties are. Fusion 2 offers a basic matchmaking system that lets you define a set of key-value pairs. A session will only be matched if all the provided properties exactly match. You can use this to filter by game mode, map name, or similar parameters. However, this approach doesn’t support more advanced scenarios like ranking-based matchmaking or skill brackets. There’s no built-in support for range comparisons in parameters.

Matchmaking abuse

Photon Fusion 2 Matchmaking is client-driven. All matchmaking decisions are based solely on the data sent by the client looking to join. So if you plan to implement features like skill-based matchmaking, you’ll need to handle this on the client side – which opens the system up to potential tampering or abuse. Players can modify their request and claim that they belong to a different skill group.

If your Matchmaking needs to be secure and cannot rely blindly on the data from the Client, you should turn to external solutions like Unity Game Services. You can integrate their Matchmaking with their Cloud Code to run sensitive logic securely on the backend. The Client never accesses this logic or data. Only the final result comes back to it.

Lobby and Sessions List

The less-recommended way to join a session is manual session browsing. Player selects a session from a full list of all available sessions in a region.

Before diving into how this works, let’s first define what a Region is. Photon Cloud sets up Regions as physical data center locations around the world to group player traffic locally and minimise latency. As of writing, Photon supports 16 regions, such as “eu” (Europe, hosted in Amsterdam) or “us” (US West, hosted in Washington).

Fusion 2 supports both automatic region selection – based on player location – and manual selection when needed.

A Lobby is a virtual container within a Region that groups active game sessions. When creating a session, you can assign it to a named Lobby. Within a Lobby, players cannot see each other, and there’s no communication or visibility of who else is present.

If you want players to manually browse and select from a list of sessions, they must first join a specific Lobby. You can join the default lobby for Client-Server mode using the following code:

After successfully joining a Lobby, any session updates within that Lobby will trigger the OnSessionListUpdated method from INetworkRunnerCallbacks. The sessionList parameter will provide information about all visible sessions. You can use this data to display a custom session browser in your UI and allow players to join a session of their choice.

Issues when using the Sessions List

This method generates significant network traffic. Every change in a session’s parameters triggers updates to all connected clients. Photon officially discourages this pattern and considers it legacy. Still, if your game requires advanced session filtering on the client side, this remains the only viable method.

Security warning: All matchmaking and filtering logic in this model happens on the client side. Without a proper backend to validate data, you are exposed to potential manipulation, e.g. Client joining a session that should not be available to them.

Private Session or Password-Protected Session

One important and sometimes overlooked topic in Photon Fusion 2 is how to create private sessions or sessions protected by a password.

Session IsVisible

A private session is one where the IsVisible flag is set to false. This means the session will not be visible to the Matchmaker or listed in the OnSessionListUpdated callback. The only way to join it is by specifying its exact name in the SessionName field of StartGameArgs. If the name matches, the session is open (IsOpen), and there are free slots, the connection will be accepted. Otherwise, the join request will be refused.

ConnectionToken

You may want to protect your session with a password. Fusion 2 does not natively support password-protected sessions, so this requires a manual approach. The only tools available for this are the SessionProperties dictionary and the ConnectionToken field. The Connection Token is a byte array in StartGameArgs. It can be set by the client and then sent to the Host/Server when a connection is attempted.

The Client can send the password to the Host using the ConnectionToken. Never store sensitive data like access passwords in SessionProperties, since all Clients can read and manipulate that data. The Host/ Server must always verify the password to ensure secure validation. If the Client handles the verification, the system loses all reliability. A malicious Client could always claim that the password is correct, completely bypassing your intended access control.

The Host triggers the OnConnectRequest callback when a player attempts to join a session. The Host can verify the password using the ConnectionToken and decide whether to accept or refuse the connection.

How can I tell if a session is password-protected?

This approach works reliably, but it only helps if the Client already knows that the session requires a password. Since there is no built-in password system, the application cannot automatically prompt for that information. The only way to communicate this is by adding a custom field like HasPassword to the SessionProperties. You can use this to display a lock icon in the session list or trigger a password prompt when the player tries to join.

The main downside is that the Client must have access to this session metadata in advance. Even if the app doesn’t show the session list in the UI, the Client must fetch session data to check whether it should ask for a password. To enable this, the session must remain visible by setting IsVisible to true. Otherwise, the Client can only join by name and can’t detect if the session requires a password.

In such cases, your only option is to show a pop-up asking the player to enter a session name and, optionally, a password. You can include a note telling players they need a password only if the session requires one. However, this information must come from an external source. When the session is not visible, the Client app cannot detect it automatically.

Summary and What’s Next?

In the previous article of this series, we introduced Photon Fusion 2 and the network topologies it supports. Also, we discussed how to choose the right one for your game. Now you know how to set up a project ready for multiplayer development. If you missed it, you can read it here: Photon Fusion 2 – Introduction – Part 1/4.

In this post, you learned how to manage multiplayer sessions using the Host-Client model. We covered the basics of creating and joining sessions, matchmaking modes, and configuring public, private, and password-protected sessions. You also became familiar with the most important callbacks from the Fusion API that relate to the connection and session lifecycle.

Now that you know how to establish and control a multiplayer session, it’s time to move on to the next key topic: data synchronisation. In the next article, we’ll explore how Fusion 2 replicates game state between clients. You’ll learn about synchronisation components, remote procedure calls (RPCs), handling player input, and how to structure your networked properties for efficient replication.

Continue reading: Photon Fusion 2 – Data Synchronisation – Part 3/4.

The post Photon Fusion 2 – Sessions Management – Part 2/4 appeared first on The Knights of U.

Introduction

In this series of posts, I’ll guide you step-by-step through setting up your project with Photon Fusion 2, creating and managing sessions, and synchronising objects and variables across your scenes. You’ll learn the basics of matchmaking and private sessions. You’ll see how Fusion manages scene loading and spawning objects, configure and call your first RPCs, and become familiar with key concepts such as State Authority and Input Authority.

For this guide, we’ll focus exclusively on the Host-Client architecture, where one player (the Host) acts as the game server. We will also discuss other Fusion architectures.

In this first post, we’ll talk about what Photon Fusion 2 is, when and why you’d want to use it, and highlight its pros and cons. I’ll walk you through setting up your first Fusion 2 project and integrating it with Unity. Afterwards, we’ll touch on the Network Topologies supported by Fusion 2 and briefly discuss their main characteristics.

Photon Fusion 2

Photon Fusion 2 is a high-level, high-performance solution designed to add multiplayer functionality to Unity games. It’s built with simplicity in mind and doesn’t require extensive low-level networking knowledge to start. Fusion 2 focuses heavily on synchronising game state, employing a variety of techniques you’ll explore in depth throughout this series.

Additionally, Fusion 2 supports advanced networking features such as Lag Compensation, Rollback, and Area of Interest. It seamlessly handles various network topologies.

Fusion 2 integrates smoothly with third-party hosting solutions like Unity Game Services and Unity Multiplay. It also provides built-in basic matchmaking capabilities, but doesn’t include typical backend services like player accounts, leaderboards, databases, or cloud code execution.

This makes Fusion 2 ideal for rapid prototyping, gameplay testing, and multiplayer development for both small and large projects. However, it’s important to remember that Fusion 2 integrates closely with your game’s logic, which can complicate transitioning to another networking solution later.

Photon Fusion 2 offers a highly developer-friendly experience, complete with detailed documentation and numerous sample projects, helping you understand and incorporate best practices directly into your game.

Photon Fusion 2 Pre-Requirements

At the time of writing this post, the latest Photon Fusion 2 SDK is 2.0.12 Stable Build 1861, released March 19, 2026. The minimum Unity version required for Photon Fusion 2 is 2021.3.45/2022.3.x/6.0.x or newer.

In the Project Setup chapter, you’ll learn how to create a new Photon Fusion 2 project and set up all the packages you’ll need to start working. Everything covered in this post is based on free solutions – you’ll need to create a Photon account, but it’s completely free.

Check out the latest Photon Fusion 2 release and release notes here.

Photon Fusion 2 Project Setup

Photon Dashboard

To start your adventure with Fusion 2, you’ll first need a Photon Engine account to set up a dedicated project for your game. If you don’t have an account yet, click this link and create one. If you already have one, head over to the Photon Dashboard and set up your first Fusion 2 application to get started!

Next, click CREATE A NEW APP to create your new application. Fill out the brief form by selecting the recommended Fusion SDK version 2, give your application a name, optionally provide a description and a website link, then click CREATE.

Your application will appear in the Applications / Public Cloud section. Right now, the most important detail for you is your application’s App ID, which you can copy by clicking on the App ID field on your app’s tile. Your app is currently on the free plan, with a limit of 20 CCU (Concurrently Connected Users). You can read more about CCU and Photon subscriptions here, but we won’t dive deeper into those topics in this post.

Unity Project

We’re now ready to create a new Unity project and integrate the Fusion 2 SDK. Download the latest Fusion 2.unitypackage from this link, and import it into Unity via the Assets → Import Package → Custom Package menu. After a successful import, you should see the Photon Fusion 2 Hub, your main management panel. If it doesn’t pop up automatically, you can always find it in the top menu at Tools → Fusion → Fusion Hub.

The Photon Fusion 2 Hub lets you manage the plugin’s configuration. Under the Fusion 2 Setup tab, you’ll find scriptable objects for configuring detailed connection and data-transfer settings. Photon’s default settings are usually good enough for most scenarios, but if you’re curious about advanced options, you can explore them in the documentation here.

At this point, paste the App ID generated earlier from the Dashboard into the appropriate field. If the App ID you’ve pasted is valid, the icon will switch from red to green. Now you’re fully set up and ready to dive into Fusion 2!

Your project setup is now complete. Before we jump into the technical details and start implementing, let’s go over the network topologies available in Fusion 2. It’s important to understand these concepts because choosing the right approach is critical for your project. Making the wrong choice here might become very expensive to correct later on.

Supported Network Topologies

You’re ready to create your first multiplayer game – exciting, right? But remember, you have some important decisions to make first, including choosing the right Network Topology. Let’s go through the three network topologies in Photon Fusion 2, highlight their pros and cons, and help you pick the right one for your project.

You may ask – what is a network topology? It is simply an organised structure of elements that can communicate with each other over the network. It can describe their physical arrangement and, what is more important to us here, it can also describe the hierarchy of those elements, their responsibilities, and the way they communicate with each other. You may have also seen the term Network Architecture. While not exactly the same, it is quite similar. Here, I use the term Network Topology to avoid confusion with the Photon Fusion 2 documentation.

In this series of posts, we won’t dive deeply into basic networking concepts like communication protocols, connection setup, NAT, IP, or data serialisation. As mentioned earlier, Photon Fusion 2 is a high-level solution designed to give you a reliable and efficient framework. You can focus on developing game features instead of dealing with low-level networking details.

When thinking about multiplayer games, the first word that probably comes to mind is “Server”. That’s good – Servers are critical to multiplayer systems, though not always strictly necessary. For simplicity’s sake, when we say “Server” here, we mean a Game Server.

Dedicated Server

The first topology we’ll cover is the Dedicated Server. This is usually what players imagine when thinking about multiplayer and “connecting to a server”. A Dedicated Server is a physical machine or a cloud-hosted virtual machine running your Game Session. Players – known as Clients – connect to this server to join the game. While this topology is powerful and comprehensive, its major downside is the relatively high maintenance cost.

The basic concept behind this topology is that the entire game runs securely on the Dedicated Server, while Clients send inputs to control their actions in the game. The Server holds State Authority, meaning it exclusively manages game-state changes, data synchronisation, and object updates. Clients have Input Authority – they can request the Server to execute actions like moving characters, picking up items, driving vehicles, or firing weapons, but cannot modify the game state. They can only change the local state, but none of the other players will be affected by it.

Dedicated servers are usually managed and paid for by the developer/publisher. They can also be hosted by the players themselves if the game supports it. This transfers the cost of maintenance to users and gives them more freedom, like the possibility to mod the game. The disadvantage is that you need to be an advanced player to be able to set up the server correctly.

Pros:

• Full Server Authority: The server fully controls the game state, significantly reducing cheating and malicious activity.
• High Stability: Server hosting from reputable providers is reliable and comes with solid technical support.
• Easy Scalability: Easily scales up to handle more players and sessions if your game becomes popular.
• Independent of Client Hardware Performance: Gameplay performance and quality don’t depend on player hardware.
• Simple Game Management: Easy deployment of server updates without always needing client-side updates, making balancing and testing easier.
• Regional Hosting: Hosting servers across multiple regions helps reduce latency and evenly distribute traffic.
• Wide range of games supported: Server can run even when there is no player currently connected, which can support gameplay that may not be possible otherwise.

Cons:

• High Costs: Dedicated server hosting is usually expensive and might not be available for smaller projects.
• Technical Complexity: Requires more expertise for proper configuration and management.

Host-Client

If a Dedicated Server is too costly or impractical for your project, you should consider the Host-Client topology. In this setup, one player (typically the first one) serves as the Host, acting simultaneously as both the Server and a Client. Usually, this player initiates the session, creates a game, and waits for or invites other players to join.

The Host holds full State Authority, giving them considerable control and potentially enabling them to cheat. Other Clients have only Input Authority, similar to Clients in a Dedicated Server scenario. This topology is best suited for smaller-scale projects with short sessions involving a few players. Keep in mind that if the Host disconnects or crashes, the session will be terminated immediately unless Host Migration is implemented.

A significant advantage of the Host-Client model is its simplicity. It enables rapid prototyping and iteration. It’s easy to set up, doesn’t require advanced hosting services or additional server infrastructure.

What may come as a surprise is that an additional server, called a relay server, may still be required. While the exact reasons for that are out of the scope of this blog, it turns out that it is not that simple to establish a direct connection between two players. If you are interested, you can read more by searching for the NAT traversal problem. All you need to know is that you don’t have to worry about such a server; Photon Fusion 2 does it for you.

Pros:

• Low Operational Costs: No dedicated server needed, drastically reducing costs.
• Ease of Implementation: Quick to set up, ideal for rapid development.
• Suitable for Non-competitive Games: Excellent for sessions with friends, co-op or casual multiplayer experiences.

Cons:

• Potential Cheating: Host has significant control, allowing him to easily cheat.
• Poor for Mobile Games: Host device limitations and mobile network throughput can negatively affect performance for all clients.
• Unequal Latency: Host experiences zero lag compared to Clients. It gives him an advantage that could be considered unfair.
• Limited Scalability: Performance is tied directly to the host’s hardware and can’t handle as many players or as complex simulation as a dedicated server.

When designing your game, you’ll likely have to choose whether it supports single-player, multiplayer, or both. Initially, this decision may seem straightforward since your game’s concept usually dictates whether it supports solo play or multiple players competing or cooperating. However, upon closer inspection, many games benefit significantly from offering both modes.

For instance, you might want a strong narrative focus best suited to single-player, or you might include a tutorial that guides players through game mechanics step-by-step. Another consideration is player base size – if your game is new and still growing, multiplayer matchmaking may suffer, discouraging players with long wait times. Offering a single-player alternative can help address this issue.

The Host-Client topology readily supports single-player modes. Fusion 2 is built in such a way that it’s simple to start a single-player session without an internet connection. From a developer’s point of view, this single-player session functions almost identically to a multiplayer session hosted by a player, just without additional clients joining.

Shared

The Shared topology is a decentralised networking model where no single player acts as a Host. Instead, each player has State Authority over the objects they create. By default, a player owns and controls any objects they spawn.

One of the core features of this model is the ability to dynamically transfer State Authority, though only the current authority holder can initiate the transfer. The system also introduces a special role called the SharedModeMasterClient – typically the first player to join a session. This player receives State Authority over all scene objects present at the start (unless reassigned), manages scene loading across all clients, and can despawn objects not owned by anyone. It might seem similar to a host, but here this player has fewer privileges and responsibilities.

In Shared mode, inputs are applied instantly and locally, and only the resulting changes are synchronised. This results in zero input lag and a responsive player experience, but at the cost of reduced predictability when both players interact. Additionally, this topology is highly resilient. By default, if one player disconnects, it doesn’t affect the rest of the session (though some games may not be able to continue due to their design). There’s no central failure point as with Host or Dedicated Server models.

Another strength of the Shared mode is load balancing. By reassigning State Authority, developers can ensure that weaker devices simulate fewer objects, while more capable machines handle more.

However, the biggest trade-off is security. This topology is extremely vulnerable to cheating. Any player with authority over an object can modify it without any restriction. As such, it is only recommended for non-competitive games, preferably those played with friends or in trusted environments.

Pros:

• Low cost: No dedicated server required.
• Zero input lag: Input is applied instantly on the local machine.
• Quick setup: Easy to prototype multiplayer functionality.
• Flexible authority management: State Authority can be transferred dynamically.
• Fault-tolerant: No single point of failure.
• For casual games: Ideal for casual, co-op games and internal development/testing.

Cons:

• Higher network traffic: Especially in sessions with many players.
• Completely insecure: Easy for any player to cheat.
• Not for competitive games: Due to the cheating, it is unsuitable for competitive environments.

Photon Fusion 2 Topologies – how to choose the correct one?

By now, you understand the essentials of different Photon Fusion 2 topologies. You’ve also learned how crucial choosing the right topology is, and why carefully weighing your decision early can save you significant effort and costs down the road. The later you make changes, the higher the costs. To help guide your decision-making, consider these important questions:

• What gameplay modes will your game support?
• Is your game competitive?
• Is preventing cheating a top priority for your game?
• Does your game require a continuously simulated world that operates independently of player presence?
• Is your game performance-intensive on player devices or on the network throughput?
• Can you handle the complexities and costs associated with running a Dedicated Server?
• Do you want players to be able to host their own dedicated servers?

Keep these key considerations in mind as you plan your game’s architecture. Consider structuring your core gameplay logic to easily support both multiplayer and single-player modes. Photon Fusion 2 offers built-in support for designing logic that’s reusable across multiple game modes.

Summary and What’s Next?

In this first article of the series, you’ve learned what Photon Fusion 2 is all about, created your Photon account, and set up your project in the Photon Dashboard and Unity. You’re now equipped with essential knowledge about available network topologies and ready to start building!

In the next article, we’ll explore how to create sessions and connect players using the Host-Client topology.

Continue reading: Photon Fusion 2 – Sessions Management – Part 2/4.

The post Photon Fusion 2 – Introduction – Part 1/4 appeared first on The Knights of U.

Contents:

1. Explaining how the effect works by this point.
2. Explaining shadowcasting technique.
3. Implementing shadowcasting to modulate the effect.

How the effect works

The effect was implemented in the deferred rendering path by modifying the GBuffer contents before the lighting was calculated. The effect reduces the albedo and GI and then increases the smoothness to mimic the wet look.

This is how the lighting initially worked: Unity was rendering a GBuffer, which was then used by the lighting algorithm to produce a color buffer.

The rain atmosphere effect works by modifying a GBuffer just before the Deferred Lighting pass. It copies GBuffer content using theInitializeRainResources node, and then creates a shared resource RainResourceData that holds copy of the GBuffer.

ApplyRainAtmosphere modifies the original GBuffer to increase smoothness and reduce global illumination and albedo, making surfaces appear more wet. The effect is applied using a full-screen shader, similar to a post-processing effect.

Shadowcasting technique

I want to modify the effect to make the surfaces look dry when they are under any cover. I want to use the shadowcasting technique for that.

Classic shadowcasting works by rendering the depth of the scene from the light point-of-view. This depth texture rendered by the light is called Shadowmap. Then, the lighting algorithm compares the rendered surface distance to the light with the distance saved in the depth rendered by the light to calculate the shadow.

In my case, I like to interpret the falling rain as a directional light that emits “wetness” instead of light. Let’s see how we can implement that using this image.

1. Rendering depth from the light point-of-view

I will place the camera at the light source. This camera will render a depth-only scene. The created texture is called a shadowmap.

2. The lighting algorithm uses shadowmap to estimate shadow

The lighting algorithm uses the shadowmap to calculate the shadows when rendering with the main camera.

When calculating the lighting for any surface, the algorithm compares the distance to the light source with the distance saved in the shadowmap.

If the distance to the light source is smaller or close to the distance saved in the shadowmap – there is no shadow.

Furthermore, when the distance from the surface to the light is larger than the distance saved in the shadowmap – there is a shadow.

To make this technique possible, we need a way to convert world space position into shadowmap UV. This can be done using the view and projection matrices of the camera that was used to render the shadowmap.

However, if we do this in the postprocess, we need to reconstruct the world space position from the main camera’s depth buffer because the world space position is not stored within the GBuffer.

Implementing shadowcasting to modulate the rain effect

To implement the shadowcasting, I need to get this data into the shader that applies the effect:

1. Main camera depth buffer – to reconstruct world space position from depth.
2. View and projection matrices used to render the camera – used to convert world space position into shadowmap UV
3. Shadowmap texture.

I will divide the implementation into a few steps:

1. Configuring a camera that will render a shadowmap.
2. Modifying the render feature – forwarding the rendered shadowmap into the shader.
3. Implement shadowcasting in the shader.

1. Configuring shadowmap camera

I created a new camera and placed it on the scene. I set the camera to render orthographic and made it render top-down, capturing most of the scene.

Then I created a RainCamera component. This component is responsible for creating a shadowmap texture and assigning it to the camera.

The component creates a shadowmap texture using a depth-only texture format. Then, it renders the camera into the shadow map and saves the parameters for further use in the render feature.

The RainCameraParameters will be used in the render feature to render the effect.

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Experimental.Rendering;

[RequireComponent(typeof(Camera))]
[ExecuteAlways]
public class RainCamera : MonoBehaviour
{
    // Keeping track of all created instances.
    public static List<RainCamera> AllInstances { get; private set; } = new();

    // Main instance - last registered one.
    public static RainCamera MainInstance => AllInstances.LastOrDefault();

    // All parameters that define the shadowmap. Those will be used in the render feature.
    public RainCameraParameters Parameters { get; private set; }

    private void OnEnable()
    {
        // Registering the new instance.
        AllInstances.Add(this);

        // Create a shadowmap texture
        RenderTexture ShadowmapTexture = new RenderTexture(1024, 1024, GraphicsFormat.None, GraphicsFormat.D32_SFloat, 0);
        ShadowmapTexture.name = $"{gameObject.name}_ShadowmapTexture"; // Assigning the name makes debugging easier.

        // Render the shadowmap
        var camera = GetComponent<Camera>();
        camera.targetTexture = ShadowmapTexture;
        camera.Render();

        // I'm assuming that the rendered environment is static, so the camera can be disabled after the first render.
        camera.enabled = false; 

        // Save parameters of the shadowmap. Those will be used in the render feature.
        Parameters = new RainCameraParameters()
        {
            // Matrices are required to read and convert the world space position to the UV of the shadowmap.
            worldToCameraMatrix = camera.worldToCameraMatrix,
            projectionMatrix = camera.nonJitteredProjectionMatrix,

            // Shadowmap will be sampled in the shader.
            shadowmapTexture = ShadowmapTexture,
        };
    }

    private void OnDisable()
    {
        // Unregistering the instance.
        AllInstances.Remove(this);

        // Release resources allocated in the OnEnable method.
        Parameters.shadowmapTexture.Release();
    }
}

// All parameters that define the rain camera. 
public struct RainCameraParameters
{
    public Matrix4x4 worldToCameraMatrix;
    public Matrix4x4 projectionMatrix;
    public RenderTexture shadowmapTexture;
}

I assigned the component to the created camera. I used a Frame Debugger to see if the shadowmap texture renders properly. After enabling the camera in the inspector, the shadowmap looks correct in the FrameDebugger.

2. Modifying the render feature

Now, I need to find a way to bind this shadowmap and camera depth buffer to the shader that renders the effect.

Initialy I used InitializeRainResourcesPass to prepare all the resources used by the effect, so it looks like a perfect place to set shadowmap parameters.

RainResourceData is a class that shares all the resources of the effect with other passes. I decided to add a shadowmap parameters here.

public class RainResourceData : ContextItem
{
    public TextureHandle normalSmoothnessTexture { get; internal set; }

    // Added shadowmap camera parameters here.
    public RainCameraParameters? rainCameraParameters { get; internal set; } = null;

    public override void Reset()
    {
        normalSmoothnessTexture = TextureHandle.nullHandle;

        // Resetting it here.
        rainCameraParameters = null;
    }
}

If the RainCamera component is present on a scene, I set the parameters for other passes.

public class InitializeRainResourcesPass : ScriptableRenderPass
{
...
    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
    {
        RainResourceData rainResources = frameData.GetOrCreate<RainResourceData>();

        var urpResources = frameData.Get<UniversalResourceData>();
        var gBuffer = urpResources.gBuffer;

        if (gBuffer == null || gBuffer.Length == 0 || gBuffer[0].Equals(TextureHandle.nullHandle))
            return;

        rainResources.normalSmoothnessTexture = renderGraph.CreateTexture(gBuffer[2].GetDescriptor(renderGraph));

        // If a rain camera is present, share its parameters with other passes.
        RainCamera mainRainCamera = RainCamera.MainInstance;
        if (mainRainCamera != null)
            rainResources.rainCameraParameters = mainRainCamera.Parameters;

        using (var builder = renderGraph.AddRasterRenderPass(GetType().Name, out PassData passData))
        {
...

Then I moved to the ApplyRainAtmospherePass, where all rendering is implemented. I need to do two things here:

• Forward the shadowmap parameters to the shader.
• Forward the camera depth buffer to the shader.

I modified the PassData that stores resources used in the render function.

internal class PassData
{
	internal Material material;
	internal TextureHandle gBuffer2;

	// Added camera depth handle to use it in the render function.
	internal TextureHandle cameraDepthTexture;

	// Added shadowmap parameters to use it in the render function.
	internal RainCameraParameters? rainCameraParameters;
}

Then, I modified the render pass that applies the rain effect. I accessed the shared resources and forwarded them into the render function. I marked new lines using comments.

    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
    {
        UniversalResourceData urpResources = frameData.Get<UniversalResourceData>();
        TextureHandle[] gBuffer = urpResources.gBuffer;

        // Accessing the active depth buffer from the camera
        TextureHandle depthBuffer = urpResources.activeDepthTexture;

        if (gBuffer == null || gBuffer.Length == 0 || gBuffer[0].Equals(TextureHandle.nullHandle))
            return;

        RainResourceData rainResources = frameData.Get<RainResourceData>();

        using (var builder = renderGraph.AddRasterRenderPass(GetType().Name, out PassData passData))
        {
            builder.UseTexture(rainResources.normalSmoothnessTexture);

            // Declare the usage of the depth buffer to avoid render graph resource stripping.
            // Shadowmap is always present in the memory, so it's usage doesn't need to be declared.
            builder.UseTexture(depthBuffer);

            passData.gBuffer2 = rainResources.normalSmoothnessTexture;
            passData.material = material;

            // Forwarding camera's depth texture to the render function;
            passData.cameraDepthTexture = depthBuffer;

            // Forwarding rain camera parameters to the render function
            passData.rainCameraParameters = rainResources.rainCameraParameters;

            for (int i = 0; i < gBuffer.Length; i++)
                builder.SetRenderAttachment(gBuffer[i], i, AccessFlags.Write);

            builder.SetRenderFunc((PassData passData, RasterGraphContext context) => RenderFunction(passData, context));
        }
    }

Then, I modified the render function to set all the resources in the shader. I used MaterialPropertyBlock from the render graph pool.

_CameraDepthTexture – Game camera’s depth texture
_RainCamera_Shadowmap – Rendered shadowmap
_RainCamera_MatrixV, _RainCamera_MatrixP – view and projection matrices of the camera that rendered a shadowmap (required to convert world space position to shadowmap UV).

public static class Uniforms
{
    internal static readonly int _GBuffer2 = Shader.PropertyToID(nameof(_GBuffer2));

    // I added those uniform constants.
    internal static readonly int _CameraDepthTexture = Shader.PropertyToID(nameof(_CameraDepthTexture));
    internal static readonly int _RainCamera_Shadowmap = Shader.PropertyToID(nameof(_RainCamera_Shadowmap));
    internal static readonly int _RainCamera_MatrixV = Shader.PropertyToID(nameof(_RainCamera_MatrixV));
    internal static readonly int _RainCamera_MatrixP = Shader.PropertyToID(nameof(_RainCamera_MatrixP));
}

private static void RenderFunction(PassData passData, RasterGraphContext context)
{
	MaterialPropertyBlock propertyBlock = context.renderGraphPool.GetTempMaterialPropertyBlock();
	propertyBlock.SetTexture(Uniforms._GBuffer2, passData.gBuffer2);

	// Setting camera depth buffer.
	propertyBlock.SetTexture(Uniforms._CameraDepthTexture, passData.cameraDepthTexture);

	// If a rain camera exists, set up shader uniforms.
	if (passData.rainCameraParameters.HasValue)
	{
		propertyBlock.SetTexture(Uniforms._RainCamera_Shadowmap, passData.rainCameraParameters.Value.shadowmapTexture);
		propertyBlock.SetMatrix(Uniforms._RainCamera_MatrixV, passData.rainCameraParameters.Value.worldToCameraMatrix);
		Matrix4x4 projectionMatrix = GL.GetGPUProjectionMatrix(passData.rainCameraParameters.Value.projectionMatrix, true);
		propertyBlock.SetMatrix(Uniforms._RainCamera_MatrixP, projectionMatrix);
	}
	else
	{
		// Otherwise, if the rain camera is not present, set all uniforms to default
		propertyBlock.SetTexture(Uniforms._RainCamera_Shadowmap, context.defaultResources.defaultShadowTexture);
		propertyBlock.SetMatrix(Uniforms._RainCamera_MatrixV, Matrix4x4.identity);
		propertyBlock.SetMatrix(Uniforms._RainCamera_MatrixP, Matrix4x4.identity);
	}

	context.cmd.DrawProcedural(Matrix4x4.identity, passData.material, 0, MeshTopology.Triangles, 6, 1, propertyBlock);
}

3. Implementing shadowcasting in the shader

After all the required matrices and textures are forwarded to the, I need to implement the shadowcasting inside the shader. There are a few steps to be done:

1. Declare all resources and uniforms in the shader.
2. Reconstruct world space position from the depth buffer.
3. Calculate shadowmap UV from the world space position.
4. Calculate the rain-camera depth value using the world space position.
5. Compare the calculated depth with the value in the shadowmap.

3.2 Reconstruct world space position from the depth buffer

Now, I need to get the world space position that I could use in the shadowcasting algorithm. Because GBuffer doesn’t contain world space position, I need to derive it from the value in the depth buffer.

The goal is to sample a raw depth buffer value. Then, I will reconstruct the clip space position of the game camera using the screen UV and this raw depth value. Clip space position can be converted into a world space position using the inversed view-projection matrices.

This is how I read the depth value from the depth buffer.

// Get raw depth buffer value
float rawScreenDepth = _CameraDepthTexture.SampleLevel(pointClampSampler, IN_uv, 0.0f).r;

Then I can reconstruct the clip space position using the UV and the raw depth value.

The screen UV range is from [0,1], and clip space XY is in [-1,1]. I just need to remap it to [-1, 1] and set the Z value to the sampled depth.

// Reconstructing Clip Space position from UV and raw depth.
float4 positionCS = float4((IN_uv.xy * 2.0 - 1.0), rawScreenDepth, 1.0);
#if UNITY_UV_STARTS_AT_TOP
	positionCS.y *= -1.0; // Some rendering APIs invert the Y axis in Unity.
#endif

Next, I need to convert the clip space position into a world space position. Usually, vertex shaders use a View-Projection matrix to convert a world space position into clip space, so I can use an inversed View-Projection matrix to flip the transformation. Unity stores the inversed view-projection matrix in the UNITY_MATRIX_I_VP.

// Use an inversed view-projection matrix to transform CS into WS.
float4 positionWS = mul(UNITY_MATRIX_I_VP, positionCS); 
positionWS /= positionWS.w; // The final value is not normalized. I normalize it by dividing it by the W component.

When making such changes, I like to print the results on the screen using just an emission buffer. It is helpful for me to see if the depth data is sampled properly or if the reconstructed position WS is correct.

OUT_GBuffer0.rgba = 0.0;
OUT_GBuffer2.rgba = 0.0;
OUT_GBuffer3.rgb = frac(positionWS.xyz); // Display position WS

// Or 

OUT_GBuffer3.rgba = rawScreenDepth * 200.0; // Display raw depth, rescaled to actually see some of the values on the screen

3.3 Calculate shadowmap UV from the world space position

Now, I can use the world space position to calculate the UV of the shadowmap. I will use the view and projection matrix of the rain-camera to calculate the clip space position.

float4 rainPositionVS = mul(_RainCamera_MatrixV, positionWS); // Convert world space to shadowmap camera view
float4 rainPositionCS = mul(_RainCamera_MatrixP, rainPositionVS); // Convert shadowmap camera view space to shadowmap clip space
rainPositionCS /= rainPositionCS.w; // Normalize the clip space to [-1, 1] values (NDC)

float2 rainUV = rainPositionCS.xy * 0.5 + 0.5; // Remap clip-space to shadowmap UV.
#if UNITY_UV_STARTS_AT_TOP
	rainUV.y = 1.0 - rainUV.y; // And flip UV.y if I'm in Australia
#endif

Again, to check if everything went correctly, I printed UV to the emission buffer:

It appears that the shadowmap UV displays properly.

3.4 Calculate rain-camera depth and sample shadowmap

It is the right time to sample the shadowmap and calculate the rain-camera depth value for the surface.

I can sample the shadowmap using the calculated UV:

float rawRainDepth = _RainCamera_DepthTexture.SampleLevel(linearClampSampler, sampleUV, 0.0f).r;

And when printed to the screen, it looks correct:

I need to get the rain-camera depth value for the surface using the world space position, but…

…it is actually the Z value of the rain camera clip space. I can just use that because it is already calculated.

float surfaceRainDepth = rainPositionCS.z;

3.5. Calculating the shadow

It’s time to compare the calculated depth value with the value read from the shadowmap. If the calculated value is smaller than the value in the shadowmap, there is a shadow.

However, the values in the shadow map are quantized and not perfect. I need to apply some offset to reduce artifacts. I tested a few different offsets, and 0.002 works fine. Later, I could polish the effect and calculate this offset on the fly instead of hardcoding it, but right now, it’s fine.

The offset should depend on the rain-camera render distance and depth encoding.

float shadowMultiplier = 1.0;
if (surfaceRainDepth < rawRainDepth - 0.002)
	shadowMultiplier = 0.0;

I used the calculated shadowMultiplier to modify the effect strength.

// Effect strength is now modulated by the calculated shadow multiplier
float effectStrength = _EffectStrength * shadowMultiplier;

float4 rawGBuffer2 = _GBuffer2.SampleLevel(pointClampSampler, IN_uv, 0.0);
rawGBuffer2.a = lerp(rawGBuffer2.a, min(_SmoothnessMax, rawGBuffer2.a + _SmoothnessAdd), effectStrength);

OUT_GBuffer0 = float4((float3)lerp(1.0, _AlbedoMultiplier, effectStrength), 1.0);
OUT_GBuffer2 = rawGBuffer2;
OUT_GBuffer3 = float4((float3)lerp(1.0, _AmbientLightMultiplier, effectStrength), 1.0);

The problem is that the calculated shadowmask is super sharp. The transition between dry and wet surfaces appears too obvious. It will be nice to blur it a little.

I will implement blurring by sampling many shadowmap samples from the nearby UVs and calculating the average shadow multiplier from those.

I will use a kernel to sample a shadowmap a few times from different positions, and then I will calculate the average shadow mask value from all those samples. The sampling kernel is an array of offsets that should be applied to UV before sampling.

I asked ChatGPT to generate a sampling kernel with 16 points with Poisson-Disk distribution. I decided to use this kernel and placed it above the fragment shader:

static const int poissonDiskCount = 16;

static const float2 poissonDisk[poissonDiskCount] = 
{
	float2(-0.094184, -0.929388),
	float2( 0.143831, -0.141007),
	float2( 0.344959,  0.293877),
	float2( 0.199841,  0.786413),
	float2(-0.241888,  0.997065),
	float2(-0.382775,  0.276768),
	float2(-0.264969, -0.418930),
	float2(-0.942016, -0.399062),
	float2(-0.915885,  0.457716),
	float2(-0.814099,  0.914375),
	float2(-0.815442, -0.879124),
	float2( 0.537429, -0.473734),
	float2( 0.791975,  0.190901),
	float2( 0.974843,  0.756483),
	float2( 0.945586, -0.768907),
	float2( 0.443233, -0.975115)
};

I iterated through all the offsets in the kernel and calculated the shadow multiplier for each offset. Then I calculated the average and used it to modulate the effect strength. After implementing the kernel, one last thing was to play with the offsets.

// I will accumulate the shadowmask value here
float shadowMultiplierSum = 0.0;

// Iterate through each offset in the kernel
for (int i = 0; i < poissonDiskCount; i++)
{
	float2 offset = poissonDisk[i].xy * 0.01; // Scale the offset
	float rawRainDepth = _RainCamera_Shadowmap.SampleLevel(linearClampSampler, rainUV + offset, 0.0f).r; // Sample the shadowmap

	// Calculate shadow multiplier for each sample
	float shadowMultiplier = 1.0;
	if (surfaceRainDepth < rawRainDepth - 0.03)
		shadowMultiplier = 0.0;

	// Accumulate shadow multiplier
	shadowMultiplierSum += shadowMultiplier;
}

// Calculate the average
float shadowmapMultiplierAvg = shadowMultiplierSum / (float)poissonDiskCount;

// And modulate the effect based on the average
float effectStrength = _EffectStrength * shadowmapMultiplierAvg;

I see that there is a lot of banding that could be fixed. But the truth is that the player will never see the mask. Try to spot this banding when it’s in action as a mask for the effect. I will add the parameters to the material to control all the offsets.

Shader "Hidden/ApplyRainAtmosphere"
{
    Properties
    {
		...

        _ShadowBlurRadius("Shadow blur radius", Range(0.0, 0.1)) = 0.007
        _ShadowBlurShape("Shadow blur shape", Range(0.0, 2.0)) = 0.65
        _MinEffectStrength("Min effect strength in shadows", Range(0.0, 1.0)) = 0.1
        _DepthOffset("Depth offset", Range(0.0, 0.1)) = 0.03
        _DepthFadeWidth("Depth fade width", Range(0.0, 0.1)) = 0.05
    }
...

This is the final fragment shader code will all the tweaks:

void frag 
(
    in float2 IN_uv : TEXCOORD0,
    out float4 OUT_GBuffer0 : SV_Target0,
    out float4 OUT_GBuffer2 : SV_Target2,
    out float4 OUT_GBuffer3 : SV_Target3
) 
{
    // Calculating world space position from depth.
    float rawScreenDepth = _CameraDepthTexture.SampleLevel(pointClampSampler, IN_uv, 0.0f).r;
    float4 positionCS = float4((IN_uv.xy * 2.0 - 1.0), rawScreenDepth, 1.0); 
    #if UNITY_UV_STARTS_AT_TOP
        positionCS.y *= -1.0;
    #endif
    float4 positionWS = mul(UNITY_MATRIX_I_VP, positionCS); 
    positionWS /= positionWS.w;

    // Calculating rain-camera clip-space position. It contains depth value.
    float4 rainPositionVS = mul(_RainCamera_MatrixV, positionWS);
    float4 rainPositionCS = mul(_RainCamera_MatrixP, rainPositionVS);
    rainPositionCS /= rainPositionCS.w;

    // Remapping rain-camera clip-space position to shadowmap UV
    float2 rainUV = rainPositionCS.xy * 0.5 + 0.5; 
    #if UNITY_UV_STARTS_AT_TOP
        rainUV.y = 1.0 - rainUV.y;
    #endif

    // Calculating the shadows.
    float surfaceRainDepth = rainPositionCS.z;
    float shadowMultiplierSum = 0.0;
    for (int i = 0; i < poissonDiskCount; i++)
    {
        float2 offset = poissonDisk[i].yx * _ShadowBlurRadius;
        float rawRainDepth = _RainCamera_Shadowmap.SampleLevel(linearClampSampler, rainUV + offset, 0.0f).r;

        // Tweaked shadow multiplier calculation to hide sharp banding
        float shadowMultiplier = smoothstep(-_DepthOffset, -_DepthOffset + _DepthFadeWidth, surfaceRainDepth - rawRainDepth);

        shadowMultiplierSum += shadowMultiplier;
    }

    float shadowMultiplierAvg = shadowMultiplierSum / (float)poissonDiskCount;

    // Calculating the final effect strength using the calculated shadows.
    // Added min strength and gamma-modifier to the calculated shadow value
    float minEffectStrength = _EffectStrength * _MinEffectStrength;
    float effectStrength = minEffectStrength + _EffectStrength * pow(shadowMultiplierAvg, _ShadowBlurShape) * (1.0 - minEffectStrength);

    float4 rawGBuffer2 = _GBuffer2.SampleLevel(pointClampSampler, IN_uv, 0.0);
    rawGBuffer2.a = lerp(rawGBuffer2.a, min(_SmoothnessMax, rawGBuffer2.a + _SmoothnessAdd), effectStrength);

    OUT_GBuffer0 = float4((float3)lerp(1.0, _AlbedoMultiplier, effectStrength), 1.0);
    OUT_GBuffer2 = rawGBuffer2;
    OUT_GBuffer3 = float4((float3)lerp(1.0, _AmbientLightMultiplier, effectStrength), 1.0);
}

This is the final effect:

About the author

Jan Mróz / Sir Johny – Graphics Programmer at The Knights of U. He specializes in rendering pipeline extensions and performance optimization across CPU, GPU, and memory. Sir Johny also leads tech-art initiatives that improve visual quality while cutting iteration time.

Learn more from Jan at proceduralpixels.com.

The post Render Graph – Creative Shadowcasting appeared first on The Knights of U.

There were two main issues I had to tackle:

1. High smoothness resulted in flickering when using the bloom post process.
2. All parameters were hard-coded, so I needed to make them accessible through the material’s properties.

Bloom flickering

High smoothness in the GBuffer can create very bright points on the screen in certain light conditions. It makes the bloom postprocess shimmer and flicker. Bloom flicker can be implemented by modifying the bloom effect itself or modifying its inputs. I decided to limit the smoothness value in the GBuffer to fix the issue. I used hardware blending for GBuffer modifications, which has limited capabilities and doesn’t allow me to limit the maximum value of the target texture. This can be fixed by copying the normal-smoothness buffer and sampling the copy to implement a custom blending in the fragment shader. I will keep the smoothness in the reasonable range in the shader that applies the effect.

The current render graph looks like this (Apply Rain Atmosphere was implemented in the previous article).

I can add a custom node between DrawGBuffer and Apply Rain Atmosphere that will create a copy of the GBuffer[2] texture and share it with other passes. The pass responsible for that will be called Initialize Rain Resources. I will call the data shared between passes RainResourceData. Then, the Apply Rain Atmosphere pass will access the copy of GBuffer[2] and use it in the shader with custom blending.

My plan:

1. Implement Initialize Rain Resources pass.
   1. Create a RainResourceData class to store resources shared between passes.
   2. Copy the GBuffer[2] contents into a custom texture using a custom shader.
2. Access the copied GBuffer[2] in Apply Rain Atmosphere pass.
3. Sample the copied GBuffer[2] in the fragment shader to implement custom blending and avoid bloom shimmer.

Implement resource initialization pass

My goal is to create a new texture in the Render Graph and copy the content of GBuffer[2] into this texture.

I created an InitializeRainResourcesPass and modified the RainAtmosphereFeature to execute it before the main pass. I’ve added a material I want to use with a custom shader to copy the GBuffer[2] contents.

public class RainAtmosphereFeature : ScriptableRendererFeature
{
    public Material copyGBufferMaterial; // Added a material that will be used to copy GBuffer[2] contents.
    public Material applyRainMaterial;

    private bool HasValidResources => applyRainMaterial != null && copyGBufferMaterial != null; // Update validation

    private InitializeRainResourcesPass initializeResourcesPass; // Added this pass to the render feature
    private ApplyRainAtmospherePass applyRainAtmospherePass;

    public override void Create()
    {
        applyRainAtmospherePass = new ApplyRainAtmospherePass();
        initializeResourcesPass = new InitializeRainResourcesPass();
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        bool isGameOrSceneCamera = renderingData.cameraData.cameraType == CameraType.Game || renderingData.cameraData.cameraType == CameraType.SceneView;
        if (isGameOrSceneCamera && HasValidResources)
        {
            initializeResourcesPass.material = copyGBufferMaterial; // Updated the material
            applyRainAtmospherePass.material = applyRainMaterial;

            renderer.EnqueuePass(initializeResourcesPass); // Enqueued as first pass
            renderer.EnqueuePass(applyRainAtmospherePass);
        }
    }
}

// This pass will initialize the resources and copy the GBuffer.
public class InitializeRainResourcesPass : ScriptableRenderPass
{
    public Material material { get; internal set; }

    public InitializeRainResourcesPass()
    {
        this.renderPassEvent = RenderPassEvent.AfterRenderingGbuffer;
    }

    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
    {
        // TODO: Initialize shared resources
        // TODO: Copy GBuffer[2] contents
    }
}

Shared resources

I started by creating a class that store the shared resources. Shared resources inherit ContextItem. They must release manually allocated resources in the Reset() function. In our case, we only need to store a TextureHandle – the copy of GBuffer[2].

// Resources shared between passes need to inherit from ContextItem
public class RainResourceData : ContextItem
{
	// Handle for Gbuffer[2] copy.
    public TextureHandle normalSmoothnessTexture { get; internal set; }

	// And reset all resources using this method.
    public override void Reset()
    {
	    // Use TextureHandle.nullHandle to reset texture handles.
        normalSmoothnessTexture = TextureHandle.nullHandle;
    }
}

I created the shared resources in the Initialize Rain Resources Pass using the frameData.GetOrCreate<>() API. After using this method, I can access those resources in other passes.

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
	// Initialize the shared resources
	RainResourceData rainResources = frameData.GetOrCreate<RainResourceData>();
	...

Accessing the GBuffer

I got the reference to the GBuffer and validated it to avoid executing the pass in a forward rendering path.

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
	RainResourceData rainResources = frameData.GetOrCreate<RainResourceData>();

	// Access URP GBuffer
	var urpResources = frameData.Get<UniversalResourceData>();
	var gBuffer = urpResources.gBuffer;

	// Check if the GBuffer exists.
	if (gBuffer == null || gBuffer.Length == 0 || gBuffer[0].Equals(TextureHandle.nullHandle))
		return;

Allocate GBuffer copy texture

I allocated the target texture using the renderGraph.CreateTexture(textureDescriptior) method. This method does not allocate the texture immediately, but it allows the Render Graph to manage the lifetime of the texture. Render Graph will ensure that the texture exists when our render function executes.

...
if (gBuffer == null || gBuffer.Length == 0 || gBuffer[0].Equals(TextureHandle.nullHandle))
		return;

// Allocate the texture handle in the render graph.
rainResources.normalSmoothnessTexture = renderGraph.CreateTexture(gBuffer[2].GetDescriptor(renderGraph));

Creating render pass

Then, I created a pass in the render graph. I used a raster render pass where I specified:

• Render attachment – our freshly allocated texture handle
• Dependencies – gBuffer[2] texture
• Render function

	...
	rainResources.normalSmoothnessTexture = renderGraph.CreateTexture(gBuffer[2].GetDescriptor(renderGraph));
	
	// Create a render pass that will create a copy of GBuffer[2]
	using (var builder = renderGraph.AddRasterRenderPass(GetType().Name, out PassData passData))
	{
		// Specify dependencies
		builder.SetRenderAttachment(rainResources.normalSmoothnessTexture, 0);
		builder.UseTexture(gBuffer[2]);

		// Save data for render function
		passData.gBuffer_2 = gBuffer[2];
		passData.material = material;

		// Set the render function
		builder.SetRenderFunc((PassData passData, RasterGraphContext context) => RenderFunction(passData, context));
	}
}

private static void RenderFunction(PassData passData, RasterGraphContext context)
{
	// TODO: Implement the rendering here
}

internal class PassData
{
	internal Material material; // Material used to copy the GBuffer
	internal TextureHandle gBuffer_2; // Original GBuffer[2] handle
}

Render function

Then, I implemented a render function. Raster Graph Context contains object pooling for PropertyBlocks – I used that to set the shader properties. _GBuffer2 property was set to the original texture. The shader used in the material will implement that property.

private static void RenderFunction(PassData passData, RasterGraphContext context)
{
	// Get property block and set shader parameters.
	MaterialPropertyBlock propertyBlock = context.renderGraphPool.GetTempMaterialPropertyBlock();
	propertyBlock.SetTexture(Uniforms._GBuffer2, passData.gBuffer_2);

	// Execute procedural fullscreen draw.
	context.cmd.DrawProcedural(Matrix4x4.identity, passData.material, 0, MeshTopology.Triangles, 6, 1, propertyBlock);
}

// Utility class that I like to use to store shader properties.
public static class Uniforms
{
    internal static readonly int _GBuffer2 = Shader.PropertyToID(nameof(_GBuffer2));
}

Writing shader

The RenderGraph node is ready, and it’s time to implement the shader that copies the contents of the GBuffer. The shader should read the contents of the GBuffer texture and then output those in the fragment shader. I used the fullscreen draw template to achieve that.

Shader "Hidden/CopyGBuffer2"
{
    SubShader
    {
        Pass
        {
            // Disable triangle culling and depth testing
            Cull Off
            ZTest Off
            ZWrite Off
            
            HLSLPROGRAM

            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            // Fulscreen quad in clip space
            static const float4 verticesCS[] = 
            {
                float4(-1.0, -1.0, 0.0, 1.0),
                float4(-1.0, 1.0, 0.0, 1.0),
                float4(1.0, 1.0, 0.0, 1.0),
                float4(-1.0, -1.0, 0.0, 1.0),
                float4(1.0, 1.0, 0.0, 1.0),
                float4(1.0, -1.0, 0.0, 1.0)
            };
			
            void vert (uint vertexID : SV_VertexID, out float4 OUT_PositionCS : SV_Position)
            {
	            // Output a fullscreen quad.
                float4 positionCS = verticesCS[vertexID];
            }

            void frag (out float4 OUT_Color : SV_Target0) 
            {
				// TODO.
            }

            ENDHLSL
        }
    }
}

Vertex Shader

I modified the vertex shader to output a UV calculated from the clip space. Clip space range is from -1.0 to 1.0, and UV is from 0.0 to 1.0, so I needed to remap those values.
On some platforms, UV starts at the top of the screen. In this case, Y-axis needs to be flipped.

// Add UV interpolator output to the vertex shader.
void vert (uint vertexID : SV_VertexID, out float2 OUT_uv : TEXCOORD0, out float4 OUT_PositionCS : SV_Position)
{
	float4 positionCS = verticesCS[vertexID];

	// Calculate screen UV from the clip space
	float2 uv = positionCS.xy * 0.5 + 0.5;
	#if UNITY_UV_STARTS_AT_TOP
		uv.y = 1.0 - uv.y;
	#endif

	// Set position on the screen and UV
	OUT_PositionCS = verticesCS[vertexID];
	OUT_uv = uv;
}

Fragment Shader

I declared Texture2D _GBuffer2 – the texture I assigned in the render function. I used the UV to sample the GBuffer and output its contents into the render attachment. An object-oriented HLSL syntax was used to sample the texture.

SamplerState pointClampSampler; // Point clamp sampler we will use to sample the GBuffer
Texture2D _GBuffer2; // GBuffer texture

void frag (in float2 IN_uv : TEXCOORD0, out float4 OUT_Color : SV_Target0) 
{
	// Use screen UV to sample and output the GBuffer contents
	OUT_Color = _GBuffer2.SampleLevel(pointClampSampler, IN_uv, 0.0f);
}

Now I could create a material with this shader and assign it to the renderer feature.

Access the copied GBuffer in ApplyRainAtmospherePass

After assigning the material to the render feature, there is no InitializeRainResourcesPass in the Frame Debugger and Render Graph Viewer. It doesn’t execute at all.

Render Graph detects that I don’t use the created texture in other passes, so it culls the render node created in the InitializeRainResourcesPass. To fix that, I must declare the texture usage in the ApplyRainAtmospherePass. I modified the ApplyRainAtmospherePass by accessing shared resources with the frameData.Get<>() API and declared the texture usage.

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
	...
	// Get the rain resources
	RainResourceData rainResources = frameData.Get<RainResourceData>();

	using (var builder = renderGraph.AddRasterRenderPass(GetType().Name, out PassData passData))
	{
		// Declare the texture usage
		builder.UseTexture(rainResources.normalSmoothnessTexture);
		...
	}
}

And after this change, Frame Debugger and Render Graph Viewer correctly display the InitializeRainResourcesPass.

Right now, when I know that Render Graph properly executes the initialization pass, I can use the copy of the GBuffer in the ApplyRainAtmospherePass. I forwarded the texture handle to the passData, used in our render function.

...
builder.UseTexture(rainResources.normalSmoothnessTexture);

passData.gBuffer2 = rainResources.normalSmoothnessTexture; // Pass the texture to the render function
passData.material = material;
...

internal class PassData
{
	internal Material material;
	internal TextureHandle gBuffer2; // Added the texture handle to the data used in the render function
}

I used a property block from the render graph pool to set the texture in the shader.

private static void RenderFunction(PassData passData, RasterGraphContext context)
{
	// Get property block from the pool and assign the texture.
	MaterialPropertyBlock propertyBlock = context.renderGraphPool.GetTempMaterialPropertyBlock();
	propertyBlock.SetTexture(Uniforms._GBuffer2, passData.gBuffer2);

	context.cmd.DrawProcedural(Matrix4x4.identity, passData.material, 0, MeshTopology.Triangles, 6, 1, propertyBlock);
}

All the data is set right now, so it’s time to adjust the shader.

Adjusting the rain atmosphere shader

My goal was to reduce the shimmering in the bloom postprocess. I could do that by implementing a custom blending for the smoothness stored in the alpha channel of the second GBuffer target. First of all, I needed to declare the texture in the shader.

SamplerState pointClampSampler; // Point clamp sampler we will use to sample the GBuffer
Texture2D _GBuffer2; // GBuffer texture

Then, I needed a UV to sample the texture. I copied the vertex shader from the CopyGBuffer.shader.

void vert (uint vertexID : SV_VertexID, out float2 OUT_uv : TEXCOORD0, out float4 OUT_PositionCS : SV_Position)
{
	float4 positionCS = verticesCS[vertexID];

	float2 uv = positionCS.xy * 0.5 + 0.5;
	#if UNITY_UV_STARTS_AT_TOP
		uv.y = 1.0 - uv.y;
	#endif

	OUT_PositionCS = verticesCS[vertexID];
	OUT_uv = uv;
}

It is a good practice to turn off the hardware blending when switching to the software blending – it can save some GPU resources.

Blend 2 Off // Disable hardware blending for the 2nd target.

The last step was to sample the GBuffer contents in the fragment shader and write a custom blending. I’ve found that additive blending for smoothness and clamping the result to a max of 0.86 works best in my case, so I hardcoded those values. This is a final fragment shader code:

void frag 
(
	in float2 IN_uv : TEXCOORD0, // Getting UV from the vertex shader
	out float4 OUT_GBuffer0 : SV_Target0,
	out float4 OUT_GBuffer2 : SV_Target2,
	out float4 OUT_GBuffer3 : SV_Target3
) 
{
	// Access GBuffer[2] value
	float4 rawGBuffer2 = _GBuffer2.SampleLevel(pointClampSampler, IN_uv, 0.0);

	// Increase smoothness and clamp the value
	rawGBuffer2.a = min(0.86, rawGBuffer2.a + 0.7);

	OUT_GBuffer0 = float4(0.5, 0.5, 0.5, 1.0);
	OUT_GBuffer2 = rawGBuffer2; // Write it back into GBuffer
	OUT_GBuffer3 = float4(0.5, 0.5, 0.5, 1.0);
}

I could test the results. As you can see, I successfully reduced most of the flickering.

You probably noticed that I needed to write much more code just to copy a texture. In the previous API I would use a CommandBuffer.Blit function to achieve that. Here I needed to explicitly create a separate pass. There are some utility methods to blit textures in Render Graph, but they still require creating a separate pass, custom shader, and managing the dependencies between passes – no way around that.

Shader Parameters

Because I hardcoded all values in the shader, I can’t adjust them outside the code. I will add parameters to the material to make the visuals easier to adjust:

• Albedo multiplier
• Ambient light multiplier
• Smoothness
• Max Smoothness
• Effect strength – controls the strength of the effect. 0 – no effect is applied, 1 – full effect is applied.

Let’s start by adding shader properties. I added this at the beginning of the shader.

Shader "Hidden/ApplyRainAtmosphere"
{
    Properties
    {
        _AlbedoMultiplier("Albedo multiplier", Range(0.0, 1.0)) = 0.5
        _AmbientLightMultiplier("Ambient multiplier", Range(0.0, 1.0)) = 0.5
        _SmoothnessAdd("Added smoothness", Range(0.0, 1.0)) = 0.7
        _SmoothnessMax("Maximum smoothness", Range(0.0, 1.0)) = 0.86
        _EffectStrength("Overall effect strength", Range(0.0, 1.0)) = 1.0
    }
    ...

Then, I included all those properties in the shader code, just above the fragment shader.

...
float _AlbedoMultiplier;
float _AmbientLightMultiplier;
float _SmoothnessAdd;
float _SmoothnessMax;
float _EffectStrength;

void frag 
(
	in float2 IN_uv : TEXCOORD0,
	...

Next, I replaced all parameters except _EffectStrength.

...
rawGBuffer2.a = min(_SmoothnessMax, rawGBuffer2.a + _SmoothnessAdd);

OUT_GBuffer0 = float4((float3)_AlbedoMultiplier, 1.0);
OUT_GBuffer2 = rawGBuffer2; // Write it back into GBuffer

OUT_GBuffer3 = float4((float3)_AmbientLightMultiplier, 1.0);
...

To implement the _EffectStrength parameter, blending in the shader needs to do nothing when the value is 0. I implemented that using a Lerp function that interpolate all the values to the neutral ones. If the effect strength is set to 0, we must output 1 for the targets with multiply-blend and leave the smoothness as is.

...
// Lerp from original smoothness value to the custom one
rawGBuffer2.a = lerp(rawGBuffer2.a, min(_SmoothnessMax, rawGBuffer2.a + _SmoothnessAdd), _EffectStrength);

// Lerp from 1 to custom values in multiply-blended targets
OUT_GBuffer0 = float4((float3)lerp(1.0, _AlbedoMultiplier, _EffectStrength), 1.0);
OUT_GBuffer2 = rawGBuffer2;
OUT_GBuffer3 = float4((float3)lerp(1.0, _AmbientLightMultiplier, _EffectStrength), 1.0);
...

Result

All parameters work nicely.

My rain atmosphere effect is ready. It takes only 0.44ms to render in 1440p on RTX 3060, increasing frame time from 7.77ms to 8.21ms (5.7% increase) – Measured with NVidia Nsight Graphics. The shader is mostly screen pipe bound – which means that most of the time is spent blending the GBuffer colors using the hardware units – I can’t get much faster than that!

About the author

Jan Mróz / Sir Johny – Graphics Programmer at The Knights of U. He specializes in rendering pipeline extensions and performance optimization across CPU, GPU, and memory. Sir Johny also leads tech-art initiatives that improve visual quality while cutting iteration time.

Learn more from Jan at proceduralpixels.com.

The post Render Graph – Polishing Rain Atmosphere appeared first on The Knights of U.

The Profile Analyzer aggregates and visualizes data from Unity’s built-in Profiler, offering insights into CPU usage, rendering times, and other performance metrics. By analyzing this data, you can pinpoint areas where the game may be underperforming and prioritize optimizations accordingly.

Let’s dive into the details!

How to get started

You can install Profile Analyzer via Window > Package Manager.

After opening the Profile Analyzer window you can see a couple of buttons. You can switch between Single and Compare mode, Export profiler data as CSV files, Pull Data from Profiler, Load or Save .pdata file (this is the data representing Profile Analyzer session).

In order to get started, first you have to capture some data with the Profiler. Once it is done, the Pull Data button in the Profile Analyzer will enable. Click it to pull the captured data from Profiler. You can also load previously saved Profiler data into the Profiler and then pull this data to the Profile Analyzer.

Once you’ve loaded your data, you’ll see it in the frame time graph. This is an interactive region – you can select a range of frames you want to analyze further.

The analysis starts immediately, and the data populates the frame time graph. On the top you can see white and cyan bars. The white bars represent the frame durations, the cyan bars however represent the currently selected marker. This allows you to compare the selected marker’s contribution to total frame time.

Filters

You can search for markers using Filters. The Marker Details automatically update to reflect the subset that you’ve selected, and in the Count column you’ll see how many occurrences it has. The frame time graph highlights the marker. When you select a marker, the Marker Summary details panel also updates to show analysis statistics for that particular marker.

There are following Filter available:

1) By name

You can search markers by substring ot a collection of substrings. If the name contains spaces, make sure to put quotes around the substring. The same goes for Exclude Names Filter. You can also populate marker filters by right-clicking on a marker of interest in the table and adding it to the filter selection.

2) Remove Filter

You can also choose to hide one marker and all child samples under these markers from the data, both in the tables and the graph. You can remove markers by selecting and choosing the Remove Marker option from the right click context menu.

You can only remove one marker at a time; you can add a marker back by choosing None in the dropdown.

3) Threads

You can choose to see data for specific worker threads. To see all of them aggregated, check “All” at the top of the thread Select pop-up window.

4) Depth Slice

You can select marker callback depth to analyze.

5) Parent

To filter by parent, right-click on the marker in the marker table and select Set as Parent Marker Filter.

6) Analysis Type

By default, the Profile Analyzer shows you Total time for the markers, but you can change to Self time. Self time is useful if you want to drill down to details to see where your time is really spent.

7) Units

The default units are milliseconds, but for smaller timings, you can switch to microseconds.

8) Marker Columns

This filter enables you to customize columns of the Marker Details section for your current needs.

Top 10 markers on median frame

This section shows the top 10 markers for the filters that you’ve selected. It is a very powerful tool if used properly. 

For example, most Unity’s subsystems have high-level markers at depth 3. Knowing that you can set Filters to:

• Thread: Main Thread
• Analysis Type: Total
• Depth Slice: 3

This will show you the most consuming markers of Unity’s subsystems. This is a good way of making the very first diagnoze of your game’s performance.

Marker Details

At the bottom of the Profile Analyzer window you will find a table of the marker data from the Profiler, based on the filters you applied. The Unity Profiler data for all the markers are aggregated to provide median and other frame times, which are also displayed in this table. You can sort this data freely by any column.

Frame Summary and Marker Summary

The right side of the Profile Analyzer window starts with Frame Summary which displays highlights on the frame time, including the minimum, maximum, and median, with buttons that let you jump to specific frames in the Profiler. This area also shows you the frame time distribution histogram and a box and whisker plot. 

Below that there is the Marker Summary which shows the current selected markers contribution to the frame time. You can see up to 10 most costly frames of that marker and preview nice graph representing times on selected frames. At the bottom, there is information about the minimum and maximum times for individual marker instances within the aggregated data set.

Make it work

It is important to remember that the Profile Analyzer should be used alongside Unity’s Profiler. In other words, Profile Analyzer can help you filter through the most important markers and find frames that are the most important which you can then keep analyzing in the Profiler.

It is important to make sure that the data you’re looking at is representative. You can easily find the representative frame using Profile Analyzer Frame Summary. Just click on the Median frame from the selection of frames range – it will select this frame in the Profiler. You can also right-click on the frame time graph and select Select Median Frame.

But let’s not limit ourselves to single point entry. Right-click on the frame time graph and select Order By Frame Duration. Now you can select a set of frames around the median frame for a representative sample that smooths out some of the noise in your data.

How to check if you are GPU-bound?

You can do it pretty easily with the Profile Analyzer. First, find the Gfx.WaitForPresentOnGfxThread marker by typing its name to Name Filter. Analyze its data – if the median value of that marker is non-zero, then the CPU is waiting on the GPU to finish its activity before it can continue, aka – you are most likely GPU bound.

Comparing data sets

Lastly, you can compare two sets of Profiler data. To do it select Compare mode at the top of the Profile Analyzer window. Then pull data from two different Profiler data sets. You can also pull data from one Profiler data set to compare for example two different frame ranges.

One data set is displayed in blue, and the other in orange. Additionally, every section of the Profile Analyzer window now visualizes loaded data sets, so you can quickly compare them. 

You can use this mode to e.g. check the effect of the global project setting change such as Graphics Jobs or Physics Solver Type. To do that, first make a baseline Profiler capture then, run the game the second time after applying the changes and make another capture. Pull both captures to the Profile Analyzer and compare results in the Frame Summary section.

Exporting data

It is good to remember that you can export the Profile Analyzer data to CSV format for further analysis. It is recommended to store that data alongside the Profiler capture data which it was generated based on.

Time to analyze!

Profile Analyzer brings new quality to the process of analyzing Profilers data. Finding bottlenecks and key performance indicators is now much easier than ever. Do not hesitate, check it yourself!

The post Leverage your profiling abilities with Profile Analyzer in Unity 6 appeared first on The Knights of U.

Render Graph API – Introduction

GBuffer

Before diving into the feature, I want to touch on what GBuffer is.

GBuffer is an array of textures containing various surface properties, like albedo, specular, smoothness, ambient occlusion, and emission. When you select the deferred rendering path in URP, Unity renders all scene objects into GBuffer. It means that instead of calculating the lighting at each draw, they output surface properties into GBuffer. Then, URP applies the lighting in the form of a postprocess.

URP GBuffer consists of 4 obligatory textures + some additional ones. According to URP documentation obligatory textures are:
GBuffer[0] – albedo in the RGB channels and material flags in the alpha channel.
GBuffer[1] – specular color in the RGB channels and ambient occlusion in the alpha channel.
GBuffer[2] – normal in the RGB channels and smoothness in the alpha channel
GBuffer[3] – the combined emission, GI, and lighting in the RGB channels.

The Render Deferred Lighting pass combines all the GBuffer textures and calculates dynamic lights.

How rain atmosphere can be achieved

To achieve the rain atmosphere effect, I need to manipulate the GBuffer content before the Render Deferred Lighting pass. I want to make the surface look wet after the lighting. But how do wet objects differ from dry objects? Here’s a photo illustrating the difference between dry and wet sand.

Wet surfaces appear darker and reflected light is sharp and bright. I can achieve that by reducing the intensity of albedo color and ambient light stored in the Gbuffer[0].RGB and GBuffer[3].RGB. Sharper reflections can be implemented by increasing the smoothness in the alpha channel in GBuffer[2].

To test the concept I adjusted material properties. I increased the smoothness and darkened the color. The visual impact matched what I hoped for.

Implementation

I broke the implementation into 3 steps:

1. Set up the render feature
2. Create the Render Graph pass
3. Write the shader

1. Setting up the render feature

First, I ensured that the project uses a deferred rendering path in the URP renderer settings. I disabled Accurate G-Buffer Normals as this option encodes the normal buffer differently. I want to use standard normal encoding to minimize complexity at this stage.

Then I started by implementing the Scriptable Renderer Feature. RainAtmosphereFeature injects the ApplyRainAtmospherePass into the render pipeline. ApplyRainAtmospherePass is set to be injected after rendering GBuffer by using a RenderPassEvent.AfterRenderingGbuffer. I will implement all rendering logic in the RecordRenderGraph method.

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.RenderGraphModule;
using UnityEngine.Rendering.Universal;

// This class is responsible for injecting the render feature into the URP renderer. 
public class RainAtmosphereFeature : ScriptableRendererFeature
{
	// Material used for rendering
    public Material applyRainMaterial;

    private bool HasValidResources => applyRainMaterial != null;

	// This pass will handle the gbuffer modification
    private ApplyRainAtmospherePass applyRainAtmospherePass;

    public override void Create()
    {
        applyRainAtmospherePass = new ApplyRainAtmospherePass();
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        bool isGameOrSceneCamera = renderingData.cameraData.cameraType == CameraType.Game || renderingData.cameraData.cameraType == CameraType.SceneView;
        if (isGameOrSceneCamera && HasValidResources)
        {
	        // Update resources in the pass
            applyRainAtmospherePass.material = applyRainMaterial;
			
			// And add the pass to the renderer
            renderer.EnqueuePass(applyRainAtmospherePass);
        }
    }
}

// This class handles the rendering logic. Here I will build new nodes and insert them into RenderGraph.
public class ApplyRainAtmospherePass : ScriptableRenderPass
{
    public Material material { get; internal set; }

    public ApplyRainAtmospherePass()
    {
        this.renderPassEvent = RenderPassEvent.AfterRenderingGbuffer;
    }

    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
    {
        // TODO: I will implement the rendering logic here
    }

2. Creating the Render Graph pass

Here I will define a Render Graph pass that directly modifies the GBuffer contents.

URP shares the GBuffer between all passes. It means I can access it using frameData.Get<>() API. The GBuffer reference is stored in the UniversalResourceData.gBuffer and is only initialized when using a deferred path. Otherwise, it may not exist, or it can be set to a null handle. I need to check that before adding a custom node to the render graph.

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
    // Get GBuffer handles
    UniversalResourceData urpResources = frameData.Get<UniversalResourceData>();
    TextureHandle[] gBuffer = urpResources.gBuffer;

    // Check if GBuffer exists and if it is properly initialized (it will not be initialized in the forward path)
    if (gBuffer == null || gBuffer.Length == 0 || gBuffer[0].Equals(TextureHandle.nullHandle))
        return;
}

Once I confirmed GBuffer was valid, I proceeded with the node creation. I will modify GBuffer by executing a fullscreen procedural draw call to alter its contents. I created a raster graph node and a PassData class to store resources required in the render function. Then, I set GBuffer textures as render attachments of the node. GBuffer is an array of textures, so I used the for loop to bind all of them.

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
	UniversalResourceData urpResources = frameData.Get<UniversalResourceData>();
	TextureHandle[] gBuffer = urpResources.gBuffer;

	if (gBuffer == null || gBuffer.Length == 0 || gBuffer[0].Equals(TextureHandle.nullHandle))
		return;

	// Start creating a render graph node
	using (var builder = renderGraph.AddRasterRenderPass(GetType().Name, out PassData passData))
	{
		// Set all resources needed in a render function
		passData.material = material;

		// Set GBuffer as render attachment
		for (int i = 0; i < gBuffer.Length; i++)
			builder.SetRenderAttachment(gBuffer[i], i, AccessFlags.Write);
	}

}

// Resources used in the render function
internal class PassData
{
	// Material with the shader that will render the effect
	internal Material material;
}

For the render function, I kept it minimal: just a DrawProcedural call that uses my material. Since I’m rendering two triangles (a fullscreen quad), I drew 6 vertices. Each of the three consecutive vertices creates a triangle – two triangles in this case.

...
		for (int i = 0; i < gBuffer.Length; i++)
			builder.SetRenderAttachment(gBuffer[i], i, AccessFlags.Write);

		// Set render function
		builder.SetRenderFunc((PassData passData, RasterGraphContext context) => RenderFunction(passData, context));
	}
}

private static void RenderFunction(PassData passData, RasterGraphContext context)
{
	// Draw a procedural mesh. The mesh will be defined in a shader, so we specify that we want to render 
	// 6 vertices as triangles using our material.
	context.cmd.DrawProcedural(Matrix4x4.identity, passData.material, 0, MeshTopology.Triangles, 6, 1);
}
...

3. Writing the shader

Now, I need to create a shader that will render into GBuffer. I must write a fragment shader that will output colors to three render targets. I prepared a basic shader that contains an empty vertex and fragment shader. We will work on these in the following steps.

Shader "Hidden/ApplyRainAtmosphere"
{
    SubShader
    {
        Pass
        {
            // Disable triangle culling
            Cull Off

            // Disable depth buffer usage
            ZTest Off
            ZWrite Off

            HLSLPROGRAM

            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            void vert ()
            {
                // TODO: Draw a fullscreen quad here
            }

            void frag () 
            {
                // TODO: Modify GBuffer here
            }

            ENDHLSL
        }
    }
}

Vertex shader

The vertex shader’s main role is to define each vertex’s position on the screen. The position of the screen is defined in the Clip Space. In short, x,y defines the screen’s pixel, where (-1, -1) is one corner of the screen and (1, 1) is a second corner. z defines the depth. The position, as in float4, uses this format: (x*w, y*w, z*w, w).

Notice that when the w component is set to 1, the whole vector simplifies to (x, y, z, 1). We will use that trick in the next step.

In the render function, I declared drawing with six vertices, using two triangles. Each of the three consecutive vertices will form a triangle. The illustration below shows how the fullscreen mesh looks like.

I stored those vertices in the constant array in the shader. I can access the ID of each vertex using the SV_VertexID semantic. This vertex shader outputs a fullscreen triangle. Here is what the code looks like:

// Fullscreen rectangle in clip space
static const float4 verticesCS[] = 
{
	float4(-1.0, -1.0, 0.0, 1.0),
	float4(-1.0, 1.0, 0.0, 1.0),
	float4(1.0, 1.0, 0.0, 1.0),
	float4(-1.0, -1.0, 0.0, 1.0),
	float4(1.0, 1.0, 0.0, 1.0),
	float4(1.0, -1.0, 0.0, 1.0)
};

void vert (uint IN_VertexID : SV_VertexID, out float4 OUT_PositionCS : SV_Position)
{
	// Output the rectangle to clip space
	OUT_PositionCS = verticesCS[IN_VertexID];
}

Blending

Shader will target GBuffer0, GBuffer2, and GBuffer3, corresponding to albedo, normal-smoothness, and ambient light. In Unity shaders, I can specify the blending operation for each target texture using a Blend keyword at the beginning of the pass.

Each respective value produced by the fragment shader will affect the GBuffer with its blend operation. This is how I configured the blending for those targets.

GBuffer0 = ShaderOutput0 * GBuffer0
GBuffer2 = ShaderOutput2 + GBuffer2
GBuffer3 = ShaderOutput3 * GBuffer3

...
ZTest Off
ZWrite Off

// Multiply blending for albedo
Blend 0 DstColor Zero
// Additive blending for normal-smoothness
Blend 2 One One
// Multiply blending for ambient light
Blend 3 DstColor Zero

HLSLPROGRAM
...

Fragment Shader

Now its a time to make the fragment shader output values into GBuffer. This is done using the SV_Target<ID> semantics. For example, I reduced the albedo and ambient light color by half and add 0.7 to the smoothness.

void frag 
(
	out float4 OUT_GBuffer0 : SV_Target0,
	out float4 OUT_GBuffer2 : SV_Target2,
	out float4 OUT_GBuffer3 : SV_Target3
) 
{
	// Multiply blending - reduce colors by half, but leave the alpha channel as is.
	OUT_GBuffer0 = float4(0.5, 0.5, 0.5, 1.0);

	// Additive blending - leave normals in RGB as is, but add 0.7 to smoothness.
	OUT_GBuffer2 = float4(0.0, 0.0, 0.0, 0.7);

	// Multiply blending - reduce colors by half, but leave the alpha channel as is.
	OUT_GBuffer3 = float4(0.5, 0.5, 0.5, 1.0);
}

Result

Shader is ready. It’s time to create a material with it and assign it to the render feature. You can see that my feature is working correctly. I was so used to the old look of the Viking Village, it is nice to have something fresh!

It is also displayed by the Render Graph Viewer (Window/Analysis/Render Graph Viewer) between Draw GBuffer pass and Render Deferred Lighting.

In the next article I will fix the bloom flickering caused by the high smoothness. I will also implement the parameters to control the visuals.

About the author

Jan Mróz / Sir Johny – Graphics Programmer at The Knights of U. He specializes in rendering pipeline extensions and performance optimization across CPU, GPU, and memory. Sir Johny also leads tech-art initiatives that improve visual quality while cutting iteration time.

Learn more from Jan at proceduralpixels.com.

The post Render Graph – Creating Rain Atmosphere appeared first on The Knights of U.

How memory works

The operating system is the manager of the memory. It allocates the amount of memory that processes can use. The applications will issue requests to it such as “I need more memory to run, please give it to me” or “I no longer need that bunch of memory, please take it and release it”. 

Applications usually allocate their memory with some margin and then create a wrapper for such allocated chunks, making this memory available within their application using so-called allocators. When they need more memory than previously allocated margin, they issue a request to the OS to give them more memory. They sometimes can face rejection because the OS cannot give them more resources. This is how the ‘out of memory’ exception is thrown by an application which cannot longer function.

Memory fragmentation

Memory is sequential. It means that if you want to create e.g. array of data, the application allocates memory for that as a non-interrupted memory block. Memory blocks are allocated one after another. Frequent allocations and deallocations can lower the actual available memory for the application.

Let’s say that we have this memory block:

And these memory allocations:

We made some allocations during our application lifetime, so our memory block now looks like this:

Now we are releasing SuperLarge allocation from memory, so it looks like this:

Next we allocate a bunch of smaller allocations:

Now we want to allocate another SuperLarge allocation. There is a space available between the last Tiny and Large allocation, but there is too small room for uninterrupted SuperLarge allocation. Our application needs to issue a request to the OS to grant it more memory space. After that our memory block with allocated another SuperLarge allocation looks like this:

That gap in the memory block is called memory fragmentation.

Unity’s Garbage Collector has the ability to move blocks of memory in order to prevent memory from fragmentation, but it’s related only to Managed memory – we will cover it in the next chapter. It has no such power when it comes to Native memory – frequently allocation of that memory can cause memory fragmentation.

Below you can see examples of fragmented and non-fragmented memory. See how nice each memory allocation is lined up in the memory block when there is no (or little to no) fragmentation.

Types of memory

There are couple types of memory allocating by Unity:

• Native Memory
• Executables and Mapped
• Managed Memory
• GPU Driver Memory
• Untracked Memory

Native Memory is a part of memory allocated by Unity itself and build-in memory allocator. It is used by objects such as:

• Scene Objects (Game Objects and their Components),
• Assets and Managers
• Native Allocations including Native Arrays and other Native Containers
• CPU side of Graphics Asset memory
• And other

This is a memory which is not handled by the Garbage Collector.

Executables and Mapped is memory taken up by the build code of the application, including all shared libraries and assemblies, managed and native.

Managed Memory is a runtime C# memory. Here you will find all created lists, arrays, hashsets, class objects etc.

GPU Driver Memory – memory allocated by the GPU driver for the purpose of rendering. Here lies most of the textures, meshes etc. 

Untracked Memory – memory allocated by third party plugins which Unity cannot track through its DLLs. 

What is allocated in my project?

Now that we know how allocation in general works and what type of memory there is in Unity, let’s see how Unity is handling allocating particular objects.

The base principle is that Unity allocates what is inside a loaded scene and all references to any object which are held by loaded objects. What does it mean?

Let’s say that we are loading a scene with 5 objects. These objects are obviously loaded into memory. Now one of these objects has a MonoBehaviour script which contains a reference to a ScriptableObject. This ScriptableObject on the other hand has a reference to a mesh which is not used in the loaded scene. Result? The mesh references by the ScriptableObject will be loaded to the memory and kept in there until one part of the reference chain will be cut. This will probably happen after the scene was unloaded. It would be much worse if ScriptableObject would be referenced to a Singleton with DontDestroyOnLoad flag enabled. In that case the mesh would not be unloaded from the memory event after unloading the scene. 

using UnityEngine;


public class SomeMonobehaviourWithReference : MonoBehaviour
{
   public Object reference;
}

using UnityEngine;


[CreateAssetMenu(fileName = "SomeScriptableObjectWithReference", menuName = "Scriptable Objects/SomeScriptableObjectWithReference")]
public class SomeScriptableObjectWithReference : ScriptableObject
{
   public Object reference;
}

This example on a large scale can cause serious memory issues, in particular if there are references to objects which hold all game logic. How can we solve this? There are plenty of solutions, one of them is to use the Addressables system and load objects only when you need it. 

Instead of having hard reference to a mesh, we could use AssetReference<TObject>:

[SerializeField] private AssetReference meshReference;

Now we can use LoadAssetAsync<TObject>() to load our Asset Reference:

AsyncOperationHandle handle = meshReference.LoadAssetAsync<Mesh>();

And ReleaseAsset() to release it from memory:

meshReference.ReleaseAsset();

Besides references to assets, Unity always loads the contents of the Resource folder to the memory. Therefore using it is nowadays considered a bad practice.

My game has huge memory allocations. How to get rid of them?

First you need to diagnose a source of the problem. You can do it by using Memory Profiler. 

You can install Memory Profiler via Package Manager. 

Before we jump in, you have to take memory snapshots of your project. There are couple of basic rules in terms of memory profiling: 

1. Always profile on the built project, on your target platform. Every platform has its own unique memory management, therefore profiling your project in the Editor will not give you relevant data. In fact, you will be profiling the Editor rather than your game. So make the build for your target platform, run it and then profile it.
2. Make a couple of snapshots from a single gameplay. Every time you run a build, your applications memory can act differently. If you want to know what is a memory flow throughout your entire application you should make a couple of snapshots of a single gameplay in key points, e.g.:
   • from the main menu after opening a game – this will give you knowledge about base memory loaded at the beginning,
   • from the gameplay scene, right after loading it from the main menu – this will show you what you are loading at the beginning of the gameplay loop
   • at the end of the gameplay session – this will show you which parts are constant in the memory and which are unloading
   • in the main menu, after the gameplay session – this will tell you if gameplay assets are properly unloaded after quitting to the main menu.

Additionally you can add a couple of snapshots throughout the gameplay to inspect your memory behaviour in particular places of your game that you are interested in examining.

3. If possible, make memory snapshots on the device with extended RAM. If you struggle with quickly reaching maximum memory capacity of a device, you would like to profile it on a device with extended RAM in order to be able to make proper snapshots and diagnose the problem.
4. If possible, use different tools to profile memory alongside Memory Profiler. Memory Profiler can only estimate the memory usage and sometimes does not show everything. That is why you should compare its output with other tools.

The newest version of Memory Profiler contains 3 tabs:

1. Summary – overall visualization of used memory
2. Unity Objects – list of all Unity objects with their allocated size, percentage impact to all memory, native size, managed size and graphic size.
3. All Of Memory – list of all objects allocated in memory with division to memory type.

You can view snapshots in single mode as well as in compare mode. This is useful if you want to show differences between particular parts of your game. 

After inspecting memory snapshots you can evaluate what is the root problem in your case. Is it too much of a base memory and assets are just taking up too much space in memory? Or maybe there are some memory leaks throughout gameplay which are causing crashes? Let’s see how we can resolve each case.

What’s taking up so much?

During memory optimization, the first thing you should do is to check which assets are taking up the most memory and how you can improve it. You just want to reach for the low hanging fruits at first as it is the easiest way to improve memory management in your project by lowering the base memory amount. So what could it be?

Texture2D

The size of texture in RAM depends solely on the:

1. Texture’s resolution
2. Texture’s format
3. Number of mip-maps

Texture’s size in RAM does not depend on Crunch compression! Crunch compression has only an impact on the texture’s size in build. After loading such a texture to RAM it is ‘unpacked’. So the size of a RGB Compressed DXT1 texture and RGB Crunched DXT1 texture is the same in RAM, even if Editor is claiming differently. It is good to keep that in mind.

It is a good practice to keep the texture’s resolution no bigger than the resolution of your target device. The 4K texture will not show all of its details on a 720p screen. You adjust the max size of a texture in the texture importer in the Editor. 

You can also set a format which texture will be compressed to. The most important thing to remember about that is the resolution of compressed textures has to be a multiple of the size of a compression block. It means that e.g. DXT1 compression which has a 4×4 compression block requires the resolution of the compressed texture to be a multiple of 4.

An exception to that rule is ASTC compression which can compress everything, except a texture with a mipmaps which is not a power-of-two.

If a texture has mip-maps, in order to be compressible, it has to have a power-of-two resolution. So a 800×1200 texture with mip-maps cannot be compressed, however it is possible with a 1024×1024 texture.

You can see it in the following example. A 256×255 texture is marked as NPOT and cannot be compressed.

After adding just one row of pixels it becomes POT and compressible, which reduces its size almost six times.

You can also tell the texture importer to automatically scale NPOT texture. The options are: 1) ToNearest 2) ToLarger 3) ToSmaller. It is a convenient way to make sure that imported texture can be compressed, although sometimes you will want to do it manually for better control.

Below you have a cheat sheet showing which textures can be compressed in relation to mip-maps.

Mesh

Meshes can consume a large amount of project memory, in particular if they are complex and huge in number.

There are a couple things you can do to reduce the size of meshes:

1. If your mesh is not using normal maps or any other effects based on tangent space, you can go ahead and turn off importing tangents.

2. If your mesh has animations that are not used, you can turn off Import Blend Shapes.

3. Remember to keep the Read/Write enabled flag to false if you do not need it (e.g. if you do not want to modify it in runtime). If you enable this option, mesh will be duplicated and kept in RAM as well as in GPU memory.

Animation

You can decrease the animation size of imported models by enabling Animation Compression. This way Unity will omit some of the unnecessary keyframes.

Shader

Every shader can have multiple variants, meaning it can be compiled multiple times and used for different features. In practice there can be a situation when some of the shader variants wont be necessary – it depends on the number of lights, their settings or quality settings. That is why it is important to track shader variants and control them. Unity often cannot tell which variants to strip, aka exclude from the build, so you have to do this on your own.

You can do it by adding IPreprocessShaders script to your project, like so:

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEditor.Build;
using UnityEditor.Rendering;


public class ShaderStripper : IPreprocessShaders
{
   private List<ShaderKeyword> keywords = new List<ShaderKeyword>()
   {
       new ShaderKeyword("POINT_COOKIE"),
       new ShaderKeyword("DIRECTIONAL_COOKIE"),
   };


   public int callbackOrder { get { return 0; } }


   public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList<ShaderCompilerData> data)
   {
       StripVariants(shader, snippet, data, keywords);
   }


   private void StripVariants(Shader shader, ShaderSnippetData snippet, IList<ShaderCompilerData> data, List<ShaderKeyword> keywordsToStrip)
   {
       for (int i = 0; i < data.Count; ++i)
       {
           if (keywordsToStrip.Any(keyword => data[i].shaderKeywordSet.IsEnabled(keyword)))
           {
               data.RemoveAt(i);
               --i;
           }
       }
   }
}

It is enough to have it laying somewhere in your project – it will be executed during compilation.

You can track the number of shaders and shader variants used in your project via Project Settings -> Graphics window. Go into Play Mode and play your game. Notice how those numbers are increasing each time another shader variant needs to be loaded. If you are satisfied with the current state, exit Play Mode and click on the ‘Save to asset…’ button to save the list of shader variants to the .shadervariants file. Next you can view this file in Inspector and check which shader variants were being loaded. 

Based on that you should establish which shader variant can be stripped. Just add appropriate keywords to your script and you should notice much lighter shaders in the build.

There is also another ‘magic’ setting in Unity which can improve memory usage of shader variants called Shader Variant Loading Settings. You can find it in Project Settings -> Player Settings -> Other Settings.

Unity stores several ‘chunks’ of compressed shader variant data. Each chunk contains multiple shader variants. When Unity loads a scene at runtime, it loads all the scene’s chunks into CPU memory and decompresses them. By default, Unity decompresses all the shader variants into another area of CPU memory. Then Unity passes the shader variant and its data to the graphics API and the graphics driver. The graphics driver creates a GPU-specific version of the shader variant and uploads it to the GPU. Unity caches each GPU-specific shader variant, to avoid another stall when Unity needs the shader variant again. Finally, Unity removes the shader variant completely from CPU and GPU memory when there are no longer any objects that reference the shader variant.

With Shader Variant Loading Settings you can control the size of chunks and how many decompressed chunks Unity keeps in memory. 

• Default chunk size (MB) controls the maximum size of compressed chunks.
• Default chunk count controls how many decompressed chunks Unity keeps in memory. The default is 0, which means there’s no limit.

You can override those values for every platform. If you decide to override it, you should experiment with different values to see how it impacts your project’s runtime. This setting is useful in particular on platforms with limited memory.

What about memory leaks?

If memory usage of your application is consistently and substantially rising during the gameplay loop, you are probably dealing with memory leak.

Memory leak is a state where there are objects in the memory which will no longer be used. This situation can arise because of couple of reasons:

1. There is a reference to an object which will no longer be used and GC cannot release it from memory because of said reference.
2. There are structures used which require manual allocation and deallocation and the latter is not executing.

To detect a memory leak you should profile the memory of your application during the main game loop. Remember about profiling principles which we covered earlier. Analyze and compare memory snapshots after a couple of main game loop iterations. If memory is rising roughly 10-20MB then it is likely no problem – could be just fragmentation. If it is much more, e.g. 100MB then it is probably a memory leak.

Here we can see a huge memory leak. These two snapshots were taken in the main menu of the game – first one at the beginning of the gameplay, second after a couple of main game loop iterations.

You can also enable memory leaks detection in the Editor but it refers only to native allocation, such as NativeArray, UnsafeList, UnsafeParallelHashSet, AllocatorManager.Allocate() etc.

You can turn it on in the Preferences -> Jobs tab. Native memory leaks will be printed in the console as errors.

How to fix a memory leak?

To find a particular memory leak, you should open a memory snapshot in single mode and move to All Of Memory tab. You can actually type ‘leaked’ in the search bar and the list below will show all managed shell leaks (they are marked as ‘Leaked Managed Shell’).

Let’s take a look at a simple example of a memory leak that was prepared for the need of this post. Looking at the memory snapshot we can see that there are 140 objects called ‘Bullet’ leaked.

Let’s select one of them and focus on the right side of the memory profiler window.

We can see References and Selection Details sections. As you can see under the Selection Details, Unity is even instructing us why this object is a leak. It appears that it was supposed to be destroyed but Garbage Collector was not able to release it because the object is still being referenced somewhere. Let’s focus on the Referenced By tab above.

How to read that tree?

1. Reference to List<Bullet> is stored in object of type Weapon
2. Reference to object of type Weapon is stored in object of type Entity
3. Reference to Entity is stored in a List<Entity>
4. List<Entity> is stored in a type of EntitiesManager as a ‘Static field type reference on Type EntitiesManager’

We have reached the root of our problem – it is the static reference to List<Entity> in EntitiesManager. What is happening here is Entities objects were destroyed after unloading a scene where they were instantiated but they are still referenced and therefore were not released from memory. What is more, Entity kept a reference to another object – Weapon and Weapon kept a reference to Bullet objects, so they were also not released from memory.

public class EntitiesManager : MonoBehaviour
{
   public static List<Entity> Entities { get; private set; } = new List<Entity>();

   ...
}

After properly releasing static references, everything should be fine.

Summary

As you can see, there are different possible sources of memory issues, as well as many tools and practices to fight them. As with every kind of optimization, the most important is to correctly recognize the root of an issue. I hope the knowledge presented in this post helps you in properly managing memory in your project.

The post Memory optimization guide in Unity 6 appeared first on The Knights of U.

Despite the name, Render Graph isn’t a node-based visual editor – it’s a programming interface. Its name originated from how it stores the data about the render pipeline. This new programming API works by implementing custom rendering “nodes” and adding them to the Render Graph.

Why Unity needed Render Graph in the first place.

Before Render Graph came in, I used ScriptableRenderPasses in URP, where I implemented most of the rendering logic imperatively using various methods. While this approach gave us programmers a lot of freedom, it completely broke down at scale. Larger projects became fragile and hard to debug. There was no organized way to store references to the GPU resources, which resulted in a tremendous mess when we needed to access many resources used by URP or different rendering features, the maintenance cost was high. While URP source code and different rendering features started to grow, no uniform way of managing resources became the most significant source of code spaghettification. Do you need an access to the ColorBuffer? Fine – override ScriptableRendererFeature.SetupRenderPasses(...) and get it there. Do you need to access a GBuffer? I hope you like System.Reflection and internal hacks.

Since Vulkan and DirectX12, a programmer is responsible for allocating and managing GPU memory using the graphics API. There is a lot of planning, pipeline state caching, and resource reusing. Render Graph API makes this much easier to handle as it introduces declarative scheduling, automatic resource lifetime management and GPU-aware optimizations, like pass culling and tile-based rendering.

Render Graph Caveats

When the Render Graph becomes strong in larger projects, it has some caveats:

• Steep learning curve – the previous model was more imperative and less restricted, while the new one is more declarative and requires the developer to better understand rendering concepts like pass culling and resource management.
• Debugging complexity – The graph is compiled and optimized under the hood. It is harder to debug rendering issues, often it is just a guessing nightmare with manual checking of all the dependencies. Render Graph lacks the basic debugging tools. We have Render Graph Viewer, but it helps only when everything already works fine.
• For simpler effects, it is boilerplate-heavy and may be unintuitive. Blitting and drawing a single mesh now requires four levels of ceremony.
• Performance implications – Pass merging and tile-based rendering are great, but declarative scheduling makes fine-tuned control harder.

How to use Render Graph?

Programming with RenderGraph API requires us to create custom rendering nodes, called Passes and add them into a Render Graph. To familiarize yourself with the concept, I analyzed how I create a custom node using visual tools like Shader Graph. In case of creating a Custom Function node in the Shader graph, I need to:

1. Create the node
2. Define inputs.
3. Define outputs.
4. Define a function that creates outputs from the inputs.
5. Connect the node somewhere in the graph – find the resources I want to use.

When programming with Render Graph API, all those steps are done using the C# code in the ScriptableRenderPass. In the next section, I will describe how to do that.

How I implemented my first render graph node!

I will implement a basic render feature to draw a mesh into a screen using a material. The setup for the ScriptableRendererFeature and pass is identical to the old URP system — nothing new.

using UnityEngine;
using UnityEngine.Rendering.Universal;
using UnityEngine.Rendering.RenderGraphModule;
using UnityEngine.Rendering;

// This class is responsible for injecting the render feature into the URP renderer. 
public class RenderIntoColorBufferFeature : ScriptableRendererFeature
{
    // Mesh and material that will be used for rendering.
    public Mesh mesh;
    public Material material;

    // This pass will handle the rendering logic
    private RenderIntoColorBufferPass pass;
    
    public override void Create()
    {
	    // Create passes in this method
        pass = new RenderIntoColorBufferPass();
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        bool isGameOrSceneCamera = renderingData.cameraData.cameraType == CameraType.Game || renderingData.cameraData.cameraType == CameraType.SceneView;
        bool hasValidResources = mesh != null && material != null;
        if (isGameOrSceneCamera && hasValidResources)
        {
            // Update resources in our pass
            pass.mesh = mesh;
            pass.material = material;

            // And add pass to the renderer
            renderer.EnqueuePass(pass);
        }
    }
}

// This class handles the rendering logic. Here we should build new nodes and insert them into RenderGraph.
public class RenderIntoColorBufferPass : ScriptableRenderPass
{
    public Mesh mesh;
    public Material material;

    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
    {
	    // In this method we will create a custom render graph node that renders a single mesh.
	    ...
    }
}

I added the feature to the URP renderer in the inspector. I used a random mesh from the project and a new material with unlit shader.

The interesting part starts in RecordRenderGraph(), where I will use the new API to create and connect a Render Graph node.

Step 1 – Create a node

I used renderGraph.AddRasterRenderPass method to create a node – this gives me a builder object and a data block. RenderGraph supports several pass types – I am using raster here to output geometry to a target texture.

I also needed to create a custom class, PassData, that holds data used by the CommandBuffer during the rendering.

I used a Dispose() method to finish node creation.

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
	// Create a new pass (node) in the graph. Note that this method creates a builder and a PassData objects for us.
	IRasterRenderGraphBuilder rasterPassBuilder = renderGraph.AddRasterRenderPass(nameof(RenderIntoColorBufferPass), out PassData passData);

	// Finish pass creation
	rasterPassBuilder.Dispose();
}

// Here, we need to store all the necessary resources during the rendering (resources used by the CommandBuffer).
public class PassData
{
}

Steps 2 and 3 – Define inputs and outputs

I defined inputs by passing the resources to our PassData object. Here, I needed to store all references that are used by a CommandBuffer API during the rendering.

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
	IRasterRenderGraphBuilder rasterPassBuilder = renderGraph.AddRasterRenderPass(nameof(RenderIntoColorBufferPass), out PassData passData);

	// Assign the resources
	passData.mesh = mesh;
	passData.material = material;

	rasterPassBuilder.Dispose();
}

public class PassData
{
	//we will use a mesh and a material during the rendering.
	public Mesh mesh;
	public Material material;
}

Now, I needed to define the render target, but how can I get the reference to the color target texture – content of the screen? I can access shared GPU resources using the frameData.Get<T>() API. I requested URP resources (UniversalResourceData) to get the activeColorTexture. This is the target texture I want to render into, so I saved the reference.

I must also tell the render graph node that I want to render the triangles into the color texture. This is done using the rasterPassBuilder.SetRenderAttachment. I also noticed that nodes can render only into one set of render targets. You can’t change the targets (attachments) during the rendering!

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
	// Gather all needed references using the frameData.Get API.
	UniversalResourceData urpResources = frameData.Get<UniversalResourceData>();
	TextureHandle colorTarget = urpResources.activeColorTexture;

	IRasterRenderGraphBuilder rasterPassBuilder = renderGraph.AddRasterRenderPass(nameof(RenderIntoColorBufferPass), out PassData passData);

	// Set the render target
	rasterPassBuilder.SetRenderAttachment(colorTarget, 0, AccessFlags.Write);

	passData.mesh = mesh;
	passData.material = material;

	rasterPassBuilder.Dispose();
}

Step 4 – Define the render function

Then, I implemented the actual rendering – defined a render function using the rasterPassBuilder.SetRenderFunc() method. The way I must wrote this line of code is quite weird, as Unity required me to write an explicit lambda expression here. No shortcuts allowed.

Making RenderFunction static forced me to keep everything inside PassData – and I think that’s a good thing.
In this method, I don’t set any render targets and I don’t create any CommandBuffers, I jump right into the drawing using the RasterCommandBuffer in context.cmd.

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
	UniversalResourceData urpResources = frameData.Get<UniversalResourceData>();
	TextureHandle colorTarget = urpResources.activeColorTexture;

	IRasterRenderGraphBuilder rasterPassBuilder = renderGraph.AddRasterRenderPass(nameof(RenderIntoColorBufferPass), out PassData passData);

	rasterPassBuilder.SetRenderAttachment(colorTarget, 0, AccessFlags.Write);

	passData.mesh = mesh;
	passData.material = material;

	// Define a rendering function for the node.
	rasterPassBuilder.SetRenderFunc((PassData passData, RasterGraphContext context) => RenderFunction(passData, context));

	rasterPassBuilder.Dispose();
}

// This is a render function for our node.
private static void RenderFunction(PassData passData, RasterGraphContext context)
{
	// Here we implement our rendering logic. 

	// Notice that we use a RasterCommandBuffer, not a CommandBuffer. It contains only a subset of CommandBuffer methods.
	RasterCommandBuffer cmd = context.cmd;

	// We use this RasterCommandBuffer to render a mesh. In this method, we can use only resources from the passData object.
	cmd.DrawMesh(passData.mesh, Matrix4x4.identity, passData.material);
}

Step 5 – Connect the node to the graph

Render Graph will automatically connect the node to the graph based on the usage of the resources. But this is not too precise. In my case, I only used a color target from URP resources. I set renderPassEvent in the constructor – this ensures the pass connects at the right stage. Set renderPassEvent to AfterRenderingPostProcessing to ensure that the mesh will be rendered on the screen after postprocesses.

public class RenderIntoColorBufferPass : ScriptableRenderPass
{
    public Mesh mesh;
    public Material material;

    public RenderIntoColorBufferPass()
    {
        //It is essential for the graph builder to build our pass after postprocesses are added to the graph.
        this.renderPassEvent = RenderPassEvent.AfterRenderingPostProcessing;
    }

    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
    {
        UniversalResourceData urpResources = frameData.Get<UniversalResourceData>();
        ...

You can see that the feature is working!

And in the Render Graph Viewer (Window/Analysis/Render Graph Viewer), you can see my “Render Into Color Buffer Pass”. It also uses _CameraTargetAttachmentB texture as a write-only target (red color).

Summary

• Render Graph API is a new way of render pipeline scripting in Unity.
• Render Graph works by appending custom rendering nodes to the graph using a C# API. It is not a visual editing tool.
• All rendering code is written in ScriptableRenderPass.RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
• To create a node in render graph, use var builder = renderGraph.Add...Pass(). The method returns the node builder and a data block of custom type.
• Add inputs and outputs to your node by using builder.SetAttachment... and builder.Use... methods. Add all resources required in the render function to the data block.
• To access or create resources shared between nodes by using frameData.Get<>() or frameData.GetOrCreate<>() methods.
• Create a render function and assign it to the node by using builder.SetRenderFunc(...)
• Finish node creation by calling builder.Dispose().

In the upcoming article, I will explain how to use a render graph to render custom content into URP GBuffer. I will alter the GBuffer contents to simulate some weather conditions – rain atmosphere effect:

About the author

Jan Mróz / Sir Johny – Graphics Programmer at The Knights of U. He specializes in rendering pipeline extensions and performance optimization across CPU, GPU, and memory. Sir Johny also leads tech-art initiatives that improve visual quality while cutting iteration time.

Learn from real production challenges and solutions at proceduralpixels.com, where Jan shares tools and insights developed to support studio pipelines and push visual quality efficiently.

The post Render Graph – Introduction appeared first on The Knights of U.

What is GPU Resident Drawer

GPU Resident Drawer is Unity’s internal rendering system which automatically uses the BatchRendererGroup API to draw GameObjects with GPU instancing. The result is reduced draw calls and freed CPU processing time.

It is best suited for large complex scenes with many objects like a large number of environment objects.

Ok, and BatchRendererGroup is?

BatchRendererGroup is a technique which makes it possible to efficiently render a large number of objects via instanced draw calls. It is done using draw commands, containing all information required to create an instanced draw call, e.g. batchID, meshID or materialID. With GPU Resident Drawer you do not have to worry about technicalities of BRG API, because Unity will do all the rendering magic for you.

How to make it work

In order to make GPU Resident Drawer work, you have to meet following requirements:

1. Set proper settings in Unity
2. Make a GameObject compatible with GPU Resident Drawer

GPU Resident Drawer requires following settings:

• The Forward+ rendering path
• Graphics APIs and platforms that support compute shaders , except OpenGL ES
• GameObjects that have a Mesh Renderer component

To enable the GPU Resident Drawer follow these steps:

1. Go to Project Settings > Graphics, then in the Shader Stripping section set BatchRendererGroup Variants to Keep All.

2. Double-click the renderer in the Renderer List to open the Universal Renderer, then set Rendering Path to Forward+.

3. Go to the active URP Asset and enable SRP Batcher.
4. Set GPU Resident Drawer to Instanced Drawing.

To make GameObject compatible with the GPU Resident Drawer, check if:

• It has a Mesh Renderer component.
• In the Mesh Renderer component, Light Probes is not set to Use Proxy Volume.
• It uses only static global illumination, not real time global illumination. 
• It uses a shader that supports DOTS instancing. 
• It doesn’t move position after one camera finishes rendering and before another camera starts rendering. 
• It doesn’t use the MaterialPropertyBlock API. 
• It doesn’t have a script that uses a per-instance callback, for example OnRenderObject.

You can also exclude a GameObject from the GPU Resident Drawer by adding a Disallow GPU Driven Rendering component to it.

Also – according to Unity – these settings may speed up GPU Resident Drawer, but are not required for it to work:

• Go to Project Settings > Player, then in the Other Settings section disable Static Batching.
• Go to Window > Panels > Lighting, then in the Lightmapping Settings section enable Fixed Lightmap Size and disable Use Mipmap Limits.

Feel free to experiment with it.

And that’s it – you are good to go!

Final results

Let’s take a look at how many draw calls we were able to reduce. 

We have prepared a test scene with over 35 000 objects representing various types of foliage – trees, grass and bushes. Here’s how it looks.

We have performed tests on a PC platform with GPU Resident Drawer enabled and disabled. All tests have been performed in 1920×1080 resolution.

Below are results with GPU Resident Drawer disabled.

As you can see, we are not even close to our target frame rate which is 60 FPS (16,667 ms). We are performing 43.5k draw calls with 43 483 batches and rendering 5 million triangles. We are also allocating 0.82GB of memory.

Below are results with GPU Resident Drawer enabled.

CPU and GPU times drastically dropped. The GPU is taking over 16 ms to process a frame but most of the time it’s idle and waiting for the target frame rate. Draw calls and batches were reduced to 128. The CPU is no longer bottled with too many draw calls and is able to quickly pass them to the GPU.

That said, we can observe that the performance improvement is huge.

Are there any drawbacks?

There is some cost of using GPU Resident Drawer. 

First of all there is an increase in memory usage – in our case it was about 100 MB which you can see on profiler extracts above.

Second, and what Unity is stating, is that the build times are longer with GPU Resident Drawer. So keep that in mind if you’re planning to use this feature.

We have not noticed any difference in time of entering the Play Mode in the Editor.

Bonus: GPU Occlusion Culling

You probably noticed how much the amount of rendering geometry has drastically dropped. This is a credit of GPU Occlusion Culling – another game-changing feature introduced in Unity 6.

The option to enable it shows in URP Asset right after enabling GPU Resident Drawer.

What it does is it uses a depth buffer from the previous frame to check if a particular instance of geometry is occluded by other objects. This results in fast and accurate occlusion culling made entirely on GPU.

You can actually enable debug mode of this feature to see how it works. To do that go to Window -> Analysis -> Rendering Debugger. Then select a GPU Resident Drawer tab and check Occlusion Test Overlay checkbox.

Now the Scene and Game View will show you which geometry is being culled by GPU Occlusion Culling. The more warmer areas the more geometry is being culled.

Summary

GPU Resident Drawer alongside GPU Occlusion Culling can significantly improve performance of your project in just a few clicks. Do not hesitate to test it yourself!

The post Boost performance of your game in Unity 6 with GPU Resident Drawer appeared first on The Knights of U.

What is Cyclomatic Complexity?

Cyclomatic Complexity (CC) is a software metric used to measure the complexity of a program’s control flow. It was introduced back in 1976 and is used to quantify the number of linearly independent paths through a program’s source code. This helps assess the complexity and maintainability of code, often being an indicator of how difficult it might be to test or understand. It’s commonly used in static code analysis and serves as a guideline to manage the complexity and improve the overall quality of software.

How to calculate CC for BP?

The original formula can be found on the Internet as well as tools that allow you to calculate CC for C++. 

What about UE Blueprints? Valentin Galea gave a speech at Unreal Fest about his custom tool, which was created exactly for this purpose. I recreated his algorithm and wrapped it in a nice plugin that you can use to check CC in your BPs in any UE project.

Here is how the algorithm works:

1. In a given BP, collect all Entry Nodes (the first Node in the function, or Event Node).
2. Skip Entry Nodes that are not connected to anything.
3. For each Entry Node iterate through connected Nodes and count all the branches in the execution flow. Start the counter with 1 since there is always one (default) flow.
4. Skip disconnected or duplicated flows.
5. Sum all branches from all selected functions – that’s the CC for this BP.

How to use the plugin?

1. Download the plugin from repo.
2. Add it to your project’s Plugin folder.
3. Compile the code.
4. Open Editor, right-click on Blueprint or the entire folder, and select “Validate Asset”. The result will be printed in Message Log -> Asset Check.

If you like to see CC for individual functions, check “Enable Verbose Logging” in Project Settings -> Plugins -> Samurai Project Validation.

This validator will be executed every time you save the BP (by default). You can disable this in Editor Preferences -> Advanced -> Data Validation -> Validate on Save.

Do you have a bonus for me?

Yes, I do!

In the plugin, you can find a Print String Validator which checks whether there is any PrintString() or PrintText() function in your BP that has the “Print to Screen” enabled. If there is, you will get an error in the Message Log. No more forgotten prints that cover your gameplay!

The post A Tool for Calculating Cyclomatic Complexity in Blueprints appeared first on The Knights of U.