PDA

View Full Version : SDL_image Opengl



phamt78
12-12-2007, 10:46 PM
Hope this help out. I've been playing around with opengl texture all day today. I found some source code in SDL source code that show you how to load a SDL_Surface into a opengl texture (testgl.c). I modify it to work with with SDL_image and wrote a c++ class for it.

/******gfx.h*******/
#ifndef GFX_H
#define GFX_H
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <gl/gl.h>

class gfx{
public:
gfx();

~gfx();

// Return texture id.
GLuint getID();

/* Load image from file to SDL_surface.
* Note: 1) If SDL_surface already exist replace with new image.
* 2) Default texture size is set to image size.
*/

bool loadImage(char *file_name);

/* Load texture to graphic card memory.
* Note: *Make sure graphic card support image size*
* Code modify from sdl source code (testgl.c)
* This function check to see if image is a power of 2.
* Then it create a new SDL_surface and load it to the graphic
* memory.
*/

bool loadTexture();

// delete texture from graphic memory;
void freeTexture();

/* Set texture clipping.
* Note: cordinate (0,0) start at top right corner of image loaded
*/
void setRect(GLfloat x, GLfloat y, GLfloat w, GLfloat h);

/* Note: This function draw texture cliiping to the framebuffer.
* To draw to screen call SDL_GL_SwapBuffers();
* flip = 0 do nothing
* flip = 1 vert flip image
* flip = 2 horz flip image
* flip = 3 vert & horz flip image
*/

void draw(GLfloat x, GLfloat y, GLfloat z=0, int flip = 0);

private:
SDL_Surface *image;
GLuint textureID;
GLfloat tx,ty,tw,th,qw,qh,iw,ih;

//code from testgl.c in sdl source code
int power_of_two(int input);
};

#endif


/****gfx.cpp******/
#include "gfx.h"

/* Quick utility function for texture creation */
int gfx::power_of_two(int input)
{
int value = 1;

while ( value < input ) {
value <<= 1;
}
return value;
}

gfx::gfx(){
glGenTextures(1, &textureID);
image = NULL;
}

gfx::~gfx(){
SDL_FreeSurface(image);
glDeleteTextures(1, &textureID);
}

GLuint gfx::getID(){return textureID;}

bool gfx::loadImage(char *file_name){
if(image != NULL){SDL_FreeSurface(image); image = NULL;}

image = IMG_Load(file_name);
if(image == NULL) return false;
else
return true;
}


bool gfx::loadTexture()
{
int w, h;
SDL_Surface *new_image;
SDL_Rect area;
Uint32 saved_flags;
Uint8 saved_alpha;

/* Use the surface width and height expanded to powers of 2 */
w = power_of_two(image->w);
h = power_of_two(image->h);
tx = 0.0f;
ty = 0.0f;
tw = (GLfloat)image->w / w;
th = (GLfloat)image->h / h;
qw = (GLfloat)w;
qh = (GLfloat)h;
iw = (GLfloat)w;
ih = (GLfloat)h;

new_image = SDL_CreateRGBSurface(
SDL_SWSURFACE,
w, h,
32,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000
#else
0xFF000000,
0x00FF0000,
0x0000FF00,
0x000000FF
#endif
);
if ( new_image == NULL ) {
return false;
}

/* Save the alpha blending attributes */
saved_flags = image->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
saved_alpha = image->format->alpha;
if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
SDL_SetAlpha(image, 0, 0);
}

/* Copy the surface into the GL texture image */
area.x = 0;
area.y = 0;
area.w = image->w;
area.h = image->h;
SDL_BlitSurface(image, &area, new_image, &area);

/* Restore the alpha blending attributes */
if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
SDL_SetAlpha(image, saved_flags, saved_alpha);
}

/* Create an OpenGL texture for the image */
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_RGBA,
w, h,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
new_image->pixels);
SDL_FreeSurface(new_image); /* No longer needed */
return true;

}


void gfx::freeTexture(){glDeleteTextures(1, &textureID);}

void gfx::setRect(GLfloat x, GLfloat y, GLfloat w, GLfloat h){
tx = x/w;
ty = y/h;
tw = w/iw;
th = h/ih;
qw = w;
qh = h;
}

