SynchronizeLayers

117     public bool DoesLayerSynchronizeTypeExist( int layerIndex )
118     {
119         return m_SynchronizeLayers.FindIndex( item => item.LayerIndex == layerIndex ) != -1;
120     }

136     public List GetSynchronizedLayers()
137     {
138         return m_SynchronizeLayers;
139     }

155     public SynchronizeType GetLayerSynchronizeType( int layerIndex )
156     {
157         int index = m_SynchronizeLayers.FindIndex( item => item.LayerIndex == layerIndex );
158
159         if( index == -1 )
160         {
161             return SynchronizeType.Disabled;
162         }
163
164         return m_SynchronizeLayers[ index ].SynchronizeType;
165     }

189     public void SetLayerSynchronized( int layerIndex, SynchronizeType synchronizeType )
190     {
191         if( Application.isPlaying == true )
192         {
193             m_WasSynchronizeTypeChanged = true;
194         }
195
196         int index = m_SynchronizeLayers.FindIndex( item => item.LayerIndex == layerIndex );
197
198         if( index == -1 )
199         {
200             m_SynchronizeLayers.Add( new SynchronizedLayer { LayerIndex = layerIndex, SynchronizeType = synchronizeType } );
201         }
202         else
203         {
204             m_SynchronizeLayers[ index ].SynchronizeType = synchronizeType;
205         }
206     }

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     }

315     void SerializeDataDiscretly( PhotonStream stream )
316     {
317         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
318         {
319             if( m_SynchronizeLayers[ i ].SynchronizeType == SynchronizeType.Discrete )
320             {
321                 stream.SendNext( m_Animator.GetLayerWeight( m_SynchronizeLayers[ i ].LayerIndex ) );
322             }
323         }
324
325         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
326         {
327             SynchronizedParameter parameter = m_SynchronizeParameters[ i ];
328
329             if( parameter.SynchronizeType == SynchronizeType.Discrete )
330             {
331                 switch( parameter.Type )
332                 {
333                 case ParameterType.Bool:
334                     stream.SendNext( m_Animator.GetBool( parameter.Name ) );
335                     break;
336                 case ParameterType.Float:
337                     stream.SendNext( m_Animator.GetFloat( parameter.Name ) );
338                     break;
339                 case ParameterType.Int:
340                     stream.SendNext( m_Animator.GetInteger( parameter.Name ) );
341                     break;
342                 case ParameterType.Trigger:
343
344                     break;
345                 }
346             }
347         }
348     }

350     void DeserializeDataDiscretly( PhotonStream stream )
351     {
352         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
353         {
354             if( m_SynchronizeLayers[ i ].SynchronizeType == SynchronizeType.Discrete )
355             {
356                 m_Animator.SetLayerWeight( m_SynchronizeLayers[ i ].LayerIndex, (float)stream.ReceiveNext() );
357             }
358         }
359
360         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
361         {
362             SynchronizedParameter parameter = m_SynchronizeParameters[ i ];
363
364             if( parameter.SynchronizeType == SynchronizeType.Discrete )
365             {
366                 switch( parameter.Type )
367                 {
368                 case ParameterType.Bool:
369                     if( stream.PeekNext() is bool == false )
370                     {
371                         return;
372                     }
373
374                     m_Animator.SetBool( parameter.Name, (bool)stream.ReceiveNext() );
375                     break;
376                 case ParameterType.Float:
377                     if( stream.PeekNext() is float == false )
378                     {
379                         return;
380                     }
381
382                     m_Animator.SetFloat( parameter.Name, (float)stream.ReceiveNext() );
383                     break;
384                 case ParameterType.Int:
385                     if( stream.PeekNext() is int == false )
386                     {
387                         return;
388                     }
389
390                     m_Animator.SetInteger( parameter.Name, (int)stream.ReceiveNext() );
391                     break;
392                 case ParameterType.Trigger:
393
394                     break;
395                 }
396             }
397         }
398     }

400     void SerializeSynchronizationTypeState( PhotonStream stream )
401     {
402         byte[] states = new byte[ m_SynchronizeLayers.Count + m_SynchronizeParameters.Count ];
403
404         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
405         {
406             states[ i ] = (byte)m_SynchronizeLayers[ i ].SynchronizeType;
407         }
408
409         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
410         {
411             states[ m_SynchronizeLayers.Count + i ] = (byte)m_SynchronizeParameters[ i ].SynchronizeType;
412         }
413
414         stream.SendNext( states );
415     }

417     void DeserializeSynchronizationTypeState( PhotonStream stream )
418     {
419         byte[] state = (byte[])stream.ReceiveNext();
420
421         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
422         {
423             m_SynchronizeLayers[ i ].SynchronizeType = (SynchronizeType)state[ i ];
424         }
425
426         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
427         {
428             m_SynchronizeParameters[ i ].SynchronizeType = (SynchronizeType)state[ m_SynchronizeLayers.Count + i ];
429         }
430     }