source/program.cpp

   1 #include <algorithm>
   2 #include "arb_shader_objects.h"
   3 #include "arb_vertex_shader.h"
   4 #include "error.h"
   5 #include "extension.h"
   6 #include "program.h"
   7 #include "shader.h"
   8
   9 using namespace std;
  10
  11 namespace {
  12
  13 const char *standard_vertex_src[] =
  14 {
  15         "n",   "attribute vec3 tangent;\n",
  16         "n",   "attribute vec3 binormal;\n",
  17         "t|n", "varying vec2 v_texcoord;\n",
  18         "s",   "varying vec3 v_shadowcoord;\n",
  19         "!lm", "varying vec4 v_color;\n",
  20         "l!n", "varying vec3 v_normal;\n",
  21         "l",   "varying vec3 v_light_dir;\n",
  22         "p",   "varying vec3 v_eye_dir;\n",
  23         "r",   "vec4 transform_vertex(vec4);\n",
  24         "lr",  "vec3 transform_normal(vec3);\n",
  25          0,    "void main()\n",
  26          0,    "{\n",
  27         "r",   "\tvec4 eye_pos = transform_vertex(gl_Vertex);\n",
  28         "!r",  "\tvec4 eye_pos = gl_ModelViewMatrix*gl_Vertex;\n",
  29          0,    "\tgl_Position = gl_ProjectionMatrix*eye_pos;\n",
  30         "lr",  "\tvec3 eye_normal = transform_normal(gl_Normal);\n",
  31         "l!r", "\tvec3 eye_normal = gl_NormalMatrix*gl_Normal;\n",
  32         "l!n", "\tv_normal = eye_normal;\n",
  33         "n",   "\tvec3 eye_tangent = gl_NormalMatrix*tangent;\n",
  34         "n",   "\tvec3 eye_binormal = gl_NormalMatrix*binormal;\n",
  35         "l",   "\tvec3 eye_light_dir = normalize(gl_LightSource[0].position.xyz-eye_pos.xyz*gl_LightSource[0].position.w);\n",
  36         "n",   "\tv_light_dir = vec3(dot(eye_tangent, eye_light_dir), dot(eye_binormal, eye_light_dir), dot(eye_normal, eye_light_dir));\n",
  37         "l!n", "\tv_light_dir = eye_light_dir;\n",
  38         "p",   "\tvec3 eye_dir = -normalize(eye_pos.xyz);\n",
  39         "pn",  "\tv_eye_dir = vec3(dot(eye_tangent, eye_dir), dot(eye_binormal, eye_dir), dot(eye_normal, eye_dir));\n",
  40         "p!n", "\tv_eye_dir = eye_dir;\n",
  41         "t|n", "\tv_texcoord = gl_MultiTexCoord0.xy;\n",
  42         "s",   "\tv_shadowcoord = vec3(dot(gl_EyePlaneS[3], eye_pos), dot(gl_EyePlaneT[3], eye_pos), dot(gl_EyePlaneR[3], eye_pos));\n",
  43         "!lm", "\tv_color = gl_Color;\n",
  44          0,    "}",
  45         0, 0
  46 };
  47
  48 const char *standard_fragment_src[] =
  49 {
  50         "t",   "uniform sampler2D texture;\n",
  51         "n",   "uniform sampler2D normalmap;\n",
  52         "s",   "uniform sampler2DShadow shadow;\n",
  53         "t|n", "varying vec2 v_texcoord;\n",
  54         "s",   "varying vec3 v_shadowcoord;\n",
  55         "!lm", "varying vec4 v_color;\n",
  56         "l!n", "varying vec3 v_normal;\n",
  57         "l",   "varying vec3 v_light_dir;\n",
  58         "p",   "varying vec3 v_eye_dir;\n",
  59          0,    "void main()\n",
  60          0,    "{\n",
  61         "n",   "\tvec3 n_normal = texture2D(normalmap, v_texcoord).xyz*2.0-1.0;\n",
  62         "l!n", "\tvec3 n_normal = normalize(v_normal);\n",
  63         "l",   "\tfloat l_diffuse = max(dot(n_normal, normalize(v_light_dir)), 0.0);\n",
  64         "p",   "\tvec3 half_dir = normalize(v_eye_dir+v_light_dir);\n",
  65         "p",   "\tfloat l_specular = pow(max(dot(half_dir, n_normal), 0.0), gl_FrontMaterial.shininess);\n",
  66         "s",   "\tfloat l_shadow = shadow2D(shadow, v_shadowcoord).r;\n",
  67          0,    "\tgl_FragColor = ",
  68         "!t!l!m", "vec4(1.0, 1.0, 1.0, 1.0)",
  69         "t",     "texture2D(texture, v_texcoord)",
  70         "l|mt",  "*",
  71         "!lm",   "v_color",
  72         "l",     "((l_diffuse",
  73         "lm",    "*gl_FrontLightProduct[0].diffuse",
  74         "p",     "+l_specular",
  75         "pm",    "*gl_FrontLightProduct[0].specular",
  76         "l",     ")",
  77         "s",     "*l_shadow",
  78         "lm",    "+gl_FrontLightModelProduct.sceneColor",
  79         "l",     ")",
  80          0,      ";\n",
  81          0,    "}\n",
  82         0, 0
  83 };
  84
  85 }
  86
  87 namespace Msp {
  88 namespace GL {
  89
  90 Program::Program():
  91         del_shaders(false)
  92 {
  93         init();
  94 }
  95
  96 Program::Program(const StandardFeatures &features):
  97         del_shaders(true)
  98 {
  99         init();
 100
 101         add_standard_shaders(features);
 102         link();
 103 }
 104
 105 Program::Program(const string &vert, const string &frag):
 106         del_shaders(true)
 107 {
 108         init();
 109
 110         attach_shader(*new Shader(VERTEX_SHADER, vert));
 111         attach_shader(*new Shader(FRAGMENT_SHADER, frag));
 112         link();
 113 }
 114
 115 void Program::init()
 116 {
 117         static RequireExtension _ext("GL_ARB_shader_objects");
 118
 119         linked = false;
 120         id = glCreateProgramObjectARB();
 121 }
 122
 123 Program::~Program()
 124 {
 125         if(del_shaders)
 126         {
 127                 for(list<Shader *>::iterator i=shaders.begin(); i!=shaders.end(); ++i)
 128                         delete *i;
 129         }
 130         glDeleteObjectARB(id);
 131 }
 132
 133 void Program::attach_shader(Shader &shader)
 134 {
 135         if(find(shaders.begin(), shaders.end(), &shader)==shaders.end())
 136         {
 137                 glAttachObjectARB(id, shader.get_id());
 138                 shaders.push_back(&shader);
 139         }
 140 }
 141
 142 void Program::detach_shader(Shader &shader)
 143 {
 144         list<Shader *>::iterator i = remove(shaders.begin(), shaders.end(), &shader);
 145         if(i!=shaders.end())
 146         {
 147                 shaders.erase(i, shaders.end());
 148                 glDetachObjectARB(id, shader.get_id());
 149         }
 150 }
 151
 152 void Program::add_standard_shaders(const StandardFeatures &features)
 153 {
 154         string flags = features.create_flags();
 155         string vertex_src = process_standard_source(standard_vertex_src, flags);
 156         string fragment_src = process_standard_source(standard_fragment_src, flags);
 157         attach_shader(*new Shader(VERTEX_SHADER, vertex_src));
 158         attach_shader(*new Shader(FRAGMENT_SHADER, fragment_src));
 159 }
 160
 161 string Program::process_standard_source(const char **source, const string &flags)
 162 {
 163         string result;
 164
 165         for(unsigned i=0; source[i+1]; i+=2)
 166         {
 167                 if(source[i])
 168                 {
 169                         bool cond = true;
 170                         char oper = '&';
 171                         for(const char *c=source[i]; *c; ++c)
 172                         {
 173                                 if(*c>='a' && *c<='z')
 174                                 {
 175                                         bool found = (flags.find(*c)!=string::npos);
 176                                         if(oper=='|')
 177                                                 cond = (cond || found);
 178                                         else if(oper=='!')
 179                                                 cond = (cond && !found);
 180                                         else if(oper=='&')
 181                                                 cond = (cond && found);
 182                                         oper = '&';
 183                                 }
 184                                 else
 185                                         oper = *c;
 186                         }
 187
 188                         if(!cond)
 189                                 continue;
 190                 }
 191
 192                 result += source[i+1];
 193         }
 194
 195         return result;
 196 }
 197
 198 void Program::set_del_shaders(bool ds)
 199 {
 200         del_shaders = ds;
 201 }
 202
 203 void Program::bind_attribute(unsigned index, const string &name)
 204 {
 205         static RequireExtension _ext("GL_ARB_vertex_shader");
 206         glBindAttribLocationARB(id, index, name.c_str());
 207 }
 208
 209 void Program::link()
 210 {
 211         for(list<Shader *>::iterator i=shaders.begin(); i!=shaders.end(); ++i)
 212                 if(!(*i)->is_compiled())
 213                         (*i)->compile();
 214
 215         uniforms.clear();
 216
 217         glLinkProgramARB(id);
 218         int value;
 219         glGetObjectParameterivARB(id, GL_OBJECT_LINK_STATUS_ARB, &value);
 220         if(!(linked = value))
 221                 throw compile_error(get_info_log());
 222
 223         glGetObjectParameterivARB(id, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &value);
 224         for(int i=0; i<value; ++i)
 225         {
 226                 UniformInfo info;
 227                 char name[128];
 228                 int len = 0;
 229                 glGetActiveUniformARB(id, i, 128, &len, &info.size, &info.type, name);
 230                 if(len)
 231                 {
 232                         info.name = name;
 233                         info.location = glGetUniformLocationARB(id, name);
 234                         uniforms[name] = info;
 235                 }
 236         }
 237 }
 238
 239 string Program::get_info_log() const
 240 {
 241         GLsizei len = 0;
 242         glGetObjectParameterivARB(id, GL_OBJECT_INFO_LOG_LENGTH_ARB, &len);
 243         char log[len+1];
 244         glGetInfoLogARB(id, len+1, &len, log);
 245         return string(log, len);
 246 }
 247
 248 void Program::bind() const
 249 {
 250         if(!linked)
 251                 throw invalid_operation("Program::bind");
 252
 253         if(!set_current(this))
 254                 return;
 255
 256         glUseProgramObjectARB(id);
 257 }
 258
 259 int Program::get_uniform_location(const string &n) const
 260 {
 261         map<string, UniformInfo>::const_iterator i = uniforms.find(n);
 262         if(i==uniforms.end())
 263                 return -1;
 264
 265         return i->second.location;
 266 }
 267
 268 void Program::unbind()
 269 {
 270         if(!set_current(0))
 271                 return;
 272
 273         glUseProgramObjectARB(0);
 274 }
 275
 276
 277 Program::StandardFeatures::StandardFeatures():
 278         texture(false),
 279         material(false),
 280         lighting(false),
 281         specular(false),
 282         normalmap(false),
 283         shadow(false),
 284         transform(false)
 285 { }
 286
 287 string Program::StandardFeatures::create_flags() const
 288 {
 289         string flags;
 290         if(texture)
 291                 flags += 't';
 292         if(material)
 293                 flags += 'm';
 294         if(lighting)
 295         {
 296                 flags += 'l';
 297                 if(specular)
 298                         flags += 'p';
 299                 if(normalmap)
 300                         flags += 'n';
 301         }
 302         if(shadow)
 303                 flags += 's';
 304         if(transform)
 305                 flags += 'r';
 306
 307         return flags;
 308 }
 309
 310
 311 Program::Loader::Loader(Program &p):
 312         DataFile::ObjectLoader<Program>(p)
 313 {
 314         obj.set_del_shaders(true);
 315
 316         add("attribute",       &Loader::attribute);
 317         add("fragment_shader", &Loader::fragment_shader);
 318         add("standard",        &Loader::standard);
 319         add("vertex_shader",   &Loader::vertex_shader);
 320 }
 321
 322 void Program::Loader::finish()
 323 {
 324         obj.link();
 325 }
 326
 327 void Program::Loader::attribute(unsigned i, const string &n)
 328 {
 329         obj.bind_attribute(i, n);
 330 }
 331
 332 void Program::Loader::fragment_shader(const string &src)
 333 {
 334         obj.attach_shader(*new Shader(FRAGMENT_SHADER, src));
 335 }
 336
 337 void Program::Loader::standard()
 338 {
 339         StandardFeatures feat;
 340         load_sub(feat);
 341         obj.add_standard_shaders(feat);
 342 }
 343
 344 void Program::Loader::vertex_shader(const string &src)
 345 {
 346         obj.attach_shader(*new Shader(VERTEX_SHADER, src));
 347 }
 348
 349
 350 Program::StandardFeatures::Loader::Loader(StandardFeatures &f):
 351         DataFile::ObjectLoader<StandardFeatures>(f)
 352 {
 353         add("lighting",  &StandardFeatures::lighting);
 354         add("material",  &StandardFeatures::material);
 355         add("normalmap", &StandardFeatures::normalmap);
 356         add("shadow",    &StandardFeatures::shadow);
 357         add("specular",  &StandardFeatures::specular);
 358         add("texture",   &StandardFeatures::texture);
 359         add("transform", &StandardFeatures::transform);
 360 }
 361
 362 } // namespace GL
 363 } // namespace Msp