Esempio n. 1
0
        protected override void SendDeltaChanges(IEnumerable <SocketEndpoint> endpoints, ChangeType changeType)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeType);

                    if (HasFlag(changeType, ChangeType.Enabled))
                    {
                        message.Write(previousEnabled);
                    }

                    if (HasFlag(changeType, ChangeType.Properties))
                    {
                        message.Write((byte)previousProperties.renderMode);
                        message.Write(previousProperties.sortingLayerID);
                        message.Write(previousProperties.sortingOrder);
                        message.Write(previousProperties.overrideSorting);
                    }

                    message.Flush();
                    StateSynchronizationSceneManager.Instance.Send(endpoints, memoryStream.ToArray());
                }
        }
Esempio n. 2
0
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, byte changeFlags)
        {
            byte changeFlagsWithoutMaterialProperty = (byte)(changeFlags & ~ChangeType.MaterialProperty);

            if (changeFlags != ChangeType.MaterialProperty)
            {
                using (MemoryStream memoryStream = new MemoryStream())
                    using (BinaryWriter message = new BinaryWriter(memoryStream))
                    {
                        ComponentBroadcasterService.WriteHeader(message, this);
                        message.Write(changeFlagsWithoutMaterialProperty);

                        WriteRenderer(message, changeFlagsWithoutMaterialProperty);

                        message.Flush();
                        var data = memoryStream.ToArray();
                        StateSynchronizationSceneManager.Instance.Send(connections, ref data);
                    }
            }

            if (HasFlag(changeFlags, ChangeType.MaterialProperty))
            {
                MaterialsBroadcaster.SendMaterialPropertyChanges(connections, Renderer, TransformBroadcaster.PerformanceParameters, message =>
                {
                    ComponentBroadcasterService.WriteHeader(message, this);
                    message.Write(ChangeType.MaterialProperty);
                }, ShouldSynchronizeMaterialProperty);
            }
        }
        protected override void SendDeltaChanges(IEnumerable <SocketEndpoint> endpoints, byte changeFlags)
        {
            foreach (SocketEndpoint endpoint in endpoints)
            {
                PerConnectionInstantiationState state;
                if (perConnectionInstantiationState.TryGetValue(endpoint, out state))
                {
                    if (state.sendInstantiationRequest)
                    {
                        state.sendInstantiationRequest = false;
                        using (MemoryStream memoryStream = new MemoryStream())
                            using (BinaryWriter message = new BinaryWriter(memoryStream))
                            {
                                ComponentBroadcasterService.WriteHeader(message, this);

                                message.Write((byte)ChangeType.CreateObserverObject);
                                WriteInstantiationRequestParameters(message);

                                message.Flush();
                                endpoint.Send(memoryStream.ToArray());
                            }
                    }

                    if (state.sendTransformHierarchyBinding)
                    {
                        state.sendTransformHierarchyBinding = false;
                        SendTransformHierarchyBinding(endpoint);
                    }
                }
            }
        }
Esempio n. 4
0
        protected override void SendDeltaChanges(IEnumerable <SocketEndpoint> endpoints, ChangeType changeFlags)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeFlags);

                    if (HasFlag(changeFlags, ChangeType.Properties))
                    {
                        message.Write(previousProperties.enabled);
                        message.Write((byte)previousProperties.type);
                        message.Write(previousProperties.bounceIntensity);
                        message.Write(previousProperties.color);
                        message.Write(previousProperties.colorTemperature);
                        AssetService.Instance.TrySerializeTexture(message, previousProperties.cookie);
                        message.Write(previousProperties.cookieSize);
                        message.Write(previousProperties.cullingMask);
                        message.Write(previousProperties.intensity);
                        message.Write(previousProperties.range);
                        message.Write(previousProperties.shadowBias);
                        message.Write(previousProperties.shadowCustomResolution);
                        message.Write(previousProperties.shadowNearPlane);
                        message.Write(previousProperties.shadowNormalBias);
                        message.Write((byte)previousProperties.shadows);
                        message.Write(previousProperties.spotAngle);
                    }

                    message.Flush();
                    StateSynchronizationSceneManager.Instance.Send(endpoints, memoryStream.ToArray());
                }
        }
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, ChangeType changeType)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeType);

                    if (HasFlag(changeType, ChangeType.Enabled))
                    {
                        message.Write(previousEnabled);
                    }

                    if (HasFlag(changeType, ChangeType.Properties))
                    {
                        message.Write((byte)previousProperties.renderMode);
                        message.Write(previousProperties.sortingLayerID);
                        message.Write(previousProperties.sortingOrder);
                        message.Write(previousProperties.overrideSorting);
                    }

                    message.Flush();
                    memoryStream.TryGetBuffer(out var buffer);
                    StateSynchronizationSceneManager.Instance.Send(connections, buffer.Array, buffer.Offset, buffer.Count);
                }
        }
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, byte changeFlags)
        {
            foreach (INetworkConnection connection in connections)
            {
                PerConnectionInstantiationState state;
                if (perConnectionInstantiationState.TryGetValue(connection, out state))
                {
                    if (state.sendInstantiationRequest)
                    {
                        state.sendInstantiationRequest = false;
                        using (MemoryStream memoryStream = new MemoryStream())
                            using (BinaryWriter message = new BinaryWriter(memoryStream))
                            {
                                ComponentBroadcasterService.WriteHeader(message, this);

                                message.Write((byte)ChangeType.CreateObserverObject);
                                WriteInstantiationRequestParameters(message);

                                message.Flush();
                                var data = memoryStream.ToArray();
                                connection.Send(ref data);
                            }
                    }

                    if (state.sendTransformHierarchyBinding)
                    {
                        state.sendTransformHierarchyBinding = false;
                        SendTransformHierarchyBinding(connection);
                    }
                }
            }
        }
