Refactored UAudioManager to match coding conventions

Jan Reinhardt · Jan Reinhardt · commit e9b9c295bc85 · 2017-08-14T23:44:55.000+02:00
diff --git a/Assets/HoloToolkit-Tests/SpatialSound/Scenes/UAudioManagerTest.unity b/Assets/HoloToolkit-Tests/SpatialSound/Scenes/UAudioManagerTest.unity
@@ -136,7 +136,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 88e5a9c38f6989249b88204932d7884f, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  events:
+  Events:
   - Name: Laser
     Spatialization: 0
     RoomSize: 0
@@ -247,16 +247,16 @@ MonoBehaviour:
     InstanceTimeBuffer: 0
     AudioEventInstanceBehavior: 0
     Container:
-      containerType: 0
-      looping: 0
-      loopTime: 0
-      sounds:
-      - sound: {fileID: 8300000, guid: 25f57a423322f5a45bf9490fe9d13300, type: 3}
-        looping: 0
-        delayCenter: 0
-        delayRandomization: 0
-      crossfadeTime: 0
-      currentClip: 0
+      ContainerType: 0
+      Looping: 0
+      LoopTime: 0
+      Sounds:
+      - Sound: {fileID: 8300000, guid: 25f57a423322f5a45bf9490fe9d13300, type: 3}
+        Looping: 0
+        DelayCenter: 0
+        DelayRandomization: 0
+      CrossfadeTime: 0
+      CurrentClip: 0
   - Name: Vocals
     Spatialization: 0
     RoomSize: 0
@@ -367,16 +367,16 @@ MonoBehaviour:
     InstanceTimeBuffer: 0
     AudioEventInstanceBehavior: 0
     Container:
-      containerType: 0
-      looping: 0
-      loopTime: 0
-      sounds:
-      - sound: {fileID: 8300000, guid: aa9275dc39fa76144bcdb5c329400abe, type: 3}
-        looping: 0
-        delayCenter: 0
-        delayRandomization: 0
-      crossfadeTime: 0
-      currentClip: 0
+      ContainerType: 0
+      Looping: 0
+      LoopTime: 0
+      Sounds:
+      - Sound: {fileID: 8300000, guid: aa9275dc39fa76144bcdb5c329400abe, type: 3}
+        Looping: 0
+        DelayCenter: 0
+        DelayRandomization: 0
+      CrossfadeTime: 0
+      CurrentClip: 0
   globalEventInstanceLimit: 0
   globalInstanceBehavior: 0
 --- !u!4 &69647939
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/ActiveEvent.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/ActiveEvent.cs
@@ -67,19 +67,19 @@ public string MessageOnAudioEnd
             private set;
         }
 
-        public AudioEvent audioEvent = null;
-        public bool isStoppable = true;
-        public float volDest = 1;
-        public float altVolDest = 1;
-        public float currentFade = 0;
-        public bool playingAlt = false;
-        public bool isActiveTimeComplete = false;
-        public float activeTime = 0;
-        public bool cancelEvent = false;
+        public AudioEvent AudioEvent = null;
+        public bool IsStoppable = true;
+        public float VolDest = 1;
+        public float AltVolDest = 1;
+        public float CurrentFade = 0;
+        public bool PlayingAlt = false;
+        public bool IsActiveTimeComplete = false;
+        public float ActiveTime = 0;
+        public bool CancelEvent = false;
 
         public ActiveEvent(AudioEvent audioEvent, GameObject emitter, AudioSource primarySource, AudioSource secondarySource, string messageOnAudioEnd = null)
         {
-            this.audioEvent = audioEvent;
+            this.AudioEvent = audioEvent;
             AudioEmitter = emitter;
             PrimarySource = primarySource;
             SecondarySource = secondarySource;
@@ -103,7 +103,7 @@ private void SetSourceProperties()
                 }
             };
 
