GLubyte ***texture; //this is a dynamically allocated 3d array containing pixel data of a .png image

//now i want to assign texture to glTexImage2D 
glTexImage2D(..., const GLvoid *texels); //which takes a const GLvoid * as a parameter

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

#include <GL/gl.h> //you have to install the glut and opengl libraries
#include <GL/glut.h>

#include "texture.h"

Texture *texture[2]; //is defined in the texture.h file below
static GLuint texnames[2]; 

void init(void); 
void reshape(int w, int h);
void keyboard(unsigned char key, int x, int y);
void display(void);
int init_game(void); 

int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); 
	glutInitWindowSize(1024, 768);
	glutCreateWindow("Test");
	glutFullScreen();
	init();
	glutDisplayFunc(display);
	glutKeyboardFunc(keyboard);
	glutReshapeFunc(reshape);
	init_game();
	glutMainLoop();
	return 0; 
}

void init(void)
{ 
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glShadeModel(GL_FLAT);
	glEnable(GL_DEPTH_TEST);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	glEnable(GL_TEXTURE_2D);
}

int init_game()
{
	if((texture[0] = load_tex_img("<your image>.png")) == NULL){
		fprintf(stderr, "init_game: failed to load texture image\n");
		return 0;
	}
	
	if((texture[1] = load_tex_img("<your image>.png")) == NULL){
		fprintf(stderr, "init_game: failed to load texture image\n");
	}

	glGenTextures(2, texnames);
	
	texture[0]->x = 0.0f; //texture coordinates ... not really necessary ..
	texture[0]->y = 0.0f;
	texture[0]->w = 1.0f;
	texture[0]->h = 1.0f; 
	
	texture[1]->x = 0.0f; 
	texture[1]->y = 0.0f; 
	texture[1]->w = 1.0f; 
	texture[1]->h = 1.0f;
	
	glBindTexture(GL_TEXTURE_2D, texnames[0]);   //texture binds
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); 
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture[0]->height, texture[0]->width, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture[0]->img); 
	
	glBindTexture(GL_TEXTURE_2D, texnames[1]);   
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); 
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture[1]->height, texture[1]->width, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture[1]->img); 
	
	return 1;
}

void display()
{
	glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
	
	glBindTexture(GL_TEXTURE_2D, texnames[0]);
	glBegin(GL_QUADS);
		glTexCoord2f(texture[0]->w, texture[0]->h); glVertex3f(0.25f, -0.25f, 0.0f);
		glTexCoord2f(texture[0]->w, texture[0]->y); glVertex3f(0.0f, -0.25f, 0.0f);
		glTexCoord2f(texture[0]->x, texture[0]->y); glVertex3f(0.0f, 0.0f, 0.0f);
		glTexCoord2f(texture[0]->x, texture[0]->h); glVertex3f(0.25f, 0.0f, 0.0f);
	glEnd();
	glBindTexture(GL_TEXTURE_2D, texnames[1]);	
	glBegin(GL_QUADS);
		glTexCoord2f(texture[1]->w, texture[1]->h); glVertex3f(0.0f, 0.0f, 0.0f);
		glTexCoord2f(texture[1]->w, texture[1]->y); glVertex3f(-1.0f, 0.0f, 0.0f);
		glTexCoord2f(texture[1]->x, texture[1]->y); glVertex3f(-1.0f, 1.0f, 0.0f);
		glTexCoord2f(texture[1]->x, texture[1]->h); glVertex3f(0.0f, 1.0f, 0.0f);
	glEnd();
	
	glutSwapBuffers(); 	//should show one image in the upper left corner and one in the center of the screen ... changing the vertex coordinates makes sense.
}

void reshape(int w, int h) //ordinary reshape function
{
	glViewport(0, 0, (GLsizei) w, (GLsizei) h);
	glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 30.0);	
	glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		glTranslatef(0.0, 0.0, -1.0);
}

void keyboard(unsigned char key, int x, int y) //ESC quits and return forces redraw.
{
	switch(key){
		case 0x20:
			glutPostRedisplay(); 
			break;
		case 0x1b:
			exit(3); //3 because of atexit for a function that frees the allocated memory.. not included yet .. :oops: 
			break; 
		default:
			break;
	}
}

