[Mesa3d-dev] OpenGL 3 Hello world

[Gonsolo <go...@gm...>]

Since I couldn't find a decent hello world program in the internet I
decided to write one. It's 256 lines long and written with QT and
OpenGL. If you have suggestions for improvement/simplification please
email me.
Could this be included in Mesa or mesa-demos?

# README
OpenGL3 Hello world.

To build and run: "qmake && make test"

# ogl.pro
TARGET = ogl
SOURCES = ogl.cc oglwidget.cc
HEADERS = oglwidget.h

QT = core gui opengl
LIBS += -lGLEW -L.

test.commands = ./ogl
test.depends = ogl
t.depends = test
edit.commands = vi oglwidget.cc
e.depends = edit

QMAKE_EXTRA_TARGETS = e edit t test

# ogl.cc
#include <QApplication>
#include "oglwidget.h"

int main( int argc, char** argv )
{
	QApplication app( argc, argv );

	OGLWidget w;
	w.show();

	return app.exec();
}

# oglwidget.h
#ifndef OPENGLWIDGET_H
#define OPENGLWIDGET_H

#include <QtOpenGL>

class OGLWidget : public QGLWidget
{
	Q_OBJECT

	public:
		OGLWidget( QGLWidget* parent = 0 );
		~OGLWidget();

		void query();

	protected:
		void keyPressEvent( QKeyEvent* event );
		void initializeGL();
		void paintGL();

	private slots:
		void animate();
};

#endif

# oglwidget.cc
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <iterator>
#include <GL/glew.h>
#include <QtCore/qtimer.h>
#include <QtGui/qpainter.h>
#include <QTime>
#include "oglwidget.h"

inline const GLubyte *BUFFER_OFFSET( size_t bytes )
{
    return reinterpret_cast<const GLubyte *>(0) + bytes;
}

struct Quad {
	struct Vertex {
		GLfloat pos[2];
		GLfloat texcoord[2];
	};
	GLushort indices[4];
	Vertex vertices[4];

	GLuint vertex_array;
	GLuint index_buffer;
	GLuint vertex_buffer;

	GLuint shader_program;
};

Quad quad;
GLfloat projection_matrix[16];
GLfloat view_matrix[16];
GLfloat model_matrix[16];

OGLWidget::OGLWidget( QGLWidget* parent ) : QGLWidget( parent )
{
	resize( 400, 400 );
	setFocusPolicy( Qt::StrongFocus );

	QTimer* timer = new QTimer( this );
	connect( timer, SIGNAL( timeout() ), this, SLOT( animate() ) );
	timer->start( 50 );
}


OGLWidget::~OGLWidget() {}

void OGLWidget::animate() {
	updateGL();
}

void OGLWidget::keyPressEvent( QKeyEvent* event )
{
	if( event->key() == Qt::Key_Escape )
		close();	
}

