com.amanotes.gdk 0.2.73-1 → 0.2.74

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.2.74] - 2024-09-17
+- [Dev] Add GDKAudio Example
+- [Feature] Add AudioSource fallback for unsupported platforms
+- Also: Improve public Audio API
+- [Fix] Wait for ad callback in editor
+- [Dev] Upgrade IronSource 8.3.0
+- [Dev] Some improvements for batch enable / disable symbols in GDKSymbolDefine
+
 ## [0.2.73] - 2024-09-09
 - [Fix] Disable incorrect in-editor warning for AdLogic
 - [Dev] Remove AdEventTracking dependency on AppsFlyer

package/Editor/Extra/GDKSymbolDefine.cs

@@ -266,6 +266,7 @@ public partial class {className}
             define = (GDKSymbolDefine)target;
             symbolsProp = serializedObject.FindProperty("symbols");
             loggerConfigProp = serializedObject.FindProperty("loggerConfig");
+            define.Read();
         }
 
         public override void OnInspectorGUI()
@@ -322,10 +323,33 @@ public partial class {className}
         private void DrawSymbolsTab()
         {
             EditorGUILayout.PropertyField(symbolsProp, new GUIContent("DEFINE SYMBOLS"), true);
-            if (define.loggerConfig.enabled)
+            if (!define.loggerConfig.enabled) return;
+            
+            GUILayout.BeginHorizontal();
+            {
+                if (GUILayout.Button("Select All"))
+                {
+                    SetSelection(true);
+                }
+                
+                if (GUILayout.Button("Deselect All"))
+                {
+                    SetSelection(false);
+                }
+            }
+            GUILayout.EndHorizontal();
+            
+            EditorGUILayout.PropertyField(loggerConfigProp.FindPropertyRelative("tags"), new GUIContent("LOGGER TAGS"), true);
+        }
+
+        private void SetSelection(bool isOn)
+        {
+            var tags = define.loggerConfig.tags;
+            for (var i = 0; i < tags.Count; i++)
             {
-                EditorGUILayout.PropertyField(loggerConfigProp.FindPropertyRelative("tags"), new GUIContent("LOGGER TAGS"), true);    
+                tags[i].enabled = isOn;
             }
+            EditorUtility.SetDirty(target);
         }
         
         private static bool showTemplate = false;

package/Runtime/AmaGDK.cs

@@ -24,7 +24,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.73-1";
+        public const string VERSION = "0.2.74";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;

package/Runtime/GDKAudio/GDKAudio.cs

@@ -2,11 +2,15 @@
 #define UNITY_MOBILE
 #endif
 
+#if UNITY_2021_1_OR_NEWER && ((UNITY_MOBILE && !UNITY_EDITOR) || (UNITY_MOBILE && UNITY_EDITOR_OSX))
+#define SUPPORTED_PLATFORMS
+#endif
+
 // GDKAudio is supported in the following environments:
 // 1. On iOS devices.
 // 2. On Android devices (excluding the Unity Editor).
 // 3. In the Unity Editor running on macOS with Apple Silicon (M1, M2, etc.).
-#if UNITY_2021_1_OR_NEWER && ((UNITY_MOBILE && !UNITY_EDITOR) || (UNITY_MOBILE && UNITY_EDITOR_OSX))
+// For unsupported environments, GDKAudio will fallback to setting the AudioSource.pitch for time stretching.
 
 using System;
 using System.Runtime.InteropServices;
@@ -15,6 +19,10 @@ using static Amanotes.Core.GDKDebug;
 
 using UnityEngine;
 
