X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcore%2Fprogram.cpp;h=f28736bd9a63b7550ef712e0ab531d5a6b26b68d;hb=58e4e69e640838076c506a94cd5f8f905d55420a;hp=74c1df3e3058ac069bda809cf96a9566bf1e2904;hpb=c1b0303f65ee966a973197cbdbf177c571478674;p=libs%2Fgl.git diff --git a/source/core/program.cpp b/source/core/program.cpp index 74c1df3e..f28736bd 100644 --- a/source/core/program.cpp +++ b/source/core/program.cpp @@ -3,6 +3,10 @@ #include #include #include +#include +#include +#include +#include #include #include #include @@ -32,26 +36,30 @@ Program::Program(const std::string &source) { init(); - SL::Compiler compiler; - if(source.find(';')==string::npos && source.size()>5 && !source.compare(source.size()-5, 5, ".glsl")) - { - if(RefPtr io = Resources::get_builtins().open(source)) - compiler.compile(*io, source); - else - throw IO::file_not_found(source); - } - else - compiler.compile(source); - compiler.add_shaders(*this); + GlslModule mod; + mod.set_source(source); + add_stages(mod); + link(); + module = 0; } Program::Program(const string &vert, const string &frag) { init(); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" attach_shader_owned(new VertexShader(vert)); attach_shader_owned(new FragmentShader(frag)); +#pragma GCC diagnostic pop + link(); +} + +Program::Program(const Module &mod, const map &spec_values) +{ + init(); + add_stages(mod, spec_values); link(); } @@ -59,52 +67,201 @@ void Program::init() { static Require _req(ARB_shader_objects); - linked = false; id = glCreateProgram(); + module = 0; + linked = false; } Program::~Program() { - for(ShaderList::iterator i=owned_data.begin(); i!=owned_data.end(); ++i) - delete *i; + for(vector::iterator i=stage_ids.begin(); i!=stage_ids.end(); ++i) + glDeleteShader(*i); glDeleteProgram(id); } -void Program::attach_shader(Shader &shader) +void Program::add_stages(const Module &mod, const map &spec_values) { - if(find(shaders.begin(), shaders.end(), &shader)==shaders.end()) + if(!stage_ids.empty()) + throw invalid_operation("Program::add_stages"); + + switch(mod.get_format()) { - glAttachShader(id, shader.get_id()); - shaders.push_back(&shader); + case Module::GLSL: return add_glsl_stages(static_cast(mod), spec_values); + case Module::SPIR_V: return add_spirv_stages(static_cast(mod), spec_values); + default: throw invalid_argument("Program::add_stages"); } } -void Program::attach_shader_owned(Shader *shader) +unsigned Program::add_stage(GLenum type) { - attach_shader(*shader); - if(find(owned_data.begin(), owned_data.end(), shader)==owned_data.end()) - owned_data.push_back(shader); + switch(type) + { + case GL_VERTEX_SHADER: { static Require _req(ARB_vertex_shader); } break; + case GL_GEOMETRY_SHADER: { static Require _req(ARB_geometry_shader4); } break; + case GL_FRAGMENT_SHADER: { static Require _req(ARB_fragment_shader); } break; + default: throw invalid_argument("Program::add_stage"); + } + + unsigned stage_id = glCreateShader(type); + stage_ids.push_back(stage_id); + glAttachShader(id, stage_id); + + return stage_id; } -void Program::detach_shader(Shader &shader) +void Program::add_glsl_stages(const GlslModule &mod, const map &spec_values) { - ShaderList::iterator i = remove(shaders.begin(), shaders.end(), &shader); - if(i!=shaders.end()) + module = &mod; + + SL::Compiler compiler; + compiler.set_source(mod.get_prepared_source(), ""); + compiler.specialize(spec_values); + compiler.compile(SL::Compiler::PROGRAM); +#ifdef DEBUG + string diagnostics = compiler.get_diagnostics(); + if(!diagnostics.empty()) + IO::print("Program diagnostics:\n%s\n", diagnostics); +#endif + + vector stages = compiler.get_stages(); + for(vector::const_iterator i=stages.begin(); i!=stages.end(); ++i) { - shaders.erase(i, shaders.end()); - glDetachShader(id, shader.get_id()); + unsigned stage_id = 0; + switch(*i) + { + 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; + default: throw invalid_operation("Program::add_glsl_stages"); + } + + string stage_src = compiler.get_stage_glsl(*i); + 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) + { + 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()); + } + + if(*i==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()); + } + + compile_glsl_stage(stage_id); } } +void Program::compile_glsl_stage(unsigned stage_id) +{ + glCompileShader(stage_id); + bool compiled = get_shader_i(stage_id, GL_COMPILE_STATUS); + + GLsizei info_log_len = get_shader_i(stage_id, GL_INFO_LOG_LENGTH); + string info_log(info_log_len+1, 0); + glGetShaderInfoLog(stage_id, info_log_len+1, &info_log_len, &info_log[0]); + info_log.erase(info_log_len); + if(module && module->get_format()==Module::GLSL) + info_log = static_cast(module)->get_source_map().translate_errors(info_log); + + if(!compiled) + throw compile_error(info_log); +#ifdef DEBUG + if(!info_log.empty()) + IO::print("Shader compile info log:\n%s", info_log); +#endif +} + +void Program::add_spirv_stages(const SpirVModule &mod, const map &spec_values) +{ + static Require _req(ARB_gl_spirv); + static Require _req2(ARB_ES2_compatibility); + + 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) + { + if(stages.count(i->stage)) + throw invalid_argument("Program::add_spirv_stages"); + + switch(i->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; + default: throw invalid_operation("Program::add_spirv_stages"); + } + + stages.insert(i->stage); + } + + 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 &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) + { + map::const_iterator j = spec_values.find(i->name); + if(j!=spec_values.end()) + { + spec_id_array.push_back(i->constant_id); + spec_value_array.push_back(j->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]); +} + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +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); + compile_glsl_stage(shader_id); +} + +void Program::attach_shader_owned(Shader *shader) +{ + attach_shader(*shader); + delete shader; +} + +void Program::detach_shader(Shader &) +{ +} + +const vector &Program::get_attached_shaders() const +{ + static vector dummy; + return dummy; +} + void Program::bind_attribute(unsigned index, const string &name) { static Require _req(ARB_vertex_shader); glBindAttribLocation(id, index, name.c_str()); } -void Program::bind_attribute(VertexComponent comp, const string &name) +void Program::bind_attribute(VertexAttribute attr, const string &name) { - bind_attribute(get_component_type(comp), name); + bind_attribute(get_attribute_semantic(attr), name); } void Program::bind_fragment_data(unsigned index, const string &name) @@ -112,28 +269,44 @@ void Program::bind_fragment_data(unsigned index, const string &name) static Require _req(EXT_gpu_shader4); glBindFragDataLocation(id, index, name.c_str()); } +#pragma GCC diagnostic pop void Program::link() { - for(ShaderList::iterator i=shaders.begin(); i!=shaders.end(); ++i) - if(!(*i)->is_compiled()) - (*i)->compile(); + if(stage_ids.empty()) + throw invalid_operation("Program::link"); uniforms.clear(); + uniform_blocks.clear(); + attributes.clear(); glLinkProgram(id); linked = get_program_i(id, GL_LINK_STATUS); - if(!linked) - throw compile_error(get_info_log()); + GLsizei info_log_len = get_program_i(id, GL_INFO_LOG_LENGTH); + string info_log(info_log_len+1, 0); + glGetProgramInfoLog(id, info_log_len+1, &info_log_len, &info_log[0]); + info_log.erase(info_log_len); + if(module && module->get_format()==Module::GLSL) + info_log = static_cast(module)->get_source_map().translate_errors(info_log); + + if(!linked) + throw compile_error(info_log); #ifdef DEBUG - std::string info_log = get_info_log(); if(!info_log.empty()) IO::print("Program link info log:\n%s", info_log); #endif - query_uniforms(); - query_attributes(); + if(module->get_format()==Module::GLSL) + { + query_uniforms(); + query_attributes(); + } + else if(module->get_format()==Module::SPIR_V) + { + collect_uniforms(); + collect_attributes(); + } for(UniformMap::const_iterator i=uniforms.begin(); i!=uniforms.end(); ++i) require_type(i->second.type); @@ -141,21 +314,6 @@ void Program::link() require_type(i->second.type); } -void Program::require_type(GLenum t) -{ - switch(t) - { - case GL_FLOAT_MAT2x3: - case GL_FLOAT_MAT2x4: - case GL_FLOAT_MAT3x2: - case GL_FLOAT_MAT3x4: - case GL_FLOAT_MAT4x2: - case GL_FLOAT_MAT4x3: - { static Require _req(NV_non_square_matrices); } - break; - } -} - void Program::query_uniforms() { unsigned count = get_program_i(id, GL_ACTIVE_UNIFORMS); @@ -175,12 +333,9 @@ void Program::query_uniforms() name[len-3] = 0; UniformInfo &info = uniforms[name]; - info.block = 0; info.name = name; - info.size = size; - info.array_stride = 0; - info.matrix_stride = 0; - info.type = type; + info.array_size = size; + info.type = from_gl_type(type); uniforms_by_index[i] = &info; } } @@ -189,8 +344,6 @@ void Program::query_uniforms() query_uniform_blocks(uniforms_by_index); UniformBlockInfo &default_block = uniform_blocks[string()]; - default_block.data_size = 0; - default_block.bind_point = -1; for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i) if(!i->second.block) @@ -202,16 +355,11 @@ void Program::query_uniforms() default_block.layout_hash = compute_layout_hash(default_block.uniforms); - 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); - uniform_layout_hash = hash32(layout_descriptor); + update_layout_hash(); } void Program::query_uniform_blocks(const vector &uniforms_by_index) { - uniform_blocks.clear(); - std::set used_bind_points; unsigned count = get_program_i(id, GL_ACTIVE_UNIFORM_BLOCKS); for(unsigned i=0; i &uniforms_by_inde uniforms_by_index[*j]->block = &info; } - vector indices2(indices.begin(), indices.end()); + vector query_indices(indices.begin(), indices.end()); vector values(indices.size()); - glGetActiveUniformsiv(id, indices.size(), &indices2[0], GL_UNIFORM_OFFSET, &values[0]); + glGetActiveUniformsiv(id, query_indices.size(), &query_indices[0], GL_UNIFORM_OFFSET, &values[0]); for(unsigned j=0; jlocation = values[j]; + uniforms_by_index[indices[j]]->offset = values[j]; - indices2.clear(); + query_indices.clear(); for(vector::iterator j=indices.begin(); j!=indices.end(); ++j) - if(uniforms_by_index[*j]->size>1) - indices2.push_back(*j); - if(!indices2.empty()) + if(uniforms_by_index[*j]->array_size>1) + query_indices.push_back(*j); + if(!query_indices.empty()) { - glGetActiveUniformsiv(id, indices2.size(), &indices2[0], GL_UNIFORM_ARRAY_STRIDE, &values[0]); - for(unsigned j=0; jarray_stride = values[j]; + glGetActiveUniformsiv(id, query_indices.size(), &query_indices[0], GL_UNIFORM_ARRAY_STRIDE, &values[0]); + for(unsigned j=0; jarray_stride = values[j]; } - indices2.clear(); + query_indices.clear(); for(vector::iterator j=indices.begin(); j!=indices.end(); ++j) { - GLenum t = uniforms_by_index[*j]->type; - if(t==GL_FLOAT_MAT4 || t==GL_FLOAT_MAT3 || t==GL_FLOAT_MAT2 || - t==GL_FLOAT_MAT2x3 || t==GL_FLOAT_MAT2x4 || t==GL_FLOAT_MAT3x2 || - t==GL_FLOAT_MAT3x4 || t==GL_FLOAT_MAT4x2 || t==GL_FLOAT_MAT4x3) - indices2.push_back(*j); + DataType t = uniforms_by_index[*j]->type; + if(is_matrix(t)) + query_indices.push_back(*j); } - if(!indices2.empty()) + if(!query_indices.empty()) { - glGetActiveUniformsiv(id, indices2.size(), &indices2[0], GL_UNIFORM_MATRIX_STRIDE, &values[0]); - for(unsigned j=0; jmatrix_stride = values[j]; + glGetActiveUniformsiv(id, query_indices.size(), &query_indices[0], GL_UNIFORM_MATRIX_STRIDE, &values[0]); + for(unsigned j=0; jmatrix_stride = values[j]; } sort(info.uniforms.begin(), info.uniforms.end(), uniform_location_compare); @@ -299,17 +445,114 @@ void Program::query_attributes() AttributeInfo &info = attributes[name]; info.name = name; info.location = glGetAttribLocation(id, name); - info.size = size; - info.type = type; + info.array_size = size; + info.type = from_gl_type(type); + } + } +} + +void Program::collect_uniforms() +{ + const SpirVModule &mod = static_cast(*module); + + UniformBlockInfo &default_block = uniform_blocks[string()]; + + const vector &variables = mod.get_variables(); + for(vector::const_iterator i=variables.begin(); i!=variables.end(); ++i) + { + if(i->storage==SpirVModule::UNIFORM && i->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; + + 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); + } + else if(i->storage==SpirVModule::UNIFORM_CONSTANT && i->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); + } + } + + default_block.layout_hash = compute_layout_hash(default_block.uniforms); + + update_layout_hash(); +} + +void Program::collect_block_uniforms(UniformBlockInfo &block, const SpirVModule::Structure &strct, const string &prefix, unsigned base_offset) +{ + for(vector::const_iterator i=strct.members.begin(); i!=strct.members.end(); ++i) + { + if(i->struct_type) + { + if(i->array_size) + { + for(unsigned j=0; jarray_size; ++j) + collect_block_uniforms(block, *i->struct_type, format("%s%s[%d].", prefix, i->name, j), base_offset+i->offset+i->array_stride*j); + } + else + collect_block_uniforms(block, *i->struct_type, prefix+i->name+".", base_offset+i->offset); + } + else + { + string name = prefix+i->name; + UniformInfo &info = uniforms[name]; + info.name = name; + info.block = █ + info.offset = i->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); } } } +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(vector::const_iterator j=i->globals.begin(); j!=i->globals.end(); ++j) + if((*j)->storage==SpirVModule::INPUT) + { + AttributeInfo &info = attributes[(*j)->name]; + info.location = (*j)->location; + info.array_size = (*j)->array_size; + info.type = (*j)->type; + } + } +} + +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); + 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)->size); + layout_descriptor += format("%d:%s:%x:%d\n", (*i)->location, (*i)->name, (*i)->type, (*i)->array_size); return hash32(layout_descriptor); } @@ -337,12 +580,12 @@ const Program::UniformInfo &Program::get_uniform_info(const string &name) const return get_item(uniforms, name); } -int Program::get_uniform_location(const string &n) const +int Program::get_uniform_location(const string &name) const { - if(n[n.size()-1]==']') + if(name[name.size()-1]==']') throw invalid_argument("Program::get_uniform_location"); - UniformMap::const_iterator i = uniforms.find(n); + UniformMap::const_iterator i = uniforms.find(name); if(i==uniforms.end()) return -1; @@ -354,12 +597,12 @@ const Program::AttributeInfo &Program::get_attribute_info(const string &name) co return get_item(attributes, name); } -int Program::get_attribute_location(const string &n) const +int Program::get_attribute_location(const string &name) const { - if(n[n.size()-1]==']') + if(name[name.size()-1]==']') throw invalid_argument("Program::get_attribute_location"); - AttributeMap::const_iterator i = attributes.find(n); + AttributeMap::const_iterator i = attributes.find(name); return i!=attributes.end() ? i->second.location : -1; } @@ -383,9 +626,36 @@ void Program::unbind() } -Program::Loader::Loader(Program &p): - DataFile::ObjectLoader(p) +Program::UniformInfo::UniformInfo(): + block(0), + location(-1), + array_size(0), + array_stride(0), + matrix_stride(0), + type(VOID) +{ } + + +Program::UniformBlockInfo::UniformBlockInfo(): + data_size(0), + bind_point(-1), + layout_hash(0) +{ } + + +Program::AttributeInfo::AttributeInfo(): + location(-1), + array_size(0), + type(VOID) +{ } + + +Program::Loader::Loader(Program &p, Collection &c): + DataFile::CollectionObjectLoader(p, &c) { + add("module", &Loader::module); + + // Deprecated add("attribute", &Loader::attribute); add("fragment_shader", &Loader::fragment_shader); add("geometry_shader", &Loader::geometry_shader); @@ -397,6 +667,16 @@ void Program::Loader::finish() obj.link(); } +void Program::Loader::module(const string &n) +{ + map spec_values; + SpecializationLoader ldr(spec_values); + load_sub_with(ldr); + obj.add_stages(get_collection().get(n), spec_values); +} + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" void Program::Loader::attribute(unsigned i, const string &n) { obj.bind_attribute(i, n); @@ -416,6 +696,32 @@ void Program::Loader::vertex_shader(const string &src) { obj.attach_shader_owned(new VertexShader(src)); } +#pragma GCC diagnostic pop + + +DataFile::Loader::ActionMap Program::SpecializationLoader::shared_actions; + +Program::SpecializationLoader::SpecializationLoader(map &sv): + spec_values(sv) +{ + set_actions(shared_actions); +} + +void Program::SpecializationLoader::init_actions() +{ + add("specialize", &SpecializationLoader::specialize_bool); + add("specialize", &SpecializationLoader::specialize_int); +} + +void Program::SpecializationLoader::specialize_bool(const string &name, bool value) +{ + spec_values[name] = value; +} + +void Program::SpecializationLoader::specialize_int(const string &name, int value) +{ + spec_values[name] = value; +} } // namespace GL } // namespace Msp