source/backends/opengl/program_backend.cpp

   1 #include <cstring>
   2 #include <msp/core/algorithm.h>
   3 #include <msp/gl/extensions/arb_es2_compatibility.h>
   4 #include <msp/gl/extensions/arb_fragment_shader.h>
   5 #include <msp/gl/extensions/arb_gl_spirv.h>
   6 #include <msp/gl/extensions/arb_geometry_shader4.h>
   7 #include <msp/gl/extensions/arb_separate_shader_objects.h>
   8 #include <msp/gl/extensions/arb_shader_objects.h>
   9 #include <msp/gl/extensions/arb_uniform_buffer_object.h>
  10 #include <msp/gl/extensions/arb_vertex_shader.h>
  11 #include <msp/gl/extensions/ext_gpu_shader4.h>
  12 #include <msp/gl/extensions/khr_debug.h>
  13 #include <msp/gl/extensions/nv_non_square_matrices.h>
  14 #include <msp/io/print.h>
  15 #include "error.h"
  16 #include "program.h"
  17 #include "program_backend.h"
  18 #include "glsl/compiler.h"
  19
  20 using namespace std;
  21
  22 namespace {
  23
  24 template<typename T, void (*&func)(GLint, GLsizei, const T *)>
  25 void uniform_wrapper(unsigned index, unsigned count, const void *data)
  26 {
  27         func(index, count, static_cast<const T *>(data));
  28 }
  29
  30 template<typename T, void (*&func)(GLint, GLsizei, GLboolean, const T *)>
  31 void uniform_matrix_wrapper(unsigned index, unsigned count, const void *data)
  32 {
  33         func(index, count, false, static_cast<const T *>(data));
  34 }
  35
  36 }
  37
  38 namespace Msp {
  39 namespace GL {
  40
  41 OpenGLProgram::OpenGLProgram()
  42 {
  43         static Require _req(ARB_shader_objects);
  44
  45         id = glCreateProgram();
  46 }
  47
  48 OpenGLProgram::~OpenGLProgram()
  49 {
  50         for(unsigned i=0; i<MAX_STAGES; ++i)
  51                 if(stage_ids[i])
  52                         glDeleteShader(stage_ids[i]);
  53         glDeleteProgram(id);
  54 }
  55
  56 bool OpenGLProgram::has_stages() const
  57 {
  58         for(unsigned i=0; i<MAX_STAGES; ++i)
  59                 if(stage_ids[i])
  60                         return true;
  61         return false;
  62 }
  63
  64 unsigned OpenGLProgram::add_stage(Stage type)
  65 {
  66         GLenum gl_type;
  67         switch(type)
  68         {
  69         case VERTEX: { static Require _req(ARB_vertex_shader); gl_type = GL_VERTEX_SHADER; } break;
  70         case GEOMETRY: { static Require _req(ARB_geometry_shader4); gl_type = GL_GEOMETRY_SHADER; } break;
  71         case FRAGMENT: { static Require _req(ARB_fragment_shader); gl_type = GL_FRAGMENT_SHADER; } break;
  72         default: throw invalid_argument("OpenGLProgram::add_stage");
  73         }
  74
  75         if(stage_ids[type])
  76                 throw invalid_operation("OpenGLProgram::add_stage");
  77
  78         unsigned stage_id = glCreateShader(gl_type);
  79         stage_ids[type] = stage_id;
  80         glAttachShader(id, stage_id);
  81
  82 #ifdef DEBUG
  83         if(!debug_name.empty() && KHR_debug)
  84                 set_stage_debug_name(stage_id, type);
  85 #endif
  86
  87         return stage_id;
  88 }
  89
  90 void OpenGLProgram::add_glsl_stages(const GlslModule &mod, const map<string, int> &spec_values, TransientData &transient)
  91 {
  92         SL::Compiler compiler;
  93         compiler.set_source(mod.get_prepared_source(), "<module>");
  94         compiler.specialize(spec_values);
  95         compiler.compile(SL::Compiler::PROGRAM);
  96 #ifdef DEBUG
  97         string diagnostics = compiler.get_diagnostics();
  98         if(!diagnostics.empty())
  99                 IO::print("Program diagnostics:\n%s\n", diagnostics);
 100 #endif
 101
 102         vector<SL::Stage::Type> stages = compiler.get_stages();
 103         if(stages.empty())
 104                 throw invalid_argument("OpenGLProgram::add_glsl_stages");
 105
 106         for(SL::Stage::Type st: stages)
 107         {
 108                 unsigned stage_id = 0;
 109                 switch(st)
 110                 {
 111                 case SL::Stage::VERTEX: stage_id = add_stage(VERTEX); break;
 112                 case SL::Stage::GEOMETRY: stage_id = add_stage(GEOMETRY); break;
 113                 case SL::Stage::FRAGMENT: stage_id = add_stage(FRAGMENT); break;
 114                 default: throw invalid_operation("OpenGLProgram::add_glsl_stages");
 115                 }
 116
 117                 string stage_src = compiler.get_stage_glsl(st);
 118                 const char *src_ptr = stage_src.data();
 119                 int src_len = stage_src.size();
 120                 glShaderSource(stage_id, 1, &src_ptr, &src_len);
 121
 122                 if(st==SL::Stage::VERTEX)
 123                 {
 124                         for(const auto &kvp: compiler.get_vertex_attributes())
 125                                 glBindAttribLocation(id, kvp.second, kvp.first.c_str());
 126                 }
 127
 128                 if(st==SL::Stage::FRAGMENT && EXT_gpu_shader4)
 129                 {
 130                         for(const auto &kvp: compiler.get_fragment_outputs())
 131                                 glBindFragDataLocation(id, kvp.second, kvp.first.c_str());
 132                 }
 133
 134                 compile_glsl_stage(mod, stage_id);
 135         }
 136
 137         transient.textures = compiler.get_texture_bindings();
 138         transient.blocks = compiler.get_uniform_block_bindings();
 139
 140         ReflectData &rd = static_cast<Program *>(this)->reflect_data;
 141         rd.n_clip_distances = compiler.get_n_clip_distances();
 142 }
 143
 144 void OpenGLProgram::compile_glsl_stage(const GlslModule &mod, unsigned stage_id)
 145 {
 146         glCompileShader(stage_id);
 147         int status = 0;
 148         glGetShaderiv(stage_id, GL_COMPILE_STATUS, &status);
 149
 150         int info_log_len = 0;
 151         glGetShaderiv(stage_id, GL_INFO_LOG_LENGTH, &info_log_len);
 152         string info_log(info_log_len+1, 0);
 153         glGetShaderInfoLog(stage_id, info_log_len+1, &info_log_len, &info_log[0]);
 154         info_log.erase(info_log_len);
 155         info_log = mod.get_source_map().translate_errors(info_log);
 156
 157         if(!status)
 158                 throw compile_error(info_log);
 159 #ifdef DEBUG
 160         if(!info_log.empty())
 161                 IO::print("Shader compile info log:\n%s", info_log);
 162 #endif
 163 }
 164
 165 void OpenGLProgram::add_spirv_stages(const SpirVModule &mod, const map<string, int> &spec_values, TransientData &transient)
 166 {
 167         static Require _req(ARB_gl_spirv);
 168         static Require _req2(ARB_ES2_compatibility);
 169
 170         unsigned n_stages = 0;
 171         unsigned used_stage_ids[MAX_STAGES];
 172         for(const SpirVModule::EntryPoint &e: mod.get_entry_points())
 173         {
 174                 unsigned stage_id = 0;
 175                 switch(e.stage)
 176                 {
 177                 case SpirVModule::VERTEX: stage_id = add_stage(VERTEX); break;
 178                 case SpirVModule::GEOMETRY: stage_id = add_stage(GEOMETRY); break;
 179                 case SpirVModule::FRAGMENT: stage_id = add_stage(FRAGMENT); break;
 180                 default: throw invalid_operation("OpenGLProgram::add_spirv_stages");
 181                 }
 182
 183                 used_stage_ids[n_stages++] = stage_id;
 184         }
 185
 186         if(!n_stages)
 187                 throw invalid_argument("OpenGLProgram::add_spirv_stages");
 188
 189         const vector<uint32_t> &code = mod.get_code();
 190         glShaderBinary(n_stages, used_stage_ids, GL_SHADER_BINARY_FORMAT_SPIR_V, &code[0], code.size()*4);
 191
 192         const vector<SpirVModule::Constant> &spec_consts = mod.get_spec_constants();
 193         vector<unsigned> spec_id_array;
 194         vector<unsigned> spec_value_array;
 195         spec_id_array.reserve(spec_consts.size());
 196         spec_value_array.reserve(spec_consts.size());
 197         for(const SpirVModule::Constant &c: spec_consts)
 198         {
 199                 auto i = spec_values.find(c.name);
 200                 if(i!=spec_values.end())
 201                 {
 202                         spec_id_array.push_back(c.constant_id);
 203                         spec_value_array.push_back(i->second);
 204                         transient.spec_values[c.constant_id] = i->second;
 205                 }
 206         }
 207
 208         auto j = mod.get_entry_points().begin();
 209         for(unsigned i=0; i<MAX_STAGES; ++i)
 210                 if(stage_ids[i])
 211                         glSpecializeShader(stage_ids[i], j->name.c_str(), spec_id_array.size(), &spec_id_array[0], &spec_value_array[0]);
 212 }
 213
 214 void OpenGLProgram::finalize(const Module &mod)
 215 {
 216         glLinkProgram(id);
 217         int status = 0;
 218         glGetProgramiv(id, GL_LINK_STATUS, &status);
 219         linked = status;
 220
 221         int info_log_len = 0;
 222         glGetProgramiv(id, GL_INFO_LOG_LENGTH, &info_log_len);
 223         string info_log(info_log_len+1, 0);
 224         glGetProgramInfoLog(id, info_log_len+1, &info_log_len, &info_log[0]);
 225         info_log.erase(info_log_len);
 226         if(mod.get_format()==Module::GLSL)
 227                 info_log = static_cast<const GlslModule &>(mod).get_source_map().translate_errors(info_log);
 228
 229         if(!linked)
 230                 throw compile_error(info_log);
 231 #ifdef DEBUG
 232         if(!info_log.empty())
 233                 IO::print("Program link info log:\n%s", info_log);
 234 #endif
 235 }
 236
 237 void OpenGLProgram::query_uniforms()
 238 {
 239         ReflectData &rd = static_cast<Program *>(this)->reflect_data;
 240
 241         unsigned count = 0;
 242         glGetProgramiv(id, GL_ACTIVE_UNIFORMS, reinterpret_cast<int *>(&count));
 243         rd.uniforms.reserve(count);
 244         vector<string> uniform_names(count);
 245         for(unsigned i=0; i<count; ++i)
 246         {
 247                 char name[128];
 248                 int len = 0;
 249                 int size;
 250                 GLenum type;
 251                 glGetActiveUniform(id, i, sizeof(name), &len, &size, &type, name);
 252                 if(len && strncmp(name, "gl_", 3))
 253                 {
 254                         /* Some implementations report the first element of a uniform array,
 255                         others report just the name of the array itself. */
 256                         if(len>3 && !strcmp(name+len-3, "[0]"))
 257                                 name[len-3] = 0;
 258
 259                         rd.uniforms.push_back(ReflectData::UniformInfo());
 260                         ReflectData::UniformInfo &info = rd.uniforms.back();
 261                         info.name = name;
 262                         info.tag = name;
 263                         info.array_size = size;
 264                         info.type = from_gl_type(type);
 265                         uniform_names[i] = name;
 266                 }
 267         }
 268
 269         sort_member(rd.uniforms, &ReflectData::UniformInfo::tag);
 270
 271         if(ARB_uniform_buffer_object)
 272         {
 273                 vector<ReflectData::UniformInfo *> uniforms_by_index(count);
 274                 for(unsigned i=0; i<count; ++i)
 275                         if(!uniform_names[i].empty())
 276                                 // The element is already known to be present
 277                                 uniforms_by_index[i] = &*lower_bound_member(rd.uniforms, Tag(uniform_names[i]), &ReflectData::UniformInfo::tag);
 278                 query_uniform_blocks(uniforms_by_index);
 279         }
 280
 281         rd.uniform_blocks.push_back(ReflectData::UniformBlockInfo());
 282         ReflectData::UniformBlockInfo &default_block = rd.uniform_blocks.back();
 283
 284         for(ReflectData::UniformInfo &u: rd.uniforms)
 285                 if(!u.block)
 286                 {
 287                         u.location = glGetUniformLocation(id, u.name.c_str());
 288                         u.block = &default_block;
 289                         u.array_stride = get_type_size(u.type);
 290                         if(is_matrix(u.type))
 291                                 u.matrix_stride = get_type_size(get_matrix_column_type(u.type));
 292                         default_block.uniforms.push_back(&u);
 293
 294                         if(u.location>=0)
 295                         {
 296                                 UniformCall::FuncPtr func = 0;
 297                                 if(is_image(u.type))
 298                                         glGetUniformiv(id, u.location, &u.binding);
 299                                 else if(u.type==FLOAT)
 300                                         func = &uniform_wrapper<float, glUniform1fv>;
 301                                 else if(u.type==FLOAT_VEC2)
 302                                         func = &uniform_wrapper<float, glUniform2fv>;
 303                                 else if(u.type==FLOAT_VEC3)
 304                                         func = &uniform_wrapper<float, glUniform3fv>;
 305                                 else if(u.type==FLOAT_VEC4)
 306                                         func = &uniform_wrapper<float, glUniform4fv>;
 307                                 else if(u.type==INT)
 308                                         func = &uniform_wrapper<int, glUniform1iv>;
 309                                 else if(u.type==INT_VEC2)
 310                                         func = &uniform_wrapper<int, glUniform2iv>;
 311                                 else if(u.type==INT_VEC3)
 312                                         func = &uniform_wrapper<int, glUniform3iv>;
 313                                 else if(u.type==INT_VEC4)
 314                                         func = &uniform_wrapper<int, glUniform4iv>;
 315                                 else if(u.type==UNSIGNED_INT)
 316                                         func = &uniform_wrapper<unsigned, glUniform1uiv>;
 317                                 else if(u.type==UINT_VEC2)
 318                                         func = &uniform_wrapper<unsigned, glUniform2uiv>;
 319                                 else if(u.type==UINT_VEC3)
 320                                         func = &uniform_wrapper<unsigned, glUniform3uiv>;
 321                                 else if(u.type==UINT_VEC4)
 322                                         func = &uniform_wrapper<unsigned, glUniform4uiv>;
 323                                 else if(u.type==FLOAT_MAT2)
 324                                         func = &uniform_matrix_wrapper<float, glUniformMatrix2fv>;
 325                                 else if(u.type==FLOAT_MAT3)
 326                                         func = &uniform_matrix_wrapper<float, glUniformMatrix3fv>;
 327                                 else if(u.type==FLOAT_MAT4)
 328                                         func = &uniform_matrix_wrapper<float, glUniformMatrix4fv>;
 329                                 else if(u.type==FLOAT_MAT2x3)
 330                                         func = &uniform_matrix_wrapper<float, glUniformMatrix2x3fv>;
 331                                 else if(u.type==FLOAT_MAT3x2)
 332                                         func = &uniform_matrix_wrapper<float, glUniformMatrix3x2fv>;
 333                                 else if(u.type==FLOAT_MAT2x4)
 334                                         func = &uniform_matrix_wrapper<float, glUniformMatrix2x4fv>;
 335                                 else if(u.type==FLOAT_MAT4x2)
 336                                         func = &uniform_matrix_wrapper<float, glUniformMatrix4x2fv>;
 337                                 else if(u.type==FLOAT_MAT3x4)
 338                                         func = &uniform_matrix_wrapper<float, glUniformMatrix3x4fv>;
 339                                 else if(u.type==FLOAT_MAT4x3)
 340                                         func = &uniform_matrix_wrapper<float, glUniformMatrix4x3fv>;
 341
 342                                 if(func)
 343                                         uniform_calls.push_back(UniformCall(u.location, u.array_size, func));
 344                         }
 345                 }
 346
 347         default_block.sort_uniforms();
 348         default_block.update_layout_hash();
 349         rd.update_layout_hash();
 350 }
 351
 352 void OpenGLProgram::query_uniform_blocks(const vector<ReflectData::UniformInfo *> &uniforms_by_index)
 353 {
 354         ReflectData &rd = static_cast<Program *>(this)->reflect_data;
 355
 356         unsigned count = 0;
 357         glGetProgramiv(id, GL_ACTIVE_UNIFORM_BLOCKS, reinterpret_cast<int *>(&count));
 358         // Reserve an extra index for the default block
 359         rd.uniform_blocks.reserve(count+1);
 360         for(unsigned i=0; i<count; ++i)
 361         {
 362                 char name[128];
 363                 int len;
 364                 glGetActiveUniformBlockName(id, i, sizeof(name), &len, name);
 365                 rd.uniform_blocks.push_back(ReflectData::UniformBlockInfo());
 366                 ReflectData::UniformBlockInfo &info = rd.uniform_blocks.back();
 367                 info.name = name;
 368
 369                 int value;
 370                 glGetActiveUniformBlockiv(id, i, GL_UNIFORM_BLOCK_DATA_SIZE, &value);
 371                 info.data_size = value;
 372
 373                 glGetActiveUniformBlockiv(id, i, GL_UNIFORM_BLOCK_BINDING, &value);
 374                 info.bind_point = value;
 375
 376                 glGetActiveUniformBlockiv(id, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &value);
 377                 vector<int> indices(value);
 378                 glGetActiveUniformBlockiv(id, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, &indices[0]);
 379                 for(int j: indices)
 380                 {
 381                         if(!uniforms_by_index[j])
 382                                 throw logic_error("OpenGLProgram::query_uniform_blocks");
 383                         info.uniforms.push_back(uniforms_by_index[j]);
 384                         uniforms_by_index[j]->block = &info;
 385                 }
 386
 387                 vector<unsigned> query_indices(indices.begin(), indices.end());
 388                 vector<int> values(indices.size());
 389                 glGetActiveUniformsiv(id, query_indices.size(), &query_indices[0], GL_UNIFORM_OFFSET, &values[0]);
 390                 for(unsigned j=0; j<indices.size(); ++j)
 391                         uniforms_by_index[indices[j]]->offset = values[j];
 392
 393                 query_indices.clear();
 394                 for(int j: indices)
 395                         if(uniforms_by_index[j]->array_size>1)
 396                                 query_indices.push_back(j);
 397                 if(!query_indices.empty())
 398                 {
 399                         glGetActiveUniformsiv(id, query_indices.size(), &query_indices[0], GL_UNIFORM_ARRAY_STRIDE, &values[0]);
 400                         for(unsigned j=0; j<query_indices.size(); ++j)
 401                                 uniforms_by_index[query_indices[j]]->array_stride = values[j];
 402                 }
 403
 404                 query_indices.clear();
 405                 for(int j: indices)
 406                 {
 407                         DataType t = uniforms_by_index[j]->type;
 408                         if(is_matrix(t))
 409                                 query_indices.push_back(j);
 410                 }
 411                 if(!query_indices.empty())
 412                 {
 413                         glGetActiveUniformsiv(id, query_indices.size(), &query_indices[0], GL_UNIFORM_MATRIX_STRIDE, &values[0]);
 414                         for(unsigned j=0; j<query_indices.size(); ++j)
 415                                 uniforms_by_index[query_indices[j]]->matrix_stride = values[j];
 416                 }
 417
 418                 info.sort_uniforms();
 419                 info.update_layout_hash();
 420         }
 421 }
 422
 423 void OpenGLProgram::query_attributes()
 424 {
 425         ReflectData &rd = static_cast<Program *>(this)->reflect_data;
 426
 427         unsigned count = 0;
 428         glGetProgramiv(id, GL_ACTIVE_ATTRIBUTES, reinterpret_cast<int *>(&count));
 429         rd.attributes.reserve(count);
 430         for(unsigned i=0; i<count; ++i)
 431         {
 432                 char name[128];
 433                 int len = 0;
 434                 int size;
 435                 GLenum type;
 436                 glGetActiveAttrib(id, i, sizeof(name), &len, &size, &type, name);
 437                 if(len && strncmp(name, "gl_", 3))
 438                 {
 439                         if(len>3 && !strcmp(name+len-3, "[0]"))
 440                                 name[len-3] = 0;
 441
 442                         rd.attributes.push_back(ReflectData::AttributeInfo());
 443                         ReflectData::AttributeInfo &info = rd.attributes.back();
 444                         info.name = name;
 445                         info.location = glGetAttribLocation(id, name);
 446                         info.array_size = size;
 447                         info.type = from_gl_type(type);
 448                 }
 449         }
 450 }
 451
 452 void OpenGLProgram::apply_bindings(const TransientData &transient)
 453 {
 454         ReflectData &rd = static_cast<Program *>(this)->reflect_data;
 455
 456         for(unsigned i=0; i<rd.uniform_blocks.size(); ++i)
 457         {
 458                 auto j = transient.blocks.find(rd.uniform_blocks[i].name);
 459                 if(j!=transient.blocks.end())
 460                 {
 461                         glUniformBlockBinding(id, i, j->second);
 462                         rd.uniform_blocks[i].bind_point = j->second;
 463                 }
 464         }
 465
 466         if(!ARB_separate_shader_objects)
 467                 glUseProgram(id);
 468         for(const auto &kvp: transient.textures)
 469         {
 470                 int location = static_cast<const Program *>(this)->get_uniform_location(kvp.first);
 471                 if(location>=0)
 472                 {
 473                         if(ARB_separate_shader_objects)
 474                                 glProgramUniform1i(id, location, kvp.second);
 475                         else
 476                                 glUniform1i(location, kvp.second);
 477                 }
 478         }
 479 }
 480
 481 void OpenGLProgram::set_debug_name(const string &name)
 482 {
 483 #ifdef DEBUG
 484         debug_name = name;
 485         if(KHR_debug)
 486         {
 487                 glObjectLabel(GL_PROGRAM, id, name.size(), name.c_str());
 488                 for(unsigned i=0; i<MAX_STAGES; ++i)
 489                         if(stage_ids[i])
 490                                 set_stage_debug_name(stage_ids[i], static_cast<Stage>(i));
 491         }
 492 #else
 493         (void)name;
 494 #endif
 495 }
 496
 497 void OpenGLProgram::set_stage_debug_name(unsigned stage_id, Stage type)
 498 {
 499 #ifdef DEBUG
 500         static const char *const suffixes[] = { " [VS]", " [GS]", " [FS]" };
 501         string name = debug_name+suffixes[type];
 502         glObjectLabel(GL_SHADER, stage_id, name.size(), name.c_str());
 503 #else
 504         (void)stage_id; (void)type;
 505 #endif
 506 }
 507
 508 } // namespace GL
 509 } // namespace Msp