+#if !SUPPORTED_PLATFORMS
+using UnityEngine.Audio;
+#endif
+
 namespace Amanotes.Core
 {
     public static class AudioSourceExtensions
@@ -42,19 +50,43 @@ namespace Amanotes.Core
 
     public partial class GDKAudio // public API
     {
-        public float speed { get; set; } = 1f;
-        public bool loop { get; set; } = true;
-        public bool isPlaying { get; private set; } = false;
+        public float speed { get; private set; } = 1f;
+        public bool loop { get; private set; } = true;
+        public bool mute { get; private set; } = false;
+        private float globalVolume = 1f;
+
 
-        public GDKAudio SetSpeed(float speed)
+        public bool isPlaying { get; private set; } = false;
+        public bool isInitialized => initialized;
+
+        /// <summary>
+        /// Set the audio playback speed.
+        /// The audio playback speed is capped in range 0.5x and 2x. Set `force` to true to disable this cap. Note: `speed` lower than 0.75 will create audio artifacts.
+        /// </summary>
+        /// <param name="speed">The desired audio speed. `speed` lower than 0.75 will create artifacts.</param>
+        /// <param name="force">Force setting the speed. this will affect the audio pitch on speed faster than 2x and below 0.5x.</param>
+        public GDKAudio SetSpeed(float speed, bool force = false)
         {
+            if (!force)
+            {
+                speed = Mathf.Clamp(speed, 0.5f, 2.0f);
+            }
             this.speed = speed;
+            SetSpeedInternal();
             return this;
         }
 
         public GDKAudio SetLoop(bool loop)
         {
             this.loop = loop;
+            audioSource.loop = this.loop;
+            return this;
+        }
+
+        public GDKAudio SetMute(bool mute)
+        {
+            this.mute = mute;
+            audioSource.mute = this.mute;
             return this;
         }
 
@@ -74,6 +106,7 @@ namespace Amanotes.Core
         {
             isPlaying = false;
             audioSource.Stop();
+            StopInternal();
             return this;
         }
 
@@ -107,7 +140,7 @@ namespace Amanotes.Core
         }
     }
 
-    partial class GDKAudio: MonoBehaviour
+    partial class GDKAudio : MonoBehaviour
     {
         private AudioSource audioSource;
 
@@ -130,8 +163,15 @@ namespace Amanotes.Core
             }
         }
 
+        private void Update()
+        {
+            // NOTE: AudioListener.volume can only be called in Main-Thread 
+            globalVolume = AudioListener.volume;
+        }
+
         private void OnDestroy()
         {
+            Stop();
             if (!initialized) return;
             FreeMemory(ptrL, ptrR);
         }
@@ -145,38 +185,57 @@ namespace Amanotes.Core
         }
     }
 
