void switchCaseFunc(FduMultiAttributeObserverOP op, ref NetworkState.NETWORK_STATE_TYPE state)
        {
            for (int i = 1; i < attrList.Length; ++i)
            {
                if (!getObservedState(i))
                {
                    continue;
                }
                switch (i)
                {
                case 1:     //TextContent
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendString(text.text);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.text = BufferedNetworkUtilsClient.ReadString(ref state);
                    }
                    break;

                case 2:    //Color
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            text.color = FduInterpolationInterface.getNextColorValue_new(text.color, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendColor(text.color);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        text.color = BufferedNetworkUtilsClient.ReadColor(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadColor(ref state));
                    }
                    break;

                case 3:     //FontStyle
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)text.fontStyle);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.fontStyle = (FontStyle)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 4:    //FontSize
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            text.fontSize = FduInterpolationInterface.getNextIntValue_new(text.fontSize, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendInt(text.fontSize);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        text.fontSize = BufferedNetworkUtilsClient.ReadInt(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadInt(ref state));
                    }
                    break;

                case 5:    //LineSpacing
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            text.lineSpacing = FduInterpolationInterface.getNextFloatValue_new(text.lineSpacing, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendFloat(text.lineSpacing);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        text.lineSpacing = BufferedNetworkUtilsClient.ReadFloat(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadFloat(ref state));
                    }
                    break;

                case 6:    //SupportRichText
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendBool(text.supportRichText);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.supportRichText = BufferedNetworkUtilsClient.ReadBool(ref state);
                    }
                    break;

                case 7:    //Aligment
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)text.alignment);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.alignment = (TextAnchor)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 8:    //AlignByGeometry
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendBool(text.alignByGeometry);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.alignByGeometry = BufferedNetworkUtilsClient.ReadBool(ref state);
                    }
                    break;

                case 9:    //HorizontalOverflow
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)text.horizontalOverflow);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.horizontalOverflow = (HorizontalWrapMode)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 10:    //VerticalOverflow
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)text.verticalOverflow);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.verticalOverflow = (VerticalWrapMode)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 11:    //BestFit
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendBool(text.resizeTextForBestFit);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.resizeTextForBestFit = BufferedNetworkUtilsClient.ReadBool(ref state);
                    }
                    break;

                case 12:    //RaycastTarget
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendBool(text.raycastTarget);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        text.raycastTarget = BufferedNetworkUtilsClient.ReadBool(ref state);
                    }
                    break;

                case 31:    //Interpolation Option
                    break;
                }
            }
        }
Beispiel #2
0
        void switchCaseFunc(FduMultiAttributeObserverOP op, ref NetworkState.NETWORK_STATE_TYPE state)
        {
            for (int i = 1; i < attrList.Length; ++i)
            {
                if (!getObservedState(i))
                {
                    continue;
                }
                switch (i)
                {
                case 1:    //Color
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            image.color = FduInterpolationInterface.getNextColorValue_new(image.color, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendColor(image.color);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        image.color = BufferedNetworkUtilsClient.ReadColor(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadColor(ref state));
                    }
                    break;

                case 2:    //RaycastTarget
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendBool(image.raycastTarget);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        image.raycastTarget = BufferedNetworkUtilsClient.ReadBool(ref state);
                    }
                    break;

                case 3:    //FillMethod
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)image.fillMethod);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        image.fillMethod = (Image.FillMethod)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 4:    //FillAmount
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            image.fillAmount = FduInterpolationInterface.getNextFloatValue_new(image.fillAmount, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendFloat(image.fillAmount);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        image.fillAmount = BufferedNetworkUtilsClient.ReadFloat(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadFloat(ref state));
                    }
                    break;

                case 5:    //FillCenter
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendBool(image.fillCenter);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        image.fillCenter = BufferedNetworkUtilsClient.ReadBool(ref state);
                    }
                    break;

                case 6:    //FillClockwise
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendBool(image.fillClockwise);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        image.fillClockwise = BufferedNetworkUtilsClient.ReadBool(ref state);
                    }
                    break;

                case 7:    //FillOrigin
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            image.fillOrigin = FduInterpolationInterface.getNextIntValue_new(image.fillOrigin, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendInt(image.fillOrigin);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        image.fillOrigin = BufferedNetworkUtilsClient.ReadInt(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadInt(ref state));
                    }
                    break;

                case 8:    //ImageType
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)image.type);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        image.type = (Image.Type)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 9:    //Image
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        bool changeFlag = false;
                        if (image.sprite != null && image.sprite.GetInstanceID() != spriteId)
                        {     //通过对比InstanceId判断该精灵是否被替换
                            changeFlag = true;
                            spriteId   = image.sprite.GetInstanceID();
                        }

                        BufferedNetworkUtilsServer.SendBool(changeFlag);
                        if (changeFlag)    //若已经变化了 则将图片分解为JPG格式传送至节点
                        {
                            byte[] arr;
                            try
                            {
                                arr = image.sprite.texture.EncodeToJPG();
                                BufferedNetworkUtilsServer.SendByteArray(arr);
                                BufferedNetworkUtilsServer.SendRect(image.sprite.textureRect);
                                BufferedNetworkUtilsServer.SendVector2(image.sprite.pivot);
                            }
                            catch (System.Exception e)
                            {
                                Debug.LogError(e.Message);
                            }
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)     //从节点先判断有没有图片传来 然后再解析
                    {
                        bool changeFlag = BufferedNetworkUtilsClient.ReadBool(ref state);
                        if (changeFlag)
                        {
                            byte[]    bytes   = BufferedNetworkUtilsClient.ReadByteArray(ref state);
                            Rect      rect    = BufferedNetworkUtilsClient.ReadRect(ref state);
                            Vector2   pivot   = BufferedNetworkUtilsClient.ReadVector2(ref state);
                            Texture2D texture = new Texture2D((int)GetComponent <RectTransform>().rect.width, (int)GetComponent <RectTransform>().rect.height);
                            texture.LoadImage(bytes);
                            image.sprite = Sprite.Create(texture, rect, pivot);
                        }
                    }
                    break;
                }
            }
        }
