18 #define HAVE_GEOMETRY_SHADER
19 #define HAVE_TESSELATION_SHADER
22 static void bind_standard_attr(const ShaderProg *prog);
23 static const char *strtype(unsigned int type);
25 ShaderProg *ShaderProg::current;
27 void bind_shader(const ShaderProg *sdr)
32 #ifndef GL_ES_VERSION_2_0
34 ShaderProg::current = 0;
39 const ShaderProg *get_current_shader()
41 return ShaderProg::current;
56 unsigned int Shader::get_id() const
61 unsigned int Shader::get_type() const
66 void Shader::set_name(const char *name)
69 this->name = new char[strlen(name) + 1];
70 strcpy(this->name, name);
73 const char *Shader::get_name() const
78 void Shader::set_source(const char *src)
81 this->src = new char[strlen(src) + 1];
82 strcpy(this->src, src);
85 const char *Shader::get_source() const
90 bool Shader::create(const char *src, unsigned int type)
92 #if !GL_ES_VERSION_2_0
93 const char *src_arr[] = {src};
95 const char *src_arr[] = { "precision mediump float; ", src };
99 if(src != this->src) {
101 int len = strlen(src);
102 this->src = new char[len + 1];
103 memcpy(this->src, src, len + 1);
107 sdr = glCreateShader(type);
110 info_log("compiling shader: %s... ", name ? name : "");
112 glShaderSource(sdr, sizeof src_arr / sizeof *src_arr, src_arr, 0);
114 glCompileShader(sdr);
117 glGetShaderiv(sdr, GL_COMPILE_STATUS, &status);
119 info_log(status ? "success\n" : "failed\n");
122 glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &info_len);
124 char *buf = (char*)alloca(info_len);
125 glGetShaderInfoLog(sdr, info_len, 0, buf);
126 buf[info_len - 1] = 0;
129 info_log("%s\n", buf);
131 error_log("%s\n", buf);
135 return status == GL_TRUE;
138 void Shader::destroy()
150 bool Shader::load(const char *fname, unsigned int type)
154 if(!(fp = fopen(fname, "rb"))) {
155 error_log("failed to load %s shader: %s: %s\n", strtype(type), fname, strerror(errno));
159 fseek(fp, 0, SEEK_END);
161 fseek(fp, 0, SEEK_SET);
163 char *src = (char*)alloca(sz + 1);
164 if(fread(src, 1, sz, fp) < (size_t)sz) {
165 error_log("failed to load %s shader: %s: %s\n", strtype(type), fname, strerror(errno));
173 return create(src, type);
176 // ---- shader program ----
177 ShaderProg::ShaderProg()
183 ShaderProg::~ShaderProg()
188 unsigned int ShaderProg::get_id() const
193 bool ShaderProg::create(const char *src, unsigned int type, ...)
198 bool res = create(src, type, ap);
204 bool ShaderProg::create(const char *src, unsigned int type, va_list ap)
207 prog = glCreateProgram();
210 Shader *sdr = new Shader;
211 if(!sdr->create(src, type)) {
216 src = va_arg(ap, const char*);
217 type = va_arg(ap, unsigned int);
222 bool ShaderProg::create(const char *vsrc, const char *psrc)
224 return create(VSDR(vsrc), PSDR(psrc), 0);
227 bool ShaderProg::create(Shader *sdr, ...)
232 bool res = create(sdr, ap);
238 bool ShaderProg::create(Shader *sdr, va_list ap)
241 prog = glCreateProgram();
245 sdr = va_arg(ap, Shader*);
250 bool ShaderProg::create(Shader *vsdr, Shader *psdr)
252 return create(vsdr, psdr, 0);
255 void ShaderProg::destroy()
258 glDeleteProgram(prog);
263 // don't actually destroy the shaders, let the ShaderSet own them
266 bool ShaderProg::load(const char *fname, unsigned int type, ...)
270 bool res = load(fname, type, ap);
276 bool ShaderProg::load(const char *fname, unsigned int type, va_list ap)
279 prog = glCreateProgram();
282 Shader *sdr = new Shader;
283 if(!sdr->load(fname, type)) {
289 if((fname = va_arg(ap, const char*))) {
290 type = va_arg(ap, unsigned int);
297 bool ShaderProg::load(const char *vfname, const char *pfname)
299 return load(VSDR(vfname), PSDR(pfname), 0);
302 void ShaderProg::add_shader(Shader *sdr)
304 glAttachShader(prog, sdr->get_id());
307 bool ShaderProg::link() const
309 bind_standard_attr(this);
311 info_log("linking program ... ");
315 glGetProgramiv(prog, GL_LINK_STATUS, &status);
317 info_log(status ? "success\n" : "failed\n");
320 glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &info_len);
322 char *buf = (char*)alloca(info_len);
323 glGetProgramInfoLog(prog, info_len, 0, buf);
324 buf[info_len - 1] = 0;
327 info_log("%s\n", buf);
329 error_log("%s\n", buf);
335 cache_state_uniforms();
342 void ShaderProg::bind() const
350 ShaderProg::current = (ShaderProg*)this;
352 setup_state_uniforms();
356 int ShaderProg::get_attrib_location(const char *name) const
359 return glGetAttribLocation(prog, name);
362 void ShaderProg::set_attrib_location(const char *name, int loc) const
364 glBindAttribLocation(prog, loc, name);
368 int ShaderProg::get_uniform_location(const char *name) const
371 return glGetUniformLocation(prog, name);
374 bool ShaderProg::set_uniform(int loc, int val) const
378 glUniform1i(loc, val);
384 bool ShaderProg::set_uniform(int loc, float val) const
388 glUniform1f(loc, val);
394 bool ShaderProg::set_uniform(int loc, const Vec2 &v) const
398 glUniform2f(loc, v.x, v.y);
404 bool ShaderProg::set_uniform(int loc, const Vec3 &v) const
408 glUniform3f(loc, v.x, v.y, v.z);
414 bool ShaderProg::set_uniform(int loc, const Vec4 &v) const
418 glUniform4f(loc, v.x, v.y, v.z, v.w);
424 bool ShaderProg::set_uniform(int loc, const Mat3 &m) const
428 glUniformMatrix3fv(loc, 1, GL_FALSE, m[0]);
434 bool ShaderProg::set_uniform(int loc, const Mat4 &m) const
438 glUniformMatrix4fv(loc, 1, GL_FALSE, m[0]);
445 bool ShaderProg::set_uniform(const char *name, int val) const
447 return set_uniform(get_uniform_location(name), val);
450 bool ShaderProg::set_uniform(const char *name, float val) const
452 return set_uniform(get_uniform_location(name), val);
455 bool ShaderProg::set_uniform(const char *name, const Vec2 &v) const
457 return set_uniform(get_uniform_location(name), v);
460 bool ShaderProg::set_uniform(const char *name, const Vec3 &v) const
462 return set_uniform(get_uniform_location(name), v);
465 bool ShaderProg::set_uniform(const char *name, const Vec4 &v) const
467 return set_uniform(get_uniform_location(name), v);
470 bool ShaderProg::set_uniform(const char *name, const Mat3 &m) const
472 return set_uniform(get_uniform_location(name), m);
475 bool ShaderProg::set_uniform(const char *name, const Mat4 &m) const
477 return set_uniform(get_uniform_location(name), m);
480 static StType unist_type(GLenum type)
493 case GL_SAMPLER_CUBE:
494 #if !GL_ES_VERSION_2_0
497 case GL_SAMPLER_1D_SHADOW:
498 case GL_SAMPLER_2D_SHADOW:
517 void ShaderProg::cache_state_uniforms() const
519 if(!glIsProgram(prog)) {
524 glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &num_uni);
527 for(int i=0; i<num_uni; i++) {
530 glGetActiveUniform(prog, i, sizeof name - 1, 0, &sz, &type, name);
532 if(strstr(name, "st_") == name) {
534 s.sidx = add_unistate(name, unist_type(type));
535 s.loc = glGetUniformLocation(prog, name);
536 stloc_cache.push_back(s);
541 void ShaderProg::setup_state_uniforms() const
547 for(size_t i=0; i<stloc_cache.size(); i++) {
548 setup_unistate(stloc_cache[i].sidx, this, stloc_cache[i].loc);
552 // ---- ShaderSet ----
553 static Shader *create_shader()
558 bool load_shader(Shader *sdr, const char *fname, unsigned int type)
562 if(!(fp = fopen(fname, "rb"))) {
563 error_log("failed to load %s shader: %s: %s\n", strtype(type), fname, strerror(errno));
567 fseek(fp, 0, SEEK_END);
569 fseek(fp, 0, SEEK_SET);
571 sdr->src = new char[sz + 1];
572 if(fread(sdr->src, 1, sz, fp) < (size_t)sz) {
573 error_log("failed to load %s shader: %s: %s\n", strtype(type), fname, strerror(errno));
581 sdr->set_name(fname);
585 static bool load_vertex_shader(Shader *sdr, const char *fname)
587 return load_shader(sdr, fname, GL_VERTEX_SHADER);
590 static bool load_pixel_shader(Shader *sdr, const char *fname)
592 return load_shader(sdr, fname, GL_FRAGMENT_SHADER);
595 #ifdef HAVE_GEOMETRY_SHADER
596 static bool load_geom_shader(Shader *sdr, const char *fname)
598 return load_shader(sdr, fname, GL_GEOMETRY_SHADER);
602 #ifdef HAVE_TESSELATION_SHADER
603 static bool load_tc_shader(Shader *sdr, const char *fname)
605 return load_shader(sdr, fname, GL_TESS_CONTROL_SHADER);
608 static bool load_te_shader(Shader *sdr, const char *fname)
610 return load_shader(sdr, fname, GL_TESS_EVALUATION_SHADER);
614 static bool done_shader(Shader *sdr)
616 return sdr->create(sdr->get_source(), sdr->get_type());
619 static void destroy_shader(Shader *sdr)
624 ShaderSet::ShaderSet(unsigned int type)
625 : DataSet<Shader*>(create_shader, 0, done_shader, destroy_shader)
630 case GL_VERTEX_SHADER:
631 load = load_vertex_shader;
634 case GL_FRAGMENT_SHADER:
635 load = load_pixel_shader;
638 #ifdef HAVE_GEOMETRY_SHADER
639 case GL_GEOMETRY_SHADER:
640 load = load_geom_shader;
644 #ifdef HAVE_TESSELATION_SHADER
645 case GL_TESS_CONTROL_SHADER:
646 load = load_tc_shader;
649 case GL_TESS_EVALUATION_SHADER:
650 load = load_te_shader;
655 error_log("ShaderSet constructed with invalid shader type!\n");
663 {"attr_vertex", MESH_ATTR_VERTEX},
664 {"attr_normal", MESH_ATTR_NORMAL},
665 {"attr_tangent", MESH_ATTR_TANGENT},
666 {"attr_texcoord", MESH_ATTR_TEXCOORD},
667 {"attr_color", MESH_ATTR_COLOR},
668 {"attr_boneweights", MESH_ATTR_BONEWEIGHTS},
669 {"attr_boneidx", MESH_ATTR_BONEIDX}
672 static void bind_standard_attr(const ShaderProg *prog)
674 // we must link once to find out which are the active attributes
675 glLinkProgram(prog->get_id());
678 glGetProgramiv(prog->get_id(), GL_ACTIVE_ATTRIBUTES, &num_attr);
681 for(int i=0; i<num_attr; i++) {
684 glGetActiveAttrib(prog->get_id(), i, sizeof name - 1, 0, &sz, &type, name);
686 for(int j=0; j<(int)(sizeof attr_loc / sizeof *attr_loc); j++) {
687 if(strcmp(name, attr_loc[j].name) == 0) {
688 prog->set_attrib_location(name, attr_loc[j].loc);
695 static const char *strtype(unsigned int type)
698 case GL_VERTEX_SHADER:
700 case GL_FRAGMENT_SHADER:
702 #ifdef HAVE_GEOMETRY_SHADER
703 case GL_GEOMETRY_SHADER:
706 #ifdef HAVE_TESSELATION_SHADER
707 case GL_TESS_CONTROL_SHADER:
708 return "tesselation control";
709 case GL_TESS_EVALUATION_SHADER:
710 return "tesselation evaluation";