+#if SUPPORTED_PLATFORMS
     partial class GDKAudio
     {
-        private float[] audioData;
+        public int numSamples { get; private set; }
+        public int numChannels { get; private set; }
+        public int sampleRate { get; private set; } = 44100;
+        public int numFrames { get; private set; } = 1;
+        public float time
+        {
+            get => timeSamples / (float)sampleRate;
+            set => timeSamples = (int)(value * sampleRate);
+        }
+
+        private int timeSamples
+        {
+            get => idxFrame * hop;
+            set => SetPlaybackFrame(value / hop);
+        }
+        private float _volume = 1f;
+
+        public float volume
+        {
+            get => _volume;
+            set => _volume = Mathf.Clamp01(value);
+        }
 
-        private int numSamples;
-        private int numChannel;
 
-        private int fs = 44100;
+        private float[] audioData;
+
         private int bufferLength;
         private int numBuffer;
 
         private int nFFT = 2048;
         private int hop = 512;
         private int cntSave = 0;
-        private int numFrame = 1;
-        private int idxFrame = 0;
+        private int idxFrame { get; set; } = 0;
         private float[] hopFrame;
-        private float [] dataOut;
-        private float [] dataOutSave;
-        private Vector3 positionOld;
+        private float[] dataOut;
+        private float[] dataOutSave;
 
-        #if UNITY_IOS && !UNITY_EDITOR
+#if UNITY_IOS && !UNITY_EDITOR
         private const string LIBRARY_NAME ="__Internal";
-        #else
-        private const string LIBRARY_NAME ="atensor";
-        #endif
+#else
+        private const string LIBRARY_NAME = "atensor";
+#endif
 
         [DllImport(LIBRARY_NAME, EntryPoint = "ptrResampleMulti")]
-        private static extern int ResampleMulti(float [] inData, ref IntPtr outData, float fs, float targetFs, int numSrcSamples, int numChannels, ref IntPtr ptrL);
+        private static extern int ResampleMulti(float[] inData, ref IntPtr outData, float fs, float targetFs, int numSrcSamples, int numChannels, ref IntPtr ptrL);
 
         [DllImport(LIBRARY_NAME, EntryPoint = "ptrTSM_Init")]
-        private static extern void TSM_Init(float [] firstFrame, float scale, float fs, int numChannel, int nFft, int hop, ref IntPtr ptrL, ref IntPtr ptrR);
+        private static extern void TSM_Init(float[] firstFrame, float scale, float fs, int numChannel, int nFft, int hop, ref IntPtr ptrL, ref IntPtr ptrR);
 
         [DllImport(LIBRARY_NAME, EntryPoint = "ptrTSM_Processing")]
         private static extern int TSM_Processing(float[] inData, float[] outData, float scale, IntPtr ptrL, IntPtr ptrR);
@@ -192,81 +251,101 @@ namespace Amanotes.Core
         internal void LoadAudioInternal(AudioClip audioClip)
         {
             AudioSettings.GetDSPBufferSize(out bufferLength, out numBuffer);
-            hop = Math.Min(bufferLength, 512);
+            hop = Mathf.Min(bufferLength, 512);
             numSamples = audioClip.samples;
-            numChannel = audioClip.channels;
-            fs = audioClip.frequency;
+            numChannels = audioClip.channels;
+            sampleRate = audioClip.frequency;
+
+            if (numChannels < 2)
+            {
+                numChannels = 2;
+                audioData = new float[numSamples * numChannels];
+                audioClip.GetData(audioData, 0);
+                for (int i = numSamples - 1; i > 0; --i)
+                {
+                    audioData[i * 2] = audioData[i];
+                    audioData[(i * 2) - 1] = audioData[i];
+                }
+            }
+            else
+            {
+                audioData = new float[numSamples * numChannels];
+                audioClip.GetData(audioData, 0);
+            }
 
-            audioData = new float[numSamples * numChannel];
-            audioClip.GetData(audioData, 0);
 
             // Do resampling
-            if (fs != AudioSettings.outputSampleRate)
+            if (sampleRate != AudioSettings.outputSampleRate)
             {
                 var audioDataResample = new IntPtr();
                 numSamples = ResampleMulti(
                     audioData,
                     ref audioDataResample,
-                    fs,
+                    sampleRate,
                     AudioSettings.outputSampleRate,
-                    numSamples * numChannel,
-                    numChannel,
+                    numSamples * numChannels,
+                    numChannels,
                     ref ptrL
-                    ) / numChannel;
-                audioData = new float[numSamples*numChannel];
-                Marshal.Copy(audioDataResample, audioData, 0, numSamples*numChannel);
+                    ) / numChannels;
+                audioData = new float[numSamples * numChannels];
+                Marshal.Copy(audioDataResample, audioData, 0, numSamples * numChannels);
+                sampleRate = AudioSettings.outputSampleRate;
                 LogWarning(
-                    "Warning: The input AudioClip has a sample rate of " + fs + " Hz," +
-                    " which does not match AudioSetting sample rate of " + AudioSettings.outputSampleRate + " Hz." +
+                    $"Warning: The input AudioClip has a sample rate of {sampleRate} Hz," +
+                    $" which does not match AudioSetting sample rate of {AudioSettings.outputSampleRate} Hz." +
                     " GDKAudio will resample the audio to match AudioSetting with high memory usage." +
                     " We recommend resampling the audio to 44100 Hz before using it in Unity."
                 );
             }
 
-            Log("[AAA]numSamples: " + numSamples);
-            Log("[AAA]numChannel:" + numChannel);
-            Log("[AAA]bufferLength:" + bufferLength);
-            Log("[AAA]numBuffer:" + numBuffer);
+            numFrames = (numSamples - nFFT) / hop;
 
-            nFFT = 2048;
-            // hop = 512;
+            Log(
+                $"[AAA] audioData: {audioData.Length}\n" +
+                $"[AAA] numSamples: {numSamples}\n" +
+                $"[AAA] numChannel: {numChannels}\n" +
+                $"[AAA] bufferLength: {bufferLength}\n" +
+                $"[AAA] numBuffer: {numBuffer}\n" +
+                $"[AAA] numFrames: {numFrames}"
+            );
 
-            numFrame = (numSamples - nFFT) / hop;
             // Initialize
             Log("[AAA]TSM_Init");
-            TSM_Init(audioData, speed, fs, numChannel,  nFFT,  hop, ref ptrL, ref ptrR);
+            TSM_Init(audioData, speed, sampleRate, numChannels, nFFT, hop, ref ptrL, ref ptrR);
+
             initialized = true;
-            hopFrame = new float[hop*numChannel];
-            dataOut = new float[4*numChannel*hop]; // minimum of scale is 0.25
-            dataOutSave = new float[numChannel*bufferLength];
+            hopFrame = new float[hop * numChannels];
+            dataOut = new float[4 * numChannels * hop]; // minimum of scale is 0.25
+            dataOutSave = new float[numChannels * bufferLength];
 
             audioSource.clip = audioClip;
             audioSource.loop = loop;
-            Log("[AAA]AudioSettings.outputSampleRate (later): " + AudioSettings.outputSampleRate);
+            Log($"[AAA]AudioSettings.outputSampleRate (later): {AudioSettings.outputSampleRate}");
         }
 
         private void OnAudioFilterRead(float[] data, int channels)
         {
             if (!isPlaying) return;
 
-            if (idxFrame >= numFrame)
+            if (idxFrame >= numFrames)
             {
                 if (!loop)
                 {
-                    for (int i = 0; i < bufferLength * numChannel; i++)
+                    for (int i = 0; i < bufferLength * numChannels; i++)
                     {
                         data[i] = 0;
                     }
                     return;
                 }
                 idxFrame = 0;
-                Log("[AAA] Loop");
             }
 
 
             int lengthOut = 0;
             int lengthOutOld = 0;
-            int idxSave=0;
+            int idxSave = 0;
+            int muteModifier = mute ? 0 : 1;
+            float volumeModifier = muteModifier * volume * globalVolume;
 
             for (; idxSave < cntSave; idxSave++)
             {
@@ -275,27 +354,27 @@ namespace Amanotes.Core
 
             cntSave = 0;
 
-            while (lengthOut < bufferLength*numChannel-idxSave)
+            while (lengthOut < bufferLength * numChannels - idxSave)
             {
-                if (idxFrame >= numFrame) break;
+                if (idxFrame >= numFrames) break;
 
                 Array.Copy(
                     audioData,
-                    nFFT*numChannel + idxFrame*hop*numChannel, 
+                    nFFT * numChannels + idxFrame * hop * numChannels,
                     hopFrame,
                     0,
-                    hop*numChannel);
+                    hop * numChannels);
                 int temp = TSM_Processing(hopFrame, dataOut, speed, ptrL, ptrR);
                 lengthOut = lengthOutOld + temp;
                 for (int i = lengthOutOld; i < lengthOut; i++)
                 {
-                    if ( i < bufferLength*numChannel - idxSave)
+                    if (i < bufferLength * numChannels - idxSave)
                     {
-                        data[i + idxSave] = dataOut[i - lengthOutOld];
+                        data[i + idxSave] = dataOut[i - lengthOutOld] * volumeModifier;
                     }
                     else
                     {
-                        dataOutSave[i + idxSave - bufferLength*numChannel] = dataOut[i - lengthOutOld];
+                        dataOutSave[i + idxSave - bufferLength * numChannels] = dataOut[i - lengthOutOld] * volumeModifier;
                         cntSave++;
                     }
                 }
@@ -303,6 +382,102 @@ namespace Amanotes.Core
                 idxFrame++;
             }
         }
