StreamQueue

85     void Awake()
86     {
87         m_PhotonView = GetComponent();
88         m_StreamQueue = new PhotonStreamQueue( 120 );
89
90         m_Animator = GetComponent();
91     }

234     void SerializeDataContinuously()
235     {
236         if( m_Animator == null )
237         {
238             return;
239         }
240
241         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
242         {
243             if( m_SynchronizeLayers[ i ].SynchronizeType == SynchronizeType.Continuous )
244             {
245                 m_StreamQueue.SendNext( m_Animator.GetLayerWeight( m_SynchronizeLayers[ i ].LayerIndex ) );
246             }
247         }
248
249         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
250         {
251             SynchronizedParameter parameter = m_SynchronizeParameters[ i ];
252
253             if( parameter.SynchronizeType == SynchronizeType.Continuous )
254             {
255
256                 switch( parameter.Type )
257                 {
258                 case ParameterType.Bool:
259                     m_StreamQueue.SendNext( m_Animator.GetBool( parameter.Name ) );
260                     break;
261                 case ParameterType.Float:
262                     m_StreamQueue.SendNext( m_Animator.GetFloat( parameter.Name ) );
263                     break;
264                 case ParameterType.Int:
265                     m_StreamQueue.SendNext( m_Animator.GetInteger( parameter.Name ) );
266                     break;
267                 case ParameterType.Trigger:
268
269                     break;
270                 }
271             }
272         }
273     }

275     void DeserializeDataContinuously()
276     {
277         if( m_StreamQueue.HasQueuedObjects() == false )
278         {
279             return;
280         }
281
282         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
283         {
284             if( m_SynchronizeLayers[ i ].SynchronizeType == SynchronizeType.Continuous )
285             {
286                 m_Animator.SetLayerWeight( m_SynchronizeLayers[ i ].LayerIndex, (float)m_StreamQueue.ReceiveNext() );
287             }
288         }
289
290         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
291         {
292             SynchronizedParameter parameter = m_SynchronizeParameters[ i ];
293
294             if( parameter.SynchronizeType == SynchronizeType.Continuous )
295             {
296                 switch( parameter.Type )
297                 {
298                 case ParameterType.Bool:
299                     m_Animator.SetBool( parameter.Name, (bool)m_StreamQueue.ReceiveNext() );
300                     break;
301                 case ParameterType.Float:
302                     m_Animator.SetFloat( parameter.Name, (float)m_StreamQueue.ReceiveNext() );
303                     break;
304                 case ParameterType.Int:
305                     m_Animator.SetInteger( parameter.Name, (int)m_StreamQueue.ReceiveNext() );
306                     break;
307                 case ParameterType.Trigger:
308
309                     break;
310                 }
311             }
312         }
313     }

432     void OnPhotonSerializeView( PhotonStream stream, PhotonMessageInfo info )
433     {
434         if( m_Animator == null )
435         {
436             return;
437         }
438
439         if( stream.isWriting == true )
440         {
441             if( m_WasSynchronizeTypeChanged == true )
442             {
443                 m_StreamQueue.Reset();
444                 SerializeSynchronizationTypeState( stream );
445
446                 m_WasSynchronizeTypeChanged = false;
447             }
448
449             m_StreamQueue.Serialize( stream );
450             SerializeDataDiscretly( stream );
451         }
452         else
453         {
454#if PHOTON_DEVELOP
455             if( ReceivingSender != null )
456             {
457                 ReceivingSender.OnPhotonSerializeView( stream, info );
458             }
459             else
460#endif
461             {
462                 if( stream.PeekNext() is byte[] )
463                 {
464                     DeserializeSynchronizationTypeState( stream );
465                 }
466
467                 m_StreamQueue.Deserialize( stream );
468                 DeserializeDataDiscretly( stream );
469             }
470         }
471     }

32     public PhotonStreamQueue( int sampleRate )
33     {
34         m_SampleRate = sampleRate;
35     }

37     void BeginWritePackage()
38     {
39         //If not enough time has passed since the last sample, we don't want to write anything
40         if( Time.realtimeSinceStartup < m_LastSampleTime + 1f / m_SampleRate )
41         {
42             m_IsWriting = false;
43             return;
44         }
45
46         if( m_SampleCount == 1 )
47         {
48             m_ObjectsPerSample = m_Objects.Count;
49             //Debug.Log( "Setting m_ObjectsPerSample to " + m_ObjectsPerSample );
50         }
51         else if( m_SampleCount > 1 )
52         {
53             if( m_Objects.Count / m_SampleCount != m_ObjectsPerSample )
54             {
55                 Debug.LogWarning( "The number of objects sent via a PhotonStreamQueue has to be the same each frame" );
56                 Debug.LogWarning( "Objects in List: " + m_Objects.Count + " / Sample Count: " + m_SampleCount + " = " + ( m_Objects.Count / m_SampleCount ) + " != " + m_ObjectsPerSample );
57             }
58         }
59
60         /*if( m_SampleCount > 1 )
61         {
62             Debug.Log( "Check: " + m_Objects.Count + " / " + m_SampleCount + " = " + ( m_Objects.Count / m_SampleCount ) + " = " + m_ObjectsPerSample );
63         }*/
64
65         m_IsWriting = true;
66         m_SampleCount++;
67         m_LastSampleTime = Time.realtimeSinceStartup;
68
69     }