src/static_gl_shader.c

   1 /*
   2  * GL - Graphics Layer
   3  *
   4  * Copyright (c) 2011-2012 David Herrmann <dh.herrmann@googlemail.com>
   5  * Copyright (c) 2011 University of Tuebingen
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining
   8  * a copy of this software and associated documentation files
   9  * (the "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sublicense, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  22  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27 /*
  28  * Shader API
  29  * This provides basic shader objects that are used to draw sprites and
  30  * textures.
  31  */
  32
  33 #define GL_GLEXT_PROTOTYPES
  34
  35 #include <errno.h>
  36 #include <GLES2/gl2.h>
  37 #include <GLES2/gl2ext.h>
  38 #include <stdbool.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include "shl_llog.h"
  42 #include "static_gl.h"
  43
  44 #define LLOG_SUBSYSTEM "gl_shader"
  45
  46 struct gl_shader {
  47         unsigned long ref;
  48         llog_submit_t llog;
  49
  50         GLuint program;
  51         GLuint vshader;
  52         GLuint fshader;
  53 };
  54
  55 /* Clear the GL error stack. The standard says that the error value is just a
  56  * single value and no list/stack. However, multiple error fields may be defined
  57  * and glGetError() returns only one of them until all are cleared. Hence, we
  58  * loop until no more errors are retrieved. */
  59 void gl_clear_error()
  60 {
  61         GLenum err;
  62
  63         do {
  64                 err = glGetError();
  65         } while (err != GL_NO_ERROR);
  66 }
  67
  68 const char *gl_err_to_str(GLenum err)
  69 {
  70         switch (err) {
  71         case GL_NO_ERROR:
  72                 return "<NO_ERROR>";
  73         case GL_INVALID_ENUM:
  74                 return "<INVALID_ENUM>";
  75         case GL_INVALID_VALUE:
  76                 return "<INVALID_VALUE>";
  77         case GL_INVALID_OPERATION:
  78                 return "<INVALID_OPERATION>";
  79 #ifdef GL_STACK_OVERFLOW
  80         case GL_STACK_OVERFLOW:
  81                 return "<STACK_OVERFLOW>";
  82 #endif
  83 #ifdef GL_STACK_UNDERFLOW
  84         case GL_STACK_UNDERFLOW:
  85                 return "<STACK_UNDERFLOW>";
  86 #endif
  87         case GL_OUT_OF_MEMORY:
  88                 return "<OUT_OF_MEMORY>";
  89         default:
  90                 return "<unknown>";
  91         }
  92 }
  93
  94 /* return true if there is a pending GL error */
  95 bool gl_has_error(struct gl_shader *shader)
  96 {
  97         GLenum err;
  98
  99         err = glGetError();
 100         if (err != GL_NO_ERROR) {
 101                 llog_error(shader, "GL error %d: %s", err, gl_err_to_str(err));
 102                 return true;
 103         }
 104
 105         return false;
 106 }
 107
 108 static int compile_shader(struct gl_shader *shader, GLenum type,
 109                           const char *source)
 110 {
 111         char msg[512];
 112         GLint status = 1;
 113         GLuint s;
 114
 115         s = glCreateShader(type);
 116         if (s == GL_NONE) {
 117                 llog_warning(shader, "cannot allocate GL shader");
 118                 return GL_NONE;
 119         }
 120
 121         glShaderSource(s, 1, &source, NULL);
 122         glCompileShader(s);
 123
 124         glGetShaderiv(s, GL_COMPILE_STATUS, &status);
 125         if (status == GL_FALSE) {
 126                 msg[0] = 0;
 127                 glGetShaderInfoLog(s, sizeof(msg), NULL, msg);
 128                 llog_warning(shader, "cannot compile shader: %s", msg);
 129                 return GL_NONE;
 130         }
 131
 132         return s;
 133 }
 134
 135 int gl_shader_new(struct gl_shader **out, const char *vert, const char *frag,
 136                   char **attr, size_t attr_count, llog_submit_t llog)
 137 {
 138         struct gl_shader *shader;
 139         int ret, i;
 140         char msg[512];
 141         GLint status = 1;
 142
 143         if (!out || !vert || !frag)
 144                 return -EINVAL;
 145
 146         shader = malloc(sizeof(*shader));
 147         if (!shader)
 148                 return -ENOMEM;
 149         memset(shader, 0, sizeof(*shader));
 150         shader->ref = 1;
 151         shader->llog = llog;
 152
 153         llog_debug(shader, "new shader");
 154
 155         shader->vshader = compile_shader(shader, GL_VERTEX_SHADER, vert);
 156         if (shader->vshader == GL_NONE) {
 157                 ret = -EFAULT;
 158                 goto err_free;
 159         }
 160
 161         shader->fshader = compile_shader(shader, GL_FRAGMENT_SHADER, frag);
 162         if (shader->fshader == GL_NONE) {
 163                 ret = -EFAULT;
 164                 goto err_vshader;
 165         }
 166
 167         shader->program = glCreateProgram();
 168         glAttachShader(shader->program, shader->vshader);
 169         glAttachShader(shader->program, shader->fshader);
 170
 171         for (i = 0; i < attr_count; ++i)
 172                 glBindAttribLocation(shader->program, i, attr[i]);
 173
 174         glLinkProgram(shader->program);
 175         glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
 176         if (status == GL_FALSE) {
 177                 msg[0] = 0;
 178                 glGetProgramInfoLog(shader->program, sizeof(msg), NULL, msg);
 179                 llog_warning(shader, "cannot link shader: %s", msg);
 180                 ret = -EFAULT;
 181                 goto err_link;
 182         }
 183
 184         if (gl_has_error(shader)) {
 185                 llog_warning(shader, "shader creation failed");
 186                 ret = -EFAULT;
 187                 goto err_link;
 188         }
 189
 190         *out = shader;
 191         return 0;
 192
 193 err_link:
 194         glDeleteProgram(shader->program);
 195         glDeleteShader(shader->fshader);
 196 err_vshader:
 197         glDeleteShader(shader->vshader);
 198 err_free:
 199         free(shader);
 200         return ret;
 201 }
 202
 203 void gl_shader_ref(struct gl_shader *shader)
 204 {
 205         if (!shader || !shader->ref)
 206                 return;
 207
 208         ++shader->ref;
 209 }
 210
 211 void gl_shader_unref(struct gl_shader *shader)
 212 {
 213         if (!shader || !shader->ref || --shader->ref)
 214                 return;
 215
 216         llog_debug(shader, "free shader");
 217
 218         glDeleteProgram(shader->program);
 219         glDeleteShader(shader->fshader);
 220         glDeleteShader(shader->vshader);
 221         free(shader);
 222 }
 223
 224 GLuint gl_shader_get_uniform(struct gl_shader *shader, const char *name)
 225 {
 226         if (!shader)
 227                 return 0;
 228
 229         return glGetUniformLocation(shader->program, name);
 230 }
 231
 232 void gl_shader_use(struct gl_shader *shader)
 233 {
 234         if (!shader)
 235                 return;
 236
 237         glUseProgram(shader->program);
 238 }
 239
 240 void gl_tex_new(GLuint *tex, size_t num)
 241 {
 242         size_t i;
 243
 244         glGenTextures(num, tex);
 245
 246         for (i = 0; i < num; ++i) {
 247                 glBindTexture(GL_TEXTURE_2D, tex[i]);
 248                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 249                                 GL_LINEAR);
 250                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
 251                                 GL_LINEAR);
 252                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
 253                                 GL_CLAMP_TO_EDGE);
 254                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
 255                                 GL_CLAMP_TO_EDGE);
 256         }
 257 }
 258
 259 void gl_tex_free(GLuint *tex, size_t num)
 260 {
 261         glDeleteTextures(num, tex);
 262 }
 263
 264 void gl_tex_load(GLuint tex, unsigned int width, unsigned int stride,
 265                  unsigned int height, uint8_t *buf)
 266 {
 267         if (!buf || !width || !height || !stride)
 268                 return;
 269
 270         /* With OpenGL instead of OpenGLES2 we must use this on linux:
 271          * glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA,
 272          *              GL_UNSIGNED_BYTE, buf);
 273          *
 274          * TODO: Check what kind of stride we need to support here.
 275          * GL_UNPACK_ROW_LENGTH only supports specifying a single row but
 276          * doesn't allow pixel strides. cairo currently works fine without
 277          * touching it but we should probably fix this properly. */
 278
 279         glBindTexture(GL_TEXTURE_2D, tex);
 280         /* glPixelStorei(GL_UNPACK_ROW_LENGTH, stride); */
 281         glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height, 0,
 282                         GL_BGRA_EXT, GL_UNSIGNED_BYTE, buf);
 283         /* glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); */
 284 }