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

Timestamp:

Mar 26, 2005, 3:28:39 PM (20 years ago)

Author:

bensch

Message:

orxonox/trunk: moved protoclass to folder proto
added protosingleton
added resourceManager
modiefied some stuff to work better

Location:

orxonox/trunk/src/lib/util

Files:

• resource_manager.cc (copied) (copied from orxonox/trunk/src/proto_class.cc) (3 diffs)
• resource_manager.h (moved) (moved from orxonox/trunk/src/proto_class.h) (1 diff)

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

@@ -1 @@
-
-
 /* 
    orxonox - the future of 3D-vertical-scrollers
@@ -12 +10 @@
 
    ### File Specific:
-   main-programmer: ...
+   main-programmer: Benjamin Grauer
    co-programmer: ...
 */
 
-#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
+#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOAD
 
-#include "proto_class.h"
+#include "resource_manager.h"
 
-#include "stdincl.h" // maybe
+// different resource Types
+#include "objModel.h"
+#include "texture.h"
+
+// File Handling Includes
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
 
 using namespace std;
@@ -27 +33 @@
 /**
    \brief standard constructor
-   \todo this constructor is not jet implemented - do it
 */
-ProtoClass::ProtoClass () 
+ResourceManager::ResourceManager () 
 {
-   this->setClassName ("ProtoClass");
+   this->setClassName ("ResourceManager");
+   this->dataDir = NULL;
+}
+
+ResourceManager* ResourceManager::getInstance(void)
+{
+  if (!ResourceManager::singletonRef)
+    ResourceManager::singletonRef = new ResourceManager();
+  return ResourceManager::singletonRef;
+}
+
+ResourceManager* ResourceManager::singletonRef = NULL;
+
+/**
+   \brief standard deconstructor
+*/
+ResourceManager::~ResourceManager (void) 
+{
+  ResourceManager::singletonRef = NULL;
 }
 
 
+
 /**
-   \brief standard deconstructor
-
+   \brief sets the data main directory
+   \param dataDir the DataDirectory.
 */
-ProtoClass::~ProtoClass () 
+bool ResourceManager::setDataDir(char* dataDir)
 {
-  // delete what has to be deleted here
+  if (isDir(dataDir))
+    {
+      this->dataDir = new char[strlen(dataDir)+1];
+      strcpy(this->dataDir, dataDir);
+    }
+  else
+    {
+      PRINTF(1)("%s is not a Directory, and can not be the Data Directory\n", dataDir);
+    }
 }
 
 /**
-   \brief nonsense - delete this method
-   \param realy nothing to give
-   \returns true or false - probably nothing?
+   \brief loads resources
+   \param fileName The fileName of the resource to load
+   \returns a pointer to a desired Resource.
+*/
+void* ResourceManager::load(const char* fileName)
+{
+  ResourceType tmpType;
+  if (!strncmp(fileName+(strlen(fileName)-4), ".obj", 4))
+    tmpType = OBJ;
 
-   this is just to show the doxygen abilities (this for example is an extension for a long comment)
+  return ResourceManager::load(fileName, tmpType);
+}
+
+/**
+   \brief loads resources
+   \param fileName The fileName of the resource to load
+   \param type The Type of Resource to load (\see ResourceType)
+   \returns a pointer to a desired Resource.
 */