Beispiel #3
0
 void switchCaseFunc(FduMultiAttributeObserverOP op, ref NetworkState.NETWORK_STATE_TYPE state)
 {
     for (int i = 0; i < m_parameterList.Count; ++i)
     {
         FduAnimatorParameter para = m_parameterList[i];
         if (para.type == AnimatorControllerParameterType.Bool) //参数为布尔类型
         {
             if (op == FduMultiAttributeObserverOP.SendData)
             {
                 BufferedNetworkUtilsServer.SendBool(animator.GetBool(para.name));
             }
             else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
             {
                 animator.SetBool(para.name, BufferedNetworkUtilsClient.ReadBool(ref state));
             }
         }
         else if (para.type == AnimatorControllerParameterType.Trigger)//参数为trigger类型
         {
             if (op == FduMultiAttributeObserverOP.SendData)
             {
                 BufferedNetworkUtilsServer.SendBool(triggerCacheList.Contains(para.name));
             }
             else if (op == FduMultiAttributeObserverOP.Receive_Direct)
             {
                 animator.SetBool(para.name, BufferedNetworkUtilsClient.ReadBool(ref state));
             }
             else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
             {
                 bool triggerValue = BufferedNetworkUtilsClient.ReadBool(ref state);
                 if (triggerValue)
                 {
                     animator.SetTrigger(para.name);
                 }
                 else
                 {
                     animator.ResetTrigger(para.name);
                 }
             }
         }
         else if (para.type == AnimatorControllerParameterType.Int)//参数为int类型
         {
             if (op == FduMultiAttributeObserverOP.SendData)
             {
                 BufferedNetworkUtilsServer.SendInt(animator.GetInteger(para.name));
             }
             else if (op == FduMultiAttributeObserverOP.Receive_Direct)
             {
                 animator.SetInteger(para.name, BufferedNetworkUtilsClient.ReadInt(ref state));
             }
             else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
             {
                 setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadInt(ref state));
             }
             else if (op == FduMultiAttributeObserverOP.Update)
             {
                 if (getCachedProperytyCount(i) > 0)
                 {
                     animator.SetInteger(para.name, FduInterpolationInterface.getNextIntValue_new(animator.GetInteger(para.name), i, this));
                 }
             }
         }
         else if (para.type == AnimatorControllerParameterType.Float)//参数为float类型
         {
             if (op == FduMultiAttributeObserverOP.SendData)
             {
                 BufferedNetworkUtilsServer.SendFloat(animator.GetFloat(para.name));
             }
             else if (op == FduMultiAttributeObserverOP.Receive_Direct)
             {
                 animator.SetFloat(para.name, BufferedNetworkUtilsClient.ReadFloat(ref state));
             }
             else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
             {
                 setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadFloat(ref state));
             }
             else if (op == FduMultiAttributeObserverOP.Update)
             {
                 if (getCachedProperytyCount(i) > 0)
                 {
                     animator.SetFloat(para.name, FduInterpolationInterface.getNextFloatValue_new(animator.GetFloat(para.name), i, this));
                 }
             }
         }
     }
 }
