Custom Query (296 matches)

A HeightMapTerrain is a class, that reads in a grey-scale image. Black is low terrain, White is high. Like this it should be very easy possible, to create good looking landscapes.
The process is called displacement and can also be applied to other bodies than flat surfaces. ⇒ Ideas?

• The class must be able to
  • read in a texture as an SDL_surface.

    bool Material::loadImage(char* imageName, GLuint* texture)
    {
      char* imgNameWithPath = searchTextureInPaths(imageName);
      if (imgNameWithPath)
        {
          SDL_Surface* map;
          Image* pImage = new Image;
          map=IMG_Load(imgNameWithPath);
          if(!map)
    	{
    	  PRINTF(1)("IMG_Load: %s\n", IMG_GetError());
    	  return false;
    	}
          pImage->height = map->h;
          pImage->width  = map->w;
          pImage->data   = (GLubyte*)map->pixels;
          if( !IMG_isPNG(SDL_RWFromFile(imgNameWithPath, "rb")) && !IMG_isJPG(SDL_RWFromFile(imgNameWithPath, "rb")))
    	for (int i=0;i<map->h * map->w *3;i+=3)
    	  { 
    	    GLuint temp = pImage->data[i];
    	    pImage->data[i] = pImage->data[i+2];
    	    pImage->data[i+2] = temp;
    	  }
          this->applyItToAHitghtMap (pImage, texture);
        }
      else
        {
          PRINTF(1)("Image not Found: %s\n", imgNameWithPath);
          return false;
        }
    }
    

  • then it should apply what it learnt to the heightMap (use the struct given below to pass info)

      struct Image
      {
        int rowSpan;    //!< The count of the rows this Image has.
        GLuint width;   //!< The width of the Image.
        GLuint height;  //!< The height of the Image.
        GLuint bpp;     //!< BitsPerPixel
        GLuint type;    //!< Type of the Image.
        GLubyte *data;  //!< The Image Data comes here! DANGER: uncompressed data. Delete it!
      };
    

  • Then Transform the mesh, pack it into (multipe) display lists, and give it back to orxonox.

• Look out!
  • Loading will heappen at levelstart, so it can use some time.
  • During the Game-runtime there may be no delay.
  Look, that your algorithm covers this.

Reimplement the system for shooting: The Fun of the game!!

• shoot:
  1. A Player emitts a shoot (in its local coordinates)
  2. The Shoot must be reparented to the World-helper-parent, so it is Free.
• modularity:
  1. The shot should be programmable, and contain some stuff, like velocity, direction and so on.
  2. A shoot must be able to be guided by forces (so do not forget that later on the physique engine will finger them)
  3. A shoot must contain some energy, must be able to send signals, and to colide.

The Material class is only showing the diffuse mapping for the moment, and it should be possible to use it easily without model-class itself.

• reimplement:
  • The class needs some refitting, so it is easy, to create a Material nad very fast work with it.
  • there must be a Method create/define/change to initialize the Material.
  • there must be a function to initialize the material, so it can be loaded on the fly and be applyed to (a part of) a model.
• Methods to add:
  • Bump-map, ambient-map, specular map and so on…
  • Possibly some predefinded textures like checker/noise/fog and so on → put this inside a new File or texture.cc.
  • change function, to modify the Material, think about that a Material is also inside of a glList.