wwise.cpp

#include <AK/SoundEngine/Common/AkMemoryMgr.h>                      // memory manager interface
#include <AK/SoundEngine/Common/AkModule.h>                         // default memory manager

#include <AK/SoundEngine/Common/IAkStreamMgr.h>                     // streaming manager interface
#include <AK/Tools/Common/AkPlatformFuncs.h>                        // thread definitions
#include <AK/SoundEngine/Win32/AkFilePackageLowLevelIOBlocking.h>   // sample low-level I/O implementation

#include <AK/SoundEngine/Common/AkSoundEngine.h>                    // actual sound engine header

#include <AK/MusicEngine/Common/AkMusicEngine.h>                    // music engine

#include <AK/SpatialAudio/Common/AkSpatialAudio.h>                  // spatial audio

#ifndef AK_OPTIMIZED                                                // AK_OPTIMIZED is only used in Release configuration

//#include <AK/Comm/AkCommunication.h>

#endif

#include "util.h"
#include "wwise.h"
#include "Wwise_IDs.h"
#include <Windows.h>

namespace AdventureEngine {

    WwiseManager::WwiseManager() {
#define AK_WIN
    }

    WwiseManager::~WwiseManager() {
        // terminate in reverse order of initialization
#ifndef AK_OPTIMIZED
        /*
        AK::Comm::Term();
        */
#endif

        //AK::SpatialAudio::Term();
        AK::MusicEngine::Term();
        AK::SoundEngine::Term();
        g_lowLevelIO.Term();
        if (AK::IAkStreamMgr::Get()) {
            AK::IAkStreamMgr::Get()->Destroy();
        }
        AK::MemoryMgr::Term();
    }

    bool WwiseManager::InitMemoryManager() {
        AkMemSettings memSettings;
        AK::MemoryMgr::GetDefaultSettings(memSettings);
        if (AK::MemoryMgr::Init(&memSettings) != AK_Success) {
            Util::Print("[WwiseManager::InitMemoryManager] Could not create the memory manager :(");
            return false;
        }

        return true;
    }

    bool WwiseManager::InitStreamingManager() {
        AkStreamMgrSettings streamSettings;                 // create & init instance of default streaming manager
        AK::StreamMgr::GetDefaultSettings(streamSettings);  // Note this can be overwritten

        // customnized stream manager settings go here

        AK::IAkStreamMgr * pStreamMgr = AK::StreamMgr::Create(streamSettings);
        AKASSERT(pStreamMgr);

        // create streaming device with low-level I/O handshaking
        // note this can be overwritten

        AkDeviceSettings deviceSettings;
        AK::StreamMgr::GetDefaultDeviceSettings(deviceSettings);

        // creates a streaming device in stream manager,
        // and registers itself as the File Location Resolver
        AKRESULT ioResult = g_lowLevelIO.Init(deviceSettings);
        AKASSERT(AK_Success == ioResult);

        return true;
    }

    bool WwiseManager::CreateSoundEngine() {
        // using default init parameters
        AkInitSettings initSettings;
        AkPlatformInitSettings platformInitSettings;
        AK::SoundEngine::GetDefaultInitSettings(initSettings);
        AK::SoundEngine::GetDefaultPlatformInitSettings(platformInitSettings);

        AKRESULT engineResult = AK::SoundEngine::Init(&initSettings, &platformInitSettings);
        AKASSERT(AK_Success == engineResult);

        return true;
    }

    bool WwiseManager::InitMusicEngine() {
        // initialize music engine using default parameters
        AkMusicSettings musicSettings;
        AK::MusicEngine::GetDefaultInitSettings(musicSettings);

        AKRESULT musicResult = AK::MusicEngine::Init(&musicSettings);
        AKASSERT(AK_Success == musicResult);

        return true;
    }

    bool WwiseManager::InitSpatialAudio() {
        // using default parameters

            //constructor fills AkSpatialAudioInitSettings w/ recommended defaults
        AkSpatialAudioInitSettings spatialSettings;

        AKRESULT spatialResult = AK::SpatialAudio::Init(spatialSettings);
        AKASSERT(AK_Success == spatialResult);

        return true;
    }

    bool WwiseManager::LoadBanks() {
        // setup bank path
        g_lowLevelIO.SetBasePath(AKTEXT("../Wwise_Adventure/GeneratedSoundBanks/Windows/"));
        AK::StreamMgr::SetCurrentLanguage(AKTEXT("English(US)"));

        // load banks synchronously
        AKRESULT initResult = AK::SoundEngine::LoadBank(AK::BANKS::INIT);
        if (initResult != AK_Success) {
            Util::Print("[WwiseManager::LoadBanks] Failed to load Init bank");
            Util::Print("initResult is " + std::to_string(initResult));
            return false;
        }

        AKRESULT musicResult = AK::SoundEngine::LoadBank(AK::BANKS::MUSIC);
        if (musicResult != AK_Success) {
            Util::Print("[WwiseManager::LoadBanks] Failed to load Music bank");
            return false;
        }

        return true;
    }

    bool WwiseManager::RegisterObjects() {
        AKRESULT listenerResult = AK::SoundEngine::RegisterGameObj(Listener, "Default Listener");
        AKRESULT regListenerResult = AK::SoundEngine::SetDefaultListeners(&Listener, 1);
        if (listenerResult != AK_Success) {
            Util::Print("[WwiseManager::RegisterObjects] Failed to register Default Listener object.");
            Util::Print("listenerResult is " + std::to_string(listenerResult));
            return false;
        }

        AKRESULT regMusicResult = AK::SoundEngine::RegisterGameObj(MusController, "MusicController");
        if (regMusicResult != AK_Success) {
            Util::Print("[WwiseManager::RegisterObjects] Failed to register MusicController.");
            Util::Print("regMusicResult is " + std::to_string(regMusicResult));
            return false;
        }

        return true;
    }

    bool WwiseManager::UnregisterObjects() {
        AKRESULT unregResult = AK::SoundEngine::UnregisterAllGameObj();
        if (unregResult != AK_Success) {
            Util::Print("[WwiseManager::UnregisterObjects] Failed to unregister all gameObjects");
            return false;
        }

        return true;
    }

    /*
#ifndef AK_OPTIMIZED

    bool WwiseManager::InitComms() {
        // method should not be called in release build;
            // only called when not using AK_OPTIMIZED
        AkCommSettings commSettings;
        AK::Comm::GetDefaultInitSettings(commSettings);
        if (AK::Comm::Init(commSettings) != AK_Success) {
            Util::Print("[WwiseManager::InitComms] Could not initialize comms :(");
            return false;
        }

        return true;
    }

#endif
*/
    bool WwiseManager::InitSoundEngine() {
        if (!InitMemoryManager()) {
            return false;
        }

        if (!InitStreamingManager()) {
            return false;
        }

        if (!CreateSoundEngine()) {
            return false;
        }

        if (!InitMusicEngine()) {
            return false;
        }

        if (!InitSpatialAudio()) {
            return false;
        }

        if (!LoadBanks()) {
            return false;
        }

        if (!RegisterObjects()) {
            return false;
        }

        //init comms
        /*
#ifndef AK_OPTIMIZED

        if (!InitComms()) {
            return false;
        }

#endif
*/
        return true;
    }

    void WwiseManager::Post(AkUniqueID eventId, AkGameObjectID gameObjectId, AkCallbackFunc callback) {
        AK::SoundEngine::PostEvent(eventId, gameObjectId, 0U, callback);

        // Process bank requests, events, positions, RTPCs, etc.
        AK::SoundEngine::RenderAudio(false);
    }
}