Beispiel #4
0
        void switchCaseFunc(FduMultiAttributeObserverOP op, ref NetworkState.NETWORK_STATE_TYPE state)
        {
            for (int i = 1; i < attrList.Length; ++i)
            {
                if (!getObservedState(i))
                {
                    continue;
                }
                switch (i)
                {
                case 1:    //MaxValue
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            slider.maxValue = FduInterpolationInterface.getNextFloatValue_new(slider.maxValue, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendFloat(slider.maxValue);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        slider.maxValue = BufferedNetworkUtilsClient.ReadFloat(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadFloat(ref state));
                    }
                    break;

                case 2:    //CurrentValue
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            slider.value = FduInterpolationInterface.getNextFloatValue_new(slider.value, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendFloat(slider.value);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        slider.value = BufferedNetworkUtilsClient.ReadFloat(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadFloat(ref state));
                    }
                    break;

                case 3:    //MinValue
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            slider.minValue = FduInterpolationInterface.getNextFloatValue_new(slider.minValue, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendFloat(slider.minValue);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        slider.minValue = BufferedNetworkUtilsClient.ReadFloat(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadFloat(ref state));
                    }
                    break;

                case 4:    //Direction
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)slider.direction);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        slider.direction = (Slider.Direction)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 5:    //NormalizedValue
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            slider.normalizedValue = FduInterpolationInterface.getNextFloatValue_new(slider.normalizedValue, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendFloat(slider.normalizedValue);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        slider.normalizedValue = BufferedNetworkUtilsClient.ReadFloat(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadFloat(ref state));
                    }
                    break;

                case 6:    //WholeNumbers
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendBool(slider.wholeNumbers);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        slider.wholeNumbers = BufferedNetworkUtilsClient.ReadBool(ref state);
                    }
                    break;
                }
            }
        }
        void switchCaseFunc(FduMultiAttributeObserverOP op, ref NetworkState.NETWORK_STATE_TYPE state)
        {
            for (int i = 1; i < attributeList.Length; ++i)
            {
                if (!getObservedState(i)) //如果editor中没有选择监控该属性 则直接跳过
                {
                    continue;
                }

                switch (i)
                {
                case 1:    //position
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            _transform.position = FduInterpolationInterface.getNextVector3Value_new(_transform.position, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector3(_transform.position);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        _transform.position = BufferedNetworkUtilsClient.ReadVector3(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector3(ref state));
                    }
                    break;

                case 2:    //rotation
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            _transform.rotation = FduInterpolationInterface.getNextQuaternionValue_new(_transform.rotation, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendQuaternion(_transform.rotation);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        _transform.rotation = BufferedNetworkUtilsClient.ReadQuaternion(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadQuaternion(ref state));
                    }
                    break;

                case 3:    //scale
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            _transform.localScale = FduInterpolationInterface.getNextVector3Value_new(_transform.localScale, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector3(_transform.localScale);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        _transform.localScale = BufferedNetworkUtilsClient.ReadVector3(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector3(ref state));
                    }
                    break;

                case 4:    //parent: 对于父节点的监控 这里只是一个不完全的解决方案 获取到父节点的路径 传输过去 然后在从节点解析。如果路径不唯一(因为可以同名)就会找不到对于的父节点
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        string parentPath;
                        if (_transform.parent == null)
                        {
                            parentPath = "";
                        }
                        else
                        {
                            parentPath = FduSupportClass.getGameObjectPath(_transform.parent.gameObject);
                        }

                        if (parentPath == null)
                        {
                            parentPath = "";
                        }
                        BufferedNetworkUtilsServer.SendString(parentPath);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        string parentPath;
                        if (_transform.parent == null)
                        {
                            parentPath = "";
                        }
                        else
                        {
                            parentPath = FduSupportClass.getGameObjectPath(_transform.parent.gameObject);
                        }

                        if (parentPath == null)
                        {
                            parentPath = "";
                        }
                        string getPath = BufferedNetworkUtilsClient.ReadString(ref state);
                        if (parentPath != getPath)     //hierarchy changed
                        {
                            GameObject go = FduSupportClass.getGameObjectByPath(getPath);
                            if (go == null)
                            {
                                _transform.SetParent(null);
                            }
                            else
                            {
                                _transform.SetParent(go.transform);
                            }
                        }
                    }
                    break;

                case 5:    //LocalPosition
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            _transform.localPosition = FduInterpolationInterface.getNextVector3Value_new(_transform.localPosition, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector3(_transform.localPosition);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        _transform.localPosition = BufferedNetworkUtilsClient.ReadVector3(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector3(ref state));
                    }
                    break;

                case 6:    //LocalRotation;
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            _transform.localRotation = FduInterpolationInterface.getNextQuaternionValue_new(_transform.localRotation, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendQuaternion(_transform.localRotation);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        _transform.localRotation = BufferedNetworkUtilsClient.ReadQuaternion(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadQuaternion(ref state));
                    }
                    break;

                case 7:    //LocalScale
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            _transform.localScale = FduInterpolationInterface.getNextVector3Value_new(_transform.localScale, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector3(_transform.localScale);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        _transform.localScale = BufferedNetworkUtilsClient.ReadVector3(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector3(ref state));
                    }
                    break;

                case 8:    //EulerAngle
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            _transform.eulerAngles = FduInterpolationInterface.getNextVector3Value_new(_transform.eulerAngles, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector3(_transform.eulerAngles);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        _transform.eulerAngles = BufferedNetworkUtilsClient.ReadVector3(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector3(ref state));
                    }
                    break;

                case 9:    //LocalEulerAngle
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            _transform.localEulerAngles = FduInterpolationInterface.getNextVector3Value_new(_transform.localEulerAngles, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector3(_transform.localEulerAngles);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        _transform.localEulerAngles = BufferedNetworkUtilsClient.ReadVector3(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector3(ref state));
                    }
                    break;

                default:
                    break;
                }
            }
        }
