1
2
3
4
5
6
7

void main(void)
{
	vec4 v = vec4(gl_Vertex);		
	v.z = 0.0;
 
	gl_Position = gl_ModelViewProjectionMatrix * v;
} 

1
2
3
4
5

void main()
{
	gl_FragColor = vec4(0.8,0.4,0.8,1.0);
}
 

1
2
3
4
5

// Definimos identificadores para el programa,
// el vertex shader y el fragment shader.
// El programa se compone de un vertex shader
// y un fragment shader.
GLuint po, vs, fs;

1
2
3
4

// Funcion para cargar los shaders. Los
// parametros son los ficheros acargar.
void CargaShader(char *v, char *f)
{

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Puntero para crear espacio en memoria
// para cargar el shader
GLchar **lineas;
// Cadena para guardar los mensajes de
// compilacion y linkaje.
char temp[1000];
// Indice 
int i;
// Otro indice
int	 i1=0;
// Creo un fichero de texto en disco para
// escribir cosas a modo de log.
std::fstream log;
log.open("log.txt",std::ios::out); 

1
2
3
4
5
6
7

// Creo un programa (vertex y fragment shaders) en
// vacio asociado al identificador.
po = glCreateProgram();
// Creo un vertex shader y lo asocio al identificador.
vs = glCreateShader(GL_VERTEX_SHADER);
// Creo un fragment shader y lo asocio al identificador.
fs = glCreateShader(GL_FRAGMENT_SHADER);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// Abro el fichero del vertex shader para lectura
std::fstream fichero;
fichero.open(v, std::ios::in );
// Recorro el fichero hasta el final contando las lineas.
while( !fichero.eof() )
	{
	fichero.getline(temp,300);
	i1++;
	}
// Me posiciono de nuevo al principio del fichero.
fichero.clear();
fichero.seekg(0L, std::ios::beg);	  
// Reservo espacio para los punteros a cada linea.
// En i1 esta el numero de lineas del shader.
lineas = new GLchar *[i1];
// Voy reservando espacio para cada linea,
// leo la linea y la cargo en el espacio reservado 
// y tambien escribo la linea en el fichero de log 
// (esto es porque me apetece comprobar que se carga bien
// pero no es necesario)
for(i=0;i<i1;i++)
	{
	// Reservo
	lineas[i]=new GLchar[300];
	// Leo la linea
	fichero.getline(lineas[i],300);
	// Escribo en la log.
	log<<lineas[i]<<"\n";
	}
// Una vez leido el fichero lo cierro.
fichero.close();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Cargo el shader leido desde disco, desde la 
// memoria donde lo tengo al vertex shader que
// habiamos creado.
// Parametros: 
//   1-Identificativo del shader de OpenGL.
//	 2-Numero de lineas.
//   3-Puntero donde esta el programa a pasarle.
//   4-Puntero a una matriz con las longitudes de linea
//        ( si es NULL asume que terminan con '\0' )
glShaderSource(vs, i1, (const GLchar**)lineas, NULL);
// Compilo el shader.
glCompileShader(vs);
// Compruebo el resultado de la compilacion.
// Parametros:
//  1-Identificativo del shader.
//	2-Maxima longitud de la cadena donde guardamos la informacion
//	3-Direccion de una variable donde dejara la longitud de la
//	  informacion.
//	4-Puntero de la cadena donde dejar la informacion.
glGetShaderInfoLog(vs, 1000, NULL, temp); 
// Escribo la informacion de la compilacion en la log.
log<<"\n\n"<<temp<<"\n\n   --------\n";
// Libero el espacio de memoria donde habiamos guardado 
// el shader.
for(i=0;i<i1;i++) delete[] lineas[i];
delete[] lineas;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// Realizamos la misma operacion para el 
// fragment shader.
// Pongo i1 a 0 para cuando contemos lineas.
i1=0;
// Abro el fichero del shader.
fichero.open(f, std::ios::in );
// Me aseguro de que esta al principio.
fichero.clear();
fichero.seekg(0L, std::ios::beg);
// Cuento las lineas de codigo. 
while( !fichero.eof() ) 
	{
	fichero.getline(temp,300);
	i1++;
	}
// Me posiciono al principio
fichero.clear();
fichero.seekg(0L, std::ios::beg);
// Reservo espacio para los punteros a las lineas
// de codigo
lineas = new GLchar *[i1];
// Reservo espacio y leo las lineas mientras
// las escribo en la log tambien.
for(i=0;i<i1;i++)
	{
	lineas[i]=new GLchar[300];
	fichero.getline(lineas[i],300);
	log<<lineas[i]<<"\n";
	}
// Cierro el fichero
fichero.close();
// Cargo el codigo al shader de OpenGL
glShaderSource(fs, i1, (const GLchar**)lineas, NULL);
// Lo compilo
glCompileShader(fs);
// Recupero la informacion de compilacion y la 
// escribo en la log.
glGetShaderInfoLog(fs, 1000, NULL, temp); 
log<<"\n\n"<<temp<<"\n\n   --------\n";
// Libero la memoria reservada.
for(i=0;i<i1;i++) delete[] lineas[i];
delete[] lineas;

1
2
3
4
5
6
7
8
9
10
11
12
13

 // Asocio el vertex shader al programa
 glAttachShader(po,vs);
 // Asocio el fragment shader al programa 
 glAttachShader(po,fs);
 // Linko el programa.
 glLinkProgram(po);
 // Compruebo la informacion de linkaje y 
 // la escribo en la log.
 glGetProgramInfoLog(po, 1000, NULL, temp);
 log<<"\n\n"<<temp;
 // Cierro el fichero de log
 log.close();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Esta es la manera de intentar definir todo lo extra 
// de la version que se quiere usar.
// Si retorna true es que la tarjeta soporta la version
// y a partir de aqui ya se pueden usar las funcionalidades 
// de la version normalmente. Si retorna false es que la 
// version no es soportada.
if (!GLEE_VERSION_2_0)
{
	// Si no se soporta mandamos un mansaje...
	MessageBoxA(NULL, "OpenGL 2.0 NO soportada", "USW", MB_OK);
	// ... salimos del programa y no hacemos mas.
	PostMessage(IdVentana, WM_CLOSE, 0, 0); 
	return;
}

1
2
3

// LLamamos a nuestra funcion para cargar shaders de disco.
// Dejara los shaders listos para ser usados cuando queramos.
CargaShader("dibus//flat.vert","dibus//flat.frag");

1
2
3
4
5
6
7
8
9
10

// Indicamos a OpenGL que use nuestro programa
// para pintar en vez de el standard de OpenGL 
// ( la "fixed functionality")
glUseProgram(po);
// Pinto el objeto que sea.
PintaModelo();
// Indico que use la "fixed functionality" de nuevo.
// Llamo a la funcion con 0 en vez de el identificador
// valido de programa.
glUseProgram(0);