Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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


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/world_entities
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • 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.