//texture.c
#include <stdio.h>
#include <stdlib.h>

#include <GL/gl.h>
#include <GL/glut.h>

#include <png.h> //you need to install libpng before compiling.  

#include "texture.h" 

int check_texture_size(Texture *tex)
{
	int n;
	int w = 0, h = 0;
	
	for(n = MAXTEXTURESIZE; n >= 1; n /= 2){
		if(tex->width == n)
			w = n;	
		if(tex->height == n)
			h = n;
	}

	if(w && h)
		return 1; 
	else 
		return 0;
}

Texture *load_tex_img(char *filename) //returns a Texture with png pixel data
{
	Texture *tex; 
	FILE *png;
	png_bytep *row_pointers; //png functions will store the pixel data in row_pointers.

	int x, y, n = 0;
	int color_type;	
	
	tex = malloc(sizeof(Texture));

	png = fopen(filename, "rb"); //open the png file.
	if(!png){
		fprintf(stderr, "load_tex_img: failed to open %s\n", filename); 
		return NULL; 
	}	

	png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);    
	if (!png_ptr){
		fprintf(stderr, "load_tex_img: failed to initialize png_ptr\n");
		return NULL;
	} //init png_ptr. 

    	png_infop info_ptr = png_create_info_struct(png_ptr); //init info_ptr
    	if (!info_ptr)
    	{
        	png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
        	fprintf(stderr, "load_tex_img: failed to initialize info_ptr\n");
    		return NULL;
	}

    	png_infop end_info = png_create_info_struct(png_ptr);
    	if (!end_info)
    	{
        	png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
        	fprintf(stderr, "load_tex_img: failed to initialze end_info\n");
        	return NULL; 
	}
	png_init_io(png_ptr, png);
	
  	png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_PACKING, NULL);
	
	row_pointers = png_get_rows(png_ptr, info_ptr);  //read pixel data into row_pointers .. to understand this part you may have a look at the libpng manual.
	 
	tex->width = info_ptr->width; //dimensions of the png file
	tex->height = info_ptr->height; 
	
	color_type = info_ptr->color_type;
	if(color_type != PNG_COLOR_TYPE_RGB_ALPHA){
		fprintf(stderr, "has no non alpha image support yet ^^\n");
	        return NULL; //all your images need to have an alpha channel .. you can write code that supports images without alpha channel. for more informations on how to do this visit the libpng homepage and look for the manual.  
        } //
	
	if(!check_texture_size(tex)){ 
		fprintf(stderr, "load_tex_img: dimensions of texture image must be powers of 2\n");
		return NULL;
	} //opengl only takes file dimensions as powers of two ... 


	tex->img = (GLubyte*)malloc(tex->width * tex->height * 4 * sizeof(GLubyte)); //malloc space for the pixel data .. thanks dave. :) 
	
	for(x = 0; x < tex->width * 4; x += 4){
		for(y = 0; y < tex->height; y++){
			tex->img[n]   = row_pointers[y][x];
			tex->img[n+1] = row_pointers[y][x+1];
		        tex->img[n+2] = row_pointers[y][x+2];
		        tex->img[n+3] = row_pointers[y][x+3];
		        n += 4;
		}
	} //copy the data from row_pointers to tex. row pointers stores its data in this order: [y][x*4]; (in lines)  

	fclose(png); 	//closes the png file and frees the data
	png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); //frees the read_struct(png_ptr) 
	
	return tex; //returns the texture.  
}

#ifndef TEXTURE
#define TEXTURE

#include <stdio.h>
#include <stdlib.h>
#include <GL/gl.h>
#include <GL/glut.h>

#include <png.h>

#include "texture.h"

#define MAXTEXTURESIZE 1024 //don't now if this is needed .. if not just leave it away...
 
typedef struct { //the Texture struct
	GLubyte *img; 
	float x, y; //texture coords  
	float w, h;
	int width, height; //file dimensions
} Texture;

Texture *load_tex_img(char *filename); 
int check_texture_size(Texture *tex); 

#endif

#include <GL/gl.h>
#include <GL/glut.h>

#include <FL/gl.h>
#include <FL/glut.H>