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); }