source/program.cpp

   1 #include <algorithm>
   2 #include <cstring>
   3 #include <msp/core/hash.h>
   4 #include <msp/core/maputils.h>
   5 #include <msp/strings/format.h>
   6 #include "arb_shader_objects.h"
   7 #include "arb_uniform_buffer_object.h"
   8 #include "arb_vertex_shader.h"
   9 #include "buffer.h"
  10 #include "error.h"
  11 #include "program.h"
  12 #include "shader.h"
  13
  14 using namespace std;
  15
  16 namespace {
  17
  18 const char *standard_vertex_src[] =
  19 {
  20         "s",   "uniform int shadow_unit;\n",
  21         "n",   "attribute vec3 tangent;\n",
  22         "n",   "attribute vec3 binormal;\n",
  23         "t|n", "varying vec2 v_texcoord;\n",
  24         "s",   "varying vec3 v_shadowcoord;\n",
  25         "!lm", "varying vec4 v_color;\n",
  26         "l!n", "varying vec3 v_normal;\n",
  27         "l",   "varying vec3 v_light_dir;\n",
  28         "p|e", "varying vec3 v_eye_dir;\n",
  29         "r",   "vec4 transform_vertex(vec4);\n",
  30         "lr",  "vec3 transform_normal(vec3);\n",
  31          0,    "void main()\n",
  32          0,    "{\n",
  33         "r",   "\tvec4 eye_pos = transform_vertex(gl_Vertex);\n",
  34         "!r",  "\tvec4 eye_pos = gl_ModelViewMatrix*gl_Vertex;\n",
  35          0,    "\tgl_Position = gl_ProjectionMatrix*eye_pos;\n",
  36         "lr",  "\tvec3 eye_normal = transform_normal(gl_Normal);\n",
  37         "l!r", "\tvec3 eye_normal = gl_NormalMatrix*gl_Normal;\n",
  38         "l!n", "\tv_normal = eye_normal;\n",
  39         "nr",  "\tvec3 eye_tangent = transform_normal(tangent);\n",
  40         "n!r", "\tvec3 eye_tangent = gl_NormalMatrix*tangent;\n",
  41         "nr",  "\tvec3 eye_binormal = transform_normal(binormal);\n",
  42         "n!r", "\tvec3 eye_binormal = gl_NormalMatrix*binormal;\n",
  43         "l",   "\tvec3 eye_light_dir = normalize(gl_LightSource[0].position.xyz-eye_pos.xyz*gl_LightSource[0].position.w);\n",
  44         "n",   "\tv_light_dir = vec3(dot(eye_tangent, eye_light_dir), dot(eye_binormal, eye_light_dir), dot(eye_normal, eye_light_dir));\n",
  45         "l!n", "\tv_light_dir = eye_light_dir;\n",
  46         "p|e", "\tvec3 eye_dir = -normalize(eye_pos.xyz);\n",
  47         "p|en",  "\tv_eye_dir = vec3(dot(eye_tangent, eye_dir), dot(eye_binormal, eye_dir), dot(eye_normal, eye_dir));\n",
  48         "p|e!n", "\tv_eye_dir = eye_dir;\n",
  49         "t|n", "\tv_texcoord = gl_MultiTexCoord0.xy;\n",
  50         "s",   "\tv_shadowcoord = vec3(dot(gl_EyePlaneS[shadow_unit], eye_pos), dot(gl_EyePlaneT[shadow_unit], eye_pos), dot(gl_EyePlaneR[shadow_unit], eye_pos));\n",
  51         "!lm", "\tv_color = gl_Color;\n",
  52          0,    "}",
  53         0, 0
  54 };
  55
  56 const char *standard_fragment_src[] =
  57 {
  58         "t",   "uniform sampler2D texture;\n",
  59         "n",   "uniform sampler2D normalmap;\n",
  60         "s",   "uniform sampler2DShadow shadow;\n",
  61         "e",   "uniform samplerCube environment;\n",
  62         "e",   "uniform float reflectivity;\n",
  63         "t|n", "varying vec2 v_texcoord;\n",
  64         "s",   "varying vec3 v_shadowcoord;\n",
  65         "!lm", "varying vec4 v_color;\n",
  66         "l!n", "varying vec3 v_normal;\n",
  67         "l",   "varying vec3 v_light_dir;\n",
  68         "p|e", "varying vec3 v_eye_dir;\n",
  69          0,    "void main()\n",
  70          0,    "{\n",
  71         "n",   "\tvec3 n_normal = texture2D(normalmap, v_texcoord).xyz*2.0-1.0;\n",
  72         "l!n", "\tvec3 n_normal = normalize(v_normal);\n",
  73         "l",   "\tfloat l_diffuse = max(dot(n_normal, normalize(v_light_dir)), 0.0);\n",
  74         "p",   "\tvec3 half_dir = normalize(v_eye_dir+v_light_dir);\n",
  75         "p",   "\tfloat l_specular = pow(max(dot(half_dir, n_normal), 0.0), gl_FrontMaterial.shininess);\n",
  76         "s",   "\tfloat l_shadow = shadow2D(shadow, v_shadowcoord).r;\n",
  77         /* XXX This is incorrect with normal mapping, since the vectors are in TBN
  78         space but environment map is expected to be in eye space */
  79         "e",   "\tvec4 reflection = textureCube(environment, n_normal*(dot(n_normal, v_eye_dir)*2.0)-v_eye_dir);\n",
  80         "t",   "\tvec4 tex_sample = texture2D(texture, v_texcoord);\n",
  81          0,    "\tgl_FragColor.rgb = ",
  82         "!t!l!m", "vec3(1.0)",
  83         "t",     "tex_sample.rgb",
  84         "l|mt",  "*",
  85         "!lm",   "v_color.rgb",
  86         "l",     "((l_diffuse",
  87         "lm",    "*gl_FrontLightProduct[0].diffuse.rgb",
  88         "p",     "+l_specular",
  89         "pm",    "*gl_FrontLightProduct[0].specular.rgb",
  90         "l",     ")",
  91         "s",     "*l_shadow",
  92         "lm",    "+gl_FrontLightModelProduct.sceneColor.rgb",
  93         "l",     ")",
  94         "e",     "+reflection.rgb*reflectivity",
  95          0,      ";\n",
  96          0,    "\tgl_FragColor.a = ",
  97         "!m",    "1.0",
  98         "!lm",   "v_color.a",
  99         "lm",    "gl_FrontMaterial.diffuse.a",
 100         "t",     "*tex_sample.a",
 101          0,      ";\n",
 102          0,    "}\n",
 103         0, 0
 104 };
 105
 106 }
 107
 108 namespace Msp {
 109 namespace GL {
 110
 111 Program::Program()
 112 {
 113         init();
 114 }
 115
 116 Program::Program(const StandardFeatures &features)
 117 {
 118         init();
 119
 120         add_standard_shaders(features);
 121         if(!features.transform)
 122                 link();
 123 }
 124
 125 Program::Program(const string &vert, const string &frag)
 126 {
 127         init();
 128
 129         attach_shader_owned(new Shader(VERTEX_SHADER, vert));
 130         attach_shader_owned(new Shader(FRAGMENT_SHADER, frag));
 131         link();
 132 }
 133
 134 void Program::init()
 135 {
 136         static Require _req(ARB_shader_objects);
 137
 138         linked = false;
 139         id = glCreateProgram();
 140 }
 141
 142 Program::~Program()
 143 {
 144         for(ShaderList::iterator i=owned_data.begin(); i!=owned_data.end(); ++i)
 145                 delete *i;
 146         glDeleteProgram(id);
 147 }
 148
 149 void Program::attach_shader(Shader &shader)
 150 {
 151         if(find(shaders.begin(), shaders.end(), &shader)==shaders.end())
 152         {
 153                 glAttachShader(id, shader.get_id());
 154                 shaders.push_back(&shader);
 155         }
 156 }
 157
 158 void Program::attach_shader_owned(Shader *shader)
 159 {
 160         attach_shader(*shader);
 161         if(find(owned_data.begin(), owned_data.end(), shader)==owned_data.end())
 162                 owned_data.push_back(shader);
 163 }
 164
 165 void Program::detach_shader(Shader &shader)
 166 {
 167         ShaderList::iterator i = remove(shaders.begin(), shaders.end(), &shader);
 168         if(i!=shaders.end())
 169         {
 170                 shaders.erase(i, shaders.end());
 171                 glDetachShader(id, shader.get_id());
 172         }
 173 }
 174
 175 void Program::add_standard_shaders(const StandardFeatures &features)
 176 {
 177         string flags = features.create_flags();
 178         string vertex_src = process_standard_source(standard_vertex_src, flags);
 179         string fragment_src = process_standard_source(standard_fragment_src, flags);
 180         attach_shader_owned(new Shader(VERTEX_SHADER, vertex_src));
 181         attach_shader_owned(new Shader(FRAGMENT_SHADER, fragment_src));
 182 }
 183
 184 string Program::process_standard_source(const char **source, const string &flags)
 185 {
 186         string result;
 187
 188         for(unsigned i=0; source[i+1]; i+=2)
 189         {
 190                 if(source[i])
 191                 {
 192                         bool cond = true;
 193                         char oper = '&';
 194                         for(const char *c=source[i]; *c; ++c)
 195                         {
 196                                 if(*c>='a' && *c<='z')
 197                                 {
 198                                         bool found = (flags.find(*c)!=string::npos);
 199                                         if(oper=='|')
 200                                                 cond = (cond || found);
 201                                         else if(oper=='!')
 202                                                 cond = (cond && !found);
 203                                         else if(oper=='&')
 204                                                 cond = (cond && found);
 205                                         oper = '&';
 206                                 }
 207                                 else
 208                                         oper = *c;
 209                         }
 210
 211                         if(!cond)
 212                                 continue;
 213                 }
 214
 215                 result += source[i+1];
 216         }
 217
 218         return result;
 219 }
 220
 221 void Program::bind_attribute(unsigned index, const string &name)
 222 {
 223         static Require _req(ARB_vertex_shader);
 224         glBindAttribLocation(id, index, name.c_str());
 225 }
 226
 227 void Program::link()
 228 {
 229         for(ShaderList::iterator i=shaders.begin(); i!=shaders.end(); ++i)
 230                 if(!(*i)->is_compiled())
 231                         (*i)->compile();
 232
 233         uniforms.clear();
 234
 235         glLinkProgram(id);
 236         int value;
 237         glGetProgramiv(id, GL_LINK_STATUS, &value);
 238         if(!(linked = value))
 239                 throw compile_error(get_info_log());
 240
 241         glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &value);
 242         unsigned count = value;
 243         vector<UniformInfo *> uniforms_by_index(count);
 244         for(unsigned i=0; i<count; ++i)
 245         {
 246                 char name[128];
 247                 int len = 0;
 248                 int size;
 249                 GLenum type;
 250                 glGetActiveUniform(id, i, 128, &len, &size, &type, name);
 251                 if(len && strncmp(name, "gl_", 3))
 252                 {
 253                         UniformInfo &info = uniforms[name];
 254                         info.block = 0;
 255                         info.name = name;
 256                         info.size = size;
 257                         info.array_stride = 0;
 258                         info.matrix_stride = 0;
 259                         info.type = type;
 260                         uniforms_by_index[i] = &info;
 261                 }
 262         }
 263
 264         if(ARB_uniform_buffer_object)
 265         {
 266                 glGetProgramiv(id, GL_ACTIVE_UNIFORM_BLOCKS, &value);
 267                 count = value;
 268                 for(unsigned i=0; i<count; ++i)
 269                 {
 270                         char name[128];
 271                         int len;
 272                         glGetActiveUniformBlockName(id, i, 128, &len, name);
 273                         UniformBlockInfo &info = uniform_blocks[name];
 274                         info.name = name;
 275
 276                         glGetActiveUniformBlockiv(id, i, GL_UNIFORM_BLOCK_DATA_SIZE, &value);
 277                         info.data_size = value;
 278
 279                         glGetActiveUniformBlockiv(id, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &value);
 280                         vector<int> indices(value);
 281                         glGetActiveUniformBlockiv(id, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, &indices[0]);
 282                         for(vector<int>::iterator j=indices.begin(); j!=indices.end(); ++j)
 283                         {
 284                                 if(!uniforms_by_index[*j])
 285                                         throw logic_error("Program::link");
 286                                 info.uniforms.push_back(uniforms_by_index[*j]);
 287                                 uniforms_by_index[*j]->block = &info;
 288                         }
 289
 290                         vector<unsigned> indices2(indices.begin(), indices.end());
 291                         vector<int> values(indices.size());
 292                         glGetActiveUniformsiv(id, indices.size(), &indices2[0], GL_UNIFORM_OFFSET, &values[0]);
 293                         for(unsigned j=0; j<indices.size(); ++j)
 294                                 uniforms_by_index[indices[j]]->location = values[j];
 295
 296                         indices2.clear();
 297                         for(vector<int>::iterator j=indices.begin(); j!=indices.end(); ++j)
 298                                 if(uniforms_by_index[*j]->size>1)
 299                                         indices2.push_back(*j);
 300                         if(!indices2.empty())
 301                         {
 302                                 glGetActiveUniformsiv(id, indices2.size(), &indices2[0], GL_UNIFORM_ARRAY_STRIDE, &values[0]);
 303                                 for(unsigned j=0; j<indices2.size(); ++j)
 304                                         uniforms_by_index[indices[j]]->array_stride = values[j];
 305                         }
 306
 307                         indices2.clear();
 308                         for(vector<int>::iterator j=indices.begin(); j!=indices.end(); ++j)
 309                         {
 310                                 GLenum t = uniforms_by_index[*j]->type;
 311                                 if(t==GL_FLOAT_MAT4 || t==GL_FLOAT_MAT3 || t==GL_FLOAT_MAT2 ||
 312                                         t==GL_FLOAT_MAT2x3 || t==GL_FLOAT_MAT2x4 || t==GL_FLOAT_MAT3x2 ||
 313                                         t==GL_FLOAT_MAT3x4 || t==GL_FLOAT_MAT4x2 || t==GL_FLOAT_MAT4x3)
 314                                         indices2.push_back(*j);
 315                         }
 316                         if(!indices2.empty())
 317                         {
 318                                 glGetActiveUniformsiv(id, indices2.size(), &indices2[0], GL_UNIFORM_MATRIX_STRIDE, &values[0]);
 319                                 for(unsigned j=0; j<indices2.size(); ++j)
 320                                         uniforms_by_index[indices[j]]->matrix_stride = values[j];
 321                         }
 322
 323                         sort(info.uniforms.begin(), info.uniforms.end(), uniform_location_compare);
 324                         info.layout_hash = compute_layout_hash(info.uniforms);
 325                         info.bind_point = info.layout_hash%BufferRange::get_n_uniform_buffer_bindings();
 326                         glUniformBlockBinding(id, i, info.bind_point);
 327                 }
 328         }
 329
 330         vector<const UniformInfo *> blockless_uniforms;
 331         for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
 332                 if(!i->second.block)
 333                 {
 334                         i->second.location = glGetUniformLocation(id, i->second.name.c_str());
 335                         blockless_uniforms.push_back(&i->second);
 336                 }
 337
 338         uniform_layout_hash = compute_layout_hash(blockless_uniforms);
 339 }
 340
 341 unsigned Program::compute_layout_hash(const vector<const UniformInfo *> &uniforms)
 342 {
 343         string layout_descriptor;
 344         for(vector<const UniformInfo *>::const_iterator i = uniforms.begin(); i!=uniforms.end(); ++i)
 345                 layout_descriptor += format("%d:%s:%x:%d\n", (*i)->location, (*i)->name, (*i)->type, (*i)->size);
 346         return hash32(layout_descriptor);
 347 }
 348
 349 bool Program::uniform_location_compare(const UniformInfo *uni1, const UniformInfo *uni2)
 350 {
 351         return uni1->location<uni2->location;
 352 }
 353
 354 string Program::get_info_log() const
 355 {
 356         GLsizei len = 0;
 357         glGetProgramiv(id, GL_INFO_LOG_LENGTH, &len);
 358         char *buf = new char[len+1];
 359         glGetProgramInfoLog(id, len+1, &len, buf);
 360         string log(buf, len);
 361         delete[] buf;
 362         return log;
 363 }
 364
 365 const Program::UniformBlockInfo &Program::get_uniform_block_info(const string &name) const
 366 {
 367         return get_item(uniform_blocks, name);
 368 }
 369
 370 const Program::UniformInfo &Program::get_uniform_info(const string &name) const
 371 {
 372         return get_item(uniforms, name);
 373 }
 374
 375 int Program::get_uniform_location(const string &n) const
 376 {
 377         UniformMap::const_iterator i = uniforms.find(n);
 378         if(i==uniforms.end())
 379         {
 380                 if(n[n.size()-1]==']')
 381                 {
 382                         string::size_type open_bracket = n.rfind('[');
 383                         if(open_bracket!=string::npos)
 384                         {
 385                                 /* The requested name looks like an array.  glGetActiveUniform only
 386                                 gives us the first element of the array, so try to look that up and
 387                                 add an offset. */
 388                                 unsigned offset = lexical_cast<unsigned>(n.substr(open_bracket+1, n.size()-2-open_bracket));
 389                                 i = uniforms.find(n.substr(0, open_bracket)+"[0]");
 390                                 if(i!=uniforms.end() && !i->second.block && offset<i->second.size)
 391                                         return i->second.location+offset;
 392                         }
 393                 }
 394                 return -1;
 395         }
 396
 397         return i->second.block ? -1 : i->second.location;
 398 }
 399
 400 void Program::bind() const
 401 {
 402         if(!linked)
 403                 throw invalid_operation("Program::bind");
 404
 405         if(!set_current(this))
 406                 return;
 407
 408         glUseProgram(id);
 409 }
 410
 411 void Program::unbind()
 412 {
 413         if(!set_current(0))
 414                 return;
 415
 416         glUseProgram(0);
 417 }
 418
 419
 420 Program::StandardFeatures::StandardFeatures():
 421         texture(false),
 422         material(false),
 423         lighting(false),
 424         specular(false),
 425         normalmap(false),
 426         shadow(false),
 427         reflection(false),
 428         transform(false)
 429 { }
 430
 431 string Program::StandardFeatures::create_flags() const
 432 {
 433         string flags;
 434         if(texture)
 435                 flags += 't';
 436         if(material)
 437                 flags += 'm';
 438         if(lighting)
 439         {
 440                 flags += 'l';
 441                 if(specular)
 442                         flags += 'p';
 443                 if(normalmap)
 444                         flags += 'n';
 445         }
 446         if(shadow)
 447                 flags += 's';
 448         if(reflection)
 449                 flags += 'e';
 450         if(transform)
 451                 flags += 'r';
 452
 453         return flags;
 454 }
 455
 456
 457 Program::Loader::Loader(Program &p):
 458         DataFile::ObjectLoader<Program>(p)
 459 {
 460         add("attribute",       &Loader::attribute);
 461         add("fragment_shader", &Loader::fragment_shader);
 462         add("standard",        &Loader::standard);
 463         add("vertex_shader",   &Loader::vertex_shader);
 464 }
 465
 466 void Program::Loader::finish()
 467 {
 468         obj.link();
 469 }
 470
 471 void Program::Loader::attribute(unsigned i, const string &n)
 472 {
 473         obj.bind_attribute(i, n);
 474 }
 475
 476 void Program::Loader::fragment_shader(const string &src)
 477 {
 478         obj.attach_shader_owned(new Shader(FRAGMENT_SHADER, src));
 479 }
 480
 481 void Program::Loader::standard()
 482 {
 483         StandardFeatures feat;
 484         load_sub(feat);
 485         obj.add_standard_shaders(feat);
 486 }
 487
 488 void Program::Loader::vertex_shader(const string &src)
 489 {
 490         obj.attach_shader_owned(new Shader(VERTEX_SHADER, src));
 491 }
 492
 493
 494 Program::StandardFeatures::Loader::Loader(StandardFeatures &f):
 495         DataFile::ObjectLoader<StandardFeatures>(f)
 496 {
 497         add("lighting",  &StandardFeatures::lighting);
 498         add("material",  &StandardFeatures::material);
 499         add("normalmap", &StandardFeatures::normalmap);
 500         add("shadow",    &StandardFeatures::shadow);
 501         add("specular",  &StandardFeatures::specular);
 502         add("texture",   &StandardFeatures::texture);
 503         add("transform", &StandardFeatures::transform);
 504 }
 505
 506 } // namespace GL
 507 } // namespace Msp