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                 fprintf(stderr, "Error resolvung function %s\n", name);
  82                 exit(1);
  83         }
  84         return proc;
  85 }
  86
  87 void resolveFunctionPointers(T_glGetProcAddress p_glGetProcAddress)
  88 {
  89 #ifdef CON_GL1
  90         // we need to check if we have GL 2.0 or greater
  91         std::string version = (char*)glGetString(GL_VERSION);
  92         std::stringstream ssv(version);
  93         std::string major;
  94         std::getline(ssv, major, '.');
  95         std::stringstream ssm(major);
  96         int majorVersion;
  97         ssm >> majorVersion;
  98         if (majorVersion < 2) {
  99                 fprintf(stderr, "Need at least GL 2.0 to function properly, but detected version %d\n", majorVersion);
 100                 exit(1);
 101         }
 102 #endif
 103
 104         // now get the function pointers
 105         p_glGetShaderiv = (GLGETSHADERIVPROC)resolveFunctionPointer(p_glGetProcAddress, "glGetShaderiv");
 106         p_glGetShaderInfoLog = (GLGETSHADERINFOLOGPROC)resolveFunctionPointer(p_glGetProcAddress, "glGetShaderInfoLog");
 107         p_glCreateShader = (GLCREATESHADERPROC)resolveFunctionPointer(p_glGetProcAddress, "glCreateShader");
 108         p_glShaderSource = (GLSHADERSOURCEPROC)resolveFunctionPointer(p_glGetProcAddress, "glShaderSource");
 109         p_glCompileShader = (GLCOMPILESHADERPROC)resolveFunctionPointer(p_glGetProcAddress, "glCompileShader");
 110         p_glCreateProgram = (GLCREATEPROGRAMPROC)resolveFunctionPointer(p_glGetProcAddress, "glCreateProgram");
 111         p_glAttachShader = (GLATTACHSHADERPROC)resolveFunctionPointer(p_glGetProcAddress, "glAttachShader");
 112         p_glLinkProgram = (GLLINKPROGRAMPROC)resolveFunctionPointer(p_glGetProcAddress, "glLinkProgram");
 113         p_glGetAttribLocation = (GLGETATTRIBLOCATIONPROC)resolveFunctionPointer(p_glGetProcAddress, "glGetAttribLocation");
 114
 115 #ifdef CON_GL3
 116         p_glBindVertexArray = (GLBINDVERTEXARRAYPROC)resolveFunctionPointer(p_glGetProcAddress, "glBindVertexArray");
 117         p_glDeleteVertexArrays = (GLDELETEVERTEXARRAYSPROC)resolveFunctionPointer(p_glGetProcAddress, "glDeleteVertexArrays");
 118         p_glGenVertexArrays = (GLGENVERTEXARRAYSPROC)resolveFunctionPointer(p_glGetProcAddress, "glGenVertexArrays");
 119 #endif
 120
 121         p_glUseProgram = (GLUSEPROGRAMPROC)resolveFunctionPointer(p_glGetProcAddress, "glUseProgram");
 122         p_glVertexAttribPointer = (GLVERTEXATTRIBPOINTERPROC)resolveFunctionPointer(p_glGetProcAddress, "glVertexAttribPointer");
 123         p_glEnableVertexAttribArray = (GLENABLEVERTEXATTRIBARRAYPROC)resolveFunctionPointer(p_glGetProcAddress, "glEnableVertexAttribArray");
 124         p_glGenBuffers = (GLGENBUFFERSPROC)resolveFunctionPointer(p_glGetProcAddress, "glGenBuffers");
 125         p_glBindBuffer = (GLBINDBUFFERPROC)resolveFunctionPointer(p_glGetProcAddress, "glBindBuffer");
 126         p_glBufferData = (GLBUFFERDATAPROC)resolveFunctionPointer(p_glGetProcAddress, "glBufferData");
 127         p_glDeleteBuffers = (GLDELETEBUFFERSPROC)resolveFunctionPointer(p_glGetProcAddress, "glDeleteBuffers");
 128 }
 129
 130 // shaders
 131 static const char *vertex_shader_source =
 132 "#version 100 \n\
 133 attribute vec2 position; \n\
 134 attribute vec3 color; \n\
 135 varying vec3 frag_color; \n\
 136 void main() \n\
 137 { \n\
 138         frag_color = color; \n\
 139         gl_Position = vec4(position * vec2(2) - vec2(1), 0.0, 1.0); \n\
 140 }";
 141 static const char *fragment_shader_source =
 142 "#version 100 \n\
 143 varying vec3 frag_color; \n\
 144 void main(void) \n\
 145 { \n\
 146         gl_FragColor = vec4(frag_color, 1.0); \n\
 147 }";
 148
 149
 150 // OpenGL IDs (yeah, this is a bad hack... do we care?)
 151 static GLuint program;
 152 static struct {
 153         GLint position;
 154         GLint color;
 155 } attributes;
 156
 157 // some local hlper functions
 158 static void show_info_log(GLuint object)
 159 {
 160         GLint log_length;
 161         p_glGetShaderiv(object, GL_INFO_LOG_LENGTH, &log_length);
 162         char *log = new char[log_length];
 163         p_glGetShaderInfoLog(object, log_length, NULL, log);
 164         fprintf(stderr, "%s", log);
 165         delete[] log;
 166 }
 167
 168 static GLuint compile_shader(GLenum shader_type, const char *source)
 169 {
 170         GLuint shader = p_glCreateShader(shader_type);
 171         p_glShaderSource(shader, 1, &source, NULL);
 172         p_glCompileShader(shader);
 173         GLint shader_ok;
 174         p_glGetShaderiv(shader, GL_COMPILE_STATUS, &shader_ok);
 175         if (!shader_ok) {
 176                 fprintf(stderr, "Failed to compile shader\n");
 177                 show_info_log(shader);
 178                 exit(1);
 179         }
 180         checkGlError("Compiling shader");
 181         return shader;
 182 }
 183
 184 static GLuint createArrayBuffer(GLsizeiptr size, GLfloat *data)
 185 {
 186         GLuint buffer;
 187         p_glGenBuffers(1, &buffer);
 188         p_glBindBuffer(GL_ARRAY_BUFFER, buffer);
 189         p_glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW);
 190         checkGlError("Creating array buffer");
 191         return buffer;
 192 }
 193
 194 // initialisation
 195 void initialise2dProjection()
 196 {
 197         GLuint vertex_shader = compile_shader(GL_VERTEX_SHADER, vertex_shader_source);
 198         GLuint fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_shader_source);
 199         program = p_glCreateProgram();
 200         p_glAttachShader(program, vertex_shader);
 201         p_glAttachShader(program, fragment_shader);
 202         p_glLinkProgram(program);
 203         attributes.position = p_glGetAttribLocation(program, "position");
 204         attributes.color = p_glGetAttribLocation(program, "color");
 205 }
 206
 207 // draw a quad
 208 void drawQuad(GLfloat red, GLfloat green, GLfloat blue, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 209 {
 210         p_glUseProgram(program);
 211         checkGlError("Enabling the shaders");
 212
 213 #ifdef CON_GL3
 214         // create a vertex array obect and use it
 215         GLuint vao;
 216         p_glGenVertexArrays(1, &vao);
 217         p_glBindVertexArray(vao);
 218         checkGlError("Creating a VAO");
 219 #endif
 220
 221         // send vertex data to card with given attribute
 222         GLfloat vertex_buffer_data[] = {
 223                 x1, y1,
 224                 x2, y1,
 225                 x2, y2,
 226                 x1, y2,
 227         };
 228         GLuint vertex_buffer = createArrayBuffer(sizeof(vertex_buffer_data), vertex_buffer_data);
 229         p_glVertexAttribPointer(
 230                 attributes.position,              /* attribute */
 231                 2,                                /* size */
 232                 GL_FLOAT,                         /* type */
 233                 GL_FALSE,                         /* normalized? */
 234                 0,                                /* stride */
 235                 (void*)0                          /* array buffer offset */
 236         );
 237         checkGlError("Preparing vertex data");
 238         p_glEnableVertexAttribArray(attributes.position);
 239         checkGlError("Sending vertex data");
 240
 241         // same with color data
 242         GLfloat color_buffer_data[] = {
 243                 red, green, blue,
 244                 red, green, blue,
 245                 red, green, blue,
 246                 red, green, blue,
 247         };
 248         GLuint color_buffer = createArrayBuffer(sizeof(color_buffer_data), color_buffer_data);
 249         p_glVertexAttribPointer(
 250                 attributes.color,              /* attribute */
 251                 3,                             /* size */
 252                 GL_FLOAT,                      /* type */
 253                 GL_FALSE,                      /* normalized? */
 254                 0,                             /* stride */
 255                 (void*)0                       /* array buffer offset */
 256         );
 257         checkGlError("Preparing color data");
 258         p_glEnableVertexAttribArray(attributes.color);
 259         checkGlError("Sending color data");
 260
 261         // draw
 262         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 263         checkGlError("Drawing");
 264
 265         // cleanup
 266         p_glDeleteBuffers(1, &vertex_buffer);
 267         p_glDeleteBuffers(1, &color_buffer);
 268 #ifdef CON_GL3
 269         p_glDeleteVertexArrays(1, &vao);
 270 #endif
 271         checkGlError("Doing cleanup");
 272 }