void gfx::draw(GLfloat x, GLfloat y, GLfloat z, int flip){
glBindTexture(GL_TEXTURE_2D, textureID);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if(flip == 0){
glBegin(GL_QUADS);
glTexCoord2f(tx, ty);
glVertex3f(x, y, z);
glTexCoord2f(tx, ty+th);
glVertex3f(x, y+qh, z);
glTexCoord2f(tx+tw, ty+th);
glVertex3f(x+qw, y+qh, z);
glTexCoord2f(tx+tw, ty);
glVertex3f(x+qw, y, z);
glEnd();
}
//vert flip
if(flip == 1){
glBegin(GL_QUADS);
glTexCoord2f(tx, ty+th);
glVertex3f(x, y, z);
glTexCoord2f(tx, ty);
glVertex3f(x, y+qh, z);
glTexCoord2f(tx+tw, ty);
glVertex3f(x+qw, y+qh, z);
glTexCoord2f(tx+tw, ty+th);
glVertex3f(x+qw, y, z);
glEnd();
}
//horiz flip
if(flip == 2){
glBegin(GL_QUADS);
glTexCoord2f(tx+tw, ty);
glVertex3f(x, y, z);
glTexCoord2f(tx+tw, ty+th);
glVertex3f(x, y+qh, z);
glTexCoord2f(tx, ty+th);
glVertex3f(x+qw, y+qh, z);
glTexCoord2f(tx, ty);
glVertex3f(x+qw, y, z);
glEnd();
}
// vert & horz flip
if(flip == 3){
glBegin(GL_QUADS);
glTexCoord2f(tx+tw, ty+th);
glVertex3f(x, y, z);
glTexCoord2f(tx+tw, ty);
glVertex3f(x, y+qh, z);
glTexCoord2f(tx, ty);
glVertex3f(x+qw, y+qh, z);
glTexCoord2f(tx, ty+th);
glVertex3f(x+qw, y, z);
glEnd();
}
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
}


/****main.cpp******/
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <gl/gl.h>
#include "gfx.h"
#include "sfx.h"

int main(int argc, char *argv[]){
SDL_Event event;
SDL_Init(SDL_INIT_VIDEO);
SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);

// Reset coordinate system
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, 640, 480, 0, -1, 1);
glClearColor(0.0f,0.0f,0.0f,1.0f); // color to clear framebuffer to
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear framebuffer
sfx_init();
gfx img;
img.loadImage("image.png");
img.loadTexture();

int done;
for(done = 0; !done;){
while ( SDL_PollEvent(&event) ) {
if ( event.type == SDL_QUIT ){
done = 1;
}
if(event.key.keysym.sym == SDLK_ESCAPE){
done = 1;
}
}
img.draw(0,0);
SDL_GL_SwapBuffers();
}
SDL_Quit();
return(0);
}

Trenki
12-13-2007, 04:08 AM
And, what is your problem? Don't expect anyone to just read all of the source without even knowing what the problem is. And for posting code you might want to use the appropriate tags, so the indentation does not get messed up.

