Jump to content
  • Advertisement
Sign in to follow this  
Shmuel

OpenGL strange texturing error

This topic is 5083 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

When I try to texture-map, the textures are oriented correctly and everything, but are tinted slighly orange. I don't think it's my computer or monitor so what's teh deal? Here is my code:
#include <SDL.h>
#include <sdl_opengl.h>

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

// screen width, height, and bit depth
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int SCREEN_BPP = 16;

// game constants
const int COMPUTERS_TURN = 0;
const int PLAYERS_TURN = 1;

const int EMPTY_SPACE = 0;
const int COMPUTER_SPACE = 1;
const int PLAYER_SPACE = 2;

// Flags to pass to SDL_SetVideoMode
int videoFlags;

// This is our SDL surface
SDL_Surface * surface;

GLuint texture[1]; // Storage for one texture

void Quit(int returnCode);
int resizeWindow(int width, int height);
void handleKeyPress(SDL_keysym * keysym);
int LoadGLTextures();
int initGL(GLvoid);

void drawQuad(GLfloat x, GLfloat y);
int drawGLScene(GLvoid);

int main(int argc, char ** argv)
{
	// game variables
	int turn;
	int board[9] = {0,0,0,0,0,0,0,0,0}; // The square numbers are:
										// 0 1 2
										// 3 4 5
										// 6 7 8
	bool gameover = false;

	
	// main loop variable
    int done = FALSE;
    
	// used to collect events
    SDL_Event event;
    
	// this holds some info about our display
    const SDL_VideoInfo * videoInfo;
    
	// whether or not the window is active
    int isActive = TRUE;

    // initialize SDL */
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
	{
	    fprintf(stderr, "Video initialization failed: %s\n",
		     SDL_GetError());
	    Quit(1);
	}

    // Fetch the video info
    videoInfo = SDL_GetVideoInfo();

    if (!videoInfo)
	{
	    fprintf(stderr, "Video query failed: %s\n",
		     SDL_GetError());
	    Quit(1);
	}

    // the flags to pass to SDL_SetVideoMode
    videoFlags  = SDL_OPENGL;						// Enable OpenGL in SDL
    videoFlags |= SDL_GL_DOUBLEBUFFER;				// Enable double buffering
    videoFlags |= SDL_HWPALETTE;					// Store the palette in hardware
    videoFlags |= SDL_RESIZABLE;					// Enable window resizing

    // This checks to see if surfaces can be stored in memory
    if (videoInfo->hw_available)
		videoFlags |= SDL_HWSURFACE;
    else
		videoFlags |= SDL_SWSURFACE;

    // This checks if hardware blits can be done
    if (videoInfo->blit_hw)
		videoFlags |= SDL_HWACCEL;

    // Sets up OpenGL double buffering
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

    // get a SDL surface
    surface = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,
				videoFlags);

    // Verify there is a surface
    if (!surface)
	{
	    fprintf(stderr, "Video mode set failed: %s\n", SDL_GetError());
	    Quit(1);
	}

	// Set window caption
	SDL_WM_SetCaption("Tic Tac Toe - Press F1 to switch to fullscreen", NULL);

    // initialize OpenGL
    if (initGL() == FALSE)
	{
	    fprintf(stderr, "Could not initialize OpenGL.\n");
	    Quit(1);
	}

    // Resize the initial window
    resizeWindow(SCREEN_WIDTH, SCREEN_HEIGHT);

    // wait for events
    while (!done)
	{
	    // handle the events in the queue

	    while (SDL_PollEvent(&event))
		{
		    switch(event.type)
			{
				case SDL_ACTIVEEVENT:
				{
					// Something's happened with our focus
				    // If we lost focus or we are iconified, we
				    // shouldn't draw the screen
			    
				    if (event.active.gain == 0)
						isActive = FALSE;
				    else
						isActive = TRUE;
				    break;
				}
				case SDL_VIDEORESIZE:
				{
				    // handle resize event
				    surface = SDL_SetVideoMode(event.resize.w,
								event.resize.h,
								16, videoFlags);
					if (!surface)
					{
					    fprintf(stderr, "Could not get a surface after resize: %s\n", SDL_GetError());
					    Quit(1);
					}
					resizeWindow(event.resize.w, event.resize.h);

					initGL();
					break;
				}
				case SDL_KEYDOWN:
				{
				    // handle key presses
				    handleKeyPress(&event.key.keysym);
				    break;
				}
				case SDL_QUIT:
				{
					// handle quit requests
					done = TRUE;
					break;
				}
			
				default:
					break;
			}
		}

	    // draw the scene
	    if (isActive)
		drawGLScene();
	}

    // clean ourselves up and exit
    Quit(0);

    // Should never get here
    return(0);
}

// function to release/destroy our resources and restoring the old desktop
void Quit(int returnCode)
{
    // clean up the window
    SDL_Quit();

    // and exit appropriately
    exit(returnCode);
}

// function to reset our viewport after a window resize
int resizeWindow(int width, int height)
{
    // Height / width ration
    GLfloat ratio;

    // Protect against a divide by zero
    if (height == 0)
	height = 1;

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

    // Setup our viewport.
    glViewport(0,0, (GLint)width,(GLint)height);

    // change to the projection matrix and set our viewing volume.
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    // Set our perspective
    gluPerspective(45.0f, ratio, 0.1f, 100.0f);

    // Make sure we're changing the model view and not the projection
    glMatrixMode(GL_MODELVIEW);

    // Reset the view
    glLoadIdentity();

    return(TRUE);
}

