Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 3658 in orxonox.OLD for orxonox/trunk/src/lib/util


Ignore:
Timestamp:
Mar 27, 2005, 7:44:39 PM (19 years ago)
Author:
bensch
Message:

orxonox/trunk: resource manager working, player uses it.

Location:
orxonox/trunk/src/lib/util
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • orxonox/trunk/src/lib/util/resource_manager.cc

    r3657 r3658  
    2323#include "texture.h"
    2424
     25#include "list.h"
     26
    2527// File Handling Includes
    2628#include <sys/types.h>
    … …  
    2830#include <unistd.h>
    2931
    30 
    3132using namespace std;
    3233
    33 
    3434/**
    3535   \brief standard constructor
    … …  
    3838{
    3939   this->setClassName ("ResourceManager");
    40    this->dataDir = NULL;
     40   dataDir = NULL;
     41   imageDirs = new tList<char>();
     42   resourceList = new tList<Resource>();
    4143}
    4244
    … …  
    4850}
    4951
     52//! Singleton Reference to the ResourceManager
    5053ResourceManager* ResourceManager::singletonRef = NULL;
     54//! The List of Resources, that has already been loaded.
     55tList<Resource>* ResourceManager::resourceList = NULL;
     56//! The Data Directory, where all relevant Data is stored.
     57char* ResourceManager::dataDir = NULL;
     58//! A list of directories in which images are stored.
     59tList<char>* ResourceManager::imageDirs = NULL;
    5160
    5261/**
    … …  
    5564ResourceManager::~ResourceManager (void)
    5665{
     66
     67  delete resourceList;
     68  resourceList = NULL;
    5769  ResourceManager::singletonRef = NULL;
    5870}
    59 
    60 
    6171
    6272/**
    … …  
    6878  if (isDir(dataDir))
    6979    {
    70       this->dataDir = new char[strlen(dataDir)+1];
    71       strcpy(this->dataDir, dataDir);
     80      ResourceManager::dataDir = new char[strlen(dataDir)+1];
     81      strcpy(ResourceManager::dataDir, dataDir);
    7282    }
    7383  else
    7484    {
    7585      PRINTF(1)("%s is not a Directory, and can not be the Data Directory\n", dataDir);
     86    }
     87}
     88
     89bool ResourceManager::addImageDir(char* imageDir)
     90{
     91  if (isDir(imageDir))
     92    {
     93      char* tmpDir  = new char[strlen(imageDir)+1];
     94      strcpy(tmpDir, imageDir);
     95      imageDirs->add(tmpDir);
     96    }
     97  else
     98    {
     99      PRINTF(1)("%s is not a Directory, and can not be added to the Paths of Images\n", dataDir);
    76100    }
    77101}
    … …  
    87111  if (!strncmp(fileName+(strlen(fileName)-4), ".obj", 4))
    88112    tmpType = OBJ;
     113  else if (!strncmp(fileName+(strlen(fileName)-4), ".wav", 4))
     114    tmpType = WAV;
     115  else if (!strncmp(fileName+(strlen(fileName)-4), ".mp3", 4))
     116    tmpType = MP3;
     117  else if (!strncmp(fileName+(strlen(fileName)-4), ".ogg", 4))
     118    tmpType = OGG;
     119  else if (!strcmp(fileName, "cube") ||
     120           !strcmp(fileName, "sphere") ||
     121           !strcmp(fileName, "plane") ||
     122           !strcmp(fileName, "cylinder") ||
     123           !strcmp(fileName, "cone"))
     124    tmpType = PRIM;
     125  else
     126    tmpType = IMAGE;
    89127
    90128  return ResourceManager::load(fileName, tmpType);
    … …  
    99137void* ResourceManager::load(const char* fileName, ResourceType type)
    100138{
    101   void* tmpResource = NULL;
    102   char* tmpName = new char[strlen(fileName)+1];
    103   strcpy(tmpName, fileName);
    104   // Checking for the type of resource \see ResourceType
    105   switch(type)
    106     {
    107     case OBJ:
    108       if(isFile(tmpName))
    109         tmpResource = new OBJModel(tmpName);
    110       else
     139  // searching if the resource was loaded before.
     140  Resource* tmpResource = ResourceManager::locateResourceByName(fileName);
     141  char* tmpDir;
     142  if (!tmpResource) // if the resource was not loaded before.
     143    {
     144      // Setting up the new Resource
     145      tmpResource = new Resource;
     146      tmpResource->count = 1;
     147      tmpResource->type = type;
     148      tmpResource->name = new char[strlen(fileName)+1];
     149      strcpy(tmpResource->name, fileName);
     150
     151      // creating the full name. (directoryName + FileName)
     152      char* fullName = new char[strlen(dataDir)+strlen(fileName)+1];
     153      sprintf(fullName, "%s%s", dataDir, fileName);
     154     
     155      // Checking for the type of resource \see ResourceType
     156      switch(type)
    111157        {
    112           PRINTF(2)("Sorry, %s does not exist. Loading a cube-Model instead\n", tmpName);
    113           tmpResource = new PrimitiveModel(CUBE);
     158        case OBJ:
     159          if(isFile(fullName))
     160            tmpResource->pointer = new OBJModel(fullName);
     161          else
     162            {
     163              PRINTF(2)("Sorry, %s does not exist. Loading a cube-Model instead\n", fullName);
     164              tmpResource->pointer = ResourceManager::load("cube", PRIM);
     165            }
     166          break;
     167        case PRIM:
     168          if (!strcmp(tmpResource->name, "cube"))
     169            tmpResource->pointer = new PrimitiveModel(CUBE);
     170          else if (!strcmp(tmpResource->name, "sphere"))
     171            tmpResource->pointer = new PrimitiveModel(SPHERE);
     172          else if (!strcmp(tmpResource->name, "plane"))
     173            tmpResource->pointer = new PrimitiveModel(PLANE);
     174          else if (!strcmp(tmpResource->name, "cylinder"))
     175            tmpResource->pointer = new PrimitiveModel(CYLINDER);
     176          else if (!strcmp(tmpResource->name, "cone"))
     177            tmpResource->pointer = new PrimitiveModel(CONE);
     178          break;
     179        case IMAGE:
     180          if(isFile(fullName))
     181            {
     182              tmpResource->pointer = new Texture(fullName);
     183            }
     184          else
     185            {
     186              tmpDir = imageDirs->enumerate();
     187              while(tmpDir)
     188                {
     189                  char* imgName = new char[strlen(tmpDir)+strlen(fileName)+1];
     190                  sprintf(imgName, "%s%s", tmpDir, fileName);
     191                  if(isFile(imgName))
     192                    tmpResource->pointer = new Texture(imgName);
     193                  delete []imgName;
     194                  tmpDir = imageDirs->nextElement();
     195                }
     196            }
     197          if(!tmpResource)
     198             PRINTF(2)("!!Image %s not Found!!\n", fileName);
     199          break;
     200        default:
     201          tmpResource->pointer = NULL;
     202          PRINTF(1)("No type found for %s.\n   !!This should not happen unless the Type is not supported yet.!!\n", tmpResource->name);
     203          break;
    114204        }
    115       break;
    116     case IMAGE:
    117       if(isFile(tmpName))
     205     
     206      // checking if the File really exists.
     207      if(!isFile(fullName))
    118208        {
    119           tmpResource = new Texture(tmpName);
     209          PRINTF(2)("Sorry, %s is not a regular file.\n", fullName);
     210          tmpResource->pointer = NULL;
    120211        }
    121       else
    122         PRINTF(1)("!!Texture %s not Found!!\n", tmpName);
    123       break;
    124     default:
    125       tmpResource = NULL;
    126       PRINTF(2)("No type found for %s.\n   !!This should not happen unless the Type is not supported yet.!!\n", tmpName);
    127       break;
    128     }
    129 
    130   // checking if the File really exists.
    131   if(!isFile(tmpName))
    132     {
    133       PRINTF(2)("Sorry, %s is not a regular file.\n", tmpName);
    134       tmpResource = NULL;
    135     }
    136   return tmpResource;
     212      resourceList->add(tmpResource);
     213      delete []fullName;
     214
     215    }
     216  else
     217    {
     218      tmpResource->count++;
     219    }
     220
     221  return tmpResource->pointer;
     222}
     223
     224/**
     225   \brief unloads a Resource
     226   \param pointer The pointer to free
     227   \returns true if successful (pointer found, and deleted), false otherwise
     228   
     229*/
     230bool ResourceManager::unload(void* pointer)
     231{
     232  // if pointer is existent. and only one resource of this type exists.
     233  Resource* tmpResource = ResourceManager::locateResourceByPointer(pointer);
     234  if (!tmpResource)
     235    {
     236      PRINTF(2)("Resource not Found %p\n", pointer);
     237      return false;
     238    }
     239  tmpResource->count--;
     240  if (tmpResource->count <= 0)
     241    {
     242      // deleting the Resource
     243      switch(tmpResource->type)
     244        {
     245        case OBJ:
     246        case PRIM:
     247          delete (Model*)tmpResource->pointer;
     248          break;
     249        case IMAGE:
     250          delete (Texture*)tmpResource->pointer;
     251          break;
     252        default:
     253          PRINTF(1)("NOT YET IMPLEMENTED FIX FIX\n");
     254          return false;
     255          break;
     256        }
     257      // deleting the List Entry:
     258      PRINTF(4)("Resource %s Safely removed.\n", tmpResource->name);
     259      delete []tmpResource->name;
     260      resourceList->remove(tmpResource);
     261    }
     262  else
     263    PRINTF(4)("Resource not removed, because there are still %d References to it.\n", tmpResource->count);
     264  return true;
     265}
     266
     267/**
     268   \brief Searches for a Resource by Name
     269   \param fileName The name to look for
     270   \returns a Pointer to the Resource if found, NULL otherwise.
     271*/
     272Resource* ResourceManager::locateResourceByName(const char* fileName)
     273{
     274  Resource* enumRes = resourceList->enumerate();
     275  while (enumRes)
     276    {
     277      if (!strcmp(fileName, enumRes->name))
     278        return enumRes;
     279      enumRes = resourceList->nextElement();
     280    }
     281  return NULL;
     282}
     283
     284/**
     285   \brief Searches for a Resource by Pointer
     286   \param pointer the Pointer to search for
     287   \returns a Pointer to the Resource if found, NULL otherwise.
     288*/
     289Resource* ResourceManager::locateResourceByPointer(const void* pointer)
     290{
     291  Resource* enumRes = resourceList->enumerate();
     292  while (enumRes)
     293    {
     294      if (pointer == enumRes->pointer);
     295        return enumRes;
     296      enumRes = resourceList->nextElement();
     297    }
     298  return NULL;
    137299}
    138300
    … …  
    148310  if (status.st_mode & (S_IFDIR | S_IFLNK))
    149311    return true;
    150   else 
     312  else
    151313    return false;
    152314}

  • orxonox/trunk/src/lib/util/resource_manager.h

    r3655 r3658  
    1515
    1616// FORWARD DEFINITION \\
     17//template<class T> class tList;
     18#include "list.h"                //! \todo do this by forward definition (ask Patrick)
     19enum ResourceType {OBJ, PRIM, WAV, MP3, OGG, IMAGE};
    1720
     21struct Resource
     22{
     23  void* pointer;             //!< Pointer to the Resource.
     24 
     25  char* name;                //!< Name of the Resource.
     26  ResourceType type;         //!< ResourceType of this Resource.
     27  int count;                 //!< How many times this Resource has been loaded.
     28};
    1829
    19 enum ResourceType {OBJ, WAV, MP3, OGG, IMAGE};
    2030
    2131//! The ResourceManager is a class, that decides if a file/resource should be loaded
    … …  
    3444  virtual ~ResourceManager();
    3545
    36   bool setDataDir(char* dataDir);
     46  static bool setDataDir(char* dataDir);
     47  static bool addImageDir(char* imageDir);
    3748  static void* load(const char* fileName);
    3849  static void* load(const char* fileName, ResourceType type);
     50  static bool unload(void* pointer);
    3951
    4052 private:
    … …  
    4254  static ResourceManager* singletonRef;
    4355
     56  static tList<Resource>* resourceList;
     57  static char* dataDir;
     58  static tList<char>* imageDirs;
    4459
    45   struct file;
    46   struct folder
    47   {
    48     char* name;
    49     folder** subfolders;             //!<
    50     file** files;                    //!< Files in the directory
    51   };
    52   struct file
    53   {
    54     char* name;                      //!< exact Name of a file
    55     void* pointer;
    56   };
    57 
    58   char* dataDir;                     //!< The main data directory
     60  static Resource* locateResourceByName(const char* fileName);
     61  static Resource* locateResourceByPointer(const void* pointer);
     62 
    5963
    6064  static bool isDir(const char* directory);
Note: See TracChangeset for help on using the changeset viewer.