[ www.trenki.net (http://www.trenki.net) | vector_math (3d math library) (http://www.trenki.net/content/view/16/36/) | software renderer (http://www.trenki.net/content/view/18/38/) ]

phamt78
12-13-2007, 09:09 AM
There is no problem with my code above. I just though it might help someone trying to use SDL_image to load an image into an opengl texture. I know I had a hard time looking for examples.

navand
12-13-2007, 04:58 PM
Hi
Could you please email me the link and the source code in c.
It might be helpful to me for my testing.

Thanks
Regards

phamt78
12-13-2007, 09:16 PM
navand, here the source code I found downloading SDL source code to compile. I modify it to work with SDL_image in my c++ code. I hope this helps you out.

/*testgl.c*/


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include "SDL.h"

#ifdef __MACOS__
#define HAVE_OPENGL
#endif

#ifdef HAVE_OPENGL

#include "SDL_opengl.h"

/* Undefine this if you want a flat cube instead of a rainbow cube */
#define SHADED_CUBE

/* Define this to be the name of the logo image to use with -logo */
#define LOGO_FILE "icon.bmp"

/* The SDL_OPENGLBLIT interface is deprecated.
The code is still available for benchmark purposes though.
*/

static SDL_bool USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;

static SDL_Surface *global_image = NULL;
static GLuint global_texture = 0;
static GLuint cursor_texture = 0;

/************************************************** ********************/

void HotKey_ToggleFullScreen(void)
{
SDL_Surface *screen;

screen = SDL_GetVideoSurface();
if ( SDL_WM_ToggleFullScreen(screen) ) {
printf("Toggled fullscreen mode - now %s\n",
(screen->flags&amp;SDL_FULLSCREEN) ? "fullscreen" : "windowed");
} else {
printf("Unable to toggle fullscreen mode\n");
}
}

void HotKey_ToggleGrab(void)
{
SDL_GrabMode mode;

printf("Ctrl-G: toggling input grab!\n");
mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
if ( mode == SDL_GRAB_ON ) {
printf("Grab was on\n");
} else {
printf("Grab was off\n");
}
mode = SDL_WM_GrabInput(!mode);
if ( mode == SDL_GRAB_ON ) {
printf("Grab is now on\n");
} else {
printf("Grab is now off\n");
}
}

void HotKey_Iconify(void)
{
printf("Ctrl-Z: iconifying window!\n");
SDL_WM_IconifyWindow();
}

int HandleEvent(SDL_Event *event)
{
int done;

done = 0;
switch( event->type ) {
case SDL_ACTIVEEVENT:
/* See what happened */
printf( "app %s ", event->active.gain ? "gained" : "lost" );
if ( event->active.state & SDL_APPACTIVE ) {
printf( "active " );
} else if ( event->active.state & SDL_APPMOUSEFOCUS ) {
printf( "mouse " );
} else if ( event->active.state & SDL_APPINPUTFOCUS ) {
printf( "input " );
}
printf( "focus\n" );
break;


case SDL_KEYDOWN:
if ( event->key.keysym.sym == SDLK_ESCAPE ) {
done = 1;
}
if ( (event->key.keysym.sym == SDLK_g) &amp;&amp;
(event->key.keysym.mod & KMOD_CTRL) ) {
HotKey_ToggleGrab();
}
if ( (event->key.keysym.sym == SDLK_z) &amp;&amp;
(event->key.keysym.mod & KMOD_CTRL) ) {
HotKey_Iconify();
}
if ( (event->key.keysym.sym == SDLK_RETURN) &amp;&amp;
(event->key.keysym.mod & KMOD_ALT) ) {
HotKey_ToggleFullScreen();
}
printf("key '%s' pressed\n",
SDL_GetKeyName(event->key.keysym.sym));
break;
case SDL_QUIT:
done = 1;
break;
}
return(done);
}

void SDL_GL_Enter2DMode()
{
SDL_Surface *screen = SDL_GetVideoSurface();

/* Note, there may be other things you need to change,
depending on how you have your OpenGL state set up.
*/
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);

/* This allows alpha blending of 2D textures with the scene */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

glViewport(0, 0, screen->w, screen->h);

glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();

glOrtho(0.0, (GLdouble)screen->w, (GLdouble)screen->h, 0.0, 0.0, 1.0);

glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();

glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
}

void SDL_GL_Leave2DMode()
{
glMatrixMode(GL_MODELVIEW);
glPopMatrix();

glMatrixMode(GL_PROJECTION);
glPopMatrix();

glPopAttrib();
}

/* Quick utility function for texture creation */
static int power_of_two(int input)
{
int value = 1;

while ( value < input ) {
value <<= 1;
}
return value;
}

GLuint SDL_GL_LoadTexture(SDL_Surface *surface, GLfloat *texcoord)
{
GLuint texture;
int w, h;
SDL_Surface *image;
SDL_Rect area;
Uint32 saved_flags;
Uint8 saved_alpha;

/* Use the surface width and height expanded to powers of 2 */
w = power_of_two(surface->w);
h = power_of_two(surface->h);
texcoord[0] = 0.0f; /* Min X */
texcoord[1] = 0.0f; /* Min Y */
texcoord[2] = (GLfloat)surface->w / w; /* Max X */
texcoord[3] = (GLfloat)surface->h / h; /* Max Y */

image = SDL_CreateRGBSurface(
SDL_SWSURFACE,
w, h,
32,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000
#else
0xFF000000,
0x00FF0000,
0x0000FF00,
0x000000FF
#endif
);
if ( image == NULL ) {
return 0;
}

/* Save the alpha blending attributes */
saved_flags = surface->flags&amp;(SDL_SRCALPHA|SDL_RLEACCELOK);
saved_alpha = surface->format->alpha;
if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
SDL_SetAlpha(surface, 0, 0);
}

/* Copy the surface into the GL texture image */
area.x = 0;
area.y = 0;
area.w = surface->w;
area.h = surface->h;
SDL_BlitSurface(surface, &amp;area, image, &amp;area);

/* Restore the alpha blending attributes */
if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
SDL_SetAlpha(surface, saved_flags, saved_alpha);
}

