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

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

Files:

• effects/fog_effect.cc (modified) (1 diff)
• effects/fog_effect.h (modified) (2 diffs)
• effects/lense_flare.cc (modified) (4 diffs)
• effects/lense_flare.h (modified) (1 diff)
• graphics_engine.cc (modified) (8 diffs)
• graphics_engine.h (modified) (4 diffs)
• importer/height_map.cc (modified) (5 diffs)
• importer/height_map.h (modified) (2 diffs)
• importer/material.cc (modified) (7 diffs)
• importer/material.h (modified) (2 diffs)
• importer/md2Model.cc (modified) (9 diffs)
• importer/md2Model.h (modified) (3 diffs)
• importer/media_container.cc (modified) (9 diffs)
• importer/media_container.h (modified) (1 diff)
• importer/movie_player.cc (modified) (6 diffs)
• importer/movie_player.h (modified) (1 diff)
• importer/objModel.cc (modified) (7 diffs)
• importer/objModel.h (modified) (1 diff)
• importer/static_model.cc (modified) (23 diffs)
• importer/static_model.h (modified) (4 diffs)
• importer/texture.cc (modified) (5 diffs)
• importer/texture.h (modified) (1 diff)
• importer/texture_sequence.cc (modified) (1 diff)
• importer/texture_sequence.h (modified) (1 diff)
• render2D/billboard.cc (modified) (2 diffs)
• render2D/billboard.h (modified) (1 diff)
• render2D/element_2d.cc (modified) (12 diffs)
• render2D/element_2d.h (modified) (6 diffs)
• shader.cc (modified) (12 diffs)
• shader.h (modified) (2 diffs)
• text_engine/font.cc (modified) (18 diffs)
• text_engine/font.h (modified) (3 diffs)
• text_engine/text.cc (modified) (12 diffs)
• text_engine/text.h (modified) (2 diffs)

trunk/src/lib/graphics/effects/fog_effect.cc

@@ -126 +126 @@
  * @param mode the mode character
  */
-GLint FogEffect::charToFogMode(const char* mode)
+GLint FogEffect::stringToFogMode(const std::string& mode)
 {
-  if( !strcmp( "GL_LINEAR", mode))
+  if(mode == "GL_LINEAR")
     return GL_LINEAR;
-  else if( !strcmp("GL_EXP", mode))
+  else if(mode == "GL_EXP")
     return GL_EXP;
-  else if(!strcmp("GL_EXP2", mode) )
+  else if(mode == "GL_EXP2" )
     return GL_EXP2;
   else

trunk/src/lib/graphics/effects/fog_effect.h

@@ -26 +26 @@
     virtual bool deactivate();
 
-    inline void setFogMode(const char* mode) { this->fogMode = this->charToFogMode(mode); }
+    inline void setFogMode(const std::string& mode) { this->fogMode = this->stringToFogMode(mode); }
     inline void setFogDensity(float density) { this->fogDensity = density; }
     inline void setFogRange(float start, float end) { this->fogStart = start; this->fogEnd = end; }
@@ -33 +33 @@
 
   private:
-    GLint charToFogMode(const char* mode);
+    GLint stringToFogMode(const std::string& mode);
 
 

trunk/src/lib/graphics/effects/lense_flare.cc

@@ -131 +131 @@
  * @param mode the mode character
  */
-GLint LenseFlare::charToFogMode(const char* mode)
+GLint LenseFlare::stringToFogMode(const std::string& mode)
 {}
 
@@ -147 +147 @@
  *  7th: Texture of the third burst
  */
-void LenseFlare::addFlare(const char* textureName)
+void LenseFlare::addFlare(const std::string& textureName)
 {
   if( this->flares.size() > LF_MAX_FLARES)
@@ -159 +159 @@
   bb->setSize(50, 50);
   this->flares.push_back(bb);
-  PRINTF(0)("Added a Lenseflare Billboard with texture %s\n", textureName);
+  PRINTF(4)("Added a Lenseflare Billboard with texture %s\n", textureName.c_str());
 
   // the first flare belongs to the light source
@@ -167 +167 @@
     bb->setVisibility(true);
   }
-  PRINTF(0)("Finished adding\n", textureName);
+  PRINTF(4)("Finished adding\n");
 }
 

trunk/src/lib/graphics/effects/lense_flare.h

@@ -39 +39 @@
     virtual void tick(float dt);
 
-    void addFlare(const char* textureName);
+    void addFlare(const std::string& textureName);
 
 
   private:
-    GLint charToFogMode(const char* mode);
+    GLint stringToFogMode(const std::string& mode);
     void setSourceVisibility(bool visibility) ;
 

trunk/src/lib/graphics/graphics_engine.cc

@@ -78 +78 @@
   this->screen = NULL;
 
-
-  // Hardware
-  this->hwRenderer = NULL;
-  this->hwVendor = NULL;
-  this->hwVersion = NULL;
-  this->hwExtensions = NULL;
-
   // initialize the Modules
   TextEngine::getInstance();
@@ -103 +96 @@
   // delete what has to be deleted here
   this->displayFPS( false );
-
-  delete[] this->hwRenderer;
-  delete[] this->hwVendor;
-  delete[] this->hwVersion;
-  delete this->hwExtensions;
 
   //TextEngine
