コード例 #1
0
    /// This function dispatches all the accumulated callbacks from the native sound engine.
    /// It must be called regularly.  By default this is called in AkInitializer.cs.
    static public int PostCallbacks()
    {
        if (m_pNotifMem == IntPtr.Zero)
        {
            return(0);
        }

        try
        {
            int numCallbacks = 0;

            for (IntPtr pNext = AkCallbackSerializer.Lock(); pNext != IntPtr.Zero; pNext = AkSoundEnginePINVOKE.CSharp_AkSerializedCallbackHeader_pNext_get(pNext), ++numCallbacks)
            {
                IntPtr         pPackage = AkSoundEnginePINVOKE.CSharp_AkSerializedCallbackHeader_pPackage_get(pNext);
                AkCallbackType eType    = (AkCallbackType)AkSoundEnginePINVOKE.CSharp_AkSerializedCallbackHeader_eType_get(pNext);
                IntPtr         pData    = AkSoundEnginePINVOKE.CSharp_AkSerializedCallbackHeader_GetData(pNext);

                switch (eType)
                {
                case AkCallbackType.AK_AudioInterruption:
#if UNITY_IOS && !UNITY_EDITOR
                    if (ms_interruptCallbackPkg != null && ms_interruptCallbackPkg.m_Callback != null)
                    {
                        AkAudioInterruptionCallbackInfo.setCPtr(pData);
                        ms_interruptCallbackPkg.m_Callback(AkAudioInterruptionCallbackInfo.bEnterInterruption, ms_interruptCallbackPkg.m_Cookie);
                    }
#endif // #if UNITY_IOS && ! UNITY_EDITOR
                    break;

                case AkCallbackType.AK_AudioSourceChange:
                    if (ms_sourceChangeCallbackPkg != null && ms_sourceChangeCallbackPkg.m_Callback != null)
                    {
                        AkAudioSourceChangeCallbackInfo.setCPtr(pData);
                        ms_sourceChangeCallbackPkg.m_Callback(AkAudioSourceChangeCallbackInfo.bOtherAudioPlaying, ms_sourceChangeCallbackPkg.m_Cookie);
                    }
                    break;

                case AkCallbackType.AK_Monitoring:
                    if (m_MonitoringCB != null)
                    {
                        AkMonitoringCallbackInfo.setCPtr(pData);
                        m_MonitoringCB(AkMonitoringCallbackInfo.errorCode, AkMonitoringCallbackInfo.errorLevel, AkMonitoringCallbackInfo.playingID,
                                       AkMonitoringCallbackInfo.gameObjID, AkMonitoringCallbackInfo.message);
                    }
#if UNITY_EDITOR
                    else if (AkSoundEngineController.Instance.engineLogging)
                    {
                        AkMonitoringCallbackInfo.setCPtr(pData);

                        string msg = "Wwise: " + AkMonitoringCallbackInfo.message;
                        if (AkMonitoringCallbackInfo.gameObjID != AkSoundEngine.AK_INVALID_GAME_OBJECT)
                        {
                            var obj = EditorUtility.InstanceIDToObject((int)AkMonitoringCallbackInfo.gameObjID) as GameObject;
                            if (obj != null)
                            {
                                msg += " (GameObject: " + obj.ToString() + ")";
                            }

                            msg += " (Instance ID: " + AkMonitoringCallbackInfo.gameObjID.ToString() + ")";
                        }

                        if (AkMonitoringCallbackInfo.errorLevel == AkMonitorErrorLevel.ErrorLevel_Error)
                        {
                            Debug.LogError(msg);
                        }
                        else
                        {
                            Debug.Log(msg);
                        }
                    }
#endif
                    break;

                case AkCallbackType.AK_Bank:
                    BankCallbackPackage bankPkg = null;
                    if (!m_mapBankCallbacks.TryGetValue((int)pPackage, out bankPkg))
                    {
                        Debug.LogError("WwiseUnity: BankCallbackPackage not found for <" + pPackage + ">.");
                        return(numCallbacks);
                    }
                    else
                    {
                        m_mapBankCallbacks.Remove((int)pPackage);

                        if (bankPkg != null && bankPkg.m_Callback != null)
                        {
                            AkBankCallbackInfo.setCPtr(pData);
                            bankPkg.m_Callback(AkBankCallbackInfo.bankID, AkBankCallbackInfo.inMemoryBankPtr, AkBankCallbackInfo.loadResult,
                                               (uint)AkBankCallbackInfo.memPoolId, bankPkg.m_Cookie);
                        }
                    }
                    break;

                default:
                    EventCallbackPackage eventPkg = null;
                    if (!m_mapEventCallbacks.TryGetValue((int)pPackage, out eventPkg))
                    {
                        Debug.LogError("WwiseUnity: EventCallbackPackage not found for <" + pPackage + ">.");
                        return(numCallbacks);
                    }
                    else
                    {
                        AkCallbackInfo info = null;

                        switch (eType)
                        {
                        case AkCallbackType.AK_EndOfEvent:
                            m_mapEventCallbacks.Remove(eventPkg.GetHashCode());
                            if (eventPkg.m_bNotifyEndOfEvent)
                            {
                                AkEventCallbackInfo.setCPtr(pData);
                                info = AkEventCallbackInfo;
                            }
                            break;

                        case AkCallbackType.AK_MusicPlayStarted:
                            AkEventCallbackInfo.setCPtr(pData);
                            info = AkEventCallbackInfo;
                            break;

                        case AkCallbackType.AK_EndOfDynamicSequenceItem:
                            AkDynamicSequenceItemCallbackInfo.setCPtr(pData);
                            info = AkDynamicSequenceItemCallbackInfo;
                            break;

                        case AkCallbackType.AK_MIDIEvent:
                            AkMIDIEventCallbackInfo.setCPtr(pData);
                            info = AkMIDIEventCallbackInfo;
                            break;

                        case AkCallbackType.AK_Marker:
                            AkMarkerCallbackInfo.setCPtr(pData);
                            info = AkMarkerCallbackInfo;
                            break;

                        case AkCallbackType.AK_Duration:
                            AkDurationCallbackInfo.setCPtr(pData);
                            info = AkDurationCallbackInfo;
                            break;

                        case AkCallbackType.AK_MusicSyncUserCue:
                        case AkCallbackType.AK_MusicSyncBar:
                        case AkCallbackType.AK_MusicSyncBeat:
                        case AkCallbackType.AK_MusicSyncEntry:
                        case AkCallbackType.AK_MusicSyncExit:
                        case AkCallbackType.AK_MusicSyncGrid:
                        case AkCallbackType.AK_MusicSyncPoint:
                            AkMusicSyncCallbackInfo.setCPtr(pData);
                            info = AkMusicSyncCallbackInfo;
                            break;

                        case AkCallbackType.AK_MusicPlaylistSelect:
                            AkMusicPlaylistCallbackInfo.setCPtr(pData);
                            info = AkMusicPlaylistCallbackInfo;
                            break;

                        default:
                            Debug.LogError("WwiseUnity: PostCallbacks aborted due to error: Undefined callback type <" + eType + "> found. Callback object possibly corrupted.");
                            return(numCallbacks);
                        }

                        if (info != null)
                        {
                            eventPkg.m_Callback(eventPkg.m_Cookie, eType, info);
                        }
                    }
                    break;
                }
            }

            return(numCallbacks);
        }
        finally
        {
            AkCallbackSerializer.Unlock();
        }
    }