/* Create an OpenGL texture for the image */
glGenTextures(1, &amp;texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_RGBA,
w, h,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
image->pixels);
SDL_FreeSurface(image); /* No longer needed */

return texture;
}

void DrawLogoCursor(void)
{
static GLfloat texMinX, texMinY;
static GLfloat texMaxX, texMaxY;
static int w, h;
int x, y;

if ( ! cursor_texture ) {
SDL_Surface *image;
GLfloat texcoord[4];

/* Load the image (could use SDL_image library here) */
image = SDL_LoadBMP(LOGO_FILE);
if ( image == NULL ) {
return;
}
w = image->w;
h = image->h;

/* Convert the image into an OpenGL texture */
cursor_texture = SDL_GL_LoadTexture(image, texcoord);

/* Make texture coordinates easy to understand */
texMinX = texcoord[0];
texMinY = texcoord[1];
texMaxX = texcoord[2];
texMaxY = texcoord[3];

/* We don't need the original image anymore */
SDL_FreeSurface(image);

/* Make sure that the texture conversion is okay */
if ( ! cursor_texture ) {
return;
}
}

/* Move the image around */
SDL_GetMouseState(&amp;x, &amp;y);
x -= w/2;
y -= h/2;

/* Show the image on the screen */
SDL_GL_Enter2DMode();
glBindTexture(GL_TEXTURE_2D, cursor_texture);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(texMinX, texMinY); glVertex2i(x, y );
glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y );
glTexCoord2f(texMinX, texMaxY); glVertex2i(x, y+h);
glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
glEnd();
SDL_GL_Leave2DMode();
}

void DrawLogoTexture(void)
{
static GLfloat texMinX, texMinY;
static GLfloat texMaxX, texMaxY;
static int x = 0;
static int y = 0;
static int w, h;
static int delta_x = 1;
static int delta_y = 1;

SDL_Surface *screen = SDL_GetVideoSurface();

if ( ! global_texture ) {
SDL_Surface *image;
GLfloat texcoord[4];

/* Load the image (could use SDL_image library here) */
image = SDL_LoadBMP(LOGO_FILE);
if ( image == NULL ) {
return;
}
w = image->w;
h = image->h;

/* Convert the image into an OpenGL texture */
global_texture = SDL_GL_LoadTexture(image, texcoord);

/* Make texture coordinates easy to understand */
texMinX = texcoord[0];
texMinY = texcoord[1];
texMaxX = texcoord[2];
texMaxY = texcoord[3];

/* We don't need the original image anymore */
SDL_FreeSurface(image);

/* Make sure that the texture conversion is okay */
if ( ! global_texture ) {
return;
}
}

/* Move the image around */
x += delta_x;
if ( x < 0 ) {
x = 0;
delta_x = -delta_x;
} else
if ( (x+w) > screen->w ) {
x = screen->w-w;
delta_x = -delta_x;
}
y += delta_y;
if ( y < 0 ) {
y = 0;
delta_y = -delta_y;
} else
if ( (y+h) > screen->h ) {
y = screen->h-h;
delta_y = -delta_y;
}

/* Show the image on the screen */
SDL_GL_Enter2DMode();
glBindTexture(GL_TEXTURE_2D, global_texture);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(texMinX, texMinY); glVertex2i(x, y );
glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y );
glTexCoord2f(texMinX, texMaxY); glVertex2i(x, y+h);
glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
glEnd();
SDL_GL_Leave2DMode();
}