@@ -169 +157 @@
 {
   // looking if we are in fullscreen-mode
-  const char* fullscreen = iniParser->getVar(CONFIG_NAME_FULLSCREEN, CONFIG_SECTION_VIDEO, "0");
-  if (strchr(fullscreen, '1') || !strcasecmp(fullscreen, "true"))
+  const std::string fullscreen = iniParser->getVar(CONFIG_NAME_FULLSCREEN, CONFIG_SECTION_VIDEO, "0");
+  if (fullscreen[0] == '1' || fullscreen == "true")
     this->fullscreenFlag = SDL_FULLSCREEN;
 
   // looking if we are in fullscreen-mode
-  const char* textures = iniParser->getVar(CONFIG_NAME_TEXTURES, CONFIG_SECTION_VIDEO_ADVANCED, "0");
-  if (strchr(textures, '1') || !strcasecmp(textures, "true"))
-    Texture::setTextureEnableState( true);
+  const std::string textures = iniParser->getVar(CONFIG_NAME_TEXTURES, CONFIG_SECTION_VIDEO_ADVANCED, "0");
+  if (textures[0] == '1' || textures == "true")
+    Texture::setTextureEnableState(true);
   else
     Texture::setTextureEnableState(false);
 
   // searching for a usefull resolution
-  SubString resolution(iniParser->getVar(CONFIG_NAME_RESOLUTION, CONFIG_SECTION_VIDEO, "640x480"), 'x');
+  SubString resolution(iniParser->getVar(CONFIG_NAME_RESOLUTION, CONFIG_SECTION_VIDEO, "640x480").c_str(), 'x'); ///FIXME
   //resolution.debug();
-
-  this->initVideo(atoi(resolution.getString(0)), atoi(resolution.getString(1)), 16);
+  MultiType x = resolution.getString(0), y = resolution.getString(1);
+  this->initVideo(x.getInt(), y.getInt(), 16);
 
   //   GraphicsEffect* fe = new FogEffect(NULL);
@@ -262 +250 @@
  * @param icon The name of the Icon on the Disc
  */
-void GraphicsEngine::setWindowName(const char* windowName, const char* icon)
-{
-  SDL_Surface* iconSurf = SDL_LoadBMP(icon);
+void GraphicsEngine::setWindowName(const std::string& windowName, const std::string& icon)
+{
+  SDL_Surface* iconSurf = SDL_LoadBMP(icon.c_str());
   if (iconSurf != NULL)
   {
     Uint32 colorkey = SDL_MapRGB(iconSurf->format, 0, 0, 0);
     SDL_SetColorKey(iconSurf, SDL_SRCCOLORKEY, colorkey);
-    SDL_WM_SetIcon(iconSurf,NULL);
+    SDL_WM_SetIcon(iconSurf, NULL);
     SDL_FreeSurface(iconSurf);
   }
 
-  SDL_WM_SetCaption (windowName, icon);
+  SDL_WM_SetCaption (windowName.c_str(), icon.c_str());
 }
 
@@ -312 +300 @@
   //  printf("%s %s %s\n %s", renderer, vendor, version, extensions);
 
-  if (this->hwRenderer == NULL && renderer != NULL)
-  {
-    this->hwRenderer = new char[strlen(renderer)+1];
-    strcpy(this->hwRenderer, renderer);
-  }
-  if (this->hwVendor == NULL && vendor != NULL)
-  {
-    this->hwVendor = new char[strlen(vendor)+1];
-    strcpy(this->hwVendor, vendor);
-  }
-  if (this->hwVersion == NULL && version != NULL)
-  {
-    this->hwVersion = new char[strlen(version)+11];
-    strcpy(this->hwVersion, version);
-  }
-
-  if (this->hwExtensions == NULL && extensions != NULL)
-    this->hwExtensions = new SubString((char*)glGetString(GL_EXTENSIONS), " \n\t,");
+  if (renderer != NULL)
+  {
+    this->hwRenderer == renderer;
+  }
+  if (vendor != NULL)
+  {
+    this->hwVendor == vendor;
+  }
+  if (version != NULL)
+  {
+    this->hwVersion == version;
+  }
+
+  if (extensions != NULL)
+    this->hwExtensions.split(extensions, " \n\t,");
 
   PRINT(4)("Running on : vendor: %s,  renderer: %s,  version:%s\n", vendor, renderer, version);
   PRINT(4)("Extensions:\n");
-  if (this->hwExtensions != NULL)
-    for (unsigned int i = 0; i < this->hwExtensions->getCount(); i++)
-      PRINT(4)("%d: %s\n", i, this->hwExtensions->getString(i));
+  for (unsigned int i = 0; i < this->hwExtensions.getCount(); i++)
+    PRINT(4)("%d: %s\n", i, this->hwExtensions.getString(i).c_str());
 
 
@@ -529 +513 @@
  * @return true if it is, false otherwise
  */
-bool GraphicsEngine::hwSupportsEXT(const char* extension)
-{
-  if (this->hwExtensions != NULL)
-    for (unsigned int i = 0; i < this->hwExtensions->getCount(); i++)
-      if (!strcmp(extension, this->hwExtensions->getString(i)))
-        return true;
+bool GraphicsEngine::hwSupportsEXT(const std::string& extension)
+{
+  for (unsigned int i = 0; i < this->hwExtensions.getCount(); i++)
+    if ( this->hwExtensions.getString(i) == extension)
+      return true;
   return false;
 }
@@ -587 +570 @@
 void GraphicsEngine::draw() const
 {
-//  LightManager::getInstance()->draw();
+  //  LightManager::getInstance()->draw();
 
   GraphicsEngine::storeMatrices();
@@ -668 +651 @@
   switch (event.type)
   {
-      case EV_VIDEO_RESIZE:
-      this->resolutionChanged(event.resize);
-      break;
-  }
-}
+  case EV_VIDEO_RESIZE:
+    this->resolutionChanged(event.resize);
+    break;
+  }
+}

trunk/src/lib/graphics/graphics_engine.h

@@ -14 +14 @@
 #include "sdlincl.h"
 #include "glincl.h"
+#include <list>
 
-#include <list>
+#include "substring.h"
 
 // Forward Declaration
 class Text;
 class IniParser;
-class SubString;
 class WorldEntity;
 class GraphicsEffect;
@@ -41 +41 @@
     int initFromIniFile(IniParser* iniParser);
 
-    void setWindowName(const char* windowName, const char* icon);
+    void setWindowName(const std::string& windowName, const std::string& icon);
 
     int setResolution(int width, int height, int bpp);
@@ -74 +74 @@
 
     void listModes();
-    bool hwSupportsEXT(const char* extension);
+    bool hwSupportsEXT(const std::string& extension);
 
     /** @brief swaps the GL_BUFFERS */
@@ -116 +116 @@
 
     // HARDWARE-Settings:
-    char*                      hwRenderer;         //!< HW-renderer-string
-    char*                      hwVendor;           //!< HW-vendor-string
-    char*                      hwVersion;          //!< HW-version-string
-    SubString*                 hwExtensions;       //!< All suported Extensions.
+    std::string                hwRenderer;         //!< HW-renderer-string
+    std::string                hwVendor;           //!< HW-vendor-string
+    std::string                hwVersion;          //!< HW-version-string
+    SubString                  hwExtensions;       //!< All suported Extensions.
 
     // FPS-related

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);

