share/glsl.c

   1 /*
   2  * Copyright (C) 2013 Robert Kooima
   3  *
   4  * NEVERBALL is  free software; you can redistribute  it and/or modify
   5  * it under the  terms of the GNU General  Public License as published
   6  * by the Free  Software Foundation; either version 2  of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT  ANY  WARRANTY;  without   even  the  implied  warranty  of
  11  * MERCHANTABILITY or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
  12  * General Public License for more details.
  13  */
  14
  15 #include <stdlib.h>
  16 #include <stdarg.h>
  17 #include <string.h>
  18 #include <stdio.h>
  19
  20 #include "glext.h"
  21 #include "glsl.h"
  22 #include "log.h"
  23
  24 /*----------------------------------------------------------------------------*/
  25
  26 #if ENABLE_OPENGLES
  27
  28 /* OpenGL ES support in Neverball is targeted toward OpenGL ES version 1.1.   */
  29 /* This version of ES has no support for programmable shading.                */
  30
  31 GLboolean glsl_create(glsl *G, int vertc, const char *const *vertv,
  32                                int fragc, const char *const *fragv)
  33 {
  34     return GL_FALSE;
  35 }
  36
  37 void glsl_delete(glsl *G) { }
  38
  39 void glsl_uniform1f(glsl *G, const char *name, GLfloat a) { }
  40 void glsl_uniform2f(glsl *G, const char *name, GLfloat a, GLfloat b) { }
  41 void glsl_uniform3f(glsl *G, const char *name, GLfloat a, GLfloat b, GLfloat c) { }
  42 void glsl_uniform4f(glsl *G, const char *name, GLfloat a, GLfloat b, GLfloat c, GLfloat d) { }
  43
  44 #else
  45
  46 /*----------------------------------------------------------------------------*/
  47
  48 static int check_shader_log(GLuint shader)
  49 {
  50     char *p = 0;
  51     GLint s = 0;
  52     GLint n = 0;
  53
  54     /* Check the shader compile status.  If failed, print the log. */
  55
  56     glGetShaderiv_(shader, GL_COMPILE_STATUS,  &s);
  57     glGetShaderiv_(shader, GL_INFO_LOG_LENGTH, &n);
  58
  59     if (s == 0)
  60     {
  61         if ((p = (char *) calloc(n + 1, 1)))
  62         {
  63             glGetShaderInfoLog_(shader, n, NULL, p);
  64
  65             log_printf("OpenGL Shader Error:\n%s", p);
  66             free(p);
  67         }
  68         return 0;
  69     }
  70     return 1;
  71 }
  72
  73 static int check_program_log(GLuint program)
  74 {
  75     char *p = 0;
  76     GLint s = 0;
  77     GLint n = 0;
  78
  79     /* Check the program link status.  If failed, print the log. */
  80
  81     glGetProgramiv_(program, GL_LINK_STATUS,     &s);
  82     glGetProgramiv_(program, GL_INFO_LOG_LENGTH, &n);
  83
  84     if (s == 0)
  85     {
  86         if ((p = (char *) calloc(n + 1, 1)))
  87         {
  88             glGetProgramInfoLog_(program, n, NULL, p);
  89
  90             log_printf("OpenGL Program Error:\n%s", p);
  91             free(p);
  92         }
  93         return 0;
  94     }
  95     return 1;
  96 }
  97
  98 /*----------------------------------------------------------------------------*/
  99
 100 static GLuint glsl_init_shader(GLenum type, int strc, const char *const *strv)
 101 {
 102     /* Compile a new shader with the given source. */
 103
 104     GLuint shader = glCreateShader_(type);
 105
 106     glShaderSource_ (shader, strc, strv, NULL);
 107     glCompileShader_(shader);
 108
 109     /* If the shader is valid, return it.  Else, delete it. */
 110
 111     if (check_shader_log(shader))
 112         return shader;
 113     else
 114         glDeleteShader_(shader);
 115
 116     return 0;
 117 }
 118
 119 static GLuint glsl_init_program(GLuint shader_vert,
 120                                 GLuint shader_frag)
 121 {
 122     /* Link a new program object. */
 123
 124     GLuint program = glCreateProgram_();
 125
 126     glAttachShader_(program, shader_vert);
 127     glAttachShader_(program, shader_frag);
 128
 129     glLinkProgram_(program);
 130
 131     /* If the program is valid, return it.  Else, delete it. */
 132
 133     if (check_program_log(program))
 134         return program;
 135     else
 136         glDeleteProgram_(program);
 137
 138     return 0;
 139 }
 140
 141 /*----------------------------------------------------------------------------*/
 142
 143 GLboolean glsl_create(glsl *G, int vertc, const char *const *vertv,
 144                                int fragc, const char *const *fragv)
 145 {
 146     if (gli.shader_objects == 0) return GL_FALSE;
 147
 148     /* Compile the shaders. */
 149
 150     G->vert_shader = glsl_init_shader(GL_VERTEX_SHADER,   vertc, vertv);
 151     G->frag_shader = glsl_init_shader(GL_FRAGMENT_SHADER, fragc, fragv);
 152
 153     /* Link the program. */
 154
 155     if (G->vert_shader && G->frag_shader)
 156     {
 157         G->program = glsl_init_program(G->vert_shader, G->frag_shader);
 158         return GL_TRUE;
 159     }
 160     return GL_FALSE;
 161 }
 162
 163 void glsl_delete(glsl *G)
 164 {
 165     if (gli.shader_objects == 0) return;
 166
 167     /* Delete the program and shaders. */
 168
 169     if (G->program)     glDeleteProgram_(G->program);
 170     if (G->frag_shader) glDeleteShader_ (G->frag_shader);
 171     if (G->vert_shader) glDeleteShader_ (G->vert_shader);
 172
 173     memset(G, 0, sizeof (glsl));
 174 }
 175
 176 void glsl_uniform1f(glsl *G, const char *name, GLfloat a)
 177 {
 178     if (gli.shader_objects)
 179         glUniform1f_(glGetUniformLocation_(G->program, name), a);
 180 }
 181
 182 void glsl_uniform2f(glsl *G, const char *name, GLfloat a, GLfloat b)
 183 {
 184     if (gli.shader_objects)
 185         glUniform2f_(glGetUniformLocation_(G->program, name), a, b);
 186 }
 187
 188 void glsl_uniform3f(glsl *G, const char *name, GLfloat a, GLfloat b, GLfloat c)
 189 {
 190     if (gli.shader_objects)
 191         glUniform3f_(glGetUniformLocation_(G->program, name), a, b, c);
 192 }
 193
 194 void glsl_uniform4f(glsl *G, const char *name, GLfloat a, GLfloat b, GLfloat c, GLfloat d)
 195 {
 196     if (gli.shader_objects)
 197         glUniform4f_(glGetUniformLocation_(G->program, name), a, b, c, d);
 198 }
 199
 200 #endif
 201