68a789b661ce65d8af5cc410482729c1700938d0
[gltest.git] / 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 }