public override void Serialize()
{
BufferedNetworkUtilsServer.SendInt(_sendList.Count);
foreach (SerializeData data in _sendList)
{
BufferedNetworkUtilsServer.SendString(data.name);
BufferedNetworkUtilsServer.SendByte((byte)data.type);
switch (data.type)
{
case FduClusterInputType.Axis:
BufferedNetworkUtilsServer.SendFloat(_axisMap[data.name]._setValue);
break;
case FduClusterInputType.Button:
BufferedNetworkUtilsServer.SendBool(_buttonMap[data.name]._setValue);
break;
case FduClusterInputType.Tracker:
BufferedNetworkUtilsServer.SendVector3(_trackerMap[data.name]._setPosValue);
BufferedNetworkUtilsServer.SendQuaternion(_trackerMap[data.name]._setRotValue);
break;
}
}
//BufferedNetworkUtilsServer.SendString("ClusterInputMgrEndFlag");
_sendList.Clear();
}
public override void OnSendData()
{
BufferedNetworkUtilsServer.SendByte(playState2Byte(particleSys.isPlaying, particleSys.isPaused, particleSys.isStopped, particleSys.isEmitting));
BufferedNetworkUtilsServer.SendFloat(particleSys.time);
if (isUsingRandomSeed)
{
BufferedNetworkUtilsServer.SendInt((int)particleSys.randomSeed);
}
}
void SerializeOnePara(byte propertyType, Material mat, string propertyName)
{
switch (propertyType)
{
case 0: //Color
BufferedNetworkUtilsServer.SendColor(mat.GetColor(propertyName));
break;
case 1: //Vector
BufferedNetworkUtilsServer.SendVector4(mat.GetVector(propertyName));
break;
case 2: //Float
BufferedNetworkUtilsServer.SendFloat(mat.GetFloat(propertyName));
break;
case 3: //Range
BufferedNetworkUtilsServer.SendFloat(mat.GetFloat(propertyName));
break;
case 4: //TexEnv
break;
}
}
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;
}
}
}
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;
}
}
}
public override void Serialize()
{
BufferedNetworkUtilsServer.SendInt(_bitArr.Data);
for (int i = 1; i < 30; ++i)
{
if (!_bitArr[FduGlobalConfig.BIT_MASK[i]])
{
continue;
}
switch (i)
{
case 1: //deltaTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["deltaTime"]._setValue);
break;
case 2: //unscaledDeltaTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["unscaledDeltaTime"]._setValue);
break;
case 3: //time
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["time"]._setValue);
break;
case 4: //unscaledTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["unscaledTime"]._setValue);
break;
case 5: //fixedTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["fixedTime"]._setValue);
break;
case 6: //fixedUnscaledTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["fixedUnscaledTime"]._setValue);
break;
case 7: //fixedDeltaTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["fixedDeltaTime"]._setValue);
break;
case 8: //fixedUnscaledDeltaTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["fixedUnscaledDeltaTime"]._setValue);
break;
case 9: //smoothDeltaTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["smoothDeltaTime"]._setValue);
break;
case 10: //timeSinceLevelLoad
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["timeSinceLevelLoad"]._setValue);
break;
case 11: //timeScale
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["timeScale"]._setValue);
break;
case 12: //captureFramerate
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["captureFramerate"]._setValue);
break;
case 13: //renderedFrameCount
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["renderedFrameCount"]._setValue);
break;
case 14: //maximumDeltaTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["maximumDeltaTime"]._setValue);
break;
case 15: //maximumParticleDeltaTime
BufferedNetworkUtilsServer.SendFloat(_timeDataMap["maximumParticleDeltaTime"]._setValue);
break;
}
}
//BufferedNetworkUtilsServer.SendString("FduClusterTimeEndFlag");
}
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));
}
}
}
}
}
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;
}
}
}
//序列化一个可传送的参数
public static void serializeOneParameter(object para)
{
FduSendableParameter typeCode = FduGlobalConfig.getSendableParameterCode(para);
BufferedNetworkUtilsServer.SendByte((byte)typeCode);
switch (typeCode)
{
case FduSendableParameter.Int:
BufferedNetworkUtilsServer.SendInt((int)para);
break;
case FduSendableParameter.IntArray:
BufferedNetworkUtilsServer.SendIntArray((int[])para);
break;
case FduSendableParameter.Byte:
BufferedNetworkUtilsServer.SendByte((byte)para);
break;
case FduSendableParameter.ByteArray:
BufferedNetworkUtilsServer.SendByteArray((byte[])para);
break;
case FduSendableParameter.Float:
BufferedNetworkUtilsServer.SendFloat((float)para);
break;
case FduSendableParameter.FloatArray:
BufferedNetworkUtilsServer.SendFloatArray((float[])para);
break;
case FduSendableParameter.Bool:
BufferedNetworkUtilsServer.SendBool((bool)para);
break;
case FduSendableParameter.BoolArray:
bool[] bolarr = (bool[])para;
int bollen = bolarr.Length;
BufferedNetworkUtilsServer.SendInt(bollen);
for (int i = 0; i < bollen; ++i)
{
BufferedNetworkUtilsServer.SendBool(bolarr[i]);
}
break;
case FduSendableParameter.String:
BufferedNetworkUtilsServer.SendString((string)para);
break;
case FduSendableParameter.StringArray:
string[] strarr = (string[])para;
int strlen = strarr.Length;
BufferedNetworkUtilsServer.SendInt(strlen);
for (int i = 0; i < strlen; ++i)
{
BufferedNetworkUtilsServer.SendString(strarr[i]);
}
break;
case FduSendableParameter.Vector2:
BufferedNetworkUtilsServer.SendVector2((Vector2)para);
break;
case FduSendableParameter.Vector2Array:
Vector2[] v2arr = (Vector2[])para;
int v2len = v2arr.Length;
BufferedNetworkUtilsServer.SendInt(v2len);
for (int i = 0; i < v2len; ++i)
{
BufferedNetworkUtilsServer.SendVector2(v2arr[i]);
}
break;
case FduSendableParameter.Vector3:
BufferedNetworkUtilsServer.SendVector3((Vector3)para);
break;
case FduSendableParameter.Vector3Array:
Vector3[] v3arr = (Vector3[])para;
int v3len = v3arr.Length;
BufferedNetworkUtilsServer.SendInt(v3len);
for (int i = 0; i < v3len; ++i)
{
BufferedNetworkUtilsServer.SendVector3(v3arr[i]);
}
break;
case FduSendableParameter.Vector4:
BufferedNetworkUtilsServer.SendVector4((Vector4)para);
break;
case FduSendableParameter.Vector4Array:
Vector4[] v4arr = (Vector4[])para;
int v4len = v4arr.Length;
BufferedNetworkUtilsServer.SendInt(v4len);
for (int i = 0; i < v4len; ++i)
{
BufferedNetworkUtilsServer.SendVector3(v4arr[i]);
}
break;
case FduSendableParameter.Color:
BufferedNetworkUtilsServer.SendColor((Color)para);
break;
case FduSendableParameter.ColorArray:
Color[] carray = (Color[])para;
int clen = carray.Length;
BufferedNetworkUtilsServer.SendInt(clen);
for (int i = 0; i < clen; ++i)
{
BufferedNetworkUtilsServer.SendColor(carray[i]);
}
break;
case FduSendableParameter.Quaternion:
BufferedNetworkUtilsServer.SendQuaternion((Quaternion)para);
break;
case FduSendableParameter.QuaternionArray:
Quaternion[] qarr = (Quaternion[])para;
int qlen = qarr.Length;
BufferedNetworkUtilsServer.SendInt(qlen);
for (int i = 0; i < qlen; i++)
{
BufferedNetworkUtilsServer.SendQuaternion(qarr[i]);
}
break;
case FduSendableParameter.GameObject:
if (((GameObject)para).GetClusterView() != null)
{
BufferedNetworkUtilsServer.SendBool(true);
BufferedNetworkUtilsServer.SendInt(((GameObject)para).GetClusterView().ViewId);
}
else
{
BufferedNetworkUtilsServer.SendBool(false);
BufferedNetworkUtilsServer.SendString(FduSupportClass.getGameObjectPath((GameObject)para));
}
break;
case FduSendableParameter.ClusterView:
BufferedNetworkUtilsServer.SendInt(((FduClusterView)para).ViewId);
break;
case FduSendableParameter.Matrix4X4:
BufferedNetworkUtilsServer.SendMatrix4x4((Matrix4x4)para);
break;
case FduSendableParameter.Matrix4X4Array:
Matrix4x4[] matarr = (Matrix4x4[])para;
int mlen = matarr.Length;
BufferedNetworkUtilsServer.SendInt(mlen);
for (int i = 0; i < mlen; ++i)
{
BufferedNetworkUtilsServer.SendMatrix4x4(matarr[i]);
}
break;
case FduSendableParameter.Rect:
BufferedNetworkUtilsServer.SendRect((Rect)para);
break;
case FduSendableParameter.RectArray:
Rect[] rectArr = (Rect[])para;
int rectlen = rectArr.Length;
BufferedNetworkUtilsServer.SendInt(rectlen);
for (int i = 0; i < rectlen; ++i)
{
BufferedNetworkUtilsServer.SendRect(rectArr[i]);
}
break;
case FduSendableParameter.Struct:
BufferedNetworkUtilsServer.SendString(para.GetType().AssemblyQualifiedName);
BufferedNetworkUtilsServer.SendStruct(para);
break;
case FduSendableParameter.SerializableClass:
BufferedNetworkUtilsServer.SendSerializableClass(para);
break;
case FduSendableParameter.Enum:
BufferedNetworkUtilsServer.SendInt(System.Convert.ToInt32(para));
break;
default:
throw new InvalidSendableDataException("Such type of data can not be sent. Type name:" + para.GetType().FullName);
}
}