+
+        private void SetSpeedInternal()
+        {
+            // This method is intentionally left empty;
+            return;
+        }
+
+        private void StopInternal()
+        {
+            idxFrame = 0;
+        }
+
+        private void SetPlaybackFrame(int frame)
+        {
+            frame = Mathf.Clamp(frame, 0, numFrames - 1);
+            idxFrame = frame;
+        }
+
+        public float GetAudioDurationInSec()
+        {
+            return numFrames * hop / sampleRate;
+        }
+
+    }
+#else
+#warning "GDKAudio is not supported on this platform. You can still use GDKAudio, but it will fallback to changing AudioSource.pitch"
+    partial class GDKAudio
+    {
+        public int numSamples => audioSource.clip.samples;
+        public int numChannels => audioSource.clip.channels;
+        public int sampleRate => audioSource.clip.frequency;
+        public int numFrames => numSamples;
+
+        public float time
+        {
+            get => audioSource.time;
+            set => audioSource.time = value;
+        }
+
+        public float volume
+        {
+            get => audioSource.volume;
+            set => audioSource.volume = value;
+        }
+
+        private AudioMixer audioMixer;
+
+        // These attributes are intentionally left unused for compatibility.
+        private readonly IntPtr ptrL;
+        private readonly IntPtr ptrR;
+        private bool initialized = false;
+
+        internal void LoadAudioInternal(AudioClip audioClip)
+        {
+            audioMixer = Resources.Load("GDKAudioMixer") as AudioMixer;
+            audioSource.clip = audioClip;
+            audioSource.loop = loop;
+            audioSource.outputAudioMixerGroup = audioMixer.FindMatchingGroups("PitchShifter")[0];
+            SetSpeedInternal();
+            initialized = true;
+        }
+
+#pragma warning disable IDE0060
+        private static void FreeMemory(IntPtr ptrL, IntPtr ptrR)
+        {
+            // This method is intentionally left empty.
+            return;
+        }
+#pragma warning restore IDE0060
+
+        private void SetSpeedInternal()
+        {
+            audioSource.pitch = speed;
+            audioMixer.SetFloat("GDKAudioMixer_PitchShifter_Pitch", 1.0f / speed);
+
+            // Note: using AudioMixer's Pitch Shifter effect makes the audio a bit louder.
+            if (speed != 1.0f)
+            {
+                audioMixer.SetFloat("GDKAudioMixer_PitchShifter_Wet", 0.0f); // disable bypass
+            }
+            else
+            {
+                audioMixer.SetFloat("GDKAudioMixer_PitchShifter_Wet", -80.0f); // enable bypass
+            }
+        }
+
+        private void StopInternal()
+        {
+            // This method is intentionally left empty.
+            return;
+        }
+
+        public float GetAudioDurationInSec()
+        {
+            return audioSource.clip.length;
+        }
     }
