using FishNet.Managing;
using FishNet.Connection;
using UnityEngine;
using FishNet.Serializing;
using FishNet.Transporting;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using FishNet.Utility.Performance;
using System;
using FishNet.Managing.Object;
using FishNet.Component.Ownership;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace FishNet.Object
{
[DisallowMultipleComponent]
public sealed partial class NetworkObject : MonoBehaviour
{
#region Public.
/// <summary>
/// True if was nested during scene setup or within a prefab.
/// </summary>
[field: SerializeField, HideInInspector]
public bool IsNested { get; private set; }
/// <summary>
/// NetworkConnection which predicted spawned this object.
/// </summary>
public NetworkConnection PredictedSpawner { get; private set; } = NetworkManager.EmptyConnection;
/// <summary>
/// True if this NetworkObject was active during edit. Will be true if placed in scene during edit, and was in active state on run.
/// </summary>
[System.NonSerialized]
internal bool ActiveDuringEdit;
/// <summary>
/// Returns if this object was placed in the scene during edit-time.
/// </summary>
/// <returns></returns>
public bool IsSceneObject => (SceneId > 0);
/// <summary>
/// ComponentIndex for this NetworkBehaviour.
/// </summary>
[field: SerializeField, HideInInspector]
public byte ComponentIndex { get; private set; }
/// <summary>
/// Unique Id for this NetworkObject. This does not represent the object owner.
/// </summary>
public int ObjectId { get; private set; }
/// <summary>
/// True if this NetworkObject is deinitializing. Will also be true until Initialize is called. May be false until the object is cleaned up if object is destroyed without using Despawn.
/// </summary>
internal bool IsDeinitializing { get; private set; } = true;
/// <summary>
/// PredictedSpawn component on this object. Will be null if not added manually.
/// </summary>
[field: SerializeField, HideInInspector]
public PredictedSpawn PredictedSpawn { get; private set; }
/// <summary>
///
/// </summary>
[field: SerializeField, HideInInspector]
private NetworkBehaviour[] _networkBehaviours;
/// <summary>
/// NetworkBehaviours within the root and children of this object.
/// </summary>
public NetworkBehaviour[] NetworkBehaviours
{
get => _networkBehaviours;
private set => _networkBehaviours = value;
}
/// <summary>
/// NetworkObject parenting this instance. The parent NetworkObject will be null if there was no parent during serialization.
/// </summary>
[field: SerializeField, HideInInspector]
public NetworkObject ParentNetworkObject { get; private set; }
/// <summary>
/// NetworkObjects nested beneath this one. Recursive NetworkObjects may exist within each entry of this field.
/// </summary>
[field: SerializeField, HideInInspector]
public List<NetworkObject> ChildNetworkObjects { get; private set; } = new List<NetworkObject>();
/// <summary>
///
/// </summary>
[SerializeField, HideInInspector]
internal TransformProperties SerializedTransformProperties = new TransformProperties();
/// <summary>
/// Current state of the NetworkObject.
/// </summary>
[System.NonSerialized]
internal NetworkObjectState State = NetworkObjectState.Unset;
#endregion
#region Serialized.
/// <summary>
/// True if the object will always initialize as a networked object. When false the object will not automatically initialize over the network. Using Spawn() on an object will always set that instance as networked.
/// </summary>
public bool IsNetworked
{
get => _isNetworked;
private set => _isNetworked = value;
}
/// <summary>
/// Sets IsNetworked value. This method must be called before Start.
/// </summary>
/// <param name="value">New IsNetworked value.</param>
public void SetIsNetworked(bool value)
{
IsNetworked = value;
}
[Tooltip("True if the object will always initialize as a networked object. When false the object will not automatically initialize over the network. Using Spawn() on an object will always set that instance as networked.")]
[SerializeField]
private bool _isNetworked = true;
/// <summary>
/// True to make this object global, and added to the DontDestroyOnLoad scene. This value may only be set for instantiated objects, and can be changed if done immediately after instantiating.
/// </summary>
public bool IsGlobal
{
get => _isGlobal;
private set => _isGlobal = value;
}
/// <summary>
/// Sets IsGlobal value.
/// </summary>
/// <param name="value">New global value.</param>
public void SetIsGlobal(bool value)
{
if (IsNested)
{
NetworkManager.StaticLogWarning($"Object {gameObject.name} cannot change IsGlobal because it is nested. Only root objects may be set global.");
return;
}
if (!IsDeinitializing)
{
NetworkManager.StaticLogWarning($"Object {gameObject.name} cannot change IsGlobal as it's already initialized. IsGlobal may only be changed immediately after instantiating.");
return;
}
if (IsSceneObject)
{
NetworkManager.StaticLogWarning($"Object {gameObject.name} cannot have be global because it is a scene object. Only instantiated objects may be global.");
return;
}
_networkObserverInitiliazed = false;
IsGlobal = value;
}
[Tooltip("True to make this object global, and added to the DontDestroyOnLoad scene. This value may only be set for instantiated objects, and can be changed if done immediately after instantiating.")]
[SerializeField]
private bool _isGlobal;
/// <summary>
/// Order to initialize this object's callbacks when spawned with other NetworkObjects in the same tick. Default value is 0, negative values will execute callbacks first.
/// </summary>
public sbyte GetInitializeOrder() => _initializeOrder;
[Tooltip("Order to initialize this object's callbacks when spawned with other NetworkObjects in the same tick. Default value is 0, negative values will execute callbacks first.")]
[SerializeField]
private sbyte _initializeOrder = 0;
/// <summary>
/// How to handle this object when it despawns. Scene objects are never destroyed when despawning.
/// </summary>
[SerializeField]
[Tooltip("How to handle this object when it despawns. Scene objects are never destroyed when despawning.")]
private DespawnType _defaultDespawnType = DespawnType.Destroy;
/// <summary>
/// True to use configured ObjectPool rather than destroy this NetworkObject when being despawned. Scene objects are never destroyed.
/// </summary>
public DespawnType GetDefaultDespawnType() => _defaultDespawnType;
/// <summary>
/// Sets DespawnType value.
/// </summary>
/// <param name="despawnType">Default despawn type for this NetworkObject.</param>
public void SetDefaultDespawnType(DespawnType despawnType)
{
_defaultDespawnType = despawnType;
}
#endregion
#region Private.
/// <summary>
/// True if disabled NetworkBehaviours have been initialized.
/// </summary>
private bool _disabledNetworkBehavioursInitialized;
#endregion
#region Const.
/// <summary>
/// Value used when the ObjectId has not been set.
/// </summary>
public const int UNSET_OBJECTID_VALUE = ushort.MaxValue;
/// <summary>
/// Value used when the PrefabId has not been set.
/// </summary>
public const int UNSET_PREFABID_VALUE = ushort.MaxValue;
#endregion
#region Editor Debug.
#if UNITY_EDITOR
private int _editorOwnerId;
#endif
#endregion
private void Awake()
{
SetChildDespawnedState();
}
private void Start()
{
TryStartDeactivation();
}
/// <summary>
/// Initializes NetworkBehaviours if they are disabled.
/// </summary>
private void InitializeNetworkBehavioursIfDisabled()
{
if (_disabledNetworkBehavioursInitialized)
return;
_disabledNetworkBehavioursInitialized = true;
for (int i = 0; i < NetworkBehaviours.Length; i++)
NetworkBehaviours[i].InitializeIfDisabled();
}
/// <summary>
/// Sets Despawned on child NetworkObjects if they are not enabled.
/// </summary>
private void SetChildDespawnedState()
{
NetworkObject nob;
for (int i = 0; i < ChildNetworkObjects.Count; i++)
{
nob = ChildNetworkObjects[i];
if (!nob.gameObject.activeSelf)
nob.State = NetworkObjectState.Despawned;
}
}
/// <summary>
/// Deactivates this NetworkObject during it's start cycle if conditions are met.
/// </summary>
internal void TryStartDeactivation()
{
if (!IsNetworked)
return;
//Global.
if (IsGlobal && !IsSceneObject)
DontDestroyOnLoad(gameObject);
if (NetworkManager == null || (!NetworkManager.IsClient && !NetworkManager.IsServer))
{
//ActiveDuringEdit is only used for scene objects.
if (IsSceneObject)
ActiveDuringEdit = true;
gameObject.SetActive(false);
}
}
private void OnDisable()
{
/* If deinitializing and an owner exist
* then remove object from owner. */
if (IsDeinitializing && Owner.IsValid)
Owner.RemoveObject(this);
/* If not nested then check to despawn this OnDisable.
* A nob may become disabled without being despawned if it's
* beneath another deinitializing nob. This can be true even while
* not nested because users may move a nob under another at runtime.
*
* This object must also be activeSelf, meaning that it became disabled
* because a parent was. If not activeSelf then it's possible the
* user simply deactivated the object themselves. */
else if (IsServer && !IsNested && gameObject.activeSelf)
{
bool canDespawn = false;
Transform nextParent = transform.parent;
while (nextParent != null)
{
if (nextParent.TryGetComponent(out NetworkObject pNob))
{
/* If pNob is not the same as ParentNetworkObject
* then that means this object was moved around. It could be
* that this was previously a child of something else
* or that was given a parent later on in it's life cycle.
^
* When this occurs do not send a despawn for this object.
* Rather, let it destroy from unity callbacks which will force
* the proper destroy/stop cycle. */
if (pNob != ParentNetworkObject)
break;
//If nob is deinitialized then this one cannot exist.
if (pNob.IsDeinitializing)
{
canDespawn = true;
break;
}
}
nextParent = nextParent.parent;
}
if (canDespawn)
Despawn();
}
}
private void OnDestroy()
{
//Does this need to be here? I'm thinking no, remove it and examine later. //todo
if (Owner.IsValid)
Owner.RemoveObject(this);
//Already being deinitialized by FishNet.
if (IsDeinitializing)
return;
if (NetworkManager != null)
{
//Was destroyed without going through the proper methods.
if (NetworkManager.IsServer)
NetworkManager.ServerManager.Objects.NetworkObjectUnexpectedlyDestroyed(this, true);
if (NetworkManager.IsClient)
NetworkManager.ClientManager.Objects.NetworkObjectUnexpectedlyDestroyed(this, false);
}
/* When destroyed unexpectedly it's
* impossible to know if this occurred on
* the server or client side, so send callbacks
* for both. */
if (IsServer)
InvokeStopCallbacks(true);
if (IsClient)
InvokeStopCallbacks(false);
/* If owner exist then remove object from owner.
* This has to be called here as well OnDisable because
* the OnDisable will only remove the object if
* deinitializing. This is because the object shouldn't
* be removed from owner if the object is simply being
* disabled, but not deinitialized. But in the scenario
* the object is unexpectedly destroyed, which is how we
* arrive here, the object needs to be removed from owner. */
if (Owner.IsValid)
Owner.RemoveObject(this);
Observers.Clear();
IsDeinitializing = true;
SetActiveStatus(false);
//Do not need to set state if being destroyed.
//Don't need to reset sync types if object is being destroyed.
}
/// <summary>
/// Sets IsClient or IsServer to isActive.
/// </summary>
private void SetActiveStatus(bool isActive, bool server)
{
if (server)
IsServer = isActive;
else
IsClient = isActive;
}
/// <summary>
/// Sets IsClient and IsServer to isActive.
/// </summary>
private void SetActiveStatus(bool isActive)
{
IsServer = isActive;
IsClient = isActive;
}
/// <summary>
/// Initializes this script. This is only called once even when as host.
/// </summary>
/// <param name="networkManager"></param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void Preinitialize_Internal(NetworkManager networkManager, int objectId, NetworkConnection owner, bool asServer)
{
State = NetworkObjectState.Spawned;
InitializeNetworkBehavioursIfDisabled();
IsDeinitializing = false;
//QOL references.
NetworkManager = networkManager;
ServerManager = networkManager.ServerManager;
ClientManager = networkManager.ClientManager;
ObserverManager = networkManager.ObserverManager;
TransportManager = networkManager.TransportManager;
TimeManager = networkManager.TimeManager;
SceneManager = networkManager.SceneManager;
PredictionManager = networkManager.PredictionManager;
RollbackManager = networkManager.RollbackManager;
SetOwner(owner);
ObjectId = objectId;
/* This must be called at the beginning
* so that all conditions are handled by the observer
* manager prior to the preinitialize call on networkobserver.
* The method called is dependent on NetworkManager being set. */
AddDefaultNetworkObserverConditions();
for (int i = 0; i < NetworkBehaviours.Length; i++)
NetworkBehaviours[i].InitializeOnce_Internal();
/* NetworkObserver uses some information from
* NetworkBehaviour so it must be preinitialized
* after NetworkBehaviours are. */
if (asServer)
NetworkObserver.PreInitialize(this);
_networkObserverInitiliazed = true;
//Add to connection objects if owner exist.
if (owner != null)
owner.AddObject(this);
}
/// <summary>
/// Adds a NetworkBehaviour and serializes it's components.
/// </summary>
internal T AddAndSerialize<T>() where T : NetworkBehaviour //runtimeNB make public.
{
int startingLength = NetworkBehaviours.Length;
T result = gameObject.AddComponent<T>();
//Add to network behaviours.
Array.Resize(ref _networkBehaviours, startingLength + 1);
_networkBehaviours[startingLength] = result;
//Serialize values and return.
result.SerializeComponents(this, (byte)startingLength);
return result;
}
/// <summary>
/// Updates NetworkBehaviours and initializes them with serialized values.
/// </summary>
/// <param name="fromPrefabCollection">True if this call originated from a prefab collection, such as during it's initialization.</param>
internal void UpdateNetworkBehaviours(NetworkObject parentNob, ref byte componentIndex) //runtimeNB make public.
{
/* This method can be called by the developer initializing prefabs, the prefab collection doing it automatically,
* or when the networkobject is modified or added to an object.
*
* Prefab collections generally contain all prefabs, meaning they will not only call this on the topmost
* networkobject but also each child, as the child would be it's own prefab in the collection. This assumes
* that is, the child is a nested prefab.
*
* Because of this potential a check must be done where if the componentIndex is 0 we must look
* for a networkobject above this one. If there is a networkObject above this one then we know the prefab
* is being initialized individually, not part of a recursive check. In this case exit early
* as the parent would have already resolved the needed information. */
//If first componentIndex make sure there's no more than maximum allowed nested nobs.
if (componentIndex == 0)
{
//Not possible for index to be 0 and nested.
if (IsNested)
return;
byte maxNobs = 255;
if (GetComponentsInChildren<NetworkObject>(true).Length > maxNobs)
{
Debug.LogError($"The number of child NetworkObjects on {gameObject.name} exceeds the maximum of {maxNobs}.");
return;
}
}
PredictedSpawn = GetComponent<PredictedSpawn>();
ComponentIndex = componentIndex;
ParentNetworkObject = parentNob;
//Transforms which can be searched for networkbehaviours.
ListCache<Transform> transformCache = ListCaches.GetTransformCache();
transformCache.Reset();
ChildNetworkObjects.Clear();
transformCache.AddValue(transform);
for (int z = 0; z < transformCache.Written; z++)
{
Transform currentT = transformCache.Collection[z];
for (int i = 0; i < currentT.childCount; i++)
{
Transform t = currentT.GetChild(i);
/* If contains a nob then do not add to transformsCache.
* Do add to ChildNetworkObjects so it can be initialized when
* parent is. */
if (t.TryGetComponent(out NetworkObject childNob))
{
/* Make sure both objects have the same value for
* IsSceneObject. It's possible the user instantiated
* an object and placed it beneath a scene object
* before the scene initialized. They may also
* add a scene object under an instantiated, even though
* this almost certainly will break things. */
if (IsSceneObject == childNob.IsSceneObject)
ChildNetworkObjects.Add(childNob);
}
else
{
transformCache.AddValue(t);
}
}
}
int written;
//Iterate all cached transforms and get networkbehaviours.
ListCache<NetworkBehaviour> nbCache = ListCaches.GetNetworkBehaviourCache();
nbCache.Reset();
written = transformCache.Written;
List<Transform> ts = transformCache.Collection;
//
for (int i = 0; i < written; i++)
nbCache.AddValues(ts[i].GetNetworkBehaviours());
//Copy to array.
written = nbCache.Written;
List<NetworkBehaviour> nbs = nbCache.Collection;
NetworkBehaviours = new NetworkBehaviour[written];
//
for (int i = 0; i < written; i++)
{
NetworkBehaviours[i] = nbs[i];
NetworkBehaviours[i].SerializeComponents(this, (byte)i);
}
ListCaches.StoreCache(transformCache);
ListCaches.StoreCache(nbCache);
//Tell children nobs to update their NetworkBehaviours.
foreach (NetworkObject item in ChildNetworkObjects)
{
componentIndex++;
item.UpdateNetworkBehaviours(this, ref componentIndex);
}
}
/// <summary>
/// Called after all data is synchronized with this NetworkObject.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void Initialize(bool asServer, bool invokeSyncTypeCallbacks)
{
InitializeCallbacks(asServer, invokeSyncTypeCallbacks);
}
/// <summary>
/// Called to prepare this object to be destroyed or disabled.
/// </summary>
internal void Deinitialize(bool asServer)
{
InvokeStopCallbacks(asServer);
if (asServer)
{
IsDeinitializing = true;
}
else
{
ClientManager.Connection.LevelOfDetails.Remove(this);
//Client only.
if (!NetworkManager.IsServer)
IsDeinitializing = true;
RemoveClientRpcLinkIndexes();
}
SetActiveStatus(false, asServer);
if (asServer)
Observers.Clear();
}
/// <summary>
/// Resets states for object to be pooled.
/// </summary>
/// <param name="asServer">True if performing as server.</param>
public void ResetForObjectPool()
{
int count = NetworkBehaviours.Length;
for (int i = 0; i < count; i++)
NetworkBehaviours[i].ResetForObjectPool();
State = NetworkObjectState.Unset;
SetOwner(NetworkManager.EmptyConnection);
NetworkObserver.Deinitialize();
//QOL references.
NetworkManager = null;
ServerManager = null;
ClientManager = null;
ObserverManager = null;
TransportManager = null;
TimeManager = null;
SceneManager = null;
RollbackManager = null;
//Misc sets.
ObjectId = 0;
ClientInitialized = false;
}
/// <summary>
/// Removes ownership from all clients.
/// </summary>
public void RemoveOwnership()
{
GiveOwnership(null, true);
}
/// <summary>
/// Gives ownership to newOwner.
/// </summary>
/// <param name="newOwner"></param>
public void GiveOwnership(NetworkConnection newOwner)
{
GiveOwnership(newOwner, true);
}
/// <summary>
/// Gives ownership to newOwner.
/// </summary>
/// <param name="newOwner"></param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void GiveOwnership(NetworkConnection newOwner, bool asServer)
{
/* Additional asServer checks. */
if (asServer)
{
if (!NetworkManager.IsServer)
{
NetworkManager.LogWarning($"Ownership cannot be given for object {gameObject.name}. Only server may give ownership.");
return;
}
//If the same owner don't bother sending a message, just ignore request.
if (newOwner == Owner && asServer)
return;
if (newOwner != null && newOwner.IsActive && !newOwner.LoadedStartScenes(true))
{
NetworkManager.LogWarning($"Ownership has been transfered to ConnectionId {newOwner.ClientId} but this is not recommended until after they have loaded start scenes. You can be notified when a connection loads start scenes by using connection.OnLoadedStartScenes on the connection, or SceneManager.OnClientLoadStartScenes.");
}
}
bool activeNewOwner = (newOwner != null && newOwner.IsActive);
//Set prevOwner, disallowing null.
NetworkConnection prevOwner = Owner;
if (prevOwner == null)
prevOwner = NetworkManager.EmptyConnection;
SetOwner(newOwner);
/* Only modify objects if asServer or not
* host. When host, server would
* have already modified objects
* collection so there is no need
* for client to as well. */
if (asServer || !NetworkManager.IsHost)
{
if (activeNewOwner)
newOwner.AddObject(this);
if (prevOwner.IsValid && prevOwner != newOwner)
prevOwner.RemoveObject(this);
}
//After changing owners invoke callbacks.
InvokeOwnership(prevOwner, asServer);
//If asServer send updates to clients as needed.
if (asServer)
{
if (activeNewOwner)
ServerManager.Objects.RebuildObservers(this, newOwner);
using (PooledWriter writer = WriterPool.GetWriter())
{
writer.WritePacketId(PacketId.OwnershipChange);
writer.WriteNetworkObject(this);
writer.WriteNetworkConnection(Owner);
//If sharing then send to all observers.
if (NetworkManager.ServerManager.ShareIds)
{
NetworkManager.TransportManager.SendToClients((byte)Channel.Reliable, writer.GetArraySegment(), this);
}
//Only sending to old / new.
else
{
if (prevOwner.IsActive)
NetworkManager.TransportManager.SendToClient((byte)Channel.Reliable, writer.GetArraySegment(), prevOwner);
if (activeNewOwner)
NetworkManager.TransportManager.SendToClient((byte)Channel.Reliable, writer.GetArraySegment(), newOwner);
}
}
if (prevOwner.IsActive)
ServerManager.Objects.RebuildObservers(prevOwner);
}
}
/// <summary>
/// Initializes a predicted object for client.
/// </summary>
internal void InitializePredictedObject_Server(NetworkManager manager, NetworkConnection predictedSpawner)
{
NetworkManager = manager;
PredictedSpawner = predictedSpawner;
}
/// <summary>
/// Initializes a predicted object for client.
/// </summary>
internal void PreinitializePredictedObject_Client(NetworkManager manager, int objectId, NetworkConnection owner, NetworkConnection predictedSpawner)
{
PredictedSpawner = predictedSpawner;
Preinitialize_Internal(manager, objectId, owner, false);
}
/// <summary>
/// Deinitializes this predicted spawned object.
/// </summary>
internal void DeinitializePredictedObject_Client()
{
/* For the time being we're just going to disable the object because
* deinitializing instead could present a lot of problems.
* For example: if client deinitializes rpc links are unregistered,
* and if server had a rpc on the way already the link would
* not be found. This would cause the reader length to be wrong
* resulting in packet corruption. */
gameObject.SetActive(false);
}
/// <summary>
/// Sets the owner of this object.
/// </summary>
/// <param name="owner"></param>
/// <param name="allowNull"></param>
private void SetOwner(NetworkConnection owner)
{
Owner = owner;
}
/// <summary>
/// Returns if this NetworkObject is a scene object, and has changed.
/// </summary>
/// <returns></returns>
internal ChangedTransformProperties GetTransformChanges(TransformProperties stp)
{
ChangedTransformProperties ctp = ChangedTransformProperties.Unset;
if (transform.localPosition != stp.Position)
ctp |= ChangedTransformProperties.LocalPosition;
if (transform.localRotation != stp.Rotation)
ctp |= ChangedTransformProperties.LocalRotation;
if (transform.localScale != stp.LocalScale)
ctp |= ChangedTransformProperties.LocalScale;
return ctp;
}
/// <summary>
/// Returns if this NetworkObject is a scene object, and has changed.
/// </summary>
/// <returns></returns>
internal ChangedTransformProperties GetTransformChanges(GameObject prefab)
{
Transform t = prefab.transform;
ChangedTransformProperties ctp = ChangedTransformProperties.Unset;
if (transform.position != t.position)
ctp |= ChangedTransformProperties.LocalPosition;
if (transform.rotation != t.rotation)
ctp |= ChangedTransformProperties.LocalRotation;
if (transform.localScale != t.localScale)
ctp |= ChangedTransformProperties.LocalScale;
return ctp;
}
#region Editor.
#if UNITY_EDITOR
/// <summary>
/// Removes duplicate NetworkObject components on this object returning the removed count.
/// </summary>
/// <returns></returns>
internal int RemoveDuplicateNetworkObjects()
{
NetworkObject[] nobs = GetComponents<NetworkObject>();
for (int i = 1; i < nobs.Length; i++)
DestroyImmediate(nobs[i]);
return (nobs.Length - 1);
}
/// <summary>
/// Sets IsNested and returns the result.
/// </summary>
/// <returns></returns>
private bool SetIsNestedThroughTraversal()
{
Transform parent = transform.parent;
//Iterate long as parent isn't null, and isnt self.
while (parent != null && parent != transform)
{
if (parent.TryGetComponent<NetworkObject>(out _))
{
IsNested = true;
return IsNested;
}
parent = parent.parent;
}
//No NetworkObject found in parents, meaning this is not nested.
IsNested = false;
return IsNested;
}
private void OnValidate()
{
SetIsNestedThroughTraversal();
SceneUpdateNetworkBehaviours();
ReferenceIds_OnValidate();
if (IsGlobal && IsSceneObject)
Debug.LogWarning($"Object {gameObject.name} will have it's IsGlobal state ignored because it is a scene object. Instantiated copies will still be global. This warning is informative only.");
}
private void Reset()
{
SetIsNestedThroughTraversal();
SerializeTransformProperties();
SceneUpdateNetworkBehaviours();
ReferenceIds_Reset();
}
private void SceneUpdateNetworkBehaviours()
{
//In a scene.
if (!string.IsNullOrEmpty(gameObject.scene.name))
{
if (IsNested)
return;
byte componentIndex = 0;
UpdateNetworkBehaviours(null, ref componentIndex);
}
}
private void OnDrawGizmosSelected()
{
_editorOwnerId = (Owner == null) ? -1 : Owner.ClientId;
SerializeTransformProperties();
}
/// <summary>
/// Serializes TransformProperties to current transform properties.
/// </summary>
private void SerializeTransformProperties()
{
/* Use this method to set scene data since it doesn't need to exist outside
* the editor and because its updated regularly while selected. */
//If a scene object.
if (!EditorApplication.isPlaying && !string.IsNullOrEmpty(gameObject.scene.name))
{
SerializedTransformProperties = new TransformProperties(
transform.localPosition, transform.localRotation, transform.localScale);
}
}
#endif
#endregion
}
}