OpenGL and SDL examples

Loading an OpenGL texture from a SDL surface with no alpha information
Loading an OpenGL texture from a BMP image
Resizing window
Using SDL_ttf with OpenGL

/**
 * Returns the first power of 2 greater or equal to the specified value.
 *
 * @param value that the  
 *
 *
 */
int powerOfTwo( int value )
{

	int result = 1 ;
	
	while ( result < value )
		result *= 2 ;
	
	return result ;		
}


/**
 * Creates a texture from a surface. Set the alpha according to the color key. 
 * Pixels that match the color key get an alpha of zero while all other
 * pixels get an alpha of one.
 *
 * The source surface can come from example from a PNG file.
 *
 */
GLuint uploadTextureFromSurface( const SDL_Surface & sourceSurface, GLfloat * textureCoordinates, 
	Uint8 colorKeyRed, Uint8 colorKeyGreen, Uint8 colorKeyBlue ) throw( ImageException )
{

  /*
   * Use the surface width and height expanded to powers of 2 :
   * (one may call also gluScaleImage.
   */

  int w = powerOfTwo( sourceSurface->w ) ;
  int h = powerOfTwo( sourceSurface->h ) ;
  
  // Min X :
  texcoord[0] = 0.0f ;
  
  // Min Y :
  texcoord[1] = 0.0f ;
  
  // Max X :
  texcoord[2] = (GLfloat) surface->w / w ;
  
   // Max Y :
  texcoord[3] = (GLfloat) surface->h / h ;
 
  /* Create the target alpha surface with correct color component ordering */
  SDL_Surface * alphaImage = SDL_CreateRGBSurface( SDL_SWSURFACE, sourceSurface->w,
 	sourceSurface->h, 32 /* bits */,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN // OpenGL RGBA masks 
                               0x000000FF, 
                               0x0000FF00, 
                               0x00FF0000, 
                               0xFF000000
#else
                               0xFF000000,
                               0x00FF0000, 
                               0x0000FF00, 
                               0x000000FF
#endif
  ) ;

  if ( alphaImage == 0 )
 	throw ImageException( "uploadTextureFromSurface : RGB surface creation failed." ) ;

  // Set up so that colorkey pixels become transparent :

  colorkey = SDL_MapRGBA( alphaImage->format, colorKeyRed, colorKeyGreen, colorKeyBlue, 0 ) ;
  SDL_FillRect( alphaImage, 0, colorkey ) ;

  colorkey = SDL_MapRGBA( sourceSurface->format, colorKeyRed, colorKeyGreen, colorKeyBlue, 0 ) ;
  SDL_SetColorKey( sourceSurface, SDL_SRCCOLORKEY, colorkey ) ;
	
  SDL_Rect area ;
 
  // Copy the surface into the GL texture image : 
  area.x = 0 ;
  area.y = 0 ; 
  area.w = sourceSurface->w ;
  area.h = sourceSurface->h ;
  SDL_BlitSurface( sourceSurface, &area, alphaImage, &area ) ;
 
  // Create an OpenGL texture for the image 

  GLuint textureID ;
  glGenTextures( 1, &textureID ) ;
  glBindTexture( GL_TEXTURE_2D, textureID ) ;

  /* Prepare the filtering of the texture image */

  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ) ;
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ) ;
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ) ;
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ) ;

 /* Map the alpha surface to the texture */
  glTexImage2D( GL_TEXTURE_2D,
               0,
               GL_RGBA,
               w, h,
               0,
               GL_RGBA,
               GL_UNSIGNED_BYTE,
               alphaImage->pixels ) ;

  // No longer needed :
  SDL_FreeSurface( alphaImage ) ; 
 
  return textureID ;
  
}

