src/shl_gl_shader.c

   1 /*
   2  * shl - OpenGL Helpers
   3  *
   4  * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files
   8  * (the "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  21  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /*
  27  * Shader API
  28  * This provides basic shader objects that are used to draw sprites and
  29  * textures.
  30  */
  31
  32 #define GL_GLEXT_PROTOTYPES
  33
  34 #include <errno.h>
  35 #include <GLES2/gl2.h>
  36 #include <GLES2/gl2ext.h>
  37 #include <stdbool.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include "shl_gl.h"
  41 #include "shl_llog.h"
  42
  43 #define LLOG_SUBSYSTEM "gl_shader"
  44
  45 struct gl_shader {
  46         unsigned long ref;
  47         llog_submit_t llog;
  48         void *llog_data;
  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                   void *llog_data)
 138 {
 139         struct gl_shader *shader;
 140         int ret, i;
 141         char msg[512];
 142         GLint status = 1;
 143
 144         if (!out || !vert || !frag)
 145                 return -EINVAL;
 146
 147         shader = malloc(sizeof(*shader));
 148         if (!shader)
 149                 return -ENOMEM;
 150         memset(shader, 0, sizeof(*shader));
 151         shader->ref = 1;
 152         shader->llog = llog;
 153         shader->llog_data = llog_data;
 154
 155         llog_debug(shader, "new shader");
 156
 157         shader->vshader = compile_shader(shader, GL_VERTEX_SHADER, vert);
 158         if (shader->vshader == GL_NONE) {
 159                 ret = -EFAULT;
 160                 goto err_free;
 161         }
 162
 163         shader->fshader = compile_shader(shader, GL_FRAGMENT_SHADER, frag);
 164         if (shader->fshader == GL_NONE) {
 165                 ret = -EFAULT;
 166                 goto err_vshader;
 167         }
 168
 169         shader->program = glCreateProgram();
 170         glAttachShader(shader->program, shader->vshader);
 171         glAttachShader(shader->program, shader->fshader);
 172
 173         for (i = 0; i < attr_count; ++i)
 174                 glBindAttribLocation(shader->program, i, attr[i]);
 175
 176         glLinkProgram(shader->program);
 177         glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
 178         if (status == GL_FALSE) {
 179                 msg[0] = 0;
 180                 glGetProgramInfoLog(shader->program, sizeof(msg), NULL, msg);
 181                 llog_warning(shader, "cannot link shader: %s", msg);
 182                 ret = -EFAULT;
 183                 goto err_link;
 184         }
 185
 186         if (gl_has_error(shader)) {
 187                 llog_warning(shader, "shader creation failed");
 188                 ret = -EFAULT;
 189                 goto err_link;
 190         }
 191
 192         *out = shader;
 193         return 0;
 194
 195 err_link:
 196         glDeleteProgram(shader->program);
 197         glDeleteShader(shader->fshader);
 198 err_vshader:
 199         glDeleteShader(shader->vshader);
 200 err_free:
 201         free(shader);
 202         return ret;
 203 }
 204
 205 void gl_shader_ref(struct gl_shader *shader)
 206 {
 207         if (!shader || !shader->ref)
 208                 return;
 209
 210         ++shader->ref;
 211 }
 212
 213 void gl_shader_unref(struct gl_shader *shader)
 214 {
 215         if (!shader || !shader->ref || --shader->ref)
 216                 return;
 217
 218         llog_debug(shader, "free shader");
 219
 220         glDeleteProgram(shader->program);
 221         glDeleteShader(shader->fshader);
 222         glDeleteShader(shader->vshader);
 223         free(shader);
 224 }
 225
 226 GLuint gl_shader_get_uniform(struct gl_shader *shader, const char *name)
 227 {
 228         if (!shader)
 229                 return 0;
 230
 231         return glGetUniformLocation(shader->program, name);
 232 }
 233
 234 void gl_shader_use(struct gl_shader *shader)
 235 {
 236         if (!shader)
 237                 return;
 238
 239         glUseProgram(shader->program);
 240 }
 241
 242 void gl_tex_new(GLuint *tex, size_t num)
 243 {
 244         size_t i;
 245
 246         glGenTextures(num, tex);
 247
 248         for (i = 0; i < num; ++i) {
 249                 glBindTexture(GL_TEXTURE_2D, tex[i]);
 250                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 251                                 GL_LINEAR);
 252                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
 253                                 GL_LINEAR);
 254                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
 255                                 GL_CLAMP_TO_EDGE);
 256                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
 257                                 GL_CLAMP_TO_EDGE);
 258         }
 259 }
 260
 261 void gl_tex_free(GLuint *tex, size_t num)
 262 {
 263         glDeleteTextures(num, tex);
 264 }
 265
 266 void gl_tex_load(GLuint tex, unsigned int width, unsigned int stride,
 267                  unsigned int height, uint8_t *buf)
 268 {
 269         if (!buf || !width || !height || !stride)
 270                 return;
 271
 272         /* With OpenGL instead of OpenGLES2 we must use this on linux:
 273          * glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA,
 274          *              GL_UNSIGNED_BYTE, buf);
 275          *
 276          * TODO: Check what kind of stride we need to support here.
 277          * GL_UNPACK_ROW_LENGTH only supports specifying a single row but
 278          * doesn't allow pixel strides. cairo currently works fine without
 279          * touching it but we should probably fix this properly. */
 280
 281         glBindTexture(GL_TEXTURE_2D, tex);
 282         /* glPixelStorei(GL_UNPACK_ROW_LENGTH, stride); */
 283         glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height, 0,
 284                         GL_BGRA_EXT, GL_UNSIGNED_BYTE, buf);
 285         /* glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); */
 286 }