// function to handle key press events
void handleKeyPress(SDL_keysym * keysym)
{
    switch (keysym->sym)
	{
		case SDLK_ESCAPE:
		{
			// ESC key was pressed
			Quit(0);
			break;
		}
		case SDLK_F1:
		{
			// F1 key was pressed
		    // this toggles fullscreen mode
		    // the flags to pass to SDL_SetVideoMode
			surface = SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,videoFlags^=SDL_FULLSCREEN);
			resizeWindow(SCREEN_WIDTH,SCREEN_HEIGHT);

			// Verify there is a surface
			if (!surface)
			{
				fprintf(stderr, "Video mode set failed: %s\n", SDL_GetError());
				Quit(1);
			}
			
			break;
		}
		default:
		{
		    break;
		}
	}

    return;
}

// function to load in bitmap as a GL texture
int LoadGLTextures()
{
	// Status indicator
	int Status = FALSE;

	// Create storage space for the texture
	SDL_Surface * TextureImage[1]; 

	// Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
	if ((TextureImage[0] = SDL_LoadBMP("square.bmp")))
    {

		// Set the status to true
		Status = TRUE;

		// Create The Texture
		glGenTextures(1, &texture[0]);

		// Typical Texture Generation Using Data From The Bitmap
		glBindTexture(GL_TEXTURE_2D, texture[0]);

		// Generate The Texture
		glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->w,
			  TextureImage[0]->h, 0, GL_RGB,
			  GL_UNSIGNED_BYTE, TextureImage[0]->pixels);

	    // Linear Filtering
	    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	}

    // Free up any memory we may have used
    if (TextureImage[0])
		SDL_FreeSurface(TextureImage[0]);

    return Status;
}

// general OpenGL initialization function
int initGL(GLvoid)
{
	/* Load in the texture */
    if (!LoadGLTextures())
	return FALSE;

    /* Enable Texture Mapping ( NEW ) */
    glEnable(GL_TEXTURE_2D);
    
	// Enable smooth shading
    glShadeModel(GL_SMOOTH);

    // Set the background black
    glClearColor(0.0f,0.0f,0.0f,0.0f);

    // Depth buffer setup
    glClearDepth(1.0f);

    // Enables depth testing
    glEnable(GL_DEPTH_TEST);

    // The type of depth test to do
    glDepthFunc(GL_LEQUAL);

    // Really nice perspective calculations
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

    return 1;
}

void drawQuad(GLfloat x, GLfloat y)
{
	glBegin(GL_QUADS);
		glTexCoord2f( 1.0f, 1.0f );glVertex3f(x,  y, 0.0);  // bottom right
		glTexCoord2f( 1.0f, 0.0f );glVertex3f(x,  y+2,0.0); // top right
		glTexCoord2f( 0.0f, 0.0f );glVertex3f(x-2,y+2,0.0); // top left
		glTexCoord2f( 0.0f, 1.0f );glVertex3f(x-2,y,  0.0); // bottom left
	glEnd();
}

// Here goes our drawing code
int drawGLScene(GLvoid)
{
    // These are to calculate our fps
    static GLint T0     = 0;
    static GLint Frames = 0;

    // Clear the screen and the depth buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

	// draw code goes here
	
	glTranslatef(0.0,0.0,-13.0);
	/* Select Our Texture */
    glBindTexture( GL_TEXTURE_2D, texture[0] );

	// row 1
	drawQuad(-1.0f,1.0);  // 0
	drawQuad( 1.0f,1.0);  // 1
	drawQuad( 3.0f,1.0);  // 2
	
	// row 2
	drawQuad(-1.0f,-1.0); // 3
	drawQuad(1.0f,-1.0);  // 4
	drawQuad(3.0f,-1.0);  // 5

	// row 2
	drawQuad(-1.0f,-3.0); // 6
	drawQuad(1.0f,-3.0);  // 7
	drawQuad(3.0f,-3.0);  // 8
	
    // Draw it to the screen
    SDL_GL_SwapBuffers();

    // Gather our frames per second
    Frames++;
    {
		GLint t = SDL_GetTicks();
		if (t - T0 >= 5000)
		{
		    GLfloat seconds = (t - T0) / float(1000.0);
		    GLfloat fps = Frames / seconds;
			printf("%d frames in %g seconds = %g FPS\n", Frames, seconds, fps);
		    T0 = t;
			Frames = 0;
		}
    }

    return 1;
}

Share this post


Link to post
Share on other sites
Advertisement
Ok, I think I figured out the problem: I changed the code:
glTexImage2D( GL_TEXTURE_2D, 0, 3, TextureImage[0]->w,
TextureImage[0]->h, 0, GL_BGR,
GL_UNSIGNED_BYTE, TextureImage[0]->pixels );



to
glTexImage2D( GL_TEXTURE_2D, 0, 3, TextureImage[0]->w,
TextureImage[0]->h, 0, GL_RGB,
GL_UNSIGNED_BYTE, TextureImage[0]->pixels )


I did this b/c it my compiler didn't recognize GL_BGR, but that caused it to invert the colors. I then changed it GL_RGB to GL_RGB_EXT and it now works fine, I just have one question. Is my app still portable or is GL_RGB_EXT a windows only constant? If so, is there a work around?

Share this post


Link to post
Share on other sites
use
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, TextureImage[0]->w,
TextureImage[0]->h, 0, GL_BGR,
GL_UNSIGNED_BYTE, TextureImage[0]->pixels )

and include this file somewhere glext.h (get from www.opengl.org)
use BGR not BGR_EXT, also use RGB not 3

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!