Changeset 7221 in orxonox.OLD for trunk/src/lib/graphics/importer

Timestamp:

Mar 15, 2006, 3:10:45 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: merged the std-branche back, it runs on windows and Linux

svn merge ​https://svn.orxonox.net/orxonox/branches/std . -r7202:HEAD

Location:

trunk/src/lib/graphics/importer

Files:

• height_map.cc (modified) (5 diffs)
• height_map.h (modified) (2 diffs)
• material.cc (modified) (7 diffs)
• material.h (modified) (2 diffs)
• md2Model.cc (modified) (9 diffs)
• md2Model.h (modified) (3 diffs)
• media_container.cc (modified) (9 diffs)
• media_container.h (modified) (1 diff)
• movie_player.cc (modified) (6 diffs)
• movie_player.h (modified) (1 diff)
• objModel.cc (modified) (7 diffs)
• objModel.h (modified) (1 diff)
• static_model.cc (modified) (23 diffs)
• static_model.h (modified) (4 diffs)
• texture.cc (modified) (5 diffs)
• texture.h (modified) (1 diff)
• texture_sequence.cc (modified) (1 diff)
• texture_sequence.h (modified) (1 diff)

trunk/src/lib/graphics/importer/height_map.cc

@@ -333 +333 @@
 }
 
-HeightMap::HeightMap(const char* height_map_name = NULL) : VertexArrayModel()
+HeightMap::HeightMap(const std::string& height_map_name = "")
+  : VertexArrayModel()
 {
    this->setClassID(CL_HEIGHT_MAP, "HeightMap");
-   heightMap =  IMG_Load(height_map_name);
+   heightMap =  IMG_Load(height_map_name.c_str());
    if(heightMap!=NULL) {
 
-                 PRINTF(0)("loading Image %s\n", height_map_name);
+     PRINTF(0)("loading Image %s\n", height_map_name.c_str());
                  PRINTF(0)("width : %i\n", heightMap->w);
                  PRINTF(0)("height : %i\n", heightMap->h);
@@ -350 +351 @@
                 }
 
-     else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name);
+                else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name.c_str());
 
 
@@ -361 +362 @@
 }
 
-HeightMap::HeightMap(const char* height_map_name = NULL, const char* colour_map_name = NULL) : VertexArrayModel()
+HeightMap::HeightMap(const std::string& height_map_name = NULL, const std::string& colour_map_name = NULL)
+  : VertexArrayModel()
 {
 this->setClassID(CL_HEIGHT_MAP, "HeightMap");
 
-   heightMap =  IMG_Load(height_map_name);
+   heightMap =  IMG_Load(height_map_name.c_str());
    if(heightMap!=NULL) {
 
-                 PRINTF(0)("loading Image %s\n", height_map_name);
+     PRINTF(0)("loading Image %s\n", height_map_name.c_str());
                  PRINTF(0)("width : %i\n", heightMap->w);
                  PRINTF(0)("height : %i\n", heightMap->h);
@@ -379 +381 @@
                 }
 
-     else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name);
+                else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name.c_str());
 
 
@@ -385 +387 @@
 
   colourMap=NULL;
