assets/MeshProcessor.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            MeshProcessor.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 "MeshProcessor.h"
#include "../core/GameManager.h"


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

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

// Gets the mesh with the given filename.
IAnimatedMesh* MeshProcessor::getMesh(const std::string &fileName)
{
    std::map<std::string, IAnimatedMesh*>::iterator it = mMeshes.find(fileName);

    if(it != mMeshes.end())
      return it->second;

    return 0;
}

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

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

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

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

    // Read the texture.
    IAnimatedMesh *mesh = pSceneMgr->getMesh(fileName.c_str());

    if(mesh)
    {
       // Store the mesh.
       mMeshes[fileName] = mesh;
       mesh->grab();

       // Remove the mesh from Irrlicht's global mesh cache.
       GameManager::Instance()->getSceneManager()->getMeshCache()->removeMesh(mesh);

       // Handle events.
       if(mIsReloading)
         pParent->emitEvent(std::string("meshes/") + fileName, mesh);

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

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

    return (mesh) ? true : false;
}

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

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

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

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

    // Read the meshes.
    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 mesh.
        IAnimatedMesh *mesh = pSceneMgr->getMesh(fileName.c_str());

        if(mesh)
        {
           // Store the mesh.
           mMeshes[fileName] = mesh;
           mesh->grab();

           // Remove the mesh from Irrlicht's global mesh cache.
           GameManager::Instance()->getSceneManager()->getMeshCache()->removeMesh(mesh);

           // Handle events.
           if(mIsReloading)
             pParent->emitEvent(std::string("meshes/") + fileName, mesh);

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

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

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

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

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

    mIsReloading = false;

    return succeeded;
}

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

    removeAssets();
    loadAssets();

    mIsReloading = false;
}

// Removes the asset with the given filename.
bool MeshProcessor::removeAsset(const std::string &fileName)
{
    // Try to find the given mesh.
    std::map<std::string, IAnimatedMesh*>::iterator it = mMeshes.find(fileName);

    // Did we find the mesh?
    if(it != mMeshes.end())
    {
       // Handle events.
       if(!mIsReloading)
       {
          std::string slotName = std::string("meshes/") + it->first;

          pParent->emitEvent(slotName, NULL);
          pParent->removeEventSlot(slotName);
       }

       // Delete the mesh.
       IAnimatedMesh *mesh = it->second;
       mesh->drop();
       mMeshes.erase(it);

       return true;
    }

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

// Removes all asssets.
void MeshProcessor::removeAssets()
{
    // Delete the meshes.
    std::map<std::string, IAnimatedMesh*>::iterator it;

    for(it = mMeshes.begin(); it != mMeshes.end(); it++)
    {
       // Handle events.
       if(!mIsReloading)
       {
          std::string slotName = std::string("meshes/") + it->first;

          pParent->emitEvent(slotName, NULL);
          pParent->removeEventSlot(slotName);
       }

       // Delete the mesh.
       IAnimatedMesh *mesh = it->second;
       mesh->drop();
    }

    // Clear the mesh map.
    mMeshes.clear();
}

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

// End of File

---