X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcore%2Fprogram.cpp;h=f28736bd9a63b7550ef712e0ab531d5a6b26b68d;hb=58e4e69e640838076c506a94cd5f8f905d55420a;hp=6cad69c4e322200b86b7f439f239e01113fa90ea;hpb=4c705a6fba590514bc3fab2a324c24fddc30cac6;p=libs%2Fgl.git diff --git a/source/core/program.cpp b/source/core/program.cpp index 6cad69c4..f28736bd 100644 --- a/source/core/program.cpp +++ b/source/core/program.cpp @@ -3,7 +3,9 @@ #include #include #include +#include #include +#include #include #include #include @@ -15,7 +17,6 @@ #include "buffer.h" #include "error.h" #include "misc.h" -#include "module.h" #include "program.h" #include "resources.h" #include "shader.h" @@ -35,7 +36,7 @@ Program::Program(const std::string &source) { init(); - Module mod; + GlslModule mod; mod.set_source(source); add_stages(mod); @@ -78,6 +79,19 @@ Program::~Program() glDeleteProgram(id); } +void Program::add_stages(const Module &mod, const map &spec_values) +{ + if(!stage_ids.empty()) + throw invalid_operation("Program::add_stages"); + + switch(mod.get_format()) + { + 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"); + } +} + unsigned Program::add_stage(GLenum type) { switch(type) @@ -95,12 +109,12 @@ unsigned Program::add_stage(GLenum type) return stage_id; } -void Program::add_stages(const Module &mod, const map &spec_values) +void Program::add_glsl_stages(const GlslModule &mod, const map &spec_values) { module = &mod; SL::Compiler compiler; - compiler.set_source(module->get_prepared_source(), ""); + compiler.set_source(mod.get_prepared_source(), ""); compiler.specialize(spec_values); compiler.compile(SL::Compiler::PROGRAM); #ifdef DEBUG @@ -140,11 +154,11 @@ void Program::add_stages(const Module &mod, const map &spec_values) glBindFragDataLocation(id, j->second, j->first.c_str()); } - compile_stage(stage_id); + compile_glsl_stage(stage_id); } } -void Program::compile_stage(unsigned stage_id) +void Program::compile_glsl_stage(unsigned stage_id) { glCompileShader(stage_id); bool compiled = get_shader_i(stage_id, GL_COMPILE_STATUS); @@ -153,8 +167,8 @@ void Program::compile_stage(unsigned stage_id) 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) - info_log = module->get_source_map().translate_errors(info_log); + 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); @@ -164,6 +178,54 @@ void Program::compile_stage(unsigned stage_id) #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) @@ -172,7 +234,7 @@ void Program::attach_shader(Shader &shader) if(!shader_id) throw invalid_argument("Program::attach_shader"); stage_ids.push_back(shader_id); - compile_stage(shader_id); + compile_glsl_stage(shader_id); } void Program::attach_shader_owned(Shader *shader) @@ -211,7 +273,12 @@ void Program::bind_fragment_data(unsigned index, const string &name) void Program::link() { + 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); @@ -220,7 +287,8 @@ void Program::link() 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); - info_log = module->get_source_map().translate_errors(info_log); + 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); @@ -229,8 +297,16 @@ void Program::link() 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); @@ -238,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); @@ -272,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; } } @@ -286,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) @@ -299,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); @@ -396,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); } @@ -434,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; @@ -451,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; } @@ -480,6 +626,30 @@ void Program::unbind() } +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) {