Elysian Shadows

Code: Select all

  surf = IMG_Load(filename);
   
  SDL_Color color;
  for (int y = 0; y < surf->h; y++)
  {
     for (int x = 0; x < surf->w; x++)
     {
          unsigned int pix = ((unsigned int*)surf->pixels)[y*(surf->pitch/sizeof(unsigned int)) + x];
          color =  translate_color(pix);
          if (color.r == 255 && color.b == 255)    
          {((unsigned int*)surf->pixels)[y*(surf->pitch/sizeof(unsigned int)) + x] = SDL_MapRGBA(surf->format, 0, 0, 0,0);}
      }
  }

Code: Select all

SDL_Color translate_color(Uint32 int_color)                           
{
    #if SDL_BYTEORDER == SDL_BIG_ENDIAN
        SDL_Color color={(int_color & 0x00ff0000)/0x10000,(int_color & 0x0000ff00)/0x100,(int_color & 0x000000ff),0};
    #else
        SDL_Color color={(int_color & 0x000000ff),(int_color & 0x0000ff00)/0x100,(int_color & 0x00ff0000)/0x10000,0};    
    #endif
    return color;
}

Code: Select all

SDL_Surface* surface = SDL_LoadBMP("blah.bmp");
SDL_SetColorKey(surface , SDL_SRCCOLORKEY, SDL_MapRGB(surface->format, 255, 0, 255);

int texID;
glGenTextures(1, &texID);
glBindTexture(GL_TEXTURE_2D, texID);
    
int width = surface->w;
int height = surface->h;
int bpp = surface->format->BitsPerPixel;

int mode = GL_RGB;

if(bpp == 32)
     mode = GL_RGBA;

glTexImage2D(GL_TEXTURE_2D, 0, mode, width, height, 0, mode, GL_UNSIGNED_BYTE, surface->pixels);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

Code: Select all

    glEnable (GL_BLEND);
    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Code: Select all

#ifndef IMAGE_H
#define IMAGE_H

#include <GLUT/glut.h>
#include <SDL/SDL.h>
#include <iostream>
using std::string;


class GLImage
{
private:
public:
    GLImage(void);
    ~GLImage(void);
    GLuint texture;
    GLuint width,height;
    string file;
};

bool GL_LoadImage(const char* file, GLImage& img, bool alpha=false);

#endif

Code: Select all

#include "Image.h"


GLImage::GLImage(void)
:texture(0),
width(0),
height(0)
{}

GLImage::~GLImage(void)
{
    glDeleteTextures( 1, &texture );
}

bool GL_LoadImage(const char* file, GLImage& img, bool alpha)
{
    SDL_Surface *tmp = NULL, *newImage = NULL;
    GLenum texture_format=0;
    tmp = SDL_LoadBMP(file);
    img.width = tmp->w;
    img.height = tmp->h;
    img.file = file;
    
    if (!tmp) {
	fprintf(stderr, "Error: '%s' could not be opened: %s\n", file, SDL_GetError());
	return false;
    }
    
    //get number of channels in the SDL surface, needed for OpenGL
    int nofcolors=tmp->format->BytesPerPixel;
    
    //contains an alpha channel
    /*if(nofcolors==4)
    {
	if(tmp->format->Rmask==0x000000ff)
	    texture_format=GL_RGBA;
	else
	    texture_format=GL_BGRA;
    }
    else*/ if(nofcolors==3) //no alpha channel
    {
	if(tmp->format->Rmask==0x000000ff)
	{
	    texture_format=GL_RGB;
	}
	else
	{
	    texture_format=GL_BGR;
	}
    }
    else
    {
	fprintf(stderr,"Error: '%s' could not be opened %d\n", file,nofcolors);
	SDL_FreeSurface(tmp);
	return false;
    }
    
    if (alpha)
    {
	// set the color key, works on BGR or RGB
	if(SDL_SetColorKey(tmp, SDL_SRCCOLORKEY | SDL_RLEACCEL, SDL_MapRGB(tmp->format, 255, 0, 255)) == -1)
	    fprintf(stderr, "Warning: colorkey will not be used, reason: %s\n", SDL_GetError());
    
	// create new image with alpha
	newImage = SDL_DisplayFormatAlpha(tmp);
    
	// make sure it was loaded correctly
	if(!newImage) 
	{	
	    fprintf(stderr, "Warning: Couldn't add alpha layer to %s, reason: %s\n", file, SDL_GetError());
	}
    }
    
    // Have OpenGL generate a texture object handle for us
    glGenTextures( 1, &img.texture );
    
    // Bind the texture
    glBindTexture( GL_TEXTURE_2D, img.texture );
    
    // Set the texture's stretching properties
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    
    
    // if not alpha or previous attempt at alpha failed
    if(!alpha || !newImage)
    {
	// load 24 bit image data
	glTexImage2D( GL_TEXTURE_2D, 0, 3, tmp->w, tmp->h, 0,
		 texture_format, GL_UNSIGNED_BYTE, tmp->pixels );
    }
    else 
    {
	// load 32 bit image data
	glTexImage2D( GL_TEXTURE_2D, 0, 4, newImage->w, newImage->h, 0,
		     ++texture_format, GL_UNSIGNED_BYTE, newImage->pixels );
    }
    
    SDL_FreeSurface(newImage);
    SDL_FreeSurface(tmp);
    
    return true;
}

Code: Select all

    GLImage img;
    GL_LoadImage("Image.bmp",img,true);

Code: Select all

#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <SDL/SDL.h>
#include <iostream>