Unbreak multi-phase rendering after we added the render-to-FBO functionality.

[movit] / effect_chain.cpp

diff --git a/effect_chain.cpp b/effect_chain.cpp
index 1dcc463bf5028ef6e4363d34973a82cbd353f92d..617d1cb007f392bf6fe816c9ccbd1ead68c9722b 100644 (file)
--- a/effect_chain.cpp
+++ b/effect_chain.cpp
@@ -242,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);
@@ -707,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;
        }
@@ -721,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);
 }
 
@@ -788,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);
@@ -884,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());
@@ -932,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);
@@ -1016,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(