Update AssetsDownloader.cs

.github/workflows/build.yml

@@ -2,9 +2,9 @@ name: Build
 
 on:
   push:
-    branches: [ "master" ]
+    branches: [ "dev" ]
   pull_request:
-    branches: [ "master" ]
+    branches: [ "dev" ]
   workflow_dispatch: {}
 
 jobs:
@@ -45,7 +45,7 @@ jobs:
         with:
           targetPlatform: Android
           allowDirtyBuild: true
-          buildName: "HooverHighQuestAppLauncher"
+          buildName: "HooverHighQuestAppLauncher-DEV"
 
       # Output
       - name: Upload build
@@ -53,12 +53,12 @@ jobs:
         with:
           files: build/Android/*.apk
           token: ${{ secrets.GITHUB_TOKEN }}
-          tag_name: "1.0.0"
+          tag_name: "1.0.0-dev"
       
       # Upload dir
       - uses: actions/upload-artifact@v2
         with:
-          name: Build
+          name: Build-dev
           path: build
       
       # Return License

.gitignore

@@ -1,42 +1,13 @@
-# This .gitignore file should be placed at the root of your Unity project directory
+[Ll]ibrary/
-#
+[Tt]emp/
-# Get latest from https://github.com/github/gitignore/blob/main/Unity.gitignore
+[Oo]bj/
-#
+[Bb]uild/
-.utmp/
+[Bb]uilds/
-/[Ll]ibrary/
+Assets/AssetStoreTools*
-/[Tt]emp/
-/[Oo]bj/
-/[Bb]uild/
-/[Bb]uilds/
-/[Ll]ogs/
-/[Uu]ser[Ss]ettings/
-*.log
-
-# By default unity supports Blender asset imports, *.blend1 blender files do not need to be commited to version control.
-*.blend1
-*.blend1.meta
-
-# MemoryCaptures can get excessive in size.
-# They also could contain extremely sensitive data
-/[Mm]emoryCaptures/
-
-# Recordings can get excessive in size
-/[Rr]ecordings/
-
-# Uncomment this line if you wish to ignore the asset store tools plugin
-# /[Aa]ssets/AssetStoreTools*
-
-# Autogenerated Jetbrains Rider plugin
-/[Aa]ssets/Plugins/Editor/JetBrains*
-# Jetbrains Rider personal-layer settings
-*.DotSettings.user
 
 # Visual Studio cache directory
 .vs/
 
-# Gradle cache directory
-.gradle/
-
 # Autogenerated VS/MD/Consulo solution and project files
 ExportedObj/
 .consulo/
@@ -51,49 +22,16 @@ ExportedObj/
 *.booproj
 *.svd
 *.pdb
-*.mdb
 *.opendb
-*.VC.db
 
 # Unity3D generated meta files
 *.pidb.meta
 *.pdb.meta
-*.mdb.meta
 
-# Unity3D generated file on crash reports
+# Unity3D Generated File On Crash Reports
 sysinfo.txt
 
-# Mono auto generated files
-mono_crash.*
-
 # Builds
 *.apk
-*.aab
 *.unitypackage
-*.unitypackage.meta
-*.app
 
-# Crashlytics generated file
-crashlytics-build.properties
-
-# TestRunner generated files
-InitTestScene*.unity*
-
-# Addressables default ignores, before user customizations
-/ServerData
-/[Aa]ssets/StreamingAssets/aa*
-/[Aa]ssets/AddressableAssetsData/link.xml*
-/[Aa]ssets/Addressables_Temp*
-# By default, Addressables content builds will generate addressables_content_state.bin
-# files in platform-specific subfolders, for example:
-# /Assets/AddressableAssetsData/OSX/addressables_content_state.bin
-/[Aa]ssets/AddressableAssetsData/*/*.bin*
-
-# Visual Scripting auto-generated files
-/[Aa]ssets/Unity.VisualScripting.Generated/VisualScripting.Flow/UnitOptions.db
-/[Aa]ssets/Unity.VisualScripting.Generated/VisualScripting.Flow/UnitOptions.db.meta
-/[Aa]ssets/Unity.VisualScripting.Generated/VisualScripting.Core/Property Providers
-/[Aa]ssets/Unity.VisualScripting.Generated/VisualScripting.Core/Property Providers.meta
-
-# Auto-generated scenes by play mode tests
-/[Aa]ssets/[Ii]nit[Tt]est[Ss]cene*.unity*

Assets/OVRInputSelection/InputSystem/OVRInputHelpers.cs

@@ -162,7 +162,7 @@ namespace ControllerSelection
             Debug.LogWarning("OVRManager is not in scene, finding tracking space is going to be expensive!");
 
             // Look for any CameraRig objects