-            AudioEvent audioEvent = this.audioEvent;
+            AudioEvent audioEvent = this.AudioEvent;
             switch (audioEvent.Spatialization)
             {
                 case SpatialPositioningType.TwoD:
@@ -186,7 +186,7 @@ private void SetSourceProperties()
             if (audioEvent.FadeInTime > 0)
             {
                 forEachSource((source) => source.volume = 0f);
-                this.currentFade = audioEvent.FadeInTime;
+                this.CurrentFade = audioEvent.FadeInTime;
                 if (audioEvent.VolumeRandomization != 0)
                 {
                     vol = UnityEngine.Random.Range(audioEvent.VolumeCenter - audioEvent.VolumeRandomization, audioEvent.VolumeCenter + audioEvent.VolumeRandomization);
@@ -195,7 +195,7 @@ private void SetSourceProperties()
                 {
                     vol = audioEvent.VolumeCenter;
                 }
-                this.volDest = vol;
+                this.VolDest = vol;
             }
             else
             {
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/AudioClip.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/AudioClip.cs
@@ -11,10 +11,10 @@ namespace HoloToolkit.Unity
     [Serializable]
     public class UAudioClip
     {
-        public UnityEngine.AudioClip sound = null;
-        public bool looping = false;
+        public UnityEngine.AudioClip Sound = null;
+        public bool Looping = false;
 
-        public float delayCenter = 0;
-        public float delayRandomization = 0;
+        public float DelayCenter = 0;
+        public float DelayRandomization = 0;
     }
 }
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/AudioContainer.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/AudioContainer.cs
@@ -14,12 +14,12 @@ namespace HoloToolkit.Unity
     public class AudioContainer
     {
         [Tooltip("The type of the audio container.")]
-        public AudioContainerType containerType = AudioContainerType.Random;
+        public AudioContainerType ContainerType = AudioContainerType.Random;
 
-        public bool looping = false;
-        public float loopTime = 0;
-        public UAudioClip[] sounds = null;
-        public float crossfadeTime = 0f;
-        public int currentClip = 0;
+        public bool Looping = false;
+        public float LoopTime = 0;
+        public UAudioClip[] Sounds = null;
+        public float CrossfadeTime = 0f;
+        public int CurrentClip = 0;
     }
 }
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/AudioEvent.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/AudioEvent.cs
@@ -158,8 +158,8 @@ public class AudioEvent : IComparable, IComparable<AudioEvent>
         /// <returns>True if this AudioEvent's container is one of the continuous types (random or sequential), otherwise false.</returns>
         public bool IsContinuous()
         {
-            return Container.containerType == AudioContainerType.ContinuousRandom ||
-                   Container.containerType == AudioContainerType.ContinuousSequence;
+            return Container.ContainerType == AudioContainerType.ContinuousRandom ||
+                   Container.ContainerType == AudioContainerType.ContinuousSequence;
         }
 
         /// <summary>
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/Editor/UAudioManagerBaseEditor.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/Editor/UAudioManagerBaseEditor.cs
@@ -9,7 +9,7 @@ namespace HoloToolkit.Unity
 {
     public class UAudioManagerBaseEditor<TEvent> : Editor where TEvent : AudioEvent, new()
     {
-        protected UAudioManagerBase<TEvent> myTarget;
+        protected UAudioManagerBase<TEvent> MyTarget;
         private string[] eventNames;
         private int selectedEventIndex = 0;
         private readonly string[] posTypes = { "2D", "3D", "Spatial Sound" };
@@ -18,37 +18,37 @@ namespace HoloToolkit.Unity
         protected void SetUpEditor()
         {
             // Having a null array of events causes too many errors and should only happen on first adding anyway.
-            if (this.myTarget.EditorEvents == null)
+            if (this.MyTarget.EditorEvents == null)
             {
-                this.myTarget.EditorEvents = new TEvent[0];
+                this.MyTarget.EditorEvents = new TEvent[0];
             }
-            this.eventNames = new string[this.myTarget.EditorEvents.Length];
-            UpdateEventNames(this.myTarget.EditorEvents);
+            this.eventNames = new string[this.MyTarget.EditorEvents.Length];
+            UpdateEventNames(this.MyTarget.EditorEvents);
         }
 
         protected void DrawInspectorGUI(bool showEmitters)
         {
             this.serializedObject.Update();
             EditorGUI.BeginChangeCheck();
-            DrawEventHeader(this.myTarget.EditorEvents);
+            DrawEventHeader(this.MyTarget.EditorEvents);
 
-            if (this.myTarget.EditorEvents != null && this.myTarget.EditorEvents.Length > 0)
+            if (this.MyTarget.EditorEvents != null && this.MyTarget.EditorEvents.Length > 0)
             {
                 // Display current event in dropdown.
                 EditorGUI.indentLevel++;
                 this.selectedEventIndex = EditorGUILayout.Popup(this.selectedEventIndex, this.eventNames);
 
-                if (this.selectedEventIndex < this.myTarget.EditorEvents.Length)
+                if (this.selectedEventIndex < this.MyTarget.EditorEvents.Length)
                 {
                     TEvent selectedEvent;
 
-                    selectedEvent = this.myTarget.EditorEvents[this.selectedEventIndex];
-                    SerializedProperty selectedEventProperty = this.serializedObject.FindProperty("events.Array.data[" + this.selectedEventIndex.ToString() + "]");
+                    selectedEvent = this.MyTarget.EditorEvents[this.selectedEventIndex];
+                    SerializedProperty selectedEventProperty = this.serializedObject.FindProperty("Events.Array.data[" + this.selectedEventIndex.ToString() + "]");
                     EditorGUILayout.Space();
 
                     if (selectedEventProperty != null)
                     {
-                        DrawEventInspector(selectedEventProperty, selectedEvent, this.myTarget.EditorEvents, showEmitters);
+                        DrawEventInspector(selectedEventProperty, selectedEvent, this.MyTarget.EditorEvents, showEmitters);
                         if (!DrawContainerInspector(selectedEventProperty, selectedEvent))
                         {
                             EditorGUI.indentLevel++;
@@ -66,7 +66,7 @@ protected void DrawInspectorGUI(bool showEmitters)
 
             if (UnityEngine.GUI.changed)
             {
-                EditorUtility.SetDirty(this.myTarget);
+                EditorUtility.SetDirty(this.MyTarget);
             }
         }
 
@@ -81,13 +81,13 @@ private void DrawEventHeader(TEvent[] EditorEvents)
             {
                 if (EditorGUILayoutExtensions.Button("Remove"))
                 {
-                    this.myTarget.EditorEvents = RemoveAudioEvent(EditorEvents, this.selectedEventIndex);
+                    this.MyTarget.EditorEvents = RemoveAudioEvent(EditorEvents, this.selectedEventIndex);
                 }
             }
 
             if (EditorGUILayoutExtensions.Button("Add"))
             {
-                this.myTarget.EditorEvents = AddAudioEvent(EditorEvents);
+                this.MyTarget.EditorEvents = AddAudioEvent(EditorEvents);
             }
 
             EditorGUILayout.EndHorizontal();
@@ -184,15 +184,15 @@ private void DrawEventInspector(SerializedProperty selectedEventProperty, TEvent
         private bool DrawContainerInspector(SerializedProperty selectedEventProperty, TEvent selectedEvent)
         {
             bool addedSound = false;
-            EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.containerType"));
+            EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.ContainerType"));
 
             if (!selectedEvent.IsContinuous())
             {
-                EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.looping"));
+                EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Looping"));
 
-                if (selectedEvent.Container.looping)
+                if (selectedEvent.Container.Looping)
                 {
-                    EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.loopTime"));
+                    EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.LoopTime"));
                 }
             }
 
@@ -201,7 +201,7 @@ private bool DrawContainerInspector(SerializedProperty selectedEventProperty, TE
 
             if (selectedEvent.IsContinuous())
             {
-                EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.crossfadeTime"));
+                EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.CrossfadeTime"));
             }
 
             EditorGUILayout.BeginHorizontal();
@@ -220,7 +220,7 @@ private bool DrawContainerInspector(SerializedProperty selectedEventProperty, TE
 
         private void DrawSoundClipInspector(SerializedProperty selectedEventProperty, TEvent selectedEvent)
         {
-            bool allowLoopingClip = !selectedEvent.Container.looping;
+            bool allowLoopingClip = !selectedEvent.Container.Looping;
 
             if (allowLoopingClip)
             {
@@ -230,15 +230,15 @@ private void DrawSoundClipInspector(SerializedProperty selectedEventProperty, TE
                 }
             }
 
-            for (int i = 0; i < selectedEvent.Container.sounds.Length; i++)
+            for (int i = 0; i < selectedEvent.Container.Sounds.Length; i++)
             {
                 EditorGUILayout.Space();
                 EditorGUILayout.BeginHorizontal();
-                EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "].sound"));
+                EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "].Sound"));
 
                 if (EditorGUILayoutExtensions.Button("Remove"))
                 {
-                    selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "]").DeleteCommand();
+                    selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "]").DeleteCommand();
                     break;
                 }
 
@@ -247,23 +247,23 @@ private void DrawSoundClipInspector(SerializedProperty selectedEventProperty, TE
                 if (!selectedEvent.IsContinuous())
                 {
                     EditorGUILayout.BeginHorizontal();
-                    EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "].delayCenter"));
-                    EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "].delayRandomization"));
+                    EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "].DelayCenter"));
+                    EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "].DelayRandomization"));
                     EditorGUILayout.EndHorizontal();
 
                     //Disable looping next clips in a simultaneous container only.
                     if (allowLoopingClip)
                     {
-                        EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "].looping"));
+                        EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "].Looping"));
 
-                        if (selectedEvent.Container.sounds[i].looping && selectedEvent.Container.containerType == AudioContainerType.Simultaneous)
+                        if (selectedEvent.Container.Sounds[i].Looping && selectedEvent.Container.ContainerType == AudioContainerType.Simultaneous)
                         {
                             allowLoopingClip = false;
                         }
                     }
                     else
                     {
-                        selectedEvent.Container.sounds[i].looping = false;
+                        selectedEvent.Container.Sounds[i].Looping = false;
                     }
                 }
             }
@@ -293,18 +293,18 @@ private void UpdateEventNames(TEvent[] EditorEvents)
         private void AddSound(TEvent selectedEvent)
         {
 
-            UAudioClip[] tempClips = new UAudioClip[selectedEvent.Container.sounds.Length + 1];
-            selectedEvent.Container.sounds.CopyTo(tempClips, 0);
+            UAudioClip[] tempClips = new UAudioClip[selectedEvent.Container.Sounds.Length + 1];
+            selectedEvent.Container.Sounds.CopyTo(tempClips, 0);
             tempClips[tempClips.Length - 1] = new UAudioClip();
-            selectedEvent.Container.sounds = tempClips;
+            selectedEvent.Container.Sounds = tempClips;
         }
 
         private TEvent[] AddAudioEvent(TEvent[] EditorEvents)
         {
             TEvent tempEvent = new TEvent();
             TEvent[] tempEventArray = new TEvent[EditorEvents.Length + 1];
             tempEvent.Container = new AudioContainer();
-            tempEvent.Container.sounds = new UAudioClip[0];
+            tempEvent.Container.Sounds = new UAudioClip[0];
             EditorEvents.CopyTo(tempEventArray, 0);
             tempEventArray[EditorEvents.Length] = tempEvent;
             this.eventNames = new string[tempEventArray.Length];
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/Editor/UAudioManagerEditor.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/Editor/UAudioManagerEditor.cs
@@ -10,7 +10,7 @@ public class UAudioManagerEditor : UAudioManagerBaseEditor<AudioEvent>
     {
         private void OnEnable()
         {
-            this.myTarget = (UAudioManager)target;
+            this.MyTarget = (UAudioManager)target;
             SetUpEditor();
         }
 
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/Editor/UAudioMiniManagerEditor.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/Editor/UAudioMiniManagerEditor.cs
@@ -10,7 +10,7 @@ public class UAudioMiniManagerEditor : UAudioManagerBaseEditor<MiniAudioEvent>
     {
         private void OnEnable()
         {
-            this.myTarget = (UAudioMiniManager)target;
+            this.MyTarget = (UAudioMiniManager)target;
             SetUpEditor();
         }
 
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/Editor/UAudioProfiler.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/Editor/UAudioProfiler.cs
@@ -65,17 +65,17 @@ private void CollectProfilerEvents(ProfilerEvent[] currentEvents)
             {
                 ActiveEvent currentEvent = activeEvents[i];
                 ProfilerEvent tempEvent = new ProfilerEvent();
-                tempEvent.EventName = currentEvent.audioEvent.Name;
+                tempEvent.EventName = currentEvent.AudioEvent.Name;
                 tempEvent.EmitterName = currentEvent.AudioEmitter.name;
 
                 // The bus might be null, Unity defaults to Editor-hidden master bus.
-                if (currentEvent.audioEvent.AudioBus == null)
+                if (currentEvent.AudioEvent.AudioBus == null)
                 {
                     tempEvent.BusName = "-MasterBus-";
                 }
                 else
                 {
-                    tempEvent.BusName = currentEvent.audioEvent.AudioBus.name;
+                    tempEvent.BusName = currentEvent.AudioEvent.AudioBus.name;
                 }
 
                 currentEvents[i] = tempEvent;
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/MiniAudioEvent.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/MiniAudioEvent.cs
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/UAudioManager.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/UAudioManager.cs
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/UAudioManagerBase.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/UAudioManagerBase.cs
diff --git a/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/UAudioMiniManager.cs b/Assets/HoloToolkit/SpatialSound/Scripts/UAudioManager/UAudioMiniManager.cs

Original file line number	Diff line number	Diff line change
`@@ -67,19 +67,19 @@ public string MessageOnAudioEnd`
`67`	`67`	`private set;`
`68`	`68`	`}`
`69`	`69`
`70`		`- public AudioEvent audioEvent = null;`
`71`		`- public bool isStoppable = true;`
`72`		`- public float volDest = 1;`
`73`		`- public float altVolDest = 1;`
`74`		`- public float currentFade = 0;`
`75`		`- public bool playingAlt = false;`
`76`		`- public bool isActiveTimeComplete = false;`
`77`		`- public float activeTime = 0;`
`78`		`- public bool cancelEvent = false;`
	`70`	`+ public AudioEvent AudioEvent = null;`
	`71`	`+ public bool IsStoppable = true;`
	`72`	`+ public float VolDest = 1;`
	`73`	`+ public float AltVolDest = 1;`
	`74`	`+ public float CurrentFade = 0;`
	`75`	`+ public bool PlayingAlt = false;`
	`76`	`+ public bool IsActiveTimeComplete = false;`
	`77`	`+ public float ActiveTime = 0;`
	`78`	`+ public bool CancelEvent = false;`
`79`	`79`
`80`	`80`	`public ActiveEvent(AudioEvent audioEvent, GameObject emitter, AudioSource primarySource, AudioSource secondarySource, string messageOnAudioEnd = null)`
`81`	`81`	`{`
`82`		`- this.audioEvent = audioEvent;`
	`82`	`+ this.AudioEvent = audioEvent;`
`83`	`83`	`AudioEmitter = emitter;`
`84`	`84`	`PrimarySource = primarySource;`
`85`	`85`	`SecondarySource = secondarySource;`
`@@ -103,7 +103,7 @@ private void SetSourceProperties()`
`103`	`103`	`}`
`104`	`104`	`};`
`105`	`105`
`106`		`- AudioEvent audioEvent = this.audioEvent;`
	`106`	`+ AudioEvent audioEvent = this.AudioEvent;`
`107`	`107`	`switch (audioEvent.Spatialization)`
`108`	`108`	`{`
`109`	`109`	`case SpatialPositioningType.TwoD:`
`@@ -186,7 +186,7 @@ private void SetSourceProperties()`
`186`	`186`	`if (audioEvent.FadeInTime > 0)`
`187`	`187`	`{`
`188`	`188`	`forEachSource((source) => source.volume = 0f);`
`189`		`- this.currentFade = audioEvent.FadeInTime;`
	`189`	`+ this.CurrentFade = audioEvent.FadeInTime;`
`190`	`190`	`if (audioEvent.VolumeRandomization != 0)`
`191`	`191`	`{`
`192`	`192`	`vol = UnityEngine.Random.Range(audioEvent.VolumeCenter - audioEvent.VolumeRandomization, audioEvent.VolumeCenter + audioEvent.VolumeRandomization);`
`@@ -195,7 +195,7 @@ private void SetSourceProperties()`
`195`	`195`	`{`
`196`	`196`	`vol = audioEvent.VolumeCenter;`
`197`	`197`	`}`
`198`		`- this.volDest = vol;`
	`198`	`+ this.VolDest = vol;`
`199`	`199`	`}`
`200`	`200`	`else`
`201`	`201`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,10 @@ namespace HoloToolkit.Unity`
`11`	`11`	`[Serializable]`
`12`	`12`	`public class UAudioClip`
`13`	`13`	`{`
`14`		`- public UnityEngine.AudioClip sound = null;`
`15`		`- public bool looping = false;`
	`14`	`+ public UnityEngine.AudioClip Sound = null;`
	`15`	`+ public bool Looping = false;`
`16`	`16`
`17`		`- public float delayCenter = 0;`
`18`		`- public float delayRandomization = 0;`
	`17`	`+ public float DelayCenter = 0;`
	`18`	`+ public float DelayRandomization = 0;`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,12 @@ namespace HoloToolkit.Unity`
`14`	`14`	`public class AudioContainer`
`15`	`15`	`{`
`16`	`16`	`[Tooltip("The type of the audio container.")]`
`17`		`- public AudioContainerType containerType = AudioContainerType.Random;`
	`17`	`+ public AudioContainerType ContainerType = AudioContainerType.Random;`
`18`	`18`
`19`		`- public bool looping = false;`
`20`		`- public float loopTime = 0;`
`21`		`- public UAudioClip[] sounds = null;`
`22`		`- public float crossfadeTime = 0f;`
`23`		`- public int currentClip = 0;`
	`19`	`+ public bool Looping = false;`
	`20`	`+ public float LoopTime = 0;`
	`21`	`+ public UAudioClip[] Sounds = null;`
	`22`	`+ public float CrossfadeTime = 0f;`
	`23`	`+ public int CurrentClip = 0;`
`24`	`24`	`}`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,8 +158,8 @@ public class AudioEvent : IComparable, IComparable<AudioEvent>`
`158`	`158`	`/// <returns>True if this AudioEvent's container is one of the continuous types (random or sequential), otherwise false.</returns>`
`159`	`159`	`public bool IsContinuous()`
`160`	`160`	`{`
`161`		`- return Container.containerType == AudioContainerType.ContinuousRandom \|\|`
`162`		`- Container.containerType == AudioContainerType.ContinuousSequence;`
	`161`	`+ return Container.ContainerType == AudioContainerType.ContinuousRandom \|\|`
	`162`	`+ Container.ContainerType == AudioContainerType.ContinuousSequence;`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace HoloToolkit.Unity`
`9`	`9`	`{`
`10`	`10`	`public class UAudioManagerBaseEditor<TEvent> : Editor where TEvent : AudioEvent, new()`
`11`	`11`	`{`
`12`		`- protected UAudioManagerBase<TEvent> myTarget;`
	`12`	`+ protected UAudioManagerBase<TEvent> MyTarget;`
`13`	`13`	`private string[] eventNames;`
`14`	`14`	`private int selectedEventIndex = 0;`
`15`	`15`	`private readonly string[] posTypes = { "2D", "3D", "Spatial Sound" };`
`@@ -18,37 +18,37 @@ namespace HoloToolkit.Unity`
`18`	`18`	`protected void SetUpEditor()`
`19`	`19`	`{`
`20`	`20`	`// Having a null array of events causes too many errors and should only happen on first adding anyway.`
`21`		`- if (this.myTarget.EditorEvents == null)`
	`21`	`+ if (this.MyTarget.EditorEvents == null)`
`22`	`22`	`{`
`23`		`- this.myTarget.EditorEvents = new TEvent[0];`
	`23`	`+ this.MyTarget.EditorEvents = new TEvent[0];`
`24`	`24`	`}`
`25`		`- this.eventNames = new string[this.myTarget.EditorEvents.Length];`
`26`		`- UpdateEventNames(this.myTarget.EditorEvents);`
	`25`	`+ this.eventNames = new string[this.MyTarget.EditorEvents.Length];`
	`26`	`+ UpdateEventNames(this.MyTarget.EditorEvents);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`protected void DrawInspectorGUI(bool showEmitters)`
`30`	`30`	`{`
`31`	`31`	`this.serializedObject.Update();`
`32`	`32`	`EditorGUI.BeginChangeCheck();`
`33`		`- DrawEventHeader(this.myTarget.EditorEvents);`
	`33`	`+ DrawEventHeader(this.MyTarget.EditorEvents);`
`34`	`34`
`35`		`- if (this.myTarget.EditorEvents != null && this.myTarget.EditorEvents.Length > 0)`
	`35`	`+ if (this.MyTarget.EditorEvents != null && this.MyTarget.EditorEvents.Length > 0)`
`36`	`36`	`{`
`37`	`37`	`// Display current event in dropdown.`
`38`	`38`	`EditorGUI.indentLevel++;`
`39`	`39`	`this.selectedEventIndex = EditorGUILayout.Popup(this.selectedEventIndex, this.eventNames);`
`40`	`40`
`41`		`- if (this.selectedEventIndex < this.myTarget.EditorEvents.Length)`
	`41`	`+ if (this.selectedEventIndex < this.MyTarget.EditorEvents.Length)`
`42`	`42`	`{`
`43`	`43`	`TEvent selectedEvent;`
`44`	`44`
`45`		`- selectedEvent = this.myTarget.EditorEvents[this.selectedEventIndex];`
`46`		`- SerializedProperty selectedEventProperty = this.serializedObject.FindProperty("events.Array.data[" + this.selectedEventIndex.ToString() + "]");`
	`45`	`+ selectedEvent = this.MyTarget.EditorEvents[this.selectedEventIndex];`
	`46`	`+ SerializedProperty selectedEventProperty = this.serializedObject.FindProperty("Events.Array.data[" + this.selectedEventIndex.ToString() + "]");`
`47`	`47`	`EditorGUILayout.Space();`
`48`	`48`
`49`	`49`	`if (selectedEventProperty != null)`
`50`	`50`	`{`
`51`		`- DrawEventInspector(selectedEventProperty, selectedEvent, this.myTarget.EditorEvents, showEmitters);`
	`51`	`+ DrawEventInspector(selectedEventProperty, selectedEvent, this.MyTarget.EditorEvents, showEmitters);`
`52`	`52`	`if (!DrawContainerInspector(selectedEventProperty, selectedEvent))`
`53`	`53`	`{`
`54`	`54`	`EditorGUI.indentLevel++;`
`@@ -66,7 +66,7 @@ protected void DrawInspectorGUI(bool showEmitters)`
`66`	`66`
`67`	`67`	`if (UnityEngine.GUI.changed)`
`68`	`68`	`{`
`69`		`- EditorUtility.SetDirty(this.myTarget);`
	`69`	`+ EditorUtility.SetDirty(this.MyTarget);`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`@@ -81,13 +81,13 @@ private void DrawEventHeader(TEvent[] EditorEvents)`
`81`	`81`	`{`
`82`	`82`	`if (EditorGUILayoutExtensions.Button("Remove"))`
`83`	`83`	`{`
`84`		`- this.myTarget.EditorEvents = RemoveAudioEvent(EditorEvents, this.selectedEventIndex);`
	`84`	`+ this.MyTarget.EditorEvents = RemoveAudioEvent(EditorEvents, this.selectedEventIndex);`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`if (EditorGUILayoutExtensions.Button("Add"))`
`89`	`89`	`{`
`90`		`- this.myTarget.EditorEvents = AddAudioEvent(EditorEvents);`
	`90`	`+ this.MyTarget.EditorEvents = AddAudioEvent(EditorEvents);`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`EditorGUILayout.EndHorizontal();`
`@@ -184,15 +184,15 @@ private void DrawEventInspector(SerializedProperty selectedEventProperty, TEvent`
`184`	`184`	`private bool DrawContainerInspector(SerializedProperty selectedEventProperty, TEvent selectedEvent)`
`185`	`185`	`{`
`186`	`186`	`bool addedSound = false;`
`187`		`- EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.containerType"));`
	`187`	`+ EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.ContainerType"));`
`188`	`188`
`189`	`189`	`if (!selectedEvent.IsContinuous())`
`190`	`190`	`{`
`191`		`- EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.looping"));`
	`191`	`+ EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Looping"));`
`192`	`192`
`193`		`- if (selectedEvent.Container.looping)`
	`193`	`+ if (selectedEvent.Container.Looping)`
`194`	`194`	`{`
`195`		`- EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.loopTime"));`
	`195`	`+ EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.LoopTime"));`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`@@ -201,7 +201,7 @@ private bool DrawContainerInspector(SerializedProperty selectedEventProperty, TE`
`201`	`201`
`202`	`202`	`if (selectedEvent.IsContinuous())`
`203`	`203`	`{`
`204`		`- EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.crossfadeTime"));`
	`204`	`+ EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.CrossfadeTime"));`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`EditorGUILayout.BeginHorizontal();`
`@@ -220,7 +220,7 @@ private bool DrawContainerInspector(SerializedProperty selectedEventProperty, TE`
`220`	`220`
`221`	`221`	`private void DrawSoundClipInspector(SerializedProperty selectedEventProperty, TEvent selectedEvent)`
`222`	`222`	`{`
`223`		`- bool allowLoopingClip = !selectedEvent.Container.looping;`
	`223`	`+ bool allowLoopingClip = !selectedEvent.Container.Looping;`
`224`	`224`
`225`	`225`	`if (allowLoopingClip)`
`226`	`226`	`{`
`@@ -230,15 +230,15 @@ private void DrawSoundClipInspector(SerializedProperty selectedEventProperty, TE`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`
`233`		`- for (int i = 0; i < selectedEvent.Container.sounds.Length; i++)`
	`233`	`+ for (int i = 0; i < selectedEvent.Container.Sounds.Length; i++)`
`234`	`234`	`{`
`235`	`235`	`EditorGUILayout.Space();`
`236`	`236`	`EditorGUILayout.BeginHorizontal();`
`237`		`- EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "].sound"));`
	`237`	`+ EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "].Sound"));`
`238`	`238`
`239`	`239`	`if (EditorGUILayoutExtensions.Button("Remove"))`
`240`	`240`	`{`
`241`		`- selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "]").DeleteCommand();`
	`241`	`+ selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "]").DeleteCommand();`
`242`	`242`	`break;`
`243`	`243`	`}`
`244`	`244`
`@@ -247,23 +247,23 @@ private void DrawSoundClipInspector(SerializedProperty selectedEventProperty, TE`
`247`	`247`	`if (!selectedEvent.IsContinuous())`
`248`	`248`	`{`
`249`	`249`	`EditorGUILayout.BeginHorizontal();`
`250`		`- EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "].delayCenter"));`
`251`		`- EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "].delayRandomization"));`
	`250`	`+ EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "].DelayCenter"));`
	`251`	`+ EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "].DelayRandomization"));`
`252`	`252`	`EditorGUILayout.EndHorizontal();`
`253`	`253`
`254`	`254`	`//Disable looping next clips in a simultaneous container only.`
`255`	`255`	`if (allowLoopingClip)`
`256`	`256`	`{`
`257`		`- EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.sounds.Array.data[" + i + "].looping"));`
	`257`	`+ EditorGUILayout.PropertyField(selectedEventProperty.FindPropertyRelative("Container.Sounds.Array.data[" + i + "].Looping"));`
