Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 7216 in orxonox.OLD for branches/std/src


Ignore:
Timestamp:
Mar 12, 2006, 8:54:30 AM (19 years ago)
Author:
bensch
Message:

orxonox/std:: compile and run again, with many more std::strings….

Location:
branches/std/src
Files:
68 edited

Legend:

Unmodified
Added
Removed

  • branches/std/src/lib/coord/p_node.cc

    r7193 r7216  
    540540 * @param childName the name of the child to add to this PNode
    541541 */
    542 void PNode::addChild (const char* childName)
     542void PNode::addChild (const std::string& childName)
    543543{
    544544  PNode* childNode = dynamic_cast<PNode*>(ClassList::getObject(childName, CL_PARENT_NODE));
    … …  
    624624 * @param parentName the name of the Parent to set to this PNode
    625625 */
    626 void PNode::setParent (const char* parentName)
     626void PNode::setParent (const std::string& parentName)
    627627{
    628628  PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
    … …  
    631631  else
    632632    PRINTF(2)("Not Found PNode's (%s::%s) new Parent by Name: %s\n",
    633               this->getClassName(), this->getName(), parentName);
     633        this->getClassName(), this->getName(), parentName.c_str());
    634634}
    635635
    … …  
    699699 * @param parentMode a String representing this parentingMode
    700700 */
    701 void PNode::setParentMode (const char* parentingMode)
     701void PNode::setParentMode (const std::string& parentingMode)
    702702{
    703703  this->setParentMode(PNode::charToParentingMode(parentingMode));
    … …  
    10681068 * @return the int corresponding to the named parentingMode
    10691069 */
    1070 PARENT_MODE PNode::charToParentingMode(const char* parentingMode)
    1071 {
    1072   if (!strcmp(parentingMode, "local-rotate"))
     1070PARENT_MODE PNode::charToParentingMode(const std::string& parentingMode)
     1071{
     1072  if (parentingMode == "local-rotate")
    10731073    return (PNODE_LOCAL_ROTATE);
    1074   else  if (!strcmp(parentingMode, "rotate-movement"))
     1074  else  if (parentingMode == "rotate-movement")
    10751075    return (PNODE_ROTATE_MOVEMENT);
    1076   else  if (!strcmp(parentingMode, "movement"))
     1076  else  if (parentingMode == "movement")
    10771077    return (PNODE_MOVEMENT);
    1078   else  if (!strcmp(parentingMode, "all"))
     1078  else  if (parentingMode == "all")
    10791079    return (PNODE_ALL);
    1080   else  if (!strcmp(parentingMode, "rotate-and-move"))
     1080  else  if (parentingMode == "rotate-and-move")
    10811081    return (PNODE_ROTATE_AND_MOVE);
    10821082}

  • branches/std/src/lib/coord/p_node.h

    r7076 r7216  
    143143  // PARENTING //
    144144  void addChild (PNode* child);
    145   void addChild (const char* childName);
     145  void addChild (const std::string& childName);
    146146  void removeChild (PNode* child);
    147147  void removeNode();
    … …  
    151151  /** @param parent the new parent of this node */
    152152  inline void setParent (PNode* parent) { parent->addChild(this); };
    153   void setParent (const char* parentName);
     153  void setParent (const std::string& parentName);
    154154  /** @returns the parent of this PNode */
    155155  inline PNode* getParent () const { return this->parent; };
    … …  
    162162  // PARENTING_MODE AND OTHER FLAGS //
    163163  void setParentMode (PARENT_MODE parentMode);
    164   void setParentMode (const char* parentingMode);
     164  void setParentMode (const std::string& parentingMode);
    165165  /** @returns the Parenting mode of this node */
    166166  int getParentMode() const { return 0x000f & this->parentMode; };
    … …  
    184184  // HELPER_FUNCTIONS //
    185185  static const char* parentingModeToChar(int parentingMode);
    186   static PARENT_MODE charToParentingMode(const char* parentingMode);
     186  static PARENT_MODE charToParentingMode(const std::string& parentingMode);
    187187  float distance(const PNode* node) const { return (this->getAbsCoor() - node->getAbsCoor()).len(); };
    188188

  • branches/std/src/lib/graphics/effects/fog_effect.cc

    r7193 r7216  
    126126 * @param mode the mode character
    127127 */
    128 GLint FogEffect::charToFogMode(const char* mode)
     128GLint FogEffect::stringToFogMode(const std::string& mode)
    129129{
    130   if( !strcmp( "GL_LINEAR", mode))
     130  if(mode == "GL_LINEAR")
    131131    return GL_LINEAR;
    132   else if( !strcmp("GL_EXP", mode))
     132  else if(mode == "GL_EXP")
    133133    return GL_EXP;
    134   else if(!strcmp("GL_EXP2", mode) )
     134  else if(mode == "GL_EXP2" )
    135135    return GL_EXP2;
    136136  else

  • branches/std/src/lib/graphics/effects/fog_effect.h

    r7107 r7216  
    2626    virtual bool deactivate();
    2727
    28     inline void setFogMode(const char* mode) { this->fogMode = this->charToFogMode(mode); }
     28    inline void setFogMode(const std::string& mode) { this->fogMode = this->stringToFogMode(mode); }
    2929    inline void setFogDensity(float density) { this->fogDensity = density; }
    3030    inline void setFogRange(float start, float end) { this->fogStart = start; this->fogEnd = end; }
    … …  
    3333
    3434  private:
    35     GLint charToFogMode(const char* mode);
     35    GLint stringToFogMode(const std::string& mode);
    3636
    3737

  • branches/std/src/lib/graphics/effects/lense_flare.cc

    r7193 r7216  
    147147 *  7th: Texture of the third burst
    148148 */
    149 void LenseFlare::addFlare(const char* textureName)
     149void LenseFlare::addFlare(const std::string& textureName)
    150150{
    151151  if( this->flares.size() > LF_MAX_FLARES)
    … …  
    159159  bb->setSize(50, 50);
    160160  this->flares.push_back(bb);
    161   PRINTF(0)("Added a Lenseflare Billboard with texture %s\n", textureName);
     161  PRINTF(4)("Added a Lenseflare Billboard with texture %s\n", textureName.c_str());
    162162
    163163  // the first flare belongs to the light source
    … …  
    167167    bb->setVisibility(true);
    168168  }
    169   PRINTF(0)("Finished adding\n", textureName);
     169  PRINTF(4)("Finished adding\n");
    170170}
    171171

  • branches/std/src/lib/graphics/effects/lense_flare.h

    r7015 r7216  
    3939    virtual void tick(float dt);
    4040
    41     void addFlare(const char* textureName);
     41    void addFlare(const std::string& textureName);
    4242
    4343

  • branches/std/src/lib/graphics/render2D/billboard.cc

    r7193 r7216  
    7878void Billboard::loadParams(const TiXmlElement* root)
    7979{
    80   LoadParam(root, "texture", this, Billboard, setTexture)
     80  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
    8181      .describe("the texture-file to load onto the Billboard");
    8282
    … …  
    100100 * @param textureFile The texture-file to load onto the crosshair
    101101 */
    102 void Billboard::setTexture(const char* textureFile)
     102void Billboard::setTexture(const std::string& textureFile)
    103103{
    104104  this->material->setDiffuseMap(textureFile);

  • branches/std/src/lib/graphics/render2D/billboard.h

    r6815 r7216  
    3030
    3131    void setSize(float sizeX, float sizeY);
    32     void setTexture(const char* textureFile);
     32    void setTexture(const std::string& textureFile);
    3333    void attachTo(PNode* pnode);
    3434

  • branches/std/src/lib/graphics/render2D/element_2d.cc

    r7199 r7216  
    180180 * @param alignment the alignment @see loadParams
    181181*/
    182 void Element2D::setAlignment(const char* alignment)
    183 {
    184   if (!strcmp(alignment, "center"))
     182void Element2D::setAlignment(const std::string& alignment)
     183{
     184  if (alignment == "center")
    185185    this->setAlignment(E2D_ALIGN_CENTER);
    186   else if (!strcmp(alignment, "left"))
     186  else if (alignment == "left")
    187187    this->setAlignment(E2D_ALIGN_LEFT);
    188   else if (!strcmp(alignment, "right"))
     188  else if (alignment == "right")
    189189    this->setAlignment(E2D_ALIGN_RIGHT);
    190   else if (!strcmp(alignment, "screen-center"))
     190  else if (alignment == "screen-center")
    191191    this->setAlignment(E2D_ALIGN_SCREEN_CENTER);
    192192}
    … …  
    213213/**
    214214 * sets the layer onto which this 2D-element is projected to.
    215  * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const char* layer)
    216  */
    217 void Element2D::setLayer(const char* layer)
     215 * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const std::string& layer)
     216 */
     217void Element2D::setLayer(const std::string& layer)
    218218{
    219219  this->setLayer(Element2D::charToLayer2D(layer));
    … …  
    235235 * @param bindNode the name of the Node (should be existing)
    236236 */
    237 void Element2D::setBindNode(const char* bindNode)
     237void Element2D::setBindNode(const std::string& bindNode)
    238238{
    239239  const PNode* tmpBindNode = dynamic_cast<const PNode*>(ClassList::getObject(bindNode, CL_PARENT_NODE));
    … …  
    572572 * @param childName the name of the child to add to this PNode
    573573 */
    574 void Element2D::addChild2D (const char* childName)
     574void Element2D::addChild2D (const std::string& childName)
    575575{
    576576  Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
    … …  
    651651 * @param parentName the name of the Parent to set to this Element2D
    652652 */
    653 void Element2D::setParent2D (const char* parentName)
     653void Element2D::setParent2D (const std::string& parentName)
    654654{
    655655  Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
    … …  
    658658  else
    659659    PRINTF(2)("Not Found Element2D's (%s::%s) new Parent by Name: %s\n",
    660                 this->getClassName(), this->getName(), parentName);
     660                this->getClassName(), this->getName(), parentName.c_str());
    661661}
    662662
    … …  
    704704 * @param bias the speed to iterate to this new Positions
    705705 */
    706 void Element2D::setParentSoft2D(const char* parentName, float bias)
     706void Element2D::setParentSoft2D(const std::string& parentName, float bias)
    707707{
    708708  Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
    … …  
    724724 * @param parentMode a String representing this parentingMode
    725725 */
    726 void Element2D::setParentMode2D (const char* parentingMode)
     726void Element2D::setParentMode2D (const std::string& parentingMode)
    727727{
    728728  this->setParentMode2D(Element2D::charToParentingMode2D(parentingMode));
    … …  
    10931093 * @return the int corresponding to the named parentingMode
    10941094 */
    1095 E2D_PARENT_MODE Element2D::charToParentingMode2D(const char* parentingMode)
    1096 {
    1097   if (!strcmp(parentingMode, "local-rotate"))
     1095E2D_PARENT_MODE Element2D::charToParentingMode2D(const std::string& parentingMode)
     1096{
     1097  if (parentingMode == "local-rotate")
    10981098    return (E2D_PARENT_LOCAL_ROTATE);
    1099   else  if (!strcmp(parentingMode, "rotate-movement"))
     1099  else  if (parentingMode == "rotate-movement")
    11001100    return (E2D_PARENT_ROTATE_MOVEMENT);
    1101   else  if (!strcmp(parentingMode, "movement"))
     1101  else  if (parentingMode == "movement")
    11021102    return (E2D_PARENT_MOVEMENT);
    1103   else  if (!strcmp(parentingMode, "all"))
     1103  else  if (parentingMode == "all")
    11041104    return (E2D_PARENT_ALL);
    1105   else  if (!strcmp(parentingMode, "rotate-and-move"))
     1105  else  if (parentingMode == "rotate-and-move")
    11061106    return (E2D_PARENT_ROTATE_AND_MOVE);
    11071107}
    … …  
    11391139 * @returns the E2D_LAYER on success, E2D_DEFAULT_LAYER on error.
    11401140 */
    1141 E2D_LAYER Element2D::charToLayer2D(const char* layer)
    1142 {
    1143   if (!strcmp(layer, "top"))
     1141E2D_LAYER Element2D::charToLayer2D(const std::string& layer)
     1142{
     1143  if (layer =="top")
    11441144    return (E2D_LAYER_TOP);
    1145   else  if (!strcmp(layer, "medium"))
     1145  else  if (layer == "medium")
    11461146    return (E2D_LAYER_MEDIUM);
    1147   else  if (!strcmp(layer, "bottom"))
     1147  else  if (layer == "bottom")
    11481148    return (E2D_LAYER_BOTTOM);
    1149   else  if (!strcmp(layer, "below-all"))
     1149  else  if (layer == "below-all")
    11501150    return (E2D_LAYER_BELOW_ALL);
    11511151  else

  • branches/std/src/lib/graphics/render2D/element_2d.h

    r7052 r7216  
    102102    /** @param alignment the new Alignment of the 2D-Element */
    103103    inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
    104     void setAlignment(const char* alignment);
     104    void setAlignment(const std::string& alignment);
    105105    inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
    106106
    107107    // LAYERING //
    108108    void setLayer(E2D_LAYER layer);
    109     void setLayer(const char* layer);
     109    void setLayer(const std::string& layer);
    110110    /** @returns the Layer this Element is drawn to */
    111111    inline E2D_LAYER getLayer() const { return this->layer; };
    … …  
    121121    /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
    122122    inline void setBindNode(const PNode* bindNode) { this->bindNode = bindNode; };
    123     void setBindNode(const char* bindNode);
     123    void setBindNode(const std::string& bindNode);
    124124    inline const PNode* getBindNode() const { return this->bindNode; };
    125125
    … …  
    181181
    182182    void addChild2D (Element2D* child);
    183     void addChild2D (const char* childName);
     183    void addChild2D (const std::string& childName);
    184184    void removeChild2D (Element2D* child);
    185185    void remove2D();
    … …  
    187187    /** @param parent the new parent of this Element2D */
    188188    void setParent2D (Element2D* parent) { parent->addChild2D(this); };
    189     void setParent2D (const char* parentName);
     189    void setParent2D (const std::string& parentName);
    190190    /** @returns the parent of this Element2D */
    191191    inline Element2D* getParent2D () const { return this->parent; };
    … …  
    194194
    195195    void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
    196     void setParentSoft2D(const char* parentName, float bias = 1.0);
     196    void setParentSoft2D(const std::string& parentName, float bias = 1.0);
    197197
    198198    void setParentMode2D (E2D_PARENT_MODE parentMode);
    199     void setParentMode2D (const char* parentingMode);
     199    void setParentMode2D (const std::string& parentingMode);
    200200    /** @returns the Parenting mode of this node */
    201201    int getParentMode2D() const { return this->parentMode; };
    … …  
    213213    // helper functions //
    214214    static const char* parentingModeToChar2D(int parentingMode);
    215     static E2D_PARENT_MODE charToParentingMode2D(const char* parentingMode);
     215    static E2D_PARENT_MODE charToParentingMode2D(const std::string& parentingMode);
    216216
    217217    static const char* layer2DToChar(E2D_LAYER layer);
    218     static E2D_LAYER charToLayer2D(const char* layer);
     218    static E2D_LAYER charToLayer2D(const std::string& layer);
    219219
    220220  private:

  • branches/std/src/lib/graphics/text_engine/text.cc

    r7207 r7216  
    5050  if (this->font != NULL && this->font != Font::getDefaultFont())
    5151    ResourceManager::getInstance()->unload(this->font);
    52 
    53   if (this->text)
    54     delete[] this->text;
    5552}
    5653
    … …  
    6461  // initialize this Text
    6562  this->font = NULL;
    66   this->text = NULL;
    67   this->externText = NULL;
     63  this->text = "";
    6864  this->setAlignment(TEXT_DEFAULT_ALIGNMENT);
    6965  this->blending = TEXT_DEFAULT_BLENDING;
    7066  this->color = TEXT_DEFAULT_COLOR;
    7167  this->setSize(TEXT_DEFAULT_SIZE);
    72   this->setText(NULL);
     68  this->setText("");
    7369}
    7470
    … …  
    104100 * @param text the new text to set
    105101 */
    106 void Text::setText(const char* text, bool isExtern)
    107 {
    108   if (isExtern)
    109   {
    110     this->externText = text;
    111 
    112     if (unlikely(this->text != NULL))
    113     {
    114       delete[] this->text;
    115       this->text = NULL;
    116     }
    117   }
    118   else
    119   {
    120     this->externText = NULL;
    121     if (this->text)
    122       delete[] this->text;
    123     if (text != NULL)
    124     {
    125       this->text = new char[strlen(text)+1];
    126       strcpy(this->text, text);
    127     }
    128     else
    129       this->text = NULL;
    130   }
     102void Text::setText(const std::string& text)
     103{
     104  this->text = text;
    131105
    132106  // setting up the Text-Width if DYNAMIC
    … …  
    138112
    139113    float width = 0;
    140     const char* tmpText = this->externText;
    141     if (this->externText == NULL)
    142       tmpText = this->text;
    143     if (tmpText != NULL)
     114    if (!this->text.empty())
    144115    {
    145       while (*tmpText != '\0')
     116      for (unsigned int i = 0; i < this->text.size(); i++)
    146117      {
    147         if(glyphArray[*tmpText] != NULL)
     118        if(glyphArray[this->text[i]] != NULL)
    148119        {
    149           width += glyphArray[*tmpText]->advance;
     120          width += glyphArray[this->text[i]]->advance;
    150121        }
    151         tmpText++;
    152122      }
    153123      this->setSizeX2D(width *this->getSizeY2D());
    … …  
    190160    glBindTexture(GL_TEXTURE_2D, Font::getDefaultFont()->getTexture());
    191161  }
    192   const char* tmpText = this->externText;
    193   if (this->externText == NULL)
    194     tmpText = this->text;
    195   if (likely(tmpText != NULL))
     162  if (likely(!this->text.empty()))
    196163  {
    197164    glTranslatef(getAbsCoor2D().x, getAbsCoor2D().y, 0);
    … …  
    201168
    202169    glBegin(GL_QUADS);
    203     while (likely(*tmpText != '\0'))
     170    for (unsigned int i = 0; i < this->text.size(); i++)
    204171    {
    205       if(likely((tmpGlyph = glyphArray[*tmpText]) != NULL))
     172      if(likely((tmpGlyph = glyphArray[this->text[i]]) != NULL))
    206173      {
    207174        glTexCoord2f(tmpGlyph->texCoord[1], tmpGlyph->texCoord[2]);
    … …  
    219186        posX += tmpGlyph->advance * this->getSizeY2D();
    220187      }
    221       ++tmpText;
    222188    }
    223189    glEnd();
    … …  
    232198void Text::debug() const
    233199{
    234   if (this->externText == NULL)
    235     PRINT(0)("=== TEXT: %s ===\n", this->text);
    236   else
    237     PRINT(0)("=== TEXT: %s ===\n", this->externText);
     200  PRINT(0)("=== TEXT: %s ===\n", this->text.c_str());
    238201
    239202  if (this->getBindNode())

  • branches/std/src/lib/graphics/text_engine/text.h

    r7207 r7216  
    4545    void setFont(const std::string& fontFile, unsigned int renderSize);
    4646
    47     void setText(const char* text, bool isExtern = false);
     47    void setText(const std::string& text);
    4848
    4949    /** @returns the String this Text displays */
    50     inline const char* getText() const { return (externText == NULL)?this->text:this->externText; };
     50    inline const std::string& getText() const { return this->text; };
    5151    /** @param blending the blending intensity to set (between 0.0 and 1.0) */
    5252    inline void setBlending(float blending) { this->blending = blending; };
    … …  
    6969    Font*             font;           //!< Font of this text
    7070
    71     char*             text;           //!< The text to display
    72     const char*       externText;     //!< the text to Display from an external Source.
     71    std::string       text;           //!< The text to display
    7372    Vector            color;          //!< The color of the font.
    7473    float             blending;       //!< The blending intensity.

  • branches/std/src/lib/lang/base_object.cc

    r7214 r7216  
    9595void BaseObject::setName (const std::string& objectName)
    9696{
    97   printf("TEST\n");
    9897  this->objectName = objectName;
    99   printf("TEST2\n");
    10098}
    10199

  • branches/std/src/lib/lang/class_list.cc

    r7199 r7216  
    3737 *  Creates a new ClassList
    3838*/
    39 ClassList::ClassList(ClassID classID, unsigned long classIDFull, const char* className)
    40 {
    41   this->className = className;
     39ClassList::ClassList(ClassID classID, unsigned long classIDFull, const std::string& className)
     40  : className(className)
     41{
    4242  this->classID = classID;
    4343  this->classIDFull = classIDFull;
    … …  
    5656
    5757//! a List of all strings of all classes, that have registered so far.
    58 std::list<const char*> ClassList::classNames;
     58std::list<std::string> ClassList::classNames;
    5959
    6060/**
    … …  
    6767 * !! Before unsing the ClassList, as it creates the ClassLits
    6868 */
    69 ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const char* className)
     69ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className)
    7070{
    7171  if (unlikely(classList == NULL))
    7272    ClassList::classList = new list<ClassList>();
    7373
    74   PRINTF(5)("subscribe a '%s'\n", className );
     74  PRINTF(5)("subscribe a '%s'\n", className.c_str() );
    7575
    7676  ClassList* regClass = ClassList::getClassList(classID);
    … …  
    113113 * befor it changes anything.
    114114 */
    115 const std::list<const char*>* ClassList::getClassNames()
     115const std::list<std::string>* ClassList::getClassNames()
    116116{
    117117  if (ClassList::classNames.size() != ClassList::classList->size())
    … …  
    155155 * @return the List accessed by classID, or NULL if not found
    156156 */
    157 const std::list<BaseObject*>* ClassList::getList(const char* className)
     157const std::list<BaseObject*>* ClassList::getList(const std::string& className)
    158158{
    159159  ClassList* fl;
    … …  
    191191 * @returns the ClassList with className as specifyer, or NULL if not
    192192 */
    193 ClassList* ClassList::getClassList(const char* className)
    194 {
    195   if (className == NULL)
     193ClassList* ClassList::getClassList(const std::string& className)
     194{
     195  if (className.empty())
    196196    return NULL;
    197197  std::list<ClassList>::iterator classIT = find (classList->begin(), classList->end(), className);
    … …  
    207207 * @todo: speed this up!!
    208208 */
    209 BaseObject* ClassList::getObject(const char* objectName, ClassID classID)
     209BaseObject* ClassList::getObject(const std::string& objectName, ClassID classID)
    210210{
    211211  if (classID != CL_NULL)
    … …  
    216216      std::list<BaseObject*>::iterator bo;
    217217      for (bo = cl->objectList.begin(); bo != cl->objectList.end(); bo++)
    218         if ((*bo)->getName() != NULL && !strcmp((*bo)->getName(), objectName))
     218        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
    219219          return (*bo);
    220220    }
    … …  
    227227      std::list<BaseObject*>::iterator bo;
    228228      for (bo = (*cl).objectList.begin(); bo != (*cl).objectList.end(); bo++)
    229         if ((*bo)->getName() != NULL && !strcmp((*bo)->getName(), objectName))
     229        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
    230230          return (*bo);
    231231    }
    … …  
    276276    if (object->isA((*cl).classID))
    277277  {
    278     PRINT(0)("=%s::0x%.8X=-", (*cl).className, (*cl).classID);
     278    PRINT(0)("=%s::0x%.8X=-", (*cl).className.c_str(), (*cl).classID);
    279279  }
    280280}
    … …  
    285285 * @return a String containing the name of the Class, NULL if the Class was not found
    286286 */
    287 const char* ClassList::IDToString(ClassID classID)
    288 {
     287const std::string& ClassList::IDToString(ClassID classID)
     288{
     289  static const std::string empty("");
     290
    289291  ClassList* cl = ClassList::getClassList(classID);
    290   return (cl != NULL) ? cl->className : NULL;
     292  return (cl != NULL) ? cl->className : empty;
    291293}
    292294
    … …  
    296298 * @return the ClassID. CL_NULL, if the class was not found.
    297299 */
    298 ClassID ClassList::StringToID(const char* className)
     300ClassID ClassList::StringToID(const std::string& className)
    299301{
    300302  ClassList* cl = ClassList::getClassList(className);
    … …  
    307309 * @returns true on match, false otherwise
    308310 */
    309 bool ClassList::operator==(const char* className)
    310 {
    311   if (likely( className != NULL && this->className != NULL))
    312     return (!strcmp(this->className, className));
    313   else
    314     return false;
     311bool ClassList::operator==(const std::string& className)
     312{
     313  return (this->className == className);
    315314}
    316315
    … …  
    342341      while (pow(10, lenCount) <= (*cl).objectList.size())
    343342        ++lenCount;
    344       for (int i=0; i < 30-strlen((*cl).className) - lenCount; i++)
     343      for (int i=0; i < 30-(*cl).className.size() - lenCount; i++)
    345344        (niceString[i]) = ' ';
    346       niceString[30-strlen((*cl).className) - lenCount] = '\0';
    347 
    348       PRINT(0)("| CLASS %s::%s %d\n", (*cl).className, niceString, (*cl).objectList.size());
     345      niceString[30-(*cl).className.size() - lenCount] = '\0';
     346
     347      PRINT(0)("| CLASS %s::%s %d\n", (*cl).className.c_str(), niceString, (*cl).objectList.size());
    349348
    350349      if (debugLevel >=2 && (*cl).objectList.size() > 0)
    … …  
    371370 * @see ClassList::debug
    372371 */
    373 void ClassList::debugS(const char* className, unsigned int debugLevel)
     372void ClassList::debugS(const std::string& className, unsigned int debugLevel)
    374373{
    375374  ClassList::debug(debugLevel, ClassList::StringToID(className));

  • branches/std/src/lib/lang/class_list.h

    r7165 r7216  
    1010#include "class_id.h"
    1111#include <list>
     12#include <string>
    1213#ifndef NULL
    1314#define NULL     0    //!< NULL
    … …  
    3233class ClassList {
    3334  public:
    34     ClassList(ClassID classID, unsigned long classIDFull, const char* className);
     35    ClassList(ClassID classID, unsigned long classIDFull, const std::string& className);
    3536    virtual ~ClassList();
    3637
    3738    /* MAINTENANCE FUNCTIONS THESE ARE !!ONLY FOR BASEOBJECT !! */
    38     static ClassList*                     addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const char* className);
     39    static ClassList*                     addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className);
    3940    static void                           removeFromClassList(BaseObject* objectPointer);
    4041
    … …  
    4243
    4344    static const std::list<BaseObject*>*  getList(ClassID classID = CL_NULL);// { return (ClassList* fl = ClassList::getClassList(classID) != NULL)? &(fl->objectList) : NULL; };
    44     static const std::list<BaseObject*>*  getList(const char* className); // { return (ClassList* fl = ClassList::getClassList(className) != NULL)? &(fl->objectList) : NULL;  };
    45     static const std::list<const char*>*  getClassNames();
    46     static BaseObject*                    getObject(const char* name, ClassID classID = CL_NULL);
     45    static const std::list<BaseObject*>*  getList(const std::string& className); // { return (ClassList* fl = ClassList::getClassList(className) != NULL)? &(fl->objectList) : NULL;  };
     46    static const std::list<std::string>*  getClassNames();
     47    static BaseObject*                    getObject(const std::string& name, ClassID classID = CL_NULL);
    4748    static bool                           exists(const BaseObject* object, ClassID classID = CL_NULL);
    4849
    … …  
    5152    static void                           whatIs(const BaseObject* object);
    5253
    53     static const char*                    IDToString(ClassID classID = CL_NULL);
    54     static ClassID                        StringToID(const char* className);
     54    static const std::string&             IDToString(ClassID classID = CL_NULL);
     55    static ClassID                        StringToID(const std::string& className);
    5556    static void                           debug(unsigned int debugLevel = 0, ClassID classID = CL_NULL);
    56     static void                           debugS(const char* className = NULL, unsigned int debugLevel = 0);
     57    static void                           debugS(const std::string& className = "", unsigned int debugLevel = 0);
    5758
    5859    inline bool                           operator==(ClassID classID) { return (this->classID == classID); };
    59     bool                                  operator==(const char* className);
     60    bool                                  operator==(const std::string& className);
    6061    inline ClassID                        getLeafClassID() const { return this->classID; };
    6162
    6263  private:
    6364    static ClassList*                     getClassList(ClassID classID);
    64     static ClassList*                     getClassList(const char* className);
     65    static ClassList*                     getClassList(const std::string& className);
    6566
    6667  private:
    67     ClassID                         classID;                //!< ClassID stored in this ClassList
    68     unsigned long                   classIDFull;            //!< The Full ClassID of this Class.
     68    ClassID                               classID;                //!< ClassID stored in this ClassList
     69    unsigned long                         classIDFull;            //!< The Full ClassID of this Class.
    6970
    70     const char*                     className;              //!< Name of the Class Stored here
     71    const std::string                     className;              //!< Name of the Class Stored here
    7172
    72     std::list<BaseObject*>          objectList;             //!< A list of Objects belonging to this Class
     73    std::list<BaseObject*>                objectList;             //!< A list of Objects belonging to this Class
    7374
    7475    // STATIC MEMBERS
    75     static std::list<ClassList>*    classList;              //!< The first Class in the List
    76     static std::list<const char*>   classNames;             //!< a List of all Names of all classes, that have registered so far.
     76    static std::list<ClassList>*          classList;              //!< The first Class in the List
     77    static std::list<std::string>         classNames;             //!< a List of all Names of all classes, that have registered so far.
    7778};
    7879

  • branches/std/src/lib/particles/dot_particles.h

    r6652 r7216  
    2121  virtual void loadParams(const TiXmlElement* root);
    2222
    23   void setMaterialTexture(const char* textureFile);
     23  void setMaterialTexture(const std::string& textureFile);
    2424
    2525  /** @returns the Material that lies on this particles */

  • branches/std/src/lib/particles/model_particles.cc

    r7198 r7216  
    8989 * @param textureFile the Texture to load onto these ModelParticles
    9090 */
    91 void ModelParticles::setMaterialTexture(const char* textureFile)
     91void ModelParticles::setMaterialTexture(const std::string& textureFile)
    9292{
    9393  this->material.setDiffuseMap(textureFile);

  • branches/std/src/lib/particles/model_particles.h

    r6629 r7216  
    2020  virtual void loadParams(const TiXmlElement* root);
    2121
    22   void setMaterialTexture(const char* textureFile);
     22  void setMaterialTexture(const std::string& textureFile);
    2323
    2424  /** @returns the Material that lies on this particles */

  • branches/std/src/lib/particles/sprite_particles.cc

    r7198 r7216  
    8989 * @param textureFile the Texture to load onto these SpriteParticles
    9090 */
    91 void SpriteParticles::setMaterialTexture(const char* textureFile)
     91void SpriteParticles::setMaterialTexture(const std::string& textureFile)
    9292{
    9393  this->material.setDiffuseMap(textureFile);

  • branches/std/src/lib/particles/sprite_particles.h

    r6626 r7216  
    2121  virtual void loadParams(const TiXmlElement* root);
    2222
    23   void setMaterialTexture(const char* textureFile);
     23  void setMaterialTexture(const std::string& textureFile);
    2424
    2525  /** @returns the Material that lies on this particles */

  • branches/std/src/lib/physics/physics_connection.cc

    r7193 r7216  
    7373 * @param subjectName the name of the Subject for this PhysicsConnection
    7474*/
    75 void PhysicsConnection::setSubject(const char* subjectName)
     75void PhysicsConnection::setSubject(const std::string& subjectName)
    7676{
    7777  this->subject = PhysicsEngine::getInstance()->getPhysicsInterfaceByName(subjectName);
    7878  if (this->subject == NULL)
    7979  {
    80     PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName);
     80    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName.c_str());
    8181  }
    8282  else
    … …  
    8787* @param fieldName the Name of the Field for this connection
    8888*/
    89 void PhysicsConnection::setField(const char* fieldName)
     89void PhysicsConnection::setField(const std::string& fieldName)
    9090{
    9191  this->field = PhysicsEngine::getInstance()->getFieldByName(fieldName);
    9292  if (this->field == NULL)
    9393  {
    94         PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName);
     94    PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName.c_str());
    9595  }
    9696  else

  • branches/std/src/lib/physics/physics_connection.h

    r5257 r7216  
    3535  virtual ~PhysicsConnection();
    3636
    37   void setSubject(const char* subjectName);
    38   void setField(const char* fieldName);
     37  void setSubject(const std::string& subjectName);
     38  void setField(const std::string& fieldName);
    3939
    4040  void apply() const;

  • branches/std/src/lib/physics/physics_engine.cc

    r7193 r7216  
    128128  @returns the PhysicsInterface if found, or NULL if not
    129129 */
    130 PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const char* physicsInterfaceName) const
     130PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const
    131131{
    132132  BaseObject* interface = ClassList::getObject(physicsInterfaceName, CL_PHYSICS_INTERFACE);
    … …  
    157157
    158158/**
    159 * @param FieldName the Name of the PhysicsInterface to search for
     159* @param fieldName the Name of the PhysicsInterface to search for
    160160  @returns the Field if found, or NULL if not
    161161 */
    162 Field* PhysicsEngine::getFieldByName(const char* FieldName) const
     162Field* PhysicsEngine::getFieldByName(const std::string& fieldName) const
    163163{
    164164  list<Field*>::const_iterator field;
    165165  for (field = this->fields.begin(); field != this->fields.end(); field++)
    166     if (!strcmp(FieldName, (*field)->getName()))
     166    if (fieldName == (*field)->getName())
    167167      return (*field);
    168168  return NULL;
    … …  
    197197  @returns the PhysicsConnection if found, or NULL if not
    198198 */
    199 PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const char* physicsConnectionName) const
     199PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const std::string& physicsConnectionName) const
    200200{
    201201  list<PhysicsConnection*>::const_iterator pc;
    202202  for (pc = this->connections.begin(); pc != this->connections.end(); pc++)
    203     if (!strcmp(physicsConnectionName, (*pc)->getName()))
     203    if (physicsConnectionName == (*pc)->getName())
    204204      delete (*pc);
    205205  return NULL;

  • branches/std/src/lib/physics/physics_engine.h

    r6512 r7216  
    3131  void loadConnections(const TiXmlElement* root);
    3232
    33   PhysicsInterface*      getPhysicsInterfaceByName(const char* physicsInterfaceName) const;
     33  PhysicsInterface*      getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const;
    3434
    3535  void                   addField(Field* field);
    3636  void                   removeField(Field* field);
    37   Field*                 getFieldByName(const char* FieldName) const;
     37  Field*                 getFieldByName(const std::string& fieldName) const;
    3838
    3939  void                   addConnection(PhysicsConnection* connection);
    4040  void                   removeConnection(PhysicsConnection* connection);
    41   PhysicsConnection*     getPhysicsConnectionByName(const char* physicsConnectionName) const;
     41  PhysicsConnection*     getPhysicsConnectionByName(const std::string& physicsConnectionName) const;
    4242
    4343

  • branches/std/src/lib/shell/shell.cc

    r7198 r7216  
    8585  this->lineSpacing = 0;
    8686  this->bActive = true;
    87   this->fontFile = new char[strlen(SHELL_DEFAULT_FONT)+1];
    88   strcpy(this->fontFile, SHELL_DEFAULT_FONT);
     87  this->fontFile = SHELL_DEFAULT_FONT;
    8988
    9089
    … …  
    110109    delete this->bufferText[i];
    111110  delete[] this->bufferText;
    112   delete[] this->fontFile;
    113111  // delete the inputLine
    114112  delete this->shellInput;
    … …  
    139137    if (!top)
    140138    {
    141       this->bufferText[i]->setText((*textLine), true);
     139      this->bufferText[i]->setText((*textLine));
    142140    if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
    143141      top = true;
    … …  
    167165    if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
    168166    {
    169       this->bufferText[i]->setText((*textLine), false);
     167      this->bufferText[i]->setText((*textLine));
    170168      textLine--;
    171169    }
    … …  
    181179 * (be aware that within orxonox fontFile is relative to the Data-Dir)
    182180 */
    183 void Shell::setFont(const char* fontFile)
     181void Shell::setFont(const std::string& fontFile)
    184182{
    185183//   if (!ResourceManager::isInDataDir(fontFile))
    186184//     return false;
    187185
    188   if (this->fontFile != NULL)
    189     delete[] this->fontFile;
    190 
    191   this->fontFile = new char[strlen(fontFile)+1];
    192   strcpy(this->fontFile, fontFile);
     186  this->fontFile = fontFile;
    193187
    194188  this->rebuildText();
    … …  
    245239 * @param fileName the filename of the Image to load
    246240 */
    247 void Shell::setBackgroundImage(const char* fileName)
     241void Shell::setBackgroundImage(const std::string& fileName)
    248242{
    249243  this->backgroundMaterial->setDiffuseMap(fileName);
    … …  
    340334    for (int i = 0; i < this->bufferDisplaySize; i++)
    341335    {
    342       this->bufferText[i]->setText(NULL, true);
     336      this->bufferText[i]->setText("");
    343337    }
    344338
    … …  
    351345 * @param text the text to output.
    352346 */
    353 void Shell::printToDisplayBuffer(const char* text)
     347void Shell::printToDisplayBuffer(const std::string& text)
    354348{
    355349  if(likely(bufferText != NULL))
    … …  
    382376    this->bufferText[0] = lastText;
    383377
    384     this->bufferText[0]->setText(text, true);
     378    this->bufferText[0]->setText(text);
    385379  }
    386380}
    … …  
    427421  for (unsigned int i = 0; i < this->bufferDisplaySize; i++)
    428422  {
    429     this->bufferText[i]->setText((*it), false);
     423    this->bufferText[i]->setText((*it));
    430424    it--;
    431425  }

  • branches/std/src/lib/shell/shell.h

    r5784 r7216  
    5353    inline bool isActive() const { return this->bActive; };
    5454
    55     void setFont(const char* fontFile);
     55    void setFont(const std::string& fontFile);
    5656    void setTextSize(unsigned int textSize, unsigned int lineSpacing = 1);
    5757    void setTextColor(float r, float g, float b, float a);
    5858    void setBackgroundColor(float r, float g, float b, float a);
    59     void setBackgroundImage(const char* fileName);
     59    void setBackgroundImage(const std::string& fileName);
    6060
    6161    void resetValues();
    … …  
    6464    // BUFFERS
    6565    void setBufferDisplaySize(unsigned int bufferDisplaySize);
    66     void printToDisplayBuffer(const char* text);
     66    void printToDisplayBuffer(const std::string& text);
    6767    void moveDisplayBuffer(int lineCount);
    6868
    … …  
    8383
    8484    //     void testI (int i);
    85     //     void testS (const char* s);
     85    //     void testS (const std::string& s);
    8686    //     void testB (bool b);
    8787    //     void testF (float f);
    88     //     void testSF (const char* s, float f);
     88    //     void testSF (const std::string& s, float f);
    8989
    9090  private:
    … …  
    9595    unsigned int                textSize;               //!< The size of the text.
    9696    float                       textColor[4];           //!< The text's color [r,g,b,a].
    97     char*                       fontFile;               //!< The file containing the font.
     97    std::string                 fontFile;               //!< The file containing the font.
    9898    Material*                   backgroundMaterial;     //!< A material for the background.
    9999

  • branches/std/src/lib/shell/shell_command.cc

    r7211 r7216  
    153153 * @return true on success, false otherwise.
    154154 */
    155 bool ShellCommand::execute(const char* executionString)
     155bool ShellCommand::execute(const std::string& executionString)
    156156{
    157157  if (ShellCommandClass::commandClassList == NULL)
    … …  
    184184          {
    185185            if (inputSplits.getCount() > 1)
    186               (*alias)->getCommand()->executor->execute(objectList->front(), executionString+inputSplits.getOffset(1));
     186            {
     187
     188              (*alias)->getCommand()->executor->execute(objectList->front(), executionString.substr(inputSplits.getOffset(1), executionString.size())); /// TODO CHECK IF OK
     189            }
    187190            else
    188191              (*alias)->getCommand()->executor->execute(objectList->front(), "");
    … …  
    240243              return false;
    241244            if (inputSplits.getCount() > fktPos+1)
    242               (*cmdIT)->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
     245              (*cmdIT)->executor->execute(objectPointer, executionString.substr(inputSplits.getOffset(fktPos +1), executionString.size())); /// TODO CHECK IF OK
    243246            else
    244247              (*cmdIT)->executor->execute(objectPointer, "");
    … …  
    326329  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
    327330  {
    328     PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
     331    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
    329332
    330333    list<ShellCommand*>::iterator cmdIT;

  • branches/std/src/lib/shell/shell_command.h

    r7201 r7216  
    6161  friend class ShellCommandClass;
    6262  public:
    63     static bool execute (const char* executionString);
     63    static bool execute (const std::string& executionString);
    6464
    6565    ShellCommand* describe(const char* description);

  • branches/std/src/lib/shell/shell_command_class.cc

    r5780 r7216  
    3636 * @param className the Name of the command-class to create
    3737 */
    38 ShellCommandClass::ShellCommandClass(const char* className)
     38ShellCommandClass::ShellCommandClass(const std::string& className)
     39  : className(className)
    3940{
    4041  this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
    4142  this->setName(className);
    4243
    43   this->className = className;
    4444  this->classID = CL_NULL;
    4545
    … …  
    6565 * @returns true on success, false otherwise
    6666 */
    67 bool ShellCommandClass::getCommandListOfClass(const char* className, std::list<const char*>* stringList)
    68 {
    69   if (stringList == NULL || className == NULL)
     67bool ShellCommandClass::getCommandListOfClass(const std::string& className, std::list<std::string>* stringList)
     68{
     69  if (stringList == NULL)
    7070    return false;
    7171
    … …  
    7373  for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
    7474  {
    75     if (!strcmp ((*elem)->getName(), className))
     75    if (className == (*elem)->getName())
    7676    {
    7777      list<ShellCommand*>::iterator command;
    … …  
    8888 * @returns true on success, false otherwise
    8989 */
    90 bool ShellCommandClass::getCommandListOfAlias(std::list<const char*>* stringList)
     90bool ShellCommandClass::getCommandListOfAlias(std::list<std::string>* stringList)
    9191{
    9292  if (stringList == NULL || ShellCommandClass::aliasList == NULL)
    … …  
    138138  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
    139139  {
    140     if (!strcmp(className, (*classIT)->className))
     140    if (className == (*classIT)->className)
    141141    {
    142142      if ((*classIT)->classID == CL_NULL)
    … …  
    154154 * @returns the CommandClass if found, or a new CommandClass if not
    155155 */
    156 ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
     156ShellCommandClass* ShellCommandClass::getCommandClass(const std::string& className)
    157157{
    158158  if (ShellCommandClass::commandClassList == NULL)
    … …  
    162162  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
    163163  {
    164     if (!strcmp(className, (*classIT)->className))
     164    if (className == (*classIT)->className)
    165165    {
    166166      return (*classIT);
    … …  
    186186 * @param className: the Class of Commands to show help about
    187187 */
    188 void ShellCommandClass::help(const char* className)
    189 {
    190   if (className == NULL)
    191     return;
     188void ShellCommandClass::help(const std::string& className)
     189{
    192190  if (likely(ShellCommandClass::commandClassList != NULL))
    193191  {
    … …  
    195193    for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
    196194    {
    197       if ((*classIT)->className && !strcasecmp(className, (*classIT)->className))
     195      if (className == (*classIT)->className)
    198196      {
    199         PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
     197        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
    200198        list<ShellCommand*>::const_iterator cmdIT;
    201199        for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
    … …  
    212210      }
    213211    }
    214     PRINTF(3)("Class %s not found in Command's classes\n", className);
     212    PRINTF(3)("Class %s not found in Command's classes\n", className.c_str());
    215213  }
    216214  else

  • branches/std/src/lib/shell/shell_command_class.h

    r6981 r7216  
    2727    /** @returns the CommandClassList */
    2828    static const std::list<ShellCommandClass*>* getCommandClassList() { return ShellCommandClass::commandClassList; };
    29     static bool getCommandListOfClass(const char* className, std::list<const char*>* stringList);
    30     static bool getCommandListOfAlias(std::list<const char*>* aliasList);
     29    static bool getCommandListOfClass(const std::string& className, std::list<std::string>* stringList);
     30    static bool getCommandListOfAlias(std::list<std::string>* aliasList);
    3131
    32     static ShellCommandClass* getCommandClass(const char* className);
     32    static ShellCommandClass* getCommandClass(const std::string& className);
    3333    static void unregisterAllCommands();
    3434
    35     static void help (const char* className);
     35    static void help (const std::string& className);
    3636
    3737  private:
    38     ShellCommandClass(const char* className);
     38    ShellCommandClass(const std::string& className);
    3939    virtual ~ShellCommandClass();
    4040
    … …  
    4343
    4444  private:
    45     const char*                            className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
     45    const std::string                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
    4646    long                                   classID;                   //!< The classID of this Class
    4747    std::list<ShellCommand*>               commandList;               //!< A list of Commands from this Class

  • branches/std/src/lib/shell/shell_completion.cc

    r7211 r7216  
    7676
    7777  // Check if we are in a input. eg. the supplied string "class " and now we complete either function or object
    78   if (this->input->getInput() != NULL &&
    79       strrchr(this->input->getInput(), ' ') >= this->input->getInput() + strlen(this->input->getInput())-1)
     78  if (this->input->getInput()[this->input->getInput().size()-1] == ' ')
    8079  {
    8180    emptyComplete = true;
    … …  
    8382
    8483  // CREATE INPUTS
    85   if (this->input->getInput() == NULL)
    86     completionLine = "";
    87   else
    88     completionLine = this->input->getInput() + strspn(this->input->getInput(), " \t\n");
    89   SubString inputSplits(completionLine, " \t\n,");
     84  SubString inputSplits(this->input->getInput(), " \t\n,");
    9085
    9186  // What String will be completed
    … …  
    151146  if (unlikely(classBegin == NULL))
    152147    return false;
    153   const std::list<const char*>* clList = ClassList::getClassNames();
     148  const std::list<std::string>* clList = ClassList::getClassNames();
    154149  if (clList != NULL)
    155150  {
    … …  
    195190  if (unlikely(functionBegin == NULL))
    196191    return false;
    197   std::list<const char*> fktList;
     192  std::list<std::string> fktList;
    198193  ShellCommandClass::getCommandListOfClass(className, &fktList);
    199194  //printf("%s\n", boList->firstElement()->getName());
    … …  
    212207  if (unlikely(aliasBegin == NULL))
    213208    return false;
    214   std::list<const char*> aliasList;
     209  std::list<std::string> aliasList;
    215210  ShellCommandClass::getCommandListOfAlias(&aliasList);
    216211  //printf("%s\n", boList->firstElement()->getName());
    … …  
    295290 * !! The strings MUST NOT be deleted !!
    296291 */
    297 bool ShellCompletion::addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type)
     292bool ShellCompletion::addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type)
    298293{
    299294  if (inputList == NULL || completionBegin == NULL)
    … …  
    301296  unsigned int searchLength = strlen(completionBegin);
    302297
    303   list<const char*>::const_iterator string;
     298  list<std::string>::const_iterator string;
    304299  for (string = inputList->begin(); string != inputList->end(); string++)
    305300  {
    306     if (strlen(*string) >= searchLength &&
    307         !strncasecmp(*string, completionBegin, searchLength))
     301    if ((*string).size() >= searchLength &&
     302          !strncasecmp((*string).c_str(), completionBegin, searchLength))
    308303    {
    309304      ShellC_Element newElem;
    310       newElem.name = *string;
     305      newElem.name = (*string).c_str();
    311306      newElem.type = type;
    312307      this->completionList.push_back(newElem);

  • branches/std/src/lib/shell/shell_completion.h

    r5784 r7216  
    5252  bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
    5353
    54   bool addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type);
     54  bool addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type);
    5555  bool addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type);
    5656  void emptyCompletionList();

  • branches/std/src/lib/shell/shell_input.cc

    r7207 r7216  
    4646  this->setClassID(CL_SHELL_INPUT, "ShellInput");
    4747
    48   this->inputLine = new char[1];
    49   this->inputLine[0] = '\0';
     48  this->inputLine = "";
    5049  this->historyIT = this->history.begin();
    5150  this->setHistoryLength(50);
    … …  
    7069{
    7170  // delete what has to be deleted here
    72   delete[] this->inputLine;
    7371  delete this->completion;
    7472
    7573  while (!this->history.empty())
    7674  {
    77     delete[] this->history.front();
    7875    this->history.pop_front();
    7976  }
    … …  
    9693void ShellInput::flush()
    9794{
    98   if (likely(this->inputLine != NULL))
    99   {
    100     delete[] this->inputLine;
    101   }
    102   this->inputLine = new char[1];
    103   *this->inputLine = '\0';
    104   this->setText(this->inputLine, true);
     95  this->inputLine.clear();
     96  this->setText(this->inputLine);
    10597}
    10698
    … …  
    109101 * @param text the new Text to set as InputLine
    110102 */
    111 void ShellInput::setInputText(const char* text)
    112 {
    113   delete[] this->inputLine;
    114   if (text == NULL)
    115   {
    116     this->inputLine = new char[1];
    117     this->inputLine[0] = '\0';
    118   }
    119   else
    120   {
    121     this->inputLine = new char[strlen(text)+1];
    122     strcpy(this->inputLine, text);
    123   }
    124   this->setText(this->inputLine, true);
     103void ShellInput::setInputText(const std::string& text)
     104{
     105  this->inputLine = text;
     106  this->setText(this->inputLine);
    125107}
    126108
    … …  
    134116  if (this->historyScrolling)
    135117  {
    136     delete[] this->history.back();
    137118    this->history.pop_back();
    138119    this->historyScrolling = false;
    139120  }
    140121
    141   char* addCharLine = new char[strlen(this->inputLine)+2];
    142 
    143   sprintf(addCharLine, "%s%c", this->inputLine, character);
    144   delete[] this->inputLine;
    145   this->inputLine = addCharLine;
    146   this->setText(this->inputLine, true);
     122  this->inputLine += character;
     123  this->setText(this->inputLine);
    147124}
    148125
    … …  
    151128 * @param characters a \\0 terminated char-array to add to the InputLine
    152129 */
    153 void ShellInput::addCharacters(const char* characters)
     130void ShellInput::addCharacters(const std::string& characters)
    154131{
    155132  if (this->historyScrolling)
    156133  {
    157     delete[] this->history.back();
    158134    this->history.pop_back();
    159135    this->historyScrolling = false;
    160136  }
    161137
    162   char* addCharLine = new char[strlen(this->inputLine)+strlen(characters)+1];
    163 
    164   sprintf(addCharLine, "%s%s", this->inputLine, characters);
    165   delete[] this->inputLine;
    166   this->inputLine = addCharLine;
    167   this->setText(this->inputLine, true);
     138  this->inputLine += characters;
     139  this->setText(this->inputLine);
    168140}
    169141
    … …  
    176148  if (this->historyScrolling)
    177149  {
    178     delete[] this->history.back();
    179150    this->history.pop_back();
    180151    this->historyScrolling = false;
    181152  }
    182 
    183   if (strlen(this->inputLine) == 0)
    184     return;
    185 
    186   if (characterCount > strlen(this->inputLine))
    187     characterCount = strlen(this->inputLine);
    188 
    189   char* removeCharLine = new char[strlen(this->inputLine)-characterCount+1];
    190 
    191   strncpy(removeCharLine, this->inputLine, strlen(this->inputLine)-characterCount);
    192   removeCharLine[strlen(this->inputLine)-characterCount] = '\0';
    193   delete[] this->inputLine;
    194   this->inputLine = removeCharLine;
    195   this->setText(this->inputLine, true);
     153  if (this->inputLine.size() < characterCount)
     154    characterCount = this->inputLine.size();
     155
     156  this->inputLine.erase(this->inputLine.size() - characterCount, this->inputLine.size());
     157  this->setText(this->inputLine);
    196158}
    197159
    … …  
    202164bool ShellInput::executeCommand()
    203165{
    204   ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine);
    205 
    206   if (strlen(this->inputLine) == 0)
     166  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine.c_str());
     167
     168  if (this->inputLine.empty())
    207169    return false;
    208170
    209   char* newCommand = new char[strlen(this->inputLine)+1];
    210   strcpy(newCommand, this->inputLine);
    211 
    212   ShellCommand::execute(newCommand);
     171  ShellCommand::execute(this->inputLine);
    213172
    214173  // removing the eventually added Entry (from scrolling) to the List
    215174  if (this->historyScrolling)
    216175  {
    217     delete[] this->history.back();
    218176    this->history.pop_back();
    219177    this->historyScrolling = false;
    … …  
    221179
    222180  // adding the new Command to the History
    223   this->history.push_back(newCommand);
     181  this->history.push_back(this->inputLine);
    224182  if (this->history.size() > this->historyLength)
    225183  {
    226     delete[] this->history.front();
    227184    this->history.pop_front();
    228185  }
    … …  
    241198  if (!this->historyScrolling)
    242199  {
    243     char* currentText = new char[strlen(this->inputLine)+1];
    244     strcpy(currentText, this->inputLine);
    245     this->history.push_back(currentText);
     200    this->history.push_back(this->inputLine);
    246201    this->historyScrolling = true;
    247202    this->historyIT = --this->history.end();
    … …  
    250205  if(this->historyIT != this->history.begin())
    251206  {
    252     char* prevElem = *(--this->historyIT);
    253     if (prevElem == NULL)
     207    std::string prevElem = *(--this->historyIT);
     208    /*if (prevElem == NULL) /// TODO STD
    254209      return;
    255     else
     210    else */
    256211    {
    257212      this->flush();
    … …  
    270225  if (this->historyIT != this->history.end())
    271226  {
    272     char* nextElem = *(++this->historyIT);
    273     if (nextElem == NULL)
     227    std::string nextElem = *(++this->historyIT);
     228    /*    if (nextElem == NULL) /// TODO FIX STD
    274229      return;
    275     else
     230    else */
    276231    {
    277232      this->flush();
    … …  
    285240 * prints out some nice help about the Shell
    286241 */
    287 void ShellInput::help(const char* className, const char* functionName)
    288 {
    289   printf("%s::%s\n", className, functionName);
    290 
    291   if (strlen(className) == 0)
     242void ShellInput::help(const std::string& className, const std::string& functionName)
     243{
     244  printf("%s::%s\n", className.c_str(), functionName.c_str());
     245
     246  if (className.empty())
    292247  {
    293248    PRINT(0)("Help for the most important Shell-commands\n");
    … …  
    298253    PRINT(0)("- Also try 'help className'");
    299254  }
    300   else if (strlen (className) > 0 && strlen (functionName) == 0)
     255  else if (!className.empty() && functionName.empty())
    301256  {
    302257    ShellCommandClass::help(className);

  • branches/std/src/lib/shell/shell_input.h

    r5786 r7216  
    3131
    3232  /** @returns the inputLine */
    33   const char* getInput() const { return this->inputLine; };
     33  const std::string& getInput() const { return this->inputLine; };
    3434
    3535  // InputLine
    3636  void flush();
    37   void setInputText(const char* text);
     37  void setInputText(const std::string& text);
    3838  void addCharacter(char character);
    39   void addCharacters(const char* characters);
     39  void addCharacters(const std::string& characters);
    4040  void removeCharacters(unsigned int characterCount = 1);
    4141  void setRepeatDelay(float repeatDelay, float repeatRate);
    … …  
    4747  void historyMoveDown();
    4848
    49   void help(const char* className = "", const char* function = "");
     49  void help(const std::string& className = "", const std::string& function = "");
    5050
    5151  virtual void tick(float dt);
    … …  
    5454 private:
    5555    // HANDLING TEXT INPUT
    56    ShellCompletion*            completion;             //!< The Completion Interface.
     56   ShellCompletion*                  completion;       //!< The Completion Interface.
    5757
    58    char*                       inputLine;              //!< the Char-Array of the Buffer
    59    float                       repeatRate;             //!< The Repeat-Delay.
    60    float                       repeatDelay;            //!< The delay of the first Character of a given Character.
    61    float                       delayed;                //!< how much of the delay is remaining.
    62    Uint16                      pressedKey;             //!< the pressed key that will be repeated.
     58   std::string                       inputLine;        //!< the Char-Array of the Buffer
     59   float                             repeatRate;       //!< The Repeat-Delay.
     60   float                             repeatDelay;      //!< The delay of the first Character of a given Character.
     61   float                             delayed;          //!< how much of the delay is remaining.
     62   Uint16                            pressedKey;       //!< the pressed key that will be repeated.
    6363
    64    std::list<char*>            history;                //!< The history of given commands.
    65    std::list<char*>::iterator  historyIT;
    66    unsigned int                historyLength;          //!< The maximum length of the InputHistory.
    67    bool                        historyScrolling;      //!< true if we are scrolling through the history.
     64   std::list<std::string>            history;          //!< The history of given commands.
     65   std::list<std::string>::iterator  historyIT;        //!< The locator that tells us, where we are in the history.
     66   unsigned int                      historyLength;    //!< The maximum length of the InputHistory.
     67   bool                              historyScrolling; //!< true if we are scrolling through the history.
    6868};
    6969

  • branches/std/src/lib/util/executor/executor.h

    r7214 r7216  
    271271    {
    272272      SubString sub;
    273       printf("===%s\n", parameters.c_str());
    274273      sub.split(parameters, " \n\t,", '\\');
    275       sub.debug();
    276274//! FUNCTOR_LIST is the List of Executive Functions
    277275#define FUNCTOR_LIST(x) ExecutorExecute ## x

  • branches/std/src/lib/util/executor/functor_list.h

    r7214 r7216  
    9898
    9999  FUNCTOR_LIST(0)();
    100   //! makes functions with one cstring
    101   FUNCTOR_LIST(1)(l_CSTRING);
    102   //! makes functions with two cstrings
    103   FUNCTOR_LIST(2)(l_CSTRING, l_CSTRING);
    104   //! makes functions with three cstrings
    105   FUNCTOR_LIST(3)(l_CSTRING, l_CSTRING, l_CSTRING);
    106   //! makes functions with four cstrings
    107   FUNCTOR_LIST(4)(l_CSTRING, l_CSTRING, l_CSTRING, l_CSTRING);
    108 
    109100  //! makes functions with one string
    110101  FUNCTOR_LIST(1)(l_STRING);
    … …  
    151142
    152143  //! mixed values:
    153   FUNCTOR_LIST(2)(l_CSTRING, l_FLOAT);
     144  FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
    154145  FUNCTOR_LIST(2)(l_UINT, l_LONG);
    155   FUNCTOR_LIST(2)(l_CSTRING, l_UINT);
     146  FUNCTOR_LIST(2)(l_STRING, l_UINT);
    156147
    157   FUNCTOR_LIST(3)(l_CSTRING, l_FLOAT, l_UINT);
     148  FUNCTOR_LIST(3)(l_STRING, l_FLOAT, l_UINT);
    158149
    159150

  • branches/std/src/lib/util/helper_functions.cc

    r7214 r7216  
    104104{
    105105  if (STRING.size() > 0)
    106   {
    107     printf("DECISION1: %s\n", STRING.c_str());
    108106    return STRING;
    109   }
    110107  else
    111   {
    112     printf("DECISION2: %s\n", defaultValue.c_str());
    113108    return defaultValue;
    114   }
    115109}
    116110

  • branches/std/src/lib/util/loading/load_param.cc

    r7214 r7216  
    6666          ((this->executor->getType() & Executor_NoLoadString) == Executor_NoLoadString)))
    6767    {
    68       PRINTF(0)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassName(), this->object->getName());
     68      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassName(), this->object->getName());
    6969      this->executor->execute(this->object, loadString);
    7070    }

  • branches/std/src/story_entities/game_world_data.cc

    r7203 r7216  
    343343
    344344  if (this->music != NULL)
    345     this->setSoundTrack(NULL);
     345    this->setSoundTrack("");
    346346  this->music = NULL;
    347347  /* stop the sound eninge */
    … …  
    354354
    355355
    356 void GameWorldData::setSoundTrack(const char* name)
     356void GameWorldData::setSoundTrack(const std::string& name)
    357357{
    358358  if (this->music != NULL)
    … …  
    360360  this->music = NULL;
    361361
    362   if (name != NULL)
    363   {
    364     PRINTF(3)("Setting Sound Track to %s\n", name);
     362  if (!name.empty())
     363  {
     364    PRINTF(3)("Setting Sound Track to %s\n", name.c_str());
    365365    std::string oggFile = ResourceManager::getFullName(name);
    366366    this->music = new OggPlayer(oggFile);

  • branches/std/src/story_entities/game_world_data.h

    r7020 r7216  
    4242
    4343    /* interface functions */
    44     void setSoundTrack(const char* name);
     44    void setSoundTrack(const std::string& name);
    4545    void loadGameRule(const TiXmlElement* root);
    4646

  • branches/std/src/util/Makefile.am

    r7193 r7216  
    1515                        animation/animation_player.cc \
    1616                        \
    17                         track/pilot_node.cc \
    18                         track/track_manager.cc \
     17                        track/pilot_node.cc
     18
     19#                       track/track_manager.cc \
    1920                        track/track_node.cc
    2021
    … …  
    3132                        animation/t_animation.h \
    3233                        \
    33                         track/pilot_node.h \
    34                         track/track_manager.h \
     34                        track/pilot_node.h
     35
     36#                       track/track_manager.h \
    3537                        track/track_node.h

  • branches/std/src/util/fast_factory.cc

    r5750 r7216  
    2929 * @return a new FastFactory
    3030 */
    31 FastFactory::FastFactory (ClassID classID, const char* fastFactoryName)
     31FastFactory::FastFactory (ClassID classID, const std::string& fastFactoryName)
    3232{
    3333  this->setClassID(CL_FAST_FACTORY, "FastFactory");
    … …  
    119119 * @returns true if found, false otherwise.
    120120 */
    121 FastFactory* FastFactory::searchFastFactory(const char* fastFactoryName)
     121FastFactory* FastFactory::searchFastFactory(const std::string& fastFactoryName)
    122122{
    123123  if (FastFactory::first == NULL)
    … …  
    128128    while (tmpFac != NULL)
    129129    {
    130       if (strcmp(tmpFac->getName(), fastFactoryName))
     130      if (fastFactoryName == tmpFac->getName())
    131131        return tmpFac;
    132132      tmpFac = tmpFac->next;

  • branches/std/src/util/fast_factory.h

    r5447 r7216  
    8080
    8181    static FastFactory* searchFastFactory(ClassID classID);
    82     static FastFactory* searchFastFactory(const char* fastFactoryName);
     82    static FastFactory* searchFastFactory(const std::string& fastFactoryName);
    8383
    8484    ClassID getStoredID() const { return this->storedClassID; };
    8585
    8686  protected:
    87     FastFactory (ClassID classID, const char* fastFactoryName = NULL);
     87    FastFactory (ClassID classID, const std::string& fastFactoryName = "");
    8888
    8989    /** sets the Next factory in the list @param nextFactory the next factory */

  • branches/std/src/util/multiplayer_team_deathmatch.cc

    r7193 r7216  
    9292
    9393
    94 void MultiplayerTeamDeathmatch::setDeathScreen(const char* imageName)
     94void MultiplayerTeamDeathmatch::setDeathScreen(const std::string& imageName)
    9595{
    9696  if( this->deathScreen)

  • branches/std/src/util/multiplayer_team_deathmatch.h

    r7044 r7216  
    3838    inline void setDeathPenaltyTimeout(float time) { this->deathTimeout = time; }
    3939    inline void setMaxKills(int kills) { this->maxKills = kills; }
    40     void setDeathScreen(const char* imageName);
     40    void setDeathScreen(const std::string& imageName);
    4141
    4242  protected:

  • branches/std/src/util/object_manager.cc

    r7198 r7216  
    9797 * this function also does a transformation from omList as char* to OM_LIST.
    9898 */
    99 void ObjectManager::toList (WorldEntity* entity, const char* omList)
     99void ObjectManager::toList (WorldEntity* entity, const std::string& omList)
    100100{
    101101  this->toList(entity, ObjectManager::StringToOMList(omList));
    … …  
    153153 * @param level: level 0: only show list info; level 1: also show entities and their names.
    154154 */
    155 void ObjectManager::debug(const char* listName, unsigned int level)
     155void ObjectManager::debug(const std::string& listName, unsigned int level)
    156156{
    157157  PRINT(0)("=================================\n");
    158158  PRINT(0)("=ObjectManager-DEBUG=============\n");
    159159  PRINT(0)("=================================\n");
    160   if (listName == NULL || listName[0] == '\0')
     160  if (listName.empty())
    161161    for (unsigned int i = 0; i < OM_SIZE; ++i)
    162162      debug((OM_LIST) i, level);
    … …  
    189189 * @returns the OM_LIST transformed from listName. or the default, if not found or NULL.
    190190 */
    191 OM_LIST ObjectManager::StringToOMList(const char* listName)
    192 {
    193   if (unlikely(listName == NULL)) return OM_DEFAULT_LIST;
     191OM_LIST ObjectManager::StringToOMList(const std::string& listName)
     192{
     193  if (unlikely(listName.empty())) return OM_DEFAULT_LIST;
    194194
    195195  for(unsigned int i = 0; i < OM_SIZE; ++i) {
    196     if(!strcmp(listName, ObjectManager::objectManagerListNames[i])) {
     196    if(listName == ObjectManager::objectManagerListNames[i]) {
    197197      return (OM_LIST)i;
    198198    }

  • branches/std/src/util/object_manager.h

    r6142 r7216  
    7676
    7777  void toList (WorldEntity* entity, OM_LIST omList = OM_DEFAULT_LIST);
    78   void toList (WorldEntity* entity, const char* omList);
     78  void toList (WorldEntity* entity, const std::string& omList);
    7979
    8080
    … …  
    8585
    8686  void debug(OM_LIST omList, unsigned int level = 0) const;
    87   void debug(const char* listName = NULL, unsigned int level = 0);
     87  void debug(const std::string& listName = "", unsigned int level = 0);
    8888
    89   static OM_LIST StringToOMList(const char* listName);
     89  static OM_LIST StringToOMList(const std::string& listName);
    9090  static const char* OMListToString(OM_LIST omList);
    9191

  • branches/std/src/util/track/track_manager.h

    r7130 r7216  
    142142  // Methods to change the Path (initialisation)
    143143  void workOn(unsigned int trackID);
    144   void workOnS(const char* trackName);
     144  void workOnS(const std::string& trackName);
    145145
    146146  /** \see setCurveType(CurveType curveType, TrackElement* trackElem); @param curveType the type of the Curve */
    … …  
    157157  void fork(unsigned int count, ...);
    158158  void forkS(unsigned int count, ...);
    159   void forkS(const char* forkString);
     159  void forkS(const std::string& forkString);
    160160  void forkV(unsigned int count, int* trackIDs, char** trackNames, TrackElement* trackElem = NULL);
    161161  void condition(unsigned int trackID, CONDITION cond, void* subject);

  • branches/std/src/world_entities/elements/text_element.cc

    r7193 r7216  
    7070}
    7171
    72 void TextElement::setText(const char* text)
     72void TextElement::setText(const std::string& text)
    7373{
    7474  Text::setText(text);
    7575}
    7676
    77 void TextElement::setFont(const char* font)
     77void TextElement::setFont(const std::string& font)
    7878{
    7979  Text::setFont(font, (unsigned int)this->getSizeY2D());

  • branches/std/src/world_entities/elements/text_element.h

    r7019 r7216  
    2929  virtual void loadParams(const TiXmlElement* root);
    3030
    31   void setText(const char* text);
    32   void setFont(const char* font);
     31  void setText(const std::string& text);
     32  void setFont(const std::string& font);
    3333
    3434 private:

  • branches/std/src/world_entities/planet.cc

    r7193 r7216  
    4545  this->toList(OM_GROUP_01);
    4646
    47   this->material = new Material();
    4847  //this->material->setIllum(20);
    4948  //this->material->setAmbient(0.1, 0.1, 0.1);
    … …  
    7170{
    7271  PRINTF(5)("Deleting Planet\n");
    73   if( this->material)
    74     delete this->material;
    7572}
    7673
    … …  
    9289 * @param textureName the top texture.
    9390*/
    94 void Planet::setTexture(const char* textureName)
     91void Planet::setTexture(const std::string& textureName)
    9592{
    96   this->material->setDiffuseMap(textureName);
     93  this->material.setDiffuseMap(textureName);
    9794}
    9895
    … …  
    124121  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
    125122
    126   this->material->select();
     123  this->material.select();
    127124
    128125//   /WorldEntity::draw();

  • branches/std/src/world_entities/planet.h

    r6959 r7216  
    99/* INCLUDES */
    1010#include "world_entity.h"
    11 
     11#include "material.h"
    1212/* FORWARD DECLARATION */
    13 class Material;
    1413class Texture;
    1514
    … …  
    2625  void setSize(float size);
    2726  /** assumes jpg as input-format */
    28   void setTexture(const char* textureName);
     27  void setTexture(const std::string& textureName);
    2928
    3029
    … …  
    3433
    3534 private:
    36   Material*       material;        //!< Materials for the Planet. sorted by number (0-5) top, bottom, left, right, front, back
     35  Material        material;        //!< Materials for the Planet. sorted by number (0-5) top, bottom, left, right, front, back
    3736  Texture*        texture;         //!< Textures for the CubeMap.
    3837

  • branches/std/src/world_entities/power_ups/param_power_up.cc

    r7193 r7216  
    8181}
    8282
    83 void ParamPowerUp::setType(const char* type)
     83void ParamPowerUp::setType(const std::string& type)
    8484{
    8585  for(int i = 0; i < POWERUP_PARAM_size; ++i) {
    86     if(strcmp(type, paramTypes[i]) == 0) {
     86    if(type == paramTypes[i]) {
    8787      this->type = (EnumParamPowerUpType)i;
    8888      break;

  • branches/std/src/world_entities/power_ups/param_power_up.h

    r7065 r7216  
    2828  void setMaxValue(float value);
    2929  void setMinValue(float value);
    30   void setType(const char* type);
     30  void setType(const std::string& type);
    3131  EnumParamPowerUpType getType();
    3232  float getValue();
    … …  
    4343
    4444private:
    45   static const char* paramTypes[];
    46   EnumParamPowerUpType type;
    47   float value;
    48   float max_value;
    49   float min_value;
     45  EnumParamPowerUpType    type;
     46  float                   value;
     47  float                   max_value;
     48  float                   min_value;
     49
     50  static const char*      paramTypes[];
     51
    5052};
    5153

  • branches/std/src/world_entities/power_ups/power_up.cc

    r7207 r7216  
    182182  };
    183183
    184 void PowerUp::setRespawnType(const char* type)
     184
     185void PowerUp::setRespawnType(const std::string& type)
    185186{
    186187  for(int i = 0; i < RESPAWN_size; ++i)
    187188  {
    188     if(!strcmp(type, respawnTypes[i]))
     189    if(type == respawnTypes[i])
    189190    {
    190191      this->respawnType = (PowerUpRespawn)i;

  • branches/std/src/world_entities/power_ups/power_up.h

    r7207 r7216  
    3131  virtual void draw () const;
    3232  virtual void tick(float dt);
    33   void setRespawnType(const char* type);
     33  void setRespawnType(const std::string& type);
    3434  void setRespawnTime(const float respawn);
    3535
    … …  
    4545
    4646private:
    47   SoundSource    soundSource;
    48   SoundBuffer*   pickupBuffer;
    49   SoundBuffer*   respawnBuffer;
    50   Material* sphereMaterial;
    51   PowerUpRespawn respawnType;
    52   float respawnTime;
    53   float respawnStart;
    54   static const char* respawnTypes[];
     47  SoundSource         soundSource;
     48  SoundBuffer*        pickupBuffer;
     49  SoundBuffer*        respawnBuffer;
     50  Material*           sphereMaterial;
     51  PowerUpRespawn      respawnType;
     52  float               respawnTime;
     53  float               respawnStart;
     54  static const char*  respawnTypes[];
    5555
    56   WorldEntity* collider;
     56  WorldEntity*        collider;
    5757};
    5858

  • branches/std/src/world_entities/recorder.cc

    r7193 r7216  
    5454
    5555  LoadParam(root, "duration", this, Recorder, setStreamDuration);
     56
    5657  LoadParam(root, "fps", this, Recorder, setFPS);
     58
    5759  LoadParam(root, "name", this, Recorder, initVideo);
    5860}
    … …  
    7173
    7274
    73 void Recorder::initVideo(const char* filename)
     75void Recorder::initVideo(const std::string& filename)
    7476{
    7577  frame_count = 0;
    … …  
    7880
    7981  // auto detect the output format from the name, default is mpeg
    80   output_format = guess_format(NULL, filename, NULL);
     82  output_format = guess_format(NULL, filename.c_str(), NULL);
    8183  if (!output_format)
    8284  {
    … …  
    9395
    9496  format_context->oformat = output_format;
    95   snprintf(format_context->filename, sizeof(format_context->filename), "%s", filename);
     97  snprintf(format_context->filename, sizeof(format_context->filename), "%s", filename.c_str());
    9698
    9799  // add video stream using the default format codec and initialize the codec
    … …  
    104106
    105107  // print some information
    106   dump_format(format_context, 0, filename, 1);
     108  dump_format(format_context, 0, filename.c_str(), 1);
    107109
    108110  // now that all the parameters are set, we can open the
    … …  
    110112  if(video_stream)
    111113    this->openVideo();
    112  
     114
    113115  // open the output file, if needed
    114116  if(!(output_format->flags & AVFMT_NOFILE))
    115117  {
    116     if(url_fopen(&format_context->pb, filename, URL_WRONLY) < 0)
    117       PRINTF(1)("Could not open %s\n", filename);
     118    if(url_fopen(&format_context->pb, filename.c_str(), URL_WRONLY) < 0)
     119      PRINTF(1)("Could not open %s\n", filename.c_str());
    118120  }
    119121
    120122  // write the stream header, if any
    121   av_write_header(format_context); 
     123  av_write_header(format_context);
    122124}
    123125
    … …  
    129131  av_free(buffer);
    130132
    131   // write the trailer, if any 
     133  // write the trailer, if any
    132134  av_write_trailer(format_context);
    133  
     135
    134136  // free the streams
    135137  for(int i = 0; i < format_context->nb_streams; i++)
    … …  
    175177
    176178void Recorder::allocPicture()
    177 { 
     179{
    178180  picture = avcodec_alloc_frame();
    179181  if(!picture)
    … …  
    189191      return;
    190192  }
    191   avpicture_fill((AVPicture *)picture, picture_buf, 
     193  avpicture_fill((AVPicture *)picture, picture_buf,
    192194                  codec_context->pix_fmt, width, height);
    193195
    … …  
    211213  if (!video_stream)
    212214    PRINTF(1)("Could not alloc stream\n");
    213  
     215
    214216  codec_context = video_stream->codec;
    215217  codec_context->codec_id = output_format->video_codec;
    … …  
    219221  codec_context->bit_rate = 400000;
    220222  // resolution must be a multiple of two
    221   codec_context->width = State::getResX(); 
     223  codec_context->width = State::getResX();
    222224  codec_context->height = State::getResY();
    223225
    … …  
    229231  // timebase should be 1/framerate and timestamp increments should be
    230232  // identically 1
    231   codec_context->time_base.den = (int)stream_frame_rate; 
     233  codec_context->time_base.den = (int)stream_frame_rate;
    232234  codec_context->time_base.num = 1;
    233235  codec_context->gop_size = 12;  // emit one intra frame every twelve frames at most
    … …  
    235237
    236238  if (codec_context->codec_id == CODEC_ID_MPEG1VIDEO)
    237       // needed to avoid using macroblocks in which some coeffs overflow 
    238       // this doesnt happen with normal video, it just happens here as the 
     239      // needed to avoid using macroblocks in which some coeffs overflow
     240      // this doesnt happen with normal video, it just happens here as the
    239241      // motion of the chroma plane doesnt match the luma plane
    240242      codec_context->mb_decision=2;
    … …  
    275277{
    276278  int out_size, err;
    277  
     279
    278280  codec_context = video_stream->codec;
    279  
     281
    280282  if(frame_count >= stream_nb_frames)
    281283  {
    … …  
    287289    this->fillYuvImage();
    288290
    289  
     291
    290292  if(format_context->oformat->flags & AVFMT_RAWPICTURE)
    291293  {
    … …  
    293295    // futur for that
    294296    av_init_packet(&packet);
    295    
     297
    296298    packet.flags |= PKT_FLAG_KEY;
    297299    packet.stream_index= video_stream->index;
    298300    packet.data= (uint8_t *)picture;
    299301    packet.size= sizeof(AVPicture);
    300    
     302
    301303    err = av_write_frame(format_context, &packet);
    302304  }
    … …  
    309311    {
    310312      av_init_packet(&packet);
    311      
     313
    312314      packet.pts= av_rescale_q(codec_context->coded_frame->pts, codec_context->time_base, video_stream->time_base);
    313315      if(codec_context->coded_frame->key_frame)
    … …  
    316318      packet.data= buffer;
    317319      packet.size= out_size;
    318      
     320
    319321      // write the compressed frame in the media file
    320322      err = av_write_frame(format_context, &packet);

  • branches/std/src/world_entities/recorder.h

    r6981 r7216  
    2020class Recorder : public WorldEntity
    2121{
    22   private:
    23     AVFrame* picture;
    24     uint8_t* buffer;
    25     int frame_count;
    26     int buffer_size;
    27 
    28     AVOutputFormat* output_format;
    29     AVFormatContext* format_context;
    30     AVCodecContext* codec_context;
    31     AVCodec *codec;
    32     AVStream* video_stream;
    33     AVPacket packet;
    34     double video_pts;
    35 
    36     uint8_t *picture_buf;
    37     int size;
    38 
    39     int height;
    40     int width;
    41     float time;
    42 
    43     float stream_duration;
    44     float stream_frame_rate;
    45     int stream_nb_frames;
    46 
    47 AVFrame* RGB_frame;
    4822  public:
    4923    Recorder (const TiXmlElement* root = NULL);
    … …  
    5630
    5731  private:
    58     void initVideo(const char* filename);
     32    void initVideo(const std::string& filename);
    5933    void addVideoStream();
    6034    void openVideo();
    … …  
    6640    void setStreamDuration(float duration);
    6741    void setFPS(float fps);
     42
     43
     44  private:
     45    AVFrame*            picture;
     46    uint8_t*            buffer;
     47    int                 frame_count;
     48    int                 buffer_size;
     49
     50    AVOutputFormat*     output_format;
     51    AVFormatContext*    format_context;
     52    AVCodecContext*     codec_context;
     53    AVCodec*            codec;
     54    AVStream*           video_stream;
     55    AVPacket            packet;
     56    double              video_pts;
     57
     58    uint8_t*            picture_buf;
     59    int                 size;
     60
     61    int                 height;
     62    int                 width;
     63    float               time;
     64
     65    float               stream_duration;
     66    float               stream_frame_rate;
     67    int                 stream_nb_frames;
     68
     69    AVFrame*            RGB_frame;
    6870};
    6971

  • branches/std/src/world_entities/terrain.cc

    r7207 r7216  
    4848    this->loadParams(root);
    4949
    50 //  if (this->model != NULL)
    51     //this->ssp = new SpatialSeparation((Model*)this->model, 10.0f);
     50  //  if (this->model != NULL)
     51  //this->ssp = new SpatialSeparation((Model*)this->model, 10.0f);
    5252}
    5353
    … …  
    6464
    6565  if (!strstr(fileName, ".obj") || !strstr(fileName, ".OBJ") )
    66     {
    67       this->loadModel(fileName);
    68     }
     66  {
     67    this->loadModel(fileName);
     68  }
    6969  else
    70     {
    71       // load the hightMap here.
    72     }
     70  {
     71    // load the hightMap here.
     72  }
    7373}
    7474
    … …  
    9898
    9999  if(this->heightMap)
    100         delete heightMap;
     100    delete heightMap;
    101101}
    102102
    … …  
    122122
    123123  LoadParam(root, "scale", this, Terrain, setScale)
    124       .describe("The scale in x,y,z direction");
     124  .describe("The scale in x,y,z direction");
    125125
    126126  LoadParam(root, "texture", this, Terrain, loadTexture)
    127       .describe("The name of the Texture for this heightMap");
     127  .describe("The name of the Texture for this heightMap");
    128128
    129129  LoadParam(root, "vegetation", this, Terrain, loadVegetation)
    130       .describe("the fileName of the vegetation, that should be loaded onto this terrain. (must be relative to the data-dir)") ;
     130  .describe("the fileName of the vegetation, that should be loaded onto this terrain. (must be relative to the data-dir)") ;
    131131
    132132  LoadParam(root, "height-map", this, Terrain, loadHeightMap)
    133       .describe("The HeightMap, splitted into two strings seperated by ','. 1: HeighMap, 2: ColorMap");
     133  .describe("The HeightMap, splitted into two strings seperated by ','. 1: HeighMap, 2: ColorMap");
    134134
    135135}
    … …  
    140140}
    141141
    142 void Terrain::loadHeightMap(const char* heightMapFile, const char* colorMap)
     142void Terrain::loadHeightMap(const std::string& heightMapFile, const std::string& colorMap)
    143143{
    144144  if (this->heightMap != NULL)
    … …  
    151151
    152152  this->heightMap = new HeightMap(hmName, hmColorName);
    153 //   heightMap->scale(Vector(43.0f,4.7f,43.0f));
     153  //   heightMap->scale(Vector(43.0f,4.7f,43.0f));
    154154  heightMap->scale(this->terrainScale);
    155155  heightMap->setAbsCoor(this->getAbsCoor());
    … …  
    158158
    159159
    160 void Terrain::loadTexture(const char* textureName)
    161 {
    162    PRINTF(0)("Load texture: %s\n", textureName);
    163 
    164    heightMapMaterial->setDiffuse(1.0,1.0,1.0);
    165    heightMapMaterial->setAmbient(1.0,1.0,1.0 );
    166    heightMapMaterial->setSpecular(1.0,1.0,1.0);
    167    heightMapMaterial->setShininess(.5);
    168    heightMapMaterial->setTransparency(1.0);
    169 
    170    heightMapMaterial->setDiffuseMap(textureName);
    171   heightMapMaterial->setAmbientMap(textureName);
    172   heightMapMaterial->setSpecularMap(textureName);
     160void Terrain::loadTexture(const std::string& textureName)
     161{
     162  PRINTF(4)("Load texture: %s\n", textureName.c_str());
     163
     164  heightMapMaterial->setDiffuse(1.0,1.0,1.0);
     165  heightMapMaterial->setAmbient(1.0,1.0,1.0 );
     166  heightMapMaterial->setSpecular(1.0,1.0,1.0);
     167  heightMapMaterial->setShininess(.5);
     168  heightMapMaterial->setTransparency(1.0);
     169
     170  heightMapMaterial->setDiffuseMap(textureName);
     171  //  heightMapMaterial->setAmbientMap(textureName);
     172  //  heightMapMaterial->setSpecularMap(textureName);
    173173}
    174174
    … …  
    202202                this->getAbsCoor ().z);
    203203  /* rotate */
    204  // Vector tmpRot = this->getAbsDir().getSpacialAxis();
     204  // Vector tmpRot = this->getAbsDir().getSpacialAxis();
    205205  //glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
    206206
    … …  
    224224
    225225
    226 /*
    227   glMatrixMode(GL_MODELVIEW);
    228   glPushMatrix();
    229   glLoadIdentity();
    230   Vector camera =   State::getCameraNode()->getAbsCoor(); // Go on here ..........!!!
    231 
    232   float height =    heightMap->getHeight(camera.x, camera.z);
    233 
    234   glEnable (GL_COLOR_MATERIAL) ;
    235   glBegin(GL_QUADS);            // Draw The Cube Using quads
    236   glColor3f(0.0f,1.0f,0.0f);  // Color Blue
    237   glVertex3f(camera.x + 63.0f,Terrain->getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Right Of The Quad (Top)
    238   glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Left Of The Quad (Top)
    239   glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Left Of The Quad (Top)
    240   glVertex3f(camera.x+ 63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Right Of The Quad (Top)
    241   glEnd();                      // End Drawing The Plan
    242 
    243   glPopMatrix();*/
    244 
    245 
    246 /* THIS IS ONLY FOR DEBUGGING INFORMATION */
     226  /*
     227    glMatrixMode(GL_MODELVIEW);
     228    glPushMatrix();
     229    glLoadIdentity();
     230    Vector camera =   State::getCameraNode()->getAbsCoor(); // Go on here ..........!!!
     231
     232    float height =    heightMap->getHeight(camera.x, camera.z);
     233
     234    glEnable (GL_COLOR_MATERIAL) ;
     235    glBegin(GL_QUADS);            // Draw The Cube Using quads
     236    glColor3f(0.0f,1.0f,0.0f);  // Color Blue
     237    glVertex3f(camera.x + 63.0f,Terrain->getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Right Of The Quad (Top)
     238    glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Left Of The Quad (Top)
     239    glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Left Of The Quad (Top)
     240    glVertex3f(camera.x+ 63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Right Of The Quad (Top)
     241    glEnd();                      // End Drawing The Plan
     242
     243    glPopMatrix();*/
     244
     245
     246  /* THIS IS ONLY FOR DEBUGGING INFORMATION */
    247247  if (this->ssp != NULL)
    248248    this->ssp->drawQuadtree();
    … …  
    254254  // if the terrain is the Terrain of Dave
    255255  if (debugTerrain == TERRAIN_DAVE)
    256     {
    257       objectList = glGenLists(1);
    258       glNewList (objectList, GL_COMPILE);
    259 
    260       glColor3f(1.0,0,0);
    261 
    262       int sizeX = 100;
    263       int sizeZ = 80;
    264       float length = 1000;
    265       float width = 200;
    266       float widthX = float (length /sizeX);
    267       float widthZ = float (width /sizeZ);
    268 
    269       float height [sizeX][sizeZ];
    270       Vector normal_vectors[sizeX][sizeZ];
    271 
    272 
    273       for ( int i = 0; i<sizeX-1; i+=1)
    274         for (int j = 0; j<sizeZ-1;j+=1)
    275           //height[i][j] = rand()/20046 + (j-25)*(j-25)/30;
     256  {
     257    objectList = glGenLists(1);
     258    glNewList (objectList, GL_COMPILE);
     259
     260    glColor3f(1.0,0,0);
     261
     262    int sizeX = 100;
     263    int sizeZ = 80;
     264    float length = 1000;
     265    float width = 200;
     266    float widthX = float (length /sizeX);
     267    float widthZ = float (width /sizeZ);
     268
     269    float height [sizeX][sizeZ];
     270    Vector normal_vectors[sizeX][sizeZ];
     271
     272
     273    for ( int i = 0; i<sizeX-1; i+=1)
     274      for (int j = 0; j<sizeZ-1;j+=1)
     275        //height[i][j] = rand()/20046 + (j-25)*(j-25)/30;
    276276#ifdef __WIN32__
    277           height[i][j]=(sin((float)j/3)*rand()*i/182400)*.5;
     277        height[i][j]=(sin((float)j/3)*rand()*i/182400)*.5;
    278278#else
    279       height[i][j]=(sin((float)j/3)*rand()*(long)i/6282450500.0)*.5;
     279        height[i][j]=(sin((float)j/3)*rand()*(long)i/6282450500.0)*.5;
    280280#endif
    281281
    282       //Die Huegel ein wenig glaetten
    283       for (int h=1; h<2;h++)
    284         for (int i=1;i<sizeX-2 ;i+=1 )
    285           for(int j=1;j<sizeZ-2;j+=1)
    286             height[i][j]=(height[i+1][j]+height[i][j+1]+height[i-1][j]+height[i][j-1])/4;
    287 
    288       //Berechnung von normalen Vektoren
    289       for(int i=1;i<sizeX-2;i+=1)
    290         for(int j=1;j<sizeZ-2 ;j+=1)
    291           {
    292             Vector v1 = Vector (widthX*(1),      height[i][j],      widthZ*(j) );
    293             Vector v2 = Vector (widthX*(i-1),    height[i-1][j],    widthZ*(j));
    294             Vector v3 = Vector (widthX*(i),      height[i][j+1],    widthZ*(j+1));
    295             Vector v4 = Vector (widthX*(i+1),    height[i+1][j],    widthZ*(j));
    296             Vector v5 = Vector (widthX*(i),      height[i][j-1],    widthZ*(j-1));
    297 
    298             Vector c1 = v2 - v1;
    299             Vector c2 = v3 - v1;
    300             Vector c3=  v4 - v1;
    301             Vector c4 = v5 - v1;
    302             Vector zero = Vector (0,0,0);
    303             normal_vectors[i][j]=c1.cross(v3-v5)+c2.cross(v4-v2)+c3.cross(v5-v3)+c4.cross(v2-v4);
    304             normal_vectors[i][j].normalize();
    305           }
    306 
    307       glBegin(GL_QUADS);
    308       int snowheight=3;
    309       for ( int i = 0; i<sizeX; i+=1)
    310         for (int j = 0; j<sizeZ;j+=1)
    311           {
    312             Vector v1 = Vector (widthX*(i),      height[i][j]-20,       widthZ*(j)  -width/2);
    313             Vector v2 = Vector (widthX*(i+1),    height[i+1][j]-20,     widthZ*(j)  -width/2);
    314             Vector v3 = Vector (widthX*(i+1),    height[i+1][j+1]-20,   widthZ*(j+1)-width/2);
    315             Vector v4 = Vector (widthX*(i),      height[i][j+1]-20,     widthZ*(j+1)-width/2);
    316             float a[3];
    317             if(height[i][j]<snowheight){
    318               a[0]=0;
    319               a[1]=1.0-height[i][j]/10-.3;
    320               a[2]=0;
    321               glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
    322             }
    323             else{
    324               a[0]=1.0;
    325               a[1]=1.0;
    326               a[2]=1.0;
    327               glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
    328 
    329             }
    330             glNormal3f(normal_vectors[i][j].x, normal_vectors[i][j].y, normal_vectors[i][j].z);
    331             glVertex3f(v1.x, v1.y, v1.z);
    332             if(height[i+1][j]<snowheight){
    333               a[0]=0;
    334               a[1] =1.0-height[i+1][j]/10-.3;
    335               a[2]=0;
    336               glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
    337             }
    338             else{
    339               a[0]=1.0;
    340               a[1]=1.0;
    341               a[2]=1.0;
    342               glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
    343 
    344             }
    345             glNormal3f(normal_vectors[i+1][j].x, normal_vectors[i+1][j].y, normal_vectors[i+1][j].z);
    346             glVertex3f(v2.x, v2.y, v2.z);
    347             if(height[i+1][j+1]<snowheight){
    348               a[0]=0;
    349               a[1] =1.0-height[i+1][j+1]/10-.3;
    350               a[2]=0;
    351               glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
    352             }
    353             else{
    354               a[0]=1.0;
    355               a[1]=1.0;
    356               a[2]=1.0;
    357               glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
    358 
    359 
    360             }
    361             glNormal3f(normal_vectors[i+1][j+1].x, normal_vectors[i+1][j+1].y, normal_vectors[i+1][j+1].z);
    362             glVertex3f(v3.x, v3.y, v3.z);
    363             if(height[i][j+1]<snowheight){
    364               a[0]=0;
    365               a[1] =1.0-height[i+1][j+1]/10-.3;
    366               a[2]=0;
    367               glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
    368             }
    369             else{
    370               a[0]=1.0;
    371               a[1]=1.0;
    372               a[2]=1.0;
    373               glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
    374             }
    375             glNormal3f(normal_vectors[i][j+1].x, normal_vectors[i][j+1].y, normal_vectors[i][j+1].z);
    376             glVertex3f(v4.x, v4.y, v4.z);
    377 
    378           }
    379       glEnd();
    380       glEndList();
    381     }
     282    //Die Huegel ein wenig glaetten
     283    for (int h=1; h<2;h++)
     284      for (int i=1;i<sizeX-2 ;i+=1 )
     285        for(int j=1;j<sizeZ-2;j+=1)
     286          height[i][j]=(height[i+1][j]+height[i][j+1]+height[i-1][j]+height[i][j-1])/4;
     287
     288    //Berechnung von normalen Vektoren
     289    for(int i=1;i<sizeX-2;i+=1)
     290      for(int j=1;j<sizeZ-2 ;j+=1)
     291      {
     292        Vector v1 = Vector (widthX*(1),      height[i][j],      widthZ*(j) );
     293        Vector v2 = Vector (widthX*(i-1),    height[i-1][j],    widthZ*(j));
     294        Vector v3 = Vector (widthX*(i),      height[i][j+1],    widthZ*(j+1));
     295        Vector v4 = Vector (widthX*(i+1),    height[i+1][j],    widthZ*(j));
     296        Vector v5 = Vector (widthX*(i),      height[i][j-1],    widthZ*(j-1));
     297
     298        Vector c1 = v2 - v1;
     299        Vector c2 = v3 - v1;
     300        Vector c3=  v4 - v1;
     301        Vector c4 = v5 - v1;
     302        Vector zero = Vector (0,0,0);
     303        normal_vectors[i][j]=c1.cross(v3-v5)+c2.cross(v4-v2)+c3.cross(v5-v3)+c4.cross(v2-v4);
     304        normal_vectors[i][j].normalize();
     305      }
     306
     307    glBegin(GL_QUADS);
     308    int snowheight=3;
     309    for ( int i = 0; i<sizeX; i+=1)
     310      for (int j = 0; j<sizeZ;j+=1)
     311      {
     312        Vector v1 = Vector (widthX*(i),      height[i][j]-20,       widthZ*(j)  -width/2);
     313        Vector v2 = Vector (widthX*(i+1),    height[i+1][j]-20,     widthZ*(j)  -width/2);
     314        Vector v3 = Vector (widthX*(i+1),    height[i+1][j+1]-20,   widthZ*(j+1)-width/2);
     315        Vector v4 = Vector (widthX*(i),      height[i][j+1]-20,     widthZ*(j+1)-width/2);
     316        float a[3];
     317        if(height[i][j]<snowheight)
     318        {
     319          a[0]=0;
     320          a[1]=1.0-height[i][j]/10-.3;
     321          a[2]=0;
     322          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
     323        }
     324        else
     325        {
     326          a[0]=1.0;
     327          a[1]=1.0;
     328          a[2]=1.0;
     329          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
     330
     331        }
     332        glNormal3f(normal_vectors[i][j].x, normal_vectors[i][j].y, normal_vectors[i][j].z);
     333        glVertex3f(v1.x, v1.y, v1.z);
     334        if(height[i+1][j]<snowheight)
     335        {
     336          a[0]=0;
     337          a[1] =1.0-height[i+1][j]/10-.3;
     338          a[2]=0;
     339          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
     340        }
     341        else
     342        {
     343          a[0]=1.0;
     344          a[1]=1.0;
     345          a[2]=1.0;
     346          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
     347
     348        }
     349        glNormal3f(normal_vectors[i+1][j].x, normal_vectors[i+1][j].y, normal_vectors[i+1][j].z);
     350        glVertex3f(v2.x, v2.y, v2.z);
     351        if(height[i+1][j+1]<snowheight)
     352        {
     353          a[0]=0;
     354          a[1] =1.0-height[i+1][j+1]/10-.3;
     355          a[2]=0;
     356          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
     357        }
     358        else
     359        {
     360          a[0]=1.0;
     361          a[1]=1.0;
     362          a[2]=1.0;
     363          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
     364
     365
     366        }
     367        glNormal3f(normal_vectors[i+1][j+1].x, normal_vectors[i+1][j+1].y, normal_vectors[i+1][j+1].z);
     368        glVertex3f(v3.x, v3.y, v3.z);
     369        if(height[i][j+1]<snowheight)
     370        {
     371          a[0]=0;
     372          a[1] =1.0-height[i+1][j+1]/10-.3;
     373          a[2]=0;
     374          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
     375        }
     376        else
     377        {
     378          a[0]=1.0;
     379          a[1]=1.0;
     380          a[2]=1.0;
     381          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
     382        }
     383        glNormal3f(normal_vectors[i][j+1].x, normal_vectors[i][j+1].y, normal_vectors[i][j+1].z);
     384        glVertex3f(v4.x, v4.y, v4.z);
     385
     386      }
     387    glEnd();
     388    glEndList();
     389  }
    382390
    383391  if (debugTerrain == TERRAIN_BENSCH)
    384     {
    385       /*
    386         this->model = (OBJModel*) new Model();
    387       this->model->setName("CUBE");
    388       this->model->addVertex (-0.5, -0.5, 0.5);
    389       this->model->addVertex (0.5, -0.5, 0.5);
    390       this->model->addVertex (-0.5, 0.5, 0.5);
    391       this->model->addVertex (0.5, 0.5, 0.5);
    392       this->model->addVertex (-0.5, 0.5, -0.5);
    393       this->model->addVertex (0.5, 0.5, -0.5);
    394       this->model->addVertex (-0.5, -0.5, -0.5);
    395       this->model->addVertex (0.5, -0.5, -0.5);
    396 
    397       this->model->addVertexTexture (0.0, 0.0);
    398       this->model->addVertexTexture (1.0, 0.0);
    399       this->model->addVertexTexture (0.0, 1.0);
    400       this->model->addVertexTexture (1.0, 1.0);
    401       this->model->addVertexTexture (0.0, 2.0);
    402       this->model->addVertexTexture (1.0, 2.0);
    403       this->model->addVertexTexture (0.0, 3.0);
    404       this->model->addVertexTexture (1.0, 3.0);
    405       this->model->addVertexTexture (0.0, 4.0);
    406       this->model->addVertexTexture (1.0, 4.0);
    407       this->model->addVertexTexture (2.0, 0.0);
    408       this->model->addVertexTexture (2.0, 1.0);
    409       this->model->addVertexTexture (-1.0, 0.0);
    410       this->model->addVertexTexture (-1.0, 1.0);
    411 
    412       this->model->finalize();
    413       */
    414     }
     392  {
     393    /*
     394      this->model = (OBJModel*) new Model();
     395    this->model->setName("CUBE");
     396    this->model->addVertex (-0.5, -0.5, 0.5);
     397    this->model->addVertex (0.5, -0.5, 0.5);
     398    this->model->addVertex (-0.5, 0.5, 0.5);
     399    this->model->addVertex (0.5, 0.5, 0.5);
     400    this->model->addVertex (-0.5, 0.5, -0.5);
     401    this->model->addVertex (0.5, 0.5, -0.5);
     402    this->model->addVertex (-0.5, -0.5, -0.5);
     403    this->model->addVertex (0.5, -0.5, -0.5);
     404
     405    this->model->addVertexTexture (0.0, 0.0);
     406    this->model->addVertexTexture (1.0, 0.0);
     407    this->model->addVertexTexture (0.0, 1.0);
     408    this->model->addVertexTexture (1.0, 1.0);
     409    this->model->addVertexTexture (0.0, 2.0);
     410    this->model->addVertexTexture (1.0, 2.0);
     411    this->model->addVertexTexture (0.0, 3.0);
     412    this->model->addVertexTexture (1.0, 3.0);
     413    this->model->addVertexTexture (0.0, 4.0);
     414    this->model->addVertexTexture (1.0, 4.0);
     415    this->model->addVertexTexture (2.0, 0.0);
     416    this->model->addVertexTexture (2.0, 1.0);
     417    this->model->addVertexTexture (-1.0, 0.0);
     418    this->model->addVertexTexture (-1.0, 1.0);
     419
     420    this->model->finalize();
     421    */
     422  }
    415423}
    416424
    … …  
    450458
    451459void Terrain::writeDebug( ) const
    452 {
    453 }
     460  {}
    454461
    455462void Terrain::readDebug( ) const
    456 {
    457 }
     463  {}
    458464
    459465float Terrain::getHeight(float x, float y)
    460466{
    461         if(this->heightMap != NULL)
    462                 return (this->heightMap->getHeight(x, y));
    463         return 0;
    464 }
     467  if(this->heightMap != NULL)
     468    return (this->heightMap->getHeight(x, y));
     469  return 0;
     470}

  • branches/std/src/world_entities/terrain.h

    r7207 r7216  
    4343  void loadVegetation(const std::string& vegetationFile);
    4444
    45   void loadHeightMap(const char* heightMapFile, const char* colorMap = NULL);
    46   void loadTexture(const char* textureName);
     45  void loadHeightMap(const std::string& heightMapFile, const std::string& colorMap);
     46  void loadTexture(const std::string& textureName);
    4747  void setScale(float x, float y, float z);
    4848

  • branches/std/src/world_entities/weapons/aim.cc

    r7193 r7216  
    147147 * @param textureFile The texture-file to load onto the crosshair
    148148 */
    149 void Aim::setTexture(const char* textureFile)
     149void Aim::setTexture(const std::string& textureFile)
    150150{
    151151  this->material->setDiffuseMap(textureFile);

  • branches/std/src/world_entities/weapons/aim.h

    r6724 r7216  
    4646
    4747  void setSize(float size);
    48   void setTexture(const char* textureFile);
     48  void setTexture(const std::string& textureFile);
    4949  /** @param rotationSpeed the speed at what the crosshair should rotate */
    5050  inline void setRotationSpeed(float rotationSpeed) { this->rotationSpeed = rotationSpeed; };

  • branches/std/src/world_entities/weapons/crosshair.cc

    r7193 r7216  
    7979  EventListener::loadParams(root);
    8080
    81   LoadParam(root, "texture", this, Crosshair, setTexture)
     81  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
    8282      .describe("the texture-file to load onto the Crosshair");
    8383
    … …  
    103103 * @param textureFile The texture-file to load onto the crosshair
    104104 */
    105 void Crosshair::setTexture(const char* textureFile)
     105void Crosshair::setTexture(const std::string& textureFile)
    106106{
    107107  this->material->setDiffuseMap(textureFile);

  • branches/std/src/world_entities/weapons/crosshair.h

    r6512 r7216  
    3131
    3232  void setSize(float size);
    33   void setTexture(const char* textureFile);
     33  void setTexture(const std::string& textureFile);
    3434  /** @param rotationSpeed the speed at what the crosshair should rotate */
    3535  void setRotationSpeed(float rotationSpeed) { this->rotationSpeed = rotationSpeed; };

  • branches/std/src/world_entities/weapons/weapon.cc

    r7207 r7216  
    165165 * @param projectile the Name of the Projectile.
    166166 */
    167 void Weapon::setProjectileTypeC(const char* projectile)
    168 {
    169   if (projectile == NULL)
    170     return;
     167void Weapon::setProjectileTypeC(const std::string& projectile)
     168{
    171169  FastFactory* tmpFac = FastFactory::searchFastFactory(projectile);
    172170  if (tmpFac != NULL)
    … …  
    176174  else
    177175  {
    178     PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile, this->getName());
     176    PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile.c_str(), this->getName());
    179177  }
    180178}
    … …  
    613611 * @return The Action if known, WA_NONE otherwise.
    614612 */
    615 WeaponAction Weapon::charToAction(const char* action)
    616 {
    617   if (!strcmp(action, "none"))
     613WeaponAction Weapon::charToAction(const std::string& action)
     614{
     615  if (action == "none")
    618616    return WA_NONE;
    619   else if (!strcmp(action, "shoot"))
     617  else if (action == "shoot")
    620618    return WA_SHOOT;
    621   else if (!strcmp(action, "charge"))
     619  else if (action == "charge")
    622620    return WA_CHARGE;
    623   else if (!strcmp(action, "reload"))
     621  else if (action == "reload")
    624622    return WA_RELOAD;
    625   else if (!strcmp(action, "acitvate"))
     623  else if (action == "acitvate")
    626624    return WA_ACTIVATE;
    627   else if (!strcmp(action, "deactivate"))
     625  else if (action == "deactivate")
    628626    return WA_DEACTIVATE;
    629   else if (!strcmp(action, "special1"))
     627  else if (action == "special1")
    630628    return WA_SPECIAL1;
    631629  else
    632630  {
    633     PRINTF(2)("action %s could not be identified.\n", action);
     631    PRINTF(2)("action %s could not be identified.\n", action.c_str());
    634632    return WA_NONE;
    635633  }
    … …  
    674672 * @return The State if known, WS_NONE otherwise.
    675673 */
    676 WeaponState Weapon::charToState(const char* state)
    677 {
    678   if (!strcmp(state, "none"))
     674WeaponState Weapon::charToState(const std::string& state)
     675{
     676  if (state == "none")
    679677    return WS_NONE;
    680   else if (!strcmp(state, "shooting"))
     678  else if (state == "shooting")
    681679    return WS_SHOOTING;
    682   else if (!strcmp(state, "charging"))
     680  else if (state == "charging")
    683681    return WS_CHARGING;
    684   else if (!strcmp(state, "reloading"))
     682  else if (state == "reloading")
    685683    return WS_RELOADING;
    686   else if (!strcmp(state, "activating"))
     684  else if (state == "activating")
    687685    return WS_ACTIVATING;
    688   else if (!strcmp(state, "deactivating"))
     686  else if (state == "deactivating")
    689687    return WS_DEACTIVATING;
    690   else if (!strcmp(state, "inactive"))
     688  else if (state == "inactive")
    691689    return WS_INACTIVE;
    692   else if (!strcmp(state, "idle"))
     690  else if (state == "idle")
    693691    return WS_IDLE;
    694692  else
    695693  {
    696     PRINTF(2)("state %s could not be identified.\n", state);
     694    PRINTF(2)("state %s could not be identified.\n", state.c_str());
    697695    return WS_NONE;
    698696  }

  • branches/std/src/world_entities/weapons/weapon.h

    r7207 r7216  
    111111    inline long getCapability() const { return this->capability; };
    112112    void setProjectileType(ClassID projectile);
    113     void setProjectileTypeC(const char* projectile);
     113    void setProjectileTypeC(const std::string& projectile);
    114114    /** @returns The projectile's classID */
    115115    inline ClassID getProjectileType() { return this->projectile; };
    … …  
    132132    // STATE CHANGES //
    133133    /** @param state the State to time @param duration the duration of the State */
    134     inline void setStateDuration(const char* state, float duration) { setStateDuration(charToState(state), duration); };
     134    inline void setStateDuration(const std::string& state, float duration) { setStateDuration(charToState(state), duration); };
    135135    /** @param state the State to time @param duration the duration of the State */
    136136    inline void setStateDuration(WeaponState state, float duration) { /*(state < WS_STATE_COUNT)?*/this->times[state] = duration; };
    … …  
    149149
    150150    void setActionSound(WeaponAction action, const std::string& soundFile);
    151     /** @see void setActionSound(WeaponAction action, const char* soundFile); */
    152     void setActionSound(const char* action, const char* soundFile) { this->setActionSound(charToAction(action), soundFile); };
     151    /** @see void setActionSound(WeaponAction action, const std::string& soundFile); */
     152    void setActionSound(const std::string& action, const std::string& soundFile) { this->setActionSound(charToAction(action), soundFile); };
    153153
    154154    Animation3D* getAnimation(WeaponState state, PNode* node = NULL);
    … …  
    176176
    177177    // utility:
    178     static WeaponAction  charToAction(const char* action);
     178    static WeaponAction  charToAction(const std::string& action);
    179179    static const char*   actionToChar(WeaponAction action);
    180     static WeaponState   charToState(const char* state);
     180    static WeaponState   charToState(const std::string& state);
    181181    static const char*   stateToChar(WeaponState state);
    182182

  • branches/std/src/world_entities/world_entity.cc

    r7203 r7216  
    6161  this->bCollide = true;
    6262
    63   this->md2TextureFileName = NULL;
    64 
    6563  this->objectListNumber = OM_INIT;
    6664  this->objectListIterator = NULL;
    … …  
    123121 * @todo fix this, so it only has one loadModel-Function.
    124122*/
    125 void WorldEntity::loadModel(const char* fileName, float scaling, unsigned int modelNumber)
     123void WorldEntity::loadModel(const std::string& fileName, float scaling, unsigned int modelNumber)
    126124{
    127125  this->modelLODName = fileName;
    128126  this->scaling = scaling;
    129   if ( fileName != NULL && strcmp(fileName, "") )
     127  if (!fileName.empty())
    130128  {
    131129    // search for the special character # in the LoadParam
    132     if (strchr(fileName, '#') != NULL)
    133     {
    134       PRINTF(4)("Found # in %s... searching for LOD's\n", fileName);
    135       char* lodFile = new char[strlen(fileName)+1];
    136       strcpy(lodFile, fileName);
    137       char* depth = strchr(lodFile, '#');
     130    if (fileName.find('#') != std::string::npos)
     131    {
     132      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName.c_str());
     133      std::string lodFile = fileName;
     134      unsigned int offset = lodFile.find('#');
    138135      for (unsigned int i = 0; i < 3; i++)
    139136      {
    140         *depth = 48+(int)i;
     137        lodFile[offset] = 48+(int)i;
    141138        if (ResourceManager::isInDataDir(lodFile))
    142139          this->loadModel(lodFile, scaling, i);
    … …  
    149146      this->scaling = 1.0;
    150147    }
    151     if(strstr(fileName, ".obj"))
    152     {
    153       PRINTF(4)("fetching OBJ file: %s\n", fileName);
     148    if(fileName.find(".obj") != std::string::npos)
     149    {
     150      PRINTF(4)("fetching OBJ file: %s\n", fileName.c_str());
    154151      BaseObject* loadedModel = ResourceManager::getInstance()->load(fileName, OBJ, RP_CAMPAIGN, this->scaling);
    155152      if (loadedModel != NULL)
    … …  
    159156        this->buildObbTree(4);
    160157    }
    161     else if(strstr(fileName, ".md2"))
    162     {
    163       PRINTF(4)("fetching MD2 file: %s\n", fileName);
     158    else if(fileName.find(".md2") != std::string::npos)
     159    {
     160      PRINTF(4)("fetching MD2 file: %s\n", fileName.c_str());
    164161      Model* m = new MD2Model(fileName, this->md2TextureFileName, this->scaling);
    165162      //this->setModel((Model*)ResourceManager::getInstance()->load(fileName, MD2, RP_CAMPAIGN), 0);

  • branches/std/src/world_entities/world_entity.h

    r7095 r7216  
    3636  virtual void loadParams(const TiXmlElement* root);
    3737
    38   void loadModel(const char* fileName, float scaling = 1.0f, unsigned int modelNumber = 0);
     38  void loadModel(const std::string& fileName, float scaling = 1.0f, unsigned int modelNumber = 0);
    3939  void setModel(Model* model, unsigned int modelNumber = 0);
    4040  Model* getModel(unsigned int modelNumber = 0) const { return (this->models.size() > modelNumber)? this->models[modelNumber] : NULL; };
    4141
    42   inline void loadMD2Texture(const char* fileName) { this->md2TextureFileName = fileName; }
     42  inline void loadMD2Texture(const std::string& fileName) { this->md2TextureFileName = fileName; }
    4343
    4444  bool buildObbTree(unsigned int depth);
    … …  
    113113
    114114  std::vector<Model*>     models;             //!< The model that should be loaded for this entity.
    115   const char*             md2TextureFileName; //!< the file name of the md2 model texture, only if this
    116   const char*             modelLODName;       //!< the name of the model lod file
     115  std::string             md2TextureFileName; //!< the file name of the md2 model texture, only if this
     116  std::string             modelLODName;       //!< the name of the model lod file
    117117  BVTree*                 obbTree;            //!< this is the obb tree reference needed for collision detection
    118118
Note: See TracChangeset for help on using the changeset viewer.