GetFloat

61     public void OnGUI()
62     {
63         GUI.skin = Skin;
64
65         string[] synchronizeTypeContent = new string[] { "Disabled", "Discrete", "Continuous" };
66
67         GUILayout.BeginArea( new Rect( Screen.width - 200 * m_FoundPlayerSlideIn - 400 * m_SlideIn, 0, 600, Screen.height ), GUI.skin.box );
68         {
69             GUILayout.Label( "Mecanim Demo", GUI.skin.customStyles[ 0 ] );
70
71             GUI.color = Color.white;
72             string label = "Settings";
73
74             if( m_IsOpen == true )
75             {
76                 label = "Close";
77             }
78
79             if( GUILayout.Button( label, GUILayout.Width( 110 ) ) )
80             {
81                 m_IsOpen = !m_IsOpen;
82             }
83
84             string parameters = "";
85
86             if( m_AnimatorView != null )
87             {
88                 parameters += "Send Values:\n";
89
90                 for( int i = 0; i < m_AnimatorView.GetSynchronizedParameters().Count; ++i )
91                 {
92                     PhotonAnimatorView.SynchronizedParameter parameter = m_AnimatorView.GetSynchronizedParameters()[ i ];
93
94                     try
95                     {
96                         switch( parameter.Type )
97                         {
98                         case PhotonAnimatorView.ParameterType.Bool:
99                             parameters += parameter.Name + " (" + ( m_AnimatorView.GetComponent().GetBool( parameter.Name ) ? "True" : "False" ) + ")\n";
100                             break;
101                         case PhotonAnimatorView.ParameterType.Int:
102                             parameters += parameter.Name + " (" + m_AnimatorView.GetComponent().GetInteger( parameter.Name ) + ")\n";
103                             break;
104                         case PhotonAnimatorView.ParameterType.Float:
105                             parameters += parameter.Name + " (" + m_AnimatorView.GetComponent().GetFloat( parameter.Name ).ToString( "0.00" ) + ")\n";
106                             break;
107                         }
108                     }
109                     catch
110                     {
111                         Debug.Log( "derrrr for " + parameter.Name );
112                     }
113                 }
114             }
115
116             if( m_RemoteAnimator != null )
117             {
118                 parameters += "\nReceived Values:\n";
119
120                 for( int i = 0; i < m_AnimatorView.GetSynchronizedParameters().Count; ++i )
121                 {
122                     PhotonAnimatorView.SynchronizedParameter parameter = m_AnimatorView.GetSynchronizedParameters()[ i ];
123
124                     try
125                     {
126                         switch( parameter.Type )
127                         {
128                         case PhotonAnimatorView.ParameterType.Bool:
129                             parameters += parameter.Name + " (" + ( m_RemoteAnimator.GetBool( parameter.Name ) ? "True" : "False" ) + ")\n";
130                             break;
131                         case PhotonAnimatorView.ParameterType.Int:
132                             parameters += parameter.Name + " (" + m_RemoteAnimator.GetInteger( parameter.Name ) + ")\n";
133                             break;
134                         case PhotonAnimatorView.ParameterType.Float:
135                             parameters += parameter.Name + " (" + m_RemoteAnimator.GetFloat( parameter.Name ).ToString( "0.00" ) + ")\n";
136                             break;
137                         }
138                     }
139                     catch
140                     {
141                         Debug.Log( "derrrr for " + parameter.Name );
142                     }
143                 }
144             }
145
146             GUIStyle style = new GUIStyle( GUI.skin.label );
147             style.alignment = TextAnchor.UpperLeft;
148
149             GUI.color = new Color( 1f, 1f, 1f, 1 - m_SlideIn );
150             GUI.Label( new Rect( 10, 100, 600, Screen.height ), parameters, style );
151
152             if( m_AnimatorView != null )
153             {
154                 GUI.color = new Color( 1f, 1f, 1f, m_SlideIn );
155
156                 GUILayout.Space( 20 );
157                 GUILayout.Label( "Synchronize Parameters" );
158
159                 for( int i = 0; i < m_AnimatorView.GetSynchronizedParameters().Count; ++i )
160                 {
161                     GUILayout.BeginHorizontal();
162                     {
163                         PhotonAnimatorView.SynchronizedParameter parameter = m_AnimatorView.GetSynchronizedParameters()[ i ];
164
165                         GUILayout.Label( parameter.Name, GUILayout.Width( 100 ), GUILayout.Height( 36 ) );
166
167                         int selectedValue = (int)parameter.SynchronizeType;
168                         int newValue = GUILayout.Toolbar( selectedValue, synchronizeTypeContent );
169
170                         if( newValue != selectedValue )
171                         {
172                             m_AnimatorView.SetParameterSynchronized( parameter.Name, parameter.Type, (PhotonAnimatorView.SynchronizeType)newValue );
173                         }
174                     }
175                     GUILayout.EndHorizontal();
176                 }
177             }
178         }
179         GUILayout.EndArea();
180     }

