SO3ResourceLoader.cpp

Go to the documentation of this file.

 
#include "SO3Material/SO3ResourceLoader.h"
#include "SO3Material/SO3Material.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3Exception.h"
 
template<> SO3::SResourceLoader* Ogre::Singleton<SO3::SResourceLoader>::msSingleton = 0;
 
namespace SO3
{
 
  SResourceLoader::SResourceLoader()
  {
    mScene = 0;
  }
 
  SResourceLoader::~SResourceLoader()
  {
  }
 
  SResourceLoader* SResourceLoader::getSingletonPtr()
  {
    return msSingleton;
  }
 
  SResourceLoader& SResourceLoader::getSingleton()
  {
    assert(msSingleton);
    return (*msSingleton);
  }
 
  void SResourceLoader::SetResourceScene(SScene* scene)
  {
    mScene = scene;
  }
 
  void SResourceLoader::SyncParsedMaterials()
  {
    //update ogre material pointer
    for (auto & material : mMaterialList)
    {
      material->_UpdateOgreMaterialPointer();
      material->_BindTechniquesToOgre();
    }
    
    mMaterialList.clear();
  }
 
  bool SResourceLoader::handleEvent(Ogre::ScriptCompiler* compiler, Ogre::ScriptCompilerEvent* evt, void* retval)
  {
    // Get the type of the resource parsed by the script compiler
    bool processed = false;
 
    // If a scene was setted
    if (mScene != 0)
    {
      // A material start to be loaded from script
      if (evt->mType == Ogre::CreateMaterialScriptCompilerEvent::eventType)
      {
        // Convert the event.
        Ogre::CreateMaterialScriptCompilerEvent* convertedEvent = static_cast<Ogre::CreateMaterialScriptCompilerEvent*>(evt);
 
        // Create a new empty material using so3 class
        try
        {
          // An SException can be throwed here, so catch it!
          SMaterial* newMaterial = mScene->GetMaterial(convertedEvent->mResourceGroup, convertedEvent->mName, false);
 
          if (newMaterial != 0)
          {
            mMaterialList.push_back(newMaterial);
            return processed;
          }
 
          newMaterial = mScene->CreateMaterial(convertedEvent->mResourceGroup, convertedEvent->mName, true);
 
          // Check if the material creation was successful
          if (newMaterial != 0)
          {
            // Ok, continue.
            Ogre::MaterialPtr ogreMaterial = newMaterial->getOgreMaterialPointer();
 
            // Get the newly created Ogre::Material (in SMaterial) and return it to the script compiler, it will populate it!
            Ogre::Material** retMaterial = (Ogre::Material**)retval;
            *retMaterial = ogreMaterial.get();
            
            mMaterialList.push_back(newMaterial);
            
            // Tell Ogre that we have created the Ogre::Material, he do not need to do it.
            processed = true;
          }
        }
        catch (const SException&)
        {          
          // Do nothing, the exception content is already logged to log file by the SException ctor.
        }
      }
 
      // A material finished it's loading from script process
      /*
      if(evt->mType == Ogre::PreApplyTextureAliasesScriptCompilerEvent::eventType)
      {
        // Convert the event.
        Ogre::PreApplyTextureAliasesScriptCompilerEvent* convertedEvent = static_cast<Ogre::PreApplyTextureAliasesScriptCompilerEvent*>(evt);
 
        // Get the SO3 material
        SMaterial* material = mScene->GetMaterial(convertedEvent->mMaterial->getGroup(), convertedEvent->mMaterial->getName());
 
        // Bind loaded techniques to the material
        if (material != 0)
        {
          //update ogre material pointer
          material->_UpdateOgreMaterialPointer();
          material->_BindTechniquesToOgre();
        }
 
        // Tell Ogre that we have processed this event. In fact, Ogre's ignore this return value for PreApplyTextureAliasesScriptCompilerEvent events.
        processed = true;
      }
      */
    }
    return processed;
  }
 
}