void OGLWidget::initializeGL()
{
	if( glewInit() != GLEW_OK )
		std::cerr << "Can't initialize glew!\n";
	if ( ! GLEW_VERSION_3_0 ) {
     		std::cerr << "OpenGL version 3 is not supported!\n";
		exit( EXIT_FAILURE );
	}

	// Shaders
	GLuint vertex_shader = glCreateShader( GL_VERTEX_SHADER );
	std::string vertex_string( std::istreambuf_iterator<char>(
std::ifstream( "ogl.vert" ).rdbuf() ),
std::istreambuf_iterator<char>() );
	const GLchar* vertex_source = reinterpret_cast<const GLchar*>(
vertex_string.c_str() );
	glShaderSource( vertex_shader, 1, & vertex_source, 0 );
	glCompileShader( vertex_shader );
	GLint compiled  = 0;
	glGetShaderiv( vertex_shader, GL_COMPILE_STATUS, & compiled );
	if( ! compiled )
		std::cerr << "Compilation of vertex shader failed!\n";

	GLuint fragment_shader = glCreateShader( GL_FRAGMENT_SHADER );
	std::string fragment_string( std::istreambuf_iterator<char>(
std::ifstream( "ogl.frag" ).rdbuf() ),
std::istreambuf_iterator<char>() );
	const GLchar* fragment_source = reinterpret_cast<const GLchar*>(
fragment_string.c_str() );
	glShaderSource( fragment_shader, 1, & fragment_source, 0 );
	glCompileShader( fragment_shader );
	glGetShaderiv( fragment_shader, GL_COMPILE_STATUS, & compiled );
	if( ! compiled )
		std::cerr << "Compilation of fragment shader failed!\n";

	quad.shader_program = glCreateProgram();
	glAttachShader( quad.shader_program, vertex_shader );
	glAttachShader( quad.shader_program, fragment_shader );
	glLinkProgram( quad.shader_program );
	GLint linked;
	glGetProgramiv( quad.shader_program, GL_LINK_STATUS, & linked );	
	glDeleteShader( vertex_shader );
	glDeleteShader( fragment_shader );
	if( ! linked )
		std::cerr << "Linking failed!\n";	

	// Geometry
	GLfloat size = 100;
	quad.vertices[0].pos[0] = -size;
	quad.vertices[0].pos[1] = +size;
	quad.vertices[1].pos[0] = -size;
	quad.vertices[1].pos[1] = -size;
	quad.vertices[2].pos[0] = +size;
	quad.vertices[2].pos[1] = +size;
	quad.vertices[3].pos[0] = +size;
	quad.vertices[3].pos[1] = -size;

	quad.indices[0] = 0;
	quad.indices[1] = 1;
	quad.indices[2] = 2;
	quad.indices[3] = 3;

	glGenVertexArrays( 1, & quad.vertex_array );	
	glBindVertexArray( quad.vertex_array );

	glGenBuffers( 1, & quad.index_buffer );
	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, quad.index_buffer );
	glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( quad.indices ),
quad.indices, GL_STATIC_DRAW );

	glGenBuffers( 1, & quad.vertex_buffer );
	glBindBuffer( GL_ARRAY_BUFFER, quad.vertex_buffer );
	glBufferData( GL_ARRAY_BUFFER, sizeof( quad.vertices ),
quad.vertices, GL_STATIC_DRAW );

	glVertexAttribPointer( glGetAttribLocation( quad.shader_program,
"Position" ), 2, GL_FLOAT, GL_FALSE, sizeof( Quad::Vertex ),
BUFFER_OFFSET( 0 ) );
	glEnableVertexAttribArray( glGetAttribLocation( quad.shader_program,
"Position" ) );

	// Matrices
	projection_matrix[ 0] = 1; projection_matrix[ 1] = 0;
projection_matrix[ 2] = 0; projection_matrix[ 3] = 0;
	projection_matrix[ 4] = 0; projection_matrix[ 5] = 1;
projection_matrix[ 6] = 0; projection_matrix[ 7] = 0;
	projection_matrix[ 8] = 0; projection_matrix[ 9] = 0;
projection_matrix[10] = 1; projection_matrix[11] = 0;
	projection_matrix[12] = 0; projection_matrix[13] = 0;
projection_matrix[14] = 0; projection_matrix[15] = 1;

	view_matrix[ 0] = 1; view_matrix[ 1] = 0; view_matrix[ 2] = 0;
view_matrix[ 3] = 0;
	view_matrix[ 4] = 0; view_matrix[ 5] = 1; view_matrix[ 6] = 0;
view_matrix[ 7] = 0;
	view_matrix[ 8] = 0; view_matrix[ 9] = 0; view_matrix[10] = 1;
view_matrix[11] = 0;
	view_matrix[12] = 0; view_matrix[13] = 0; view_matrix[14] = 0;
view_matrix[15] = 1;

	model_matrix[ 0] = 1; model_matrix[ 1] = 0; model_matrix[ 2] = 0;