33     void Update ()
34     {
35         if( m_PhotonView.isMine == false && PhotonNetwork.connected == true )
36         {
37             return;
38         }
39
40         if (animator)
41         {
42             AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(0);
43
44             if (stateInfo.IsName("Base Layer.Run"))
45             {
46                 if (Input.GetButton("Fire1")) animator.SetBool("Jump", true);
47             }
48             else
49             {
50                 animator.SetBool("Jump", false);
51             }
52
53             if(Input.GetButtonDown("Fire2") && animator.layerCount >= 2)
54             {
55                 animator.SetBool("Hi", !animator.GetBool("Hi"));
56             }
57
58
59             float h = Input.GetAxis("Horizontal");
60             float v = Input.GetAxis("Vertical");
61
62             if( v < 0 )
63             {
64                 v = 0;
65             }
66
67             animator.SetFloat( "Speed", h*h+v*v );
68             animator.SetFloat( "Direction", h, DirectionDampTime, Time.deltaTime );
69
70             float direction = animator.GetFloat( "Direction" );
71
72             float targetSpeedModifier = Mathf.Abs( v );
73
74             if( Mathf.Abs( direction ) > 0.2f )
75             {
76                 targetSpeedModifier = TurnSpeedModifier;
77             }
78
79             m_SpeedModifier = Mathf.MoveTowards( m_SpeedModifier, targetSpeedModifier, Time.deltaTime * 25f );
80
81             Vector3 speed = transform.forward * SynchronizedMaxSpeed * m_SpeedModifier;
82             float turnSpeed = direction * SynchronizedTurnSpeed;
83
84             /*float moveDistance = Vector3.Distance( transform.position, m_LastPosition ) / Time.deltaTime;
85
86             if( moveDistance < 4f && turnSpeed == 0f )
87             {
88                 speed = transform.forward * moveDistance;
89             }*/
90
91             //Debug.Log( moveDistance );
92             //Debug.Log( speed + " - " + speed.magnitude + " - " + speedModifier + " - " + h + " - " + v );
93
94             m_TransformView.SetSynchronizedValues( speed, turnSpeed );
95
96             //m_LastPosition = transform.position;
97          }
98     }

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     }

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     }

194         {
195             get
196             {
197                 return EditorPrefs.GetFloat("VSCode_GitHubVersion", Version);
198             }
199             set
200             {
201                 EditorPrefs.SetFloat("VSCode_GitHubVersion", value);
202             }
203         }

42         protected override void Parse(XmlElement element, Timeline timeline)
43         {
44             base.Parse(element, timeline);
45
46             var boneElem = element["bone"];
47             Spatial = new SpatialInfo(boneElem);
48
49             Color tint = Color.white;
50             tint.r = boneElem.GetFloat("r", 1.0f);
51             tint.g = boneElem.GetFloat("g", 1.0f);
52             tint.b = boneElem.GetFloat("b", 1.0f);
53             tint.a = boneElem.GetFloat("a", 1.0f);
54             Tint = tint;
55         }

60         protected virtual void Parse(XmlElement element, Folder folder)
61         {
62             Folder = folder;
63
64             var type = element.GetString("type", "image");
65             switch(type)
66             {
67                 case "image":
68                     FileType = FileType.Image;
69                     break;
70                 case "atlas_image":
71                     FileType = FileType.AtlasImage;
72                     break;
73                 case "sound_effect":
74                     FileType = FileType.SoundEffect;
75                     break;
76                 case "entity":
77                     FileType = FileType.Entity;
78                     break;
79                 default:
80                     FileType = FileType.INVALID_TYPE;
81                     break;
82             }
83
84             Name = element.GetString("name", "");
85
86             Vector2 pivot;
87             pivot.x = element.GetFloat("pivot_x", 0.0f);
88             pivot.y = element.GetFloat("pivot_y", 0.0f);
89             Pivot = pivot;
90
91             Vector2 size;
92             size.x = element.GetInt("width", 0);
93             size.y = element.GetInt("height", 0);
94             Size = size;
95
96             Vector2 offset;
97             offset.x = element.GetInt("offset_x", 0);
98             offset.y = element.GetInt("offset_y", 0);
99             Offset = offset;
100
101             Vector2 originalSize;
102             originalSize.x = element.GetInt("original_width", 0);
103             originalSize.y = element.GetInt("original_height", 0);
104             OriginalSize = originalSize;
105         }

79         protected virtual void Parse(XmlElement element)
80         {
81             Vector2 position;
82             position.x = element.GetFloat("x", 0.0f);
83             position.y = element.GetFloat("y", 0.0f);
84             Position = position;
85
86             Vector2 scale = Vector2.one;
87             scale.x = element.GetFloat("scale_x", 1.0f);
88             scale.y = element.GetFloat("scale_y", 1.0f);
89             Scale = scale;
90
91             Angle_Deg = element.GetFloat("angle", 0.0f);
92
93             int spinVal = element.GetInt("spin", 1);
94             Spin = (spinVal == -1) ? SpinDirection.Clockwise : SpinDirection.CounterClockwise;
95         }

55         protected override void Parse(XmlElement element, Timeline timeline)
56         {
57             base.Parse(element, timeline);
58
59             var objElement = element[XmlKey];
60
61             File = GetFile(objElement);
62
63             Spatial = new SpatialInfo(objElement);
64
65             Vector2 pivot;
66             pivot.x = objElement.GetFloat("pivot_x", File.Pivot.x);
67             pivot.y = objElement.GetFloat("pivot_y", File.Pivot.y);
68             Pivot = pivot;
69
70             Color tint = Color.white;
71             tint.r = objElement.GetFloat("r", 1.0f);
72             tint.g = objElement.GetFloat("g", 1.0f);
73             tint.b = objElement.GetFloat("b", 1.0f);
74             tint.a = objElement.GetFloat("a", 1.0f);
75             Tint = tint;
76         }

58         public static bool TryGetFloat(this XmlNode node, string key, out float value)
59         {
60             value = default(float);
61             var attr = node.Attributes[key];
62             bool parsed = false;
63             if (attr != null)
64             {
65                 parsed = float.TryParse(attr.Value, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out value);
66             }
67
68             return parsed;
69         }