Beispiel #6
0
        void switchCaseFunc(FduMultiAttributeObserverOP op, ref NetworkState.NETWORK_STATE_TYPE state)
        {
            for (int i = 1; i < attrList.Length; ++i)
            {
                if (!getObservedState(i))
                {
                    continue;
                }
                switch (i)
                {
                case 1:     //InputContent
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendString(inputField.text);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        inputField.text = BufferedNetworkUtilsClient.ReadString(ref state);
                    }
                    break;

                case 2:    //CaretPosition
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            inputField.caretPosition = FduInterpolationInterface.getNextIntValue_new(inputField.caretPosition, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendInt(inputField.caretPosition);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        inputField.caretPosition = BufferedNetworkUtilsClient.ReadInt(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadInt(ref state));
                    }
                    break;

                case 3:    //CharacterValidation
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)inputField.characterValidation);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        inputField.characterValidation = (InputField.CharacterValidation)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 4:    //ContentType
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)inputField.contentType);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        inputField.contentType = (InputField.ContentType)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 5:    //InputType
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)inputField.inputType);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        inputField.inputType = (InputField.InputType)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 6:    //KeyboardType
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)inputField.keyboardType);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        inputField.keyboardType = (TouchScreenKeyboardType)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 7:    //LineType
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendByte((byte)inputField.lineType);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        inputField.lineType = (InputField.LineType)BufferedNetworkUtilsClient.ReadByte(ref state);
                    }
                    break;

                case 29:    //Remove On Value Change CallBack On Slave
                    break;

                case 30:    //Remove On End Edit CallBack On Slave
                    break;

                case 31:    //Interpolation Option
                    break;
                }
            }
        }