/* This code is deprecated, but available for speed comparisons */
void DrawLogoBlit(void)
{
static int x = 0;
static int y = 0;
static int w, h;
static int delta_x = 1;
static int delta_y = 1;

SDL_Rect dst;
SDL_Surface *screen = SDL_GetVideoSurface();

if ( global_image == NULL ) {
SDL_Surface *temp;

/* Load the image (could use SDL_image library here) */
temp = SDL_LoadBMP(LOGO_FILE);
if ( temp == NULL ) {
return;
}
w = temp->w;
h = temp->h;

/* Convert the image into the screen format */
global_image = SDL_CreateRGBSurface(
SDL_SWSURFACE,
w, h,
screen->format->BitsPerPixel,
screen->format->Rmask,
screen->format->Gmask,
screen->format->Bmask,
screen->format->Amask);
if ( global_image ) {
SDL_BlitSurface(temp, NULL, global_image, NULL);
}
SDL_FreeSurface(temp);

/* Make sure that the texture conversion is okay */
if ( ! global_image ) {
return;
}
}

/* Move the image around
Note that we do not clear the old position. This is because we
perform a glClear() which clears the framebuffer and then only
update the new area.
Note that you can also achieve interesting effects by modifying
the screen surface alpha channel. It's set to 255 by default..
*/
x += delta_x;
if ( x < 0 ) {
x = 0;
delta_x = -delta_x;
} else
if ( (x+w) > screen->w ) {
x = screen->w-w;
delta_x = -delta_x;
}
y += delta_y;
if ( y < 0 ) {
y = 0;
delta_y = -delta_y;
} else
if ( (y+h) > screen->h ) {
y = screen->h-h;
delta_y = -delta_y;
}
dst.x = x;
dst.y = y;
dst.w = w;
dst.h = h;
SDL_BlitSurface(global_image, NULL, screen, &amp;dst);

/* Show the image on the screen */
SDL_UpdateRects(screen, 1, &amp;dst);
}

int RunGLTest( int argc, char* argv[],
int logo, int logocursor, int slowly, int bpp, float gamma, int noframe, int fsaa, int sync, int accel )
{
int i;
int rgb_size[3];
int w = 640;
int h = 480;
int done = 0;
int frames;
Uint32 start_time, this_time;
float color[8][3]= {{ 1.0, 1.0, 0.0},
{ 1.0, 0.0, 0.0},
{ 0.0, 0.0, 0.0},
{ 0.0, 1.0, 0.0},
{ 0.0, 1.0, 1.0},
{ 1.0, 1.0, 1.0},
{ 1.0, 0.0, 1.0},
{ 0.0, 0.0, 1.0}};
float cube[8][3]= {{ 0.5, 0.5, -0.5},
{ 0.5, -0.5, -0.5},
{-0.5, -0.5, -0.5},
{-0.5, 0.5, -0.5},
{-0.5, 0.5, 0.5},
{ 0.5, 0.5, 0.5},
{ 0.5, -0.5, 0.5},
{-0.5, -0.5, 0.5}};
Uint32 video_flags;
int value;

if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
fprintf(stderr,"Couldn't initialize SDL: %s\n",SDL_GetError());
exit( 1 );
}

/* See if we should detect the display depth */
if ( bpp == 0 ) {
if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8 ) {
bpp = 8;
} else {
bpp = 16; /* More doesn't seem to work */
}
}

/* Set the flags we want to use for setting the video mode */
if ( logo &amp;&amp; USE_DEPRECATED_OPENGLBLIT ) {
video_flags = SDL_OPENGLBLIT;
} else {
video_flags = SDL_OPENGL;
}
for ( i=1; argv[i]; ++i ) {
if ( strcmp(argv[i], "-fullscreen") == 0 ) {
video_flags |= SDL_FULLSCREEN;
}
}

