private void EnsureChildTransformsAreSynchronized()
{
for (int i = 0; i < this.transform.childCount; i++)
{
ComponentExtensions.EnsureComponent <TransformBroadcaster>(this.transform.GetChild(i).gameObject);
}
}
protected override void EnsureTextComponent()
{
if (TextMeshObserver == null)
{
TextMeshObserver = ComponentExtensions.EnsureComponent <TextMeshPro>(gameObject);
}
}
public static StateSynchronizationPerformanceParameters CreateEmpty()
{
if (emptyParametersGameObject == null)
{
emptyParametersGameObject = new GameObject("EmptySychronizationPerformanceParameters");
}
return(ComponentExtensions.EnsureComponent <StateSynchronizationPerformanceParameters>(emptyParametersGameObject));
}
protected override void EnsureTextComponent()
{
#if STATESYNC_TEXTMESHPRO
if (TextMeshObserver == null)
{
TextMeshObserver = ComponentExtensions.EnsureComponent <TextMeshPro>(gameObject);
}
#endif
}
protected override void EnsureTextComponent()
{
if (TextMeshObserver == null)
{
RectTransformBroadcaster srt = new RectTransformBroadcaster();
RectTransform rectTransform = GetComponent <RectTransform>();
srt.Copy(rectTransform);
TextMeshObserver = ComponentExtensions.EnsureComponent <TextMeshProUGUI>(gameObject);
srt.Apply(rectTransform);
}
}
private void EnsureChildTransformsAreSynchronized()
{
if (this.CachedGameObject.tag == SpectatorViewChildrenHiddenTag)
{
return;
}
for (int i = 0; i < CachedTransform.childCount; i++)
{
ComponentExtensions.EnsureComponent <TransformBroadcaster>(CachedTransform.GetChild(i).gameObject);
}
}
public bool AttachSkinnedMeshRenderer(GameObject gameObject, Guid assetId)
{
Mesh mesh = meshAssets.GetAsset(assetId);
if (mesh != null)
{
SkinnedMeshRenderer renderer = ComponentExtensions.EnsureComponent <SkinnedMeshRenderer>(gameObject);
renderer.sharedMesh = mesh;
return(true);
}
return(false);
}
public bool AttachMeshFilter(GameObject gameObject, AssetId assetId)
{
ComponentExtensions.EnsureComponent <MeshRenderer>(gameObject);
Mesh mesh = meshAssets.GetAsset(assetId);
if (mesh != null)
{
MeshFilter filter = ComponentExtensions.EnsureComponent <MeshFilter>(gameObject);
filter.sharedMesh = mesh;
return(true);
}
return(false);
}
private void Update()
{
if (connectionManager == null)
{
return;
}
UpdateExtension();
if (HasConnections && BroadcasterSettings.IsInitialized && BroadcasterSettings.Instance && BroadcasterSettings.Instance.AutomaticallyBroadcastAllGameObjects)
{
for (int i = 0; i < SceneManager.sceneCount; i++)
{
Scene scene = SceneManager.GetSceneAt(i);
foreach (GameObject root in scene.GetRootGameObjects())
{
ComponentExtensions.EnsureComponent <TransformBroadcaster>(root);
}
}
}
}
private void Update()
{
if (connectionManager == null)
{
return;
}
UpdateExtension();
if (HasConnections && BroadcasterSettings.IsInitialized && BroadcasterSettings.Instance && BroadcasterSettings.Instance.AutomaticallyBroadcastAllGameObjects)
{
for (int i = 0; i < SceneManager.sceneCount; i++)
{
Scene scene = SceneManager.GetSceneAt(i);
foreach (GameObject root in scene.GetRootGameObjects())
{
ComponentExtensions.EnsureComponent <TransformBroadcaster>(root);
}
}
// GameObjects that are marked DontDestroyOnLoad exist in a special scene, and that scene
// cannot be enumerated via the SceneManager. The only way to access that scene is from a
// GameObject inside that scene, so we need to create a GameObject we have access to inside
// that scene in order to enumerate all of its root GameObjects.
if (dontDestroyOnLoadGameObject == null)
{
dontDestroyOnLoadGameObject = new GameObject("StateSynchronizationBroadcaster_DontDestroyOnLoad");
DontDestroyOnLoad(dontDestroyOnLoadGameObject);
}
foreach (GameObject root in dontDestroyOnLoadGameObject.scene.GetRootGameObjects())
{
ComponentExtensions.EnsureComponent <TransformBroadcaster>(root);
}
}
}
/// <summary>
/// Ensures an <see cref="IComponentObserver"/> exists on the provided game object and relays it a network message
/// </summary>
/// <param name="sendingEndpoint">Endpoint that sent the message</param>
/// <param name="message">network message</param>
/// <param name="mirror">game object to broadcast</param>
public virtual void Read(SocketEndpoint sendingEndpoint, BinaryReader message, GameObject mirror)
{
ObserverType comp = ComponentExtensions.EnsureComponent <ObserverType>(mirror);
comp.Read(sendingEndpoint, message);
}
/// <summary>
/// Ensures that the <see cref="IComponentObserver"/> type defined for the service exists for the provided game object
/// </summary>
/// <param name="mirror"></param>
public virtual void Create(GameObject mirror)
{
ComponentExtensions.EnsureComponent <ObserverType>(mirror);
}
/// <summary>
/// Reads a network message and updates local state data
/// </summary>
/// <param name="sendingEndpoint">Sender endpoint</param>
/// <param name="message">Received payload</param>
public override void Read(SocketEndpoint sendingEndpoint, BinaryReader message)
{
short id = message.ReadInt16();
TransformBroadcasterChangeType changeType = (TransformBroadcasterChangeType)message.ReadByte();
GameObject mirror = null;
RectTransform rectTransform = null;
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.RectTransform))
{
mirror = mirror ?? StateSynchronizationSceneManager.Instance.GetOrCreateMirror(id);
rectTransform = mirror.GetComponent <RectTransform>();
if (rectTransform == null)
{
rectTransform = mirror.AddComponent <RectTransform>();
}
}
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.Name))
{
mirror = mirror ?? StateSynchronizationSceneManager.Instance.GetOrCreateMirror(id);
mirror.name = message.ReadString();
}
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.Layer))
{
mirror = mirror ?? StateSynchronizationSceneManager.Instance.GetOrCreateMirror(id);
mirror.layer = message.ReadInt32();
}
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.Parent))
{
mirror = mirror ?? StateSynchronizationSceneManager.Instance.GetOrCreateMirror(id);
short parentId = message.ReadInt16();
int siblingIndex = message.ReadInt32();
Transform newParent;
if (parentId == TransformBroadcaster.NullTransformId)
{
newParent = StateSynchronizationSceneManager.Instance.RootTransform;
}
else
{
newParent = StateSynchronizationSceneManager.Instance.GetOrCreateMirror(parentId).transform;
}
if (siblingIndex < newParent.childCount)
{
Transform existingChildAtIndex = newParent.GetChild(siblingIndex);
if (existingChildAtIndex.gameObject.name == temporaryGameObjectName)
{
Destroy(existingChildAtIndex.gameObject);
}
}
else
{
for (int i = newParent.childCount; i < siblingIndex; i++)
{
GameObject temp = new GameObject(temporaryGameObjectName);
temp.SetActive(false);
temp.transform.SetParent(newParent);
temp.transform.SetSiblingIndex(i);
}
}
mirror.transform.SetParent(newParent, worldPositionStays: false);
mirror.transform.SetSiblingIndex(siblingIndex);
}
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.Position))
{
mirror = mirror ?? StateSynchronizationSceneManager.Instance.GetOrCreateMirror(id);
mirror.transform.localPosition = message.ReadVector3();
}
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.Rotation))
{
mirror = mirror ?? StateSynchronizationSceneManager.Instance.GetOrCreateMirror(id);
mirror.transform.localRotation = message.ReadQuaternion();
}
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.Scale))
{
mirror = mirror ?? StateSynchronizationSceneManager.Instance.GetOrCreateMirror(id);
mirror.transform.localScale = message.ReadVector3();
}
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.IsActive))
{
bool isActive = message.ReadBoolean();
if (isActive)
{
mirror = mirror ?? StateSynchronizationSceneManager.Instance.GetOrCreateMirror(id);
mirror.SetActive(true);
}
else
{
mirror = StateSynchronizationSceneManager.Instance.FindGameObjectWithId(id);
if (mirror != null)
{
mirror.SetActive(false);
}
}
}
if (TransformBroadcaster.HasFlag(changeType, TransformBroadcasterChangeType.RectTransform))
{
RectTransformBroadcaster.Read(rectTransform, message);
ComponentExtensions.EnsureComponent <RectTransformObserver>(mirror).CaptureRectTransform();
}
}
/// <summary>
/// Ensures an <see cref="IComponentObserver"/> exists on the provided game object and relays it a network message
/// </summary>
/// <param name="connection">Connection that sent the message</param>
/// <param name="message">network message</param>
/// <param name="mirror">game object to broadcast</param>
public virtual void Read(INetworkConnection connection, BinaryReader message, GameObject mirror)
{
ObserverType comp = ComponentExtensions.EnsureComponent <ObserverType>(mirror);
comp.Read(connection, message);
}