Esempio n. 7
0
        protected override void SendDeltaChanges(IEnumerable <SocketEndpoint> endpoints, TextMeshProBroadcasterChangeType changeFlags)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeFlags);
                    WriteText(changeFlags, message);

                    message.Flush();
                    StateSynchronizationSceneManager.Instance.Send(endpoints, memoryStream.ToArray());
                }
        }
Esempio n. 8
0
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, TextMeshProBroadcasterChangeType changeFlags)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeFlags);
                    WriteText(changeFlags, message);

                    message.Flush();
                    StateSynchronizationSceneManager.Instance.Send(connections, memoryStream.GetBuffer(), 0, memoryStream.Position);
                }
        }
        private void SendTransformHierarchyBinding(SocketEndpoint sendingEndpoint)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)ChangeType.BindTransformHierarchy);
                    DynamicObject.GetComponent <TransformBroadcaster>().WriteChildHierarchyTree(message);

                    message.Flush();

                    sendingEndpoint.Send(memoryStream.ToArray());
                }
        }
Esempio n. 10
0
        private void SendTransformHierarchyBinding(INetworkConnection connection)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)ChangeType.BindTransformHierarchy);
                    DynamicObject.GetComponent <TransformBroadcaster>().WriteChildHierarchyTree(message);

                    message.Flush();

                    connection.Send(memoryStream.GetBuffer(), 0, memoryStream.Position);
                }
        }