-  if(colour_map_name != NULL)
+  if(colour_map_name != "")
   {
-  colourMap = IMG_Load(colour_map_name);
+    colourMap = IMG_Load(colour_map_name.c_str());
   }
 
   if(colourMap != NULL)
                 {
-                 PRINTF(0)("loading Image %s\n", colour_map_name);
+                  PRINTF(0)("loading Image %s\n", colour_map_name.c_str());
                  PRINTF(0)("width : %i\n", colourMap->w);
                  PRINTF(0)("height : %i\n", colourMap->h);

trunk/src/lib/graphics/importer/height_map.h

@@ -59 +59 @@
 void load();
 void load(int Mode);
-void load(const char*, int Mode);
+void load(const std::string&, int Mode);
 void scale( Vector V);
 void setAbsCoor(Vector V);
@@ -65 +65 @@
 float getNormal(float x, float y);
 HeightMap();
-HeightMap(const char*);
-HeightMap(const char*, const char*);
+HeightMap(const std::string&);
+HeightMap(const std::string&, const std::string&);
 virtual ~HeightMap();
 

trunk/src/lib/graphics/importer/material.cc

@@ -34 +34 @@
  * @param mtlName Name of the Material to be added to the Material List
  */
-Material::Material (const char* mtlName)
+Material::Material (const std::string& mtlName)
 {
   this->setClassID(CL_MATERIAL, "Material");
@@ -278 +278 @@
  * @param pathName The Path to add.
 */
-void Material::addTexturePath(const char* pathName)
+void Material::addTexturePath(const std::string& pathName)
 {
   ResourceManager::getInstance()->addImageDir(pathName);
@@ -289 +289 @@
  * @param dMap the Name of the Image to Use
 */
-void Material::setDiffuseMap(const char* dMap, GLenum target)
+void Material::setDiffuseMap(const std::string& dMap, GLenum target)
 {
   PRINTF(5)("setting Diffuse Map %s\n", dMap);
@@ -297 +297 @@
   //! @todo check if RESOURCE MANAGER is availiable
   //! @todo Textures from .mtl-file need special care.
-  if (dMap != NULL)
+  if (!dMap.empty())
     this->diffuseTexture = (Texture*)ResourceManager::getInstance()->load(dMap, IMAGE, RP_GAME, (int)target);
   else
@@ -308 +308 @@
    @todo implement this
 */
-void Material::setAmbientMap(const char* aMap, GLenum target)
+void Material::setAmbientMap(const std::string& aMap, GLenum target)
 {
   SDL_Surface* ambientMap;
@@ -319 +319 @@
    @todo implement this
 */
-void Material::setSpecularMap(const char* sMap, GLenum target)
+void Material::setSpecularMap(const std::string& sMap, GLenum target)
 {
   SDL_Surface* specularMap;
@@ -330 +330 @@
    @todo implemet this
 */
-void Material::setBump(const char* bump)
-{
-
-}
+void Material::setBump(const std::string& bump)
+{
+
+}

trunk/src/lib/graphics/importer/material.h

@@ -26 +26 @@
 {
  public:
-  Material (const char* mtlName = NULL);
+  Material (const std::string& mtlName = "");
   virtual ~Material ();
 
@@ -49 +49 @@
 
  // MAPPING //
-  void setDiffuseMap(const char* dMap, GLenum target = GL_TEXTURE_2D);
-  void setAmbientMap(const char* aMap, GLenum target = GL_TEXTURE_2D);
-  void setSpecularMap(const char* sMap, GLenum target = GL_TEXTURE_2D);
-  void setBump(const char* bump);
+  void setDiffuseMap(const std::string& dMap, GLenum target = GL_TEXTURE_2D);
+  void setAmbientMap(const std::string& aMap, GLenum target = GL_TEXTURE_2D);
+  void setSpecularMap(const std::string& sMap, GLenum target = GL_TEXTURE_2D);
+  void setBump(const std::string& bump);
   GLuint getDiffuseTexture() const { return (this->diffuseTexture)? this->diffuseTexture->getTexture() : 0; };
 
-  static void addTexturePath(const char* pathName);
+  static void addTexturePath(const std::string& pathName);
 
   private:

trunk/src/lib/graphics/importer/md2Model.cc

@@ -75 +75 @@
   \brief simple constructor initializing all variables
 */
-MD2Model::MD2Model(const char* modelFileName, const char* skinFileName, float scale)
+MD2Model::MD2Model(const std::string& modelFileName, const std::string& skinFileName, float scale)
 {
   this->setClassID(CL_MD2_MODEL, "MD2Model");
   /* this creates the data container via ressource manager */
-  this->data = (MD2Data*)ResourceManager::getInstance()->load(modelFileName, MD2, RP_GAME, skinFileName, scale);
+  if (!modelFileName.empty())
+    this->data = (MD2Data*)ResourceManager::getInstance()->load(modelFileName, MD2, RP_GAME, skinFileName, scale);
   if( unlikely(this->data == NULL))
     PRINTF(0)("The model was not found, MD2Model Loader finished abnormaly. Update the data-repos\n");
@@ -352 +353 @@
 {
   PRINT(0)("\n==========================| MD2Model::debug() |===\n");
-  PRINT(0)("=  Model FileName:\t%s\n", this->data->fileName);
-  PRINT(0)("=  Skin FileName:\t%s\n", this->data->skinFileName);
+  PRINT(0)("=  Model FileName:\t%s\n", this->data->fileName.c_str());
+  PRINT(0)("=  Skin FileName:\t%s\n", this->data->skinFileName.c_str());
   PRINT(0)("=  Size in Memory:\t%i Bytes\n", this->data->header->frameSize * this->data->header->numFrames + 64); // 64bytes is the header size
   PRINT(0)("=  Number of Vertices:\t%i\n", this->data->header->numVertices);
@@ -370 +371 @@
   \brief simple constructor
 */
-MD2Data::MD2Data(const char* modelFileName, const char* skinFileName, float scale)
+MD2Data::MD2Data(const std::string& modelFileName, const std::string& skinFileName, float scale)
 {
   scale *= 0.1f;
@@ -387 +388 @@
   this->scaleFactor = scale;
 
-  this->fileName = NULL;
-  this->skinFileName = NULL;
+  this->fileName = "";
+  this->skinFileName = "";
   this->loadModel(modelFileName);
   this->loadSkin(skinFileName);
@@ -401 +402 @@
 MD2Data::~MD2Data()
 {
-  delete [] this->fileName;
-  delete [] this->skinFileName;
   delete this->header;
 
@@ -419 +418 @@
   \return true if success
 */
-bool MD2Data::loadModel(const char* fileName)
+bool MD2Data::loadModel(const std::string& fileName)
 {
   FILE *pFile;                            //file stream
@@ -428 +427 @@
 
   //! @todo this chek should include deleting a loaded model (eventually)
-  if (fileName == NULL)
+  if (fileName.empty())
     return false;
 
-  pFile = fopen(fileName, "rb");
+  pFile = fopen(fileName.c_str(), "rb");
   if( unlikely(!pFile))
     {
@@ -442 +441 @@
   if( unlikely(this->header->version != MD2_VERSION) && unlikely(this->header->ident != MD2_IDENT))
     {
-      PRINTF(1)("Couldn't load file %s: invalid file format: stop loading\n", fileName);
+      PRINTF(1)("Couldn't load file %s: invalid file format: stop loading\n", fileName.c_str());
       return false;
     }
 
-  this->fileName = new char[strlen(fileName)+1];
-  strcpy(this->fileName, fileName);
+  this->fileName =fileName;
   /* got the data: map it to locals */
   this->numFrames = this->header->numFrames;
@@ -507 +505 @@
   \return true if success
 */
-bool MD2Data::loadSkin(const char* fileName)
-{
-  if( fileName == NULL)
-    {
-      this->skinFileName = NULL;
+bool MD2Data::loadSkin(const std::string& fileName)
+{
+  if( fileName.empty())
+    {
+      this->skinFileName = "";
       return false;
     }
 
-  this->skinFileName = new char[strlen(fileName)+1];
-  strcpy(this->skinFileName, fileName);
+  this->skinFileName = fileName;
 
   this->material.setName("md2ModelMaterial");

trunk/src/lib/graphics/importer/md2Model.h

@@ -189 +189 @@
 {
  public:
-   MD2Data(const char* modelFileName, const char* skinFileName, float scale = 1.0f);
+   MD2Data(const std::string& modelFileName, const std::string& skinFileName, float scale = 1.0f);
   virtual ~MD2Data();
 
  private:
-  bool loadModel(const char* fileName);
-  bool loadSkin(const char* fileName = NULL);
+   bool loadModel(const std::string& fileName);
+   bool loadSkin(const std::string& fileName = "");
 
  public:
@@ -202 +202 @@
   int                numTexCoor;            //!< number of texture coordinates
   int                numGLCommands;         //!< number of gl commands in the glList (tells how to draw)
-  char*              fileName;              //!< file name of the model File
-  char*              skinFileName;          //!< file name of the skin file
+  std::string        fileName;              //!< file name of the model File
+  std::string        skinFileName;          //!< file name of the skin file
   MD2Header*         header;                //!< the header file
 
@@ -223 +223 @@
 
 public:
-  MD2Model(const char* modelFileName, const char* skinFileName = NULL, float scale = 1.0f);
+  MD2Model(const std::string& modelFileName, const std::string& skinFileName = "", float scale = 1.0f);
   virtual ~MD2Model();
 

trunk/src/lib/graphics/importer/media_container.cc

@@ -34 +34 @@
  * Default constructor
  */
-MediaContainer::MediaContainer(const char* filename)
+MediaContainer::MediaContainer(const std::string& filename)
 {
   // set the class id for the base object
@@ -41 +41 @@
   fps = 0;
   mediaLoaded = false;
-
-  this->loadMedia(filename);
+  if (!filename.empty())
+    this->loadMedia(filename);
 }
 
@@ -84 +84 @@
 }
 
-bool MediaContainer::loadMedia(const char* filename)
+bool MediaContainer::loadMedia(const std::string& filename)
 {
   this->unloadMedia();
 
-  if(filename == NULL)
+  if(filename.empty())
     return false;
   // check whether file exists
   if(!ResourceManager::isInDataDir(filename))
   {
-    PRINTF(1)("Could not find %s\n", filename);
+    PRINTF(1)("Could not find %s\n", filename.c_str());
     return false;
   }
@@ -101 +101 @@
 
   // Open video file
-  if (av_open_input_file(&format_context, ResourceManager::getFullName(filename), NULL, 0, NULL) !=0 )
-  {
-    PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename));
+  if (av_open_input_file(&format_context, ResourceManager::getFullName(filename).c_str(), NULL, 0, NULL) !=0 )
+  {
+    PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -110 +110 @@
   if (av_find_stream_info(format_context) < 0)
   {
-    PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename));
+    PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -116 +116 @@
   // Find the first video stream and take it
   video_stream = av_find_default_stream_index(format_context);
-  
+
   if(video_stream == -1)
   {
-    PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename));
+    PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -202 +202 @@
       // Free the packet that was allocated by av_read_frame
       av_free_packet(&packet);
-      
+
       // Did we get a video frame?
       if(frame_finished)
@@ -216 +216 @@
           memcpy(&data[i*codec_context->width*3],
                  ((AVPicture*)RGB_frame)->data[0]+i *
-                 ((AVPicture*)RGB_frame)->linesize[0], 
+                 ((AVPicture*)RGB_frame)->linesize[0],
                   codec_context->width*sizeof(uint8_t)*3);
 
@@ -258 +258 @@
   }
   else
-    return NULL;
-}
+    return 0;
+}

trunk/src/lib/graphics/importer/media_container.h

@@ -44 +44 @@
 public:
 
-  MediaContainer(const char* filename = NULL);
+  MediaContainer(const std::string& filename = "");
   virtual ~MediaContainer();
 
-  bool loadMedia(const char* filename);
+  bool loadMedia(const std::string& filename);
   void loadFrames();
 

trunk/src/lib/graphics/importer/movie_player.cc

@@ -31 +31 @@
 
 
-MoviePlayer::MoviePlayer(const char* filename)
+MoviePlayer::MoviePlayer(const std::string& filename)
 {
   // set the class id for the base object
@@ -42 +42 @@
   mediaLoaded = false;
 
-  this->loadMovie(filename);
-
+  if (!filename.empty())
+    this->loadMovie(filename);
 }
 
@@ -83 +83 @@
 
 
-bool MoviePlayer::loadMovie(const char* filename)
+bool MoviePlayer::loadMovie(const std::string& filename)
 {
   this->unloadMedia();
 
-  if(filename == NULL)
+  if(filename.empty())
     return false;
   // check whether file exists
   if(!ResourceManager::isInDataDir(filename))
   {
-    PRINTF(1)("Could not find %s\n", filename);
+    PRINTF(1)("Could not find %s\n", filename.c_str());
     return false;
   }
@@ -100 +100 @@
 
   // Open video file
-  if (av_open_input_file(&format_context, ResourceManager::getFullName(filename), NULL, 0, NULL) !=0 )
-  {
-    PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename));
+  if (av_open_input_file(&format_context, ResourceManager::getFullName(filename).c_str(), NULL, 0, NULL) !=0 )
+  {
+    PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -109 +109 @@
   if (av_find_stream_info(format_context) < 0)
   {
-    PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename));
+    PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -118 +118 @@
   if(video_stream == -1)
   {
-    PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename));
+    PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }

trunk/src/lib/graphics/importer/movie_player.h

@@ -58 +58 @@
 public:
 
-  MoviePlayer(const char* filename = NULL);
+  MoviePlayer(const std::string& filename = "");
   virtual ~MoviePlayer();
 
-  bool loadMovie(const char* filename);
+  bool loadMovie(const std::string& filename);
 
   void start(float start_time);

trunk/src/lib/graphics/importer/objModel.cc

@@ -32 +32 @@
  * @param scaling The factor that the model will be scaled with.
 */
-OBJModel::OBJModel(const char* fileName, float scaling) : StaticModel(fileName)
+OBJModel::OBJModel(const std::string& fileName, float scaling)
+  : StaticModel(fileName)
 {
   this->setClassID(CL_OBJ_MODEL, "OBJModel");
@@ -51 +52 @@
 */
 OBJModel::~OBJModel()
-{
-  PRINTF(4)("Deleting the obj-names\n");
-  if (this->objPath)
-    delete []this->objPath;
-}
+{ }
 
 /**
@@ -63 +60 @@
    Splits the FileName from the DirectoryName
 */
-bool OBJModel::importFile (const char* fileName)
-{
+bool OBJModel::importFile (const std::string& fileNameInput)
+{
+  const char* fileName = fileNameInput.c_str();
   PRINTF(4)("preparing to read in file: %s\n", fileName);
   // splitting the
@@ -74 +72 @@
     {
       int len = split - fileName+1;
-      this->objPath = new char[len +2];
-      strncpy(this->objPath, fileName, len);
+      this->objPath =  fileName;
+      this->objPath.erase(len, this->objPath.size());
       this->objPath[len] = '\0';
       PRINTF(4)("Resolved file %s to Path %s.\n", fileName, this->objPath);
@@ -91 +89 @@
    This function does read the file, parses it for the occurence of things like vertices, faces and so on, and executes the specific tasks
 */
-bool OBJModel::readFromObjFile(const char* fileName)
+bool OBJModel::readFromObjFile(const std::string& fileName)
 {
   FILE* stream;
-  if( (stream = fopen (fileName, "r")) == NULL)
-    {
-      PRINTF(2)("Object File Could not be Opened %s\n", fileName);
+  if( (stream = fopen (fileName.c_str(), "r")) == NULL)
+    {
+      PRINTF(2)("Object File Could not be Opened %s\n", fileName.c_str());
       return false;
     }
@@ -162 +160 @@
  * that a material does not have to be able to read itself in from a File.
  */
-bool OBJModel::readMtlLib (const char* mtlFile)
-{
-  char* fileName = new char [strlen(this->objPath) + strlen(mtlFile)+1];
-  sprintf(fileName, "%s%s", this->objPath, mtlFile);
+bool OBJModel::readMtlLib (const std::string& mtlFile)
+{
+  std::string fileName = this->objPath + mtlFile;
 
   FILE* stream;
-  if( (stream = fopen (fileName, "r")) == NULL)
-    {
-      PRINTF(2)("MaterialLibrary could not be opened %s\n", fileName);
-      delete[] fileName;
+  if( (stream = fopen (fileName.c_str(), "r")) == NULL)
+    {
+      PRINTF(2)("MaterialLibrary could not be opened %s\n", fileName.c_str());
       return false;
     }
@@ -258 +254 @@
     }
   fclose(stream);
-  delete []fileName;
   return true;
 }

trunk/src/lib/graphics/importer/objModel.h

@@ -13 +13 @@
 {
  public:
-  OBJModel(const char* fileName, float scaling = 1.0);
+   OBJModel(const std::string& fileName, float scaling = 1.0);
   virtual ~OBJModel();
 
  private:
   ///// readin /////
-  bool importFile (const char* fileName);
-  bool readFromObjFile (const char* fileName);
-  bool readMtlLib (const char* matFile);
+   bool importFile (const std::string& fileName);
+   bool readFromObjFile (const std::string& fileName);
+   bool readMtlLib (const std::string& matFile);
 
  private:
-  char*       objPath;     //!< The Path where the obj and mtl-file are located.
+   std::string       objPath;     //!< The Path where the obj and mtl-file are located.
 };
 

trunk/src/lib/graphics/importer/static_model.cc

@@ -23 +23 @@
 #include <stdarg.h>
 
-#include "vector.h"
-
 using namespace std;
 
@@ -86 +84 @@
 {
   PRINTF(4)("Adding new Group\n");
-  this->name = NULL;
+  this->name = "";
   this->faceMode = -1;
   this->faceCount = 0;
@@ -109 +107 @@
   if (this->listNumber != 0)
     glDeleteLists(this->listNumber, 1);
-
-  if (this->name != NULL)
-    delete[] this->name;
 
   if (this->next !=NULL)
@@ -142 +137 @@
  * assigns it a Name and a Type
  */
-StaticModel::StaticModel(const char* modelName)
+StaticModel::StaticModel(const std::string& modelName)
 {
   this->setClassID(CL_STATIC_MODEL, "StaticModel");
@@ -230 +225 @@
   ModelGroup* tmpGroup = this->firstGroup;
   while (tmpGroup != NULL)
-    {
-      PRINTF(5)("Drawing model %s\n", tmpGroup->name);
-      glCallList (tmpGroup->listNumber);
-      tmpGroup = tmpGroup->next;
-    }
+  {
+    PRINTF(5)("Drawing model %s\n", tmpGroup->name);
+    glCallList (tmpGroup->listNumber);
+    tmpGroup = tmpGroup->next;
+  }
 }
 
@@ -247 +242 @@
 {
   if (unlikely(groupNumber >= this->groupCount))
-    {
-      PRINTF(2)("You requested model number %i, but this File only contains of %i Models.\n", groupNumber-1, this->groupCount);
-      return;
-    }
+  {
+    PRINTF(2)("You requested model number %i, but this File only contains of %i Models.\n", groupNumber-1, this->groupCount);
+    return;
+  }
   PRINTF(4)("drawing the requested 3D-Models if found.\n");
   ModelGroup* tmpGroup = this->firstGroup;
   int counter = 0;
   while (tmpGroup != NULL)
+  {
+    if (counter == groupNumber)
     {
-      if (counter == groupNumber)
-        {
-          PRINTF(4)("Drawing model number %i named %s\n", counter, tmpGroup->name);
-          glCallList (tmpGroup->listNumber);
-          return;
-        }
-      ++counter;
-      tmpGroup = tmpGroup->next;
+      PRINTF(4)("Drawing model number %i named %s\n", counter, tmpGroup->name);
+      glCallList (tmpGroup->listNumber);
+      return;
     }
+    ++counter;
+    tmpGroup = tmpGroup->next;
+  }
   PRINTF(2)("Model number %i in %s not Found.\n", groupNumber, this->getName());
   return;
@@ -276 +271 @@
  * It does this by just calling the List that must have been created earlier.
  */
-void StaticModel::draw (char* groupName) const
-{
-  if (groupName == NULL)
-     return;
+void StaticModel::draw (const std::string& groupName) const
+{
   PRINTF(4)("drawing the requested 3D-Models if found.\n");
   ModelGroup* tmpGroup = this->firstGroup;
   while (tmpGroup != NULL)
+  {
+    if (tmpGroup->name == groupName)
     {
-      if (tmpGroup->name != NULL && !strcmp(tmpGroup->name, groupName))
-        {
-          PRINTF(4)("Drawing model %s\n", tmpGroup->name);
-          glCallList (tmpGroup->listNumber);
-          return;
-        }
-      tmpGroup = tmpGroup->next;
+      PRINTF(4)("Drawing model %s\n", tmpGroup->name.c_str());
+      glCallList (tmpGroup->listNumber);
+      return;
     }
-  PRINTF(2)("Model Named %s in %s not Found.\n", groupName, this->getName());
+    tmpGroup = tmpGroup->next;
+  }
+  PRINTF(2)("Model Named %s in %s not Found.\n", groupName.c_str(), this->getName());
   return;
 }
@@ -341 +334 @@
  * @returns the added material
  */
-Material* StaticModel::addMaterial(const char* materialName)
+Material* StaticModel::addMaterial(const std::string& materialName)
 {
   ModelMaterial* modMat = new ModelMaterial;
@@ -357 +350 @@
  * @returns the Material if found, NULL otherwise
  */
-Material* StaticModel::findMaterialByName(const char* materialName)
+Material* StaticModel::findMaterialByName(const std::string& materialName)
 {
   list<ModelMaterial*>::iterator modMat;
   for  (modMat = this->materialList.begin(); modMat != this->materialList.end(); modMat++)
-    if (!strcmp((*modMat)->material->getName(), materialName))
+    if (materialName == (*modMat)->material->getName())
       return (*modMat)->material;
   return NULL;
@@ -373 +366 @@
  * With it you should be able to create Models with more than one SubModel inside
  */
-bool StaticModel::addGroup(const char* groupString)
+bool StaticModel::addGroup(const std::string& groupString)
 {
   PRINTF(5)("Read Group: %s.\n", groupString);
   if (this->groupCount != 0 && this->currentGroup->faceCount > 0)
-    {
-      // finalizeGroup(currentGroup);
-      this->currentGroup = this->currentGroup->next = new ModelGroup;
-    }
+  {
+    // finalizeGroup(currentGroup);
+    this->currentGroup = this->currentGroup->next = new ModelGroup;
+  }
   // setting the group name if not default.
-  if (strcmp(groupString, "default"))
-    {
-      this->currentGroup->name = new char [strlen(groupString)+1];
-      strcpy(this->currentGroup->name, groupString);
-    }
+  if (groupString == "default")
+  {
+    this->currentGroup->name = groupString;
+  }
   ++this->groupCount;
 }
@@ -396 +388 @@
  *  If a vertex line is found this function will inject it into the vertex-Array
  */
-bool StaticModel::addVertex (const char* vertexString)
+bool StaticModel::addVertex (const std::string& vertexString)
 {
   float subbuffer1;
   float subbuffer2;
   float subbuffer3;
-  sscanf (vertexString, "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
+  sscanf (vertexString.c_str(), "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
   this->vertices.push_back(subbuffer1*scaleFactor);
   this->vertices.push_back(subbuffer2*scaleFactor);
@@ -431 +423 @@
  * If a vertexNormal line is found this function will inject it into the vertexNormal-Array
  */
-bool StaticModel::addVertexNormal (const char* normalString)
+bool StaticModel::addVertexNormal (const std::string& normalString)
 {
   float subbuffer1;
   float subbuffer2;
   float subbuffer3;
-  sscanf (normalString, "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
+  sscanf (normalString.c_str(), "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
   this->normals.push_back(subbuffer1);
   this->normals.push_back(subbuffer2);
@@ -471 +463 @@
  * !! WARNING THIS IS DIFFERNT FROM addVervexTexture(float, float); because it changes the second entry to 1-v !!
  */
-bool StaticModel::addVertexTexture (const char* vTextureString)
+bool StaticModel::addVertexTexture (const std::string& vTextureString)
 {
   float subbuffer1;
   float subbuffer2;
-  sscanf (vTextureString, "%f %f", &subbuffer1, &subbuffer2);
+  sscanf (vTextureString.c_str(), "%f %f", &subbuffer1, &subbuffer2);
   this->vTexture.push_back(subbuffer1);
   this->vTexture.push_back(1 - subbuffer2);
@@ -507 +499 @@
  * String is different from the argument addFace,
  * in this, that the first Vertex/Normal/Texcoord is 1 instead of 0
- */
-bool StaticModel::addFace (const char* faceString)
-{
+ *
+ * @TODO make it std::string conform
+ */
+bool StaticModel::addFace (const std::string& faceStringInput)
+{
+  const char* faceString = faceStringInput.c_str();
   if (this->currentGroup->faceCount >0)
     this->currentGroup->currentFace = this->currentGroup->currentFace->next = new ModelFace;
@@ -516 +511 @@
   tmpElem->next = NULL;
   while(strcmp (faceString, "\0"))
+  {
+    if (this->currentGroup->currentFace->vertexCount>0)
+      tmpElem = tmpElem->next = new ModelFaceElement;
+    tmpElem->next = NULL;
+
+    char tmpValue [50];
+    int tmpLen;
+    char* vertex = NULL;
+    char* texture = NULL;
+    char* normal = NULL;
+
+    sscanf (faceString, "%s", tmpValue);
+    tmpLen = strlen(tmpValue);
+    vertex = tmpValue;
+
+    if ((texture = strstr (vertex, "/")) != NULL)
     {
-      if (this->currentGroup->currentFace->vertexCount>0)
-          tmpElem = tmpElem->next = new ModelFaceElement;
-      tmpElem->next = NULL;
-
-      char tmpValue [50];
-      int tmpLen;
-      char* vertex = NULL;
-      char* texture = NULL;
-      char* normal = NULL;
-
-      sscanf (faceString, "%s", tmpValue);
-      tmpLen = strlen(tmpValue);
-      vertex = tmpValue;
-
-      if ((texture = strstr (vertex, "/")) != NULL)
-        {
-          texture[0] = '\0';
-          texture ++;
-
-          if ((normal = strstr (texture, "/")) !=NULL)
-            {
-              normal[0] = '\0';
-              normal ++;
-            }
-        }
-      if (vertex)
-        tmpElem->vertexNumber = atoi(vertex)-1;
-      if (texture)
-        tmpElem->texCoordNumber = atoi(texture)-1;
-      if (normal)
-        tmpElem->normalNumber = atoi(normal)-1;
-
-      faceString += tmpLen;
-      if (strcmp (faceString, "\0"))
-        faceString++;
-      this->currentGroup->currentFace->vertexCount++;
+      texture[0] = '\0';
+      texture ++;
+
+      if ((normal = strstr (texture, "/")) !=NULL)
+      {
+        normal[0] = '\0';
+        normal ++;
+      }
     }
+    if (vertex)
+      tmpElem->vertexNumber = atoi(vertex)-1;
+    if (texture)
+      tmpElem->texCoordNumber = atoi(texture)-1;
+    if (normal)
+      tmpElem->normalNumber = atoi(normal)-1;
+
+    faceString += tmpLen;
+    if (strcmp (faceString, "\0"))
+      faceString++;
+    this->currentGroup->currentFace->vertexCount++;
+  }
 
   this->currentGroup->faceCount += this->currentGroup->currentFace->vertexCount -2;
@@ -575 +570 @@
 
   for (int i = 0; i < faceElemCount; i++)
-    {
-      if (this->currentGroup->currentFace->vertexCount > 0)
-        tmpElem = tmpElem->next = new ModelFaceElement;
-
-      tmpElem->vertexNumber = va_arg (itemlist, int);
-      if (type & TEXCOORD)
-        tmpElem->texCoordNumber = va_arg (itemlist, int);
-      if (type & NORMAL)
-        tmpElem->normalNumber = va_arg(itemlist, int);
-      this->currentGroup->currentFace->vertexCount++;
-    }
+  {
+    if (this->currentGroup->currentFace->vertexCount > 0)
+      tmpElem = tmpElem->next = new ModelFaceElement;
+
+    tmpElem->vertexNumber = va_arg (itemlist, int);
+    if (type & TEXCOORD)
+      tmpElem->texCoordNumber = va_arg (itemlist, int);
+    if (type & NORMAL)
+      tmpElem->normalNumber = va_arg(itemlist, int);
+    this->currentGroup->currentFace->vertexCount++;
+  }
   va_end(itemlist);
 
@@ -596 +591 @@
  * @param matString the Material that will be set.
 */
-bool StaticModel::setMaterial(const char* matString)
+bool StaticModel::setMaterial(const std::string& matString)
 {
   if (this->currentGroup->faceCount > 0)
@@ -647 +642 @@
   ModelGroup* tmpGroup = firstGroup;
   while (tmpGroup != NULL)
+  {
+    ModelFace* tmpFace = tmpGroup->firstFace;
+    while (tmpFace != NULL)
     {
-      ModelFace* tmpFace = tmpGroup->firstFace;
-      while (tmpFace != NULL)
+      if (tmpFace->firstElem != NULL)
+      {
+        ModelFaceElement* firstElem = tmpFace->firstElem;
+        ModelFaceElement* prevElem;
+        ModelFaceElement* curElem = firstElem;
+        ModelFaceElement* nextElem;
+        ModelFaceElement* lastElem;
+        // find last Element of the Chain. !! IMPORTANT:the last Element of the Chain must point to NULL, or it will resolv into an infinity-loop.
+        while (curElem != NULL)
         {
-          if (tmpFace->firstElem != NULL)
-            {
-              ModelFaceElement* firstElem = tmpFace->firstElem;
-              ModelFaceElement* prevElem;
-              ModelFaceElement* curElem = firstElem;
-              ModelFaceElement* nextElem;
-              ModelFaceElement* lastElem;
-              // find last Element of the Chain. !! IMPORTANT:the last Element of the Chain must point to NULL, or it will resolv into an infinity-loop.
-              while (curElem != NULL)
-                {
-                  prevElem = curElem;
-                  curElem = curElem->next;
-                }
-              lastElem = prevElem;
-
-              curElem = firstElem;
-              for (int j=0; j<tmpFace->vertexCount; j++)
-                {
-                  if (!(nextElem = curElem->next))
-                    nextElem = firstElem;
-                  curElem->normalNumber = curElem->vertexNumber;
-
-                  curV = Vector (this->vertices[curElem->vertexNumber*3],
-                                 this->vertices[curElem->vertexNumber*3+1],
-                                 this->vertices[curElem->vertexNumber*3+2]);
-
-                  prevV = Vector (this->vertices[prevElem->vertexNumber*3],
-                                  this->vertices[prevElem->vertexNumber*3+1],
-                                  this->vertices[prevElem->vertexNumber*3+2]) - curV;
-
-                  nextV = Vector (this->vertices[nextElem->vertexNumber*3],
-                                  this->vertices[nextElem->vertexNumber*3+1],
-                                  this->vertices[nextElem->vertexNumber*3+2]) - curV;
-                  normArray[curElem->vertexNumber] = normArray[curElem->vertexNumber] + nextV.cross(prevV);
-
-                  prevElem = curElem;
-                  curElem = curElem->next;
-                }
-            }
-          tmpFace = tmpFace->next;
+          prevElem = curElem;
+          curElem = curElem->next;
         }
-      tmpGroup = tmpGroup->next;
+        lastElem = prevElem;
+
+        curElem = firstElem;
+        for (int j=0; j<tmpFace->vertexCount; j++)
+        {
+          if (!(nextElem = curElem->next))
+            nextElem = firstElem;
+          curElem->normalNumber = curElem->vertexNumber;
+
+          curV = Vector (this->vertices[curElem->vertexNumber*3],
+                         this->vertices[curElem->vertexNumber*3+1],
+                         this->vertices[curElem->vertexNumber*3+2]);
+
+          prevV = Vector (this->vertices[prevElem->vertexNumber*3],
+                          this->vertices[prevElem->vertexNumber*3+1],
+                          this->vertices[prevElem->vertexNumber*3+2]) - curV;
+
+          nextV = Vector (this->vertices[nextElem->vertexNumber*3],
+                          this->vertices[nextElem->vertexNumber*3+1],
+                          this->vertices[nextElem->vertexNumber*3+2]) - curV;
+          normArray[curElem->vertexNumber] = normArray[curElem->vertexNumber] + nextV.cross(prevV);
+
+          prevElem = curElem;
+          curElem = curElem->next;
+        }
+      }
+      tmpFace = tmpFace->next;
     }
+    tmpGroup = tmpGroup->next;
+  }
 
   for (int i=0; i < this->vertices.size()/3;i++)
-    {
-      normArray[i].normalize();
-      PRINTF(5)("Found Normale number %d: (%f; %f, %f).\n", i, normArray[i].x, normArray[i].y, normArray[i].z);
-
-      this->addVertexNormal(normArray[i].x, normArray[i].y, normArray[i].z);
-
-    }
+  {
+    normArray[i].normalize();
+    PRINTF(5)("Found Normale number %d: (%f; %f, %f).\n", i, normArray[i].x, normArray[i].y, normArray[i].z);
+
+    this->addVertexNormal(normArray[i].x, normArray[i].y, normArray[i].z);
+
+  }
   delete[] normArray;
 }
@@ -721 +716 @@
 
   while (this->currentGroup != NULL)
+  {
+
+    // creating a glList for the Group
+    if ((this->currentGroup->listNumber = glGenLists(1)) == 0)
     {
-
-      // creating a glList for the Group
-      if ((this->currentGroup->listNumber = glGenLists(1)) == 0)
+      PRINTF(2)("glList could not be created for this Model\n");
+      return false;
+    }
+    glNewList (this->currentGroup->listNumber, GL_COMPILE);
+
+    // Putting Faces to GL
+    ModelFace* tmpFace = this->currentGroup->firstFace;
+    while (tmpFace != NULL)
+    {
+      if (tmpFace->vertexCount == 0 && tmpFace->material != NULL)
+      {
+        if (this->currentGroup->faceMode != -1)
+          glEnd();
+        this->currentGroup->faceMode = 0;
+        Material* tmpMat;
+        if (tmpFace->material != NULL)
         {
-          PRINTF(2)("glList could not be created for this Model\n");
-          return false;
+          tmpFace->material->select();
+          PRINTF(5)("using material %s for coming Faces.\n", tmpFace->material->getName());
         }
-      glNewList (this->currentGroup->listNumber, GL_COMPILE);
-
-      // Putting Faces to GL
-      ModelFace* tmpFace = this->currentGroup->firstFace;
-      while (tmpFace != NULL)
+      }
+
+      else if (tmpFace->vertexCount == 3)
+      {
+        if (this->currentGroup->faceMode != 3)
         {
-          if (tmpFace->vertexCount == 0 && tmpFace->material != NULL)
-            {
-              if (this->currentGroup->faceMode != -1)
-                glEnd();
-              this->currentGroup->faceMode = 0;
-              Material* tmpMat;
-              if (tmpFace->material != NULL)
-                {
-                  tmpFace->material->select();
-                  PRINTF(5)("using material %s for coming Faces.\n", tmpFace->material->getName());
-                }
-            }
-
-          else if (tmpFace->vertexCount == 3)
-            {
-              if (this->currentGroup->faceMode != 3)
-                {
-                  if (this->currentGroup->faceMode != -1)
-                    glEnd();
-                  glBegin(GL_TRIANGLES);
-                }
-
-              this->currentGroup->faceMode = 3;
-              PRINTF(5)("found triag.\n");
-            }
-
-          else if (tmpFace->vertexCount == 4)
-            {
-              if (this->currentGroup->faceMode != 4)
-                {
-                  if (this->currentGroup->faceMode != -1)
-                    glEnd();
-                  glBegin(GL_QUADS);
-                }
-              this->currentGroup->faceMode = 4;
-              PRINTF(5)("found quad.\n");
-            }
-
-          else if (tmpFace->vertexCount > 4)
-            {
-              if (this->currentGroup->faceMode != -1)
-                glEnd();
-              glBegin(GL_POLYGON);
-              PRINTF(5)("Polygon with %i faces found.", tmpFace->vertexCount);
-              this->currentGroup->faceMode = tmpFace->vertexCount;
-            }
-
-          ModelFaceElement* tmpElem = tmpFace->firstElem;
-          while (tmpElem != NULL)
-            {
-              //      PRINTF(2)("%s\n", tmpElem->value);
-              this->addGLElement(tmpElem);
-              tmpElem = tmpElem->next;
-            }
-          tmpFace = tmpFace->next;
+          if (this->currentGroup->faceMode != -1)
+            glEnd();
+          glBegin(GL_TRIANGLES);
         }
-      glEnd();
-      glEndList();
-
-      this->currentGroup = this->currentGroup->next;
+
+        this->currentGroup->faceMode = 3;
+        PRINTF(5)("found triag.\n");
+      }
+
+      else if (tmpFace->vertexCount == 4)
+      {
+        if (this->currentGroup->faceMode != 4)
+        {
+          if (this->currentGroup->faceMode != -1)
+            glEnd();
+          glBegin(GL_QUADS);
+        }
+        this->currentGroup->faceMode = 4;
+        PRINTF(5)("found quad.\n");
+      }
+
+      else if (tmpFace->vertexCount > 4)
+      {
+        if (this->currentGroup->faceMode != -1)
+          glEnd();
+        glBegin(GL_POLYGON);
+        PRINTF(5)("Polygon with %i faces found.", tmpFace->vertexCount);
+        this->currentGroup->faceMode = tmpFace->vertexCount;
+      }
+
+      ModelFaceElement* tmpElem = tmpFace->firstElem;
+      while (tmpElem != NULL)
+      {
+        //      PRINTF(2)("%s\n", tmpElem->value);
+        this->addGLElement(tmpElem);
+        tmpElem = tmpElem->next;
+      }
+      tmpFace = tmpFace->next;
     }
+    glEnd();
+    glEndList();
+
+    this->currentGroup = this->currentGroup->next;
+  }
 }
 
@@ -814 +809 @@
   ModelFace* tmpFace;              //!< the temporary face referece
 
+  bool warned = false;
+
   /* count the number of triangles */
   /* now iterate through all groups and build up the triangle list */
@@ -834 +831 @@
       else if( tmpFace->vertexCount > 4)
       {
-        PRINTF(1)("This model (%s) got over 4 vertices per face <=> conflicts in the CD engine!\n", this->getName());
-      //exit(0);
+        if (!warned)
+        {
+          PRINTF(2)("This model (%s) got over 4 vertices per face <=> conflicts in the CD engine!\n", this->getName());
+          warned = true;
+        }
+        //exit(0);
       }
       tmpFace = tmpFace->next;
@@ -858 +859 @@
   while( this->currentGroup != NULL)
   {
-      // Putting Faces to GL
+    // Putting Faces to GL
     tmpFace = this->currentGroup->firstFace;
     while( tmpFace != NULL)
@@ -931 +932 @@
 
   if (elem->texCoordNumber != -1)
-    {
-      if (likely(elem->texCoordNumber < this->pModelInfo.numTexCoor))
-        glTexCoord2fv(&this->vTexture[0] + elem->texCoordNumber * 2);
-      else
-        PRINTF(2)("TextureCoordinate %d is not in the List (max: %d)\nThe Model might be incomplete\n",
-                  elem->texCoordNumber, this->pModelInfo.numTexCoor);
-    }
+  {
+    if (likely(elem->texCoordNumber < this->pModelInfo.numTexCoor))
+      glTexCoord2fv(&this->vTexture[0] + elem->texCoordNumber * 2);
+    else
+      PRINTF(2)("TextureCoordinate %d is not in the List (max: %d)\nThe Model might be incomplete\n",
+                elem->texCoordNumber, this->pModelInfo.numTexCoor);
+  }
   if (elem->normalNumber != -1)
-    {
+  {
     if (likely(elem->normalNumber < this->pModelInfo.numNormals))
       glNormal3fv(&this->normals[0] + elem->normalNumber * 3);
     else
-        PRINTF(2)("Normal %d is not in the List (max: %d)\nThe Model might be incomplete",
-                  elem->normalNumber, this->pModelInfo.numNormals);
-    }
+      PRINTF(2)("Normal %d is not in the List (max: %d)\nThe Model might be incomplete",
+                elem->normalNumber, this->pModelInfo.numNormals);
+  }
   if (elem->vertexNumber != -1)
-    {
-      if (likely(elem->vertexNumber < this->pModelInfo.numVertices))
-          glVertex3fv(&this->vertices[0]+ elem->vertexNumber * 3);
-      else
-        PRINTF(2)("Vertex %d is not in the List (max: %d)\nThe Model might be incomplete",
-                  elem->vertexNumber, this->pModelInfo.numVertices);
-    }
+  {
+    if (likely(elem->vertexNumber < this->pModelInfo.numVertices))
+      glVertex3fv(&this->vertices[0]+ elem->vertexNumber * 3);
+    else
+      PRINTF(2)("Vertex %d is not in the List (max: %d)\nThe Model might be incomplete",
+                elem->vertexNumber, this->pModelInfo.numVertices);
+  }
 
 }

trunk/src/lib/graphics/importer/static_model.h

@@ -13 +13 @@
 #include <vector>
 #include <list>
-
-// FORWARD DECLARATION //
-template<class T> class tArray;
 
 // definition of different modes for setting up Faces
@@ -70 +67 @@
   void cleanup();
 
-  char*        name;           //!< the Name of the Group. this is an identifier, that can be accessed via the draw (char* name) function.
+  std::string  name;           //!< the Name of the Group. this is an identifier, that can be accessed via the draw (std::string name) function.
   GLubyte*     indices;        //!< The indices of the Groups. Needed for vertex-arrays
   GLuint       listNumber;     //!< The number of the GL-List this Group gets.
@@ -98 +95 @@
 {
  public:
-  StaticModel(const char* modelName = NULL);
+  StaticModel(const std::string& modelName = "");
   virtual ~StaticModel();
 
   virtual void draw() const;
   void draw(int groupNumber) const;
-  void draw(char* groupName) const;
+  void draw(const std::string& groupName) const;
 
   void rebuild();
 
   Material* addMaterial(Material* material);
-  Material* addMaterial(const char* materialName);
+  Material* addMaterial(const std::string& materialName);
 
-  bool addGroup(const char* groupString);
+  bool addGroup(const std::string& groupString);
 
-  bool addVertex(const char* vertexString);
+  bool addVertex(const std::string& vertexString);
   bool addVertex(float x, float y, float z);
 
-  bool addFace(const char* faceString);
+  bool addFace(const std::string& faceString);
   bool addFace(int faceElemCount, VERTEX_FORMAT type, ...);
 
-  bool addVertexNormal(const char* normalString);
+  bool addVertexNormal(const std::string& normalString);
   bool addVertexNormal(float x, float y, float z);
 
-  bool addVertexTexture(const char* vTextureString);
+  bool addVertexTexture(const std::string& vTextureString);
   bool addVertexTexture(float u, float v);
 
-  bool setMaterial(const char* mtlString);
+  bool setMaterial(const std::string& mtlString);
   bool setMaterial(Material* mtl);
 
@@ -133 +130 @@
   void cubeModel();
 
-  Material* findMaterialByName(const char* materialName);
+  Material* findMaterialByName(const std::string& materialName);
 
  protected:

trunk/src/lib/graphics/importer/texture.cc

@@ -32 +32 @@
  *  Constructor for a Texture
 */
-Texture::Texture(const char* imageName, GLenum target)
+Texture::Texture(const std::string& imageName, GLenum target)
 {
   this->setClassID(CL_TEXTURE, "Texture");
@@ -41 +41 @@
   this->priority = 0.5;
 
-  if (imageName != NULL)
+  if (!imageName.empty())
   {
     this->setName(imageName);
@@ -67 +67 @@
  * @param imageName The image to load
 */
-bool Texture::loadImage(const char* imageName, GLenum target)
+bool Texture::loadImage(const std::string& imageName, GLenum target)
 {
   if (Texture::texturesEnabled)
@@ -81 +81 @@
       this->texture = 0;
     }
-    if (imageName != NULL)
+    if (!imageName.empty())
     {
       SDL_Surface* tmpSurf;
@@ -87 +87 @@
         glDeleteTextures(1, &this->texture);
       // load the new Image to memory
-      tmpSurf = IMG_Load(imageName);
+      tmpSurf = IMG_Load(imageName.c_str());
       if(tmpSurf != NULL)
       {

trunk/src/lib/graphics/importer/texture.h

@@ -18 +18 @@
   {
     public:
-      Texture(const char* imageName = NULL, GLenum target = GL_TEXTURE_2D);
+      Texture(const std::string& imageName = "", GLenum target = GL_TEXTURE_2D);
   //  Texture(TEXTURE_TYPE type, int resolution);
       virtual ~Texture();
 
-      bool loadImage(const char* imageName, GLenum target = GL_TEXTURE_2D);
+      bool loadImage(const std::string& imageName, GLenum target = GL_TEXTURE_2D);
       virtual bool rebuild();
 

trunk/src/lib/graphics/importer/texture_sequence.cc

@@ -124 +124 @@
  * @returns true on success
  */
-bool TextureSequence::addFrame(const char* imageName)
+bool TextureSequence::addFrame(const std::string& imageName)
 {
-  if (imageName == NULL)
-    return false;
-
-  SDL_Surface* addSurface = IMG_Load(imageName);
+  SDL_Surface* addSurface = IMG_Load(imageName.c_str());
   bool success = this->addFrame(addSurface);
   delete addSurface;

trunk/src/lib/graphics/importer/texture_sequence.h

@@ -23 +23 @@
     bool loadImageSeries(unsigned int count, ...);
     bool loadImageSeries(unsigned int count, va_list textureNames);
-    bool addFrame(const char* image);
+    bool addFrame(const std::string& image);
     bool addFrame(SDL_Surface* surface);
     bool addFrame(GLuint texture);