X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.cpp;h=617d1cb007f392bf6fe816c9ccbd1ead68c9722b;hp=87d0663e098be1920fe1419144ccaf6f99f0756e;hb=45c3b698b97bfcf4036910ee3539bd5eab4e9751;hpb=4a9b478d0cc333e7b47a766d3d27ffe67c08f15a diff --git a/effect_chain.cpp b/effect_chain.cpp index 87d0663..617d1cb 100644 --- a/effect_chain.cpp +++ b/effect_chain.cpp @@ -111,7 +111,8 @@ void EffectChain::insert_node_between(Node *sender, Node *middle, Node *receiver void EffectChain::find_all_nonlinear_inputs(Node *node, std::vector *nonlinear_inputs) { - if (node->output_gamma_curve == GAMMA_LINEAR) { + if (node->output_gamma_curve == GAMMA_LINEAR && + node->effect->effect_type_id() != "GammaCompressionEffect") { return; } if (node->effect->num_inputs() == 0) { @@ -241,7 +242,18 @@ Phase *EffectChain::compile_glsl_program( } frag_shader += std::string("#define INPUT ") + effects.back()->effect_id + "\n"; frag_shader.append(read_file("footer.frag")); - printf("%s\n", frag_shader.c_str()); + + // Output shader to a temporary file, for easier debugging. + static int compiled_shader_num = 0; + char filename[256]; + sprintf(filename, "chain-%03d.frag", compiled_shader_num++); + FILE *fp = fopen(filename, "w"); + if (fp == NULL) { + perror(filename); + exit(1); + } + fprintf(fp, "%s\n", frag_shader.c_str()); + fclose(fp); GLuint glsl_program_num = glCreateProgram(); GLuint vs_obj = compile_shader(read_file("vs.vert"), GL_VERTEX_SHADER); @@ -450,12 +462,69 @@ unsigned EffectChain::fit_rectangle_to_aspect(unsigned width, unsigned height) } } +// Propagate input texture sizes throughout, and inform effects downstream. +// (Like a lot of other code, we depend on effects being in topological order.) +void EffectChain::inform_input_sizes(Phase *phase) +{ + // All effects that have a defined size (inputs and RTT inputs) + // get that. Reset all others. + for (unsigned i = 0; i < phase->effects.size(); ++i) { + Node *node = phase->effects[i]; + if (node->effect->num_inputs() == 0) { + Input *input = static_cast(node->effect); + node->output_width = input->get_width(); + node->output_height = input->get_height(); + assert(node->output_width != 0); + assert(node->output_height != 0); + } else { + node->output_width = node->output_height = 0; + } + } + for (unsigned i = 0; i < phase->inputs.size(); ++i) { + Node *input = phase->inputs[i]; + input->output_width = input->phase->output_width; + input->output_height = input->phase->output_height; + assert(input->output_width != 0); + assert(input->output_height != 0); + } + + // Now propagate from the inputs towards the end, and inform as we go. + // The rules are simple: + // + // 1. Don't touch effects that already have given sizes (ie., inputs). + // 2. If all of your inputs have the same size, that will be your output size. + // 3. Otherwise, your output size is 0x0. + for (unsigned i = 0; i < phase->effects.size(); ++i) { + Node *node = phase->effects[i]; + if (node->effect->num_inputs() == 0) { + continue; + } + unsigned this_output_width = 0; + unsigned this_output_height = 0; + for (unsigned j = 0; j < node->incoming_links.size(); ++j) { + Node *input = node->incoming_links[j]; + node->effect->inform_input_size(j, input->output_width, input->output_height); + if (j == 0) { + this_output_width = input->output_width; + this_output_height = input->output_height; + } else if (input->output_width != this_output_width || input->output_height != this_output_height) { + // Inputs disagree. + this_output_width = 0; + this_output_height = 0; + } + } + node->output_width = this_output_width; + node->output_height = this_output_height; + } +} + +// Note: You should call inform_input_sizes() before this, as the last effect's +// desired output size might change based on the inputs. void EffectChain::find_output_size(Phase *phase) { Node *output_node = phase->effects.back(); - // If the last effect explicitly sets an output size, - // use that. + // If the last effect explicitly sets an output size, use that. if (output_node->effect->changes_output_size()) { output_node->effect->get_output_size(&phase->output_width, &phase->output_height); return; @@ -649,6 +718,22 @@ bool EffectChain::node_needs_gamma_fix(Node *node) if (node->disabled) { return false; } + + // Small hack since the output is not an explicit node: + // If we are the last node and our output is in the wrong + // space compared to EffectChain's output, we need to fix it. + // This will only take us to linear, but fix_output_gamma() + // will come and take us to the desired output gamma + // if it is needed. + // + // This needs to be before everything else, since it could + // even apply to inputs (if they are the only effect). + if (node->outgoing_links.empty() && + node->output_gamma_curve != output_format.gamma_curve && + node->output_gamma_curve != GAMMA_LINEAR) { + return true; + } + if (node->effect->num_inputs() == 0) { return false; } @@ -663,6 +748,7 @@ bool EffectChain::node_needs_gamma_fix(Node *node) assert(node->incoming_links.size() == 1); return node->incoming_links[0]->output_gamma_curve != GAMMA_LINEAR; } + return (node->effect->needs_linear_light() && node->output_gamma_curve != GAMMA_LINEAR); } @@ -687,6 +773,7 @@ void EffectChain::fix_internal_gamma_by_asking_inputs(unsigned step) // See if all inputs can give us linear gamma. If not, leave it. std::vector nonlinear_inputs; find_all_nonlinear_inputs(node, &nonlinear_inputs); + assert(!nonlinear_inputs.empty()); bool all_ok = true; for (unsigned i = 0; i < nonlinear_inputs.size(); ++i) { @@ -729,8 +816,21 @@ void EffectChain::fix_internal_gamma_by_inserting_nodes(unsigned step) continue; } - // Go through each input that is not linear gamma, and insert - // a gamma conversion before it. + // Special case: We could be an input and still be asked to + // fix our gamma; if so, we should be the only node + // (as node_needs_gamma_fix() would only return true in + // for an input in that case). That means we should insert + // a conversion node _after_ ourselves. + if (node->incoming_links.empty()) { + assert(node->outgoing_links.empty()); + Node *conversion = add_node(new GammaExpansionEffect()); + conversion->effect->set_int("source_curve", node->output_gamma_curve); + conversion->output_gamma_curve = GAMMA_LINEAR; + connect_nodes(node, conversion); + } + + // If not, go through each input that is not linear gamma, + // and insert a gamma conversion before it. for (unsigned j = 0; j < node->incoming_links.size(); ++j) { Node *input = node->incoming_links[j]; assert(input->output_gamma_curve != GAMMA_INVALID); @@ -738,7 +838,7 @@ void EffectChain::fix_internal_gamma_by_inserting_nodes(unsigned step) continue; } Node *conversion = add_node(new GammaExpansionEffect()); - conversion->effect->set_int("destination_curve", GAMMA_LINEAR); + conversion->effect->set_int("source_curve", input->output_gamma_curve); conversion->output_gamma_curve = GAMMA_LINEAR; insert_node_between(input, conversion, node); } @@ -825,11 +925,11 @@ void EffectChain::finalize() fix_internal_gamma_by_asking_inputs(5); fix_internal_gamma_by_inserting_nodes(6); fix_output_gamma(); - output_dot("step8-output-gammafix.dot"); - fix_internal_gamma_by_asking_inputs(9); - fix_internal_gamma_by_inserting_nodes(10); + output_dot("step7-output-gammafix.dot"); + fix_internal_gamma_by_asking_inputs(8); + fix_internal_gamma_by_inserting_nodes(9); - output_dot("step11-final.dot"); + output_dot("step10-final.dot"); // Construct all needed GLSL programs, starting at the output. construct_glsl_programs(find_output_node()); @@ -843,6 +943,7 @@ void EffectChain::finalize() glGenFramebuffers(1, &fbo); for (unsigned i = 0; i < phases.size() - 1; ++i) { + inform_input_sizes(phases[i]); find_output_size(phases[i]); Node *output_node = phases[i]->effects.back(); @@ -860,6 +961,7 @@ void EffectChain::finalize() output_node->output_texture_width = phases[i]->output_width; output_node->output_texture_height = phases[i]->output_height; } + inform_input_sizes(phases.back()); } for (unsigned i = 0; i < inputs.size(); ++i) { @@ -871,13 +973,21 @@ void EffectChain::finalize() finalized = true; } -void EffectChain::render_to_screen() +void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height) { assert(finalized); // Save original viewport. - GLint viewport[4]; - glGetIntegerv(GL_VIEWPORT, viewport); + GLuint x = 0, y = 0; + + if (width == 0 && height == 0) { + GLint viewport[4]; + glGetIntegerv(GL_VIEWPORT, viewport); + x = viewport[0]; + y = viewport[1]; + width = viewport[2]; + height = viewport[3]; + } // Basic state. glDisable(GL_BLEND); @@ -904,6 +1014,7 @@ void EffectChain::render_to_screen() for (unsigned phase = 0; phase < phases.size(); ++phase) { // See if the requested output size has changed. If so, we need to recreate // the texture (and before we start setting up inputs). + inform_input_sizes(phases[phase]); if (phase != phases.size() - 1) { find_output_size(phases[phase]); @@ -954,10 +1065,10 @@ void EffectChain::render_to_screen() // And now the output. if (phase == phases.size() - 1) { - // Last phase goes directly to the screen. - glBindFramebuffer(GL_FRAMEBUFFER, 0); + // Last phase goes to the output the user specified. + glBindFramebuffer(GL_FRAMEBUFFER, dest_fbo); check_error(); - glViewport(viewport[0], viewport[1], viewport[2], viewport[3]); + glViewport(x, y, width, height); } else { Node *output_node = phases[phase]->effects.back(); glFramebufferTexture2D(