`258`	`258`
`259`		`- if (selectedEvent.Container.sounds[i].looping && selectedEvent.Container.containerType == AudioContainerType.Simultaneous)`
	`259`	`+ if (selectedEvent.Container.Sounds[i].Looping && selectedEvent.Container.ContainerType == AudioContainerType.Simultaneous)`
`260`	`260`	`{`
`261`	`261`	`allowLoopingClip = false;`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`	`else`
`265`	`265`	`{`
`266`		`- selectedEvent.Container.sounds[i].looping = false;`
	`266`	`+ selectedEvent.Container.Sounds[i].Looping = false;`
`267`	`267`	`}`
`268`	`268`	`}`
`269`	`269`	`}`
`@@ -293,18 +293,18 @@ private void UpdateEventNames(TEvent[] EditorEvents)`
`293`	`293`	`private void AddSound(TEvent selectedEvent)`
`294`	`294`	`{`
`295`	`295`
`296`		`- UAudioClip[] tempClips = new UAudioClip[selectedEvent.Container.sounds.Length + 1];`
`297`		`- selectedEvent.Container.sounds.CopyTo(tempClips, 0);`
	`296`	`+ UAudioClip[] tempClips = new UAudioClip[selectedEvent.Container.Sounds.Length + 1];`
	`297`	`+ selectedEvent.Container.Sounds.CopyTo(tempClips, 0);`
`298`	`298`	`tempClips[tempClips.Length - 1] = new UAudioClip();`
`299`		`- selectedEvent.Container.sounds = tempClips;`
	`299`	`+ selectedEvent.Container.Sounds = tempClips;`
`300`	`300`	`}`
`301`	`301`
`302`	`302`	`private TEvent[] AddAudioEvent(TEvent[] EditorEvents)`
`303`	`303`	`{`
`304`	`304`	`TEvent tempEvent = new TEvent();`
`305`	`305`	`TEvent[] tempEventArray = new TEvent[EditorEvents.Length + 1];`
`306`	`306`	`tempEvent.Container = new AudioContainer();`
`307`		`- tempEvent.Container.sounds = new UAudioClip[0];`
	`307`	`+ tempEvent.Container.Sounds = new UAudioClip[0];`
`308`	`308`	`EditorEvents.CopyTo(tempEventArray, 0);`
`309`	`309`	`tempEventArray[EditorEvents.Length] = tempEvent;`
`310`	`310`	`this.eventNames = new string[tempEventArray.Length];`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public class UAudioManagerEditor : UAudioManagerBaseEditor<AudioEvent>`
`10`	`10`	`{`
`11`	`11`	`private void OnEnable()`
`12`	`12`	`{`
`13`		`- this.myTarget = (UAudioManager)target;`
	`13`	`+ this.MyTarget = (UAudioManager)target;`
`14`	`14`	`SetUpEditor();`
`15`	`15`	`}`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public class UAudioMiniManagerEditor : UAudioManagerBaseEditor<MiniAudioEvent>`
`10`	`10`	`{`
`11`	`11`	`private void OnEnable()`
`12`	`12`	`{`
`13`		`- this.myTarget = (UAudioMiniManager)target;`
	`13`	`+ this.MyTarget = (UAudioMiniManager)target;`
`14`	`14`	`SetUpEditor();`
`15`	`15`	`}`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -65,17 +65,17 @@ private void CollectProfilerEvents(ProfilerEvent[] currentEvents)`
`65`	`65`	`{`
`66`	`66`	`ActiveEvent currentEvent = activeEvents[i];`
`67`	`67`	`ProfilerEvent tempEvent = new ProfilerEvent();`
`68`		`- tempEvent.EventName = currentEvent.audioEvent.Name;`
	`68`	`+ tempEvent.EventName = currentEvent.AudioEvent.Name;`
`69`	`69`	`tempEvent.EmitterName = currentEvent.AudioEmitter.name;`
`70`	`70`
`71`	`71`	`// The bus might be null, Unity defaults to Editor-hidden master bus.`
`72`		`- if (currentEvent.audioEvent.AudioBus == null)`
	`72`	`+ if (currentEvent.AudioEvent.AudioBus == null)`
`73`	`73`	`{`
`74`	`74`	`tempEvent.BusName = "-MasterBus-";`
`75`	`75`	`}`
`76`	`76`	`else`
`77`	`77`	`{`
`78`		`- tempEvent.BusName = currentEvent.audioEvent.AudioBus.name;`
	`78`	`+ tempEvent.BusName = currentEvent.AudioEvent.AudioBus.name;`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`currentEvents[i] = tempEvent;`