void opengl_compile_shader_actual(shader_type sdr, const uint &flags, opengl_shader_t &new_shader)
{
opengl_shader_type_t *sdr_info = &GL_shader_types[sdr];
Assert(sdr_info->type_id == sdr);
mprintf(("Compiling new shader:\n"));
mprintf((" %s\n", sdr_info->description));
// figure out if the variant requested needs a geometry shader
bool use_geo_sdr = false;
// do we even have a geometry shader?
if (sdr_info->geo != NULL) {
for (int i = 0; i < GL_num_shader_variants; ++i) {
opengl_shader_variant_t *variant = &GL_shader_variants[i];
if (variant->type_id == sdr && flags & variant->flag && variant->use_geometry_sdr) {
use_geo_sdr = true;
break;
}
}
}
auto vert_content = opengl_get_shader_content(sdr_info->type_id, sdr_info->vert, flags, use_geo_sdr);
auto frag_content = opengl_get_shader_content(sdr_info->type_id, sdr_info->frag, flags, use_geo_sdr);
SCP_vector<SCP_string> geom_content;
if (use_geo_sdr) {
// read geometry shader
geom_content = opengl_get_shader_content(sdr_info->type_id, sdr_info->geo, flags, use_geo_sdr);
}
auto shader_hash = get_shader_hash(vert_content, geom_content, frag_content);
std::unique_ptr<opengl::ShaderProgram> program(new opengl::ShaderProgram(sdr_info->description));
if (!load_cached_shader_binary(program.get(), shader_hash)) {
GR_DEBUG_SCOPE("Compiling shader code");
try {
program->addShaderCode(opengl::STAGE_VERTEX, sdr_info->vert, vert_content);
program->addShaderCode(opengl::STAGE_FRAGMENT, sdr_info->frag, frag_content);
if (use_geo_sdr) {
program->addShaderCode(opengl::STAGE_GEOMETRY, sdr_info->geo, geom_content);
}
for (size_t i = 0; i < GL_vertex_attrib_info.size(); ++i) {
// Check that the enum values match the position in the vector to make accessing that information more efficient
Assertion(GL_vertex_attrib_info[i].attribute_id == (int)i, "Mistmatch between enum values and attribute vector detected!");
// assign vert attribute binding locations before we link the shader
glBindAttribLocation(program->getShaderHandle(), (GLint)i, GL_vertex_attrib_info[i].name.c_str());
}
// bind fragment data locations before we link the shader
glBindFragDataLocation(program->getShaderHandle(), 0, "fragOut0");
glBindFragDataLocation(program->getShaderHandle(), 1, "fragOut1");
glBindFragDataLocation(program->getShaderHandle(), 2, "fragOut2");
glBindFragDataLocation(program->getShaderHandle(), 3, "fragOut3");
glBindFragDataLocation(program->getShaderHandle(), 4, "fragOut4");
if (do_shader_caching()) {
// Enable shader caching
glProgramParameteri(program->getShaderHandle(), GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
}
program->linkProgram();
}
catch (const std::exception&) {
// Since all shaders are required a compilation failure is a fatal error
Error(LOCATION, "A shader failed to compile! Check the debug log for more information.");
}
cache_program_binary(program->getShaderHandle(), shader_hash);
}
new_shader.shader = sdr_info->type_id;
new_shader.flags = flags;
new_shader.program = std::move(program);
opengl_shader_set_current(&new_shader);
// initialize the attributes
for (auto& attr : sdr_info->attributes) {
new_shader.program->initAttribute(GL_vertex_attrib_info[attr].name, GL_vertex_attrib_info[attr].attribute_id, GL_vertex_attrib_info[attr].default_value);
}
for (auto& uniform_block : GL_uniform_blocks) {
auto blockIndex = glGetUniformBlockIndex(new_shader.program->getShaderHandle(), uniform_block.name);
if (blockIndex != GL_INVALID_INDEX) {
glUniformBlockBinding(new_shader.program->getShaderHandle(), blockIndex, static_cast<GLuint>(uniform_block.block_type));
}
}
mprintf(("Shader Variant Features:\n"));
// initialize all uniforms and attributes that are specific to this variant
for (int i = 0; i < GL_num_shader_variants; ++i) {
opengl_shader_variant_t &variant = GL_shader_variants[i];
if (sdr_info->type_id == variant.type_id && variant.flag & flags) {
for (auto& attr : variant.attributes) {
auto& attr_info = GL_vertex_attrib_info[attr];
new_shader.program->initAttribute(attr_info.name, attr_info.attribute_id, attr_info.default_value);
}
mprintf((" %s\n", variant.description));
}
}
opengl_set_default_uniforms(new_shader);
}
/**
* Compiles a new shader, and creates an opengl_shader_t that will be put into the GL_shader vector
* if compilation is successful.
*
* @param sdr Identifier defined with the program we wish to compile
* @param flags Combination of SDR_* flags
*/
int opengl_compile_shader(shader_type sdr, uint flags)
{
int sdr_index = -1;
int empty_idx;
opengl_shader_t new_shader;
Assert(sdr < NUM_SHADER_TYPES);
opengl_shader_type_t *sdr_info = &GL_shader_types[sdr];
mprintf(("Compiling new shader:\n"));
mprintf((" %s\n", sdr_info->description));
// figure out if the variant requested needs a geometry shader
bool use_geo_sdr = false;
// do we even have a geometry shader?
if ( sdr_info->geo != NULL ) {
for (int i = 0; i < GL_num_shader_variants; ++i) {
opengl_shader_variant_t *variant = &GL_shader_variants[i];
if (variant->type_id == sdr && flags & variant->flag && variant->use_geometry_sdr) {
use_geo_sdr = true;
break;
}
}
}
auto vertex_content = opengl_get_shader_content(sdr_info->type_id, sdr_info->vert, flags);
auto fragment_content = opengl_get_shader_content(sdr_info->type_id, sdr_info->frag, flags);
SCP_vector<SCP_string> geom_content;
if ( use_geo_sdr ) {
if (!Is_Extension_Enabled(OGL_EXT_GEOMETRY_SHADER4)) {
return -1;
}
// read geometry shader
geom_content = opengl_get_shader_content(sdr_info->type_id, sdr_info->geo, flags);
Current_geo_sdr_params = &sdr_info->geo_sdr_info;
}
new_shader.program_id = opengl_shader_create(vertex_content, fragment_content, geom_content);
if (!new_shader.program_id) {
return -1;
}
new_shader.shader = sdr_info->type_id;
new_shader.flags = flags;
opengl_shader_set_current(&new_shader);
// initialize uniforms and attributes
for ( int i = 0; i < sdr_info->num_uniforms; ++i ) {
opengl_shader_init_uniform( sdr_info->uniforms[i] );
}
for (int i = 0; i < sdr_info->num_attributes; ++i) {
opengl_shader_init_attribute(sdr_info->attributes[i]);
}
// if this shader is POST_PROCESS_MAIN, hack in the user-defined flags
if ( sdr_info->type_id == SDR_TYPE_POST_PROCESS_MAIN ) {
opengl_post_init_uniforms(flags);
}
mprintf(("Shader Variant Features:\n"));
// initialize all uniforms and attributes that are specific to this variant
for ( int i = 0; i < GL_num_shader_variants; ++i ) {
opengl_shader_variant_t &variant = GL_shader_variants[i];
if ( sdr_info->type_id == variant.type_id && variant.flag & flags ) {
for (int j = 0; j < variant.num_uniforms; ++j) {
opengl_shader_init_uniform(variant.uniforms[j]);
}
for (int j = 0; j < variant.num_attributes; ++j) {
opengl_shader_init_attribute(variant.attributes[j]);
}
mprintf((" %s\n", variant.description));
}
}
opengl_shader_set_current();
// add it to our list of embedded shaders
// see if we have empty shader slots
empty_idx = -1;
for ( int i = 0; i < (int)GL_shader.size(); ++i ) {
if ( GL_shader[i].shader == NUM_SHADER_TYPES ) {
empty_idx = i;
break;
}
}
// then insert it at an empty slot or at the end
if ( empty_idx >= 0 ) {
GL_shader[empty_idx] = new_shader;
sdr_index = empty_idx;
} else {
sdr_index = GL_shader.size();
GL_shader.push_back(new_shader);
}
return sdr_index;
}