Esempio n. 11
0
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, ChangeType changeFlags)
        {
            if (changeFlags != ChangeType.MaterialProperty)
            {
                using (MemoryStream memoryStream = new MemoryStream())
                    using (BinaryWriter message = new BinaryWriter(memoryStream))
                    {
                        ComponentBroadcasterService.WriteHeader(message, this);

                        message.Write((byte)(changeFlags & ~ChangeType.MaterialProperty));

                        if (HasFlag(changeFlags, ChangeType.Data))
                        {
                            message.Write(ImageService.Instance.GetSpriteId(imageComp.overrideSprite));
                            message.Write(ImageService.Instance.GetSpriteId(imageComp.sprite));
                            message.Write(imageComp.fillAmount);
                            message.Write(imageComp.color);

                            message.Write(imageComp.alphaHitTestMinimumThreshold);
                            message.Write(imageComp.fillOrigin);
                            message.Write(imageComp.fillClockwise);
                            message.Write((byte)imageComp.fillMethod);
                            message.Write(imageComp.fillCenter);
                            message.Write(imageComp.preserveAspect);
                            message.Write((byte)imageComp.type);
                            message.Write(imageComp.enabled);
                        }

                        if (HasFlag(changeFlags, ChangeType.Materials))
                        {
                            MaterialsBroadcaster.SendMaterials(message, null, ShouldSynchronizeMaterialProperty);
                        }

                        message.Flush();
                        var data = memoryStream.ToArray();
                        StateSynchronizationSceneManager.Instance.Send(connections, ref data);
                    }
            }

            if (HasFlag(changeFlags, ChangeType.MaterialProperty))
            {
                MaterialsBroadcaster.SendMaterialPropertyChanges(connections, null, TransformBroadcaster.PerformanceParameters, m =>
                {
                    ImageService.Instance.WriteHeader(m, this);
                    m.Write((byte)ChangeType.MaterialProperty);
                }, ShouldSynchronizeMaterialProperty);
            }
        }
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, ChangeType changeFlags)
        {
            if (changeFlags != ChangeType.MaterialProperty)
            {
                using (MemoryStream memoryStream = new MemoryStream())
                    using (BinaryWriter message = new BinaryWriter(memoryStream))
                    {
                        ComponentBroadcasterService.WriteHeader(message, this);

                        message.Write((byte)(changeFlags & ~ChangeType.MaterialProperty));

                        if (HasFlag(changeFlags, ChangeType.Text))
                        {
                            message.Write(textComp.text);
                        }
                        if (HasFlag(changeFlags, ChangeType.FontAndPlacement))
                        {
                            message.Write((byte)textComp.alignment);
                            message.Write(textComp.color);
                            message.Write(textComp.fontSize);
                            message.Write((byte)textComp.fontStyle);
                            message.Write(textComp.lineSpacing);
                            message.Write((byte)textComp.horizontalOverflow);
                            message.Write((byte)textComp.verticalOverflow);
                            message.Write(FontAssetId);
                        }
                        if (HasFlag(changeFlags, ChangeType.Materials))
                        {
                            MaterialsBroadcaster.SendMaterials(message, null, ShouldSynchronizeMaterialProperty);
                        }

                        message.Flush();
                        var data = memoryStream.ToArray();
                        StateSynchronizationSceneManager.Instance.Send(connections, ref data);
                    }
            }

            if (HasFlag(changeFlags, ChangeType.MaterialProperty))
            {
                MaterialsBroadcaster.SendMaterialPropertyChanges(connections, null, TransformBroadcaster.PerformanceParameters, message =>
                {
                    TextService.Instance.WriteHeader(message, this);
                    message.Write((byte)ChangeType.MaterialProperty);
                }, ShouldSynchronizeMaterialProperty);
            }
        }
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, ChangeType changeFlags)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeFlags);

                    if (HasFlag(changeFlags, ChangeType.Properties))
                    {
                        message.Write(AudioClipAssetId);
                        message.Write(AudioMixerGroupAssetId);
                        message.Write(previousProperties.bypassEffects);
                        message.Write(previousProperties.bypassListenerEffects);
                        message.Write(previousProperties.bypassReverbZones);
                        message.Write(previousProperties.dopplerLevel);
                        message.Write(previousProperties.enabled);
                        message.Write(previousProperties.ignoreListenerPause);
                        message.Write(previousProperties.ignoreListenerVolume);
                        message.Write(previousProperties.loop);
                        message.Write(previousProperties.maxDistance);
                        message.Write(previousProperties.minDistance);
                        message.Write(previousProperties.mute);
                        message.Write(previousProperties.panStereo);
                        message.Write(previousProperties.pitch);
                        message.Write(previousProperties.priority);
                        message.Write(previousProperties.reverbZoneMix);
                        message.Write((byte)previousProperties.rolloffMode);
                        message.Write(previousProperties.spatialBlend);
                        message.Write(previousProperties.spatialize);
                        message.Write(previousProperties.spatializePostEffects);
                        message.Write(previousProperties.spread);
                        message.Write((byte)previousProperties.velocityUpdateMode);
                    }
                    if (HasFlag(changeFlags, ChangeType.Volume))
                    {
                        message.Write(previousVolume);
                    }

                    message.Flush();
                    memoryStream.TryGetBuffer(out var buffer);
                    StateSynchronizationSceneManager.Instance.Send(connections, buffer.Array, buffer.Offset, buffer.Count);
                }
        }
Esempio n. 14
0
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, ChangeType changeFlags)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeFlags);

                    if (HasFlag(changeFlags, ChangeType.Properties))
                    {
                        message.Write(previousEnabled);
                    }

                    message.Flush();
                    var data = memoryStream.ToArray();
                    StateSynchronizationSceneManager.Instance.Send(connections, ref data);
                }
        }
Esempio n. 15
0
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, ChangeType changeFlags)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeFlags);

                    if (HasFlag(changeFlags, ChangeType.Properties))
                    {
                        message.Write(previousProperties.isMainCamera);
                        message.Write(previousProperties.cullingMask);
                    }

                    message.Flush();
                    StateSynchronizationSceneManager.Instance.Send(connections, memoryStream.GetBuffer(), 0, memoryStream.Position);
                }
        }
        protected override void SendDeltaChanges(IEnumerable <SocketEndpoint> endpoints, ChangeType changeFlags)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeFlags);

                    if (HasFlag(changeFlags, ChangeType.Properties))
                    {
                        message.Write(previousValues.enabled);
                        message.Write(previousValues.showMaskGraphic);
                    }

                    message.Flush();
                    StateSynchronizationSceneManager.Instance.Send(endpoints, memoryStream.ToArray());
                }
        }
Esempio n. 17
0
        protected override void SendDeltaChanges(IEnumerable <INetworkConnection> connections, ChangeType changeFlags)
        {
            using (MemoryStream memoryStream = new MemoryStream())
                using (BinaryWriter message = new BinaryWriter(memoryStream))
                {
                    ComponentBroadcasterService.WriteHeader(message, this);

                    message.Write((byte)changeFlags);

                    if (HasFlag(changeFlags, ChangeType.Properties))
                    {
                        message.Write(previousValues.alpha);
                        message.Write(previousValues.ignoreParentGroups);
                    }

                    message.Flush();
                    memoryStream.TryGetBuffer(out var buffer);
                    StateSynchronizationSceneManager.Instance.Send(connections, buffer.Array, buffer.Offset, buffer.Count);
                }
        }