X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fcore%2Fprogram.cpp;h=473d8a0b0d2c79e8a147e4b278e02ffbf303cb73;hp=6fdf747d99d477078ab2421cd325989a455aca82;hb=3a1b9cbe2441ae670a97541dc8ccb0a2860c8302;hpb=63383e58b25321188cbc65bf9a6bc7e2a0faaabb diff --git a/source/core/program.cpp b/source/core/program.cpp index 6fdf747d..473d8a0b 100644 --- a/source/core/program.cpp +++ b/source/core/program.cpp @@ -1,16 +1,19 @@ -#include #include #include +#include #include #include +#include #include #include #include #include +#include #include #include #include #include +#include #include #include #include @@ -32,7 +35,7 @@ Program::Program() init(); } -Program::Program(const std::string &source) +Program::Program(const string &source) { init(); @@ -68,20 +71,23 @@ void Program::init() static Require _req(ARB_shader_objects); id = glCreateProgram(); + fill(stage_ids, stage_ids+MAX_STAGES, 0); module = 0; + transient = 0; linked = false; } Program::~Program() { - for(vector::iterator i=stage_ids.begin(); i!=stage_ids.end(); ++i) - glDeleteShader(*i); + for(unsigned i=0; i &spec_values) { - if(!stage_ids.empty()) + if(has_stages()) throw invalid_operation("Program::add_stages"); switch(mod.get_format()) @@ -92,20 +98,37 @@ void Program::add_stages(const Module &mod, const map &spec_values) } } -unsigned Program::add_stage(GLenum type) +bool Program::has_stages() const { + for(unsigned i=0; i &spe #endif vector stages = compiler.get_stages(); - for(vector::const_iterator i=stages.begin(); i!=stages.end(); ++i) + for(SL::Stage::Type st: stages) { unsigned stage_id = 0; - switch(*i) + switch(st) { - case SL::Stage::VERTEX: stage_id = add_stage(GL_VERTEX_SHADER); break; - case SL::Stage::GEOMETRY: stage_id = add_stage(GL_GEOMETRY_SHADER); break; - case SL::Stage::FRAGMENT: stage_id = add_stage(GL_FRAGMENT_SHADER); break; + case SL::Stage::VERTEX: stage_id = add_stage(VERTEX); break; + case SL::Stage::GEOMETRY: stage_id = add_stage(GEOMETRY); break; + case SL::Stage::FRAGMENT: stage_id = add_stage(FRAGMENT); break; default: throw invalid_operation("Program::add_glsl_stages"); } - string stage_src = compiler.get_stage_glsl(*i); + string stage_src = compiler.get_stage_glsl(st); const char *src_ptr = stage_src.data(); int src_len = stage_src.size(); glShaderSource(stage_id, 1, &src_ptr, &src_len); - if(*i==SL::Stage::VERTEX) + if(st==SL::Stage::VERTEX) { - const map &attribs = compiler.get_vertex_attributes(); - for(map::const_iterator j=attribs.begin(); j!=attribs.end(); ++j) - glBindAttribLocation(id, j->second, j->first.c_str()); + for(const auto &kvp: compiler.get_vertex_attributes()) + glBindAttribLocation(id, kvp.second, kvp.first.c_str()); } - if(*i==SL::Stage::FRAGMENT && EXT_gpu_shader4) + if(st==SL::Stage::FRAGMENT && EXT_gpu_shader4) { - const map &frag_outs = compiler.get_fragment_outputs(); - for(map::const_iterator j=frag_outs.begin(); j!=frag_outs.end(); ++j) - glBindFragDataLocation(id, j->second, j->first.c_str()); + for(const auto &kvp: compiler.get_fragment_outputs()) + glBindFragDataLocation(id, kvp.second, kvp.first.c_str()); } compile_glsl_stage(stage_id); } + + if(!transient) + transient = new TransientData; + transient->textures = compiler.get_texture_bindings(); + transient->blocks = compiler.get_uniform_block_bindings(); } void Program::compile_glsl_stage(unsigned stage_id) @@ -185,45 +211,48 @@ void Program::add_spirv_stages(const SpirVModule &mod, const map &s module = &mod; - const vector &entry_points = mod.get_entry_points(); - std::set stages; - for(vector::const_iterator i=entry_points.begin(); i!=entry_points.end(); ++i) + unsigned n_stages = 0; + unsigned used_stage_ids[MAX_STAGES]; + for(const SpirVModule::EntryPoint &e: mod.get_entry_points()) { - if(stages.count(i->stage)) - throw invalid_argument("Program::add_spirv_stages"); - - switch(i->stage) + unsigned stage_id = 0; + switch(e.stage) { - case SpirVModule::VERTEX: add_stage(GL_VERTEX_SHADER); break; - case SpirVModule::GEOMETRY: add_stage(GL_GEOMETRY_SHADER); break; - case SpirVModule::FRAGMENT: add_stage(GL_FRAGMENT_SHADER); break; + case SpirVModule::VERTEX: stage_id = add_stage(VERTEX); break; + case SpirVModule::GEOMETRY: stage_id = add_stage(GEOMETRY); break; + case SpirVModule::FRAGMENT: stage_id = add_stage(FRAGMENT); break; default: throw invalid_operation("Program::add_spirv_stages"); } - stages.insert(i->stage); + used_stage_ids[n_stages++] = stage_id; } - const vector &code = mod.get_code(); - glShaderBinary(stage_ids.size(), &stage_ids[0], GL_SHADER_BINARY_FORMAT_SPIR_V, &code[0], code.size()*4); + const vector &code = mod.get_code(); + glShaderBinary(n_stages, used_stage_ids, GL_SHADER_BINARY_FORMAT_SPIR_V, &code[0], code.size()*4); - const vector &spec_consts = mod.get_spec_constants(); + if(!spec_values.empty() && !transient) + transient = new TransientData; + + const vector &spec_consts = mod.get_spec_constants(); vector spec_id_array; vector spec_value_array; spec_id_array.reserve(spec_consts.size()); spec_value_array.reserve(spec_consts.size()); - for(vector::const_iterator i=spec_consts.begin(); i!=spec_consts.end(); ++i) + for(const SpirVModule::Constant &c: spec_consts) { - map::const_iterator j = spec_values.find(i->name); - if(j!=spec_values.end()) + auto i = spec_values.find(c.name); + if(i!=spec_values.end()) { - spec_id_array.push_back(i->constant_id); - spec_value_array.push_back(j->second); + spec_id_array.push_back(c.constant_id); + spec_value_array.push_back(i->second); + transient->spec_values[c.constant_id] = i->second; } } - vector::const_iterator j=entry_points.begin(); - for(vector::const_iterator i=stage_ids.begin(); i!=stage_ids.end(); ++i, ++j) - glSpecializeShader(*i, j->name.c_str(), spec_id_array.size(), &spec_id_array[0], &spec_value_array[0]); + auto j = mod.get_entry_points().begin(); + for(unsigned i=0; iname.c_str(), spec_id_array.size(), &spec_id_array[0], &spec_value_array[0]); } #pragma GCC diagnostic push @@ -233,7 +262,17 @@ void Program::attach_shader(Shader &shader) unsigned shader_id = shader.steal_id(); if(!shader_id) throw invalid_argument("Program::attach_shader"); - stage_ids.push_back(shader_id); + + int type; + glGetShaderiv(shader_id, GL_SHADER_TYPE, &type); + switch(type) + { + case GL_VERTEX_SHADER: stage_ids[VERTEX] = shader_id; break; + case GL_GEOMETRY_SHADER: stage_ids[GEOMETRY] = shader_id; break; + case GL_FRAGMENT_SHADER: stage_ids[FRAGMENT] = shader_id; break; + } + + glAttachShader(id, shader_id); compile_glsl_stage(shader_id); } @@ -273,7 +312,7 @@ void Program::bind_fragment_data(unsigned index, const string &name) void Program::link() { - if(stage_ids.empty()) + if(!has_stages()) throw invalid_operation("Program::link"); uniforms.clear(); @@ -301,6 +340,32 @@ void Program::link() { query_uniforms(); query_attributes(); + if(transient) + { + for(unsigned i=0; iblocks.find(uniform_blocks[i].name); + if(j!=transient->blocks.end()) + { + glUniformBlockBinding(id, i, j->second); + uniform_blocks[i].bind_point = j->second; + } + } + + if(!ARB_separate_shader_objects) + glUseProgram(id); + for(const auto &kvp: transient->textures) + { + int location = get_uniform_location(kvp.first); + if(location>=0) + { + if(ARB_separate_shader_objects) + glProgramUniform1i(id, location, kvp.second); + else + glUniform1i(location, kvp.second); + } + } + } } else if(module->get_format()==Module::SPIR_V) { @@ -308,16 +373,20 @@ void Program::link() collect_attributes(); } - for(UniformMap::const_iterator i=uniforms.begin(); i!=uniforms.end(); ++i) - require_type(i->second.type); - for(AttributeMap::const_iterator i=attributes.begin(); i!=attributes.end(); ++i) - require_type(i->second.type); + delete transient; + transient = 0; + + for(const UniformInfo &u: uniforms) + require_type(u.type); + for(const AttributeInfo &a: attributes) + require_type(a.type); } void Program::query_uniforms() { unsigned count = get_program_i(id, GL_ACTIVE_UNIFORMS); - vector uniforms_by_index(count); + uniforms.reserve(count); + vector uniform_names(count); for(unsigned i=0; i3 && !strcmp(name+len-3, "[0]")) name[len-3] = 0; - UniformInfo &info = uniforms[name]; + uniforms.push_back(UniformInfo()); + UniformInfo &info = uniforms.back(); info.name = name; + info.tag = name; info.array_size = size; info.type = from_gl_type(type); - uniforms_by_index[i] = &info; + uniform_names[i] = name; } } + sort_member(uniforms, &UniformInfo::tag); + if(ARB_uniform_buffer_object) + { + vector uniforms_by_index(count); + for(unsigned i=0; isecond.block) + for(UniformInfo &u: uniforms) + if(!u.block) { - i->second.location = glGetUniformLocation(id, i->second.name.c_str()); - i->second.block = &default_block; - default_block.uniforms.push_back(&i->second); + u.location = glGetUniformLocation(id, u.name.c_str()); + u.block = &default_block; + default_block.uniforms.push_back(&u); + + if(is_image(u.type) && u.location>=0) + glGetUniformiv(id, u.location, &u.binding); } default_block.layout_hash = compute_layout_hash(default_block.uniforms); @@ -360,29 +444,34 @@ void Program::query_uniforms() void Program::query_uniform_blocks(const vector &uniforms_by_index) { - std::set used_bind_points; unsigned count = get_program_i(id, GL_ACTIVE_UNIFORM_BLOCKS); + // Reserve an extra index for the default block + uniform_blocks.reserve(count+1); for(unsigned i=0; i indices(value); glGetActiveUniformBlockiv(id, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, &indices[0]); - for(vector::iterator j=indices.begin(); j!=indices.end(); ++j) + for(int j: indices) { - if(!uniforms_by_index[*j]) + if(!uniforms_by_index[j]) throw logic_error("Program::link"); - info.uniforms.push_back(uniforms_by_index[*j]); - uniforms_by_index[*j]->block = &info; + info.uniforms.push_back(uniforms_by_index[j]); + uniforms_by_index[j]->block = &info; } vector query_indices(indices.begin(), indices.end()); @@ -392,9 +481,9 @@ void Program::query_uniform_blocks(const vector &uniforms_by_inde uniforms_by_index[indices[j]]->offset = values[j]; query_indices.clear(); - for(vector::iterator j=indices.begin(); j!=indices.end(); ++j) - if(uniforms_by_index[*j]->array_size>1) - query_indices.push_back(*j); + for(int j: indices) + if(uniforms_by_index[j]->array_size>1) + query_indices.push_back(j); if(!query_indices.empty()) { glGetActiveUniformsiv(id, query_indices.size(), &query_indices[0], GL_UNIFORM_ARRAY_STRIDE, &values[0]); @@ -403,11 +492,11 @@ void Program::query_uniform_blocks(const vector &uniforms_by_inde } query_indices.clear(); - for(vector::iterator j=indices.begin(); j!=indices.end(); ++j) + for(int j: indices) { - DataType t = uniforms_by_index[*j]->type; + DataType t = uniforms_by_index[j]->type; if(is_matrix(t)) - query_indices.push_back(*j); + query_indices.push_back(j); } if(!query_indices.empty()) { @@ -416,20 +505,15 @@ void Program::query_uniform_blocks(const vector &uniforms_by_inde uniforms_by_index[query_indices[j]]->matrix_stride = values[j]; } - sort(info.uniforms.begin(), info.uniforms.end(), uniform_location_compare); + sort(info.uniforms, uniform_location_compare); info.layout_hash = compute_layout_hash(info.uniforms); - unsigned n_bindings = BufferRange::get_n_uniform_buffer_bindings(); - info.bind_point = info.layout_hash%n_bindings; - while(used_bind_points.count(info.bind_point)) - info.bind_point = (info.bind_point+1)%n_bindings; - glUniformBlockBinding(id, i, info.bind_point); - used_bind_points.insert(info.bind_point); } } void Program::query_attributes() { unsigned count = get_program_i(id, GL_ACTIVE_ATTRIBUTES); + attributes.reserve(count); for(unsigned i=0; i3 && !strcmp(name+len-3, "[0]")) name[len-3] = 0; - AttributeInfo &info = attributes[name]; + attributes.push_back(AttributeInfo()); + AttributeInfo &info = attributes.back(); info.name = name; info.location = glGetAttribLocation(id, name); info.array_size = size; @@ -455,69 +540,99 @@ void Program::collect_uniforms() { const SpirVModule &mod = static_cast(*module); - UniformBlockInfo &default_block = uniform_blocks[string()]; + // Prepare the default block + uniform_blocks.push_back(UniformBlockInfo()); + vector > block_uniform_names(1); - const vector &variables = mod.get_variables(); - for(vector::const_iterator i=variables.begin(); i!=variables.end(); ++i) + for(const SpirVModule::Variable &v: mod.get_variables()) { - if(i->storage==SpirVModule::UNIFORM && i->struct_type) + if(v.storage==SpirVModule::UNIFORM && v.struct_type) { - UniformBlockInfo &info = uniform_blocks[i->struct_type->name]; - info.name = i->struct_type->name; - info.bind_point = i->binding; - info.data_size = i->struct_type->size; + uniform_blocks.push_back(UniformBlockInfo()); + UniformBlockInfo &info = uniform_blocks.back(); + info.name = v.struct_type->name; + info.bind_point = v.binding; + info.data_size = v.struct_type->size; string prefix; - if(!i->name.empty()) - prefix = i->struct_type->name+"."; - collect_block_uniforms(info, *i->struct_type, prefix, 0); - - info.layout_hash = compute_layout_hash(info.uniforms); + if(!v.name.empty()) + prefix = v.struct_type->name+"."; + block_uniform_names.push_back(vector()); + collect_block_uniforms(*v.struct_type, prefix, 0, block_uniform_names.back()); } - else if(i->storage==SpirVModule::UNIFORM_CONSTANT && i->location>=0) + else if(v.storage==SpirVModule::UNIFORM_CONSTANT && v.location>=0) { - UniformInfo &info = uniforms[i->name]; - info.name = i->name; - info.block = &default_block; - info.location = i->location; - info.array_size = i->array_size; - info.type = i->type; - default_block.uniforms.push_back(&info); + block_uniform_names[0].push_back(v.name); + uniforms.push_back(UniformInfo()); + UniformInfo &info = uniforms.back(); + info.name = v.name; + info.tag = v.name; + info.location = v.location; + info.binding = v.binding; + info.array_size = v.array_size; + info.type = v.type; } } - default_block.layout_hash = compute_layout_hash(default_block.uniforms); + sort_member(uniforms, &UniformInfo::tag); + + for(unsigned i=0; i &uniform_names) { - for(vector::const_iterator i=strct.members.begin(); i!=strct.members.end(); ++i) + for(const SpirVModule::StructMember &m: strct.members) { - unsigned offset = base_offset+i->offset; - if(i->struct_type) + unsigned offset = base_offset+m.offset; + if(m.struct_type) { - if(i->array_size) + unsigned array_size = m.array_size; + if(m.array_size_spec) { - for(unsigned j=0; jarray_size; ++j, offset+=i->array_stride) - collect_block_uniforms(block, *i->struct_type, format("%s%s[%d].", prefix, i->name, j), offset); + array_size = m.array_size_spec->i_value; + if(transient) + { + auto j = transient->spec_values.find(m.array_size_spec->constant_id); + if(j!=transient->spec_values.end()) + array_size = j->second; + } + } + + if(array_size) + { + for(unsigned j=0; jstruct_type, prefix+i->name+".", offset); + collect_block_uniforms(*m.struct_type, prefix+m.name+".", offset, uniform_names); } else { - string name = prefix+i->name; - UniformInfo &info = uniforms[name]; + string name = prefix+m.name; + uniform_names.push_back(name); + uniforms.push_back(UniformInfo()); + UniformInfo &info = uniforms.back(); info.name = name; - info.block = █ + info.tag = name; info.offset = offset; - info.array_size = i->array_size; - info.array_stride = i->array_stride; - info.matrix_stride = i->matrix_stride; - info.type = i->type; - block.uniforms.push_back(&info); + info.array_size = m.array_size; + info.array_stride = m.array_stride; + info.matrix_stride = m.matrix_stride; + info.type = m.type; } } } @@ -526,17 +641,18 @@ void Program::collect_attributes() { const SpirVModule &mod = static_cast(*module); - const vector &entry_points = mod.get_entry_points(); - for(vector::const_iterator i=entry_points.begin(); i!=entry_points.end(); ++i) - if(i->stage==SpirVModule::VERTEX && i->name=="main") + for(const SpirVModule::EntryPoint &e: mod.get_entry_points()) + if(e.stage==SpirVModule::VERTEX && e.name=="main") { - for(vector::const_iterator j=i->globals.begin(); j!=i->globals.end(); ++j) - if((*j)->storage==SpirVModule::INPUT) + for(const SpirVModule::Variable *v: e.globals) + if(v->storage==SpirVModule::INPUT) { - AttributeInfo &info = attributes[(*j)->name]; - info.location = (*j)->location; - info.array_size = (*j)->array_size; - info.type = (*j)->type; + attributes.push_back(AttributeInfo()); + AttributeInfo &info = attributes.back(); + info.name = v->name; + info.location = v->location; + info.array_size = v->array_size; + info.type = v->type; } } } @@ -544,16 +660,16 @@ void Program::collect_attributes() void Program::update_layout_hash() { string layout_descriptor; - for(UniformBlockMap::const_iterator i=uniform_blocks.begin(); i!=uniform_blocks.end(); ++i) - layout_descriptor += format("%d:%x\n", i->second.bind_point, i->second.layout_hash); + for(const UniformBlockInfo &b: uniform_blocks) + layout_descriptor += format("%d:%x\n", b.bind_point, b.layout_hash); uniform_layout_hash = hash32(layout_descriptor); } Program::LayoutHash Program::compute_layout_hash(const vector &uniforms) { string layout_descriptor; - for(vector::const_iterator i = uniforms.begin(); i!=uniforms.end(); ++i) - layout_descriptor += format("%d:%s:%x:%d\n", (*i)->location, (*i)->name, (*i)->type, (*i)->array_size); + for(const UniformInfo *u: uniforms) + layout_descriptor += format("%d:%s:%x:%d\n", u->location, u->name, u->type, u->array_size); return hash32(layout_descriptor); } @@ -573,12 +689,26 @@ string Program::get_info_log() const const Program::UniformBlockInfo &Program::get_uniform_block_info(const string &name) const { - return get_item(uniform_blocks, name); + auto i = find_member(uniform_blocks, name, &UniformBlockInfo::name); + if(i==uniform_blocks.end()) + throw key_error(name); + return *i; } const Program::UniformInfo &Program::get_uniform_info(const string &name) const { - return get_item(uniforms, name); + auto i = lower_bound_member(uniforms, Tag(name), &UniformInfo::tag); + if(i==uniforms.end() || i->name!=name) + throw key_error(name); + return *i; +} + +const Program::UniformInfo &Program::get_uniform_info(Tag tag) const +{ + auto i = lower_bound_member(uniforms, tag, &UniformInfo::tag); + if(i==uniforms.end() || i->tag!=tag) + throw key_error(tag); + return *i; } int Program::get_uniform_location(const string &name) const @@ -586,16 +716,28 @@ int Program::get_uniform_location(const string &name) const if(name[name.size()-1]==']') throw invalid_argument("Program::get_uniform_location"); - UniformMap::const_iterator i = uniforms.find(name); - if(i==uniforms.end()) - return -1; + auto i = lower_bound_member(uniforms, Tag(name), &UniformInfo::tag); + return i!=uniforms.end() && i->name==name && i->block->bind_point<0 ? i->location : -1; +} + +int Program::get_uniform_location(Tag tag) const +{ + auto i = lower_bound_member(uniforms, tag, &UniformInfo::tag); + return i!=uniforms.end() && i->tag==tag && i->block->bind_point<0 ? i->location : -1; +} - return i->second.block->bind_point<0 ? i->second.location : -1; +int Program::get_uniform_binding(Tag tag) const +{ + auto i = lower_bound_member(uniforms, tag, &UniformInfo::tag); + return i!=uniforms.end() && i->tag==tag ? i->binding : -1; } const Program::AttributeInfo &Program::get_attribute_info(const string &name) const { - return get_item(attributes, name); + auto i = lower_bound_member(attributes, name, &AttributeInfo::name); + if(i==attributes.end() || i->name!=name) + throw key_error(name); + return *i; } int Program::get_attribute_location(const string &name) const @@ -603,27 +745,35 @@ int Program::get_attribute_location(const string &name) const if(name[name.size()-1]==']') throw invalid_argument("Program::get_attribute_location"); - AttributeMap::const_iterator i = attributes.find(name); - return i!=attributes.end() ? i->second.location : -1; + auto i = lower_bound_member(attributes, name, &AttributeInfo::name); + return i!=attributes.end() && i->name==name ? i->location : -1; } -void Program::bind() const +void Program::set_debug_name(const string &name) { - if(!linked) - throw invalid_operation("Program::bind"); - - if(!set_current(this)) - return; - - glUseProgram(id); +#ifdef DEBUG + debug_name = name; + if(KHR_debug) + { + glObjectLabel(GL_PROGRAM, id, name.size(), name.c_str()); + for(unsigned i=0; i(i)); + } +#else + (void)name; +#endif } -void Program::unbind() +void Program::set_stage_debug_name(unsigned stage_id, Stage type) { - if(!set_current(0)) - return; - - glUseProgram(0); +#ifdef DEBUG + static const char *const suffixes[] = { " [VS]", " [GS]", " [FS]" }; + string name = debug_name+suffixes[type]; + glObjectLabel(GL_SHADER, stage_id, name.size(), name.c_str()); +#else + (void)stage_id; (void)type; +#endif } @@ -633,7 +783,8 @@ Program::UniformInfo::UniformInfo(): array_size(0), array_stride(0), matrix_stride(0), - type(VOID) + type(VOID), + binding(-1) { }