-            OVRCameraRig[] cameraRigs = UnityEngine.Object.FindObjectsByType<OVRCameraRig>(FindObjectsSortMode.None);
+            OVRCameraRig[] cameraRigs = UnityEngine.Object.FindObjectsOfType(typeof(OVRCameraRig)) as OVRCameraRig[];
             foreach (OVRCameraRig cameraRig in cameraRigs) {
                 if (cameraRig.gameObject.activeSelf) {
                     Transform trackingSpace = cameraRig.transform.Find("TrackingSpace");
@@ -201,6 +201,16 @@ namespace ControllerSelection
                 return OVRInput.Controller.LTouch;
             }
 
+            if (((filter & HandFilter.Right) == HandFilter.Right) && (controller & OVRInput.Controller.RTrackedRemote) == OVRInput.Controller.RTrackedRemote)
+            {
+                return OVRInput.Controller.RTrackedRemote;
+            }
+
+            if (((filter & HandFilter.Left) == HandFilter.Left) && (controller & OVRInput.Controller.LTrackedRemote) == OVRInput.Controller.LTrackedRemote)
+            {
+                return OVRInput.Controller.LTrackedRemote;
+            }
+
             controller = OVRInput.Controller.None;
             if (OVRPlugin.GetHandTrackingEnabled())
             {

Assets/OVRInputSelection/InputSystem/OVRInputModule.cs

@@ -140,7 +140,7 @@ namespace ControllerSelection
         protected OVRInputModule()
         {}
 
-        protected void Reset()
+        protected new void Reset()
         {
             allowActivationOnMobileDevice = true;
         }

Assets/OVRInputSelection/InputSystem/OVRPointerVisualizer.cs.meta

@@ -1,7 +1,8 @@
 fileFormatVersion: 2
-guid: 381438ccbd3fed745bdd420a3ffddd83
+guid: 12283131fa5724f44b343883ae474072
+timeCreated: 1512454634
+licenseType: Pro
 MonoImporter:
-  externalObjects: {}
   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0

Assets/OVRInputSelection/InputSystem/OVRRawRaycaster.cs

@@ -190,8 +190,10 @@ namespace ControllerSelection
         {
             // Handle selection callbacks. An object is selected if the button selecting it was
             // pressed AND released while hovering over the object.
-            if (isLeft && (activeController & OVRInput.Controller.LTouch) != OVRInput.Controller.LTouch ||
+            if (isLeft && (activeController & OVRInput.Controller.LTouch) != OVRInput.Controller.LTouch &&
-                !isLeft && (activeController & OVRInput.Controller.RTouch) != OVRInput.Controller.RTouch)
+                (activeController & OVRInput.Controller.LTrackedRemote) != OVRInput.Controller.LTrackedRemote ||
+                !isLeft && (activeController & OVRInput.Controller.RTouch) != OVRInput.Controller.RTouch &&
+                (activeController & OVRInput.Controller.RTrackedRemote) != OVRInput.Controller.RTrackedRemote)
             {
                 return;
             }

Assets/OVRInputSelection/Materials/SelectionRay.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: SelectionRay
+  m_Shader: {fileID: 10755, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 0, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/OVRInputSelection/Materials/SelectionRay.mat.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 02f4d91e963f1e74d8bee0002c24efe7
+timeCreated: 1512379123
+licenseType: Free
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/OVRInputSelection/Scripts/BackButtonLogic.cs

@@ -36,7 +36,7 @@ public class BackButtonLogic : MonoBehaviour {
 
             if (scene.name == "main") {
 #if UNITY_ANDROID && !UNITY_EDITOR
-                UnityEngine.Application.Quit();
+		        OVRManager.PlatformUIConfirmQuit();
 #endif
             }
             else {

Assets/Oculus/AudioManager.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3701e8c189047bd4e846e85a926beca3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 25be027379f7fce4d97ba2bcaf313019
+folderAsset: yes
+timeCreated: 1470780399
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Audio.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b8c0d722519c64144a78f8fc99cd40b5
+folderAsset: yes
+timeCreated: 1468505670
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Audio/AmbienceEmitter.cs

@@ -0,0 +1,118 @@
+using UnityEngine;
+using System.Collections;
+
+namespace OVR
+{
+
+/*
+-----------------------
+ 
+ AmbienceEmitter()
+ 
+-----------------------
+*/
+public class AmbienceEmitter : MonoBehaviour {
+
+	public SoundFXRef[]		ambientSounds = new SoundFXRef[0];
+	public bool				autoActivate = true;
+	[Tooltip("Automatically play the sound randomly again when checked.  Should be OFF for looping sounds")]
+	public bool				autoRetrigger = true;
+	[MinMax( 2.0f, 4.0f, 0.1f, 10.0f )]
+	public Vector2			randomRetriggerDelaySecs = new Vector2( 2.0f, 4.0f );
+	[Tooltip( "If defined, the sounds will randomly play from these transform positions, otherwise the sound will play from this transform" )]
+	public Transform[]		playPositions = new Transform[0];
+	private bool			activated = false;
+	private int				playingIdx = -1;
+	private float			nextPlayTime = 0.0f;
+	private float			fadeTime = 0.25f;
+	private int				lastPosIdx = -1;
+
+	/*
+	-----------------------
+	Awake()
+	-----------------------
+	*/
+	void Awake() {
+		if ( autoActivate ) {
+			activated = true;
+			nextPlayTime = Time.time + Random.Range( randomRetriggerDelaySecs.x, randomRetriggerDelaySecs.y );
+		}
+		// verify all the play positions are valid
+		foreach ( Transform t in playPositions ) {
+			if ( t == null ) {
+				Debug.LogWarning( "[AmbienceEmitter] Invalid play positions in " + name );
+				playPositions = new Transform[0];
+				break;
+			}
+		}
+	}
+
+	/*
+	-----------------------
+	Update()
+	-----------------------
+	*/
+	void Update() {
+		if ( activated ) {
+			if ( ( playingIdx == -1 ) || autoRetrigger ) {
+				if ( Time.time >= nextPlayTime ) {
+					Play();
+					if ( !autoRetrigger ) {
+						activated = false;
+					}
+				}
+			}
+		}
+	}
+
+	/*
+	-----------------------
+	OnTriggerEnter()
+	-----------------------
+	*/
+	public void OnTriggerEnter( Collider col ) {
+		activated = !activated;
+	}
+
+	/*
+	-----------------------
+	Play()
+	-----------------------
+	*/
+	public void Play() {
+		Transform transformToPlayFrom = transform;
+		if ( playPositions.Length > 0 ) {
+			int idx = Random.Range( 0, playPositions.Length );
+			while ( ( playPositions.Length > 1 ) && ( idx == lastPosIdx ) ) {
+				 idx = Random.Range( 0, playPositions.Length );
+			}
+			transformToPlayFrom = playPositions[idx];
+			lastPosIdx = idx;
+		}
+		playingIdx = ambientSounds[Random.Range(0, ambientSounds.Length)].PlaySoundAt( transformToPlayFrom.position );
+		if ( playingIdx != -1 ) {
+			AudioManager.FadeInSound( playingIdx, fadeTime );
+			nextPlayTime = Time.time + Random.Range( randomRetriggerDelaySecs.x, randomRetriggerDelaySecs.y );
+		}
+	}
+
+	/*
+	-----------------------
+	EnableEmitter()
+	-----------------------
+	*/
+	public void EnableEmitter( bool enable ) {
+		activated = enable;
+		if ( enable ) {
+			Play();
+		} else {
+			if ( playingIdx != -1 ) {
+				AudioManager.FadeOutSound( playingIdx, fadeTime );
+			}
+		}
+
+	}
+
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/AmbienceEmitter.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c11944691f6b9cf44a391c95cb3f7dea
+timeCreated: 1455050294
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Audio/AudioManager.cs

@@ -0,0 +1,429 @@
+using UnityEngine;
+using UnityEngine.Audio;
+using System.Collections;
+using System.Collections.Generic;
+#if UNITY_EDITOR
+using UnityEditor;
+using System;
+using System.Reflection;
+#endif
+
+namespace OVR
+{
+
+public enum PreloadSounds {
+	Default,		// default unity behavior
+	Preload,		// audio clips are forced to preload
+	ManualPreload,	// audio clips are forced to not preload, preloading must be done manually
+}
+
+public enum Fade
+{
+    In,
+    Out
+}
+
+[System.Serializable]
+public class SoundGroup {
+	public SoundGroup( string name ) {
+		this.name = name;
+	}
+	public SoundGroup() {
+		mixerGroup = null;
+		maxPlayingSounds = 0;
+		preloadAudio = PreloadSounds.Default;
+		volumeOverride = 1.0f;
+	}
+	public void IncrementPlayCount() {
+		playingSoundCount = Mathf.Clamp( ++playingSoundCount, 0, maxPlayingSounds );
+	}
+	public void DecrementPlayCount() {
+		playingSoundCount = Mathf.Clamp( --playingSoundCount, 0, maxPlayingSounds );
+	}
+	public bool CanPlaySound() {
+		return ( maxPlayingSounds == 0 ) || ( playingSoundCount < maxPlayingSounds );
+	}
+
+	public string			name = string.Empty;
+	public SoundFX[]		soundList = new SoundFX[0];
+	public AudioMixerGroup  mixerGroup = null;						// default = AudioManager.defaultMixerGroup
+	[Range(0,64)]
+	public int              maxPlayingSounds = 0;                   // default = 0, unlimited
+	// TODO: this preload behavior is not yet implemented
+	public PreloadSounds	preloadAudio = PreloadSounds.Default;	// default = true, audio clip data will be preloaded
+	public float            volumeOverride = 1.0f;					// default = 1.0
+
+	[HideInInspector]
+	public int              playingSoundCount = 0;
+}
+
+/*
+-----------------------
+
+ AudioManager
+
+-----------------------
+*/
+public partial class AudioManager : MonoBehaviour {
+
+	[Tooltip("Make the audio manager persistent across all scene loads")]
+	public bool							makePersistent = true;							// true = don't destroy on load
+	[Tooltip("Enable the OSP audio plugin features")]
+	public bool							enableSpatializedAudio = true;                  // true = enable spatialized audio
+	[Tooltip("Always play spatialized sounds with no reflections (Default)")]
+	public bool                         enableSpatializedFastOverride = false;          // true = disable spatialized reflections override
+	[Tooltip("The audio mixer asset used for snapshot blends, etc.")]
+	public AudioMixer                   audioMixer = null;
+	[Tooltip( "The audio mixer group used for the pooled emitters" )]
+	public AudioMixerGroup				defaultMixerGroup = null;
+	[Tooltip( "The audio mixer group used for the reserved pool emitter" )]
+	public AudioMixerGroup				reservedMixerGroup = null;
+	[Tooltip( "The audio mixer group used for voice chat" )]
+	public AudioMixerGroup				voiceChatMixerGroup = null;
+	[Tooltip("Log all PlaySound calls to the Unity console")]
+	public bool							verboseLogging = false;							// true = log all PlaySounds
+	[Tooltip("Maximum sound emitters")]
+	public int 							maxSoundEmitters = 32;							// total number of sound emitters created
+	[Tooltip("Default volume for all sounds modulated by individual sound FX volumes")]
+	public float						volumeSoundFX = 1.0f;							// user pref: volume of all sound FX
+	[Tooltip("Sound FX fade time")]
+	public float						soundFxFadeSecs = 1.0f;							// sound FX fade time
+	
+	public float						audioMinFallOffDistance = 1.0f;					// minimum falloff distance
+	public float						audioMaxFallOffDistance = 25.0f;				// maximum falloff distance
+
+	public SoundGroup[]					soundGroupings = new SoundGroup[0];
+
+	private Dictionary<string,SoundFX>	soundFXCache = null;
+
+	static private AudioManager			theAudioManager = null;
+	static private FastList<string> 	names = new FastList<string>();
+	static private string[]				defaultSound = new string[1] { "Default Sound" };
+	static private SoundFX				nullSound = new SoundFX();
+	static private bool					hideWarnings = false;
+	static public bool 					enableSpatialization { get { return ( theAudioManager !=null ) ? theAudioManager.enableSpatializedAudio : false; } }
+
+	static public AudioManager			Instance { get { return theAudioManager; } }
+	static public float					NearFallOff { get { return theAudioManager.audioMinFallOffDistance; } }
+	static public float					FarFallOff { get { return theAudioManager.audioMaxFallOffDistance; } }
+	static public AudioMixerGroup		EmitterGroup { get { return theAudioManager.defaultMixerGroup; } }
+	static public AudioMixerGroup		ReservedGroup { get { return theAudioManager.reservedMixerGroup; } }
+	static public AudioMixerGroup		VoipGroup { get { return theAudioManager.voiceChatMixerGroup; } }
+
+	/*
+	-----------------------
+	Awake()
+	-----------------------
+	*/
+	void Awake() {
+		Init();
+	}
+
+	/*
+	-----------------------
+	OnDestroy()
+	-----------------------
+	*/
+	void OnDestroy() {
+		// we only want the initialized audio manager instance cleaning up the sound emitters
+		if ( theAudioManager == this ) {
+			if ( soundEmitterParent != null ) {
+				Destroy( soundEmitterParent );
+			}
+		}
+		///TODO - if you change scenes you'll want to call OnPreSceneLoad to detach the sound emitters
+		///from anything they might be parented to or they will get destroyed with that object
+		///there should only be one instance of the AudioManager across the life of the game/app
+		///GameManager.OnPreSceneLoad -= OnPreSceneLoad;
+	}
+
+	/*
+	-----------------------
+	Init()
+	-----------------------
+	*/
+	void Init() {
+		if ( theAudioManager != null ) {
+			if ( Application.isPlaying && ( theAudioManager != this ) ) {
+				enabled = false;
+			}
+			return;
+		}
+		theAudioManager = this;
+
+		///TODO - if you change scenes you'll want to call OnPreSceneLoad to detach the sound emitters
+		///from anything they might be parented to or they will get destroyed with that object
+		///there should only be one instance of the AudioManager across the life of the game/app
+		///GameManager.OnPreSceneLoad += OnPreSceneLoad;
+
+		// make sure the first one is a null sound
+		nullSound.name = "Default Sound";
+
+		// build the sound FX cache
+		RebuildSoundFXCache();
+
+		// create the sound emitters
+		if ( Application.isPlaying ) {
+			InitializeSoundSystem();
+			if ( makePersistent && ( transform.parent == null ) ) {
+				// don't destroy the audio manager on scene loads
+				DontDestroyOnLoad( gameObject );
+			}
+		}
+
+#if UNITY_EDITOR
+		Debug.Log( "[AudioManager] Initialized..." );
+#endif
+	}
+
+	/*
+	-----------------------
+	Update()
+	-----------------------
+	*/
+	void Update() {
+		// update the free and playing lists
+		UpdateFreeEmitters();
+	}
+
+	/*
+	-----------------------
+	RebuildSoundFXCache()
+	-----------------------
+	*/
+	void RebuildSoundFXCache() {
+		// build the SoundFX dictionary for quick name lookups
+		int count = 0;
+		for ( int group = 0; group < soundGroupings.Length; group++ ) {
+			count += soundGroupings[group].soundList.Length;
+		}
+		soundFXCache = new Dictionary<string,SoundFX>( count + 1 );	
+		// add the null sound
+		soundFXCache.Add( nullSound.name, nullSound );
+		// add the rest
+		for ( int group = 0; group < soundGroupings.Length; group++ ) {
+			for ( int i = 0; i < soundGroupings[group].soundList.Length; i++ ) {
+				if ( soundFXCache.ContainsKey( soundGroupings[group].soundList[i].name ) ) {
+					Debug.LogError( "ERROR: Duplicate Sound FX name in the audio manager: '" + soundGroupings[group].name + "' > '" + soundGroupings[group].soundList[i].name + "'" );
+				} else {
+					soundGroupings[group].soundList[i].Group = soundGroupings[group];
+					soundFXCache.Add( soundGroupings[group].soundList[i].name, soundGroupings[group].soundList[i] );
+				}
+			}
+			soundGroupings[group].playingSoundCount = 0;
+		}
+	}
+
+	/*
+	-----------------------
+	FindSoundFX()
+	-----------------------
+	*/
+	static public SoundFX FindSoundFX( string name, bool rebuildCache = false ) {
+#if UNITY_EDITOR
+		if ( theAudioManager == null ) {
+			Debug.LogError( "ERROR: audio manager not yet initialized or created!" + " Time: " + Time.time  );
+			return null;
+		}
+#endif
+		if ( string.IsNullOrEmpty( name ) ) {
+			return nullSound;
+		}
+		if ( rebuildCache ) {
+			theAudioManager.RebuildSoundFXCache();
+		}
+		if ( !theAudioManager.soundFXCache.ContainsKey( name ) ) {
+#if DEBUG_BUILD || UNITY_EDITOR
+			Debug.LogError( "WARNING: Missing Sound FX in cache: " + name );
+#endif
+			return nullSound;
+		}
+		return theAudioManager.soundFXCache[name];
+	}
+
+	/*
+	-----------------------
+	FindAudioManager()
+	-----------------------
+	*/
+	static private bool FindAudioManager() {
+		GameObject audioManagerObject = GameObject.Find( "AudioManager" );
+		if ( ( audioManagerObject == null ) || ( audioManagerObject.GetComponent<AudioManager>() == null ) ) {
+			if ( !hideWarnings ) {
+				Debug.LogError( "[ERROR] AudioManager object missing from hierarchy!" );
+				hideWarnings = true;
+			}
+			return false;
+		} else {
+			audioManagerObject.GetComponent<AudioManager>().Init();
+		}
+		return true;
+	}
+
+	/*
+	-----------------------
+	GetGameObject()
+	-----------------------
+	*/
+	static public GameObject GetGameObject() {
+		if ( theAudioManager == null ) {
+			if ( !FindAudioManager() ) {
+				return null;
+			}
+		}
+		return theAudioManager.gameObject;
+	}
+
+	/*
+	-----------------------
+	NameMinusGroup()
+	strip off the sound group from the inspector dropdown
+	-----------------------
+	*/
+	static public string NameMinusGroup( string name ) {
+		if ( name.IndexOf( "/" ) > -1 ) {
+			return name.Substring( name.IndexOf( "/" ) + 1 );
+		}
+		return name;
+	}
+	
+	/*
+	-----------------------
+	GetSoundFXNames()
+	used by the inspector
+	-----------------------
+	*/
+	static public string[] GetSoundFXNames( string currentValue, out int currentIdx ) {
+		currentIdx = 0;
+		names.Clear();
+		if ( theAudioManager == null ) {
+			if ( !FindAudioManager() ) {
+				return defaultSound;
+			}
+		}
+		names.Add( nullSound.name );
+		for ( int group = 0; group < theAudioManager.soundGroupings.Length; group++ ) {
+			for ( int i = 0; i < theAudioManager.soundGroupings[group].soundList.Length; i++ ) {
+				if ( string.Compare( currentValue, theAudioManager.soundGroupings[group].soundList[i].name, true ) == 0 ) {
+					currentIdx = names.Count;
+				}
+				names.Add( theAudioManager.soundGroupings[group].name + "/" + theAudioManager.soundGroupings[group].soundList[i].name );
+			}
+		}
+		//names.Sort( delegate( string s1, string s2 ) { return s1.CompareTo( s2 ); } );
+		return names.ToArray();
+
+	}
+#if UNITY_EDITOR
+	/*
+	-----------------------
+	OnPrefabReimported()
+	-----------------------
+	*/
+	static public void OnPrefabReimported() {
+		if ( theAudioManager != null ) {
+			Debug.Log( "[AudioManager] Reimporting the sound FX cache." );
+			theAudioManager.RebuildSoundFXCache();
+		}
+	}
+
+	/*
+	-----------------------
+	PlaySound()
+	used in the editor
+	-----------------------
+	*/
+	static public void PlaySound( string soundFxName ) {
+		if ( theAudioManager == null ) {
+			if ( !FindAudioManager() ) {
+				return;
+			}
+		}
+		SoundFX soundFX = FindSoundFX( soundFxName, true );
+		if ( soundFX == null ) {
+			return;
+		}
+		AudioClip clip = soundFX.GetClip();
+		if ( clip != null ) {
+			Assembly unityEditorAssembly = typeof(AudioImporter).Assembly;
+			Type audioUtilClass = unityEditorAssembly.GetType("UnityEditor.AudioUtil");
+			MethodInfo method = audioUtilClass.GetMethod(
+				"PlayClip",
+				BindingFlags.Static | BindingFlags.Public,
+				null,
+				new System.Type[] { typeof(AudioClip) },
+				null );
+			method.Invoke( null, new object[] { clip } );
+		}
+	}
+
+	/*
+	-----------------------
+	IsSoundPlaying()
+	used in the editor
+	-----------------------
+	*/
+	static public bool IsSoundPlaying( string soundFxName ) {
+		if ( theAudioManager == null ) {
+			if ( !FindAudioManager() ) {
+				return false;
+			}
+		}
+		SoundFX soundFX = FindSoundFX( soundFxName, true );
+		if ( soundFX == null ) {
+			return false;
+		}
+		AudioClip clip = soundFX.GetClip();
+		if ( clip != null ) {
+			Assembly unityEditorAssembly = typeof(AudioImporter).Assembly;
+			Type audioUtilClass = unityEditorAssembly.GetType("UnityEditor.AudioUtil");
+			MethodInfo method = audioUtilClass.GetMethod(
+				"IsClipPlaying",
+				BindingFlags.Static | BindingFlags.Public,
+				null,
+				new System.Type[] { typeof(AudioClip) },
+				null );
+			return Convert.ToBoolean( method.Invoke( null, new object[] { clip } ) );
+		}
+
+		return false;
+	}
+
+	/*
+	-----------------------
+	StopSound()
+	used in the editor
+	-----------------------
+	*/
+	static public void StopSound(string soundFxName)
+	{
+		if (theAudioManager == null)
+		{
+			if (!FindAudioManager())
+			{
+				return;
+			}
+		}
+		SoundFX soundFX = FindSoundFX(soundFxName, true);
+		if (soundFX == null)
+		{
+			return;
+		}
+		AudioClip clip = soundFX.GetClip();
+		if (clip != null)
+		{
+			Assembly unityEditorAssembly = typeof(AudioImporter).Assembly;
+			Type audioUtilClass = unityEditorAssembly.GetType("UnityEditor.AudioUtil");
+			MethodInfo method = audioUtilClass.GetMethod(
+				"StopClip",
+				BindingFlags.Static | BindingFlags.Public,
+				null,
+				new System.Type[] { typeof(AudioClip) },
+				null);
+			method.Invoke(null, new object[] { clip });
+		}
+	}
+#endif
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/AudioManager.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6d1d30b41806244fca035fdae2896fb7
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/AudioManager_Sound.cs

@@ -0,0 +1,787 @@
+using UnityEngine;
+using UnityEngine.Audio;
+
+namespace OVR
+{
+
+//-------------------------------------------------------------------------
+// Types
+//-------------------------------------------------------------------------
+
+public enum EmitterChannel {
+	None = -1,
+	Reserved = 0,	// plays on the single reserved emitter
+	Any				// queues to the next available emitter
+}
+
+[System.Serializable]
+public class MixerSnapshot {
+	public AudioMixerSnapshot       snapshot = null;
+	public float                    transitionTime = 0.25f;
+}
+
+/*
+-----------------------
+ 
+ GameManager Sound Routines
+
+-----------------------
+*/
+public partial class AudioManager : MonoBehaviour {
+
+	public enum Fade {
+		In,
+		Out
+	}
+
+	private float					audioMaxFallOffDistanceSqr = 25.0f * 25.0f;		// past this distance, sounds are ignored for the local player 
+
+	private SoundEmitter[] 			soundEmitters = null;                           // pool of sound emitters to play sounds through
+
+	private FastList<SoundEmitter>  playingEmitters = new FastList<SoundEmitter>();
+	private FastList<SoundEmitter>  nextFreeEmitters = new FastList<SoundEmitter>();
+
+	private MixerSnapshot			currentSnapshot = null;
+
+	static private GameObject		soundEmitterParent = null;						// parent object for the sound emitters
+	static private Transform		staticListenerPosition = null;                  // play position for regular 2D sounds
+
+	static private bool				showPlayingEmitterCount = false;
+	static private bool				forceShowEmitterCount = false;
+
+	static private bool				soundEnabled = true;
+	static public bool				SoundEnabled { get { return soundEnabled; } }
+
+	static readonly AnimationCurve	defaultReverbZoneMix = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
+
+	/*
+	-----------------------
+	InitializeSoundSystem()
+	initialize persistent sound emitter objects that live across scene loads
+	-----------------------
+	*/
+	void InitializeSoundSystem() {
+
+		int bufferLength = 960;
+		int numBuffers = 4;
+		AudioSettings.GetDSPBufferSize( out bufferLength, out numBuffers );
+		if ( Application.isPlaying ) {
+			Debug.Log( "[AudioManager] Audio Sample Rate: " + AudioSettings.outputSampleRate );
+			Debug.Log( "[AudioManager] Audio Buffer Length: " + bufferLength + " Size: " + numBuffers );
+		}
+
+		// find the audio listener for playing regular 2D sounds
+		AudioListener audioListenerObject = GameObject.FindObjectOfType<AudioListener>() as AudioListener;
+		if ( audioListenerObject == null ) {
+			Debug.LogError( "[AudioManager] Missing AudioListener object!  Add one to the scene." );
+		} else {
+			staticListenerPosition = audioListenerObject.transform;
+		}
+
+		// we allocate maxSoundEmitters + reserved channels
+		soundEmitters = new SoundEmitter[maxSoundEmitters+(int)EmitterChannel.Any];
+		
+		// see if the sound emitters have already been created, if so, nuke it, it shouldn't exist in the scene upon load
+		soundEmitterParent = GameObject.Find( "__SoundEmitters__" );
+		if ( soundEmitterParent != null ) {
+			// delete any sound emitters hanging around
+			Destroy( soundEmitterParent );
+		}
+
+		// create them all															
+		soundEmitterParent = new GameObject( "__SoundEmitters__" );
+		for ( int i = 0; i < maxSoundEmitters + (int)EmitterChannel.Any; i++ ) {
+			GameObject emitterObject = new GameObject( "SoundEmitter_" + i ); 
+			emitterObject.transform.parent = soundEmitterParent.transform;
+			emitterObject.transform.position = Vector3.zero;
+			// don't ever save this to the scene
+			emitterObject.hideFlags = HideFlags.DontSaveInEditor;
+			// add the sound emitter components
+			soundEmitters[i] = emitterObject.AddComponent<SoundEmitter>();
+			soundEmitters[i].SetDefaultParent( soundEmitterParent.transform );
+			soundEmitters[i].SetChannel( i );
+			soundEmitters[i].Stop();
+			// save off the original index
+			soundEmitters[i].originalIdx = i;
+		}
+		// reset the free emitter lists
+		ResetFreeEmitters();
+		soundEmitterParent.hideFlags = HideFlags.DontSaveInEditor;
+			
+		audioMaxFallOffDistanceSqr = audioMaxFallOffDistance * audioMaxFallOffDistance;
+	}
+
+	/*
+	-----------------------
+	UpdateFreeEmitters()
+	-----------------------
+	*/
+	void UpdateFreeEmitters() {
+		if ( verboseLogging ) {
+			if ( Input.GetKeyDown( KeyCode.A ) ) {
+				forceShowEmitterCount = !forceShowEmitterCount;
+			}
+			if ( forceShowEmitterCount ) {
+				showPlayingEmitterCount = true;
+			}
+		}
+		// display playing emitter count when the sound system is overwhelmed
+		int total = 0, veryLow = 0, low = 0, def = 0, high = 0, veryHigh = 0;
+
+		// find emitters that are done playing and add them to the nextFreeEmitters list
+		for ( int i = 0; i < playingEmitters.size; ) {
+			if ( playingEmitters[i] == null ) {
+				Debug.LogError( "[AudioManager] ERROR: playingEmitters list had a null emitter! Something nuked a sound emitter!!!" );
+				playingEmitters.RemoveAtFast( i );
+				return;
+			}
+			if ( !playingEmitters[i].IsPlaying() ) {
+				// add to the free list and remove from the playing list
+				if ( verboseLogging ) {
+					if ( nextFreeEmitters.Contains( playingEmitters[i] ) ) {
+						Debug.LogError( "[AudioManager] ERROR: playing sound emitter already in the free emitters list!" );
+					}
+				}
+				playingEmitters[i].Stop();
+				nextFreeEmitters.Add( playingEmitters[i] );
+				playingEmitters.RemoveAtFast( i );
+				continue;
+			}
+			// debugging/profiling
+			if ( verboseLogging && showPlayingEmitterCount ) {
+				total++;
+				switch ( playingEmitters[i].priority ) {
+					case SoundPriority.VeryLow: veryLow++; break;
+					case SoundPriority.Low: low++; break;
+					case SoundPriority.Default: def++; break;
+					case SoundPriority.High: high++; break;
+					case SoundPriority.VeryHigh: veryHigh++; break;
+				}
+			}
+			i++;
+		}
+		if ( verboseLogging && showPlayingEmitterCount ) {
+			Debug.LogWarning( string.Format( "[AudioManager] Playing sounds: Total {0} | VeryLow {1} | Low {2} | Default {3} | High {4} | VeryHigh {5} | Free {6}", Fmt( total ), Fmt( veryLow ), Fmt( low ), Fmt( def ), Fmt( high ), Fmt( veryHigh ), FmtFree( nextFreeEmitters.Count ) ) );
+			showPlayingEmitterCount = false;
+		}
+	}
+
+	/*
+	-----------------------
+	Fmt()
+	-----------------------
+	*/
+	string Fmt( int count ) {
+		float t = count / (float)theAudioManager.maxSoundEmitters;
+		if ( t < 0.5f ) {
+			return "<color=green>" + count.ToString() + "</color>";
+		} else if ( t < 0.7 ) {
+			return "<color=yellow>" + count.ToString() + "</color>";
+		} else {
+			return "<color=red>" + count.ToString() + "</color>";
+		}
+	}
+
+	/*
+	-----------------------
+	FmtFree()
+	-----------------------
+	*/
+	string FmtFree( int count ) {
+		float t = count / (float)theAudioManager.maxSoundEmitters;
+		if ( t < 0.2f ) {
+			return "<color=red>" + count.ToString() + "</color>";
+		} else if ( t < 0.3 ) {
+			return "<color=yellow>" + count.ToString() + "</color>";
+		} else {
+			return "<color=green>" + count.ToString() + "</color>";
+		}
+	}
+
+	/*
+	-----------------------
+	OnPreSceneLoad()
+	-----------------------
+	*/
+	void OnPreSceneLoad() {
+		// move any attached sounds back to the sound emitters parent before changing levels so they don't get destroyed
+		Debug.Log( "[AudioManager] OnPreSceneLoad cleanup" );
+		for ( int i = 0; i < soundEmitters.Length; i++ ) {
+			soundEmitters[i].Stop();
+			soundEmitters[i].ResetParent( soundEmitterParent.transform );
+		}
+		// reset our emitter lists
+		ResetFreeEmitters();
+	}
+
+	/*
+	-----------------------
+	ResetFreeEmitters()
+	-----------------------
+	*/
+	void ResetFreeEmitters() {
+		nextFreeEmitters.Clear();
+		playingEmitters.Clear();
+		for ( int i = (int)EmitterChannel.Any; i < soundEmitters.Length; i++ ) {
+			nextFreeEmitters.Add( soundEmitters[i] );
+		}
+	}
+
+ 	/*
+ 	-----------------------
+ 	FadeOutSoundChannel()
+ 	utility function to fade out a playing sound channel
+ 	-----------------------
+ 	*/
+ 	static public void FadeOutSoundChannel( int channel, float delaySecs, float fadeTime ) {
+		theAudioManager.soundEmitters[channel].FadeOutDelayed( delaySecs, fadeTime );
+ 	}
+
+	/*
+	-----------------------
+	StopSound()
+	-----------------------
+	*/
+	static public bool StopSound( int idx, bool fadeOut = true, bool stopReserved = false ) {
+		if ( !stopReserved && ( idx == (int)EmitterChannel.Reserved ) ) {
+			return false;
+		}
+		if ( !fadeOut ) {
+			theAudioManager.soundEmitters[idx].Stop();
+		}
+		else {
+			theAudioManager.soundEmitters[idx].FadeOut( theAudioManager.soundFxFadeSecs );
+		}
+
+		return true;
+	}
+
+	/*
+	-----------------------
+	FadeInSound()
+	-----------------------
+	*/
+	public static void FadeInSound( int idx, float fadeTime, float volume ) {
+		theAudioManager.soundEmitters[idx].FadeIn( fadeTime, volume );
+	}
+
+	/*
+	-----------------------
+	FadeInSound()
+	-----------------------
+	*/
+	public static void FadeInSound( int idx, float fadeTime ) {
+		theAudioManager.soundEmitters[idx].FadeIn( fadeTime );
+	}
+
+	/*
+	-----------------------
+	FadeOutSound()
+	-----------------------
+	*/
+	public static void FadeOutSound( int idx, float fadeTime ) {
+		theAudioManager.soundEmitters[idx].FadeOut( fadeTime );
+	}
+
+	/*
+	-----------------------
+	StopAllSounds()
+	-----------------------
+	*/
+	public static void StopAllSounds( bool fadeOut, bool stopReserved = false ) {
+		for ( int i = 0; i < theAudioManager.soundEmitters.Length; i++ ) {
+			StopSound( i, fadeOut, stopReserved );
+		}
+	}
+	
+	/*
+	-----------------------
+	MuteAllSounds()
+	-----------------------
+	*/
+	public void MuteAllSounds( bool mute, bool muteReserved = false ) {
+		for ( int i = 0; i < soundEmitters.Length; i++ ) {
+			if ( !muteReserved && ( i == (int)EmitterChannel.Reserved ) ) {
+				continue;
+			}
+			soundEmitters[i].audioSource.mute = true;
+		}
+	}	
+
+	/*
+	-----------------------
+	UnMuteAllSounds()
+	-----------------------
+	*/
+	public void UnMuteAllSounds( bool unmute, bool unmuteReserved = false ) {
+		for ( int i = 0; i < soundEmitters.Length; i++ ) {
+			if ( !unmuteReserved && ( i == (int)EmitterChannel.Reserved ) ) {
+				continue;
+			}
+			if ( soundEmitters[i].audioSource.isPlaying ) {
+				soundEmitters[i].audioSource.mute = false;
+			}
+		}
+	}
+
+	/*
+	-----------------------
+	GetEmitterEndTime()
+	-----------------------
+	*/
+	static public float GetEmitterEndTime( int idx ) {
+		return theAudioManager.soundEmitters[idx].endPlayTime;
+	}
+
+	/*
+	-----------------------
+	SetEmitterTime()
+	-----------------------
+	*/
+	static public float SetEmitterTime( int idx, float time ) {
+		return theAudioManager.soundEmitters[idx].time = time;
+	}
+
+	/*
+	-----------------------
+	PlaySound()
+	-----------------------
+	*/
+	static public int PlaySound( AudioClip clip, float volume, EmitterChannel src = EmitterChannel.Any, float delay = 0.0f, float pitchVariance = 1.0f, bool loop = false ) {
+		if ( !SoundEnabled ) {
+			return -1;
+		}
+		return PlaySoundAt( ( staticListenerPosition != null ) ? staticListenerPosition.position : Vector3.zero, clip, volume, src, delay, pitchVariance, loop );
+	}
+
+	/*
+	-----------------------
+	FindFreeEmitter()
+	-----------------------
+	*/
+	static private int FindFreeEmitter( EmitterChannel src, SoundPriority priority ) {
+		// default to the reserved emitter
+		SoundEmitter next = theAudioManager.soundEmitters[0];
+		if ( src == EmitterChannel.Any ) {
+			// pull from the free emitter list if possible
+			if ( theAudioManager.nextFreeEmitters.size > 0 ) {
+				// return the first in the list
+				next = theAudioManager.nextFreeEmitters[0];
+				// remove it from the free list
+				theAudioManager.nextFreeEmitters.RemoveAtFast( 0 );
+			} else {
+				// no free emitters available so pull from the lowest priority sound
+				if ( priority == SoundPriority.VeryLow ) {
+					// skip low priority sounds
+					return -1;
+				} else {
+					// find a playing emitter that has a lower priority than what we're requesting
+					// TODO - we could first search for Very Low, then Low, etc ... TBD if it's worth the effort
+					next = theAudioManager.playingEmitters.Find( item => item != null && item.priority < priority );
+					if ( next == null ) {
+						// last chance to find a free emitter
+						if ( priority < SoundPriority.Default ) {
+							// skip sounds less than the default priority
+							if ( theAudioManager.verboseLogging ) {
+								Debug.LogWarning( "[AudioManager] skipping sound " + priority );
+							}
+							return -1;
+						} else {
+							// grab a default priority emitter so that we don't cannabalize a high priority sound
+							next = theAudioManager.playingEmitters.Find( item => item != null && item.priority <= SoundPriority.Default ); ;
+						}
+					}
+					if ( next != null ) {
+						if ( theAudioManager.verboseLogging ) {
+							Debug.LogWarning( "[AudioManager] cannabalizing " + next.originalIdx + " Time: " + Time.time );
+						}
+						// remove it from the playing list
+						next.Stop();
+						theAudioManager.playingEmitters.RemoveFast( next );
+					}
+				}
+			}
+		}
+		if ( next == null ) {
+			Debug.LogError( "[AudioManager] ERROR - absolutely couldn't find a free emitter! Priority = " + priority + " TOO MANY PlaySound* calls!" );
+			showPlayingEmitterCount = true;
+			return -1;
+		}
+		return next.originalIdx;
+	}
+
+	/*
+	-----------------------
+	PlaySound()
+	-----------------------
+	*/
+	static public int PlaySound( SoundFX soundFX, EmitterChannel src = EmitterChannel.Any, float delay = 0.0f ) {
+		if ( !SoundEnabled ) {
+			return -1;
+		}
+		return PlaySoundAt( ( staticListenerPosition != null ) ? staticListenerPosition.position : Vector3.zero, soundFX, src, delay );
+	}
+
+	/*
+	-----------------------
+	PlaySoundAt()
+	-----------------------
+	*/
+	static public int PlaySoundAt( Vector3 position, SoundFX soundFX, EmitterChannel src = EmitterChannel.Any, float delay = 0.0f, float volumeOverride = 1.0f, float pitchMultiplier = 1.0f ) {
+		if ( !SoundEnabled ) {
+			return -1;
+		}
+
+		AudioClip clip = soundFX.GetClip();
+		if ( clip == null ) {
+			return -1;
+		}
+
+		// check the distance from the local player and ignore sounds out of range
+		if ( staticListenerPosition != null ) {
+			float distFromListener = ( staticListenerPosition.position - position ).sqrMagnitude;
+			if ( distFromListener > theAudioManager.audioMaxFallOffDistanceSqr ) {
+				return -1;
+			}
+			if ( distFromListener > soundFX.MaxFalloffDistSquared ) {
+				return -1;
+			}
+		}
+
+		// check max playing sounds
+		if ( soundFX.ReachedGroupPlayLimit() ) {
+			if ( theAudioManager.verboseLogging ) {
+				Debug.Log( "[AudioManager] PlaySoundAt() with " + soundFX.name + " skipped due to group play limit" );
+			}
+			return -1;
+		}
+
+		int idx = FindFreeEmitter( src, soundFX.priority );
+		if ( idx == -1 ) {
+			// no free emitters	- should only happen on very low priority sounds
+			return -1;
+		}
+		SoundEmitter emitter = theAudioManager.soundEmitters[idx];
+
+		// make sure to detach the emitter from a previous parent
+		emitter.ResetParent( soundEmitterParent.transform );
+		emitter.gameObject.SetActive( true );
+
+		// set up the sound emitter
+		AudioSource audioSource = emitter.audioSource;
+		ONSPAudioSource osp = emitter.osp;
+
+		audioSource.enabled = true;
+		audioSource.volume = Mathf.Clamp01( Mathf.Clamp01( theAudioManager.volumeSoundFX * soundFX.volume ) * volumeOverride * soundFX.GroupVolumeOverride );
+		audioSource.pitch = soundFX.GetPitch() * pitchMultiplier;
+		audioSource.time = 0.0f;
+		audioSource.spatialBlend = 1.0f;
+		audioSource.rolloffMode = soundFX.falloffCurve;
+		if ( soundFX.falloffCurve == AudioRolloffMode.Custom ) {
+			audioSource.SetCustomCurve( AudioSourceCurveType.CustomRolloff, soundFX.volumeFalloffCurve );
+		}
+		audioSource.SetCustomCurve( AudioSourceCurveType.ReverbZoneMix, soundFX.reverbZoneMix );
+		audioSource.dopplerLevel = 0;
+		audioSource.clip = clip;
+		audioSource.spread = soundFX.spread;
+		audioSource.loop = soundFX.looping;
+		audioSource.mute = false;
+		audioSource.minDistance = soundFX.falloffDistance.x;
+		audioSource.maxDistance = soundFX.falloffDistance.y;
+		audioSource.outputAudioMixerGroup = soundFX.GetMixerGroup( AudioManager.EmitterGroup );
+		// set the play time so we can check when sounds are done
+		emitter.endPlayTime = Time.time + clip.length + delay;
+		// cache the default volume for fading
+		emitter.defaultVolume = audioSource.volume;
+		// sound priority
+		emitter.priority = soundFX.priority;
+		// reset this
+		emitter.onFinished = null;
+		// update the sound group limits
+		emitter.SetPlayingSoundGroup( soundFX.Group );
+		// add to the playing list
+		if ( src == EmitterChannel.Any ) {
+			theAudioManager.playingEmitters.AddUnique( emitter );
+		}
+
+		// OSP properties
+		if ( osp != null ) {
+            osp.EnableSpatialization = soundFX.ospProps.enableSpatialization;
+			osp.EnableRfl = theAudioManager.enableSpatializedFastOverride || soundFX.ospProps.useFastOverride ? true : false;
+			osp.Gain = soundFX.ospProps.gain;
+            osp.UseInvSqr = soundFX.ospProps.enableInvSquare;
+			osp.Near = soundFX.ospProps.invSquareFalloff.x;
+			osp.Far  = soundFX.ospProps.invSquareFalloff.y;
+            audioSource.spatialBlend = (soundFX.ospProps.enableSpatialization) ? 1.0f : 0.8f;
+            
+			// make sure to set the properties in the audio source before playing
+            osp.SetParameters(ref audioSource);
+		}
+
+		audioSource.transform.position = position;
+
+		if ( theAudioManager.verboseLogging ) {
+			Debug.Log( "[AudioManager] PlaySoundAt() channel = " + idx + " soundFX = " + soundFX.name + " volume = " + emitter.volume + " Delay = " + delay + " time = " + Time.time + "\n" );
+		}
+		
+		// play the sound
+		if ( delay > 0f ) {
+			audioSource.PlayDelayed( delay );
+		} else {
+			audioSource.Play();
+		}
+		
+		return idx;
+	}	
+
+	/*
+	-----------------------
+	PlayRandomSoundAt()
+	-----------------------
+	*/
+	static public int PlayRandomSoundAt( Vector3 position, AudioClip[] clips, float volume, EmitterChannel src = EmitterChannel.Any, float delay = 0.0f, float pitch = 1.0f, bool loop = false ) {
+		if ( ( clips == null ) || ( clips.Length == 0 ) ) {
+			return -1;
+		}
+		int idx = Random.Range( 0, clips.Length );
+		return PlaySoundAt( position, clips[idx], volume, src, delay, pitch, loop );
+	}
+	
+	/*
+	-----------------------
+	PlaySoundAt()
+	-----------------------
+	*/
+	static public int PlaySoundAt( Vector3 position, AudioClip clip, float volume = 1.0f, EmitterChannel src = EmitterChannel.Any, float delay = 0.0f, float pitch = 1.0f, bool loop = false ) {
+		if ( !SoundEnabled ) {
+			return -1;
+		}
+		
+		if ( clip == null ) {
+			return -1;
+		}
+
+		// check the distance from the local player and ignore sounds out of range
+		if ( staticListenerPosition != null ) {
+			if ( ( staticListenerPosition.position - position ).sqrMagnitude > theAudioManager.audioMaxFallOffDistanceSqr ) {
+				// no chance of being heard
+				return -1;
+			}
+		}
+
+		int idx = FindFreeEmitter( src, 0 );
+		if ( idx == -1 ) {
+			// no free emitters	- should only happen on very low priority sounds
+			return -1;
+		}
+		SoundEmitter emitter = theAudioManager.soundEmitters[idx];
+
+		// make sure to detach the emitter from a previous parent
+		emitter.ResetParent( soundEmitterParent.transform );
+		emitter.gameObject.SetActive( true );
+
+		// set up the sound emitter
+		AudioSource audioSource = emitter.audioSource;
+		ONSPAudioSource osp = emitter.osp;
+
+		audioSource.enabled = true;
+		audioSource.volume = Mathf.Clamp01( theAudioManager.volumeSoundFX * volume );
+		audioSource.pitch = pitch;
+		audioSource.spatialBlend = 0.8f;
+		audioSource.rolloffMode = AudioRolloffMode.Linear;
+		audioSource.SetCustomCurve( AudioSourceCurveType.ReverbZoneMix, defaultReverbZoneMix );
+		audioSource.dopplerLevel = 0.0f;
+		audioSource.clip = clip;
+		audioSource.spread = 0.0f;
+		audioSource.loop = loop;
+		audioSource.mute = false;
+		audioSource.minDistance = theAudioManager.audioMinFallOffDistance;
+		audioSource.maxDistance = theAudioManager.audioMaxFallOffDistance;
+		audioSource.outputAudioMixerGroup = AudioManager.EmitterGroup;
+		// set the play time so we can check when sounds are done
+		emitter.endPlayTime = Time.time + clip.length + delay;
+		// cache the default volume for fading
+		emitter.defaultVolume = audioSource.volume;
+		// default priority
+		emitter.priority = 0;
+		// reset this
+		emitter.onFinished = null;
+		// update the sound group limits
+		emitter.SetPlayingSoundGroup( null );
+ 		// add to the playing list
+		if ( src == EmitterChannel.Any ) {
+			theAudioManager.playingEmitters.AddUnique( emitter );
+		}
+
+		// disable spatialization (by default for regular AudioClips)
+		if ( osp != null ) {
+			osp.EnableSpatialization = false;
+		}
+
+		audioSource.transform.position = position;
+
+		if ( theAudioManager.verboseLogging ) {
+			Debug.Log( "[AudioManager] PlaySoundAt() channel = " + idx + " clip = " + clip.name + " volume = " + emitter.volume + " Delay = " + delay + " time = " + Time.time + "\n" );
+		}
+
+		// play the sound
+		if ( delay > 0f ) {
+			audioSource.PlayDelayed( delay );
+		} else {
+			audioSource.Play();
+		}
+		
+		return idx;
+	}
+
+	/*
+	-----------------------
+	SetOnFinished()
+	-----------------------
+	*/
+	public static void SetOnFinished( int emitterIdx, System.Action onFinished ) {
+		if ( emitterIdx >= 0 && emitterIdx < theAudioManager.maxSoundEmitters ) {
+			theAudioManager.soundEmitters[emitterIdx].SetOnFinished( onFinished );
+		}
+	}
+
+	/*
+	-----------------------
+	SetOnFinished()
+	-----------------------
+	*/
+	public static void SetOnFinished( int emitterIdx, System.Action<object> onFinished, object obj ) {
+		if ( emitterIdx >= 0 && emitterIdx < theAudioManager.maxSoundEmitters ) {
+			theAudioManager.soundEmitters[emitterIdx].SetOnFinished( onFinished, obj );
+		}
+	}
+
+	/*
+	-----------------------
+	AttachSoundToParent()
+	-----------------------
+	*/
+	public static void AttachSoundToParent( int idx, Transform parent ) {
+		if ( theAudioManager.verboseLogging ) {
+			string parentName = parent.name;
+			if ( parent.parent != null ) {
+				parentName = parent.parent.name + "/" + parentName;
+			}
+			Debug.Log( "[AudioManager] ATTACHING INDEX " + idx + " to " + parentName );
+		}
+		theAudioManager.soundEmitters[idx].ParentTo( parent );
+	}
+
+	/*
+	-----------------------
+	DetachSoundFromParent()
+	-----------------------
+	*/
+	public static void DetachSoundFromParent( int idx )	{
+		if ( theAudioManager.verboseLogging ) {
+			Debug.Log( "[AudioManager] DETACHING INDEX " + idx );
+		}
+		theAudioManager.soundEmitters[idx].DetachFromParent();
+	}
+
+	/*
+	-----------------------
+	DetachSoundsFromParent()
+	-----------------------
+	*/
+	public static void DetachSoundsFromParent( SoundEmitter[] emitters, bool stopSounds = true ) {
+		if ( emitters == null ) {
+			return;
+		}
+		foreach ( SoundEmitter emitter in emitters ) {
+			if ( emitter.defaultParent != null ) {
+				if ( stopSounds ) {
+					emitter.Stop();
+				}
+				emitter.DetachFromParent();
+				// make sure it's active
+				emitter.gameObject.SetActive( true );
+			} else {
+				if ( stopSounds ) {
+					emitter.Stop();
+				}
+			}
+		}
+	}
+
+	/*
+	-----------------------
+	SetEmitterMixerGroup()
+	-----------------------
+	*/
+	public static void SetEmitterMixerGroup( int idx, AudioMixerGroup mixerGroup ) {
+		if ( ( theAudioManager != null ) && ( idx > -1 ) ) {
+			theAudioManager.soundEmitters[idx].SetAudioMixer( mixerGroup );
+		}	
+	}
+
+	/*
+	-----------------------
+	GetActiveSnapshot()
+	-----------------------
+	*/
+	public static MixerSnapshot GetActiveSnapshot() {
+		return ( theAudioManager != null ) ? theAudioManager.currentSnapshot : null;
+	}
+
+	/*
+	-----------------------
+	SetCurrentSnapshot()
+	-----------------------
+	*/
+	public static void SetCurrentSnapshot( MixerSnapshot mixerSnapshot ) {
+#if UNITY_EDITOR
+		if ( mixerSnapshot == null || mixerSnapshot.snapshot == null ) {
+			Debug.LogError( "[AudioManager] ERROR setting empty mixer snapshot!" );
+		} else {
+			Debug.Log( "[AudioManager] Setting audio mixer snapshot: " + ( ( mixerSnapshot != null && mixerSnapshot.snapshot != null ) ? mixerSnapshot.snapshot.name : "None" ) + " Time: " + Time.time );
+		}
+#endif
+		if ( theAudioManager != null ) {
+			if ( ( mixerSnapshot != null ) && ( mixerSnapshot.snapshot != null ) ) {
+				mixerSnapshot.snapshot.TransitionTo( mixerSnapshot.transitionTime );
+			} else {
+				mixerSnapshot = null;
+			}
+			theAudioManager.currentSnapshot = mixerSnapshot;
+		}
+	}
+
+	/*
+	-----------------------
+	BlendWithCurrentSnapshot()
+	-----------------------
+	*/
+	public static void BlendWithCurrentSnapshot( MixerSnapshot blendSnapshot, float weight, float blendTime = 0.0f ) {
+		if ( theAudioManager != null ) {
+			if ( theAudioManager.audioMixer == null ) {
+				Debug.LogWarning( "[AudioManager] can't call BlendWithCurrentSnapshot if the audio mixer is not set!" );	
+				return;
+			}
+			if ( blendTime == 0.0f ) {
+				blendTime = Time.deltaTime;
+			}
+			if ( ( theAudioManager.currentSnapshot != null ) && (theAudioManager.currentSnapshot.snapshot != null ) ) {
+				if ( ( blendSnapshot != null ) && ( blendSnapshot.snapshot != null ) ) {
+					weight = Mathf.Clamp01( weight );
+					if ( weight == 0.0f ) {
+						// revert to the default snapshot
+						theAudioManager.currentSnapshot.snapshot.TransitionTo( blendTime );
+					} else {
+						AudioMixerSnapshot[] snapshots = new AudioMixerSnapshot[] { theAudioManager.currentSnapshot.snapshot, blendSnapshot.snapshot };
+						float[] weights = new float[] { 1.0f - weight, weight };
+						theAudioManager.audioMixer.TransitionToSnapshots( snapshots, weights, blendTime );
+					}
+				}
+			}
+		}
+	}
+
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/AudioManager_Sound.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 41cb0f893e9a44e83b09a66c55bd7856
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/Editor.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 02213405caaf04aeea7876974c06fa5a
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/Editor/AudioImportPostProcessor.cs

@@ -0,0 +1,46 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace OVR
+{
+
+/*
+-----------------------
+AudioImportPostProcessor()
+-----------------------
+*/
+public class AudioImportPostProcessor : AssetPostprocessor {
+
+	static void OnPostprocessAllAssets( string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths ) {
+		AudioManager audioManager = AudioManager.Instance;
+		if ( audioManager != null ) {
+      // find the asset path to the loaded audio manager prefab
+#if UNITY_2018_2_OR_NEWER
+      Object prefabObject = PrefabUtility.GetCorrespondingObjectFromSource(audioManager);
+#else
+      Object prefabObject = PrefabUtility.GetPrefabParent( audioManager );
+#endif
+      if ( prefabObject != null ) {
+				string path = AssetDatabase.GetAssetPath( prefabObject );
+				// check to see if the AudioManager prefab has been reimported.
+				// if so, rebuild everything
+				foreach ( string asset in importedAssets ) {
+					if ( asset.ToLower() == path.ToLower() ) {
+						// in the event the audio manager is selected, deselect it first before reloading
+						Debug.Log( "[AudioManager] AudioManager prefab reloaded: " + path );
+						Selection.objects = new Object[0] { };
+						// unfortunately even saving the audio manager prefab will trigger this action
+						//string msg = "The Audio Manager was reloaded.  If you are going to be making modifications to the Audio Manager, ";
+						//msg += "please verify you have the latest version before proceeding.  If in doubt, restart Unity before making modifications.";
+						//EditorUtility.DisplayDialog( "Audio Manager Prefab Reloaded", msg, "OK" );
+						// do the actual reload
+						AudioManager.OnPrefabReimported();
+						break;
+					}
+				}
+			}
+		}
+	}
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/Editor/AudioImportPostProcessor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 48902580b26e3554d992bad48087eee5
+timeCreated: 1471010515
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Audio/Editor/AudioManagerInspector.cs

@@ -0,0 +1,631 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace OVR
+{
+
+/*
+-----------------------
+ 
+ AudioManagerInspector
+
+-----------------------
+*/
+[CustomEditor(typeof(AudioManager))]
+public class AudioManagerInspector : Editor {
+
+	private AudioManager 	audioManager = null;
+	private string			dragDropIdentifier = "MoveSoundFX";
+	private GUIStyle        customDividerStyle = null;
+
+	/*
+	-----------------------
+	OnInspectorGUI()
+	-----------------------
+	*/
+	public override void OnInspectorGUI() {
+
+		audioManager = target as AudioManager;
+
+		Event e = Event.current;
+
+		// draw the default properties
+		DrawDefaultProperties();
+
+		// draw the categories section
+		DrawCategories( e );
+
+		serializedObject.Update();
+
+		// draw the sound effects for the selected category
+		DrawSoundEffects( e );
+
+		serializedObject.ApplyModifiedProperties();
+
+		CreateStyles();
+	}
+
+	/*
+	-----------------------
+	MarkDirty()
+	-----------------------
+	*/
+	void MarkDirty() {
+		serializedObject.SetIsDifferentCacheDirty();
+		EditorUtility.SetDirty( audioManager );
+	}
+
+	static private int selectedGroup = 0;
+	private int nextGroup = -1;
+	private int editGroup = -1;
+	private FastList<SoundGroup> 	soundGroups = new FastList<SoundGroup>();
+	private FastList<ItemRect> 		groups = new FastList<ItemRect>();
+	private Rect 					dropArea = new Rect();
+	private bool                    addSound = false;
+	private int                     deleteSoundIdx = -1;
+	private int                     dupeSoundIdx = -1;
+	private bool					sortSounds = false;
+	private bool					moveQueued = false;
+	private int						origGroup = -1;
+	private int						origIndex = -1;
+	private int						moveToGroup = -1;
+
+	/*
+	-----------------------
+	DrawDefaultProperties()
+	-----------------------
+	*/
+	void DrawDefaultProperties() {
+
+		BeginContents();
+		if ( DrawHeader( "Default Properties", true ) ) {
+			EditorGUILayout.BeginVertical( GUI.skin.box );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "makePersistent" ), new GUIContent( "Don't Destroy on Load" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "enableSpatializedAudio" ), new GUIContent( "Enable Spatialized Audio" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "enableSpatializedFastOverride" ), new GUIContent( "Force Disable Reflections" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "audioMixer" ), new GUIContent( "Master Audio Mixer" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "defaultMixerGroup" ), new GUIContent( "Pooled Emitter Mixer Group" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "reservedMixerGroup" ), new GUIContent( "Reserved Emitter Mixer Group" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "voiceChatMixerGroup" ), new GUIContent( "Voice Chat Mixer Group" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "verboseLogging" ), new GUIContent( "Verbose Logging" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "maxSoundEmitters" ), new GUIContent( "Max Sound Emitters" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "volumeSoundFX" ), new GUIContent( "Default Volume" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "soundFxFadeSecs" ), new GUIContent( "Sound FX Fade Secs" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "audioMinFallOffDistance" ), new GUIContent( "Minimum Falloff Distance" ) );
+			EditorGUILayout.PropertyField( serializedObject.FindProperty( "audioMaxFallOffDistance" ), new GUIContent( "Maximum Falloff Distance" ) );
+			EditorGUILayout.EndVertical();
+			serializedObject.ApplyModifiedProperties();
+		}
+		EndContents();
+	}
+
+	/*
+	-----------------------
+	DrawSoundGroupProperties()
+	-----------------------
+	*/
+	void DrawSoundGroupProperties() {
+		if ( selectedGroup == -1 ) {
+			return;
+		}
+
+		SerializedProperty soundGroupsArray = serializedObject.FindProperty( "soundGroupings" );
+		if ( selectedGroup >= soundGroupsArray.arraySize ) {
+			return;
+		}
+		SerializedProperty soundGroup = soundGroupsArray.GetArrayElementAtIndex( selectedGroup );
+		string soundGroupName = soundGroup.FindPropertyRelative( "name" ).stringValue;
+		if ( DrawHeader( string.Format( "{0} Properties", soundGroupName ), true ) ) {
+			EditorGUILayout.BeginVertical( GUI.skin.box );
+			EditorGUILayout.PropertyField( soundGroup.FindPropertyRelative( "mixerGroup" ), new GUIContent( "Override Mixer Group", "Leave empty to use the Audio Manager's default mixer group" ) );
+			if ( !Application.isPlaying ) {
+				EditorGUILayout.PropertyField( soundGroup.FindPropertyRelative( "maxPlayingSounds" ), new GUIContent( "Max Playing Sounds Limit", "Max playing sounds for this sound group, 0 = no limit" ) );
+			} else {
+				EditorGUILayout.BeginHorizontal();
+				EditorGUILayout.PropertyField( soundGroup.FindPropertyRelative( "maxPlayingSounds" ), new GUIContent( "Max Playing Sounds Limit", "Max playing sounds for this sound group, 0 = no limit" ) );
+				// cast to the actual object
+				int playingSounds = soundGroup.FindPropertyRelative( "playingSoundCount" ).intValue;
+				EditorGUILayout.LabelField( string.Format( "Playing: {0}", playingSounds ), GUILayout.Width( 80.0f ) );
+				EditorGUILayout.EndHorizontal();
+			}
+			EditorGUILayout.PropertyField( soundGroup.FindPropertyRelative( "preloadAudio" ), new GUIContent( "Preload Audio Clips", "Default = No special preloading, Preload = Audio clips are set to 'Preload', Manual Preload = Audio clips are set to not 'Preload'" ) );
+			EditorGUILayout.PropertyField( soundGroup.FindPropertyRelative( "volumeOverride" ), new GUIContent( "Volume Override", "All sounds played in this group will have volume scaled by this amount" ) );
+			if ( soundGroup.FindPropertyRelative( "volumeOverride" ).floatValue == 0.0f ) {
+				EditorGUILayout.HelpBox( "With a volumeOverride of 0.0, these sounds will not play!", MessageType.Warning );
+			}
+			EditorGUILayout.EndVertical();
+			serializedObject.ApplyModifiedProperties();
+		}
+	}
+
+	/*
+	-----------------------
+	DrawCategories()
+	-----------------------
+	*/
+	void DrawCategories( Event e ) {
+
+		// do any housework before we start drawing
+		if ( moveQueued ) {
+			// make a temp copy
+			List<SoundFX> origSoundList = new List<SoundFX>( audioManager.soundGroupings[origGroup].soundList );
+			SoundFX temp = origSoundList[origIndex];
+			List<SoundFX> moveToSoundList = new List<SoundFX>( audioManager.soundGroupings[moveToGroup].soundList );
+			// add it to the move to group
+			moveToSoundList.Add( temp );
+			audioManager.soundGroupings[moveToGroup].soundList = moveToSoundList.ToArray();
+			// and finally, remove it from the original group
+			origSoundList.RemoveAt( origIndex );
+			audioManager.soundGroupings[origGroup].soundList = origSoundList.ToArray();
+			Debug.Log( "> Moved '" + temp.name + "' from " + "'" + audioManager.soundGroupings[origGroup].name + "' to '" + audioManager.soundGroupings[moveToGroup].name );
+			MarkDirty();
+			moveQueued = false;
+		}
+		// switch to the next group
+		if ( nextGroup > -1 ) {
+			selectedGroup = nextGroup;
+			nextGroup = -1;
+		}
+		// add a sound
+		if ( addSound ) {
+			List<SoundFX> soundList = new List<SoundFX>( audioManager.soundGroupings[selectedGroup].soundList );
+			SoundFX soundFX = new SoundFX();
+			soundFX.name = audioManager.soundGroupings[selectedGroup].name.ToLower() + "_new_unnamed_sound_fx";
+			soundList.Add( soundFX );
+			audioManager.soundGroupings[selectedGroup].soundList = soundList.ToArray();
+			MarkDirty();
+			addSound = false;
+		}
+		// sort the sounds
+		if ( sortSounds ) {
+			List<SoundFX> soundList = new List<SoundFX>( audioManager.soundGroupings[selectedGroup].soundList );
+			soundList.Sort( delegate ( SoundFX sfx1, SoundFX sfx2 ) { return string.Compare( sfx1.name, sfx2.name ); } );
+			audioManager.soundGroupings[selectedGroup].soundList = soundList.ToArray();
+			MarkDirty();
+			sortSounds = false;
+		}
+		// delete a sound
+		if ( deleteSoundIdx > -1 ) {
+			List<SoundFX> soundList = new List<SoundFX>( audioManager.soundGroupings[selectedGroup].soundList );
+			soundList.RemoveAt( deleteSoundIdx );
+			audioManager.soundGroupings[selectedGroup].soundList = soundList.ToArray();
+			MarkDirty();
+			deleteSoundIdx = -1;
+		}
+		// duplicate a sound
+		if ( dupeSoundIdx > -1 ) {
+			List<SoundFX> soundList = new List<SoundFX>( audioManager.soundGroupings[selectedGroup].soundList );
+			SoundFX origSoundFX = soundList[dupeSoundIdx];
+			// clone this soundFX
+			string json = JsonUtility.ToJson( origSoundFX );
+			SoundFX soundFX = JsonUtility.FromJson<SoundFX>( json );
+			soundFX.name += "_duplicated";
+			soundList.Insert( dupeSoundIdx + 1, soundFX );
+			audioManager.soundGroupings[selectedGroup].soundList = soundList.ToArray();
+			MarkDirty();
+			dupeSoundIdx = -1;
+		}
+
+		if ( e.type == EventType.Repaint ) {
+			groups.Clear();
+		}
+
+		GUILayout.Space( 6f );
+		
+		Color defaultColor = GUI.contentColor;
+		BeginContents();
+
+		if ( DrawHeader( "Sound FX Groups", true ) ) {
+			EditorGUILayout.BeginVertical( GUI.skin.box );
+			soundGroups.Clear();
+			for ( int i = 0; i < audioManager.soundGroupings.Length; i++ ) {
+				soundGroups.Add( audioManager.soundGroupings[i] );
+			}
+			for ( int i = 0; i < soundGroups.size; i++ ) {
+				EditorGUILayout.BeginHorizontal();
+				{
+					if ( i == selectedGroup ) {
+						GUI.contentColor = ( i == editGroup ) ? Color.white : Color.yellow;
+					} else {
+						GUI.contentColor = defaultColor;
+					}
+					if ( ( e.type == EventType.KeyDown ) && ( ( e.keyCode == KeyCode.Return ) || ( e.keyCode == KeyCode.KeypadEnter ) ) ) {
+						// toggle editing
+						if ( editGroup >= 0 ) {
+							editGroup = -1;
+						}
+						Event.current.Use();
+					}
+					if ( i == editGroup ) {
+						soundGroups[i].name = GUILayout.TextField( soundGroups[i].name, GUILayout.MinWidth( Screen.width - 80f ) );
+					} else {
+						GUILayout.Label( soundGroups[i].name, ( i == selectedGroup ) ? EditorStyles.whiteLabel : EditorStyles.label, GUILayout.ExpandWidth( true ) );
+					}
+					GUILayout.FlexibleSpace();
+					if ( GUILayout.Button( GUIContent.none, "OL Minus", GUILayout.Width(17f) ) ) {	// minus button
+						if ( EditorUtility.DisplayDialog( "Delete '" + soundGroups[i].name + "'", "Are you sure you want to delete the selected sound group?", "Continue", "Cancel" ) ) {
+							soundGroups.RemoveAt( i );
+							MarkDirty();
+						}
+					}
+				}
+				EditorGUILayout.EndHorizontal();
+				// build a list of items
+				Rect lastRect = GUILayoutUtility.GetLastRect();
+				if ( e.type == EventType.Repaint ) {
+					groups.Add ( new ItemRect( i, lastRect, null ) );
+				}
+				if ( ( e.type == EventType.MouseDown ) && lastRect.Contains( e.mousePosition ) ) {
+					if ( ( i != selectedGroup ) || ( e.clickCount == 2 ) ) {
+						nextGroup = i;
+						if ( e.clickCount == 2 ) {
+							editGroup = i;
+						} else if ( editGroup != nextGroup ) {
+							editGroup = -1;
+						}
+						Repaint();
+					}
+				}
+			}
+			// add the final plus button
+			EditorGUILayout.BeginHorizontal();
+			GUILayout.FlexibleSpace();
+			if ( GUILayout.Button( GUIContent.none, "OL Plus", GUILayout.Width(17f) ) ) {	// plus button
+				soundGroups.Add( new SoundGroup( "unnamed sound group" ) );
+				selectedGroup = editGroup = soundGroups.size - 1;
+				MarkDirty();
+			}
+			EditorGUILayout.EndHorizontal();
+			EditorGUILayout.EndVertical();
+
+			// reset the color
+			GUI.contentColor = defaultColor;
+
+			// the sort and import buttons
+			EditorGUILayout.BeginHorizontal();
+			GUILayout.FlexibleSpace();
+			if ( GUILayout.Button( "Sort", GUILayout.Width( 70f ) ) ) {
+				soundGroups.Sort( delegate( SoundGroup sg1, SoundGroup sg2 ) { return string.Compare( sg1.name, sg2.name ); } );
+				MarkDirty();
+			}
+			EditorGUILayout.EndHorizontal();
+
+			// draw a rect around the selected item
+			if ( ( selectedGroup >= 0 ) && ( selectedGroup < groups.size ) ) {
+				EditorGUI.DrawRect( groups[selectedGroup].rect, new Color( 1f, 1f, 1f, 0.06f ) );      
+			}
+
+			// finally move the sound groups back into the audio manager
+			if ( soundGroups.size > 0 ) {
+				audioManager.soundGroupings = soundGroups.ToArray();
+			}
+
+			// calculate the drop area rect
+			if ( ( e.type == EventType.Repaint ) && ( groups.size > 0 ) ) {
+				dropArea.x = groups[0].rect.x;
+				dropArea.y = groups[0].rect.y;
+				dropArea.width = groups[0].rect.width;
+				dropArea.height = ( groups[groups.size-1].rect.y - groups[0].rect.y ) + groups[groups.size-1].rect.height;
+			}
+		}
+		// draw the sound group properties now
+		DrawSoundGroupProperties();
+
+		EndContents();
+
+		EditorGUILayout.HelpBox("Create and delete sound groups by clicking + and - respectively.  Double click to rename sound groups.  Drag and drop sounds from below to the groups above to move them.", MessageType.Info);
+
+	}
+
+	public class CustomDragData{
+		public int originalGroupIndex;
+		public int originalIndex;
+		public SerializedProperty originalProperty;
+	}
+
+	public class ItemRect {
+		public ItemRect( int index, Rect rect, SerializedProperty prop ) {
+			this.index = index;
+			this.rect = rect;
+			this.prop = prop;
+		}																	   
+		public int					index;
+		public Rect 				rect;
+		public SerializedProperty	prop;
+	}
+
+	private FastList<ItemRect> 	items = new FastList<ItemRect>();
+
+	/*
+	-----------------------
+	CreateStyles()
+	-----------------------
+	*/
+	void CreateStyles() {
+		if ( customDividerStyle == null ) {
+			customDividerStyle = new GUIStyle( EditorStyles.label );
+			customDividerStyle.normal.background = MakeTex( 4, 4, new Color( 0.5f, 0.5f, 0.5f, 0.25f ) );
+			customDividerStyle.margin.right -= 16;
+		}
+	}
+
+	/*
+	-----------------------
+	MakeTex()
+	-----------------------
+	*/
+	private Texture2D MakeTex( int width, int height, Color col ) {
+		Color[] pix = new Color[width*height];
+
+		for ( int i = 0; i < pix.Length; i++ )
+			pix[i] = col;
+
+		Texture2D result = new Texture2D(width, height);
+		result.SetPixels( pix );
+		result.Apply();
+
+		return result;
+	}
+
+	/*
+	-----------------------
+	DrawSoundEffects()
+	-----------------------
+	*/
+	void DrawSoundEffects( Event e ) {
+		if ( ( selectedGroup < 0 ) || ( audioManager.soundGroupings.Length == 0 ) || ( selectedGroup >= audioManager.soundGroupings.Length ) ) {
+			return;
+		}
+
+		if ( e.type == EventType.Repaint ) {
+			items.Clear();
+		} else {
+			CheckStartDrag( e );
+		}
+
+		BeginContents();
+		if ( DrawHeader( "Sound Effects", true ) ) {
+			GUILayout.Space(3f);
+			GUILayout.BeginVertical( GUI.skin.box );
+
+			SerializedProperty soundGroupsArray = serializedObject.FindProperty( "soundGroupings" );
+			SerializedProperty soundGroup = soundGroupsArray.GetArrayElementAtIndex( selectedGroup );
+			SerializedProperty soundList = soundGroup.FindPropertyRelative( "soundList" );
+
+			CreateStyles();
+
+			Rect prevRect = new Rect();
+			if ( soundList.arraySize > 0 ) {
+				// show all the sounds
+				for ( int i = 0; i < soundList.arraySize; i++ ) {
+					EditorGUI.indentLevel = 1;
+					SerializedProperty soundFX = soundList.GetArrayElementAtIndex( i );
+					SerializedProperty visToggle = soundFX.FindPropertyRelative( "visibilityToggle"  );
+					EditorGUILayout.BeginHorizontal( customDividerStyle );
+					{
+						string soundFXName = soundFX.FindPropertyRelative( "name" ).stringValue;
+						// save the visibility state
+						visToggle.boolValue = EditorGUILayout.Foldout( visToggle.boolValue, soundFXName );
+
+						// play button
+						if ( GUILayout.Button( "\u25BA", GUILayout.Width( 17f ), GUILayout.Height( 16f ) ) ) {
+							if ( AudioManager.IsSoundPlaying( soundFXName ) ) {
+								AudioManager.StopSound( soundFXName );
+							} else {
+								AudioManager.PlaySound( soundFXName );
+							}
+						}
+					}
+					EditorGUILayout.EndHorizontal();
+					if ( visToggle.boolValue ) {
+						EditorGUILayout.PropertyField( soundFX, true );
+						EditorGUILayout.BeginHorizontal();
+						GUILayout.FlexibleSpace();
+						if ( GUILayout.Button( "Delete FX", GUILayout.Width( Screen.width / 3.0f ) ) ) {
+							if ( EditorUtility.DisplayDialog( "Delete " + soundFX.displayName, "Are you sure?", "Yes", "No!" ) ) {
+								deleteSoundIdx = i;
+							}
+						}
+						if ( GUILayout.Button( "Duplicate FX", GUILayout.Width( Screen.width / 3.0f ) ) ) {
+							dupeSoundIdx = i;
+						}
+						GUILayout.FlexibleSpace();
+						EditorGUILayout.EndHorizontal();
+						GUILayout.Space( 10.0f );
+					}
+					if ( e.type == EventType.Repaint ) {
+						// GetLastRect() is now returning the last rect drawn in the property drawer,
+						// not the rect used for the entire SoundFX
+						Rect curRect = prevRect;
+						curRect.y = prevRect.y + EditorGUIUtility.singleLineHeight;
+						Rect lastRect = GUILayoutUtility.GetLastRect();
+						curRect.height = ( lastRect.y + lastRect.height ) - curRect.y;
+						curRect.width = Screen.width;
+						items.Add( new ItemRect( i, curRect, soundFX ) );
+					}
+					prevRect = GUILayoutUtility.GetLastRect();
+				}
+			} else {
+				EditorGUILayout.LabelField( " " );
+			}
+			GUILayout.EndVertical();
+			GUILayout.Space(3f);
+			EditorGUILayout.BeginHorizontal();
+			GUILayout.FlexibleSpace();
+			if ( GUILayout.Button( "Add FX", GUILayout.Width( 70f ) ) ) {
+				//soundList.InsertArrayElementAtIndex( soundList.arraySize );
+				//MarkDirty();
+				addSound = true;
+			}
+			if ( GUILayout.Button( "Sort", GUILayout.Width( 70f ) ) ) {
+				sortSounds = true;
+			}
+			EditorGUILayout.EndHorizontal();
+
+		}
+		EndContents();
+
+		UpdateDrag( e );
+
+	}
+
+	/*
+	-----------------------
+	CheckStartDrag()
+	-----------------------
+	*/
+	void CheckStartDrag( Event e ) {
+
+		if ( ( e.type == EventType.MouseDrag ) && ( e.button == 0 ) ) {
+			for ( int i = 0; i < items.size; i++ ) {
+				if ( items[i].rect.Contains( e.mousePosition ) ) {
+					DragAndDrop.PrepareStartDrag();// reset data
+					
+					CustomDragData dragData = new CustomDragData();
+					dragData.originalGroupIndex = selectedGroup;
+					dragData.originalIndex = items[i].index;
+					dragData.originalProperty = items[i].prop;
+
+					DragAndDrop.SetGenericData( dragDropIdentifier, dragData );
+					
+					DragAndDrop.objectReferences = new Object[0];
+
+					DragAndDrop.StartDrag( dragData.originalProperty.FindPropertyRelative( "name" ).stringValue );
+					e.Use();
+				}
+			}
+		}
+	}
+
+	/*
+	-----------------------
+	FindGroupIndex()
+	-----------------------
+	*/
+	int FindGroupIndex( Event e ) {
+		for ( int i = 0; i < groups.size; i++ ) {
+			if ( groups[i].rect.Contains( e.mousePosition ) ) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	/*
+	-----------------------
+	UpdateDrag()
+	-----------------------
+	*/
+	void UpdateDrag( Event e ) {
+
+		CustomDragData dragData = DragAndDrop.GetGenericData( dragDropIdentifier ) as CustomDragData;
+		if ( dragData == null ) {
+			return;
+		}
+
+		int groupIndex = FindGroupIndex( e );
+
+		switch ( e.type ) {
+		case EventType.DragUpdated:
+			if ( ( groupIndex >= 0 ) && ( groupIndex != selectedGroup ) ) {
+				DragAndDrop.visualMode = DragAndDropVisualMode.Move;
+			} else {
+				DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
+			}
+			e.Use();
+			break;     
+		case EventType.Repaint:
+			if ( ( DragAndDrop.visualMode == DragAndDropVisualMode.None ) ||
+				 ( DragAndDrop.visualMode == DragAndDropVisualMode.Rejected ) ) {
+				break;
+			}
+			if ( groupIndex >= 0 && groupIndex < groups.size ) {
+				EditorGUI.DrawRect( groups[groupIndex].rect, new Color( 0f, 1f, 0f, 0.1f ) );      
+			}
+			break;
+		case EventType.DragPerform:
+			DragAndDrop.AcceptDrag();
+			// queue the sound FX move
+			QueueSoundFXMove( dragData.originalGroupIndex, dragData.originalIndex, groupIndex );
+			e.Use();
+			break;
+		case EventType.MouseUp:
+			// in case MouseDrag never occurred:
+			DragAndDrop.PrepareStartDrag();
+			break;
+		}
+	}
+
+	/*
+	-----------------------
+	QueueSoundFXMove()
+	-----------------------
+	*/
+	void QueueSoundFXMove( int origGroupIndex, int origSoundIndex, int newGroupIndex ) {
+		moveQueued = true;
+		origGroup = origGroupIndex;
+		origIndex = origSoundIndex;
+		moveToGroup = newGroupIndex;
+	}
+
+	/*
+	-----------------------
+	DrawHeader()
+	-----------------------
+	*/
+	static public bool DrawHeader (string text) { return DrawHeader(text, text, false); }
+	static public bool DrawHeader (string text, string key) { return DrawHeader(text, key, false); }
+	static public bool DrawHeader (string text, bool forceOn) { return DrawHeader(text, text, forceOn); }
+	static public bool DrawHeader( string text, string key, bool forceOn ) {
+		bool state = EditorPrefs.GetBool(key, true);
+		
+		GUILayout.Space(3f);
+		if (!forceOn && !state) GUI.backgroundColor = new Color(0.8f, 0.8f, 0.8f);
+		GUILayout.BeginHorizontal();
+		GUILayout.Space(3f);
+		
+		GUI.changed = false;
+		text = "<b><size=11>" + text + "</size></b>";
+		if (state) text = "\u25BC " + text;
+		else text = "\u25B6 " + text;
+		if (!GUILayout.Toggle(true, text, "dragtab", GUILayout.MinWidth(20f))) state = !state;
+		if (GUI.changed) EditorPrefs.SetBool(key, state);
+		
+		GUILayout.Space(2f);
+		GUILayout.EndHorizontal();
+		GUI.backgroundColor = Color.white;
+		if (!forceOn && !state) GUILayout.Space(3f);
+		return state;
+	}
+	
+	/*
+	-----------------------
+	BeginContents()
+	-----------------------
+	*/
+	static public void BeginContents() {
+		GUILayout.BeginHorizontal();
+		GUILayout.Space(4f);
+		EditorGUILayout.BeginHorizontal(GUILayout.MinHeight(10f));
+		GUILayout.BeginVertical();
+		GUILayout.Space(2f);
+	}
+	
+	/*
+	-----------------------
+	EndContents()
+	-----------------------
+	*/
+	static public void EndContents() {
+		GUILayout.Space(3f);
+		GUILayout.EndVertical();
+		EditorGUILayout.EndHorizontal();
+		GUILayout.Space(3f);
+		GUILayout.EndHorizontal();
+		GUILayout.Space(3f);
+	}
+
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/Editor/AudioManagerInspector.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9f04a80514947486d9793cab0005447f
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/Editor/MinMaxPropertyDrawer.cs

@@ -0,0 +1,70 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace OVR
+{
+
+/*
+-----------------------
+
+ MinMaxPropertyDrawer
+
+-----------------------
+*/
+[CustomPropertyDrawer (typeof (MinMaxAttribute))]
+public class MinMaxPropertyDrawer : PropertyDrawer {
+
+	// Provide easy access to the MinMaxAttribute for reading information from it.
+	MinMaxAttribute minMax { get { return ((MinMaxAttribute)attribute); } }
+
+	/*
+	-----------------------
+	GetPropertyHeight()
+	-----------------------
+	*/
+	public override float GetPropertyHeight( SerializedProperty prop, GUIContent label ) {
+		return base.GetPropertyHeight( prop, label ) * 2f;
+	}
+	
+	/*
+	-----------------------
+	OnGUI()
+	-----------------------
+	*/
+	public override void OnGUI( Rect position, SerializedProperty property, GUIContent label ) {
+		Rect sliderPosition = EditorGUI.PrefixLabel( position, label );
+		SerializedProperty min = property.FindPropertyRelative( "x" );
+		SerializedProperty max = property.FindPropertyRelative( "y" );
+
+		// draw the range and the reset button first so that the slider doesn't grab all the input
+		Rect rangePosition = sliderPosition;
+		rangePosition.y += rangePosition.height * 0.5f;
+		rangePosition.height *= 0.5f;
+		Rect contentPosition = rangePosition;
+		EditorGUI.indentLevel = 0;
+		EditorGUIUtility.labelWidth = 30f;
+		contentPosition.width *= 0.3f;
+		EditorGUI.PropertyField(contentPosition, min, new GUIContent( "Min" ) );
+		contentPosition.x += contentPosition.width + 20f;
+		EditorGUI.PropertyField( contentPosition, max, new GUIContent( "Max" ) );
+		contentPosition.x += contentPosition.width + 20f;
+		contentPosition.width = 50.0f;
+		if ( GUI.Button( contentPosition, "Reset" ) ) {
+			min.floatValue = minMax.minDefaultVal;
+			max.floatValue = minMax.maxDefaultVal;
+		}
+		float minValue = min.floatValue;
+		float maxValue = max.floatValue;
+#if UNITY_2017_1_OR_NEWER
+		EditorGUI.MinMaxSlider( sliderPosition, GUIContent.none, ref minValue, ref maxValue, minMax.min, minMax.max );
+#else
+        EditorGUI.MinMaxSlider( GUIContent.none, sliderPosition, ref minValue, ref maxValue, minMax.min, minMax.max );
+#endif
+        // round to readable values
+        min.floatValue = Mathf.Round( minValue / 0.01f ) * 0.01f;
+		max.floatValue = Mathf.Round( maxValue / 0.01f ) * 0.01f;
+	}
+
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/Editor/MinMaxPropertyDrawer.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 225aed143a64c4a6a93f3a07656ac5cd
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/Editor/MixerSnapshotPropertyDrawer.cs

@@ -0,0 +1,50 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace OVR
+{
+
+/*
+-----------------------
+
+ MixerSnapshotPropertyDrawer
+
+-----------------------
+*/
+[CustomPropertyDrawer( typeof( MixerSnapshot ) )]
+public class MixerSnapshotPropertyDrawer : PropertyDrawer {
+
+	// Draw the property inside the given rect
+	public override void OnGUI( Rect position, SerializedProperty property, GUIContent label ) {
+		// Using BeginProperty / EndProperty on the parent property means that
+		// prefab override logic works on the entire property.
+		EditorGUI.BeginProperty( position, label, property );
+
+		// Draw label
+		position = EditorGUI.PrefixLabel( position, GUIUtility.GetControlID( FocusType.Passive ), label );
+
+		// Don't make child fields be indented
+		var indent = EditorGUI.indentLevel;
+		EditorGUI.indentLevel = 0;
+		EditorGUIUtility.labelWidth = 65;
+
+		float width = ( position.width - 15.0f ) / 2.0f;
+
+		// Calculate rects
+		var srcRect = new Rect( position.x, position.y, width + 20, position.height ); position.x += width + 25.0f;
+		var destRect = new Rect( position.x, position.y, width - 60, position.height ); position.x += width - 60.0f;
+		var secsRect = new Rect( position.x, position.y, 40, position.height );
+
+		// Draw fields - pass GUIContent.none to each so they are drawn without labels
+		EditorGUI.PropertyField( srcRect, property.FindPropertyRelative( "snapshot" ), GUIContent.none );
+		EditorGUI.PropertyField( destRect, property.FindPropertyRelative( "transitionTime" ), new GUIContent( "Transition" ) );
+		EditorGUI.LabelField( secsRect, new GUIContent( "sec(s)" ) );
+
+		// Set indent back to what it was
+		EditorGUI.indentLevel = indent;
+
+		EditorGUI.EndProperty();
+	}
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/Editor/MixerSnapshotPropertyDrawer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 82a91f30f2305c14dbfd2cc3c289dc59
+timeCreated: 1472247018
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Audio/Editor/OSPPropsPropertyDrawer.cs

@@ -0,0 +1,66 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace OVR
+{
+
+/*
+-----------------------
+
+OSPPropsPropertyDrawer
+
+-----------------------
+*/
+[CustomPropertyDrawer(typeof(OSPProps))]
+public class OSPPropsPropertyDrawer : PropertyDrawer {
+
+	static float lineHeight = EditorGUIUtility.singleLineHeight + 2.0f;
+	static float indent = 32.0f;
+	// TODO - some day just enumerate these
+	static string[] props = new string[] { "useFastOverride", "gain", "enableInvSquare", "volumetric" , "invSquareFalloff" };
+	static string[] names = new string[] { "Reflections Enabled", "Gain", "Enable Oculus Atten.", "Volumetric", "Range" };
+	static int[] lines = new int[] { 1, 1, 1, 1, 2, 2 };
+	/*
+	-----------------------
+	OnGUI()
+	-----------------------
+	*/
+	public override void OnGUI( Rect position, SerializedProperty prop, GUIContent label ) {
+        SerializedProperty playSpatializedProp = prop.FindPropertyRelative("enableSpatialization");
+		position.height = lineHeight;
+		EditorGUI.PropertyField( position, playSpatializedProp );
+		if ( playSpatializedProp.boolValue ) {
+			position.y += lineHeight + 4.0f;
+			Rect posLine = position;
+			posLine.x += indent;
+			posLine.width -= indent;
+			posLine.height = 1f;
+			GUI.Box( posLine, "" );
+			position.y -= 10.0f;
+			for ( int i = 0; i < props.Length; i++ ) {
+				position.y += lineHeight;
+				position.height = ( lineHeight * lines[i] );
+				SerializedProperty sibling = prop.FindPropertyRelative( props[i] );
+				EditorGUI.PropertyField( position, sibling, new GUIContent( names[i] ) );
+			}
+		}
+	}
+
+	/*
+	-----------------------
+	GetPropertyHeight()
+	-----------------------
+	*/
+	public override float GetPropertyHeight (SerializedProperty prop, GUIContent label) {
+        SerializedProperty playSpatializedProp = prop.FindPropertyRelative("enableSpatialization");
+		if ( !playSpatializedProp.boolValue ) {
+			return base.GetPropertyHeight( prop, label );
+		} else {
+			return base.GetPropertyHeight( prop, label ) + ( lineHeight * ( props.Length + 1 ) ) + 16.0f;
+		}
+	}
+
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/Editor/OSPPropsPropertyDrawer.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9fc79251b168140d68851f1e8c283514
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/Editor/SoundFXPropertyDrawer.cs

@@ -0,0 +1,67 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace OVR
+{
+
+/*
+-----------------------
+
+SoundFXPropertyDrawer
+
+-----------------------
+*/
+[CustomPropertyDrawer(typeof(SoundFX))]
+public class SoundFXPropertyDrawer : PropertyDrawer {
+
+	static float lineHeight = EditorGUIUtility.singleLineHeight + 2.0f;
+
+	static string[] props = new string[] { "name", "playback", "volume", "pitchVariance", "falloffDistance", "falloffCurve", "reverbZoneMix", "spread", "pctChanceToPlay", "priority", "delay", "looping", "ospProps", "soundClips" };
+
+	/*
+	-----------------------
+	OnGUI()
+	-----------------------
+	*/
+	public override void OnGUI( Rect position, SerializedProperty prop, GUIContent label ) {
+
+		EditorGUILayout.BeginVertical();
+		for ( int i = 0; i < props.Length; i++ ) {
+			EditorGUI.indentLevel = 2;
+			SerializedProperty property = prop.FindPropertyRelative( props[i] );
+			if ( props[i] == "reverbZoneMix" ) {
+				EditorGUILayout.BeginHorizontal();
+				SerializedProperty reverbCurve = prop.FindPropertyRelative( "reverbZoneMix" );
+				EditorGUILayout.PropertyField( reverbCurve, true, GUILayout.Width( Screen.width - 130.0f ) );
+				if ( GUILayout.Button( "Reset", GUILayout.Width( 50.0f ) ) ) {
+					reverbCurve.animationCurveValue = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
+				}
+				EditorGUILayout.EndHorizontal();
+			} else {
+				EditorGUILayout.PropertyField( property, true, GUILayout.Width( Screen.width - 80.0f ) );
+				position.y += lineHeight + 4.0f;
+				if ( props[i] == "falloffCurve" ) {
+					if ( property.enumValueIndex == (int)AudioRolloffMode.Custom ) {
+						EditorGUILayout.PropertyField( prop.FindPropertyRelative( "volumeFalloffCurve" ), true, GUILayout.Width( Screen.width - 80.0f ) );
+						position.y += lineHeight + 4.0f;
+					}
+				}
+			}
+		}
+		EditorGUILayout.EndVertical();
+		GUILayout.Space( 5.0f );
+	}
+
+	/*
+	-----------------------
+	GetPropertyHeight()
+	-----------------------
+	*/
+	public override float GetPropertyHeight (SerializedProperty prop, GUIContent label) {
+		return base.GetPropertyHeight( prop, label );
+	}
+
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/Editor/SoundFXPropertyDrawer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e791ce392b6937f47b1f7c90c6b402db
+timeCreated: 1468857307
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Audio/Editor/SoundFXRefPropertyDrawer.cs

@@ -0,0 +1,62 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace OVR
+{
+
+/*
+-----------------------
+
+SoundFXRefPropertyDrawer
+
+-----------------------
+*/
+[CustomPropertyDrawer(typeof(SoundFXRef))]
+public class SoundFXRefPropertyDrawer : PropertyDrawer {
+
+	static private GUIStyle disabledStyle = null;
+
+	/*
+	-----------------------
+	OnGUI()
+	-----------------------
+	*/
+	public override void OnGUI( Rect position, SerializedProperty prop, GUIContent label ) {
+		int idx = 0;
+		Rect buttonPosition = position;
+		buttonPosition.x = position.x + position.width - 40f;
+		buttonPosition.width = 20f;
+		position.width = buttonPosition.x - position.x - 2f;
+		SerializedProperty nameProp = prop.FindPropertyRelative( "soundFXName" );
+		if ( AudioManager.GetGameObject() == null ) {
+			if ( disabledStyle == null ) {
+				disabledStyle = new GUIStyle();
+				disabledStyle.normal.textColor = Color.gray;
+			}
+			EditorGUI.LabelField(position, label.text, nameProp.stringValue, disabledStyle );
+		}
+		else {
+			string[] soundFXNames = AudioManager.GetSoundFXNames( nameProp.stringValue, out idx );
+		
+			idx = EditorGUI.Popup( position, label.text, idx, soundFXNames );
+			nameProp.stringValue = AudioManager.NameMinusGroup( soundFXNames[idx] );
+			// play button
+			if ( GUI.Button( buttonPosition, "\u25BA" ) ) {
+				if ( AudioManager.IsSoundPlaying( nameProp.stringValue ) ) {
+					AudioManager.StopSound( nameProp.stringValue );
+				} else {
+					AudioManager.PlaySound( nameProp.stringValue );
+				}
+			}
+			buttonPosition.x += 22.0f;
+			// select audio manager
+			if ( GUI.Button( buttonPosition, "\u2630" ) ) { 
+				Selection.activeGameObject = AudioManager.GetGameObject();
+			}
+
+		}
+	}
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/Editor/SoundFXRefPropertyDrawer.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6204bcaba636340b48858c9f10ab9016
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/MinMaxAttribute.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+namespace OVR
+{
+
+/*
+-----------------------
+
+ MinMaxAttribute
+
+-----------------------
+*/
+public class MinMaxAttribute : PropertyAttribute {
+	public float minDefaultVal = 1.0f;
+	public float maxDefaultVal = 1.0f;
+	public float min = 0.0f;
+	public float max = 1.0f;
+	public MinMaxAttribute( float minDefaultVal, float maxDefaultVal, float min, float max ) {
+		this.minDefaultVal = minDefaultVal;
+		this.maxDefaultVal = maxDefaultVal;
+		this.min = min;
+		this.max = max;
+	}
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/MinMaxAttribute.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 15126f023faf44286a08bdb5bdbdb6e7
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/SoundEmitter.cs

@@ -0,0 +1,433 @@
+using UnityEngine;
+using UnityEngine.Audio;
+using System.Collections;
+
+namespace OVR
+{
+
+/*
+-----------------------
+ 
+ SoundEmitter()
+ 
+-----------------------
+*/
+public class SoundEmitter : MonoBehaviour {
+	public enum FadeState {
+		Null,
+		FadingIn,
+		FadingOut,
+		Ducking,
+	}	
+
+	// OPTIMIZE
+
+	public float 					volume { get { return audioSource.volume; } set { audioSource.volume = value; } }
+	public float 					pitch { get { return audioSource.pitch; } set { audioSource.pitch = value; } }
+	public AudioClip				clip { get { return audioSource.clip; } set { audioSource.clip = value; } }
+	public float 					time { get { return audioSource.time; } set { audioSource.time = value; } }
+	public float 					length { get { return ( audioSource.clip != null ) ? audioSource.clip.length : 0.0f; } }
+	public bool 					loop { get { return audioSource.loop; } set { audioSource.loop = value; } }
+	public bool 					mute { get { return audioSource.mute; } set { audioSource.mute = value; } }
+	public AudioVelocityUpdateMode	velocityUpdateMode { get { return audioSource.velocityUpdateMode; } set { audioSource.velocityUpdateMode = value; } }
+	public bool						isPlaying { get { return audioSource.isPlaying; } }
+
+	public EmitterChannel			channel = EmitterChannel.Reserved;
+	public bool						disableSpatialization = false;
+	private	FadeState				state = FadeState.Null;
+	[System.NonSerialized]
+	[HideInInspector]
+	public AudioSource				audioSource = null;
+	[System.NonSerialized]
+	[HideInInspector]
+	public SoundPriority            priority = SoundPriority.Default;
+	[System.NonSerialized]
+	[HideInInspector]
+	public ONSPAudioSource			osp = null;
+	[System.NonSerialized]
+	[HideInInspector]
+	public float					endPlayTime = 0.0f;
+	private Transform				lastParentTransform = null;
+	[System.NonSerialized]
+	[HideInInspector]
+	public float					defaultVolume = 1.0f;
+	[System.NonSerialized]
+	[HideInInspector]
+	public Transform				defaultParent = null;
+	[System.NonSerialized]
+	[HideInInspector]
+	public int						originalIdx = -1;
+	[System.NonSerialized]
+	[HideInInspector]
+	public System.Action			onFinished = null;
+	[System.NonSerialized]
+	[HideInInspector]
+	public System.Action<object>	onFinishedObject = null;
+	[System.NonSerialized]
+	[HideInInspector]
+	public object					onFinishedParam;
+	[System.NonSerialized]
+	[HideInInspector]
+	public SoundGroup               playingSoundGroup = null;
+
+	/*
+	-----------------------
+	Awake()
+	-----------------------
+	*/
+	void Awake() {
+		// unity defaults to 'playOnAwake = true'
+		audioSource = GetComponent<AudioSource>();
+		if ( audioSource == null ) {
+			audioSource = gameObject.AddComponent<AudioSource>();
+		}
+		// is the spatialized audio enabled?
+		if ( AudioManager.enableSpatialization && !disableSpatialization ) {
+			osp = GetComponent<ONSPAudioSource>(); 
+			if ( osp == null ) {
+				osp = gameObject.AddComponent<ONSPAudioSource>();
+			}
+		}
+		audioSource.playOnAwake = false;
+		audioSource.Stop();
+	}
+
+	/*
+	-----------------------
+	SetPlayingSoundGroup()
+	-----------------------
+	*/
+	public void SetPlayingSoundGroup( SoundGroup soundGroup ) {
+		playingSoundGroup = soundGroup;
+		if ( soundGroup != null ) {
+			soundGroup.IncrementPlayCount();
+		}
+	}
+
+	/*
+	-----------------------
+	SetOnFinished()
+	-----------------------
+	*/
+	public void SetOnFinished( System.Action onFinished ) {
+		this.onFinished = onFinished;
+	}
+
+	/*
+	-----------------------
+	SetOnFinished()
+	-----------------------
+	*/
+	public void SetOnFinished( System.Action<object> onFinished, object obj ) {
+		onFinishedObject = onFinished;
+		onFinishedParam = obj;
+	}
+
+	/*
+	-----------------------
+	SetChannel()
+	-----------------------
+	*/
+	public void SetChannel( int _channel ) {
+		channel = (EmitterChannel)_channel;
+	}
+
+	/*
+	-----------------------
+	SetDefaultParent()
+	-----------------------
+	*/
+	public void SetDefaultParent( Transform parent ) {
+		defaultParent = parent;
+	}
+
+	/*
+	-----------------------
+	SetAudioMixer()
+	-----------------------
+	*/
+	public void SetAudioMixer( AudioMixerGroup _mixer ) {
+		if ( audioSource != null ) {
+			audioSource.outputAudioMixerGroup = _mixer;
+		}
+	}
+
+	/*
+	-----------------------
+	IsPlaying()
+	-----------------------
+	*/
+	public bool IsPlaying() {
+		if ( loop && audioSource.isPlaying ) {
+			return true;
+		}
+		return endPlayTime > Time.time;
+	} 
+
+	/*
+	-----------------------
+	Play()
+	-----------------------
+	*/
+	public void Play() {
+		// overrides everything
+		state = FadeState.Null;
+		endPlayTime = Time.time + length;
+		StopAllCoroutines();
+		audioSource.Play();
+	}
+
+	/*
+	-----------------------
+	Pause()
+	-----------------------
+	*/
+	public void Pause() {
+		// overrides everything
+		state = FadeState.Null;
+		StopAllCoroutines();
+		audioSource.Pause();
+	}
+	
+	/*
+	-----------------------
+	Stop()
+	-----------------------
+	*/
+	public void Stop() {
+		// overrides everything
+		state = FadeState.Null;
+		StopAllCoroutines();
+		if ( audioSource != null ) {
+			audioSource.Stop();
+		}
+		if ( onFinished != null ) {
+			onFinished();
+			onFinished = null;
+		}
+		if ( onFinishedObject != null ) {
+			onFinishedObject( onFinishedParam );
+			onFinishedObject = null;
+		}
+		if ( playingSoundGroup != null ) {
+			playingSoundGroup.DecrementPlayCount();
+			playingSoundGroup = null;
+		}
+	}
+
+	/*
+	-----------------------
+	GetSampleTime()
+	-----------------------
+	*/
+	int GetSampleTime() {
+		return audioSource.clip.samples - audioSource.timeSamples;
+	}
+
+	/*
+	-----------------------
+	ParentTo()
+	-----------------------
+	*/
+	public void ParentTo( Transform parent ) {
+		if ( lastParentTransform != null ) {
+			Debug.LogError( "[SoundEmitter] You must detach the sound emitter before parenting to another object!" );
+			return;
+		}
+		lastParentTransform = transform.parent;
+		transform.parent = parent;
+	}
+
+	/*
+	-----------------------
+	DetachFromParent()
+	-----------------------
+	*/
+	public void DetachFromParent() {
+		if ( lastParentTransform == null ) {
+			transform.parent = defaultParent;
+			return;
+		}
+		transform.parent = lastParentTransform;
+		lastParentTransform = null;
+	}
+
+	/*
+	-----------------------
+	ResetParent()
+	-----------------------
+	*/
+	public void ResetParent( Transform parent ) {
+		transform.parent = parent;
+		lastParentTransform = null;
+	}
+
+	/*
+	-----------------------
+	SyncTo()
+	-----------------------
+	*/
+	public void SyncTo( SoundEmitter other, float fadeTime, float toVolume ) {
+		StartCoroutine( DelayedSyncTo( other, fadeTime, toVolume ) );
+	}
+
+	/*
+	-----------------------
+	DelayedSyncTo()
+	have to wait until the end of frame to do proper sync'ing
+	-----------------------
+	*/
+	IEnumerator DelayedSyncTo( SoundEmitter other, float fadeTime, float toVolume ) {
+		yield return new WaitForEndOfFrame();
+		//audio.timeSamples = other.GetSampleTime();
+		//audio.time = Mathf.Min( Mathf.Max( 0.0f, other.time - other.length ), other.time );
+		audioSource.time = other.time;
+		audioSource.Play();
+		FadeTo( fadeTime, toVolume );
+	}
+
+	/*
+	-----------------------
+	FadeTo()
+	-----------------------
+	*/
+	public void FadeTo( float fadeTime, float toVolume ) {
+		//Log.Print( ">>> FADE TO: " + channel );
+
+		
+		// don't override a fade out 
+		if ( state == FadeState.FadingOut ) {
+			//Log.Print( "    ....ABORTED" );
+			return; 
+		}
+		state = FadeState.Ducking;
+		StopAllCoroutines();
+		StartCoroutine( FadeSoundChannelTo( fadeTime, toVolume ) );
+	}
+	
+	/*
+	-----------------------
+	FadeIn()
+	-----------------------
+	*/
+	public void FadeIn( float fadeTime, float defaultVolume ) {
+		
+		//Log.Print( ">>> FADE IN: " + channel );
+		audioSource.volume = 0.0f;		
+		state = FadeState.FadingIn;		
+		StopAllCoroutines();
+		StartCoroutine( FadeSoundChannel( 0.0f, fadeTime, Fade.In, defaultVolume ) );
+	}
+
+	/*
+	-----------------------
+	FadeIn()
+	-----------------------
+	*/
+	public void FadeIn( float fadeTime ) {
+
+		//Log.Print( ">>> FADE IN: " + channel );
+		audioSource.volume = 0.0f;
+		state = FadeState.FadingIn;
+		StopAllCoroutines();
+		StartCoroutine( FadeSoundChannel( 0.0f, fadeTime, Fade.In, defaultVolume ) );
+	}
+
+	/*
+	-----------------------
+	FadeOut()
+	-----------------------
+	*/
+	public void FadeOut( float fadeTime ) {
+		//Log.Print( ">>> FADE OUT: " + channel );
+		if ( !audioSource.isPlaying ) {
+			//Log.Print( "   ... SKIPPING" );
+			return;
+		}
+		state = FadeState.FadingOut;
+		StopAllCoroutines();
+		StartCoroutine( FadeSoundChannel( 0.0f, fadeTime, Fade.Out, audioSource.volume ) );
+	}
+	
+	/*
+	-----------------------
+	FadeOutDelayed()
+	-----------------------
+	*/
+	public void FadeOutDelayed( float delayedSecs, float fadeTime ) {
+		//Log.Print( ">>> FADE OUT DELAYED: " + channel );
+		if ( !audioSource.isPlaying ) {
+			//Log.Print( "   ... SKIPPING" );
+			return;
+		}
+		state = FadeState.FadingOut;
+		StopAllCoroutines();
+		StartCoroutine( FadeSoundChannel( delayedSecs, fadeTime, Fade.Out, audioSource.volume ) );
+	}
+	
+	/*
+	-----------------------
+	FadeSoundChannelTo()
+	-----------------------
+	*/
+	IEnumerator FadeSoundChannelTo( float fadeTime, float toVolume ) {
+		float start = audioSource.volume;
+		float end = toVolume;
+		float startTime = Time.realtimeSinceStartup;
+		float elapsedTime = 0.0f;
+
+		while ( elapsedTime < fadeTime ) {
+			elapsedTime = Time.realtimeSinceStartup - startTime;
+			float t = elapsedTime / fadeTime;
+			audioSource.volume = Mathf.Lerp( start, end, t );
+			yield return 0;
+		}
+		state = FadeState.Null;
+	}		
+	
+	/*
+	-----------------------
+	FadeSoundChannel()
+	-----------------------
+	*/
+	IEnumerator FadeSoundChannel( float delaySecs, float fadeTime, Fade fadeType, float defaultVolume ) {
+ 		if ( delaySecs > 0.0f ) {
+ 			yield return new WaitForSeconds( delaySecs );
+ 		}
+		float start = ( fadeType == Fade.In ) ? 0.0f : defaultVolume;
+		float end = ( fadeType == Fade.In ) ? defaultVolume : 0.0f;
+		bool restartPlay = false;
+		
+		if ( fadeType == Fade.In ) {
+			if ( Time.time == 0.0f ) {
+				restartPlay = true;
+			}
+			audioSource.volume = 0.0f;
+			audioSource.Play();	
+		}
+
+		float startTime = Time.realtimeSinceStartup;
+		float elapsedTime = 0.0f;
+
+		while ( elapsedTime < fadeTime ) {
+			elapsedTime = Time.realtimeSinceStartup - startTime;
+			float t = elapsedTime / fadeTime;
+			audioSource.volume = Mathf.Lerp( start, end, t );
+			yield return 0;
+			if ( restartPlay && ( Time.time > 0.0f ) ) {
+				audioSource.Play();	
+				restartPlay = false;
+			}
+			if ( !audioSource.isPlaying ) {
+				break;
+			}
+		}
+
+		if ( fadeType == Fade.Out ) {
+			Stop();
+		}
+		state = FadeState.Null;
+	}		
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/SoundEmitter.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ecd24e91b27c645fc95f6c42115c13cc
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/SoundFX.cs

@@ -0,0 +1,311 @@
+using UnityEngine;
+using UnityEngine.Audio;
+
+namespace OVR
+{
+
+public enum SoundFXNext {
+	Random = 0,
+	Sequential = 1,
+}
+
+public enum FreqHint {
+	None = 0,
+	Wide = 1,
+	Narrow = 2,
+}
+
+public enum SoundPriority {
+	VeryLow = -2,
+	Low = -1,
+	Default = 0,
+	High = 1,
+	VeryHigh = 2,
+}
+
+[System.Serializable]
+public class OSPProps {
+	public OSPProps() {
+        enableSpatialization = false;
+		useFastOverride = false;
+		gain = 0.0f;
+        enableInvSquare = false;
+        volumetric = 0.0f;
+		invSquareFalloff = new Vector2( 1.0f, 25.0f );
+	}
+
+	[Tooltip( "Set to true to play the sound FX spatialized with binaural HRTF, default = false")]
+    public bool enableSpatialization = false;
+	[Tooltip( "Play the sound FX with reflections, default = false")]
+	public bool			useFastOverride = false;
+	[Tooltip( "Boost the gain on the spatialized sound FX, default = 0.0")]
+	[Range( 0.0f, 24.0f )]
+	public float		gain = 0.0f;
+    [Tooltip("Enable Inverse Square attenuation curve, default = false")]
+    public bool         enableInvSquare = false;
+    [Tooltip("Change the sound from point source (0.0f) to a spherical volume, default = 0.0")]
+    [Range(0.0f, 1000.0f)]
+    public float volumetric = 0.0f;
+    [Tooltip("Set the near and far falloff value for the OSP attenuation curve, default = 1.0")]
+	[MinMax ( 1.0f, 25.0f, 0.0f, 250.0f )]
+	public Vector2		invSquareFalloff = new Vector2( 1.0f, 25.0f );
+}
+
+/*
+-----------------------
+
+SoundFX
+
+-----------------------
+*/
+[System.Serializable]
+public class SoundFX {
+	public SoundFX() { 
+		playback = SoundFXNext.Random;
+		volume = 1.0f;
+		pitchVariance = Vector2.one;
+		falloffDistance = new Vector2( 1.0f, 25.0f );
+		falloffCurve = AudioRolloffMode.Linear;
+		volumeFalloffCurve = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
+		reverbZoneMix = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
+		spread = 0.0f;
+		pctChanceToPlay = 1.0f;
+		priority = SoundPriority.Default;
+		delay = Vector2.zero;
+		looping = false;
+		ospProps = new OSPProps();
+	}
+
+	[Tooltip( "Each sound FX should have a unique name")]
+	public string			name = string.Empty;
+	[Tooltip( "Sound diversity playback option when multiple audio clips are defined, default = Random")]
+	public SoundFXNext		playback = SoundFXNext.Random;
+	[Tooltip( "Default volume for this sound FX, default = 1.0")]
+	[Range (0.0f, 1.0f)]
+	public float			volume = 1.0f;
+	[Tooltip( "Random pitch variance each time a sound FX is played, default = 1.0 (none)")]
+	[MinMax ( 1.0f, 1.0f, 0.0f, 2.0f )]
+	public Vector2			pitchVariance = Vector2.one;
+	[Tooltip( "Falloff distance for the sound FX, default = 1m min to 25m max")]
+	[MinMax ( 1.0f, 25.0f, 0.0f, 250.0f )]
+	public Vector2			falloffDistance = new Vector2( 1.0f, 25.0f );
+	[Tooltip( "Volume falloff curve - sets how the sound FX attenuates over distance, default = Linear")]
+	public AudioRolloffMode	falloffCurve = AudioRolloffMode.Linear;
+	[Tooltip( "Defines the custom volume falloff curve")]
+	public AnimationCurve   volumeFalloffCurve = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
+	[Tooltip( "The amount by which the signal from the AudioSource will be mixed into the global reverb associated with the Reverb Zones | Valid range is 0.0 - 1.1, default = 1.0" )]
+	public AnimationCurve   reverbZoneMix = new AnimationCurve( new Keyframe[2] { new Keyframe( 0f, 1.0f ), new Keyframe( 1f, 1f ) } );
+	[Tooltip( "Sets the spread angle (in degrees) of a 3d stereo or multichannel sound in speaker space, default = 0")]
+	[Range (0.0f, 360.0f)]
+	public float			spread = 0.0f;
+	[Tooltip( "The percentage chance that this sound FX will play | 0.0 = none, 1.0 = 100%, default = 1.0")]
+	[Range (0.0f, 1.0f)]
+	public float			pctChanceToPlay = 1.0f;
+	[Tooltip( "Sets the priority for this sound to play and/or to override a currently playing sound FX, default = Default")]
+	public SoundPriority	priority = SoundPriority.Default;
+	[Tooltip( "Specifies the default delay when this sound FX is played, default = 0.0 secs")]
+	[MinMax ( 0.0f, 0.0f, 0.0f, 2.0f )]
+	public Vector2          delay = Vector2.zero;   // this overrides any delay passed into PlaySound() or PlaySoundAt()
+	[Tooltip( "Set to true for the sound to loop continuously, default = false")]
+	public bool				looping = false;
+	public OSPProps			ospProps = new OSPProps();
+	[Tooltip( "List of the audio clips assigned to this sound FX")]
+	public AudioClip[]		soundClips = new AudioClip[1];
+	// editor only - unfortunately if we set it not to serialize, we can't query it from the editor
+	public bool             visibilityToggle = false;
+	// runtime vars
+	[System.NonSerialized]
+	private SoundGroup      soundGroup = null;
+	private int				lastIdx = -1;
+	private int				playingIdx = -1;
+
+	public int 				Length { get { return soundClips.Length; } }
+	public bool				IsValid { get { return ( ( soundClips.Length != 0 ) && ( soundClips[0] != null ) ); } }
+	public SoundGroup		Group { get { return soundGroup; } set { soundGroup = value; } }
+	public float			MaxFalloffDistSquared { get { return falloffDistance.y * falloffDistance.y; } }
+	public float			GroupVolumeOverride { get { return ( soundGroup != null ) ? soundGroup.volumeOverride : 1.0f; } }
+
+	/*
+	-----------------------
+	GetClip()
+	-----------------------
+	*/
+	public AudioClip GetClip() {
+		if ( soundClips.Length == 0 ) {
+			return null;
+		} else if ( soundClips.Length == 1 ) {
+			return soundClips[0];
+		}
+		if ( playback == SoundFXNext.Random ) {
+			// random, but don't pick the last one
+			int idx = Random.Range( 0, soundClips.Length );
+			while ( idx == lastIdx ) {
+				idx = Random.Range( 0, soundClips.Length );
+			}
+			lastIdx = idx;
+			return soundClips[idx];
+		} else {
+			// sequential
+			if ( ++lastIdx >= soundClips.Length ) {
+				lastIdx = 0;
+			}
+			return soundClips[lastIdx];
+		}
+	}
+
+	/*
+	-----------------------
+	GetMixerGroup()
+	-----------------------
+	*/
+	public AudioMixerGroup GetMixerGroup( AudioMixerGroup defaultMixerGroup ) {
+		if ( soundGroup != null ) {
+			return ( soundGroup.mixerGroup != null ) ? soundGroup.mixerGroup : defaultMixerGroup;	
+		}
+		return defaultMixerGroup;
+	} 
+
+	/*
+	-----------------------
+	ReachedGroupPlayLimit()
+	-----------------------
+	*/
+	public bool ReachedGroupPlayLimit() {
+		if ( soundGroup != null ) {
+			return !soundGroup.CanPlaySound();
+		}
+		return false;
+	}
+
+	/*
+	-----------------------
+	GetClipLength()
+	-----------------------
+	*/
+	public float GetClipLength( int idx ) {
+		if ( ( idx == -1 ) || ( soundClips.Length == 0 ) || ( idx >= soundClips.Length ) || ( soundClips[idx] == null ) ) {
+			return 0.0f;
+		} else {
+			return soundClips[idx].length;
+		}
+	}
+
+	/*
+	-----------------------
+	GetPitch()
+	-----------------------
+	*/
+	public float GetPitch() {
+		return Random.Range( pitchVariance.x, pitchVariance.y );
+	}
+
+	/*
+	-----------------------
+	PlaySound()
+	-----------------------
+	*/
+	public int PlaySound( float delaySecs = 0.0f ) {
+		playingIdx = -1;
+
+		if ( !IsValid ) {
+			return playingIdx;
+		}
+
+		// check the random chance to play here to save the function calls
+		if ( ( pctChanceToPlay > 0.99f ) || ( Random.value < pctChanceToPlay ) ) {
+			if ( delay.y > 0.0f ) {
+				delaySecs = Random.Range( delay.x, delay.y );
+			}
+			playingIdx = AudioManager.PlaySound( this, EmitterChannel.Any, delaySecs );
+		}
+
+		return playingIdx;
+	}
+
+	/*
+	-----------------------
+	PlaySoundAt()
+	-----------------------
+	*/
+	public int PlaySoundAt( Vector3 pos, float delaySecs = 0.0f, float volumeOverride = 1.0f, float pitchMultiplier = 1.0f ) {
+		playingIdx = -1;
+
+		if ( !IsValid ) {
+			return playingIdx;
+		}
+
+		// check the random chance to play here to save the function calls
+		if ( ( pctChanceToPlay > 0.99f ) || ( Random.value < pctChanceToPlay ) ) {
+			if ( delay.y > 0.0f ) {
+				delaySecs = Random.Range( delay.x, delay.y );
+			}
+			playingIdx = AudioManager.PlaySoundAt( pos, this, EmitterChannel.Any, delaySecs, volumeOverride, pitchMultiplier );
+		}
+
+		return playingIdx;
+	}
+
+	/*
+	-----------------------
+	SetOnFinished()
+	get a callback when the sound is finished playing
+	-----------------------
+	*/
+	public void SetOnFinished( System.Action onFinished ) {
+		if ( playingIdx > -1 ) {
+			AudioManager.SetOnFinished( playingIdx, onFinished );
+		}
+	}
+
+	/*
+	-----------------------
+	SetOnFinished()
+	get a callback with an object parameter when the sound is finished playing
+	-----------------------
+	*/
+	public void SetOnFinished( System.Action<object> onFinished, object obj ) {
+		if ( playingIdx > -1 ) {
+			AudioManager.SetOnFinished( playingIdx, onFinished, obj );
+		}
+	}
+
+	/*
+	-----------------------
+	StopSound()
+	-----------------------
+	*/
+	public bool StopSound() {
+		bool stopped = false;
+
+		if (playingIdx > -1){
+			stopped = AudioManager.StopSound(playingIdx);
+			playingIdx = -1;
+		}
+
+		return stopped;
+	}
+
+	/*
+	-----------------------
+	AttachToParent()
+	-----------------------
+	*/
+	public void AttachToParent( Transform parent) {
+		if (playingIdx > -1) {
+			AudioManager.AttachSoundToParent(playingIdx, parent);
+		}
+	}
+
+	/*
+	-----------------------
+	DetachFromParent()
+	-----------------------
+	*/
+	public void DetachFromParent() {
+		if (playingIdx > -1) {
+			AudioManager.DetachSoundFromParent(playingIdx);
+		}
+	}
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/SoundFX.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b0a1e5e7b5cff46a187b02100f0e4a3c
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Audio/SoundFXRef.cs

@@ -0,0 +1,144 @@
+using UnityEngine;
+using System.Collections;
+
+namespace OVR
+{
+
+/*
+-----------------------
+SoundFXRef
+just a references to a SoundFX.. all the SoundFX methods are called indirectly from here
+-----------------------
+*/
+[System.Serializable]
+public class SoundFXRef {
+
+	public string			soundFXName = string.Empty;
+
+	private bool			initialized = false;
+	private SoundFX			soundFXCached = null;
+	public SoundFX			soundFX { 
+		get {
+			if ( !initialized ) {
+				Init();
+			}
+			return soundFXCached;
+		}
+	}
+	public string name { get { return soundFXName; } set { soundFXName = value; Init(); } }
+
+	/*
+	-----------------------
+	Init()
+	-----------------------
+	*/
+	void Init() {
+		// look up the actual SoundFX object
+		soundFXCached = AudioManager.FindSoundFX( soundFXName );
+		if ( soundFXCached == null ) {
+			soundFXCached = AudioManager.FindSoundFX( string.Empty );
+		}
+		initialized = true;
+	}
+
+	/*
+	-----------------------
+	Length()
+	-----------------------
+	*/
+	public int 	Length { get { return soundFX.Length; } }
+
+	/*
+	-----------------------
+	IsValid()
+	-----------------------
+	*/
+	public bool IsValid { get { return soundFX.IsValid; } }
+
+	/*
+	-----------------------
+	GetClip()
+	-----------------------
+	*/
+	public AudioClip GetClip() {	
+		return soundFX.GetClip(); 
+	}
+
+	/*
+	-----------------------
+	GetClipLength()
+	-----------------------
+	*/
+	public float GetClipLength( int idx ) {
+		return soundFX.GetClipLength( idx );
+	}
+
+	/*
+	-----------------------
+	PlaySound()
+	-----------------------
+	*/
+	public int PlaySound( float delaySecs = 0.0f ) {
+		return soundFX.PlaySound( delaySecs );
+	}
+	
+	/*
+	-----------------------
+	PlaySoundAt()
+	-----------------------
+	*/
+	public int PlaySoundAt( Vector3 pos, float delaySecs = 0.0f, float volume = 1.0f, float pitchMultiplier = 1.0f ) {
+		return soundFX.PlaySoundAt( pos, delaySecs, volume, pitchMultiplier );
+	}
+
+	/*
+	-----------------------
+	SetOnFinished()
+	get a callback when the sound is finished playing
+	-----------------------
+	*/
+	public void SetOnFinished( System.Action onFinished ) {
+		soundFX.SetOnFinished( onFinished );
+	}
+
+	/*
+	-----------------------
+	SetOnFinished()
+	get a callback with an object parameter when the sound is finished playing
+	-----------------------
+	*/
+	public void SetOnFinished( System.Action<object> onFinished, object obj ) {
+		soundFX.SetOnFinished( onFinished, obj );
+	}
+
+	/*
+	-----------------------
+	StopSound()
+	-----------------------
+	*/
+	public bool StopSound() {
+		return soundFX.StopSound();
+	}
+
+	/*
+	-----------------------
+	AttachToParent()
+	-----------------------
+	*/
+	public void AttachToParent( Transform parent)
+	{
+		soundFX.AttachToParent( parent);
+	}
+
+	/*
+	-----------------------
+	DetachFromParent()
+	-----------------------
+	*/
+	public void DetachFromParent()
+	{
+		soundFX.DetachFromParent();
+	}
+}
+
+} // namespace OVR

Assets/Oculus/AudioManager/Scripts/Audio/SoundFXRef.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 48176edab546a48de9b146105d7c5f47
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Utils.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 02268a883a27b9c4abac4ee978caec4d
+folderAsset: yes
+timeCreated: 1468506022
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Utils/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b43e7f73d4ffc2545a17b938f63e6bc0
+folderAsset: yes
+timeCreated: 1468507225
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Utils/Editor/DrawerInspectorNote.cs

@@ -0,0 +1,77 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+using System.Collections.Generic;
+
+[CustomPropertyDrawer(typeof(InspectorNoteAttribute))]
+public class DrawerInspectorNote : DecoratorDrawer
+{
+	public override void OnGUI( Rect position )
+	{
+		InspectorNoteAttribute note = attribute as InspectorNoteAttribute;
+
+		// our header is always present
+		Rect posLabel = position;
+		posLabel.y += 13;
+		posLabel.x -= 2;
+		posLabel.height += 13;
+		EditorGUI.LabelField(posLabel, note.header, EditorStyles.whiteLargeLabel);
+
+		// do we have a message too?
+		if (!string.IsNullOrEmpty(note.message))
+		{
+			Color color = GUI.color;
+			Color faded = color;
+			faded.a = 0.6f;
+
+			Rect posExplain = posLabel;
+			posExplain.y += 15;
+			GUI.color = faded;
+			EditorGUI.LabelField(posExplain, note.message, EditorStyles.whiteMiniLabel);
+			GUI.color = color;
+		}
+
+		Rect posLine = position;
+		posLine.y += string.IsNullOrEmpty(note.message) ? 30 : 42;
+		posLine.height = 1f;
+		GUI.Box(posLine, "");
+	}
+
+	public override float GetHeight() {
+		InspectorNoteAttribute note = attribute as InspectorNoteAttribute;
+		return string.IsNullOrEmpty( note.message ) ? 38 : 50;
+	}
+}
+
+[CustomPropertyDrawer( typeof( InspectorCommentAttribute ) )]
+public class DrawerInspectorComment : DecoratorDrawer {
+	public override void OnGUI( Rect position ) {
+		InspectorCommentAttribute comment = attribute as InspectorCommentAttribute;
+
+		// our header is always present
+		Rect posLabel = position;
+		//posLabel.y += 13;
+		//posLabel.x -= 2;
+		//posLabel.height += 13;
+		//EditorGUI.LabelField( posLabel, comment.header, EditorStyles.whiteLargeLabel );
+
+		// do we have a message too?
+		if ( !string.IsNullOrEmpty( comment.message ) ) {
+			Color color = GUI.color;
+			Color faded = color;
+			faded.a = 0.6f;
+
+			Rect posExplain = posLabel;
+			posExplain.y += 15;
+			GUI.color = faded;
+			EditorGUI.LabelField( posExplain, comment.message, EditorStyles.whiteMiniLabel );
+			GUI.color = color;
+		}
+
+	}
+
+	public override float GetHeight() {
+		InspectorNoteAttribute note = attribute as InspectorNoteAttribute;
+		return string.IsNullOrEmpty( note.message ) ? 38 : 50;
+	}
+}

Assets/Oculus/AudioManager/Scripts/Utils/Editor/DrawerInspectorNote.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f244e745a5bf8412d9d81d43dff35cf5
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/AudioManager/Scripts/Utils/FastList.cs

@@ -0,0 +1,283 @@
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+public class FastList<T> {
+
+    /// <summary>
+    /// Comparison function should return -1 if left is less than right, 1 if left is greater than right, and 0 if they match.
+    /// </summary>
+    public delegate int CompareFunc(T left, T right);
+
+
+    public T[]      array = null;
+    public int      size = 0;
+
+    public FastList () {
+    }
+
+    public FastList(int size) {
+        if (size > 0) {
+            this.size = 0;
+            array = new T[size];
+        }
+        else {
+            this.size = 0;
+        }
+    }
+
+    public int Count {
+        get { return size;}
+        set { }
+    }
+
+    public T this[int i] {
+        get { return array[i];}
+        set { array[i] = value;}
+    }
+
+    //Add item to end of list.
+    public void Add(T item) {
+        if (array == null || size == array.Length) {
+            Allocate();
+        }
+        array[size] = item;
+        size++;
+    }
+
+	//Add item to end of list if it is unique.
+	public void AddUnique( T item ) {
+		if ( array == null || size == array.Length ) {
+			Allocate();
+		}
+		if ( !Contains( item ) ) {
+			array[size] = item;
+			size++;
+		}
+	}
+
+	//Add items to the end of the list
+	public void AddRange( IEnumerable<T> items ) {
+		foreach ( T item in items ) {
+			Add( item );
+		}
+	}
+
+	//Insert item at specified index
+	public void Insert(int index, T item) {
+        if (array == null || size == array.Length) {
+            Allocate();
+        }
+        if (index < size) {
+            //move things back 1
+            for (int i = size; i > index; i--) {
+                array[i] = array[i-1];
+            }
+            array[index] = item;
+            size++;
+        }
+        else Add(item);
+    }
+
+    //Removes specified item and keeps everything else in order
+    public bool Remove(T item) {
+        if (array != null) {
+            for (int i = 0; i < size; i++) {
+                if (item.Equals(array[i])) { //found it, push everything up
+                    size--;
+                    for (int j = i; j < size; j++) {
+                        array[j] = array[j+1];
+                    }
+                    array[size] = default(T);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    //Removes item at specified index while keeping everything else in order
+    //O(n)
+    public void RemoveAt(int index) {
+        if (array != null && size > 0 && index < size) {
+            size--;
+            for (int i = index; i < size; i++) {
+                array[i] = array[i+1];
+            }
+            array[size] = default(T);
+        }
+    }
+
+    //Removes the specified item from the list and replaces with last item. Return true if removed, false if not found.
+    public bool RemoveFast(T item) {
+        if (array != null) {
+            for (int i = 0; i < size; i++) {
+				if ( item.Equals( array[i] )) { //found
+                    //Move last item here
+                    if (i < (size - 1)) {
+                        T lastItem = array[size-1];
+                        array[size-1] = default(T);
+                        array[i] = lastItem;
+                    } else {
+                        array[i] = default(T);
+                    }
+                    size--;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    //Removes item at specified index and replace with last item.
+    public void RemoveAtFast(int index) {
+        if (array != null && index < size && index >= 0) {
+            //last element
+            if (index == size - 1) {
+                array[index] = default(T);
+            }
+            else {
+                T lastItem = array[size - 1];
+                array[index] = lastItem;
+                array[size - 1] = default(T);
+            }
+            size--;
+
+        }
+    }
+
+    //Return whether an item is contained within the list
+    //O(n)
+    public bool Contains(T item) {
+        if (array == null || size <= 0 ) return false;
+        for (int i = 0; i < size; i++) {
+            if (array[i].Equals(item)) { return true;}
+        }
+        return false;
+    }
+
+    //Returns index of specified item, or -1 if not found.
+    //O(n)
+    public int IndexOf(T item) {
+        if (size <= 0 || array == null) { return -1;}
+        for (int i = 0; i < size; i++) {
+            if (item.Equals(array[i])) { return i;}
+        }
+        return -1;
+    }
+
+    public T Pop() {
+        if (array != null && size > 0) {
+            T lastItem = array[size-1];
+            array[size-1] = default(T);
+            size--;
+            return lastItem;
+        }
+
+        return default(T);
+    }
+
+    public T[] ToArray() {
+        Trim();
+        return array;
+    }
+
+    public void Sort (CompareFunc comparer) {
+        int start = 0;
+        int end = size - 1;
+        bool changed = true;
+
+        while (changed) {
+            changed = false;
+
+            for (int i = start; i < end; i++) {
+
+                if (comparer(array[i], array[i + 1]) > 0) {
+                    T temp = array[i];
+                    array[i] = array[i+1];
+                    array[i+1] = temp;
+                    changed = true;
+                }
+                else if (!changed) {
+                    start = (i==0) ? 0 : i-1;
+                }
+            }
+        }
+    }
+
+    public void InsertionSort(CompareFunc comparer) {
+        for (int i = 1; i < size; i++) {
+            T curr = array[i];
+            int j = i;
+            while (j > 0 && comparer(array[j - 1], curr) > 0) {
+                array[j] = array[j-1];
+                j--;
+            }
+            array[j] = curr;
+        }
+    }
+
+    public IEnumerator<T> GetEnumerator() {
+        if (array != null) {
+            for (int i = 0; i < size; i++) {
+                yield return array[i];
+            }
+        }
+    }
+
+    public T Find(Predicate<T> match) {
+        if (match != null) {
+            if (array != null) {
+                for (int i = 0; i < size; i++) {
+                    if (match(array[i])) { return array[i];}
+                }
+            }
+        }
+        return default(T);
+    }
+    
+    //Allocate more space to internal array. 
+    void Allocate() {
+        T[] newArray;
+        if (array == null) {
+            newArray = new T[32];
+        }
+        else {
+            newArray = new T[Mathf.Max(array.Length << 1, 32)];
+        }
+        if (array != null && size > 0) {
+            array.CopyTo(newArray, 0);
+        }
+
+        array = newArray;
+    }
+
+
+    void Trim() {
+        if (size > 0) {
+            T[] newArray = new T[size];
+            for (int i = 0; i < size; i++) {
+                newArray[i] = array[i];
+            }
+            array = newArray;
+        }
+        else {
+            array = null;
+        }
+    }
+
+    //Set size to 0, does not delete array from memory
+    public void Clear() {
+        size = 0;
+    }
+
+    //Delete array from memory
+    public void Release() {
+        Clear();
+        array = null;
+    }
+
+
+
+}

Assets/Oculus/AudioManager/Scripts/Utils/FastList.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5ad95fb7eea735748bd34c963525ea21
+timeCreated: 1432749689
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/AudioManager/Scripts/Utils/InspectorNoteAttribute.cs

@@ -0,0 +1,35 @@
+using UnityEngine;
+
+/*
+-----------------------
+ 
+ InspectorNoteAttribute()
+ 
+-----------------------
+*/
+public class InspectorNoteAttribute : PropertyAttribute
+{
+	public readonly string header;
+	public readonly string message;
+
+	public InspectorNoteAttribute(string header, string message = "")
+	{
+		this.header = header;
+		this.message = message;
+	}
+}
+
+/*
+-----------------------
+ 
+ InspectorCommentAttribute()
+ 
+-----------------------
+*/
+public class InspectorCommentAttribute : PropertyAttribute {
+	public readonly string message;
+
+	public InspectorCommentAttribute( string message = "" ) {
+		this.message = message;
+	}
+}

Assets/Oculus/AudioManager/Scripts/Utils/InspectorNoteAttribute.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4616bbe65d311471f8d71174295f4986
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/Oculus/OculusProjectConfig.asset

@@ -12,33 +12,9 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 05d394ae2a81edd4cbc3c51917e766e3, type: 3}
   m_Name: OculusProjectConfig
   m_EditorClassIdentifier: 
-  targetDeviceTypes: 0200000003000000
+  targetDeviceTypes: 01000000
-  allowOptional3DofHeadTracking: 0
   handTrackingSupport: 1
-  handTrackingFrequency: 0
+  colorGamut: 0
-  handTrackingVersion: 0
-  anchorSupport: 0
-  sharedAnchorSupport: 0
-  renderModelSupport: 1
-  trackedKeyboardSupport: 0
-  bodyTrackingSupport: 0
-  faceTrackingSupport: 0
-  eyeTrackingSupport: 0
-  virtualKeyboardSupport: 0
-  sceneSupport: 0
   disableBackups: 1
   enableNSCConfig: 1
-  securityXmlPath: 
+  focusAware: 0
-  skipUnneededShaders: 0
-  enableIL2CPPLTO: 0
-  focusAware: 1
-  requiresSystemKeyboard: 0
-  experimentalFeaturesEnabled: 0
-  insightPassthroughEnabled: 0
-  _insightPassthroughSupport: 0
-  _processorFavor: 0
-  systemSplashScreen: {fileID: 0}
-  systemSplashScreenType: 0
-  _systemLoadingScreenBackground: 0
-  ovrPluginMd5Win64: 9622adb0c825689c7a69d4de80ae2f0e24a3bfc356377c3aa62fb9a630d3c134
-  ovrPluginMd5Android: 01d89b6385c0568f3a175449d4370ee0afc4a01c331c333bc3f7cb0614397256

Assets/Oculus/OculusProjectConfig.asset.meta

@@ -2,7 +2,7 @@ fileFormatVersion: 2
 guid: 10ace22946bbe714a9fce09f84fd47b3
 NativeFormatImporter:
   externalObjects: {}
-  mainObjectFileID: 11400000
+  mainObjectFileID: 0
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Assets/Oculus/Platform.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5d96358144d2ac9469bb51ecc2285f27
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4e678f02c24ca7d45add6932bfe529b9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Editor/GUIHelper.cs

@@ -0,0 +1,45 @@
+namespace Oculus.Platform
+{
+  using UnityEditor;
+  using UnityEngine;
+
+  class GUIHelper {
+    public delegate void Worker();
+
+    static void InOut(Worker begin, Worker body, Worker end) {
+      try {
+        begin();
+        body();
+      } finally {
+        end();
+      }
+    }
+
+    public static void HInset(int pixels, Worker worker) {
+      InOut( 
+        () => {
+          GUILayout.BeginHorizontal();
+          GUILayout.Space(pixels);
+          GUILayout.BeginVertical();
+        },
+        worker,
+        () => {
+          GUILayout.EndVertical();
+          GUILayout.EndHorizontal();
+        }
+      );
+    }
+
+    public delegate T ControlWorker<T>();
+    public static T MakeControlWithLabel<T>(GUIContent label, ControlWorker<T> worker) {
+      EditorGUILayout.BeginHorizontal();
+      EditorGUILayout.LabelField(label);
+
+      var result = worker();
+
+      EditorGUILayout.EndHorizontal();
+      return result;
+    }
+  }
+
+}

Assets/Oculus/Platform/Editor/GUIHelper.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 19bb2c637ba6e9c459e3db36b2ec10c3
+timeCreated: 1523486797
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Editor/Oculus.Platform.Editor.asmdef

@@ -0,0 +1,25 @@
+{
+    "name": "Oculus.Platform.Editor",
+    "references": [
+        "Oculus.Platform"
+    ],
+    "optionalUnityReferences": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "versionDefines": [
+        {
+            "name": "com.unity.xr.management",
+            "expression": "",
+            "define": "USING_XR_MANAGEMENT"
+        },
+        {
+            "name": "com.unity.xr.oculus",
+            "expression": "",
+            "define": "USING_XR_SDK_OCULUS"
+        }
+    ]
+}
+

Assets/Oculus/Platform/Editor/Oculus.Platform.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ae177491a94151a4899094505be41938
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Editor/OculusPlatformSettingsEditor.cs

@@ -0,0 +1,450 @@
+#if USING_XR_MANAGEMENT && USING_XR_SDK_OCULUS
+#define USING_XR_SDK
+#endif
+
+namespace Oculus.Platform
+{
+  using System;
+  using System.IO;
+  using UnityEditor;
+  using UnityEngine;
+  using UnityEngine.Networking;
+
+  // This classes implements a UI to edit the PlatformSettings class.
+  // The UI is accessible from a the menu bar via: Oculus Platform -> Edit Settings
+  [CustomEditor(typeof(PlatformSettings))]
+  public class OculusPlatformSettingsEditor : Editor
+  {
+    private bool isUnityEditorSettingsExpanded;
+    private bool isBuildSettingsExpanded;
+
+    private UnityWebRequest getAccessTokenRequest;
+
+    private void OnEnable()
+    {
+      isUnityEditorSettingsExpanded = true;
+      isBuildSettingsExpanded = true;
+    }
+
+    [UnityEditor.MenuItem("Oculus/Platform/Edit Settings")]
+    public static void Edit()
+    {
+      UnityEditor.Selection.activeObject = PlatformSettings.Instance;
+    }
+
+    public override void OnInspectorGUI()
+    {
+      //
+      // Application IDs section
+      //
+      EditorGUILayout.LabelField("Application ID:");
+      GUIContent riftAppIDLabel = new GUIContent("Oculus Rift [?]", "This AppID will be used when building to the Windows target.");
+      GUIContent mobileAppIDLabel = new GUIContent("Oculus Go/Quest or Gear VR [?]", "This AppID will be used when building to the Android target");
+      PlatformSettings.AppID = MakeTextBox(riftAppIDLabel, PlatformSettings.AppID);
+      PlatformSettings.MobileAppID = MakeTextBox(mobileAppIDLabel, PlatformSettings.MobileAppID);
+
+      if (GUILayout.Button("Create / Find your app on https://dashboard.oculus.com"))
+      {
+        UnityEngine.Application.OpenURL("https://dashboard.oculus.com/");
+      }
+
+#if UNITY_ANDROID
+      if (String.IsNullOrEmpty(PlatformSettings.MobileAppID))
+      {
+        EditorGUILayout.HelpBox("Please enter a valid Oculus Go/Quest or Gear VR App ID.", MessageType.Error);
+      }
+      else
+      {
+        var msg = "Configured to connect with App ID " + PlatformSettings.MobileAppID;
+        EditorGUILayout.HelpBox(msg, MessageType.Info);
+      }
+#else
+      if (String.IsNullOrEmpty(PlatformSettings.AppID))
+      {
+        EditorGUILayout.HelpBox("Please enter a valid Oculus Rift App ID.", MessageType.Error);
+      }
+      else
+      {
+        var msg = "Configured to connect with App ID " + PlatformSettings.AppID;
+        EditorGUILayout.HelpBox(msg, MessageType.Info);
+      }
+#endif
+      EditorGUILayout.Separator();
+
+      //
+      // Unity Editor Settings section
+      //
+      isUnityEditorSettingsExpanded = EditorGUILayout.Foldout(isUnityEditorSettingsExpanded, "Unity Editor Settings");
+      if (isUnityEditorSettingsExpanded)
+      {
+        GUIHelper.HInset(6, () =>
+        {
+          bool HasTestAccessToken = !String.IsNullOrEmpty(StandalonePlatformSettings.OculusPlatformTestUserAccessToken);
+          if (PlatformSettings.UseStandalonePlatform)
+          {
+            if (!HasTestAccessToken &&
+            (String.IsNullOrEmpty(StandalonePlatformSettings.OculusPlatformTestUserEmail) ||
+            String.IsNullOrEmpty(StandalonePlatformSettings.OculusPlatformTestUserPassword)))
+            {
+              EditorGUILayout.HelpBox("Please enter a valid user credentials.", MessageType.Error);
+            }
+            else
+            {
+              var msg = "The Unity editor will use the supplied test user credentials and operate in standalone mode.  Some user data will be mocked.";
+              EditorGUILayout.HelpBox(msg, MessageType.Info);
+            }
+          }
+          else
+          {
+            var msg = "The Unity editor will use the user credentials from the Oculus application.";
+            EditorGUILayout.HelpBox(msg, MessageType.Info);
+          }
+
+          var useStandaloneLabel = "Use Standalone Platform [?]";
+          var useStandaloneHint = "If this is checked your app will use a debug platform with the User info below.  "
+            + "Otherwise your app will connect to the Oculus Platform.  This setting only applies to the Unity Editor";
+          PlatformSettings.UseStandalonePlatform =
+            MakeToggle(new GUIContent(useStandaloneLabel, useStandaloneHint), PlatformSettings.UseStandalonePlatform);
+
+          GUI.enabled = PlatformSettings.UseStandalonePlatform;
+
+          if (!HasTestAccessToken)
+          {
+            var emailLabel = "Test User Email: ";
+            var emailHint = "Test users can be configured at " +
+              "https://dashboard.oculus.com/organizations/<your org ID>/testusers " +
+              "however any valid Oculus account email may be used.";
+            StandalonePlatformSettings.OculusPlatformTestUserEmail =
+              MakeTextBox(new GUIContent(emailLabel, emailHint), StandalonePlatformSettings.OculusPlatformTestUserEmail);
+
+            var passwdLabel = "Test User Password: ";
+            var passwdHint = "Password associated with the email address.";
+            StandalonePlatformSettings.OculusPlatformTestUserPassword =
+              MakePasswordBox(new GUIContent(passwdLabel, passwdHint), StandalonePlatformSettings.OculusPlatformTestUserPassword);
+
+            var isLoggingIn = (getAccessTokenRequest != null);
+            var loginLabel = (!isLoggingIn) ? "Login" : "Logging in...";
+
+            GUI.enabled = !isLoggingIn;
+            if (GUILayout.Button(loginLabel))
+            {
+              WWWForm form = new WWWForm();
+              form.AddField("email", StandalonePlatformSettings.OculusPlatformTestUserEmail);
+              form.AddField("password", StandalonePlatformSettings.OculusPlatformTestUserPassword);
+
+              // Start the WWW request to get the access token
+              getAccessTokenRequest = UnityWebRequest.Post("https://graph.oculus.com/login", form);
+              getAccessTokenRequest.SetRequestHeader("Authorization", "Bearer OC|1141595335965881|");
+              getAccessTokenRequest.SendWebRequest();
+              EditorApplication.update += GetAccessToken;
+            }
+            GUI.enabled = true;
+          }
+          else
+          {
+            var loggedInMsg = "Currently using the credentials associated with " + StandalonePlatformSettings.OculusPlatformTestUserEmail;
+            EditorGUILayout.HelpBox(loggedInMsg, MessageType.Info);
+
+            var logoutLabel = "Clear Credentials";
+
+            if (GUILayout.Button(logoutLabel))
+            {
+              StandalonePlatformSettings.OculusPlatformTestUserAccessToken = "";
+            }
+          }
+
+          GUI.enabled = true;
+        });
+      }
+      EditorGUILayout.Separator();
+
+      //
+      // Build Settings section
+      //
+      isBuildSettingsExpanded = EditorGUILayout.Foldout(isBuildSettingsExpanded, "Build Settings");
+      if (isBuildSettingsExpanded)
+      {
+        GUIHelper.HInset(6, () => {
+#if !USING_XR_SDK
+#if UNITY_2020_1_OR_NEWER
+          EditorGUILayout.HelpBox("The Oculus XR Plugin isn't enabled from XR Plugin Management in Project Settings", MessageType.Warning);
+#else
+          if (!PlayerSettings.virtualRealitySupported)
+          {
+            EditorGUILayout.HelpBox("VR Support isn't enabled in the Player Settings", MessageType.Warning);
+          }
+
+          PlayerSettings.virtualRealitySupported = MakeToggle(new GUIContent("Virtual Reality Support"), PlayerSettings.virtualRealitySupported);
+#endif
+#endif
+
+          PlayerSettings.bundleVersion = MakeTextBox(new GUIContent("Bundle Version"), PlayerSettings.bundleVersion);
+#if UNITY_5_3 || UNITY_5_4 || UNITY_5_5
+          PlayerSettings.bundleIdentifier = MakeTextBox(new GUIContent("Bundle Identifier"), PlayerSettings.bundleIdentifier);
+#else
+          BuildTargetGroup buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
+          PlayerSettings.SetApplicationIdentifier(
+            buildTargetGroup,
+            MakeTextBox(
+              new GUIContent("Bundle Identifier"),
+              PlayerSettings.GetApplicationIdentifier(buildTargetGroup)));
+#endif
+          bool canEnableARM64Support = false;
+#if UNITY_2018_1_OR_NEWER
+          canEnableARM64Support = true;
+#endif
+          if (!canEnableARM64Support)
+          {
+            var msg = "Update your Unity Editor to 2018.1.x or newer to enable Arm64 support";
+            EditorGUILayout.HelpBox(msg, MessageType.Warning);
+            if (IsArm64PluginPlatformEnabled())
+            {
+              DisablePluginPlatform(PluginPlatform.Android64);
+            }
+          }
+          else
+          {
+            if (!IsArm64PluginPlatformEnabled())
+            {
+              EnablePluginPlatform(PluginPlatform.Android64);
+            }
+          }
+
+          GUI.enabled = true;
+        });
+      }
+      EditorGUILayout.Separator();
+    }
+
+    // Asyncronously fetch the access token with the given credentials
+    private void GetAccessToken()
+    {
+      if (getAccessTokenRequest != null && getAccessTokenRequest.isDone)
+      {
+        // Clear the password
+        StandalonePlatformSettings.OculusPlatformTestUserPassword = "";
+
+        if (String.IsNullOrEmpty(getAccessTokenRequest.error))
+        {
+          var Response = JsonUtility.FromJson<OculusStandalonePlatformResponse>(getAccessTokenRequest.downloadHandler.text);
+          StandalonePlatformSettings.OculusPlatformTestUserAccessToken = Response.access_token;
+        }
+
+        GUI.changed = true;
+        EditorApplication.update -= GetAccessToken;
+        getAccessTokenRequest.Dispose();
+        getAccessTokenRequest = null;
+      }
+    }
+
+    private string MakeTextBox(GUIContent label, string variable)
+    {
+      return GUIHelper.MakeControlWithLabel(label, () => {
+        GUI.changed = false;
+        var result = EditorGUILayout.TextField(variable);
+        SetDirtyOnGUIChange();
+        return result;
+      });
+    }
+
+    private string MakePasswordBox(GUIContent label, string variable)
+    {
+      return GUIHelper.MakeControlWithLabel(label, () => {
+        GUI.changed = false;
+        var result = EditorGUILayout.PasswordField(variable);
+        SetDirtyOnGUIChange();
+        return result;
+      });
+    }
+
+    private bool MakeToggle(GUIContent label, bool variable)
+    {
+      return GUIHelper.MakeControlWithLabel(label, () => {
+        GUI.changed = false;
+        var result = EditorGUILayout.Toggle(variable);
+        SetDirtyOnGUIChange();
+        return result;
+      });
+    }
+
+    private void SetDirtyOnGUIChange()
+    {
+      if (GUI.changed)
+      {
+        EditorUtility.SetDirty(PlatformSettings.Instance);
+        GUI.changed = false;
+      }
+    }
+
+    // TODO: Merge this with core utilities plugin updater functionality. Piggybacking here to avoid an orphaned delete in the future.
+    private const string PluginSubPathAndroid32 = @"/Plugins/Android32/libovrplatformloader.so";
+    private const string PluginSubPathAndroid64 = @"/Plugins/Android64/libovrplatformloader.so";
+    private const string PluginDisabledSuffix = @".disabled";
+
+    public enum PluginPlatform
+    {
+      Android32,
+      Android64
+    }
+
+    private static string GetCurrentProjectPath()
+    {
+      return Directory.GetParent(UnityEngine.Application.dataPath).FullName;
+    }
+
+    private static string GetPlatformRootPath()
+    {
+      // use the path to OculusPluginUpdaterStub as a relative path anchor point
+      var so = ScriptableObject.CreateInstance(typeof(OculusPluginUpdaterStub));
+      var script = MonoScript.FromScriptableObject(so);
+      string assetPath = AssetDatabase.GetAssetPath(script);
+      string editorDir = Directory.GetParent(assetPath).FullName;
+      string platformDir = Directory.GetParent(editorDir).FullName;
+
+      return platformDir;
+    }
+
+    private static string GetPlatformPluginPath(PluginPlatform platform)
+    {
+      string path = GetPlatformRootPath();
+      switch (platform)
+      {
+        case PluginPlatform.Android32:
+          path += PluginSubPathAndroid32;
+          break;
+        case PluginPlatform.Android64:
+          path += PluginSubPathAndroid64;
+          break;
+        default:
+          throw new ArgumentException("Attempted to enable platform support for unsupported platform: " + platform);
+      }
+
+      return path;
+    }
+
+    //[UnityEditor.MenuItem("Oculus/Platform/EnforcePluginPlatformSettings")]
+    public static void EnforcePluginPlatformSettings()
+    {
+      EnforcePluginPlatformSettings(PluginPlatform.Android32);
+      EnforcePluginPlatformSettings(PluginPlatform.Android64);
+    }
+
+    public static void EnforcePluginPlatformSettings(PluginPlatform platform)
+    {
+      string path = GetPlatformPluginPath(platform);
+
+      if (!Directory.Exists(path) && !File.Exists(path))
+      {
+        path += PluginDisabledSuffix;
+      }
+
+      if ((Directory.Exists(path)) || (File.Exists(path)))
+      {
+        string basePath = GetCurrentProjectPath();
+        string relPath = path.Substring(basePath.Length + 1);
+
+        PluginImporter pi = PluginImporter.GetAtPath(relPath) as PluginImporter;
+        if (pi == null)
+        {
+          return;
+        }
+
+        // Disable support for all platforms, then conditionally enable desired support below
+        pi.SetCompatibleWithEditor(false);
+        pi.SetCompatibleWithAnyPlatform(false);
+        pi.SetCompatibleWithPlatform(BuildTarget.Android, false);
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
+#if !UNITY_2019_2_OR_NEWER
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
+#endif
+#if UNITY_2017_3_OR_NEWER
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
+#else
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
+        pi.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
+#endif
+
+        switch (platform)
+        {
+          case PluginPlatform.Android32:
+            pi.SetCompatibleWithPlatform(BuildTarget.Android, true);
+            pi.SetPlatformData(BuildTarget.Android, "CPU", "ARMv7");
+            break;
+          case PluginPlatform.Android64:
+            pi.SetCompatibleWithPlatform(BuildTarget.Android, true);
+            pi.SetPlatformData(BuildTarget.Android, "CPU", "ARM64");
+            break;
+          default:
+            throw new ArgumentException("Attempted to enable platform support for unsupported platform: " + platform);
+        }
+
+        AssetDatabase.ImportAsset(relPath, ImportAssetOptions.ForceUpdate);
+        AssetDatabase.SaveAssets();
+        AssetDatabase.Refresh();
+        AssetDatabase.SaveAssets();
+      }
+    }
+
+    public static bool IsArm64PluginPlatformEnabled()
+    {
+      string path = GetPlatformPluginPath(PluginPlatform.Android64);
+      bool pathAlreadyExists = Directory.Exists(path) || File.Exists(path);
+      return pathAlreadyExists;
+    }
+
+    public static void EnablePluginPlatform(PluginPlatform platform)
+    {
+      string path = GetPlatformPluginPath(platform);
+      string disabledPath = path + PluginDisabledSuffix;
+
+      bool pathAlreadyExists = Directory.Exists(path) || File.Exists(path);
+      bool disabledPathDoesNotExist = !Directory.Exists(disabledPath) && !File.Exists(disabledPath);
+
+      if (pathAlreadyExists || disabledPathDoesNotExist)
+      {
+        return;
+      }
+
+      string basePath = GetCurrentProjectPath();
+      string relPath = path.Substring(basePath.Length + 1);
+      string relDisabledPath = relPath + PluginDisabledSuffix;
+
+      AssetDatabase.MoveAsset(relDisabledPath, relPath);
+      AssetDatabase.ImportAsset(relPath, ImportAssetOptions.ForceUpdate);
+      AssetDatabase.SaveAssets();
+      AssetDatabase.Refresh();
+      AssetDatabase.SaveAssets();
+
+      // Force reserialization of platform settings meta data
+      EnforcePluginPlatformSettings(platform);
+    }
+
+    public static void DisablePluginPlatform(PluginPlatform platform)
+    {
+      string path = GetPlatformPluginPath(platform);
+      string disabledPath = path + PluginDisabledSuffix;
+
+      bool pathDoesNotExist = !Directory.Exists(path) && !File.Exists(path);
+      bool disabledPathAlreadyExists = Directory.Exists(disabledPath) || File.Exists(disabledPath);
+
+      if (pathDoesNotExist || disabledPathAlreadyExists)
+      {
+        return;
+      }
+
+      string basePath = GetCurrentProjectPath();
+      string relPath = path.Substring(basePath.Length + 1);
+      string relDisabledPath = relPath + PluginDisabledSuffix;
+
+      AssetDatabase.MoveAsset(relPath, relDisabledPath);
+      AssetDatabase.ImportAsset(relDisabledPath, ImportAssetOptions.ForceUpdate);
+      AssetDatabase.SaveAssets();
+      AssetDatabase.Refresh();
+      AssetDatabase.SaveAssets();
+    }
+  }
+}

Assets/Oculus/Platform/Editor/OculusPlatformSettingsEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 03780432f190e734dba71a2337880cdb
+timeCreated: 1523486796
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Editor/OculusPluginUpdaterStub.cs

@@ -0,0 +1,30 @@
+/************************************************************************************
+
+Copyright   :   Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Licensed under the Oculus SDK License Version 3.4.1 (the "License");
+you may not use the Oculus SDK except in compliance with the License,
+which is provided at the time of installation or download, or which
+otherwise accompanies this software in either electronic or hard copy form.
+
+You may obtain a copy of the License at
+
+https://developer.oculus.com/licenses/sdk-3.4.1
+
+Unless required by applicable law or agreed to in writing, the Oculus SDK
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+using UnityEngine;
+using System.Collections;
+
+public class OculusPluginUpdaterStub : ScriptableObject
+{
+	// Stub helper class to locate script paths through Unity Editor API.
+	// Required to be a standalone class in a separate file or else MonoScript.FromScriptableObject() returns an empty string path.
+}
+

Assets/Oculus/Platform/Editor/OculusPluginUpdaterStub.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: af1b0142a3500574289a5ff8ae25dfa4
+timeCreated: 1543975087
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Editor/OculusStandalonePlatformResponse.cs

@@ -0,0 +1,10 @@
+namespace Oculus.Platform
+{
+  using System;
+
+  [Serializable]
+  public sealed class OculusStandalonePlatformResponse
+  {
+    public string access_token;
+  }
+}

Assets/Oculus/Platform/Editor/OculusStandalonePlatformResponse.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 81f0418e197774a4e8d643b56923cb90
+timeCreated: 1523486799
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Oculus.Platform.asmdef

@@ -0,0 +1,20 @@
+{
+    "name": "Oculus.Platform",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "versionDefines": [
+        {
+            "name": "com.unity.xr.management",
+            "expression": "",
+            "define": "USING_XR_MANAGEMENT"
+        },
+        {
+            "name": "com.unity.xr.oculus",
+            "expression": "",
+            "define": "USING_XR_SDK_OCULUS"
+        }
+    ]
+}

Assets/Oculus/Platform/Oculus.Platform.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8c01d52dc9e9c7c41b509ed43aa1d098
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4ceb3cc2da1c38048ba9123f908c33f9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/Android32.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d16a4c02095db1245a50b1de0d5bcdf6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/Android32/libovrplatformloader.so.meta

@@ -0,0 +1,30 @@
+fileFormatVersion: 2
+guid: 18fb0e7057360374fa820eece0d5d112
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  isOverridable: 0
+  platformData:
+  - first:
+      Android: Android
+    second:
+      enabled: 1
+      settings:
+        CPU: ARMv7
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/Android64.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 724a505b68ecac443bc477eeb986e34f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/Android64/libovrplatformloader.so.meta

@@ -0,0 +1,30 @@
+fileFormatVersion: 2
+guid: 456b08f21cd27084d92a877dbf2b9ee5
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  isOverridable: 0
+  platformData:
+  - first:
+      Android: Android
+    second:
+      enabled: 1
+      settings:
+        CPU: ARM64
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 68570290d524957498dd0da9b1d2dc6c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle.meta

@@ -0,0 +1,40 @@
+fileFormatVersion: 2
+guid: 8510295b7cdee6f42ab455bd44554d03
+folderAsset: yes
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  isOverridable: 0
+  platformData:
+  - first:
+      '': OSXIntel
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      '': OSXIntel64
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a3737aca096834747a7d6edc4d3cda30
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/Info.plist.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: eddc37f131931d64a862552274d9cf4f
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/MacOS.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9a31a6f920e4fad41a4699114f8da5dd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/MacOS/ovrplatform.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 6547d763bf83228429a4d12428194804
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/PkgInfo

@@ -0,0 +1 @@
+APPLWRUN

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/PkgInfo.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 14f341254c04db042bf0039bf9a08821
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/Resources.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cada87648ac58ca4dbc5b97959e6e149
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/Resources/darwin-x86_64.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 792761b2e0b935a4fbf41b0b0daff5ab
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/Resources/darwin-x86_64/liboculus_p2p.dylib.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d0c0677176bd3cb4c92d3da1c0c50508
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/_CodeSignature.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ad8545c7084eea840a0d2dbb015e9e70
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/_CodeSignature/CodeResources

@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>files</key>
+	<dict>
+		<key>Resources/darwin-x86_64/liboculus_p2p.dylib</key>
+		<data>
+		JKNLD2GjErCVA+jyjwiOflKeNFE=
+		</data>
+	</dict>
+	<key>files2</key>
+	<dict>
+		<key>Resources/darwin-x86_64/liboculus_p2p.dylib</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			0Dix3PTkS51fqcK03xNszglO51JTVoPTad1LpFlSEzA=
+			</data>
+		</dict>
+	</dict>
+	<key>rules</key>
+	<dict>
+		<key>^Resources/</key>
+		<true/>
+		<key>^Resources/.*\.lproj/</key>
+		<dict>
+			<key>optional</key>
+			<true/>
+			<key>weight</key>
+			<real>1000</real>
+		</dict>
+		<key>^Resources/.*\.lproj/locversion.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>1100</real>
+		</dict>
+		<key>^Resources/Base\.lproj/</key>
+		<dict>
+			<key>weight</key>
+			<real>1010</real>
+		</dict>
+		<key>^version.plist$</key>
+		<true/>
+	</dict>
+	<key>rules2</key>
+	<dict>
+		<key>.*\.dSYM($|/)</key>
+		<dict>
+			<key>weight</key>
+			<real>11</real>
+		</dict>
+		<key>^(.*/)?\.DS_Store$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>2000</real>
+		</dict>
+		<key>^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/</key>
+		<dict>
+			<key>nested</key>
+			<true/>
+			<key>weight</key>
+			<real>10</real>
+		</dict>
+		<key>^.*</key>
+		<true/>
+		<key>^Info\.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^PkgInfo$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^Resources/</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^Resources/.*\.lproj/</key>
+		<dict>
+			<key>optional</key>
+			<true/>
+			<key>weight</key>
+			<real>1000</real>
+		</dict>
+		<key>^Resources/.*\.lproj/locversion.plist$</key>
+		<dict>
+			<key>omit</key>
+			<true/>
+			<key>weight</key>
+			<real>1100</real>
+		</dict>
+		<key>^Resources/Base\.lproj/</key>
+		<dict>
+			<key>weight</key>
+			<real>1010</real>
+		</dict>
+		<key>^[^/]+$</key>
+		<dict>
+			<key>nested</key>
+			<true/>
+			<key>weight</key>
+			<real>10</real>
+		</dict>
+		<key>^embedded\.provisionprofile$</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+		<key>^version\.plist$</key>
+		<dict>
+			<key>weight</key>
+			<real>20</real>
+		</dict>
+	</dict>
+</dict>
+</plist>

Assets/Oculus/Platform/Plugins/MacOSX/ovrplatform.bundle/Contents/_CodeSignature/CodeResources.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 0431403efe8137c4d88bcef2b0c6e0d8
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 410f24c4266efe34985820a13cac86ce
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Scripts/AbuseReportOptions.cs

@@ -0,0 +1,37 @@
+// This file was @generated with LibOVRPlatform/codegen/main. Do not modify it!
+
+namespace Oculus.Platform
+{
+  using System;
+  using System.Collections;
+  using Oculus.Platform.Models;
+  using System.Collections.Generic;
+  using UnityEngine;
+
+  public class AbuseReportOptions {
+
+    public AbuseReportOptions() {
+      Handle = CAPI.ovr_AbuseReportOptions_Create();
+    }
+
+    public void SetPreventPeopleChooser(bool value) {
+      CAPI.ovr_AbuseReportOptions_SetPreventPeopleChooser(Handle, value);
+    }
+
+    public void SetReportType(AbuseReportType value) {
+      CAPI.ovr_AbuseReportOptions_SetReportType(Handle, value);
+    }
+
+
+    // For passing to native C
+    public static explicit operator IntPtr(AbuseReportOptions options) {
+      return options != null ? options.Handle : IntPtr.Zero;
+    }
+
+    ~AbuseReportOptions() {
+      CAPI.ovr_AbuseReportOptions_Destroy(Handle);
+    }
+
+    IntPtr Handle;
+  }
+}

Assets/Oculus/Platform/Scripts/AbuseReportOptions.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0645da8344fc475469d13a6494437f8e
+timeCreated: 1533910660
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Scripts/AbuseReportType.cs

@@ -0,0 +1,21 @@
+// This file was @generated with LibOVRPlatform/codegen/main. Do not modify it!
+
+namespace Oculus.Platform
+{
+
+  using Description = System.ComponentModel.DescriptionAttribute;
+
+  public enum AbuseReportType : int
+  {
+    [Description("UNKNOWN")]
+    Unknown,
+
+    [Description("OBJECT")]
+    Object,
+
+    [Description("USER")]
+    User,
+
+  }
+
+}

Assets/Oculus/Platform/Scripts/AbuseReportType.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c69cf9c4f527f9e4a8dc49125afacc7b
+timeCreated: 1533910663
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Scripts/AchievementType.cs

@@ -0,0 +1,24 @@
+// This file was @generated with LibOVRPlatform/codegen/main. Do not modify it!
+
+namespace Oculus.Platform
+{
+
+  using Description = System.ComponentModel.DescriptionAttribute;
+
+  public enum AchievementType : int
+  {
+    [Description("UNKNOWN")]
+    Unknown,
+
+    [Description("SIMPLE")]
+    Simple,
+
+    [Description("BITFIELD")]
+    Bitfield,
+
+    [Description("COUNT")]
+    Count,
+
+  }
+
+}

Assets/Oculus/Platform/Scripts/AchievementType.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 42d96355ad5dd4b4eab18452dbd62fa7
+timeCreated: 1523486798
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Scripts/AndroidPlatform.cs

@@ -0,0 +1,35 @@
+namespace Oculus.Platform
+{
+  using UnityEngine;
+  using System.Collections;
+  using System;
+
+  public class AndroidPlatform
+  {
+    public bool Initialize(string appId)
+    {
+#if UNITY_ANDROID
+      if(String.IsNullOrEmpty(appId))
+      {
+        throw new UnityException("AppID must not be null or empty");
+      }
+      return CAPI.ovr_UnityInitWrapper(appId);
+#else
+      return false;
+#endif
+    }
+
+    public Request<Models.PlatformInitialize> AsyncInitialize(string appId)
+    {
+#if UNITY_ANDROID
+      if(String.IsNullOrEmpty(appId))
+      {
+        throw new UnityException("AppID must not be null or empty");
+      }
+      return new Request<Models.PlatformInitialize>(CAPI.ovr_UnityInitWrapperAsynchronous(appId));
+#else
+      return new Request<Models.PlatformInitialize>(0);
+#endif
+    }
+  }
+}

Assets/Oculus/Platform/Scripts/AndroidPlatform.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7293b4a3c3806ad448e3b421baf984b1
+timeCreated: 1523486799
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Platform/Scripts/ApplicationOptions.cs

@@ -0,0 +1,33 @@
+// This file was @generated with LibOVRPlatform/codegen/main. Do not modify it!
+
+namespace Oculus.Platform
+{
+  using System;
+  using System.Collections;
+  using Oculus.Platform.Models;
+  using System.Collections.Generic;
+  using UnityEngine;
+
+  public class ApplicationOptions {
+
+    public ApplicationOptions() {
+      Handle = CAPI.ovr_ApplicationOptions_Create();
+    }
+
+    public void SetDeeplinkMessage(string value) {
+      CAPI.ovr_ApplicationOptions_SetDeeplinkMessage(Handle, value);
+    }
+
+
+    // For passing to native C
+    public static explicit operator IntPtr(ApplicationOptions options) {
+      return options != null ? options.Handle : IntPtr.Zero;
+    }
+
+    ~ApplicationOptions() {
+      CAPI.ovr_ApplicationOptions_Destroy(Handle);
+    }
+
+    IntPtr Handle;
+  }
+}

Assets/Oculus/Platform/Scripts/ApplicationOptions.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d089d8a70f920a5469fca1917d5e5122
+timeCreated: 1523486800
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: