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