SCOLResources.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
 
#include "SCOLPack/SO3SCOL.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Texture.h"
#include "SO3SceneGraph/SO3Scene.h"
 
 
//TODO REMOVE ?
int SO3AddResourceLocationURL(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AddResourceLocationURL\n");
#endif
 
  int p = MMpull(m);
  int group = MMget(m, 0);
  if (p == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  const char* resourceLocation = MMstartstr(m, MTOP(p));
 
  std::string groupResource;
  if (group == NIL)
    groupResource = Ogre::RGN_DEFAULT;
  else
    groupResource = std::string(MMstartstr(m, MTOP(group)));
 
  try
  {
    if (!checkGroupExists(groupResource))
    {
      Ogre::ResourceGroupManager::getSingleton().addResourceLocation(resourceLocation, "URL", groupResource);
      Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup(groupResource);
      Ogre::ResourceGroupManager::getSingleton().loadResourceGroup(groupResource);
    }
    else
    {
      Ogre::FileInfoListPtr finfo;
      Ogre::FileInfoList::iterator it;
      finfo = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(groupResource, "*");
      Ogre::ResourceGroupManager::getSingleton().clearResourceGroup(groupResource);
      for (it = finfo->begin(); it != finfo->end(); ++it)
      {
        if (!Ogre::ResourceGroupManager::getSingleton().resourceExists(groupResource, it->basename)) Ogre::ResourceGroupManager::getSingleton().addResourceLocation(it->archive->getName().c_str(), it->archive->getType(), groupResource);
      }
      Ogre::ResourceGroupManager::getSingleton().addResourceLocation(resourceLocation, "URL", groupResource);
      Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup(groupResource);
    }
    MMset(m, 0, ITOM(1));
    return 0;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
}
 
 
int SO3AddResourceLocationZIP(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AddResourceLocationZIP\n");
#endif
 
  bool exists = false;
 
  int p = MMpull(m);
  int group = MMget(m, 0);
  if (p == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string pathStd = MMstartstr(m, MTOP(p));
  if (pathStd.find(".zip") == std::string::npos)
  {
    MMechostr(MSKRUNTIME, "SO3AddResourceLocationZIP the file %s is not a .zip file", pathStd.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string groupResource;
  if (group == NIL)
    groupResource = Ogre::RGN_DEFAULT;
  else
    groupResource = std::string(MMstartstr(m, MTOP(group)));
 
  if (!checkGroupExists(groupResource))
  {
    MMechostr(MSKRUNTIME, "SO3AddResourceLocationZIP the group %s does not exist", groupResource.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    Ogre::ResourceGroupManager::getSingleton().addResourceLocation(pathStd, "Zip", groupResource, true);
    Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup(groupResource);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
//TODO insert Groupmap in scene, Use scene name as group index
int SO3GroupCreate(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3GroupCreate\n");
#endif
 
  int group = MMpull(m);
  int s = MMget(m, 0);
  if ((group == NIL) || (s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string groupResource = std::string(MMstartstr(m, MTOP(group)));
  groupResource = scene->GetName() + groupResource;
 
  if (checkGroupProtected(groupResource))
  {
    MMechostr(MSKDEBUG, "SO3Engine Exception : Group is Protected \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (checkGroupExists(groupResource))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    SRoot::getSingletonPtr()->AddManualRessourceGroup(groupResource);
    MMset(m, 0, ITOM(1));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
  }
 
  //TODO remove
  packdir mypack = (packdir)SCgetExtra("FirstPack");
  string pathStd;
  std::vector<string> partitions;
 
  while (mypack)
  {
    pathStd = mypack->path;
    for (unsigned int i = 0; i < pathStd.length(); i++)
    {
      if (pathStd.substr(i, 1) == "\\")
        pathStd.replace(i, 1, "/");
    }
    partitions.push_back(pathStd);
    mypack = mypack->next;
  }
  
  //for default resources for unified shaders
#ifdef _WIN32
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/OgreCore.zip", "Zip", groupResource, true);
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Plugins/Ogre_Redist/rtshaderlib.zip", "Zip", groupResource, true);
#elif defined(ANDROID)
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/ogrecore.zip", "APKZip", groupResource, true);
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/rtshaderlib.zip", "APKZip", groupResource, true);
#elif defined(SO3_USE_OPENGLES2)
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/ogrecore.zip", "Zip", groupResource, true);
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation("ogre_redist/rtshaderlib.zip", "Zip", groupResource, true);
#else //linux
std::string baseDir = (char*)SCgetExtra("scolExecDir");
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation(baseDir + "/ogre_redist/ogrecore.zip", "Zip", groupResource, true);
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation(baseDir + "/ogre_redist/rtshaderlib.zip", "Zip", groupResource, true);
#endif
 
  std::vector<string>::iterator iPartition = partitions.begin();
  while (iPartition != partitions.end())
  {
    Ogre::ResourceGroupManager::getSingleton().addResourceLocation((*iPartition), "ScolFileSystem", groupResource, false);
 
    iPartition++;
  }
 
  return 0;
}
 
 
int SO3GroupList(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3GroupList\n");
#endif
 
  int k = 0;
 
  int s = MMpull(m);
  if (s == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  Ogre::StringVector myStr = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
  std::vector<std::string> sceneGroups;
 
  for (unsigned int i = 0; i < myStr.size(); i++)
  {
    std::string loc = myStr[i];
    if ((loc.compare(0, scene->GetName().length(), scene->GetName()) == 0) && (loc.compare(scene->GetName().length(), loc.length(), Ogre::RGN_DEFAULT) != 0))
    {
      loc = loc.substr(scene->GetName().length());
      sceneGroups.push_back(loc);
      if (k = Mpushstrbloc(m, (char*)loc.c_str()))
        return k;
    }
  }
 
  if (MMpush(m, NIL))
    return MERRMEM;
 
  for (unsigned int i = 0; i < sceneGroups.size(); i++)
  {
    if (MMpush(m, 2 * 2))
      return MERRMEM;
    if (k = MBdeftab(m))
      return k;
  }
  return 0;
}
 
 
int SO3GroupDelete(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3GroupDelete\n");
#endif
 
  int group = MMpull(m);
  int s = MMget(m, 0);
  if ((group == NIL) || (s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string groupResource(MMstartstr(m, MTOP(group)));
  groupResource = scene->GetName() + groupResource;
 
  if (checkGroupProtected(std::string(groupResource)))
  {
    MMechostr(MSKRUNTIME, "SO3GroupDelete : Group is Protected \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!checkGroupExists(groupResource))
  {
    MMset(m, 0, NIL);
    MMechostr(MSKRUNTIME, "SO3GroupDelete : Group %s do not exist\n", groupResource.c_str());
    return 0;
  }
 
  // meshes
  const SNodeMap nodesListCopy = scene->GetNodeList();
  SNodeMap::const_iterator iNodeList = nodesListCopy.begin();
  while (iNodeList != nodesListCopy.end())
  {
    if (iNodeList->second->GetNodeType() == SNode::ENTITY_TYPE_ID)
    {
      SEntity* entity = static_cast <SEntity*> (iNodeList->second);
      if (entity->GetGroupName() == groupResource)
        OBJdelTH(m, SO3OBJTYPE, SCOL_PTR(entity));
    }
 
    iNodeList++;
  }
 
  //const Ogre::RenderSystemCapabilities* caps = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getCapabilities();
  //if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
  {
    // cleanup shaders before material (crash)
    try
    {
      Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques();
    }
    catch (Ogre::Exception &e)
    {
      MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    }
  }
 
  //$BB NEED to remove Scol and scene Resources from group ! material / textures / particle scripts ...
  const SMaterialMap* matmap = scene->GetMaterials(groupResource);
  if (matmap != 0)
  {
    SMaterialMap matmapCopy = (*matmap);
    SMaterialMap::iterator iMaterialList = matmapCopy.begin();
    while (iMaterialList != matmapCopy.end())
    {
      MMechostr(MSKDEBUG, ":>>> Delete SMaterial : %s\n", iMaterialList->second->GetName().c_str());
      OBJdelTH(m, SO3MATERIAL, SCOL_PTR(iMaterialList->second));
      iMaterialList++;
    }
  }
  scene->CleanGroupMaterials(groupResource);
 
  const STextureMap* texmap = scene->GetTextures(groupResource);
  if (texmap != 0)
  {
    STextureMap texmapCopy = (*texmap);
    STextureMap::iterator iTextureList = texmapCopy.begin();
    while (iTextureList != texmapCopy.end())
    {
      OBJdelTH(m, SO3TEXTURE, SCOL_PTR(iTextureList->second));
      iTextureList++;
    }
  }
  scene->CleanGroupTextures(groupResource);
 
  try
  {
    Ogre::ParticleSystemManager::getSingleton().removeTemplatesByResourceGroup(groupResource);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
  }
 
  try
  {
    SRoot::getSingletonPtr()->RemoveManualRessourceGroup(groupResource);
    MMset(m, 0, ITOM(1));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  return 0;
}
 
int SO3GroupReload(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3GroupReload\n");
#endif
 
  int group = MMpull(m);
  int s = MMget(m, 0);
  if ((group == NIL) || (s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string groupResource(MMstartstr(m, MTOP(group)));
  groupResource = scene->GetName() + groupResource;
 
  if (checkGroupProtected(std::string(groupResource)))
  {
    MMechostr(MSKDEBUG, "SO3Engine Exception : Group is Protected \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!checkGroupExists(groupResource))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    Ogre::ResourceGroupManager::getSingleton().unloadResourceGroup(groupResource);
    Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup(groupResource);
    Ogre::ResourceGroupManager::getSingleton().loadResourceGroup(groupResource);
    Ogre::GpuProgramManager::getSingletonPtr()->reloadAll(true);
    Ogre::GpuProgramManager::getSingletonPtr()->reloadAll(true);
    scene->O3TextureManager->reloadAll(true);
    scene->O3MaterialManager->reloadAll(true);
    scene->O3MeshManager->reloadAll(true);
    scene->ReloadEntities();
    MMset(m, 0, ITOM(1));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  return 0;
}
 
//TODO REMOVE
int SO3AddResourceLocationDirectory(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AddResourceLocationDirectory\n");
#endif
 
  int p = MMpull(m);
  int group = MMget(m, 0);
  if (p == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    const char* groupResource;
    if (group == NIL)
      groupResource = Ogre::RGN_DEFAULT;
    else
      groupResource = MMstartstr(m, MTOP(group));
 
    const char* resourceLocation = MMstartstr(m, MTOP(p));
    /* SCOL Partition Manipulation */
    /* NB : This function does not work when a check pack scol is calling so material can't be loaded with SO3SceneLoadResource */
 
    packdir mypack = (packdir)SCgetExtra("FirstPack");
    string pathStd;
    std::vector<string> partitions;
    while (mypack)
    {
      pathStd = mypack->path;
 
      for (unsigned int i = 0; i < pathStd.length(); i++)
      {
        if (pathStd.substr(i, 1) == "\\") pathStd.replace(i, 1, "/");
      }
 
      partitions.push_back(pathStd);
      mypack = mypack->next;
    }
 
    /* Adding resource location for all partitions with recursive boolean to "true" */
    std::vector<string>::reverse_iterator iPartition = partitions.rbegin();
    while (iPartition != partitions.rend())
    {
      (*iPartition) += resourceLocation;
      Ogre::ResourceGroupManager::getSingleton().addResourceLocation((*iPartition), "ScolFileSystem", groupResource, true);
 
      iPartition++;
    }
    MMset(m, 0, ITOM(1));
    return 0;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  return 0;
}
 
 
NativeDefinition natSO3Res[] = {
  { "SO3GroupCreate",                  2, "fun [SO3_SCENE S] I",                SO3GroupCreate                   },
  { "SO3GroupDelete",                  2, "fun [SO3_SCENE S] I",                SO3GroupDelete                   },
  { "SO3GroupReload",                  2, "fun [SO3_SCENE S] I",                SO3GroupReload                   },
  { "SO3GroupList",                    1, "fun [SO3_SCENE] [S r1]",     SO3GroupList                     },
  { "SO3AddResourceLocationURL",       2, "fun [S S] I",                                                SO3AddResourceLocationURL        },
  { "SO3AddResourceLocationZIP",       2, "fun [S P] I",                                                SO3AddResourceLocationZIP        },
  { "SO3AddResourceLocationDirectory", 2, "fun [S S] I",                                                SO3AddResourceLocationDirectory  }
};
 
 
int SCOLloadResources(mmachine m, cbmachine w)
{
  return PKhardpak2(m, "SO3Res.pkg", sizeof(natSO3Res) / sizeof(natSO3Res[0]), natSO3Res);
}
 
 
int SCOLfreeResources()
{
  return 0;
}