model_matrix[ 3] = 0;
	model_matrix[ 4] = 0; model_matrix[ 5] = 1; model_matrix[ 6] = 0;
model_matrix[ 7] = 0;
	model_matrix[ 8] = 0; model_matrix[ 9] = 0; model_matrix[10] = 1;
model_matrix[11] = 0;
	model_matrix[12] = 0; model_matrix[13] = 0; model_matrix[14] = 0;
model_matrix[15] = 1;
}

void OGLWidget::paintGL()
{
	// ortho2d
	GLfloat left = 0;
	GLfloat right = 400;
	GLfloat bottom = 0;
	GLfloat top = 400;
	const GLfloat near_val = -1.0f;
	const GLfloat far_val = 1.0f;
	GLfloat tx = -(right + left) / (right - left);
	GLfloat ty = -(top + bottom) / (top - bottom);
	GLfloat tz = -(far_val + near_val) / (far_val - near_val);	

	projection_matrix[ 0] = 2.0 / ( right-left ); projection_matrix[ 1] =
0; projection_matrix[ 2] = 0; projection_matrix[ 3] = 0;
	projection_matrix[ 4] = 0; projection_matrix[ 5] = 2.0 / ( top-bottom
); projection_matrix[ 6] = 0; projection_matrix[ 7] = 0;
	projection_matrix[ 8] = 0; projection_matrix[ 9] = 0;
projection_matrix[10] = -2.0 / ( far_val-near_val );
projection_matrix[11] = 0;
	projection_matrix[12] = tx; projection_matrix[13] = ty;
projection_matrix[14] = tz; projection_matrix[15] = 1;

	model_matrix[ 0] = 1; model_matrix[ 1] = 0; model_matrix[ 2] = 0;
model_matrix[ 3] = 0;
	model_matrix[ 4] = 0; model_matrix[ 5] = 1; model_matrix[ 6] = 0;
model_matrix[ 7] = 0;
	model_matrix[ 8] = 0; model_matrix[ 9] = 0; model_matrix[10] = 1;
model_matrix[11] = 0;
	model_matrix[12] = 200; model_matrix[13] = 200; model_matrix[14] = 0;
model_matrix[15] = 1;

	glViewport( 0, 0, 400, 400 );
	glClearColor( 0.0, 0.0, 0.0, 1.0 );
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	glUseProgram( quad.shader_program );

	glUniformMatrix4fv( glGetUniformLocation( quad.shader_program,
"ProjectionMatrix" ), 1, GL_FALSE, projection_matrix );
	glUniformMatrix4fv( glGetUniformLocation( quad.shader_program,
"ViewMatrix" ), 1, GL_FALSE, view_matrix );
	glUniformMatrix4fv( glGetUniformLocation( quad.shader_program,
"ModelMatrix" ), 1, GL_FALSE, model_matrix );

	glBindVertexArray( quad.vertex_array );
	glDrawElements( GL_TRIANGLE_STRIP, sizeof( quad.indices ) / sizeof(
quad.indices[0] ), GL_UNSIGNED_SHORT, BUFFER_OFFSET(0) );
	glBindVertexArray( 0 );

	glUseProgram( 0 );

	int error = glGetError();
	if( error != GL_NO_ERROR )
		std::cerr << "Error: " << glGetError() << std::endl;
}

# ogl.vert
#version 130

precision highp float;

uniform mat4 ProjectionMatrix;
uniform mat4 ViewMatrix;
uniform mat4 ModelMatrix;

in vec2 Position;

void main()
{
    mat4 mvpMatrix = ProjectionMatrix * ViewMatrix * ModelMatrix;
    vec4 pos = vec4( Position.x, Position.y, 0.0, 1.0 );
    gl_Position = mvpMatrix * pos;
}

# ogl.frag
#version 130

precision highp float;

out vec4 fragcolor;

void main()
{
	fragcolor = vec4( 1, 1, 1, 1 );
}