AudioClip exposed to managed code

Source/BansheeCore/Include/BsAudioClip.h

@@ -70,7 +70,7 @@ namespace BansheeEngine
 
 	/** 
 	 * Audio clip stores audio data in a compressed or uncompressed format. Clips can be provided to audio sources or
-	 * or other audio methods to be played.
+	 * other audio methods to be played.
 	 */
 	class BS_CORE_EXPORT AudioClip : public Resource
 	{

Source/BansheeCore/Include/BsAudioClipImportOptions.h

@@ -43,7 +43,7 @@ namespace BansheeEngine
 		/** Sets the size of a single sample in bits. The clip will be converted to this bit depth on import. */
 		void setBitDepth(UINT32 bitDepth) { mBitDepth = bitDepth; }
 
-		// Note: Add options to resample to a different frequency, reduce/increase bit depth
+		// Note: Add options to resample to a different frequency
 
 	private:
 		AudioFormat mFormat = AudioFormat::PCM;

Source/BansheeCore/Include/BsCorePrerequisites.h

@@ -350,6 +350,7 @@ namespace BansheeEngine
 	class ShaderImportOptions;
 	class AudioListener;
 	class AudioSource;
+	class AudioClipImportOptions;
 	// Asset import
 	class SpecificImporter;
 	class Importer;

Source/MBansheeEditor/Inspectors/AudioClipInspector.cs

@@ -0,0 +1,110 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    /** @addtogroup Inspectors
+     *  @{
+     */
+
+    /// <summary>
+    /// Renders an inspector for the <see cref="AudioClip"/> resource.
+    /// </summary>
+    [CustomInspector(typeof(AudioClip))]
+    internal class AudioClipInspector : Inspector
+    {
+        private GUIEnumField formatField = new GUIEnumField(typeof(AudioFormat), new LocEdString("Format"));
+        private GUIEnumField readModeField = new GUIEnumField(typeof(AudioReadMode), new LocEdString("Read mode"));
+        private GUIEnumField bitDepthField = new GUIEnumField(typeof(AudioBitDepth), new LocEdString("Bit depth"));
+        private GUIToggleField is3DField = new GUIToggleField(new LocEdString("3D"));
+        
+        private GUIButton reimportButton = new GUIButton(new LocEdString("Reimport"));
+
+        private AudioClipImportOptions importOptions;
+
+        /// <inheritdoc/>
+        protected internal override void Initialize()
+        {
+            if (InspectedObject != null)
+            {
+                importOptions = GetImportOptions();
+
+                formatField.OnSelectionChanged += x => importOptions.Format = (AudioFormat)x;
+                readModeField.OnSelectionChanged += x => importOptions.ReadMode = (AudioReadMode)x;
+                bitDepthField.OnSelectionChanged += x => importOptions.BitDepth = (AudioBitDepth)x;
+                is3DField.OnChanged += x => importOptions.Is3D = x;
+                
+                reimportButton.OnClick += TriggerReimport;
+
+                Layout.AddElement(formatField);
+                Layout.AddElement(readModeField);
+                Layout.AddElement(bitDepthField);
+                Layout.AddElement(is3DField);
+                Layout.AddSpace(10);
+
+                GUILayout reimportButtonLayout = Layout.AddLayoutX();
+                reimportButtonLayout.AddFlexibleSpace();
+                reimportButtonLayout.AddElement(reimportButton);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected internal override InspectableState Refresh()
+        {
+            AudioClipImportOptions newImportOptions = GetImportOptions();
+
+            formatField.Value = (ulong)newImportOptions.Format;
+            readModeField.Value = (ulong)newImportOptions.ReadMode;
+            bitDepthField.Value = (ulong)newImportOptions.BitDepth;
+            is3DField.Value = newImportOptions.Is3D;
+
+            importOptions = newImportOptions;
+
+            return InspectableState.NotModified;
+        }
+
+        /// <summary>
+        /// Retrieves import options for the audio clip we're currently inspecting.
+        /// </summary>
+        /// <returns>Audio clip import options object.</returns>
+        private AudioClipImportOptions GetImportOptions()
+        {
+            AudioClip audioClip = InspectedObject as AudioClip;
+            AudioClipImportOptions output = null;
+
+            if (audioClip != null)
+            {
+                LibraryEntry meshEntry = ProjectLibrary.GetEntry(ProjectLibrary.GetPath(audioClip));
+                if (meshEntry != null && meshEntry.Type == LibraryEntryType.File)
+                {
+                    FileEntry meshFileEntry = (FileEntry)meshEntry;
+                    output = meshFileEntry.Options as AudioClipImportOptions;
+                }
+            }
+
+            if (output == null)
+            {
+                if (importOptions == null)
+                    output = new AudioClipImportOptions();
+                else
+                    output = importOptions;
+            }
+
+            return output;
+        }
+
+        /// <summary>
+        /// Reimports the resource according to the currently set import options.
+        /// </summary>
+        private void TriggerReimport()
+        {
+            AudioClip audioClip = (AudioClip)InspectedObject;
+            string resourcePath = ProjectLibrary.GetPath(audioClip);
+
+            ProjectLibrary.Reimport(resourcePath, importOptions, true);
+        }
+    }
+
+    /** @} */
+}

Source/MBansheeEditor/Inspectors/MeshInspector.cs

@@ -112,7 +112,7 @@ namespace BansheeEditor
         }
 
         /// <summary>
-        /// Reimports the texture resource according to the currently set import options.
+        /// Reimports the resource according to the currently set import options.
         /// </summary>
         private void TriggerReimport()
         {

Source/MBansheeEditor/MBansheeEditor.csproj

@@ -40,6 +40,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Inspectors\AudioClipInspector.cs" />
     <Compile Include="Inspectors\PostProcessSettingsInspector.cs" />
     <Compile Include="Windows\AboutBox.cs" />
     <Compile Include="Windows\BrowseDialog.cs" />

Source/MBansheeEditor/Windows/Library/ImportOptions.cs

@@ -420,7 +420,101 @@ namespace BansheeEditor
 		HintedSmooth,
         /// <summary>Render non-antialiased fonts with hinting.</summary>
 		HintedRaster
-	};
+	}
+
+    /// <summary>
+    /// Provides various options for controlling how is an audio clip file imported.
+    /// </summary>
+    public class AudioClipImportOptions : ImportOptions
+    {
+        /// <summary>
+        /// Creates new audio clip import options with default values.
+        /// </summary>
+        public AudioClipImportOptions()
+        {
+            Internal_CreateInstance(this);
+        }
+
+        /// <summary>
+        /// Format to import the audio clip as.
+        /// </summary>
+        public AudioFormat Format
+        {
+            get { return Internal_GetFormat(mCachedPtr); }
+            set { Internal_SetFormat(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Determines how is audio data loaded into memory.
+        /// </summary>
+        public AudioReadMode ReadMode
+        {
+            get { return Internal_GetReadMode(mCachedPtr); }
+            set { Internal_SetReadMode(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Determines will the clip be played as spatial (3D) audio or as normal audio.
+        /// </summary>
+        public bool Is3D
+        {
+            get { return Internal_GetIs3D(mCachedPtr); }
+            set { Internal_SetIs3D(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Size of a single sample in bits.
+        /// </summary>
+        public AudioBitDepth BitDepth
+        {
+            get
+            {
+                int bits = Internal_GetBitDepth(mCachedPtr);
+                switch (bits)
+                {
+                    case 8:
+                        return AudioBitDepth.Bits8;
+                    case 16:
+                        return AudioBitDepth.Bits16;
+                    case 24:
+                        return AudioBitDepth.Bits24;
+                    case 32:
+                        return AudioBitDepth.Bits32;
+                }
+
+                return AudioBitDepth.Bits16;
+            }
+
+            set { Internal_SetBitDepth(mCachedPtr, (int)value); }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(AudioClipImportOptions instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern AudioFormat Internal_GetFormat(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetFormat(IntPtr thisPtr, AudioFormat format);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern AudioReadMode Internal_GetReadMode(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetReadMode(IntPtr thisPtr, AudioReadMode readMode);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetIs3D(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetIs3D(IntPtr thisPtr, bool is3d);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetBitDepth(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetBitDepth(IntPtr thisPtr, int bitDepth);
+    }
 
     /** @} */
 }

Source/MBansheeEngine/Audio/AudioClip.cs

@@ -0,0 +1,158 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+using System;
+using System.Runtime.CompilerServices;
+
+namespace BansheeEngine
+{
+    /** @addtogroup Audio
+     *  @{
+     */
+
+    /// <summary>
+    /// Valid internal engine audio formats.
+    /// </summary>
+    public enum AudioFormat // Note: Must match C++ enum AudioFormat
+    {
+        /// <summary>Pulse code modulation audio ("raw" uncompressed audio).</summary>
+        PCM,
+        /// <summary>Vorbis compressed audio.</summary>
+	    VORBIS
+    }
+
+    /// <summary>
+    /// Modes that determine how and when is audio data read.
+    /// </summary>
+    public enum AudioReadMode // Note: Must match C++ enum AudioReadMode
+    {
+        /// <summary>
+        /// Entire audio clip will be loaded and decompressed. Uses most memory but has lowest CPU impact.
+        /// </summary>
+        LoadDecompressed, 
+        /// <summary>
+        /// Entire audio clip will be loaded, but will be decompressed while playing. Uses medium amount of memory and has
+        /// the highest CPU impact. 
+        /// </summary>
+		LoadCompressed,
+        /// <summary>
+        /// Audio will be slowly streamed from the disk, and decompressed if needed. Uses very little memory, and has either
+        /// low or high CPU impact depending if the audio is in a compressed format. Since data is streamed from the disk,
+        /// read speeds could also be a bottleneck.
+        /// </summary>
+		Stream
+    }
+
+    /// <summary>
+    /// Numbers of bits per audio sample.
+    /// </summary>
+    public enum AudioBitDepth
+    {
+        Bits8 = 8,
+        Bits16 = 16,
+        Bits24 = 24,
+        Bits32 = 32
+    }
+
+    /// <summary>
+    /// Audio clip stores audio data in a compressed or uncompressed format. Clips can be provided to audio sources or
+    /// other audio methods to be played.
+    /// </summary>
+    public class AudioClip : Resource
+    {
+        /// <summary>
+        /// Constructor for internal use by the runtime.
+        /// </summary>
+        private AudioClip()
+        { }
+
+        /// <summary>
+        /// Returns the size of a single sample, in bits.
+        /// </summary>
+        public int BitDepth
+        {
+            get { return Internal_GetBitDepth(mCachedPtr); }
+        }
+
+        /// <summary>
+        /// Returns how many samples per second is the audio encoded in.
+        /// </summary>
+        public int SampleRate
+        {
+            get { return Internal_GetSampleRate(mCachedPtr); }
+        }
+
+        /// <summary>
+        /// Returns the number of channels provided by the clip.
+        /// </summary>
+        public int NumChannels
+        {
+            get { return Internal_GetNumChannels(mCachedPtr); }
+        }
+
+        /// <summary>
+        /// Returns in which format is audio data stored in. 
+        /// </summary>
+        public AudioFormat Format
+        {
+            get { return Internal_GetAudioFormat(mCachedPtr); }
+        }
+
+        /// <summary>
+        /// Returns how is the audio data read/decoded. 
+        /// </summary>
+        public AudioReadMode ReadMode
+        {
+            get { return Internal_GetReadMode(mCachedPtr); }
+        }
+
+        /// <summary>
+        /// Returns the total number of samples in the clip (includes all channels).
+        /// </summary>
+        public int NumSamples
+        {
+            get { return Internal_GetNumSamples(mCachedPtr); }
+        }
+
+        /// <summary>
+        /// Returns the length of the audio clip, in seconds.
+        /// </summary>
+        public float Duration
+        {
+            get { return Internal_GetDuration(mCachedPtr); }
+        }
+
+        /// <summary>
+        /// Determines will the clip be played a spatial 3D sound, or as a normal sound (for example music).
+        /// </summary>
+        public bool Is3D
+        {
+            get { return Internal_GetIs3D(mCachedPtr); }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetBitDepth(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetSampleRate(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetNumChannels(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern AudioFormat Internal_GetAudioFormat(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern AudioReadMode Internal_GetReadMode(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetNumSamples(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetDuration(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_GetIs3D(IntPtr thisPtr);
+    }
+
+    /** @} */
+}

Source/MBansheeEngine/Interop/Program.cs

@@ -19,6 +19,10 @@ namespace BansheeEngine
      *  %Input (mouse, keyboard, gamepad, etc.).
      */
 
+    /** @defgroup Audio Audio
+     *  Audio clips, 3D sound and music reproduction.
+     */
+
     /** @defgroup Math Math 
      *  Variety of general purpose math functionality.
      */

Source/MBansheeEngine/MBansheeEngine.csproj

@@ -43,6 +43,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Audio\AudioClip.cs" />
     <Compile Include="Rendering\PostProcessSettings.cs" />
     <Compile Include="Utility\AsyncOp.cs" />
     <Compile Include="Math\Bounds.cs" />

Source/SBansheeEditor/Include/BsScriptImportOptions.h

@@ -5,6 +5,7 @@
 #include "BsScriptEditorPrerequisites.h"
 #include "BsScriptObject.h"
 #include "BsPixelData.h"
+#include "BsAudioClipImportOptions.h"
 #include "BsGpuProgram.h"
 
 namespace BansheeEngine
@@ -181,5 +182,37 @@ namespace BansheeEngine
 		static void internal_SetEditorScript(ScriptScriptCodeImportOptions* thisPtr, bool value);
 	};
 
+	/**	Interop class between C++ & CLR for AudioClipImportOptions. */
+	class BS_SCR_BED_EXPORT ScriptAudioClipImportOptions : public ScriptObject <ScriptAudioClipImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "AudioClipImportOptions")
+
+		/** Creates a new managed AudioClipImportOptions instance containing the default import options for audio files. */
+		static MonoObject* create();
+
+		/** Creates a new managed AudioClipImportOptions instance containing the provided import options. */
+		static MonoObject* create(const SPtr<AudioClipImportOptions>& options);
+
+	private:
+		ScriptAudioClipImportOptions(MonoObject* instance);
+
+		/**	Returns the internal native import options. */
+		SPtr<AudioClipImportOptions> getClipImportOptions();
+
+		/************************************************************************/
+		/* 								CLR HOOKS						   		*/
+		/************************************************************************/
+		static void internal_CreateInstance(MonoObject* instance);
+		static AudioFormat internal_GetFormat(ScriptAudioClipImportOptions* thisPtr);
+		static void internal_SetFormat(ScriptAudioClipImportOptions* thisPtr, AudioFormat format);
+		static AudioReadMode internal_GetReadMode(ScriptAudioClipImportOptions* thisPtr);
+		static void internal_SetReadMode(ScriptAudioClipImportOptions* thisPtr, AudioReadMode readMode);
+		static bool internal_GetIs3D(ScriptAudioClipImportOptions* thisPtr);
+		static void internal_SetIs3D(ScriptAudioClipImportOptions* thisPtr, bool is3d);
+		static UINT32 internal_GetBitDepth(ScriptAudioClipImportOptions* thisPtr);
+		static void internal_SetBitDepth(ScriptAudioClipImportOptions* thisPtr, UINT32 bitDepth);
+	};
+
 	/** @} */
 }

Source/SBansheeEditor/Source/BsScriptImportOptions.cpp

@@ -468,4 +468,95 @@ namespace BansheeEngine
 	{
 		thisPtr->getCodeImportOptions()->setEditorScript(value);
 	}
+
+	ScriptAudioClipImportOptions::ScriptAudioClipImportOptions(MonoObject* instance)
+		:ScriptObject(instance)
+	{
+		mImportOptions = bs_shared_ptr_new<AudioClipImportOptions>();
+	}
+
+	void ScriptAudioClipImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptAudioClipImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetFormat", &ScriptAudioClipImportOptions::internal_GetFormat);
+		metaData.scriptClass->addInternalCall("Internal_SetFormat", &ScriptAudioClipImportOptions::internal_SetFormat);
+		metaData.scriptClass->addInternalCall("Internal_GetReadMode", &ScriptAudioClipImportOptions::internal_GetReadMode);
+		metaData.scriptClass->addInternalCall("Internal_SetReadMode", &ScriptAudioClipImportOptions::internal_SetReadMode);
+		metaData.scriptClass->addInternalCall("Internal_GetIs3D", &ScriptAudioClipImportOptions::internal_GetIs3D);
+		metaData.scriptClass->addInternalCall("Internal_SetIs3D", &ScriptAudioClipImportOptions::internal_SetIs3D);
+		metaData.scriptClass->addInternalCall("Internal_GetBitDepth", &ScriptAudioClipImportOptions::internal_GetBitDepth);
+		metaData.scriptClass->addInternalCall("Internal_SetBitDepth", &ScriptAudioClipImportOptions::internal_SetBitDepth);
+	}
+
+	SPtr<AudioClipImportOptions> ScriptAudioClipImportOptions::getClipImportOptions()
+	{
+		return std::static_pointer_cast<AudioClipImportOptions>(mImportOptions);
+	}
+
+	MonoObject* ScriptAudioClipImportOptions::create()
+	{
+		return metaData.scriptClass->createInstance();
+	}
+
+	MonoObject* ScriptAudioClipImportOptions::create(const SPtr<AudioClipImportOptions>& options)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+		ScriptAudioClipImportOptions* scriptObj = ScriptAudioClipImportOptions::toNative(managedInstance);
+		scriptObj->mImportOptions = options;
+
+		return managedInstance;
+	}
+
+	void ScriptAudioClipImportOptions::internal_CreateInstance(MonoObject* instance)
+	{
+		new (bs_alloc<ScriptAudioClipImportOptions>()) ScriptAudioClipImportOptions(instance);
+	}
+
+	AudioFormat ScriptAudioClipImportOptions::internal_GetFormat(ScriptAudioClipImportOptions* thisPtr)
+	{
+		auto io = thisPtr->getClipImportOptions();
+		return io->getFormat();
+	}
+
+	void ScriptAudioClipImportOptions::internal_SetFormat(ScriptAudioClipImportOptions* thisPtr, AudioFormat format)
+	{
+		auto io = thisPtr->getClipImportOptions();
+		io->setFormat(format);
+	}
+
+	AudioReadMode ScriptAudioClipImportOptions::internal_GetReadMode(ScriptAudioClipImportOptions* thisPtr)
+	{
+		auto io = thisPtr->getClipImportOptions();
+		return io->getReadMode();
+	}
+
+	void ScriptAudioClipImportOptions::internal_SetReadMode(ScriptAudioClipImportOptions* thisPtr, AudioReadMode readMode)
+	{
+		auto io = thisPtr->getClipImportOptions();
+		io->setReadMode(readMode);
+	}
+
+	bool ScriptAudioClipImportOptions::internal_GetIs3D(ScriptAudioClipImportOptions* thisPtr)
+	{
+		auto io = thisPtr->getClipImportOptions();
+		return io->getIs3D();
+	}
+
+	void ScriptAudioClipImportOptions::internal_SetIs3D(ScriptAudioClipImportOptions* thisPtr, bool is3d)
+	{
+		auto io = thisPtr->getClipImportOptions();
+		io->setIs3D(is3d);
+	}
+
+	UINT32 ScriptAudioClipImportOptions::internal_GetBitDepth(ScriptAudioClipImportOptions* thisPtr)
+	{
+		auto io = thisPtr->getClipImportOptions();
+		return io->getBitDepth();
+	}
+
+	void ScriptAudioClipImportOptions::internal_SetBitDepth(ScriptAudioClipImportOptions* thisPtr, UINT32 bitDepth)
+	{
+		auto io = thisPtr->getClipImportOptions();
+		io->setBitDepth(bitDepth);
+	}
 }

Source/SBansheeEngine/CMakeSources.cmake

@@ -133,6 +133,7 @@ set(BS_SBANSHEEENGINE_INC_WRAPPERS
 	"Include/BsScriptResources.h"
 	"Include/BsScriptResourceRef.h"
 	"Include/BsScriptPostProcessSettings.h"
+	"Include/BsScriptAudioClip.h"
 )
 
 set(BS_SBANSHEEENGINE_INC_WRAPPERS_GUI
@@ -256,6 +257,7 @@ set(BS_SBANSHEEENGINE_SRC_WRAPPERS
 	"Source/BsScriptRenderTarget.cpp"
 	"Source/BsScriptRenderable.cpp"
 	"Source/BsScriptPostProcessSettings.cpp"
+	"Source/BsScriptAudioClip.cpp"
 )
 
 set(BS_SBANSHEEENGINE_INC_SERIALIZATION

Source/SBansheeEngine/Include/BsManagedSerializableObjectInfo.h

@@ -52,6 +52,7 @@ namespace BansheeEngine
 		Component,
 		PhysicsMaterial,
 		PhysicsMesh,
+		AudioClip,
 		ManagedComponent,
 		Resource,
 		Count // Keep at end

Source/SBansheeEngine/Include/BsScriptAudioClip.h

@@ -0,0 +1,43 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptResource.h"
+#include "BsAudioClip.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup ScriptInteropEngine
+	 *  @{
+	 */
+
+	/**	Interop class between C++ & CLR for AudioClip. */
+	class BS_SCR_BE_EXPORT ScriptAudioClip : public TScriptResource<ScriptAudioClip, AudioClip>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "AudioClip")
+
+		/**	Creates an empty, uninitialized managed instance of the resource interop object. */
+		static MonoObject* createInstance();
+
+	private:
+		friend class ScriptResourceManager;
+
+		ScriptAudioClip(MonoObject* instance, const HAudioClip& audioClip);
+
+		/************************************************************************/
+		/* 								CLR HOOKS						   		*/
+		/************************************************************************/
+		static UINT32 internal_GetBitDepth(ScriptAudioClip* thisPtr);
+		static UINT32 internal_GetSampleRate(ScriptAudioClip* thisPtr);
+		static UINT32 internal_GetNumChannels(ScriptAudioClip* thisPtr);
+		static AudioFormat internal_GetAudioFormat(ScriptAudioClip* thisPtr);
+		static AudioReadMode internal_GetReadMode(ScriptAudioClip* thisPtr);
+		static UINT32 internal_GetNumSamples(ScriptAudioClip* thisPtr);
+		static float internal_GetDuration(ScriptAudioClip* thisPtr);
+		static bool internal_GetIs3D(ScriptAudioClip* thisPtr);
+	};
+
+	/** @} */
+}

Source/SBansheeEngine/Include/BsScriptEnginePrerequisites.h

@@ -106,6 +106,7 @@ namespace BansheeEngine
 	class ScriptPhysicsMesh;
 	class ScriptRigidbody;
 	class ScriptColliderBase;
+	class ScriptAudioClip;
 
 	typedef GameObjectHandle<ManagedComponent> HManagedComponent;
 	typedef ResourceHandle<ManagedResource> HManagedResource;

Source/SBansheeEngine/Include/BsScriptResource.h

@@ -16,7 +16,7 @@ namespace BansheeEngine
 	enum class ScriptResourceType // Note: Must be the same as C# enum ResourceType
 	{
 		Texture, SpriteTexture, Mesh, Font, Shader, ShaderInclude, Material, Prefab, 
-		PlainText, ScriptCode, StringTable, GUISkin, PhysicsMaterial, PhysicsMesh, Undefined
+		PlainText, ScriptCode, StringTable, GUISkin, PhysicsMaterial, PhysicsMesh, AudioClip, Undefined
 	};
 
 	/**	Base class for all resource interop objects. */

Source/SBansheeEngine/Source/BsManagedSerializableField.cpp

@@ -24,6 +24,7 @@
 #include "BsScriptGUISkin.h"
 #include "BsScriptPhysicsMaterial.h"
 #include "BsScriptPhysicsMesh.h"
+#include "BsScriptAudioClip.h"
 #include "BsScriptSceneObject.h"
 #include "BsScriptComponent.h"
 #include "BsManagedSerializableObject.h"
@@ -179,6 +180,9 @@ namespace BansheeEngine
 			lookup[(int)ScriptReferenceType::PhysicsMesh] =
 				{ &getScriptResource<PhysicsMesh, ScriptPhysicsMesh>, &setScriptResource<ScriptPhysicsMesh> };
 
+			lookup[(int)ScriptReferenceType::AudioClip] =
+				{ &getScriptResource<AudioClip, ScriptAudioClip>, &setScriptResource<ScriptAudioClip> };
+
 			lookup[(int)ScriptReferenceType::ManagedResource] =
 				{ &getScriptResource<ManagedResource, ScriptManagedResource>, &setScriptResource<ScriptManagedResource> };
 

Source/SBansheeEngine/Source/BsManagedSerializableObjectInfo.cpp

@@ -21,6 +21,7 @@
 #include "BsScriptGUISkin.h"
 #include "BsScriptPhysicsMaterial.h"
 #include "BsScriptPhysicsMesh.h"
+#include "BsScriptAudioClip.h"
 #include "BsScriptPrefab.h"
 #include "BsScriptManagedResource.h"
 
@@ -206,6 +207,7 @@ namespace BansheeEngine
 		case ScriptReferenceType::GUISkin:
 		case ScriptReferenceType::PhysicsMaterial:
 		case ScriptReferenceType::PhysicsMesh:
+		case ScriptReferenceType::AudioClip:
 		case ScriptReferenceType::SceneObject:
 		case ScriptReferenceType::Component:
 			return true;
@@ -254,6 +256,8 @@ namespace BansheeEngine
 			return ScriptPhysicsMaterial::getMetaData()->scriptClass->_getInternalClass();
 		case ScriptReferenceType::PhysicsMesh:
 			return ScriptPhysicsMesh::getMetaData()->scriptClass->_getInternalClass();
+		case ScriptReferenceType::AudioClip:
+			return ScriptAudioClip::getMetaData()->scriptClass->_getInternalClass();
 		case ScriptReferenceType::SceneObject:
 			return ScriptAssemblyManager::instance().getSceneObjectClass()->_getInternalClass();
 		case ScriptReferenceType::Component:

Source/SBansheeEngine/Source/BsScriptAssemblyManager.cpp

@@ -24,6 +24,7 @@
 #include "BsScriptGUISkin.h"
 #include "BsScriptPhysicsMaterial.h"
 #include "BsScriptPhysicsMesh.h"
+#include "BsScriptAudioClip.h"
 #include "BsScriptPrefab.h"
 
 namespace BansheeEngine
@@ -305,6 +306,8 @@ namespace BansheeEngine
 					typeInfo->mType = ScriptReferenceType::PhysicsMaterial;
 				else if (monoClass->isSubClassOf(ScriptPhysicsMesh::getMetaData()->scriptClass))
 					typeInfo->mType = ScriptReferenceType::PhysicsMesh;
+				else if (monoClass->isSubClassOf(ScriptAudioClip::getMetaData()->scriptClass))
+					typeInfo->mType = ScriptReferenceType::AudioClip;
 				else
 				{
 					assert(false && "Unrecognized resource type");

Source/SBansheeEngine/Source/BsScriptAudioClip.cpp

@@ -0,0 +1,89 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsScriptAudioClip.h"
+#include "BsScriptResourceManager.h"
+#include "BsScriptMeta.h"
+#include "BsScriptMeshData.h"
+#include "BsMonoClass.h"
+
+namespace BansheeEngine
+{
+	ScriptAudioClip::ScriptAudioClip(MonoObject* instance, const HAudioClip& audioClip)
+		:TScriptResource(instance, audioClip)
+	{
+
+	}
+
+	void ScriptAudioClip::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_GetBitDepth", &ScriptAudioClip::internal_GetBitDepth);
+		metaData.scriptClass->addInternalCall("Internal_GetSampleRate", &ScriptAudioClip::internal_GetSampleRate);
+		metaData.scriptClass->addInternalCall("Internal_GetNumChannels", &ScriptAudioClip::internal_GetNumChannels);
+		metaData.scriptClass->addInternalCall("Internal_GetAudioFormat", &ScriptAudioClip::internal_GetAudioFormat);
+		metaData.scriptClass->addInternalCall("Internal_GetReadMode", &ScriptAudioClip::internal_GetReadMode);
+		metaData.scriptClass->addInternalCall("Internal_GetNumSamples", &ScriptAudioClip::internal_GetNumSamples);
+		metaData.scriptClass->addInternalCall("Internal_GetDuration", &ScriptAudioClip::internal_GetDuration);
+		metaData.scriptClass->addInternalCall("Internal_GetIs3D", &ScriptAudioClip::internal_GetIs3D);
+	}
+
+	UINT32 ScriptAudioClip::internal_GetBitDepth(ScriptAudioClip* thisPtr)
+	{
+		HAudioClip audioClip = thisPtr->getHandle();
+
+		return audioClip->getBitDepth();
+	}
+
+	UINT32 ScriptAudioClip::internal_GetSampleRate(ScriptAudioClip* thisPtr)
+	{
+		HAudioClip audioClip = thisPtr->getHandle();
+
+		return audioClip->getFrequency();
+	}
+
+	UINT32 ScriptAudioClip::internal_GetNumChannels(ScriptAudioClip* thisPtr)
+	{
+		HAudioClip audioClip = thisPtr->getHandle();
+
+		return audioClip->getNumChannels();
+	}
+
+	AudioFormat ScriptAudioClip::internal_GetAudioFormat(ScriptAudioClip* thisPtr)
+	{
+		HAudioClip audioClip = thisPtr->getHandle();
+
+		return audioClip->getFormat();
+	}
+
+	AudioReadMode ScriptAudioClip::internal_GetReadMode(ScriptAudioClip* thisPtr)
+	{
+		HAudioClip audioClip = thisPtr->getHandle();
+
+		return audioClip->getReadMode();
+	}
+
+	UINT32 ScriptAudioClip::internal_GetNumSamples(ScriptAudioClip* thisPtr)
+	{
+		HAudioClip audioClip = thisPtr->getHandle();
+
+		return audioClip->getNumSamples();
+	}
+
+	float ScriptAudioClip::internal_GetDuration(ScriptAudioClip* thisPtr)
+	{
+		HAudioClip audioClip = thisPtr->getHandle();
+
+		return audioClip->getLength();
+	}
+
+	bool ScriptAudioClip::internal_GetIs3D(ScriptAudioClip* thisPtr)
+	{
+		HAudioClip audioClip = thisPtr->getHandle();
+
+		return audioClip->is3D();
+	}
+
+	MonoObject* ScriptAudioClip::createInstance()
+	{
+		return metaData.scriptClass->createInstance();
+	}
+}

Source/SBansheeEngine/Source/BsScriptResource.cpp

@@ -19,6 +19,7 @@
 #include "BsScriptGUISkin.h"
 #include "BsScriptPhysicsMesh.h"
 #include "BsScriptPhysicsMaterial.h"
+#include "BsScriptAudioClip.h"
 #include "BsScriptPrefab.h"
 
 namespace BansheeEngine
@@ -89,6 +90,8 @@ namespace BansheeEngine
 			return ScriptPhysicsMaterial::getMetaData()->scriptClass;
 		case TID_PhysicsMesh:
 			return ScriptPhysicsMesh::getMetaData()->scriptClass;
+		case TID_AudioClip:
+			return ScriptAudioClip::getMetaData()->scriptClass;
 		}
 
 		return nullptr;
@@ -126,6 +129,8 @@ namespace BansheeEngine
 			return ScriptResourceType::PhysicsMaterial;
 		case TID_PhysicsMesh:
 			return ScriptResourceType::PhysicsMesh;
+		case TID_AudioClip:
+			return ScriptResourceType::AudioClip;
 		}
 
 		return ScriptResourceType::Undefined;
@@ -163,6 +168,8 @@ namespace BansheeEngine
 			return TID_PhysicsMaterial;
 		case ScriptResourceType::PhysicsMesh:
 			return TID_PhysicsMesh;
+		case ScriptResourceType::AudioClip:
+			return TID_AudioClip;
 		default:
 			break;
 		}

Source/SBansheeEngine/Source/BsScriptResourceManager.cpp

@@ -21,6 +21,7 @@
 #include "BsScriptGUISkin.h"
 #include "BsScriptPhysicsMaterial.h"
 #include "BsScriptPhysicsMesh.h"
+#include "BsScriptAudioClip.h"
 #include "BsScriptManagedResource.h"
 #include "BsScriptAssemblyManager.h"
 
@@ -152,6 +153,8 @@ namespace BansheeEngine
 				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<PhysicsMaterial>(resourceHandle), (ScriptPhysicsMaterial**)out);
 			case TID_PhysicsMesh:
 				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<PhysicsMesh>(resourceHandle), (ScriptPhysicsMesh**)out);
+			case TID_AudioClip:
+				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<AudioClip>(resourceHandle), (ScriptAudioClip**)out);
 			case TID_ManagedResource:
 				BS_EXCEPT(InternalErrorException, "Managed resources must have a managed instance by default, this call is invalid.")
 					break;
@@ -178,6 +181,7 @@ namespace BansheeEngine
 		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<GUISkin>&, ScriptGUISkin**);
 		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<PhysicsMesh>&, ScriptPhysicsMesh**);
 		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<PhysicsMaterial>&, ScriptPhysicsMaterial**);
+		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<AudioClip>&, ScriptAudioClip**);
 	}
 
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<Texture>&, ScriptTexture2D**);
@@ -196,6 +200,7 @@ namespace BansheeEngine
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<GUISkin>&, ScriptGUISkin**);
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<PhysicsMesh>&, ScriptPhysicsMesh**);
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<PhysicsMaterial>&, ScriptPhysicsMaterial**);
+	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<AudioClip>&, ScriptAudioClip**);
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<ManagedResource>&, ScriptManagedResource**);
 
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Texture>& resourceHandle, ScriptTexture2D** out, bool create);
@@ -215,6 +220,7 @@ namespace BansheeEngine
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<GUISkin>& resourceHandle, ScriptGUISkin** out, bool create);
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<PhysicsMesh>& resourceHandle, ScriptPhysicsMesh** out, bool create);
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<PhysicsMaterial>& resourceHandle, ScriptPhysicsMaterial** out, bool create);
+	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<AudioClip>& resourceHandle, ScriptAudioClip** out, bool create);
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<ManagedResource>& resourceHandle, ScriptManagedResource** out, bool create);
 	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Resource>& resourceHandle, ScriptResourceBase** out, bool create);