glutil_gl2.cpp

   1 /* gltest - small OpenGL tearing test program
   2  * Copyright (C) 2012-2013 Ralf Jung <post@ralfj.de>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  */
  18
  19 #include "glutil.h"
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string>
  24 #include <sstream>
  25
  26 // extension functions we use
  27 typedef GLuint (*GLCREATESHADERPROC) (GLenum type);
  28 typedef void (*GLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
  29 typedef void (*GLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
  30 typedef void (*GLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
  31 typedef void (*GLCOMPILESHADERPROC) (GLuint shader);
  32 typedef GLuint (*GLCREATEPROGRAMPROC) (void);
  33 typedef void (*GLATTACHSHADERPROC) (GLuint program, GLuint shader);
  34 typedef void (*GLLINKPROGRAMPROC) (GLuint program);
  35 typedef GLint (*GLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name);
  36 typedef void (*GLUSEPROGRAMPROC) (GLuint program);
  37
  38 typedef void (*GLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
  39 typedef void (*GLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
  40 typedef void (*GLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
  41 typedef void (*GLBINDBUFFERPROC) (GLenum target, GLuint buffer);
  42 typedef void (*GLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
  43 typedef void (*GLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
  44
  45 #ifdef CON_GL3
  46 // VAOs are only supported in GL3+, and not needed in earler contexts
  47 typedef void (*GLBINDVERTEXARRAYPROC) (GLuint array);
  48 typedef void (*GLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint *arrays);
  49 typedef void (*GLGENVERTEXARRAYSPROC) (GLsizei n, GLuint *arrays);
  50 #endif
  51
  52 GLGETSHADERIVPROC p_glGetShaderiv = NULL;
  53 GLGETSHADERINFOLOGPROC p_glGetShaderInfoLog = NULL;
  54 GLCREATESHADERPROC p_glCreateShader = NULL;
  55 GLSHADERSOURCEPROC p_glShaderSource = NULL;
  56 GLCOMPILESHADERPROC p_glCompileShader = NULL;
  57 GLCREATEPROGRAMPROC p_glCreateProgram = NULL;
  58 GLATTACHSHADERPROC p_glAttachShader = NULL;
  59 GLLINKPROGRAMPROC p_glLinkProgram = NULL;
  60 GLGETATTRIBLOCATIONPROC p_glGetAttribLocation = NULL;
  61 GLUSEPROGRAMPROC p_glUseProgram = NULL;
  62
  63 GLVERTEXATTRIBPOINTERPROC p_glVertexAttribPointer = NULL;
  64 GLENABLEVERTEXATTRIBARRAYPROC p_glEnableVertexAttribArray = NULL;
  65 GLGENBUFFERSPROC p_glGenBuffers = NULL;
  66 GLBINDBUFFERPROC p_glBindBuffer = NULL;
  67 GLBUFFERDATAPROC p_glBufferData = NULL;
  68 GLDELETEBUFFERSPROC p_glDeleteBuffers = NULL;
  69
  70 #ifdef CON_GL3
  71 GLBINDVERTEXARRAYPROC p_glBindVertexArray = NULL;
  72 GLDELETEVERTEXARRAYSPROC p_glDeleteVertexArrays = NULL;
  73 GLGENVERTEXARRAYSPROC p_glGenVertexArrays = NULL;
  74 #endif
  75
  76 // resolve function pointers
  77 static T_proc resolveFunctionPointer(T_glGetProcAddress p_glGetProcAddress, const char *name)
  78 {
  79         T_proc proc = p_glGetProcAddress(name);
  80         if (proc == NULL) {
  81                 die("Error resolvung function %s\n", name);
  82         }
  83         return proc;
  84 }
  85
  86 void resolveFunctionPointers(T_glGetProcAddress p_glGetProcAddress)
  87 {
  88 #ifdef CON_GL1
  89         // we need to check if we have GL 2.0 or greater
  90         std::string version = (char*)glGetString(GL_VERSION);
  91         std::stringstream ssv(version);
  92         std::string major;
  93         std::getline(ssv, major, '.');
  94         std::stringstream ssm(major);
  95         int majorVersion;
  96         ssm >> majorVersion;
  97         if (majorVersion < 2) {
  98                 die("Need at least GL 2.0 to function properly, but detected version %d\n", majorVersion);
  99         }
 100 #endif
 101
 102         // now get the function pointers
 103         p_glGetShaderiv = (GLGETSHADERIVPROC)resolveFunctionPointer(p_glGetProcAddress, "glGetShaderiv");
 104         p_glGetShaderInfoLog = (GLGETSHADERINFOLOGPROC)resolveFunctionPointer(p_glGetProcAddress, "glGetShaderInfoLog");
 105         p_glCreateShader = (GLCREATESHADERPROC)resolveFunctionPointer(p_glGetProcAddress, "glCreateShader");
 106         p_glShaderSource = (GLSHADERSOURCEPROC)resolveFunctionPointer(p_glGetProcAddress, "glShaderSource");
 107         p_glCompileShader = (GLCOMPILESHADERPROC)resolveFunctionPointer(p_glGetProcAddress, "glCompileShader");
 108         p_glCreateProgram = (GLCREATEPROGRAMPROC)resolveFunctionPointer(p_glGetProcAddress, "glCreateProgram");
 109         p_glAttachShader = (GLATTACHSHADERPROC)resolveFunctionPointer(p_glGetProcAddress, "glAttachShader");
 110         p_glLinkProgram = (GLLINKPROGRAMPROC)resolveFunctionPointer(p_glGetProcAddress, "glLinkProgram");
 111         p_glGetAttribLocation = (GLGETATTRIBLOCATIONPROC)resolveFunctionPointer(p_glGetProcAddress, "glGetAttribLocation");
 112
 113 #ifdef CON_GL3
 114         p_glBindVertexArray = (GLBINDVERTEXARRAYPROC)resolveFunctionPointer(p_glGetProcAddress, "glBindVertexArray");
 115         p_glDeleteVertexArrays = (GLDELETEVERTEXARRAYSPROC)resolveFunctionPointer(p_glGetProcAddress, "glDeleteVertexArrays");
 116         p_glGenVertexArrays = (GLGENVERTEXARRAYSPROC)resolveFunctionPointer(p_glGetProcAddress, "glGenVertexArrays");
 117 #endif
 118
 119         p_glUseProgram = (GLUSEPROGRAMPROC)resolveFunctionPointer(p_glGetProcAddress, "glUseProgram");
 120         p_glVertexAttribPointer = (GLVERTEXATTRIBPOINTERPROC)resolveFunctionPointer(p_glGetProcAddress, "glVertexAttribPointer");
 121         p_glEnableVertexAttribArray = (GLENABLEVERTEXATTRIBARRAYPROC)resolveFunctionPointer(p_glGetProcAddress, "glEnableVertexAttribArray");
 122         p_glGenBuffers = (GLGENBUFFERSPROC)resolveFunctionPointer(p_glGetProcAddress, "glGenBuffers");
 123         p_glBindBuffer = (GLBINDBUFFERPROC)resolveFunctionPointer(p_glGetProcAddress, "glBindBuffer");
 124         p_glBufferData = (GLBUFFERDATAPROC)resolveFunctionPointer(p_glGetProcAddress, "glBufferData");
 125         p_glDeleteBuffers = (GLDELETEBUFFERSPROC)resolveFunctionPointer(p_glGetProcAddress, "glDeleteBuffers");
 126 }
 127
 128 // shaders
 129 static const char *vertex_shader_source =
 130 "#version 100 \n\
 131 attribute vec2 position; \n\
 132 attribute vec3 color; \n\
 133 varying vec3 frag_color; \n\
 134 void main() \n\
 135 { \n\
 136         frag_color = color; \n\
 137         gl_Position = vec4(position * vec2(2) - vec2(1), 0.0, 1.0); \n\
 138 }";
 139 static const char *fragment_shader_source =
 140 "#version 100 \n\
 141 varying vec3 frag_color; \n\
 142 void main(void) \n\
 143 { \n\
 144         gl_FragColor = vec4(frag_color, 1.0); \n\
 145 }";
 146
 147
 148 // OpenGL IDs (yeah, this is a bad hack... do we care?)
 149 static GLuint program;
 150 static struct {
 151         GLint position;
 152         GLint color;
 153 } attributes;
 154
 155 // some local hlper functions
 156 static void show_info_log(GLuint object)
 157 {
 158         GLint log_length;
 159         p_glGetShaderiv(object, GL_INFO_LOG_LENGTH, &log_length);
 160         char *log = new char[log_length];
 161         p_glGetShaderInfoLog(object, log_length, NULL, log);
 162         fprintf(stderr, "%s", log);
 163         delete[] log;
 164 }
 165
 166 static GLuint compile_shader(GLenum shader_type, const char *source)
 167 {
 168         GLuint shader = p_glCreateShader(shader_type);
 169         p_glShaderSource(shader, 1, &source, NULL);
 170         p_glCompileShader(shader);
 171         GLint shader_ok;
 172         p_glGetShaderiv(shader, GL_COMPILE_STATUS, &shader_ok);
 173         if (!shader_ok) {
 174                 fprintf(stderr, "Failed to compile shader\n");
 175                 show_info_log(shader);
 176                 exit(1);
 177         }
 178         checkGlError("Compiling shader");
 179         return shader;
 180 }
 181
 182 static GLuint createArrayBuffer(GLsizeiptr size, GLfloat *data)
 183 {
 184         GLuint buffer;
 185         p_glGenBuffers(1, &buffer);
 186         p_glBindBuffer(GL_ARRAY_BUFFER, buffer);
 187         p_glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW);
 188         checkGlError("Creating array buffer");
 189         return buffer;
 190 }
 191
 192 // initialisation
 193 void initialise2dProjection()
 194 {
 195         GLuint vertex_shader = compile_shader(GL_VERTEX_SHADER, vertex_shader_source);
 196         GLuint fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_shader_source);
 197         program = p_glCreateProgram();
 198         p_glAttachShader(program, vertex_shader);
 199         p_glAttachShader(program, fragment_shader);
 200         p_glLinkProgram(program);
 201         attributes.position = p_glGetAttribLocation(program, "position");
 202         attributes.color = p_glGetAttribLocation(program, "color");
 203 }
 204
 205 // draw a quad
 206 void drawQuad(GLfloat red, GLfloat green, GLfloat blue, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 207 {
 208         p_glUseProgram(program);
 209         checkGlError("Enabling the shaders");
 210
 211 #ifdef CON_GL3
 212         // create a vertex array obect and use it
 213         GLuint vao;
 214         p_glGenVertexArrays(1, &vao);
 215         p_glBindVertexArray(vao);
 216         checkGlError("Creating a VAO");
 217 #endif
 218
 219         // send vertex data to card with given attribute
 220         GLfloat vertex_buffer_data[] = {
 221                 x1, y1,
 222                 x2, y1,
 223                 x2, y2,
 224                 x1, y2,
 225         };
 226         GLuint vertex_buffer = createArrayBuffer(sizeof(vertex_buffer_data), vertex_buffer_data);
 227         p_glVertexAttribPointer(
 228                 attributes.position,              /* attribute */
 229                 2,                                /* size */
 230                 GL_FLOAT,                         /* type */
 231                 GL_FALSE,                         /* normalized? */
 232                 0,                                /* stride */
 233                 (void*)0                          /* array buffer offset */
 234         );
 235         checkGlError("Preparing vertex data");
 236         p_glEnableVertexAttribArray(attributes.position);
 237         checkGlError("Sending vertex data");
 238
 239         // same with color data
 240         GLfloat color_buffer_data[] = {
 241                 red, green, blue,
 242                 red, green, blue,
 243                 red, green, blue,
 244                 red, green, blue,
 245         };
 246         GLuint color_buffer = createArrayBuffer(sizeof(color_buffer_data), color_buffer_data);
 247         p_glVertexAttribPointer(
 248                 attributes.color,              /* attribute */
 249                 3,                             /* size */
 250                 GL_FLOAT,                      /* type */
 251                 GL_FALSE,                      /* normalized? */
 252                 0,                             /* stride */
 253                 (void*)0                       /* array buffer offset */
 254         );
 255         checkGlError("Preparing color data");
 256         p_glEnableVertexAttribArray(attributes.color);
 257         checkGlError("Sending color data");
 258
 259         // draw
 260         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 261         checkGlError("Drawing");
 262
 263         // cleanup
 264         p_glDeleteBuffers(1, &vertex_buffer);
 265         p_glDeleteBuffers(1, &color_buffer);
 266 #ifdef CON_GL3
 267         p_glDeleteVertexArrays(1, &vao);
 268 #endif
 269         checkGlError("Doing cleanup");
 270 }