if (noframe) {
video_flags |= SDL_NOFRAME;
}

/* Initialize the display */
switch (bpp) {
case 8:
rgb_size[0] = 3;
rgb_size[1] = 3;
rgb_size[2] = 2;
break;
case 15:
case 16:
rgb_size[0] = 5;
rgb_size[1] = 5;
rgb_size[2] = 5;
break;
default:
rgb_size[0] = 8;
rgb_size[1] = 8;
rgb_size[2] = 8;
break;
}
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, rgb_size[0] );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, rgb_size[1] );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, rgb_size[2] );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
if ( fsaa ) {
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, fsaa );
}
if ( accel ) {
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
}
if ( sync ) {
SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 );
} else {
SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 0 );
}
if ( SDL_SetVideoMode( w, h, bpp, video_flags ) == NULL ) {
fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());
SDL_Quit();
exit(1);
}

printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);
printf("\n");
printf( "Vendor : %s\n", glGetString( GL_VENDOR ) );
printf( "Renderer : %s\n", glGetString( GL_RENDERER ) );
printf( "Version : %s\n", glGetString( GL_VERSION ) );
printf( "Extensions : %s\n", glGetString( GL_EXTENSIONS ) );
printf("\n");

SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &amp;value );
printf( "SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0],value);
SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &amp;value );
printf( "SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1],value);
SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &amp;value );
printf( "SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2],value);
SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &amp;value );
printf( "SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value );
SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &amp;value );
printf( "SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value );
if ( fsaa ) {
SDL_GL_GetAttribute( SDL_GL_MULTISAMPLEBUFFERS, &amp;value );
printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value );
SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &amp;value );
printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value );
}
if ( accel ) {
SDL_GL_GetAttribute( SDL_GL_ACCELERATED_VISUAL, &amp;value );
printf( "SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value );
}
if ( sync ) {
SDL_GL_GetAttribute( SDL_GL_SWAP_CONTROL, &amp;value );
printf( "SDL_GL_SWAP_CONTROL: requested 1, got %d\n", value );
}

/* Set the window manager title bar */
SDL_WM_SetCaption( "SDL GL test", "testgl" );

/* Set the gamma for the window */
if ( gamma != 0.0 ) {
SDL_SetGamma(gamma, gamma, gamma);
}

glViewport( 0, 0, w, h );
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );

glOrtho( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 );

glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );

glEnable(GL_DEPTH_TEST);

glDepthFunc(GL_LESS);

glShadeModel(GL_SMOOTH);

/* Loop until done. */
start_time = SDL_GetTicks();
frames = 0;
while( !done ) {
GLenum gl_error;
char* sdl_error;
SDL_Event event;

/* Do our drawing, too. */
glClearColor( 0.0, 0.0, 0.0, 1.0 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glBegin( GL_QUADS );

#ifdef SHADED_CUBE
glColor3fv(color[0]);
glVertex3fv(cube[0]);
glColor3fv(color[1]);
glVertex3fv(cube[1]);
glColor3fv(color[2]);
glVertex3fv(cube[2]);
glColor3fv(color[3]);
glVertex3fv(cube[3]);

glColor3fv(color[3]);
glVertex3fv(cube[3]);
glColor3fv(color[4]);
glVertex3fv(cube[4]);
glColor3fv(color[7]);
glVertex3fv(cube[7]);
glColor3fv(color[2]);
glVertex3fv(cube[2]);

glColor3fv(color[0]);
glVertex3fv(cube[0]);
glColor3fv(color[5]);
glVertex3fv(cube[5]);
glColor3fv(color[6]);
glVertex3fv(cube[6]);
glColor3fv(color[1]);
glVertex3fv(cube[1]);

glColor3fv(color[5]);
glVertex3fv(cube[5]);
glColor3fv(color[4]);
glVertex3fv(cube[4]);
glColor3fv(color[7]);
glVertex3fv(cube[7]);
glColor3fv(color[6]);
glVertex3fv(cube[6]);

glColor3fv(color[5]);
glVertex3fv(cube[5]);
glColor3fv(color[0]);
glVertex3fv(cube[0]);
glColor3fv(color[3]);
glVertex3fv(cube[3]);
glColor3fv(color[4]);
glVertex3fv(cube[4]);

glColor3fv(color[6]);
glVertex3fv(cube[6]);
glColor3fv(color[1]);
glVertex3fv(cube[1]);
glColor3fv(color[2]);
glVertex3fv(cube[2]);
glColor3fv(color[7]);
glVertex3fv(cube[7]);
#else /* flat cube */
glColor3f(1.0, 0.0, 0.0);
glVertex3fv(cube[0]);
glVertex3fv(cube[1]);
glVertex3fv(cube[2]);
glVertex3fv(cube[3]);

glColor3f(0.0, 1.0, 0.0);
glVertex3fv(cube[3]);
glVertex3fv(cube[4]);
glVertex3fv(cube[7]);
glVertex3fv(cube[2]);

glColor3f(0.0, 0.0, 1.0);
glVertex3fv(cube[0]);
glVertex3fv(cube[5]);
glVertex3fv(cube[6]);
glVertex3fv(cube[1]);

glColor3f(0.0, 1.0, 1.0);
glVertex3fv(cube[5]);
glVertex3fv(cube[4]);
glVertex3fv(cube[7]);
glVertex3fv(cube[6]);

glColor3f(1.0, 1.0, 0.0);
glVertex3fv(cube[5]);
glVertex3fv(cube[0]);
glVertex3fv(cube[3]);
glVertex3fv(cube[4]);

glColor3f(1.0, 0.0, 1.0);
glVertex3fv(cube[6]);
glVertex3fv(cube[1]);
glVertex3fv(cube[2]);
glVertex3fv(cube[7]);
#endif /* SHADED_CUBE */

glEnd( );

glMatrixMode(GL_MODELVIEW);
glRotatef(5.0, 1.0, 1.0, 1.0);

/* Draw 2D logo onto the 3D display */
if ( logo ) {
if ( USE_DEPRECATED_OPENGLBLIT ) {
DrawLogoBlit();
} else {
DrawLogoTexture();
}
}
if ( logocursor ) {
DrawLogoCursor();
}

SDL_GL_SwapBuffers( );

/* Check for error conditions. */
gl_error = glGetError( );

if( gl_error != GL_NO_ERROR ) {
fprintf( stderr, "testgl: OpenGL error: %d\n", gl_error );
}

sdl_error = SDL_GetError( );

if( sdl_error[0] != '\0' ) {
fprintf(stderr, "testgl: SDL error '%s'\n", sdl_error);
SDL_ClearError();
}

/* Allow the user to see what's happening */
if ( slowly ) {
SDL_Delay( 20 );
}

/* Check if there's a pending event. */
while( SDL_PollEvent( &amp;event ) ) {
done = HandleEvent(&amp;event);
}
++frames;
}

/* Print out the frames per second */
this_time = SDL_GetTicks();
if ( this_time != start_time ) {
printf("%2.2f FPS\n",
((float)frames/(this_time-start_time))*1000.0);
}

if ( global_image ) {
SDL_FreeSurface(global_image);
global_image = NULL;
}
if ( global_texture ) {
glDeleteTextures( 1, &amp;global_texture );
global_texture = 0;
}
if ( cursor_texture ) {
glDeleteTextures( 1, &amp;cursor_texture );
cursor_texture = 0;
}

/* Destroy our GL context, etc. */
SDL_Quit( );
return(0);
}

