assets/SoundProcessor.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            SoundProcessor.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           AssetProcessor for processing meshes in an AssetGroup.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "SoundProcessor.h"

#ifdef __COMPILE_WITH_SFML_AUDIO__

#include "../core/GameManager.h"
#include <algorithm>


// SoundProcessor class
// SoundProcessor constructor.
SoundProcessor::SoundProcessor(AssetGroup *parent)
: AssetProcessor(parent, "sounds"), mIsReloading(false)
{
}

// SoundProcessor deconstructor.
SoundProcessor::~SoundProcessor()
{
    removeAssets();
}

// Gets the sound with the given filename.
bool SoundProcessor::getSound(const std::string &fileName, c8 *& buffer, long &length)
{
#ifdef WIN32
        std::string tmp = fileName;
        std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
    std::map<std::string, std::pair<c8*, long> >::iterator it = mSounds.find(tmp);
#else
    std::map<std::string, std::pair<c8*, long> >::iterator it = mSounds.find(fileName);
#endif

    if(it != mSounds.end())
    {
       buffer = (it->second).first;
       length = (it->second).second;
       return true;
    }

    return false;
}

// Loads the mesh with the given filename.
bool SoundProcessor::loadAsset(const std::string &fileName)
{
    // Retrieve pointers to sub-sytems of the Irrlicht engine.
    IFileSystem *fileSystem = GameManager::Instance()->getDevice()->getFileSystem();

    // Change the working directory to the sounds directory.
    std::string workingDir = (fileSystem->getWorkingDirectory()).c_str();

    if(!fileSystem->changeWorkingDirectoryTo( (pParent->getBaseDir()).c_str() ) )
      return false;

    if(!fileSystem->changeWorkingDirectoryTo("./sounds/"))
      return false;

    // Load the sound.
    IReadFile *file = fileSystem->createAndOpenFile(fileName.c_str());

    if(file)
    {
       // Retrieve data.
       long fSize = file->getSize();
       c8 *fBuffer = new c8[fSize+1];
       memset(fBuffer, 0, fSize+1);

       file->read(fBuffer, fSize);
       file->drop();

       // Store data.
       mSounds[fileName] = std::pair<c8*, long>(fBuffer, fSize);
       cout << "Loaded sound: " << fileName << "\n";

       // Handle events.
       if(mIsReloading)
         pParent->emitEvent(std::string("sounds/") + fileName, &mSounds[fileName]);

       else
         pParent->createEventSlot(std::string("sounds/") + fileName);
    }

    // Clean up.
    fileSystem->changeWorkingDirectoryTo(workingDir.c_str());

    return (file) ? true : false;
}

// Loads the meshes associated with this asset group.
void SoundProcessor::loadAssets()
{
    // Retrieve pointers to sub-sytems of the Irrlicht engine.
    IFileSystem *fileSystem = GameManager::Instance()->getDevice()->getFileSystem();

    // Change the working directory to the sounds directory.
    std::string workingDir = (fileSystem->getWorkingDirectory()).c_str();

    if(!fileSystem->changeWorkingDirectoryTo( (pParent->getBaseDir()).c_str() ) )
      return;

    if(!fileSystem->changeWorkingDirectoryTo("./sounds/"))
      return;

    // Read the textures.
    IFileList *fileList = fileSystem->createFileList();

    for(u32 i = 0; i < fileList->getFileCount(); i++)
    {
        // Get file name.
        std::string fileName = (fileList->getFileName(i)).c_str();

        if(fileName == "..")
          continue;

        // Load the sound.
        IReadFile *file = fileSystem->createAndOpenFile(fileName.c_str());

        if(file)
        {
           // Retrieve data.
           long fSize = file->getSize();
           c8 *fBuffer = new c8[fSize+1];
           memset(fBuffer, 0, fSize+1);

           file->read(fBuffer, fSize);
           file->drop();

           // Store data.
           mSounds[fileName] = std::pair<c8*, long>(fBuffer, fSize);
           cout << "Loaded sound: " << fileName << "\n";

           // Handle events.
           if(mIsReloading)
             pParent->emitEvent(std::string("sounds/") + fileName, &mSounds[fileName]);

           else
             pParent->createEventSlot(std::string("sounds/") + fileName);
        }
    }

    // Clean up.
    fileList->drop();

    fileSystem->changeWorkingDirectoryTo(workingDir.c_str());
}

// Reloads the asset with the given filename.
bool SoundProcessor::reloadAsset(const std::string &fileName)
{
    mIsReloading = true;

    removeAsset(fileName);
    bool succeeded = loadAsset(fileName);

    mIsReloading = false;

    return succeeded;
}

// Reloads all assets.
void SoundProcessor::reloadAssets()
{
    mIsReloading = true;

    removeAssets();
    loadAssets();

    mIsReloading = false;
}

// Removes the asset with the given filename.
bool SoundProcessor::removeAsset(const std::string &fileName)
{
    // Try to find the given sound.
#ifdef WIN32
        std::string tmp = fileName;
        std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
    std::map<std::string, std::pair<c8*, long> >::iterator it = mSounds.find(tmp);
#else
    std::map<std::string, std::pair<c8*, long> >::iterator it = mSounds.find(fileName);
#endif

    // Did we find the sound?
    if(it != mSounds.end())
    {
       // Handle events.
       if(!mIsReloading)
       {
          std::string slotName = std::string("sounds/") + it->first;
          std::pair<c8*, long> emptySound = std::pair<c8*, long>(NULL, 0);

          pParent->emitEvent(slotName, &emptySound);
          pParent->removeEventSlot(slotName);
       }

       // Delete the sound.
       c8 *fBuffer = (it->second).first;
       delete [] fBuffer;
       mSounds.erase(it);

       return true;
    }

    // We didn't find the sounds.
    else return false;
}

// Removes all asssets.
void SoundProcessor::removeAssets()
{
// Delete the sounds.
    std::map<std::string, std::pair<c8*, long> >::iterator it;

    for(it = mSounds.begin(); it != mSounds.end(); it++)
    {
       // Handle events.
       std::string slotName = std::string("sounds/") + it->first;
       std::pair<c8*, long> emptySound = std::pair<c8*, long>(NULL, 0);

       pParent->emitEvent(slotName, &emptySound);

       if(!mIsReloading)
         pParent->removeEventSlot(slotName);

       // Delete the sound.
       c8 *fBuffer = (it->second).first;
       delete [] fBuffer;
    }

    // Clear the sounds map.
    mSounds.clear();
}

// Creates a new SoundProcessor.
AssetProcessor* SoundProcessor::createProcessor(AssetGroup *parent)
{
    return new SoundProcessor(parent);
}

#endif // __COMPILE_WITH_SFML_AUDIO__

// End of File

---