Beispiel #7
0
        void switchCaseFunc(FduMultiAttributeObserverOP op, ref NetworkState.NETWORK_STATE_TYPE state)
        {
            for (int i = 1; i < attrList.Length; ++i)
            {
                if (!getObservedState(i))
                {
                    continue;
                }
                switch (i)
                {
                case 1:     //AnchoredPosition
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.anchoredPosition = FduInterpolationInterface.getNextVector2Value_new(rectTransform.anchoredPosition, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector2(rectTransform.anchoredPosition);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.anchoredPosition = BufferedNetworkUtilsClient.ReadVector2(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector2(ref state));
                    }
                    break;

                case 2:    //AnchoredPosition3D
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.anchoredPosition3D = FduInterpolationInterface.getNextVector3Value_new(rectTransform.anchoredPosition3D, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector3(rectTransform.anchoredPosition3D);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.anchoredPosition3D = BufferedNetworkUtilsClient.ReadVector3(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector3(ref state));
                    }
                    break;

                case 3:    //Rotation
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.rotation = FduInterpolationInterface.getNextQuaternionValue_new(rectTransform.rotation, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendQuaternion(rectTransform.rotation);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.rotation = BufferedNetworkUtilsClient.ReadQuaternion(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadQuaternion(ref state));
                    }
                    break;

                case 4:    //Scale
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.localScale = FduInterpolationInterface.getNextVector3Value_new(rectTransform.localScale, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector3(rectTransform.localScale);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.localScale = BufferedNetworkUtilsClient.ReadVector3(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty_append(i, BufferedNetworkUtilsClient.ReadVector3(ref state));
                    }
                    break;

                case 5:    //Parent
                    if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        string parentPath;
                        if (rectTransform.parent == null)
                        {
                            parentPath = "";
                        }
                        else
                        {
                            parentPath = FduSupportClass.getGameObjectPath(rectTransform.parent.gameObject);
                        }

                        if (parentPath == null)
                        {
                            parentPath = "";
                        }
                        BufferedNetworkUtilsServer.SendString(parentPath);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct || op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        string parentPath;
                        if (rectTransform.parent == null)
                        {
                            parentPath = "";
                        }
                        else
                        {
                            parentPath = FduSupportClass.getGameObjectPath(rectTransform.parent.gameObject);
                        }

                        if (parentPath == null)
                        {
                            parentPath = "";
                        }
                        string getPath = BufferedNetworkUtilsClient.ReadString(ref state);
                        if (parentPath != getPath)     //hierarchy changed
                        {
                            GameObject go = FduSupportClass.getGameObjectByPath(getPath);
                            if (go == null)
                            {
                                rectTransform.SetParent(null);
                            }
                            else
                            {
                                rectTransform.SetParent(go.transform);
                            }
                        }
                    }
                    break;

                case 6:    //AnchorMax
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.anchorMax = FduInterpolationInterface.getNextVector2Value_new(rectTransform.anchorMax, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector2(rectTransform.anchorMax);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.anchorMax = BufferedNetworkUtilsClient.ReadVector2(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadVector2(ref state));
                    }
                    break;

                case 7:    //AnchorMin
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.anchorMin = FduInterpolationInterface.getNextVector2Value_new(rectTransform.anchorMin, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector2(rectTransform.anchorMin);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.anchorMin = BufferedNetworkUtilsClient.ReadVector2(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadVector2(ref state));
                    }
                    break;

                case 8:    //OffsetMax
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.offsetMax = FduInterpolationInterface.getNextVector2Value_new(rectTransform.offsetMax, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector2(rectTransform.offsetMax);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.offsetMax = BufferedNetworkUtilsClient.ReadVector2(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadVector2(ref state));
                    }
                    break;

                case 9:    //OffsetMin
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.offsetMin = FduInterpolationInterface.getNextVector2Value_new(rectTransform.offsetMin, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector2(rectTransform.offsetMin);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.offsetMin = BufferedNetworkUtilsClient.ReadVector2(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadVector2(ref state));
                    }
                    break;

                case 10:    //Pivot
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.pivot = FduInterpolationInterface.getNextVector2Value_new(rectTransform.pivot, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector2(rectTransform.pivot);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.pivot = BufferedNetworkUtilsClient.ReadVector2(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadVector2(ref state));
                    }
                    break;

                case 11:    //SizeDelta
                    if (op == FduMultiAttributeObserverOP.Update)
                    {
                        if (getCachedProperytyCount(i) > 0)
                        {
                            rectTransform.sizeDelta = FduInterpolationInterface.getNextVector2Value_new(rectTransform.sizeDelta, i, this);
                        }
                    }
                    else if (op == FduMultiAttributeObserverOP.SendData)
                    {
                        BufferedNetworkUtilsServer.SendVector2(rectTransform.sizeDelta);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Direct)
                    {
                        rectTransform.sizeDelta = BufferedNetworkUtilsClient.ReadVector2(ref state);
                    }
                    else if (op == FduMultiAttributeObserverOP.Receive_Interpolation)
                    {
                        setCachedProperty(i, BufferedNetworkUtilsClient.ReadVector2(ref state));
                    }
                    break;
                }
            }
        }