trunk/src/lib/graphics/render2D/billboard.cc

@@ -78 +78 @@
 void Billboard::loadParams(const TiXmlElement* root)
 {
-  LoadParam(root, "texture", this, Billboard, setTexture)
+  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
       .describe("the texture-file to load onto the Billboard");
 
@@ -100 +100 @@
  * @param textureFile The texture-file to load onto the crosshair
  */
-void Billboard::setTexture(const char* textureFile)
+void Billboard::setTexture(const std::string& textureFile)
 {
   this->material->setDiffuseMap(textureFile);

trunk/src/lib/graphics/render2D/billboard.h

@@ -30 +30 @@
 
     void setSize(float sizeX, float sizeY);
-    void setTexture(const char* textureFile);
+    void setTexture(const std::string& textureFile);
     void attachTo(PNode* pnode);
 

trunk/src/lib/graphics/render2D/element_2d.cc

@@ -180 +180 @@
  * @param alignment the alignment @see loadParams
 */
-void Element2D::setAlignment(const char* alignment)
-{
-  if (!strcmp(alignment, "center"))
+void Element2D::setAlignment(const std::string& alignment)
+{
+  if (alignment == "center")
     this->setAlignment(E2D_ALIGN_CENTER);
-  else if (!strcmp(alignment, "left"))
+  else if (alignment == "left")
     this->setAlignment(E2D_ALIGN_LEFT);
-  else if (!strcmp(alignment, "right"))
+  else if (alignment == "right")
     this->setAlignment(E2D_ALIGN_RIGHT);
-  else if (!strcmp(alignment, "screen-center"))
+  else if (alignment == "screen-center")
     this->setAlignment(E2D_ALIGN_SCREEN_CENTER);
 }
@@ -213 +213 @@
 /**
  * sets the layer onto which this 2D-element is projected to.
- * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const char* layer)
- */
-void Element2D::setLayer(const char* layer)
+ * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const std::string& layer)
+ */
+void Element2D::setLayer(const std::string& layer)
 {
   this->setLayer(Element2D::charToLayer2D(layer));
@@ -235 +235 @@
  * @param bindNode the name of the Node (should be existing)
  */
-void Element2D::setBindNode(const char* bindNode)
+void Element2D::setBindNode(const std::string& bindNode)
 {
   const PNode* tmpBindNode = dynamic_cast<const PNode*>(ClassList::getObject(bindNode, CL_PARENT_NODE));
@@ -572 +572 @@
  * @param childName the name of the child to add to this PNode
  */
-void Element2D::addChild2D (const char* childName)
+void Element2D::addChild2D (const std::string& childName)
 {
   Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
@@ -651 +651 @@
  * @param parentName the name of the Parent to set to this Element2D
  */
-void Element2D::setParent2D (const char* parentName)
+void Element2D::setParent2D (const std::string& parentName)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -658 +658 @@
   else
     PRINTF(2)("Not Found Element2D's (%s::%s) new Parent by Name: %s\n",
-                this->getClassName(), this->getName(), parentName);
+                this->getClassName(), this->getName(), parentName.c_str());
 }
 
@@ -704 +704 @@
  * @param bias the speed to iterate to this new Positions
  */
-void Element2D::setParentSoft2D(const char* parentName, float bias)
+void Element2D::setParentSoft2D(const std::string& parentName, float bias)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -724 +724 @@
  * @param parentMode a String representing this parentingMode
  */
-void Element2D::setParentMode2D (const char* parentingMode)
-{
-  this->setParentMode2D(Element2D::charToParentingMode2D(parentingMode));
+void Element2D::setParentMode2D (const std::string& parentingMode)
+{
+  this->setParentMode2D(Element2D::stringToParentingMode2D(parentingMode));
 }
 
@@ -952 +952 @@
             this->relCoordinate.y,
             this->getAbsDir2D(),
-            Element2D::parentingModeToChar2D(parentMode),
+            Element2D::parentingModeToString2D(parentMode),
             Element2D::layer2DToChar(this->layer));
 
@@ -1074 +1074 @@
  * @return the converted string
  */
-const char* Element2D::parentingModeToChar2D(int parentingMode)
+const char* Element2D::parentingModeToString2D(int parentingMode)
 {
   if (parentingMode == E2D_PARENT_LOCAL_ROTATE)
@@ -1093 +1093 @@
  * @return the int corresponding to the named parentingMode
  */
-E2D_PARENT_MODE Element2D::charToParentingMode2D(const char* parentingMode)
-{
-  if (!strcmp(parentingMode, "local-rotate"))
+E2D_PARENT_MODE Element2D::stringToParentingMode2D(const std::string& parentingMode)
+{
+  if (parentingMode == "local-rotate")
     return (E2D_PARENT_LOCAL_ROTATE);
-  else  if (!strcmp(parentingMode, "rotate-movement"))
+  else  if (parentingMode == "rotate-movement")
     return (E2D_PARENT_ROTATE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "movement"))
+  else  if (parentingMode == "movement")
     return (E2D_PARENT_MOVEMENT);
-  else  if (!strcmp(parentingMode, "all"))
+  else  if (parentingMode == "all")
     return (E2D_PARENT_ALL);
-  else  if (!strcmp(parentingMode, "rotate-and-move"))
+  else  if (parentingMode == "rotate-and-move")
     return (E2D_PARENT_ROTATE_AND_MOVE);
 }
@@ -1139 +1139 @@
  * @returns the E2D_LAYER on success, E2D_DEFAULT_LAYER on error.
  */
-E2D_LAYER Element2D::charToLayer2D(const char* layer)
-{
-  if (!strcmp(layer, "top"))
+E2D_LAYER Element2D::charToLayer2D(const std::string& layer)
+{
+  if (layer =="top")
     return (E2D_LAYER_TOP);
-  else  if (!strcmp(layer, "medium"))
+  else  if (layer == "medium")
     return (E2D_LAYER_MEDIUM);
-  else  if (!strcmp(layer, "bottom"))
+  else  if (layer == "bottom")
     return (E2D_LAYER_BOTTOM);
-  else  if (!strcmp(layer, "below-all"))
+  else  if (layer == "below-all")
     return (E2D_LAYER_BELOW_ALL);
   else

trunk/src/lib/graphics/render2D/element_2d.h

@@ -102 +102 @@
     /** @param alignment the new Alignment of the 2D-Element */
     inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
-    void setAlignment(const char* alignment);
+    void setAlignment(const std::string& alignment);
     inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
 
     // LAYERING //
     void setLayer(E2D_LAYER layer);
-    void setLayer(const char* layer);
+    void setLayer(const std::string& layer);
     /** @returns the Layer this Element is drawn to */
     inline E2D_LAYER getLayer() const { return this->layer; };
@@ -121 +121 @@
     /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
     inline void setBindNode(const PNode* bindNode) { this->bindNode = bindNode; };
-    void setBindNode(const char* bindNode);
+    void setBindNode(const std::string& bindNode);
     inline const PNode* getBindNode() const { return this->bindNode; };
 
@@ -181 +181 @@
 
     void addChild2D (Element2D* child);
-    void addChild2D (const char* childName);
+    void addChild2D (const std::string& childName);
     void removeChild2D (Element2D* child);
     void remove2D();
@@ -187 +187 @@
     /** @param parent the new parent of this Element2D */
     void setParent2D (Element2D* parent) { parent->addChild2D(this); };
-    void setParent2D (const char* parentName);
+    void setParent2D (const std::string& parentName);
     /** @returns the parent of this Element2D */
     inline Element2D* getParent2D () const { return this->parent; };
@@ -194 +194 @@
 
     void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
-    void setParentSoft2D(const char* parentName, float bias = 1.0);
+    void setParentSoft2D(const std::string& parentName, float bias = 1.0);
 
     void setParentMode2D (E2D_PARENT_MODE parentMode);
-    void setParentMode2D (const char* parentingMode);
+    void setParentMode2D (const std::string& parentingMode);
     /** @returns the Parenting mode of this node */
     int getParentMode2D() const { return this->parentMode; };
@@ -212 +212 @@
 
     // helper functions //
-    static const char* parentingModeToChar2D(int parentingMode);
-    static E2D_PARENT_MODE charToParentingMode2D(const char* parentingMode);
+    static const char* parentingModeToString2D(int parentingMode);
+    static E2D_PARENT_MODE stringToParentingMode2D(const std::string& parentingMode);
 
     static const char* layer2DToChar(E2D_LAYER layer);
-    static E2D_LAYER charToLayer2D(const char* layer);
+    static E2D_LAYER charToLayer2D(const std::string& layer);
 
   private:

trunk/src/lib/graphics/shader.cc

@@ -36 +36 @@
  * standard constructor
 */
-Shader::Shader (const char* vertexShaderFile, const char* fragmentShaderFile)
+Shader::Shader (const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
 {
    this->setClassID(CL_SHADER, "Shader");
 
-   this->fragmentShaderFile = NULL;
-   this->vertexShaderFile = NULL;
+   this->fragmentShaderFile = "";
+   this->vertexShaderFile = "";
    this->shaderProgram = 0;
    this->vertexShader = 0;
@@ -52 +52 @@
        this->shaderProgram = glCreateProgramObjectARB();
 
-       if (vertexShaderFile != NULL)
+       if (!vertexShaderFile.empty())
          this->loadShaderProgramm(SHADER_VERTEX, vertexShaderFile);
-       if (fragmentShaderFile != NULL)
+       if (!fragmentShaderFile.empty())
          this->loadShaderProgramm(SHADER_FRAGMENT, fragmentShaderFile);
        glLinkProgramARB(this->shaderProgram);
@@ -103 +103 @@
 }
 
-Shader* Shader::getShader(const char* vertexShaderFile, const char* fragmentShaderFile)
+Shader* Shader::getShader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
 {
   return (Shader*)ResourceManager::getInstance()->load(vertexShaderFile, SHADER,  RP_LEVEL, fragmentShaderFile);
@@ -116 +116 @@
 
 
-bool Shader::loadShaderProgramm(SHADER_TYPE type, const char* fileName)
+bool Shader::loadShaderProgramm(SHADER_TYPE type, const std::string& fileName)
 {
   GLhandleARB shader = 0;
@@ -129 +129 @@
   if (type == SHADER_VERTEX && GLEW_ARB_vertex_shader)
   {
-    this->vertexShaderFile = new char[strlen(fileName)+1];
-    strcpy(this->vertexShaderFile, fileName);
+    this->vertexShaderFile = fileName;
 
     shader = this->vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
@@ -137 +136 @@
   if (type == SHADER_FRAGMENT && GLEW_ARB_fragment_shader)
   {
-    this->fragmentShaderFile = new char[strlen(fileName)+1];
-    strcpy(this->fragmentShaderFile, fileName);
+    this->fragmentShaderFile = fileName;
 
     shader = this->fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
@@ -146 +144 @@
   {
     GLint status = 0;
-    glShaderSourceARB(shader, program->size(), (const char**)&(*program)[0], NULL);
+    /// FIXME do it back
+    //    glShaderSourceARB(shader, program->size(), (const std::string&)&(*program)[0], NULL);
     glCompileShaderARB(shader);
     // checking on error.
@@ -160 +159 @@
 }
 
-char* Shader::fileRead(const char* fileName)
+char* Shader::fileRead(const std::string& fileName)
 {
   FILE* fileHandle;
@@ -167 +166 @@
   int count = 0;
 
-  if (fileName == NULL)
+  if (fileName.empty())
     return NULL;
 
-  fileHandle = fopen(fileName, "rt");
+  fileHandle = fopen(fileName.c_str(), "rt");
 
   if (fileHandle == NULL)
@@ -187 +186 @@
 
 
-std::vector<char*>* Shader::fileReadArray(const char* fileName)
+std::vector<char*>* Shader::fileReadArray(const std::string& fileName)
 {
   FILE*    stream;           //< The stream we use to read the file.
 
-  if( (stream = fopen (fileName, "rt")) == NULL)
-  {
-    PRINTF(1)("Shader could not open %s\n", fileName);
+  if( (stream = fopen (fileName.c_str(), "rt")) == NULL)
+  {
+    PRINTF(1)("Shader could not open %s\n", fileName.c_str());
     return NULL;
   }
@@ -234 +233 @@
   if (type == SHADER_VERTEX && this->vertexShader != 0)
   {
-    delete[] this->vertexShaderFile;
-    this->vertexShaderFile = NULL;
+    this->vertexShaderFile = "";
     glDetachObjectARB(this->shaderProgram, this->vertexShader);
     glDeleteObjectARB(this->vertexShader);
@@ -245 +243 @@
   else if (type == SHADER_FRAGMENT && this->fragmentShader != 0)
   {
-    delete[] this->fragmentShaderFile;
-    this->fragmentShaderFile = NULL;
+    this->fragmentShaderFile = "";
     glDetachObjectARB(this->shaderProgram, this->fragmentShader);
     glDeleteObjectARB(this->fragmentShader);

trunk/src/lib/graphics/shader.h

@@ -27 +27 @@
 
   public:
-  Shader(const char* vertexShaderFile = NULL, const char* fragmentShaderFile = NULL);
+  Shader(const std::string& vertexShaderFile = "", const std::string& fragmentShaderFile = "");
   virtual ~Shader();
-  static Shader* getShader(const char* vertexShaderFile, const char* fragmentShaderFile);
+  static Shader* getShader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile);
   static bool unload(Shader* shader);
 
-  bool loadShaderProgramm(SHADER_TYPE type, const char* fileName);
+  bool loadShaderProgramm(SHADER_TYPE type, const std::string& fileName);
   void activateShader();
   static void deactivateShader();
   void deleteProgram(SHADER_TYPE type);
 
-  char* fileRead(const char* fileName);
-  std::vector<char*>* fileReadArray(const char* fileName);
+  char* fileRead(const std::string& fileName);
+  std::vector<char*>* fileReadArray(const std::string& fileName);
 
   static bool checkShaderAbility();
@@ -54 +54 @@
 
  private:
-   char*                  fragmentShaderFile;
-   char*                  vertexShaderFile;
+   std::string            fragmentShaderFile;
+   std::string            vertexShaderFile;
    GLhandleARB            shaderProgram;
    GLhandleARB            vertexShader;

trunk/src/lib/graphics/text_engine/font.cc

@@ -37 +37 @@
  * @param fontSize the Size of the Font in Pixels
  */
-Font::Font(const char* fontFile, unsigned int renderSize)
+Font::Font(const std::string& fontFile, unsigned int renderSize)
 {
   this->init();
@@ -44 +44 @@
   this->setStyle("c");
 
-  if (fontFile != NULL)
+  if (!fontFile.empty())
     this->loadFontFromTTF(fontFile);
 }
@@ -52 +52 @@
  * @param imageFile the ImageFile to load the Font From.
  */
-Font::Font(const char* imageFile)
+Font::Font(const std::string& imageFile)
 {
   this->init();
@@ -58 +58 @@
   //  this->setSize(fontSize);
   SDL_Surface* image = NULL;
-  if (imageFile != NULL)
-    image = IMG_Load(imageFile);
+  if (!imageFile.empty())
+    image = IMG_Load(imageFile.c_str());
   else
     return;
@@ -68 +68 @@
   }
   else
-    PRINTF(1)("loading from surface %s failed: %s\n", imageFile, IMG_GetError());
+    PRINTF(1)("loading from surface %s failed: %s\n", imageFile.c_str(), IMG_GetError());
 }
 
@@ -114 +114 @@
 
   //! @todo check if we really do not need to delete the fastTextureID here.
-//   if (this->fastTextureID != 0)
-//     if(glIsTexture(this->fastTextureID))
-//       glDeleteTextures(1, &this->fastTextureID);
+  //   if (this->fastTextureID != 0)
+  //     if(glIsTexture(this->fastTextureID))
+  //       glDeleteTextures(1, &this->fastTextureID);
 
   // erease this font out of the memory.
@@ -140 +140 @@
  * @returns true if loaded, false if something went wrong, or if a font was loaded before.
  */
-bool Font::loadFontFromTTF(const char* fontFile)
+bool Font::loadFontFromTTF(const std::string& fontFile)
 {
   // checking for existent Font.
@@ -222 +222 @@
  *   i: italic, b: bold, u, underline
  */
-void Font::setStyle(const char* renderStyle)
+void Font::setStyle(const std::string& renderStyle)
 {
   this->renderStyle = TTF_STYLE_NORMAL;
 
-  for (int i = 0; i < strlen(renderStyle); i++)
-    if (strncmp(renderStyle+i, "b", 1) == 0)
+  for (int i = 0; i < renderStyle.size(); i++)
+  {
+    if (renderStyle[i] == 'b')
       this->renderStyle |= TTF_STYLE_BOLD;
-  else if (strncmp(renderStyle+i, "i", 1) == 0)
-    this->renderStyle |= TTF_STYLE_ITALIC;
-  else if (strncmp(renderStyle+i, "u", 1) == 0)
-    this->renderStyle |= TTF_STYLE_UNDERLINE;
-
+    else if (renderStyle[i] == 'i')
+      this->renderStyle |= TTF_STYLE_ITALIC;
+    else if (renderStyle[i] == 'u')
+      this->renderStyle |= TTF_STYLE_UNDERLINE;
+  }
   if (likely(this->fontTTF != NULL))
     TTF_SetFontStyle(this->fontTTF, this->renderStyle);
-//  else
-//    PRINTF(2)("Font was not initialized, please do so before setting the Font-Style.\n");
+  //  else
+  //    PRINTF(2)("Font was not initialized, please do so before setting the Font-Style.\n");
 }
 
@@ -247 +248 @@
  * @param fileName the File to write the image into.
  */
-void Font::createAsciiImage(const char* fileName, unsigned int size) const
+void Font::createAsciiImage(const std::string& fileName, unsigned int size) const
 {
   if (this->fontTTF == NULL)
@@ -258 +259 @@
   SDL_Rect tmpRect; // this represents a Rectangle for blitting.
   SDL_Surface* tmpSurf =  SDL_CreateRGBSurface(SDL_SWSURFACE,
-                                               height*size, height*size,
-                                               32,
+                          height*size, height*size,
+                          32,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
-                                               0x000000FF,
-                                               0x0000FF00,
-                                               0x00FF0000,
-                                               0xFF000000
+                          0x000000FF,
+                          0x0000FF00,
+                          0x00FF0000,
+                          0xFF000000
 #else
-                                               0xFF000000,
-                                               0x00FF0000,
-                                               0x0000FF00,
-                                               0x000000FF
+                          0xFF000000,
+                          0x00FF0000,
+                          0x0000FF00,
+                          0x000000FF
 #endif
                                               );
@@ -299 +300 @@
     }
   }
-  SDL_SaveBMP(tmpSurf, fileName);
+  SDL_SaveBMP(tmpSurf, fileName.c_str());
   SDL_FreeSurface(tmpSurf);
 }
@@ -409 +410 @@
 
   this->initGlyphs(32, numberOfGlyphs);
-//  this->glyphArray[32]->width = .5f; //!< @todo find out the real size of a Space
+  //  this->glyphArray[32]->width = .5f; //!< @todo find out the real size of a Space
 
   int rectSize = this->findOptimalFastTextureSize();
@@ -418 +419 @@
   SDL_Rect tmpRect; // this represents a Rectangle for blitting.
   SDL_Surface* tmpSurf =  SDL_CreateRGBSurface(SDL_SWSURFACE,
-                                               rectSize, rectSize,
-                                               32,
+                          rectSize, rectSize,
+                          32,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
-                                               0x000000FF,
-                                               0x0000FF00,
-                                               0x00FF0000,
-                                               0xFF000000
+                          0x000000FF,
+                          0x0000FF00,
+                          0x00FF0000,
+                          0xFF000000
 #else
-                                               0xFF000000,
-                                               0x00FF0000,
-                                               0x0000FF00,
-                                               0x000000FF
+                          0xFF000000,
+                          0x00FF0000,
+                          0x0000FF00,
+                          0x000000FF
 #endif
                                               );
@@ -457 +458 @@
         break;
       }
-          // reading in the new Glyph
+      // reading in the new Glyph
       if (likely(this->fontTTF != NULL))
       {
@@ -521 +522 @@
   for (int i = from; i <= lastGlyph; i++)
   {
-      // setting up all the Glyphs we like.
+    // setting up all the Glyphs we like.
     glyphArray[i] = getGlyphMetrics(i);
   }
@@ -555 +556 @@
       if((tmpGlyph = this->glyphArray[i]) != NULL)
       {
-              // getting the height of the highest Glyph in the Line.
+        // getting the height of the highest Glyph in the Line.
         if (tmpGlyph->height*this->renderSize > maxLineHeight)
           maxLineHeight = (int)(tmpGlyph->height*this->renderSize);
@@ -563 +564 @@
           x = 0;
           y = y + maxLineHeight;
-                  //maxLineHeight = 0;
+          //maxLineHeight = 0;
         }
         if (y + maxLineHeight + 1 > size)
@@ -592 +593 @@
   if(style==TTF_STYLE_NORMAL)
     PRINTF(0)(" normal");
-  else {
+  else
+  {
     if(style&TTF_STYLE_BOLD)
       PRINTF(0)(" bold");

trunk/src/lib/graphics/text_engine/font.h

@@ -55 +55 @@
 {
   public:
-    Font(const char* fontFile,
+    Font(const std::string& fontFile,
          unsigned int renderSize);
-    Font(const char* imageFile);
+    Font(const std::string& imageFile);
     Font(char** xpmArray);
     virtual ~Font();
@@ -64 +64 @@
 
   //  font
-    bool loadFontFromTTF(const char* fontFile);
+    bool loadFontFromTTF(const std::string& fontFile);
     bool loadFontFromSDL_Surface(SDL_Surface* surface);
 
-    void setStyle(const char* renderStyle);
+    void setStyle(const std::string& renderStyle);
 
     /** @returns a Pointer to the Array of Glyphs */
@@ -78 +78 @@
     inline static Font* getDefaultFont() { if (Font::defaultFont == NULL) initDefaultFont(); return Font::defaultFont; };
 
-    void createAsciiImage(const char* fileName, unsigned int size) const;
+    void createAsciiImage(const std::string& fileName, unsigned int size) const;
     static void initDefaultFont();
     static void removeDefaultFont();

trunk/src/lib/graphics/text_engine/text.cc

@@ -32 +32 @@
  * @param type The renderType to display this font in
  */
-Text::Text(const char* fontFile, unsigned int textSize)
+Text::Text(const std::string& fontFile, unsigned int textSize)
 {
   this->init();
 
-  if (fontFile != NULL)
+  if (!fontFile.empty())
     this->setFont(fontFile, FONT_DEFAULT_RENDER_SIZE);
   this->setSizeY2D(textSize);
@@ -50 +50 @@
   if (this->font != NULL && this->font != Font::getDefaultFont())
     ResourceManager::getInstance()->unload(this->font);
-
-  if (this->text)
-    delete[] this->text;
 }
 
@@ -64 +61 @@
   // initialize this Text
   this->font = NULL;
-  this->text = NULL;
-  this->externText = NULL;
+  this->text = "";
   this->setAlignment(TEXT_DEFAULT_ALIGNMENT);
   this->blending = TEXT_DEFAULT_BLENDING;
   this->color = TEXT_DEFAULT_COLOR;
   this->setSize(TEXT_DEFAULT_SIZE);
-  this->setText(NULL);
+  this->setText("");
 }
 
@@ -78 +74 @@
  * @param fontSize the Size of the Font
  */
-void Text::setFont(const char* fontFile, unsigned int fontSize)
+void Text::setFont(const std::string& fontFile, unsigned int fontSize)
 {
   Font* tmpFont;
@@ -90 +86 @@
 
   // load a new Font
-  if (fontFile != NULL)
+  if (!fontFile.empty())
   {
     tmpFont = (Font*)ResourceManager::getInstance()->load(fontFile, TTF, RP_GAME, (int)fontSize);
@@ -96 +92 @@
       this->font = tmpFont;
     else
-      PRINTF(2)("Font %s could not be loaded, probably file not found\n", fontFile);
+      PRINTF(2)("Font %s could not be loaded, probably file not found\n", fontFile.c_str());
   }
 }
@@ -104 +100 @@
  * @param text the new text to set
  */
-void Text::setText(const char* text, bool isExtern)
-{
-  if (isExtern)
-  {
-    this->externText = text;
-
-    if (unlikely(this->text != NULL))
-    {
-      delete[] this->text;
-      this->text = NULL;
-    }
-  }
-  else
-  {
-    this->externText = NULL;
-    if (this->text)
-      delete[] this->text;
-    if (text != NULL)
-    {
-      this->text = new char[strlen(text)+1];
-      strcpy(this->text, text);
-    }
-    else
-      this->text = NULL;
-  }
+void Text::setText(const std::string& text)
+{
+  this->text = text;
 
   // setting up the Text-Width if DYNAMIC
@@ -138 +112 @@
 
     float width = 0;
-    const char* tmpText = this->externText;
-    if (this->externText == NULL)
-      tmpText = this->text;
-    if (tmpText != NULL)
+    if (!this->text.empty())
     {
-      while (*tmpText != '\0')
+      for (unsigned int i = 0; i < this->text.size(); i++)
       {
-        if(glyphArray[*tmpText] != NULL)
+        if(glyphArray[this->text[i]] != NULL)
         {
-          width += glyphArray[*tmpText]->advance;
+          width += glyphArray[this->text[i]]->advance;
         }
-        tmpText++;
       }
       this->setSizeX2D(width *this->getSizeY2D());
@@ -190 +160 @@
     glBindTexture(GL_TEXTURE_2D, Font::getDefaultFont()->getTexture());
   }
-  const char* tmpText = this->externText;
-  if (this->externText == NULL)
-    tmpText = this->text;
-  if (likely(tmpText != NULL))
+  if (likely(!this->text.empty()))
   {
     glTranslatef(getAbsCoor2D().x, getAbsCoor2D().y, 0);
@@ -201 +168 @@
 
     glBegin(GL_QUADS);
-    while (likely(*tmpText != '\0'))
+    for (unsigned int i = 0; i < this->text.size(); i++)
     {
-      if(likely((tmpGlyph = glyphArray[*tmpText]) != NULL))
+      if(likely((tmpGlyph = glyphArray[this->text[i]]) != NULL))
       {
         glTexCoord2f(tmpGlyph->texCoord[1], tmpGlyph->texCoord[2]);
@@ -219 +186 @@
         posX += tmpGlyph->advance * this->getSizeY2D();
       }
-      ++tmpText;
     }
     glEnd();
@@ -232 +198 @@
 void Text::debug() const
 {
-  if (this->externText == NULL)
-    PRINT(0)("=== TEXT: %s ===\n", this->text);
-  else
-    PRINT(0)("=== TEXT: %s ===\n", this->externText);
+  PRINT(0)("=== TEXT: %s ===\n", this->text.c_str());
 
   if (this->getBindNode())

trunk/src/lib/graphics/text_engine/text.h

@@ -39 +39 @@
 {
   public:
-    Text(const char* fontFile = NULL, unsigned int fontSize = TEXT_DEFAULT_SIZE);
+    Text(const std::string& fontFile = "", unsigned int fontSize = TEXT_DEFAULT_SIZE);
     virtual ~Text();
     void init();
 
-    void setFont(const char* fontFile, unsigned int renderSize);
+    void setFont(const std::string& fontFile, unsigned int renderSize);
 
-    void setText(const char* text, bool isExtern = false);
+    void setText(const std::string& text);
 
     /** @returns the String this Text displays */
-    inline const char* getText() const { return (externText == NULL)?this->text:this->externText; };
+    inline const std::string& getText() const { return this->text; };
     /** @param blending the blending intensity to set (between 0.0 and 1.0) */
     inline void setBlending(float blending) { this->blending = blending; };
@@ -69 +69 @@
     Font*             font;           //!< Font of this text
 
-    char*             text;           //!< The text to display
-    const char*       externText;     //!< the text to Display from an external Source.
+    std::string       text;           //!< The text to display
     Vector            color;          //!< The color of the font.
     float             blending;       //!< The blending intensity.