- 对象池
- 1 网络预处理实例处理程序
- 2 案例
Netcode for GameObjects (Netcode)提供了对象池的内置支持，这允许您覆盖Netcode的默认destroy方法，并用您自己的逻辑生成处理程序。
这允许您将被破坏的网络对象存储在一个池中，以便以后重用。
这对于经常使用的对象很有用，比如投射物，也是提高应用程序整体性能的一种方式。
通过预先实例化和重用这些对象的实例，对象池消除了在运行时创建或销毁对象的需要，这可以为CPU节省大量工作。
这意味着，不是一次又一次地创建或销毁同一个对象，而是在使用后简单地停用它，然后，当需要另一个对象时，池回收停用的对象之一并重新激活它。
看见对象池简介了解更多关于对象池的重要性。
1 网络预处理实例处理程序您可以通过包含INetworkPrefabInstanceHandler接口并注册NetworkPrefabHandler注册自己的【对象池】处理程序.
public interface INetworkPrefabInstanceHandler
{
NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation);
void Destroy(NetworkObject networkObject);
}
Netcode将使用Instantiate和Destroy方法代替默认的派生处理程序NetworkObject在Spawn和DeSpawn期间使用。
因为消息实例化一个新的NetworkObject源自主机或服务器，两者都不会调用Instantiate方法。
如果INetworkPrefabInstanceHandler实现NetworkPrefabHanlder (NetworkManager.PrefabHandler)，主机或服务器生成关联的NetworkObject 时，所有客户端(不包括主机)都将调用实例化方法.
下面的例子来自Boss Room。它展示了如何使用对象池来处理不同的投射对象。
在该示例中，NetworkObjectPool包含池对象和类的数据结构PooledPrefabInstanceHandler处理程序实现INetworkPrefabInstanceHandler.
assets/boss room/Scripts/Shared/Net/networkobjectpool . cs
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Assertions;
namespace BossRoom.Scripts.Shared.Net.NetworkObjectPool
{
///
/// Object Pool for networked objects, used for controlling how objects are spawned by Netcode. Netcode by default will allocate new memory when spawning new
/// objects. With this Networked Pool, we're using custom spawning to reuse objects.
/// Boss Room uses this for projectiles. In theory it should use this for imps too, but we wanted to show vanilla spawning vs pooled spawning.
/// Hooks to NetworkManager's prefab handler to intercept object spawning and do custom actions
///
public class NetworkObjectPool : NetworkBehaviour
{
private static NetworkObjectPool _instance;
public static NetworkObjectPool Singleton { get { return _instance; } }
[SerializeField]
List PooledPrefabsList;
HashSet prefabs = new HashSet();
Dictionary> pooledObjects = new Dictionary>();
private bool m_HasInitialized = false;
public void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
}
else
{
_instance = this;
}
}
public override void OnNetworkSpawn()
{
InitializePool();
}
public override void OnNetworkDespawn()
{
ClearPool();
}
public void OnValidate()
{
for (var i = 0; i < PooledPrefabsList.Count; i++)
{
var prefab = PooledPrefabsList[i].Prefab;
if (prefab != null)
{
Assert.IsNotNull(prefab.GetComponent(), $"{nameof(NetworkObjectPool)}: Pooled prefab "{prefab.name}" at index {i.ToString()} has no {nameof(NetworkObject)} component.");
}
}
}
///
/// Gets an instance of the given prefab from the pool. The prefab must be registered to the pool.
///
///
///
/// Gets an instance of the given prefab from the pool. The prefab must be registered to the pool.
///
///
/// The position to spawn the object at.
/// The rotation to spawn the object with.
///
/// Return an object to the pool (reset objects before returning).
///
public void ReturnNetworkObject(NetworkObject networkObject, GameObject prefab)
{
var go = networkObject.gameObject;
go.SetActive(false);
pooledObjects[prefab].Enqueue(networkObject);
}
///
/// Adds a prefab to the list of spawnable prefabs.
///
/// The prefab to add.
///
public void AddPrefab(GameObject prefab, int prewarmCount = 0)
{
var networkObject = prefab.GetComponent();
Assert.IsNotNull(networkObject, $"{nameof(prefab)} must have {nameof(networkObject)} component.");
Assert.IsFalse(prefabs.Contains(prefab), $"Prefab {prefab.name} is already registered in the pool.");
RegisterPrefabInternal(prefab, prewarmCount);
}
///
/// Builds up the cache for a prefab.
///
private void RegisterPrefabInternal(GameObject prefab, int prewarmCount)
{
prefabs.Add(prefab);
var prefabQueue = new Queue();
pooledObjects[prefab] = prefabQueue;
for (int i = 0; i < prewarmCount; i++)
{
var go = CreateInstance(prefab);
ReturnNetworkObject(go.GetComponent(), prefab);
}
// Register Netcode Spawn handlers
NetworkManager.Singleton.PrefabHandler.AddHandler(prefab, new PooledPrefabInstanceHandler(prefab, this));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private GameObject CreateInstance(GameObject prefab)
{
return Instantiate(prefab);
}
///
/// This matches the signature of
///
///
///
/// ();
}
// Here we must reverse the logic in ReturnNetworkObject.
var go = networkObject.gameObject;
go.SetActive(true);
go.transform.position = position;
go.transform.rotation = rotation;
return networkObject;
}
///
/// Registers all objects in
public void InitializePool()
{
if (m_HasInitialized) return;
foreach (var configObject in PooledPrefabsList)
{
RegisterPrefabInternal(configObject.Prefab, configObject.PrewarmCount);
}
m_HasInitialized = true;
}
///
/// Unregisters all objects in
public void ClearPool()
{
foreach (var prefab in prefabs)
{
// Unregister Netcode Spawn handlers
NetworkManager.Singleton.PrefabHandler.RemoveHandler(prefab);
}
pooledObjects.Clear();
}
}
[Serializable]
struct PoolConfigObject
{
public GameObject Prefab;
public int PrewarmCount;
}
class PooledPrefabInstanceHandler : INetworkPrefabInstanceHandler
{
GameObject m_Prefab;
NetworkObjectPool m_Pool;
public PooledPrefabInstanceHandler(GameObject prefab, NetworkObjectPool pool)
{
m_Prefab = prefab;
m_Pool = pool;
}
NetworkObject INetworkPrefabInstanceHandler.Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation)
{
var netObject = m_Pool.GetNetworkObject(m_Prefab, position, rotation);
return netObject;
}
void INetworkPrefabInstanceHandler.Destroy(NetworkObject networkObject)
{
m_Pool.ReturnNetworkObject(networkObject, m_Prefab);
}
}
}