int main(int argc, char *argv[])
{
int i, logo, logocursor = 0;
int numtests;
int bpp = 0;
int slowly;
float gamma = 0.0;
int noframe = 0;
int fsaa = 0;
int accel = 0;
int sync = 0;

logo = 0;
slowly = 0;
numtests = 1;
for ( i=1; argv[i]; ++i ) {
if ( strcmp(argv[i], "-twice") == 0 ) {
++numtests;
}
if ( strcmp(argv[i], "-logo") == 0 ) {
logo = 1;
USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
}
if ( strcmp(argv[i], "-logoblit") == 0 ) {
logo = 1;
USE_DEPRECATED_OPENGLBLIT = SDL_TRUE;
}
if ( strcmp(argv[i], "-logocursor") == 0 ) {
logocursor = 1;
}
if ( strcmp(argv[i], "-slow") == 0 ) {
slowly = 1;
}
if ( strcmp(argv[i], "-bpp") == 0 ) {
bpp = atoi(argv[++i]);
}
if ( strcmp(argv[i], "-gamma") == 0 ) {
gamma = (float)atof(argv[++i]);
}
if ( strcmp(argv[i], "-noframe") == 0 ) {
noframe = 1;
}
if ( strcmp(argv[i], "-fsaa") == 0 ) {
++fsaa;
}
if ( strcmp(argv[i], "-accel") == 0 ) {
++accel;
}
if ( strcmp(argv[i], "-sync") == 0 ) {
++sync;
}
if ( strncmp(argv[i], "-h", 2) == 0 ) {
printf(
"Usage: %s [-twice] [-logo] [-logocursor] [-slow] [-bpp n] [-gamma n] [-noframe] [-fsaa] [-accel] [-sync] [-fullscreen]\n",
argv[0]);
exit(0);
}
}
for ( i=0; i<numtests; ++i ) {
RunGLTest(argc, argv, logo, logocursor, slowly, bpp, gamma, noframe, fsaa, sync, accel);
}
return 0;
}

#else /* HAVE_OPENGL */

int main(int argc, char *argv[])
{
printf("No OpenGL support on this system\n");
return 1;
}

#endif /* HAVE_OPENGL */

navand
12-13-2007, 09:45 PM
Hi phamt78
Thanks a lot. I will give it a try in the morning.

Really appreciate your help.
Regards

Aintaer
12-18-2007, 01:02 AM
Hi guys,
I'm trying to use SDL_image as well and am running into some problems. Here's my code so far...

The texture generator


TexQuad GenerateTex(SDL_Surface* s, int w, int h) {
GLuint texture;
Uint32 saved_flags;
Uint8 saved_alpha;
SDL_Surface* surface;

w = nextPowTwo(w);
h = nextPowTwo(h);

glGenTextures(1, &amp;texture);
glBindTexture(GL_TEXTURE_2D, texture);

surface = SDL_CreateRGBSurface(SDL_SWSURFACE,w,h,32,rmask,gm ask,bmask,amask);
saved_flags = s->flags&amp;(SDL_SRCALPHA|SDL_RLEACCELOK);
saved_alpha = s->format->alpha;
if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
SDL_SetAlpha(s, 0, 0);
}
SDL_BlitSurface(s,NULL,surface,NULL);
if ((saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
SDL_SetAlpha(s, saved_flags, saved_alpha);
}
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTE R,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTE R,GL_NEAREST);
SDL_LockSurface(surface);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0,
GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels);
SDL_UnlockSurface(surface);
SDL_FreeSurface(s);
SDL_FreeSurface(surface);
return ((TexQuad){texture, w, h});
}


The vertices and tex coords generator


void FillList(int w, int h) {
// Creates interleaved array of one quad in GLfloat *iList
if (iList!=0) delete iList;
iList = new GLfloat [20];
// Pack texture first, vertex later
for (int i=0; i<20; i+=5) {
int b = i/5;
iList[i] = b>1?1.0f:0.0f;
iList[i+1] = b<3?(b>0?1.0f:0.0f):0.0f;
iList[i+2] = float (b>1?w:0);
iList[i+3] = float (b<3?(b>0?h:0):0);
iList[i+4] = 0.0f;
}
glInterleavedArrays(GL_T2F_V3F, 0, iList);
}


The quad is then drawn with glDrawArrays(GL_QUADS, 0, 4);

Now, the problem is, all I get from SDL_image's IMG_Load, when run into that mess up there, is a black screen. However, I use the same code on an SDL_Surface from SDL_ttf and it works like a charm.

I suspect it's because of my texture coordinate scheme. Anybody else have any ideas?