-bool ProtoClass::doNonSense (int nothing) {}
+void* ResourceManager::load(const char* fileName, ResourceType type)
+{
+  void* tmpResource = NULL;
+  char* tmpName = new char[strlen(fileName)+1];
+  strcpy(tmpName, fileName);
+  // Checking for the type of resource \see ResourceType
+  switch(type)
+    {
+    case OBJ:
+      if(isFile(tmpName))
+        tmpResource = new OBJModel(tmpName);
+      else
+        {
+          PRINTF(2)("Sorry, %s does not exist. Loading a cube-Model instead\n", tmpName);
+          tmpResource = new Model(CUBE);
+        }
+      break;
+    case IMAGE:
+      if(isFile(tmpName))
+        {
+          tmpResource = new Texture(tmpName);
+        }
+      else
+        PRINTF(1)("!!Texture %s not Found!!\n", tmpName);
+      break;
+    default:
+      tmpResource = NULL;
+      PRINTF(2)("No type found for %s.\n   !!This should not happen unless the Type is not supported yet.!!\n", tmpName);
+      break;
+    }
+
+  // checking if the File really exists.
+  if(!isFile(tmpName))
+    {
+      PRINTF(2)("Sorry, %s is not a regular file.\n", tmpName);
+      tmpResource = NULL;
+    }
+  return tmpResource;
+}
+
+/**
+   \brief Checks if it is a Directory
+   \param directoryName the Directory to check for
+   \returns true if it is a directory/symlink false otherwise
+*/
+bool ResourceManager::isDir(const char* directoryName)
+{
+  struct stat status;
+  stat(directoryName, &status);
+  if (status.st_mode & (S_IFDIR | S_IFLNK))
+    return true;
+  else 
+    return false;
+}
+
+/**
+   \brief Checks if the file is either a Regular file or a Symlink
+   \param fileName the File to check for
+   \returns true if it is a regular file/symlink, false otherwise
+*/
+bool ResourceManager::isFile(const char* fileName)
+{
+  struct stat status;
+  stat(fileName, &status);
+  if (status.st_mode & (S_IFREG | S_IFLNK))
+    return true;
+  else
+    return false;
+}

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

@@ -1 +1 @@
 /*! 
-    \file proto_class.h
-    \brief Definition of the proto class template, used quickly start work
-    \todo Example: this shows how to use simply add a Marker that here has to be done something.
+    \file resource_manager.h
+    \brief The Resource Manager checks if a file/resource is loaded.
 
-    The Protoclass exists, to help you quikly getting the run for how to develop in orxonox.
-    It is an example for the CODING-CONVENTION, and a starting-point for every class.
+    If a file/resource was already loaded the resourceManager will 
+    return a void pointer to the desired resource.
+    Otherwise it will instruct the coresponding resource-loader to load,
+    and receive a pointer to it.
 */
 
-#ifndef _PROTO_CLASS_H
-#define _PROTO_CLASS_H
+#ifndef _RESOURCE_MANAGER_H
+#define _RESOURCE_MANAGER_H
 
-#include "what realy has to be included"
 #include "base_object.h"
 
 // FORWARD DEFINITION \\
-class someClassWeNeed;
 
 
-/*class Test;*/ /* forward definition of class Test (without including it here!)*/
+enum ResourceType {OBJ, WAV, MP3, OGG, IMAGE};
 
-//! A default class that aids you to start creating a new class
+//! The ResourceManager is a class, that decides if a file/resource should be loaded
 /**
-   here can be some longer description of this class
+   If a file/resource was already loaded the resourceManager will 
+   return a void pointer to the desired resource.
+   Otherwise it will instruct the corresponding resource-loader to load,
+   and receive the pointer to it.
+
+   It does it by looking, if a desired file has already been loaded.
 */
-class ProtoClass : public BaseObject {
+class ResourceManager : public BaseObject 
+{
+ public:
+  static ResourceManager* getInstance();
+  virtual ~ResourceManager();
 
- public:
-  ProtoClass();
-  virtual ~ProtoClass();
-
-  bool doNonSense (int nothing);
+  bool setDataDir(char* dataDir);
+  static void* load(const char* fileName);
+  static void* load(const char* fileName, ResourceType type);
 
  private:
-  int nonSense;  //!< doxygen tag here like this for all the variables - delete this variable if you use this
+  ResourceManager();
+  static ResourceManager* singletonRef;
 
+
+  struct file;
+  struct folder
+  {
+    char* name;
+    folder** subfolders;             //!< 
+    file** files;                    //!< Files in the directory
+  };
+  struct file
+  {
+    char* name;                      //!< exact Name of a file
+    void* pointer;
+  };
+
+  char* dataDir;                     //!< The main data directory
+
+  static bool isDir(const char* directory);
+  static bool isFile(const char* directory);  
 };
 
-#endif /* _PROTO_CLASS_H */
+#endif /* _RESOURCE_MANAGER_H */