internal ReverbProperties(ref REVERB_PROPERTIES props)
            : this()
        {
            // All field of REVERB_PROPERTIES are private in the wrapper, I had to modify the wrapper here to expose those fields

            DecayTime = props.DecayTime;
            EarlyDelay = props.EarlyDelay;
            LateDelay = props.LateDelay;
            HFReference = props.HFReference;
            HFDecayRatio = props.HFDecayRatio;
            Diffusion = props.Diffusion;
            Density = props.Density;
            LowShelfFrequency = props.LowShelfFrequency;
            LowShelfGain = props.LowShelfGain;
            HighCut = props.HighCut;
            EarlyLateMix = props.EarlyLateMix;
            WetLevel = props.WetLevel;
        }

 public RESULT setProperties(ref REVERB_PROPERTIES properties)
 {
     return Reverb3D.FMOD5_Reverb3D_SetProperties(this.rawPtr, ref properties);
 }

 private static extern RESULT FMOD_EventSystem_SetReverbAmbientProperties(IntPtr eventsystem, ref REVERB_PROPERTIES props);

 // Reverb api
 public RESULT setReverbProperties(ref REVERB_PROPERTIES prop)
 {
     return FMOD_System_SetReverbProperties(systemraw, ref prop);
 }

 private static extern RESULT FMOD_Reverb_SetProperties(IntPtr reverb, ref REVERB_PROPERTIES properties);

 public RESULT getProperties(ref REVERB_PROPERTIES properties)
 {
     return FMOD_Reverb3D_GetProperties(rawPtr, ref properties);
 }

 public RESULT getReverbProperties    (int instance, out REVERB_PROPERTIES prop)
 {
     return FMOD_System_GetReverbProperties(rawPtr, instance, out prop);
 }

 private static extern RESULT FMOD_EventReverb_GetProperties(IntPtr eventreverb, ref REVERB_PROPERTIES props);

 public RESULT getProperties(ref REVERB_PROPERTIES props)
 {
     return FMOD_EventReverb_GetProperties(eventreverbraw, ref props);
 }

    private void _updateReverbStack()
    {
        if (m_reverbStack.Count == 0) {
            return ;
        }
        m_reverbStack.Sort((x, y) => (int)(y.Priority).CompareTo((int)x.Priority));
        FmodReverbZone newCurrentZone = m_reverbStack[0];

        if (m_currentZone != newCurrentZone) { // we should transition
            float fadeInTime = newCurrentZone.fadeTime;

            // if we are transitionning from a zone back to the global zone, we use the previous fade time
            // to fade out
            if (newCurrentZone == m_globalReverbZone && m_currentZone != m_globalReverbZone) {
                m_globalReverb.Initialize(m_globalReverb.getName(), FmodReverb.GLOBAL_REVERB.Properties);
                fadeInTime = m_currentZone.fadeTime;
            }
            FMOD.REVERB_PROPERTIES targetProps = newCurrentZone.GetReverb().getProperties();
            if (fadeInTime <= 0) {
                FmodEventSystemHandle handle = new FmodEventSystemHandle();

                m_isInTransition = false;
                m_startProperties = m_curProperties;
                m_endProperties = targetProps;
                handle.getEventSystem().setReverbImmediate(targetProps);
                handle.Dispose();
            } else {
                m_isInTransition = true;
                m_startProperties = m_curProperties;
                m_endProperties = targetProps;
                m_curTransitionDuration = fadeInTime;
                m_curTransitionTime = 0;
            }
            m_currentZone = newCurrentZone;
        }
    }

    protected void loadReverbsFromFile(FmodEventAsset asset)
    {
        List<FmodReverb> reverbs = new List<FmodReverb>();
        FMOD.REVERB_PROPERTIES curReverb = new FMOD.REVERB_PROPERTIES();
        IntPtr curReverbName = new IntPtr();
        string curReverbNameAsString;
        int numReverbs = 0;
        FMOD.RESULT result = FMOD.RESULT.OK;
        FmodReverb newReverb = null;

        result = getEventSystem().getNumReverbPresets(ref numReverbs);
        ERRCHECK(result);
        if (result == FMOD.RESULT.OK) {
            for (int i = 0; i < numReverbs; i++) {
                result = getEventSystem().getReverbPresetByIndex(i, ref curReverb, ref curReverbName);
                ERRCHECK(result);
                if (result == FMOD.RESULT.OK) {
                    curReverbNameAsString = Marshal.PtrToStringAnsi(curReverbName);
                    newReverb = ScriptableObject.CreateInstance(typeof(FmodReverb)) as FmodReverb;
                    newReverb.Initialize(curReverbNameAsString, curReverb);
                    reverbs.Add(newReverb);
                }
            }
        }
        asset.setReverbs(reverbs);
    }

 public RESULT getReverbPreset(string name, ref REVERB_PROPERTIES props, ref int index)
 {
     return FMOD_EventSystem_GetReverbPreset(eventsystemraw, name, ref props, ref index);
 }

 // Reverb api.
 public RESULT setReverbProperties    (int instance, ref REVERB_PROPERTIES prop)
 {
     return FMOD_System_SetReverbProperties(rawPtr, instance, ref prop);
 }

 public RESULT getReverbPresetByIndex(int index,  ref REVERB_PROPERTIES props, ref IntPtr name)
 {
     return FMOD_EventSystem_GetReverbPresetByIndex(eventsystemraw, index, ref props, ref name);
 }

 private static extern RESULT FMOD_System_GetReverbProperties    (IntPtr system, int instance, out REVERB_PROPERTIES prop);

 // Reverb interfaces.
 public RESULT setReverbProperties(ref REVERB_PROPERTIES props)
 {
     return FMOD_EventSystem_SetReverbProperties(eventsystemraw, ref props);
 }

 public RESULT setProperties(ref REVERB_PROPERTIES properties)
 {
     return FMOD_Reverb_SetProperties(reverbraw, ref properties);
 }

 private static extern RESULT FMOD_EventSystem_GetReverbPreset(IntPtr eventsystem, string name, ref REVERB_PROPERTIES props, ref int index);

 public RESULT getReverbAmbientProperties(ref REVERB_PROPERTIES prop)
 {
     return FMOD_System_GetReverbAmbientProperties(systemraw, ref prop);
 }

 private static extern RESULT FMOD_EventSystem_GetReverbPresetByIndex(IntPtr eventsystem, int index, ref REVERB_PROPERTIES props, ref IntPtr name);