-}
-#endif
+#endif
+}

package/Runtime/GDKAudio/Resources/GDKAudioMixer.mixer

@@ -0,0 +1,133 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!244 &-8349116154838344368
+AudioMixerEffectController:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_EffectID: 62a47044fd08b45cabe751635fe041c0
+  m_EffectName: Pitch Shifter
+  m_MixLevel: bd39be11d4b2e4d6b8d9eeb4854b6d41
+  m_Parameters:
+  - m_ParameterName: Pitch
+    m_GUID: e55392888f7544d359c260ebe4936b8b
+  - m_ParameterName: FFT size
+    m_GUID: 35576bb3f03224c908f09c33dcda7d23
+  - m_ParameterName: Overlap
+    m_GUID: eca58a2b2f2e54e08a192192f13b7093
+  - m_ParameterName: Max channels
+    m_GUID: 457e26280456e494eaa0151ae35aef65
+  m_SendTarget: {fileID: 0}
+  m_EnableWetMix: 1
+  m_Bypass: 0
+--- !u!243 &-4402511794110498525
+AudioMixerGroupController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: PitchShifter
+  m_AudioMixer: {fileID: 24100000}
+  m_GroupID: 5da7d04a1a2b04cc0bffe1517ba3a8ae
+  m_Children: []
+  m_Volume: 84ace98bec1c94eacabcb0b7cb3b7bce
+  m_Pitch: 62b46cb0c79874888b6d32635cc94987
+  m_Send: 00000000000000000000000000000000
+  m_Effects:
+  - {fileID: 3247467911740954387}
+  - {fileID: -8349116154838344368}
+  m_UserColorIndex: 0
+  m_Mute: 0
+  m_Solo: 0
+  m_BypassEffects: 0
+--- !u!241 &24100000
+AudioMixerController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: GDKAudioMixer
+  m_OutputGroup: {fileID: 0}
+  m_MasterGroup: {fileID: 24300002}
+  m_Snapshots:
+  - {fileID: 24500006}
+  m_StartSnapshot: {fileID: 24500006}
+  m_SuspendThreshold: -80
+  m_EnableSuspend: 1
+  m_UpdateMode: 0
+  m_ExposedParameters:
+  - guid: bd39be11d4b2e4d6b8d9eeb4854b6d41
+    name: GDKAudioMixer_PitchShifter_Wet
+  - guid: e55392888f7544d359c260ebe4936b8b
+    name: GDKAudioMixer_PitchShifter_Pitch
+  m_AudioMixerGroupViews:
+  - guids:
+    - 363e439911f3f4a8ea067b41152e999e
+    - 5da7d04a1a2b04cc0bffe1517ba3a8ae
+    name: View
+  m_CurrentViewIndex: 0
+  m_TargetSnapshot: {fileID: 24500006}
+--- !u!243 &24300002
+AudioMixerGroupController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Master
+  m_AudioMixer: {fileID: 24100000}
+  m_GroupID: 363e439911f3f4a8ea067b41152e999e
+  m_Children:
+  - {fileID: -4402511794110498525}
+  m_Volume: 6606288e2cb5341fdb244f298dde03ec
+  m_Pitch: 879bd0be0ae3a4cf29389421cfecca55
+  m_Send: 00000000000000000000000000000000
+  m_Effects:
+  - {fileID: 24400004}
+  m_UserColorIndex: 0
+  m_Mute: 0
+  m_Solo: 0
+  m_BypassEffects: 0
+--- !u!244 &24400004
+AudioMixerEffectController:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_EffectID: 7983e0a3221f048a99731b59d2cc18c7
+  m_EffectName: Attenuation
+  m_MixLevel: c382a734e5f624369a85819269419d46
+  m_Parameters: []
+  m_SendTarget: {fileID: 0}
+  m_EnableWetMix: 0
+  m_Bypass: 0
+--- !u!245 &24500006
+AudioMixerSnapshotController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Snapshot
+  m_AudioMixer: {fileID: 24100000}
+  m_SnapshotID: d21282160540b4f76ae89a904c77c48c
+  m_FloatValues:
+    bd39be11d4b2e4d6b8d9eeb4854b6d41: 0
+    e55392888f7544d359c260ebe4936b8b: 1
+    84ace98bec1c94eacabcb0b7cb3b7bce: 0
+  m_TransitionOverrides: {}
+--- !u!244 &3247467911740954387
+AudioMixerEffectController:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_EffectID: ba84eaaddd67e4c15a1738b305b3ea16
+  m_EffectName: Attenuation
+  m_MixLevel: 54ebf4c4d3ebc4055b44df5b15c3fbd9
+  m_Parameters: []
+  m_SendTarget: {fileID: 0}
+  m_EnableWetMix: 0
+  m_Bypass: 0

package/Runtime/GDKAudio/Resources/GDKAudioMixer.mixer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9ec5f19cbc83d45feb9901c997bdc585
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 24100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/GDKAudio/Resources.meta

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.2.73-1",
+    "version": "0.2.74",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",