Merge branch 'master' into epoxy

[movit] / effect_chain.cpp

diff --git a/effect_chain.cpp b/effect_chain.cpp
index 82f1b2939cc088e8268c0d883f6a1c69e0979dc1..47938455b02bee9f9ff1b1be7b3cf5cbe1fd0a95 100644 (file)
--- a/effect_chain.cpp
+++ b/effect_chain.cpp
@@ -68,11 +68,6 @@ EffectChain::~EffectChain()
        if (owns_resource_pool) {
                delete resource_pool;
        }
-       for (map<void *, GLuint>::const_iterator fbo_it = fbos.begin();
-            fbo_it != fbos.end(); ++fbo_it) {
-               glDeleteFramebuffers(1, &fbo_it->second);
-               check_error();
-       }
 }
 
 Input *EffectChain::add_input(Input *input)
@@ -1460,47 +1455,37 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height
        glDepthMask(GL_FALSE);
        check_error();
 
-       if (phases.size() > 1) {
-               if (fbos.count(context) == 0) {
-                       glGenFramebuffers(1, &fbo);
-                       check_error();
-                       fbos.insert(make_pair(context, fbo));
-               } else {
-                       fbo = fbos[context];
-               }
-               glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-               check_error();
-       }
-
        set<Phase *> generated_mipmaps;
 
        // We choose the simplest option of having one texture per output,
        // since otherwise this turns into an (albeit simple) register allocation problem.
        map<Phase *, GLuint> output_textures;
 
-       for (unsigned phase = 0; phase < phases.size(); ++phase) {
+       for (unsigned phase_num = 0; phase_num < phases.size(); ++phase_num) {
+               Phase *phase = phases[phase_num];
+
                // Find a texture for this phase.
-               inform_input_sizes(phases[phase]);
-               if (phase != phases.size() - 1) {
-                       find_output_size(phases[phase]);
+               inform_input_sizes(phase);
+               if (phase_num != phases.size() - 1) {
+                       find_output_size(phase);
 
-                       GLuint tex_num = resource_pool->create_2d_texture(GL_RGBA16F_ARB, phases[phase]->output_width, phases[phase]->output_height);
-                       output_textures.insert(make_pair(phases[phase], tex_num));
+                       GLuint tex_num = resource_pool->create_2d_texture(GL_RGBA16F, phase->output_width, phase->output_height);
+                       output_textures.insert(make_pair(phase, tex_num));
                }
 
-               const GLuint glsl_program_num = phases[phase]->glsl_program_num;
+               const GLuint glsl_program_num = phase->glsl_program_num;
                check_error();
                glUseProgram(glsl_program_num);
                check_error();
 
                // Set up RTT inputs for this phase.
-               for (unsigned sampler = 0; sampler < phases[phase]->inputs.size(); ++sampler) {
+               for (unsigned sampler = 0; sampler < phase->inputs.size(); ++sampler) {
                        glActiveTexture(GL_TEXTURE0 + sampler);
-                       Phase *input = phases[phase]->inputs[sampler];
+                       Phase *input = phase->inputs[sampler];
                        input->output_node->bound_sampler_num = sampler;
                        glBindTexture(GL_TEXTURE_2D, output_textures[input]);
                        check_error();
-                       if (phases[phase]->input_needs_mipmaps) {
+                       if (phase->input_needs_mipmaps) {
                                if (generated_mipmaps.count(input) == 0) {
                                        glGenerateMipmap(GL_TEXTURE_2D);
                                        check_error();
@@ -1517,13 +1502,13 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
                        check_error();
 
-                       string texture_name = string("tex_") + phases[phase]->effect_ids[input->output_node];
+                       string texture_name = string("tex_") + phase->effect_ids[input->output_node];
                        glUniform1i(glGetUniformLocation(glsl_program_num, texture_name.c_str()), sampler);
                        check_error();
                }
 
                // And now the output.
-               if (phase == phases.size() - 1) {
+               if (phase_num == phases.size() - 1) {
                        // Last phase goes to the output the user specified.
                        glBindFramebuffer(GL_FRAMEBUFFER, dest_fbo);
                        check_error();
@@ -1535,24 +1520,17 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height
                                CHECK(dither_effect->set_int("output_height", height));
                        }
                } else {
-                       glFramebufferTexture2D(
-                               GL_FRAMEBUFFER,
-                               GL_COLOR_ATTACHMENT0,
-                               GL_TEXTURE_2D,
-                               output_textures[phases[phase]],
-                               0);
-                       check_error();
-                       GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
-                       assert(status == GL_FRAMEBUFFER_COMPLETE);
-                       glViewport(0, 0, phases[phase]->output_width, phases[phase]->output_height);
+                       fbo = resource_pool->create_fbo(context, output_textures[phase]);
+                       glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+                       glViewport(0, 0, phase->output_width, phase->output_height);
                }
 
                // Give the required parameters to all the effects.
-               unsigned sampler_num = phases[phase]->inputs.size();
-               for (unsigned i = 0; i < phases[phase]->effects.size(); ++i) {
-                       Node *node = phases[phase]->effects[i];
+               unsigned sampler_num = phase->inputs.size();
+               for (unsigned i = 0; i < phase->effects.size(); ++i) {
+                       Node *node = phase->effects[i];
                        unsigned old_sampler_num = sampler_num;
-                       node->effect->set_gl_state(glsl_program_num, phases[phase]->effect_ids[node], &sampler_num);
+                       node->effect->set_gl_state(glsl_program_num, phase->effect_ids[node], &sampler_num);
                        check_error();
 
                        if (node->effect->is_single_texture()) {
@@ -1563,15 +1541,18 @@ void EffectChain::render_to_fbo(GLuint dest_fbo, unsigned width, unsigned height
                        }
                }
 
-               glBindVertexArray(phases[phase]->vao);
+               glBindVertexArray(phase->vao);
                check_error();
                glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
                check_error();
 
-               for (unsigned i = 0; i < phases[phase]->effects.size(); ++i) {
-                       Node *node = phases[phase]->effects[i];
+               for (unsigned i = 0; i < phase->effects.size(); ++i) {
+                       Node *node = phase->effects[i];
                        node->effect->clear_gl_state();
                }
+               if (phase_num != phases.size() - 1) {
+                       resource_pool->release_fbo(fbo);
+               }
        }
 
        for (map<Phase *, GLuint>::const_iterator texture_it = output_textures.begin();