OnlyRotation

348     internal protected void DeserializeComponent( Component component, PhotonStream stream, PhotonMessageInfo info )
349     {
350         if( component == null )
351         {
352             return;
353         }
354
355         // Use incoming data according to observed type
356         if( component is MonoBehaviour )
357         {
358             ExecuteComponentOnSerialize( component, stream, info );
359         }
360         else if( component is Transform )
361         {
362             Transform trans = (Transform)component;
363
364             switch( onSerializeTransformOption )
365             {
366             case OnSerializeTransform.All:
367                 trans.localPosition = (Vector3)stream.ReceiveNext();
368                 trans.localRotation = (Quaternion)stream.ReceiveNext();
369                 trans.localScale = (Vector3)stream.ReceiveNext();
370                 break;
371             case OnSerializeTransform.OnlyPosition:
372                 trans.localPosition = (Vector3)stream.ReceiveNext();
373                 break;
374             case OnSerializeTransform.OnlyRotation:
375                 trans.localRotation = (Quaternion)stream.ReceiveNext();
376                 break;
377             case OnSerializeTransform.OnlyScale:
378                 trans.localScale = (Vector3)stream.ReceiveNext();
379                 break;
380             case OnSerializeTransform.PositionAndRotation:
381                 trans.localPosition = (Vector3)stream.ReceiveNext();
382                 trans.localRotation = (Quaternion)stream.ReceiveNext();
383                 break;
384             }
385         }
386         else if( component is Rigidbody )
387         {
388             Rigidbody rigidB = (Rigidbody)component;
389
390             switch( onSerializeRigidBodyOption )
391             {
392             case OnSerializeRigidBody.All:
393                 rigidB.velocity = (Vector3)stream.ReceiveNext();
394                 rigidB.angularVelocity = (Vector3)stream.ReceiveNext();
395                 break;
396             case OnSerializeRigidBody.OnlyAngularVelocity:
397                 rigidB.angularVelocity = (Vector3)stream.ReceiveNext();
398                 break;
399             case OnSerializeRigidBody.OnlyVelocity:
400                 rigidB.velocity = (Vector3)stream.ReceiveNext();
401                 break;
402             }
403         }
404         else if( component is Rigidbody2D )
405         {
406             Rigidbody2D rigidB = (Rigidbody2D)component;
407
408             switch( onSerializeRigidBodyOption )
409             {
410             case OnSerializeRigidBody.All:
411                 rigidB.velocity = (Vector2)stream.ReceiveNext();
412                 rigidB.angularVelocity = (float)stream.ReceiveNext();
413                 break;
414             case OnSerializeRigidBody.OnlyAngularVelocity:
415                 rigidB.angularVelocity = (float)stream.ReceiveNext();
416                 break;
417             case OnSerializeRigidBody.OnlyVelocity:
418                 rigidB.velocity = (Vector2)stream.ReceiveNext();
419                 break;
420             }
421         }
422         else
423         {
424             Debug.LogError( "Type of observed is unknown when receiving." );
425         }
426     }

428     internal protected void SerializeComponent( Component component, PhotonStream stream, PhotonMessageInfo info )
429     {
430         if( component == null )
431         {
432             return;
433         }
434
435         if( component is MonoBehaviour )
436         {
437             ExecuteComponentOnSerialize( component, stream, info );
438         }
439         else if( component is Transform )
440         {
441             Transform trans = (Transform)component;
442
443             switch( onSerializeTransformOption )
444             {
445             case OnSerializeTransform.All:
446                 stream.SendNext( trans.localPosition );
447                 stream.SendNext( trans.localRotation );
448                 stream.SendNext( trans.localScale );
449                 break;
450             case OnSerializeTransform.OnlyPosition:
451                 stream.SendNext( trans.localPosition );
452                 break;
453             case OnSerializeTransform.OnlyRotation:
454                 stream.SendNext( trans.localRotation );
455                 break;
456             case OnSerializeTransform.OnlyScale:
457                 stream.SendNext( trans.localScale );
458                 break;
459             case OnSerializeTransform.PositionAndRotation:
460                 stream.SendNext( trans.localPosition );
461                 stream.SendNext( trans.localRotation );
462                 break;
463             }
464         }
465         else if( component is Rigidbody )
466         {
467             Rigidbody rigidB = (Rigidbody)component;
468
469             switch( onSerializeRigidBodyOption )
470             {
471             case OnSerializeRigidBody.All:
472                 stream.SendNext( rigidB.velocity );
473                 stream.SendNext( rigidB.angularVelocity );
474                 break;
475             case OnSerializeRigidBody.OnlyAngularVelocity:
476                 stream.SendNext( rigidB.angularVelocity );
477                 break;
478             case OnSerializeRigidBody.OnlyVelocity:
479                 stream.SendNext( rigidB.velocity );
480                 break;
481             }
482         }
483         else if( component is Rigidbody2D )
484         {
485             Rigidbody2D rigidB = (Rigidbody2D)component;
486
487             switch( onSerializeRigidBodyOption )
488             {
489             case OnSerializeRigidBody.All:
490                 stream.SendNext( rigidB.velocity );
491                 stream.SendNext( rigidB.angularVelocity );
492                 break;
493             case OnSerializeRigidBody.OnlyAngularVelocity:
494                 stream.SendNext( rigidB.angularVelocity );
495                 break;
496             case OnSerializeRigidBody.OnlyVelocity:
497                 stream.SendNext( rigidB.velocity );
498                 break;
499             }
500         }
501         else
502         {
503             Debug.LogError( "Observed type is not serializable: " + component.GetType() );
504         }
505     }