LayerIndex

41     {
42         public SynchronizeType SynchronizeType;
43         public int LayerIndex;
44     }

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

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     }

15     public override void OnInspectorGUI()
16     {
17         // Get the renderer from the target object
18         var renderer = (target as SortingLayerExposed).gameObject.GetComponent();
19
20         // If there is no renderer, we can't do anything
21         if (!renderer)
22         {
23             return;
24         }
25
26         // Expose the sorting layer name
27         //string newSortingLayerName = EditorGUILayout.TextField("Sorting Layer", renderer.sortingLayerName);
28         //if (newSortingLayerName != renderer.sortingLayerName)
29         //{
30         // Undo.RecordObject(renderer, "Edit Sorting Layer Name");
31         // renderer.sortingLayerName = newSortingLayerName;
32         // EditorUtility.SetDirty(renderer);
33         //}
34
35         // Expose the sorting layer ID
36         //int newSortingLayerId = EditorGUILayout.IntField("Sorting Layer ID", renderer.sortingLayerID);
37         //if (newSortingLayerId != renderer.sortingLayerID)
38         //{
39         // Undo.RecordObject(renderer, "Edit Sorting Layer ID");
40         // renderer.sortingLayerID = newSortingLayerId;
41         // EditorUtility.SetDirty(renderer);
42         //}
43
44         // Seanba: Use a popup that is populated with the acceptable sorting layers for the renderer
45         // Also allow the player to bring up the Tag/Layers inspector if they choose so
46         string[] sortLayerNames = GetSortingLayerNames();
47         //int[] sortLayerIds = GetSortingLayerUniqueIDs();
48         //{
49         // StringBuilder builder = new StringBuilder("Sorting Layers = ");
50         // for (int i = 0; i < sortLayerNames.Length; ++i)
51         // {
52         // builder.AppendFormat("({0} = {1},{2}) ", i, sortLayerIds[i], sortLayerNames[i]);
53         // }
54         // Debug.Log(builder.ToString());
55         //}
56
57         int sortLayerSelection = GetSortingLayerIndex(renderer, sortLayerNames);
58
59         GUIContent[] sortingLayerContexts = GetSortingLayerContexts();
60         int newSortingLayerIndex = EditorGUILayout.Popup(new GUIContent("Sorting Layer"), sortLayerSelection, sortingLayerContexts);
61         if (newSortingLayerIndex == sortingLayerContexts.Length - 1)
62         {
63             EditorApplication.ExecuteMenuItem("Edit/Project Settings/Tags and Layers");
64         }
65         else if (newSortingLayerIndex != sortLayerSelection)
66         {
67             //int newSortingLayerId = sortLayerIds[newSortingLayerIndex];
68             string newSortingLayerName = sortLayerNames[newSortingLayerIndex];
69
70             Undo.RecordObject(renderer, "Edit Sorting Layer ID");
71             renderer.sortingLayerName = newSortingLayerName;
72             //renderer.sortingLayerID = newSortingLayerId;
73
74             EditorUtility.SetDirty(renderer);
75         }
76
77         // Expose the manual sorting order within a sort layer
78         int newSortingLayerOrder = EditorGUILayout.IntField("Order in Layer", renderer.sortingOrder);
79         if (newSortingLayerOrder != renderer.sortingOrder)
80         {
81             Undo.RecordObject(renderer, "Edit Sorting Order");
82             renderer.sortingOrder = newSortingLayerOrder;
83             EditorUtility.SetDirty(renderer);
84         }
85     }

118     public static int GetSortingLayerIndex(Renderer renderer, string[] layerNames)
119     {
120         for (int i = 0; i < layerNames.Length; ++i)
121         {
122             if (layerNames[i] == renderer.sortingLayerName)
123                 return i;
124
125             // Special case for Default, goddammit
126             if (layerNames[i] == "Default" && String.IsNullOrEmpty(renderer.sortingLayerName))
127                 return i;
128         }
129
130         return 0;
131     }