git.mutantstargoat.com Git - laserbrain_demo/blob - src/sdr.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <errno.h>
   5 #include <stdarg.h>
   6 #include <assert.h>
   7 #include "opengl.h"
   8 #include "logger.h"
   9
  10 #if defined(unix) || defined(__unix__)
  11 #include <unistd.h>
  12 #include <sys/stat.h>
  13 #endif  /* unix */
  14
  15 #include "sdr.h"
  16
  17 static const char *sdrtypestr(unsigned int sdrtype);
  18 static int sdrtypeidx(unsigned int sdrtype);
  19
  20
  21 unsigned int create_vertex_shader(const char *src)
  22 {
  23         return create_shader(src, GL_VERTEX_SHADER);
  24 }
  25
  26 unsigned int create_pixel_shader(const char *src)
  27 {
  28         return create_shader(src, GL_FRAGMENT_SHADER);
  29 }
  30
  31 unsigned int create_tessctl_shader(const char *src)
  32 {
  33 #ifdef GL_TESS_CONTROL_SHADER
  34         return create_shader(src, GL_TESS_CONTROL_SHADER);
  35 #else
  36         return 0;
  37 #endif
  38 }
  39
  40 unsigned int create_tesseval_shader(const char *src)
  41 {
  42 #ifdef GL_TESS_EVALUATION_SHADER
  43         return create_shader(src, GL_TESS_EVALUATION_SHADER);
  44 #else
  45         return 0;
  46 #endif
  47 }
  48
  49 unsigned int create_geometry_shader(const char *src)
  50 {
  51 #ifdef GL_GEOMETRY_SHADER
  52         return create_shader(src, GL_GEOMETRY_SHADER);
  53 #else
  54         return 0;
  55 #endif
  56 }
  57
  58 unsigned int create_shader(const char *src, unsigned int sdr_type)
  59 {
  60         unsigned int sdr;
  61         int success, info_len;
  62         char *info_str = 0;
  63         const char *src_str[3], *header, *footer;
  64         int src_str_count = 0;
  65         GLenum err;
  66
  67         if((header = get_shader_header(sdr_type))) {
  68                 src_str[src_str_count++] = header;
  69         }
  70         src_str[src_str_count++] = src;
  71         if((footer = get_shader_footer(sdr_type))) {
  72                 src_str[src_str_count++] = footer;
  73         }
  74
  75         sdr = glCreateShader(sdr_type);
  76         assert(glGetError() == GL_NO_ERROR);
  77         glShaderSource(sdr, src_str_count, src_str, 0);
  78         err = glGetError();
  79         assert(err == GL_NO_ERROR);
  80         glCompileShader(sdr);
  81         assert(glGetError() == GL_NO_ERROR);
  82
  83         glGetShaderiv(sdr, GL_COMPILE_STATUS, &success);
  84         assert(glGetError() == GL_NO_ERROR);
  85         glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &info_len);
  86         assert(glGetError() == GL_NO_ERROR);
  87
  88         if(info_len) {
  89                 if((info_str = malloc(info_len + 1))) {
  90                         glGetShaderInfoLog(sdr, info_len, 0, info_str);
  91                         assert(glGetError() == GL_NO_ERROR);
  92                         info_str[info_len] = 0;
  93                 }
  94         }
  95
  96         if(success) {
  97                 info_log(info_str ? "done: %s\n" : "done\n", info_str);
  98         } else {
  99                 error_log(info_str ? "failed: %s\n" : "failed\n", info_str);
 100                 glDeleteShader(sdr);
 101                 sdr = 0;
 102         }
 103
 104         free(info_str);
 105         return sdr;
 106 }
 107
 108 void free_shader(unsigned int sdr)
 109 {
 110         glDeleteShader(sdr);
 111 }
 112
 113 unsigned int load_vertex_shader(const char *fname)
 114 {
 115         return load_shader(fname, GL_VERTEX_SHADER);
 116 }
 117
 118 unsigned int load_pixel_shader(const char *fname)
 119 {
 120         return load_shader(fname, GL_FRAGMENT_SHADER);
 121 }
 122
 123 unsigned int load_tessctl_shader(const char *fname)
 124 {
 125 #ifdef GL_TESS_CONTROL_SHADER
 126         return load_shader(fname, GL_TESS_CONTROL_SHADER);
 127 #else
 128         return 0;
 129 #endif
 130 }
 131
 132 unsigned int load_tesseval_shader(const char *fname)
 133 {
 134 #ifdef GL_TESS_EVALUATION_SHADER
 135         return load_shader(fname, GL_TESS_EVALUATION_SHADER);
 136 #else
 137         return 0;
 138 #endif
 139 }
 140
 141 unsigned int load_geometry_shader(const char *fname)
 142 {
 143 #ifdef GL_GEOMETRY_SHADER
 144         return load_shader(fname, GL_GEOMETRY_SHADER);
 145 #else
 146         return 0;
 147 #endif
 148 }
 149
 150 unsigned int load_shader(const char *fname, unsigned int sdr_type)
 151 {
 152         unsigned int sdr;
 153         size_t filesize;
 154         FILE *fp;
 155         char *src;
 156
 157         if(!(fp = fopen(fname, "rb"))) {
 158                 error_log("failed to open shader %s: %s\n", fname, strerror(errno));
 159                 return 0;
 160         }
 161
 162         fseek(fp, 0, SEEK_END);
 163         filesize = ftell(fp);
 164         fseek(fp, 0, SEEK_SET);
 165
 166         if(!(src = malloc(filesize + 1))) {
 167                 fclose(fp);
 168                 return 0;
 169         }
 170         fread(src, 1, filesize, fp);
 171         src[filesize] = 0;
 172         fclose(fp);
 173
 174         info_log("compiling %s shader: %s... ", sdrtypestr(sdr_type), fname);
 175         sdr = create_shader(src, sdr_type);
 176
 177         free(src);
 178         return sdr;
 179 }
 180
 181
 182 /* ---- gpu programs ---- */
 183
 184 unsigned int create_program(void)
 185 {
 186         unsigned int prog = glCreateProgram();
 187         assert(glGetError() == GL_NO_ERROR);
 188         return prog;
 189 }
 190
 191 unsigned int create_program_link(unsigned int sdr0, ...)
 192 {
 193         unsigned int prog, sdr;
 194         va_list ap;
 195
 196         if(!(prog = create_program())) {
 197                 return 0;
 198         }
 199
 200         attach_shader(prog, sdr0);
 201         if(glGetError()) {
 202                 return 0;
 203         }
 204
 205         va_start(ap, sdr0);
 206         while((sdr = va_arg(ap, unsigned int))) {
 207                 attach_shader(prog, sdr);
 208                 if(glGetError()) {
 209                         return 0;
 210                 }
 211         }
 212         va_end(ap);
 213
 214         if(link_program(prog) == -1) {
 215                 free_program(prog);
 216                 return 0;
 217         }
 218         return prog;
 219 }
 220
 221 unsigned int create_program_load(const char *vfile, const char *pfile)
 222 {
 223         unsigned int vs = 0, ps = 0;
 224
 225         if(vfile && *vfile && !(vs = load_vertex_shader(vfile))) {
 226                 return 0;
 227         }
 228         if(pfile && *pfile && !(ps = load_pixel_shader(pfile))) {
 229                 return 0;
 230         }
 231         return create_program_link(vs, ps, 0);
 232 }
 233
 234 void free_program(unsigned int sdr)
 235 {
 236         glDeleteProgram(sdr);
 237 }
 238
 239 void attach_shader(unsigned int prog, unsigned int sdr)
 240 {
 241         int err;
 242
 243         if(prog && sdr) {
 244                 assert(glGetError() == GL_NO_ERROR);
 245                 glAttachShader(prog, sdr);
 246                 if((err = glGetError()) != GL_NO_ERROR) {
 247                         error_log("failed to attach shader %u to program %u (err: 0x%x)\n", sdr, prog, err);
 248                         abort();
 249                 }
 250         }
 251 }
 252
 253 int link_program(unsigned int prog)
 254 {
 255         int linked, info_len, retval = 0;
 256         char *info_str = 0;
 257
 258         glLinkProgram(prog);
 259         assert(glGetError() == GL_NO_ERROR);
 260         glGetProgramiv(prog, GL_LINK_STATUS, &linked);
 261         assert(glGetError() == GL_NO_ERROR);
 262         glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &info_len);
 263         assert(glGetError() == GL_NO_ERROR);
 264
 265         if(info_len) {
 266                 if((info_str = malloc(info_len + 1))) {
 267                         glGetProgramInfoLog(prog, info_len, 0, info_str);
 268                         assert(glGetError() == GL_NO_ERROR);
 269                         info_str[info_len] = 0;
 270                 }
 271         }
 272
 273         if(linked) {
 274                 info_log(info_str ? "linking done: %s\n" : "linking done\n", info_str);
 275         } else {
 276                 error_log(info_str ? "linking failed: %s\n" : "linking failed\n", info_str);
 277                 retval = -1;
 278         }
 279
 280         free(info_str);
 281         return retval;
 282 }
 283
 284 int bind_program(unsigned int prog)
 285 {
 286         GLenum err;
 287
 288         glUseProgram(prog);
 289         if(prog && (err = glGetError()) != GL_NO_ERROR) {
 290                 /* maybe the program is not linked, try linking first */
 291                 if(err == GL_INVALID_OPERATION) {
 292                         if(link_program(prog) == -1) {
 293                                 return -1;
 294                         }
 295                         glUseProgram(prog);
 296                         return glGetError() == GL_NO_ERROR ? 0 : -1;
 297                 }
 298                 return -1;
 299         }
 300         return 0;
 301 }
 302
 303 /* ugly but I'm not going to write the same bloody code over and over */
 304 #define BEGIN_UNIFORM_CODE \
 305         int loc, curr_prog; \
 306         glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); \
 307         if((unsigned int)curr_prog != prog && bind_program(prog) == -1) { \
 308                 return -1; \
 309         } \
 310         if((loc = glGetUniformLocation(prog, name)) != -1)
 311
 312 #define END_UNIFORM_CODE \
 313         if((unsigned int)curr_prog != prog) { \
 314                 bind_program(curr_prog); \
 315         } \
 316         return loc == -1 ? -1 : 0
 317
 318 int get_uniform_loc(unsigned int prog, const char *name)
 319 {
 320         int loc, curr_prog;
 321         glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);
 322         if((unsigned int)curr_prog != prog && bind_program(prog) == -1) {
 323                 return -1;
 324         }
 325         loc = glGetUniformLocation(prog, name);
 326         if((unsigned int)curr_prog != prog) {
 327                 bind_program(curr_prog);
 328         }
 329         return loc;
 330 }
 331
 332 int set_uniform_int(unsigned int prog, const char *name, int val)
 333 {
 334         BEGIN_UNIFORM_CODE {
 335                 glUniform1i(loc, val);
 336         }
 337         END_UNIFORM_CODE;
 338 }
 339
 340 int set_uniform_float(unsigned int prog, const char *name, float val)
 341 {
 342         BEGIN_UNIFORM_CODE {
 343                 glUniform1f(loc, val);
 344         }
 345         END_UNIFORM_CODE;
 346 }
 347
 348 int set_uniform_float2(unsigned int prog, const char *name, float x, float y)
 349 {
 350         BEGIN_UNIFORM_CODE {
 351                 glUniform2f(loc, x, y);
 352         }
 353         END_UNIFORM_CODE;
 354 }
 355
 356 int set_uniform_float3(unsigned int prog, const char *name, float x, float y, float z)
 357 {
 358         BEGIN_UNIFORM_CODE {
 359                 glUniform3f(loc, x, y, z);
 360         }
 361         END_UNIFORM_CODE;
 362 }
 363
 364 int set_uniform_float4(unsigned int prog, const char *name, float x, float y, float z, float w)
 365 {
 366         BEGIN_UNIFORM_CODE {
 367                 glUniform4f(loc, x, y, z, w);
 368         }
 369         END_UNIFORM_CODE;
 370 }
 371
 372 int set_uniform_matrix4(unsigned int prog, const char *name, const float *mat)
 373 {
 374         BEGIN_UNIFORM_CODE {
 375                 glUniformMatrix4fv(loc, 1, GL_FALSE, mat);
 376         }
 377         END_UNIFORM_CODE;
 378 }
 379
 380 int set_uniform_matrix4_transposed(unsigned int prog, const char *name, const float *mat)
 381 {
 382         BEGIN_UNIFORM_CODE {
 383                 glUniformMatrix4fv(loc, 1, GL_TRUE, mat);
 384         }
 385         END_UNIFORM_CODE;
 386 }
 387
 388 int get_attrib_loc(unsigned int prog, const char *name)
 389 {
 390         int loc, curr_prog;
 391
 392         glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);
 393         if((unsigned int)curr_prog != prog && bind_program(prog) == -1) {
 394                 return -1;
 395         }
 396
 397         loc = glGetAttribLocation(prog, (char*)name);
 398
 399         if((unsigned int)curr_prog != prog) {
 400                 bind_program(curr_prog);
 401         }
 402         return loc;
 403 }
 404
 405 void set_attrib_float3(int attr_loc, float x, float y, float z)
 406 {
 407         glVertexAttrib3f(attr_loc, x, y, z);
 408 }
 409
 410 /* ---- shader composition ---- */
 411 struct string {
 412         char *text;
 413         int len;
 414 };
 415
 416 #define NUM_SHADER_TYPES        5
 417 static struct string header[NUM_SHADER_TYPES];
 418 static struct string footer[NUM_SHADER_TYPES];
 419
 420 static void clear_string(struct string *str)
 421 {
 422         free(str->text);
 423         str->text = 0;
 424         str->len = 0;
 425 }
 426
 427 static void append_string(struct string *str, const char *s)
 428 {
 429         int len, newlen;
 430         char *newstr;
 431
 432         if(!s || !*s) return;
 433
 434         len = strlen(s);
 435         newlen = str->len + len;
 436         if(!(newstr = malloc(newlen + 2))) {    /* leave space for a possible newline */
 437                 error_log("shader composition: failed to append string of size %d\n", len);
 438                 abort();
 439         }
 440
 441         if(str->text) {
 442                 memcpy(newstr, str->text, str->len);
 443         }
 444         memcpy(newstr + str->len, s, len + 1);
 445
 446         if(s[len - 1] != '\n') {
 447                 newstr[newlen] = '\n';
 448                 newstr[newlen + 1] = 0;
 449         }
 450
 451         free(str->text);
 452         str->text = newstr;
 453         str->len = newlen;
 454 }
 455
 456 void clear_shader_header(unsigned int type)
 457 {
 458         if(type) {
 459                 int idx = sdrtypeidx(type);
 460                 clear_string(&header[idx]);
 461         } else {
 462                 int i;
 463                 for(i=0; i<NUM_SHADER_TYPES; i++) {
 464                         clear_string(&header[i]);
 465                 }
 466         }
 467 }
 468
 469 void clear_shader_footer(unsigned int type)
 470 {
 471         if(type) {
 472                 int idx = sdrtypeidx(type);
 473                 clear_string(&footer[idx]);
 474         } else {
 475                 int i;
 476                 for(i=0; i<NUM_SHADER_TYPES; i++) {
 477                         clear_string(&footer[i]);
 478                 }
 479         }
 480 }
 481
 482 void add_shader_header(unsigned int type, const char *s)
 483 {
 484         if(type) {
 485                 int idx = sdrtypeidx(type);
 486                 append_string(&header[idx], s);
 487         } else {
 488                 int i;
 489                 for(i=0; i<NUM_SHADER_TYPES; i++) {
 490                         append_string(&header[i], s);
 491                 }
 492         }
 493 }
 494
 495 void add_shader_footer(unsigned int type, const char *s)
 496 {
 497         if(type) {
 498                 int idx = sdrtypeidx(type);
 499                 append_string(&footer[idx], s);
 500         } else {
 501                 int i;
 502                 for(i=0; i<NUM_SHADER_TYPES; i++) {
 503                         append_string(&footer[i], s);
 504                 }
 505         }
 506 }
 507
 508 const char *get_shader_header(unsigned int type)
 509 {
 510         int idx = sdrtypeidx(type);
 511         return header[idx].text;
 512 }
 513
 514 const char *get_shader_footer(unsigned int type)
 515 {
 516         int idx = sdrtypeidx(type);
 517         return footer[idx].text;
 518 }
 519
 520 static const char *sdrtypestr(unsigned int sdrtype)
 521 {
 522         switch(sdrtype) {
 523         case GL_VERTEX_SHADER:
 524                 return "vertex";
 525         case GL_FRAGMENT_SHADER:
 526                 return "pixel";
 527 #ifdef GL_TESS_CONTROL_SHADER
 528         case GL_TESS_CONTROL_SHADER:
 529                 return "tessellation control";
 530 #endif
 531 #ifdef GL_TESS_EVALUATION_SHADER
 532         case GL_TESS_EVALUATION_SHADER:
 533                 return "tessellation evaluation";
 534 #endif
 535 #ifdef GL_GEOMETRY_SHADER
 536         case GL_GEOMETRY_SHADER:
 537                 return "geometry";
 538 #endif
 539
 540         default:
 541                 break;
 542         }
 543         return "<unknown>";
 544 }
 545
 546 static int sdrtypeidx(unsigned int sdrtype)
 547 {
 548         switch(sdrtype) {
 549         case GL_VERTEX_SHADER:
 550                 return 0;
 551         case GL_FRAGMENT_SHADER:
 552                 return 1;
 553         case GL_TESS_CONTROL_SHADER:
 554                 return 2;
 555         case GL_TESS_EVALUATION_SHADER:
 556                 return 3;
 557         case GL_GEOMETRY_SHADER:
 558                 return 4;
 559         default:
 560                 break;
 561         }
 562         return 0;
 563 }