bool loadbmp(char *img, GLuint &image) {
	SDL_Surface *temp, *flipped;		// temporary SDL image
	
	if((temp = SDL_LoadBMP(img)) == NULL) {
		printf("Cannot load bmp: %s\n", img);
		return false;
	}
	
	if(temp->w != temp->h) {
		printf("Image not square\n");
		return false;
	}
	
	if(temp->w < 1) {
		printf("Invalid image\n");
		return false;
	} else if(!((temp->w & (temp->w-1)) == 0)) {
		printf("Invalid image dimensions\n");
		return false;
	}
	
	Uint32 rmask, gmask, bmask, amask;
	
	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
		rmask = 0xff000000;
		gmask = 0x00ff0000;
		bmask = 0x0000ff00;
		amask = 0x000000ff;
	#else
		rmask = 0x000000ff;
		gmask = 0x0000ff00;
		bmask = 0x00ff0000;
		amask = 0xff000000;
	#endif
	
	// now flip the image
	flipped = SDL_CreateRGBSurface(SDL_SWSURFACE, temp->w, temp->h,
temp->format->BitsPerPixel, rmask, gmask, bmask, amask);
	if(flipped == NULL) {
		printf("Error flipping image: %s\n", img);
		return false;
	}
	
	
	SLock(temp);
	SLock(flipped);
	
	for(int i = 0; i < temp->h; i++) {
		for(int j = 0; j < temp->w; j++) {
			putpixel(flipped, i, temp->h - j - 1, getpixel(temp, i, j));
		}
	}
	
	SUnlock(temp);
	SUnlock(flipped);
	
	
	
	if(temp != NULL) {
		SDL_FreeSurface(temp);
	}
	
	// Create textures
	glGenTextures(1, &image);
	
	// load the texture
	glBindTexture(GL_TEXTURE_2D, image);
	
	// Generate the texture
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, flipped->w, flipped->h, 0,
GL_BGR, GL_UNSIGNED_BYTE, flipped->pixels);
	
	if(flipped != NULL) {
		SDL_FreeSurface(flipped);
	}
	
	// Use nearest filtering
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	
	return true;
}

is what I use when I need to load a bmp as a texture.

void SetGLWindow(int width, int height)
{
  GLfloat ratio;

  if(height == 0)
    height = 1;

  ratio = (GLfloat)width/(GLfloat)height;

  glViewport(0, 0, (GLint)width, (GLint)height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  gluPerspective(45.0f, ratio, 0.1f, 100.0f);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

}

Then I wait for a resize event in my main loop


while(!done)
    {
      while(SDL_PollEvent(&event))
    {
     switch(event.type)
      {
      case SDL_ACTIVEEVENT:
       if(event.active.gain == 0)
        isActive = FALSE;
       else
        isActive = TRUE;
       break;
      case SDL_VIDEORESIZE:
       if((surface = SDL_SetVideoMode(event.resize.w,
                       event.resize.h,
                       SCREEN_BPP,
                       videoFlags)) == NULL)
        {
         fprintf(stderr,"Unable to grab surface after resize event: 
%s\n",SDL_GetError());
         Quit(1);
        }
       SetGLWindow(event.resize.w, event.resize.h);
       break;
      case SDL_KEYDOWN:
       HandleKeyDown(&event.key.keysym);
       break;
      case SDL_QUIT:
       done = TRUE;
       break;
      default:
       break;
      }
    }
      if(isActive)
    DrawScreen();
    }

 
void test_event(SDL_Event *event)
{
	switch(event->type)
	{
		[...]
		case SDL_VIDEORESIZE:
		 {
		   if(event->resize.w < 200) event->resize.w = 200;
		   if(event->resize.h < 200) event->resize.h = 200;
		   int bpp;
		   if((bpp = SDL_VideoModeOK(
			 	event->resize.w,event->resize.h,32,init_vflag)) == 0)
		   h_term_error(
			 	"Requested video mode not supported please use another mode : ");
		   if ((main_w = SDL_SetVideoMode(
			 	event->resize.w,event->resize.h,bpp,init_vflag)) == NULL)
		   h_term_error("Unable to open a surface : ");
		   at_resize_draw_scene();
		   simple_report("Resize maked");
		   break;
		 }
	}
}

[...]far far away

void at_resize_draw_scene(void)
{
	glViewport(0,0,main_w->w,main_w->h);
	glClearColor(0.3, 0.3, 0.3, 0.0);
	glClearDepth(1.0);
	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(90.0,static_cast(main_w->w)/main_w->h, 0.1, 1000.0);
	glPushMatrix();
}