9 #if defined(unix) || defined(__unix__)
16 #ifndef GL_GEOMETRY_SHADER
17 #define GL_GEOMETRY_SHADER 0x8dd9
19 #ifndef GL_TESS_EVALUATION_SHADER
20 #define GL_TESS_EVALUATION_SHADER 0x8e87
22 #ifndef GL_TESS_CONTROL_SHADER
23 #define GL_TESS_CONTROL_SHADER 0x8e88
26 static const char *sdrtypestr(unsigned int sdrtype);
27 static int sdrtypeidx(unsigned int sdrtype);
30 unsigned int create_vertex_shader(const char *src)
32 return create_shader(src, GL_VERTEX_SHADER);
35 unsigned int create_pixel_shader(const char *src)
37 return create_shader(src, GL_FRAGMENT_SHADER);
40 unsigned int create_tessctl_shader(const char *src)
42 return create_shader(src, GL_TESS_CONTROL_SHADER);
45 unsigned int create_tesseval_shader(const char *src)
47 return create_shader(src, GL_TESS_EVALUATION_SHADER);
50 unsigned int create_geometry_shader(const char *src)
52 #ifdef GL_GEOMETRY_SHADER
53 return create_shader(src, GL_GEOMETRY_SHADER);
59 unsigned int create_shader(const char *src, unsigned int sdr_type)
62 int success, info_len;
64 const char *src_str[3], *header, *footer;
65 int src_str_count = 0;
68 if((header = get_shader_header(sdr_type))) {
69 src_str[src_str_count++] = header;
71 src_str[src_str_count++] = src;
72 if((footer = get_shader_footer(sdr_type))) {
73 src_str[src_str_count++] = footer;
76 sdr = glCreateShader(sdr_type);
77 assert(glGetError() == GL_NO_ERROR);
78 glShaderSource(sdr, src_str_count, src_str, 0);
80 assert(err == GL_NO_ERROR);
82 assert(glGetError() == GL_NO_ERROR);
84 glGetShaderiv(sdr, GL_COMPILE_STATUS, &success);
85 assert(glGetError() == GL_NO_ERROR);
86 glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &info_len);
87 assert(glGetError() == GL_NO_ERROR);
90 if((info_str = malloc(info_len + 1))) {
91 glGetShaderInfoLog(sdr, info_len, 0, info_str);
92 assert(glGetError() == GL_NO_ERROR);
93 info_str[info_len] = 0;
98 fprintf(stderr, info_str ? "done: %s\n" : "done\n", info_str);
100 fprintf(stderr, info_str ? "failed: %s\n" : "failed\n", info_str);
109 void free_shader(unsigned int sdr)
114 unsigned int load_vertex_shader(const char *fname)
116 return load_shader(fname, GL_VERTEX_SHADER);
119 unsigned int load_pixel_shader(const char *fname)
121 return load_shader(fname, GL_FRAGMENT_SHADER);
124 unsigned int load_tessctl_shader(const char *fname)
126 return load_shader(fname, GL_TESS_CONTROL_SHADER);
129 unsigned int load_tesseval_shader(const char *fname)
131 return load_shader(fname, GL_TESS_EVALUATION_SHADER);
134 unsigned int load_geometry_shader(const char *fname)
136 #ifdef GL_GEOMETRY_SHADER
137 return load_shader(fname, GL_GEOMETRY_SHADER);
143 unsigned int load_shader(const char *fname, unsigned int sdr_type)
150 if(!(fp = fopen(fname, "rb"))) {
151 fprintf(stderr, "failed to open shader %s: %s\n", fname, strerror(errno));
155 fseek(fp, 0, SEEK_END);
156 filesize = ftell(fp);
157 fseek(fp, 0, SEEK_SET);
159 if(!(src = malloc(filesize + 1))) {
163 fread(src, 1, filesize, fp);
167 fprintf(stderr, "compiling %s shader: %s... ", sdrtypestr(sdr_type), fname);
168 sdr = create_shader(src, sdr_type);
175 /* ---- gpu programs ---- */
177 unsigned int create_program(void)
179 unsigned int prog = glCreateProgram();
180 assert(glGetError() == GL_NO_ERROR);
184 unsigned int create_program_link(unsigned int sdr0, ...)
186 unsigned int prog, sdr;
189 if(!(prog = create_program())) {
193 attach_shader(prog, sdr0);
199 while((sdr = va_arg(ap, unsigned int))) {
200 attach_shader(prog, sdr);
207 if(link_program(prog) == -1) {
214 unsigned int create_program_load(const char *vfile, const char *pfile)
216 unsigned int vs = 0, ps = 0;
218 if(vfile && *vfile && !(vs = load_vertex_shader(vfile))) {
221 if(pfile && *pfile && !(ps = load_pixel_shader(pfile))) {
224 return create_program_link(vs, ps, 0);
227 void free_program(unsigned int sdr)
229 glDeleteProgram(sdr);
232 void attach_shader(unsigned int prog, unsigned int sdr)
237 assert(glGetError() == GL_NO_ERROR);
238 glAttachShader(prog, sdr);
239 if((err = glGetError()) != GL_NO_ERROR) {
240 fprintf(stderr, "failed to attach shader %u to program %u (err: 0x%x)\n", sdr, prog, err);
246 int link_program(unsigned int prog)
248 int linked, info_len, retval = 0;
252 assert(glGetError() == GL_NO_ERROR);
253 glGetProgramiv(prog, GL_LINK_STATUS, &linked);
254 assert(glGetError() == GL_NO_ERROR);
255 glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &info_len);
256 assert(glGetError() == GL_NO_ERROR);
259 if((info_str = malloc(info_len + 1))) {
260 glGetProgramInfoLog(prog, info_len, 0, info_str);
261 assert(glGetError() == GL_NO_ERROR);
262 info_str[info_len] = 0;
267 fprintf(stderr, info_str ? "linking done: %s\n" : "linking done\n", info_str);
269 fprintf(stderr, info_str ? "linking failed: %s\n" : "linking failed\n", info_str);
277 int bind_program(unsigned int prog)
282 if(prog && (err = glGetError()) != GL_NO_ERROR) {
283 /* maybe the program is not linked, try linking first */
284 if(err == GL_INVALID_OPERATION) {
285 if(link_program(prog) == -1) {
289 return glGetError() == GL_NO_ERROR ? 0 : -1;
296 /* ugly but I'm not going to write the same bloody code over and over */
297 #define BEGIN_UNIFORM_CODE \
298 int loc, curr_prog; \
299 glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); \
300 if((unsigned int)curr_prog != prog && bind_program(prog) == -1) { \
303 if((loc = glGetUniformLocation(prog, name)) != -1)
305 #define END_UNIFORM_CODE \
306 if((unsigned int)curr_prog != prog) { \
307 bind_program(curr_prog); \
309 return loc == -1 ? -1 : 0
311 int get_uniform_loc(unsigned int prog, const char *name)
314 glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);
315 if((unsigned int)curr_prog != prog && bind_program(prog) == -1) {
318 loc = glGetUniformLocation(prog, name);
319 if((unsigned int)curr_prog != prog) {
320 bind_program(curr_prog);
325 int set_uniform_int(unsigned int prog, const char *name, int val)
328 glUniform1i(loc, val);
333 int set_uniform_float(unsigned int prog, const char *name, float val)
336 glUniform1f(loc, val);
341 int set_uniform_float2(unsigned int prog, const char *name, float x, float y)
344 glUniform2f(loc, x, y);
349 int set_uniform_float3(unsigned int prog, const char *name, float x, float y, float z)
352 glUniform3f(loc, x, y, z);
357 int set_uniform_float4(unsigned int prog, const char *name, float x, float y, float z, float w)
360 glUniform4f(loc, x, y, z, w);
365 int set_uniform_matrix4(unsigned int prog, const char *name, const float *mat)
368 glUniformMatrix4fv(loc, 1, GL_FALSE, mat);
373 int set_uniform_matrix4_transposed(unsigned int prog, const char *name, const float *mat)
376 glUniformMatrix4fv(loc, 1, GL_TRUE, mat);
381 int get_attrib_loc(unsigned int prog, const char *name)
385 glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);
386 if((unsigned int)curr_prog != prog && bind_program(prog) == -1) {
390 loc = glGetAttribLocation(prog, (char*)name);
392 if((unsigned int)curr_prog != prog) {
393 bind_program(curr_prog);
398 void set_attrib_float3(int attr_loc, float x, float y, float z)
400 glVertexAttrib3f(attr_loc, x, y, z);
403 /* ---- shader composition ---- */
409 #define NUM_SHADER_TYPES 5
410 static struct string header[NUM_SHADER_TYPES];
411 static struct string footer[NUM_SHADER_TYPES];
413 static void clear_string(struct string *str)
420 static void append_string(struct string *str, const char *s)
425 if(!s || !*s) return;
428 newlen = str->len + len;
429 if(!(newstr = malloc(newlen + 2))) { /* leave space for a possible newline */
430 fprintf(stderr, "shader composition: failed to append string of size %d\n", len);
435 memcpy(newstr, str->text, str->len);
437 memcpy(newstr + str->len, s, len + 1);
439 if(s[len - 1] != '\n') {
440 newstr[newlen] = '\n';
441 newstr[newlen + 1] = 0;
449 void clear_shader_header(unsigned int type)
452 int idx = sdrtypeidx(type);
453 clear_string(&header[idx]);
456 for(i=0; i<NUM_SHADER_TYPES; i++) {
457 clear_string(&header[i]);
462 void clear_shader_footer(unsigned int type)
465 int idx = sdrtypeidx(type);
466 clear_string(&footer[idx]);
469 for(i=0; i<NUM_SHADER_TYPES; i++) {
470 clear_string(&footer[i]);
475 void add_shader_header(unsigned int type, const char *s)
478 int idx = sdrtypeidx(type);
479 append_string(&header[idx], s);
482 for(i=0; i<NUM_SHADER_TYPES; i++) {
483 append_string(&header[i], s);
488 void add_shader_footer(unsigned int type, const char *s)
491 int idx = sdrtypeidx(type);
492 append_string(&footer[idx], s);
495 for(i=0; i<NUM_SHADER_TYPES; i++) {
496 append_string(&footer[i], s);
501 const char *get_shader_header(unsigned int type)
503 int idx = sdrtypeidx(type);
504 return header[idx].text;
507 const char *get_shader_footer(unsigned int type)
509 int idx = sdrtypeidx(type);
510 return footer[idx].text;
513 static const char *sdrtypestr(unsigned int sdrtype)
516 case GL_VERTEX_SHADER:
518 case GL_FRAGMENT_SHADER:
520 case GL_TESS_CONTROL_SHADER:
521 return "tessellation control";
522 case GL_TESS_EVALUATION_SHADER:
523 return "tessellation evaluation";
524 case GL_GEOMETRY_SHADER:
532 static int sdrtypeidx(unsigned int sdrtype)
535 case GL_VERTEX_SHADER:
537 case GL_FRAGMENT_SHADER:
539 case GL_TESS_CONTROL_SHADER:
541 case GL_TESS_EVALUATION_SHADER:
543 case GL_GEOMETRY_SHADER: