Custom Query (296 matches)

implement an easy to use class, that…

• creates emitters.
  • different forms: point cube sphere so that emiters will spread volumetric.
• spreads particles from those emitters

The Particle engine should support the following:

• interact with the forces Physique-engine
• display as…
  • shape
  • points
  • 3d-objects (for commet-swarms
• Particles should be programmable, that means:
  • position, direction, velocity can be changed per-particle with a function
• color should be animatable
• MANY many more…

The importer seems to have errors to initialize the right texture-Vertex-Coordinates:

• Fix this in the Material-class in this file.
• test it with some different image-formats

this problem seems to have something to do with how to read in the coordinates in the first place, so also have a look into the model-class itself.

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.