Split inputs into a separate class (descending from Effect) instead of handling them...
authorSteinar H. Gunderson <sgunderson@bigfoot.com>
Fri, 5 Oct 2012 22:24:33 +0000 (00:24 +0200)
committerSteinar H. Gunderson <sgunderson@bigfoot.com>
Fri, 5 Oct 2012 22:24:33 +0000 (00:24 +0200)
Makefile
effect.cpp
effect_chain.cpp
effect_chain.h
input.cpp [new file with mode: 0644]
input.frag [new file with mode: 0644]
input.h [new file with mode: 0644]
main.cpp

index e17e229..b79bd78 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -2,7 +2,7 @@ CC=gcc
 CXX=g++
 CXXFLAGS=-Wall -g
 LDFLAGS=-lSDL -lSDL_image -lGL
-OBJS=main.o util.o widgets.o effect.o effect_chain.o
+OBJS=main.o util.o widgets.o effect.o effect_chain.o input.o
 OBJS += lift_gamma_gain_effect.o gamma_expansion_effect.o gamma_compression_effect.o colorspace_conversion_effect.o saturation_effect.o vignette_effect.o mirror_effect.o blur_effect.o diffusion_effect.o sandbox_effect.o
 
 test: $(OBJS)
index 3128f0d..1bbb89f 100644 (file)
@@ -229,7 +229,7 @@ void Effect::set_gl_state(GLuint glsl_program_num, const std::string& prefix, un
                set_uniform_vec3(glsl_program_num, prefix, it->first, it->second);
        }
 
-       for (std::map<std::string, Texture1D>::const_iterator it = params_tex_1d.begin();
+       for (std::map<std::string, Texture1D>::iterator it = params_tex_1d.begin();
             it != params_tex_1d.end();
             ++it) {
                glActiveTexture(GL_TEXTURE0 + *sampler_num);
index 2144bfd..f4706a4 100644 (file)
 #include "vignette_effect.h"
 #include "blur_effect.h"
 #include "diffusion_effect.h"
+#include "input.h"
 
 EffectChain::EffectChain(unsigned width, unsigned height)
        : width(width),
          height(height),
-         use_srgb_texture_format(false),
          finalized(false) {}
 
-void EffectChain::add_input(const ImageFormat &format)
+Input *EffectChain::add_input(const ImageFormat &format)
 {
-       input_format = format;
-       output_color_space.insert(std::make_pair(static_cast<Effect *>(NULL), format.color_space));
-       output_gamma_curve.insert(std::make_pair(static_cast<Effect *>(NULL), format.gamma_curve));
-       effect_ids.insert(std::make_pair(static_cast<Effect *>(NULL), "src_image"));
+       Input *input = new Input(format, width, height);
+       effects.push_back(input);
+       output_color_space.insert(std::make_pair(input, format.color_space));
+       output_gamma_curve.insert(std::make_pair(input, format.gamma_curve));
+       effect_ids.insert(std::make_pair(input, "src_image"));
+       incoming_links.insert(std::make_pair(input, std::vector<Effect *>()));
+       return input;
 }
 
 void EffectChain::add_output(const ImageFormat &format)
@@ -51,9 +54,7 @@ void EffectChain::add_effect_raw(Effect *effect, const std::vector<Effect *> &in
        effect_ids.insert(std::make_pair(effect, effect_id));
        assert(inputs.size() == effect->num_inputs());
        for (unsigned i = 0; i < inputs.size(); ++i) {
-               if (inputs[i] != NULL) {
-                       assert(std::find(effects.begin(), effects.end(), inputs[i]) != effects.end());
-               }
+               assert(std::find(effects.begin(), effects.end(), inputs[i]) != effects.end());
                outgoing_links[inputs[i]].push_back(effect);
        }
        incoming_links.insert(std::make_pair(effect, inputs));
@@ -93,7 +94,7 @@ Effect *EffectChain::normalize_to_linear_gamma(Effect *input)
        assert(output_gamma_curve.count(input) != 0);
        if (output_gamma_curve[input] == GAMMA_sRGB) {
                // TODO: check if the extension exists
-               use_srgb_texture_format = true;
+               effects[0]->set_int("use_srgb_texture_format", 1);
                output_gamma_curve[input] = GAMMA_LINEAR;
                return input;
        } else {
@@ -210,7 +211,7 @@ EffectChain::Phase EffectChain::compile_glsl_program(const std::vector<Effect *>
        
                frag_shader += std::string("uniform sampler2D tex_") + effect_id + ";\n";       
                frag_shader += std::string("vec4 ") + effect_id + "(vec2 tc) {\n";
-               if (effect == NULL) {
+               if (effect->num_inputs() == 0) {
                        // OpenGL's origin is bottom-left, but most graphics software assumes
                        // a top-left origin. Thus, for inputs that come from the user,
                        // we flip the y coordinate. However, for FBOs, the origin
@@ -259,6 +260,12 @@ EffectChain::Phase EffectChain::compile_glsl_program(const std::vector<Effect *>
 
                input_needs_mipmaps |= effect->needs_mipmaps();
        }
+       for (unsigned i = 0; i < effects.size(); ++i) {
+               Effect *effect = effects[i];
+               if (effect->num_inputs() == 0) {
+                       effect->set_int("needs_mipmaps", input_needs_mipmaps);
+               }
+       }
        assert(!last_effect_id.empty());
        frag_shader += std::string("#define INPUT ") + last_effect_id + "\n";
        frag_shader.append(read_file("footer.frag"));
@@ -289,6 +296,7 @@ EffectChain::Phase EffectChain::compile_glsl_program(const std::vector<Effect *>
 // effects, and of course at the end.
 void EffectChain::construct_glsl_programs(Effect *start, std::set<Effect *> *completed_effects)
 {
+       assert(start != NULL);
        if (completed_effects->count(start) != 0) {
                // This has already been done for us.
                return;
@@ -298,15 +306,15 @@ void EffectChain::construct_glsl_programs(Effect *start, std::set<Effect *> *com
        std::vector<Effect *> this_phase_effects;
        Effect *node = start;
        for ( ;; ) {  // Termination condition within loop.
-               if (node == NULL) {
-                       this_phase_inputs.push_back(node);
-               } else {
-                       // Check that we have all the inputs we need for this effect.
-                       // If not, we end the phase here right away; the other side
-                       // of the input chain will eventually come and pick the effect up.
-                       assert(incoming_links.count(node) != 0);
-                       std::vector<Effect *> deps = incoming_links[node];
-                       assert(!deps.empty());
+               assert(node != NULL);
+
+               // Check that we have all the inputs we need for this effect.
+               // If not, we end the phase here right away; the other side
+               // of the input chain will eventually come and pick the effect up.
+               assert(incoming_links.count(node) == 1);
+               std::vector<Effect *> deps = incoming_links[node];
+               assert(node->num_inputs() == deps.size());
+               if (!deps.empty()) {
                        bool have_all_deps = true;
                        for (unsigned i = 0; i < deps.size(); ++i) {
                                if (completed_effects->count(deps[i]) == 0) {
@@ -322,8 +330,8 @@ void EffectChain::construct_glsl_programs(Effect *start, std::set<Effect *> *com
                                return;
                        }
                        this_phase_inputs.insert(this_phase_inputs.end(), deps.begin(), deps.end());    
-                       this_phase_effects.push_back(node);
                }
+               this_phase_effects.push_back(node);
                completed_effects->insert(node);        
 
                // Find all the effects that use this one as a direct input.
@@ -336,11 +344,11 @@ void EffectChain::construct_glsl_programs(Effect *start, std::set<Effect *> *com
                std::vector<Effect *> next = outgoing_links[node];
                assert(!next.empty());
                if (next.size() > 1) {
-                       // More than one effect uses this as the input.
-                       // The easiest thing to do (and probably also the safest
-                       // performance-wise in most cases) is to bounce it to a texture
-                       // and then let the next passes read from that.
-                       if (node != NULL) {
+                       if (node->num_inputs() != 0) {
+                               // More than one effect uses this as the input, and it is not a texture itself.
+                               // The easiest thing to do (and probably also the safest
+                               // performance-wise in most cases) is to bounce it to a texture
+                               // and then let the next passes read from that.
                                phases.push_back(compile_glsl_program(this_phase_inputs, this_phase_effects));
                        }
 
@@ -394,7 +402,7 @@ void EffectChain::finalize()
 
        // Construct all needed GLSL programs, starting at the input.
        std::set<Effect *> completed_effects;
-       construct_glsl_programs(NULL, &completed_effects);
+       construct_glsl_programs(effects[0], &completed_effects);
 
        // If we have more than one phase, we need intermediate render-to-texture.
        // Construct an FBO, and then as many textures as we need.
@@ -420,79 +428,16 @@ void EffectChain::finalize()
                        effect_output_textures.insert(std::make_pair(output_effect, temp_texture));
                }
        }
+               
+       (static_cast<Input *>(effects[0]))->finalize();
        
-       // Translate the input format to OpenGL's enums.
-       GLenum internal_format;
-       if (use_srgb_texture_format) {
-               internal_format = GL_SRGB8;
-       } else {
-               internal_format = GL_RGBA8;
-       }
-       if (input_format.pixel_format == FORMAT_RGB) {
-               format = GL_RGB;
-               bytes_per_pixel = 3;
-       } else if (input_format.pixel_format == FORMAT_RGBA) {
-               format = GL_RGBA;
-               bytes_per_pixel = 4;
-       } else if (input_format.pixel_format == FORMAT_BGR) {
-               format = GL_BGR;
-               bytes_per_pixel = 3;
-       } else if (input_format.pixel_format == FORMAT_BGRA) {
-               format = GL_BGRA;
-               bytes_per_pixel = 4;
-       } else {
-               assert(false);
-       }
-
-       // Create PBO to hold the texture holding the input image, and then the texture itself.
-       glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 2);
-       check_error();
-       glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * bytes_per_pixel, NULL, GL_STREAM_DRAW);
-       check_error();
-       glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
-       check_error();
-       
-       glGenTextures(1, &source_image_num);
-       check_error();
-       glBindTexture(GL_TEXTURE_2D, source_image_num);
-       check_error();
-       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-       check_error();
-       // Intel/Mesa seems to have a broken glGenerateMipmap() for non-FBO textures, so do it here.
-       glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, phases[0].input_needs_mipmaps ? GL_TRUE : GL_FALSE);
-       check_error();
-       glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
-       check_error();
-
        finalized = true;
 }
 
-void EffectChain::render_to_screen(unsigned char *src)
+void EffectChain::render_to_screen()
 {
        assert(finalized);
 
-       // Copy the pixel data into the PBO.
-       glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 2);
-       check_error();
-       void *mapped_pbo = glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY);
-       memcpy(mapped_pbo, src, width * height * bytes_per_pixel);
-       glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
-       check_error();
-
-       // Re-upload the texture from the PBO.
-       glActiveTexture(GL_TEXTURE0);
-       check_error();
-       glBindTexture(GL_TEXTURE_2D, source_image_num);
-       check_error();
-       glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0));
-       check_error();
-       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-       check_error();
-       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-       check_error();
-       glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
-       check_error();
-
        // Basic state.
        glDisable(GL_BLEND);
        check_error();
@@ -514,25 +459,19 @@ void EffectChain::render_to_screen(unsigned char *src)
        }
 
        std::set<Effect *> generated_mipmaps;
-       generated_mipmaps.insert(NULL);  // Already done further up.
+       generated_mipmaps.insert(effects[0]);  // Already done further up.
 
        for (unsigned phase = 0; phase < phases.size(); ++phase) {
                glUseProgram(phases[phase].glsl_program_num);
                check_error();
 
-               // Set up inputs for this phase.
-               assert(!phases[phase].inputs.empty());
+               // Set up RTT inputs for this phase.
                for (unsigned sampler = 0; sampler < phases[phase].inputs.size(); ++sampler) {
                        glActiveTexture(GL_TEXTURE0 + sampler);
                        Effect *input = phases[phase].inputs[sampler];
-                       if (input == NULL) {
-                               glBindTexture(GL_TEXTURE_2D, source_image_num);
-                               check_error();
-                       } else {
-                               assert(effect_output_textures.count(input) != 0);
-                               glBindTexture(GL_TEXTURE_2D, effect_output_textures[input]);
-                               check_error();
-                       }
+                       assert(effect_output_textures.count(input) != 0);
+                       glBindTexture(GL_TEXTURE_2D, effect_output_textures[input]);
+                       check_error();
                        if (phases[phase].input_needs_mipmaps) {
                                if (generated_mipmaps.count(input) == 0) {
                                        glGenerateMipmap(GL_TEXTURE_2D);
index 561d823..5e3b93d 100644 (file)
@@ -6,28 +6,8 @@
 
 #include "effect.h"
 #include "effect_id.h"
-
-enum PixelFormat { FORMAT_RGB, FORMAT_RGBA, FORMAT_BGR, FORMAT_BGRA };
-
-enum ColorSpace {
-       COLORSPACE_sRGB = 0,
-       COLORSPACE_REC_709 = 0,  // Same as sRGB.
-       COLORSPACE_REC_601_525 = 1,
-       COLORSPACE_REC_601_625 = 2,
-};
-
-enum GammaCurve {
-       GAMMA_LINEAR = 0,
-       GAMMA_sRGB = 1,
-       GAMMA_REC_601 = 2,
-       GAMMA_REC_709 = 2,  // Same as Rec. 601.
-};
-
-struct ImageFormat {
-       PixelFormat pixel_format;
-       ColorSpace color_space;
-       GammaCurve gamma_curve;
-};
+#include "image_format.h"
+#include "input.h"
 
 class EffectChain {
 public:
@@ -36,7 +16,7 @@ public:
        // User API:
        // input, effects, output, finalize need to come in that specific order.
 
-       void add_input(const ImageFormat &format);
+       Input *add_input(const ImageFormat &format);
 
        // The returned pointer is owned by EffectChain.
        Effect *add_effect(EffectId effect) {
@@ -69,7 +49,7 @@ public:
        void finalize();
 
        //void render(unsigned char *src, unsigned char *dst);
-       void render_to_screen(unsigned char *src);
+       void render_to_screen();
 
        Effect *last_added_effect() {
                if (effects.empty()) {
@@ -107,9 +87,6 @@ private:
        std::map<Effect *, std::vector<Effect *> > outgoing_links;
        std::map<Effect *, std::vector<Effect *> > incoming_links;
 
-       GLuint source_image_num;
-       bool use_srgb_texture_format;
-
        GLuint fbo;
        std::vector<Phase> phases;
 
diff --git a/input.cpp b/input.cpp
new file mode 100644 (file)
index 0000000..1e460f0
--- /dev/null
+++ b/input.cpp
@@ -0,0 +1,108 @@
+#define GL_GLEXT_PROTOTYPES 1
+
+#include <string.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include <assert.h>
+
+#include "input.h"
+#include "util.h"
+
+Input::Input(ImageFormat image_format, unsigned width, unsigned height)
+       : image_format(image_format),
+         needs_update(false),
+         use_srgb_texture_format(false),
+         needs_mipmaps(false),
+         width(width),
+         height(height)
+{
+       register_int("use_srgb_texture_format", &use_srgb_texture_format);
+       register_int("needs_mipmaps", &needs_mipmaps);
+}
+
+void Input::finalize()
+{
+       // Translate the input format to OpenGL's enums.
+       GLenum internal_format;
+       if (use_srgb_texture_format) {
+               internal_format = GL_SRGB8;
+       } else {
+               internal_format = GL_RGBA8;
+       }
+       if (image_format.pixel_format == FORMAT_RGB) {
+               format = GL_RGB;
+               bytes_per_pixel = 3;
+       } else if (image_format.pixel_format == FORMAT_RGBA) {
+               format = GL_RGBA;
+               bytes_per_pixel = 4;
+       } else if (image_format.pixel_format == FORMAT_BGR) {
+               format = GL_BGR;
+               bytes_per_pixel = 3;
+       } else if (image_format.pixel_format == FORMAT_BGRA) {
+               format = GL_BGRA;
+               bytes_per_pixel = 4;
+       } else {
+               assert(false);
+       }
+
+       // Create PBO to hold the texture holding the input image, and then the texture itself.
+       glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 2);
+       check_error();
+       glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * bytes_per_pixel, NULL, GL_STREAM_DRAW);
+       check_error();
+       glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+       check_error();
+       
+       glGenTextures(1, &texture_num);
+       check_error();
+       glBindTexture(GL_TEXTURE_2D, texture_num);
+       check_error();
+       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+       check_error();
+       // Intel/Mesa seems to have a broken glGenerateMipmap() for non-FBO textures, so do it here
+       // instead of calling glGenerateMipmap().
+       glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, needs_mipmaps);
+       check_error();
+       glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
+       check_error();
+
+       needs_update = false;
+}
+       
+void Input::set_gl_state(GLuint glsl_program_num, const std::string& prefix, unsigned *sampler_num)
+{
+       if (needs_update) {
+               // Copy the pixel data into the PBO.
+               glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 2);
+               check_error();
+               void *mapped_pbo = glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY);
+               memcpy(mapped_pbo, pixel_data, width * height * bytes_per_pixel);
+               glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
+               check_error();
+
+               // Re-upload the texture from the PBO.
+               glActiveTexture(GL_TEXTURE0);
+               check_error();
+               glBindTexture(GL_TEXTURE_2D, texture_num);
+               check_error();
+               glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0));
+               check_error();
+               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+               check_error();
+               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+               check_error();
+               glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+               check_error();
+
+               needs_update = false;
+       }
+
+       // Bind it to a sampler.
+       set_uniform_int(glsl_program_num, prefix, "tex", *sampler_num);
+       ++*sampler_num;
+}
+
+std::string Input::output_fragment_shader()
+{
+       return read_file("input.frag");
+}
diff --git a/input.frag b/input.frag
new file mode 100644 (file)
index 0000000..4bc055e
--- /dev/null
@@ -0,0 +1,10 @@
+uniform sampler2D PREFIX(tex);
+
+vec4 FUNCNAME(vec2 tc) {
+       // OpenGL's origin is bottom-left, but most graphics software assumes
+       // a top-left origin. Thus, for inputs that come from the user,
+       // we flip the y coordinate.
+       tc.y = 1.0f - tc.y;
+
+       return texture2D(PREFIX(tex), tc);
+}
diff --git a/input.h b/input.h
new file mode 100644 (file)
index 0000000..dd80bb6
--- /dev/null
+++ b/input.h
@@ -0,0 +1,56 @@
+#ifndef _INPUT_H
+#define _INPUT_H 1
+
+#include "effect.h"
+#include "image_format.h"
+
+// An input is a degenerate case of an effect; it represents the picture data
+// that comes from the user. As such, it has zero “inputs” itself, and some of
+// the normal operations don't really make sense for it.
+class Input : public Effect {
+public:
+       Input(ImageFormat format, unsigned width, unsigned height);
+
+       unsigned num_inputs() const { return 0; }
+
+       // Create the texture itself. We cannot do this in the constructor,
+       // because we don't necessarily know all the settings (sRGB texture,
+       // mipmap generation) at that point.
+       void finalize();
+
+       std::string output_fragment_shader();
+
+       // Uploads the texture if it has changed since last time.
+       void set_gl_state(GLuint glsl_program_num, const std::string& prefix, unsigned *sampler_num);
+
+       // Tells the input where to fetch the actual pixel data. Note that if you change
+       // this data, you must either call set_pixel_data() again (using the same pointer
+       // is fine), or invalidate_pixel_data(). Otherwise, the texture won't be re-uploaded
+       // on subsequent frames.
+       void set_pixel_data(const unsigned char *pixel_data)
+       {
+               this->pixel_data = pixel_data;
+               invalidate_pixel_data();
+       }
+
+       void invalidate_pixel_data()
+       {
+               needs_update = true;
+       }
+
+       const unsigned char *get_pixel_data() const
+       {
+               return pixel_data;
+       }
+
+private:
+       ImageFormat image_format;
+       GLenum format;
+       GLuint texture_num;
+       bool needs_update;
+       int use_srgb_texture_format, needs_mipmaps;
+       unsigned width, height, bytes_per_pixel;
+       const unsigned char *pixel_data;
+};
+
+#endif // !defined(_INPUT_H)
index bbc7752..8693716 100644 (file)
--- a/main.cpp
+++ b/main.cpp
@@ -164,7 +164,7 @@ int main(int argc, char **argv)
        inout_format.color_space = COLORSPACE_sRGB;
        inout_format.gamma_curve = GAMMA_sRGB;
 
-       chain.add_input(inout_format);
+       Input *input = chain.add_input(inout_format);
        Effect *lift_gamma_gain_effect = chain.add_effect(EFFECT_LIFT_GAMMA_GAIN);
        Effect *saturation_effect = chain.add_effect(EFFECT_SATURATION);
        Effect *diffusion_effect = chain.add_effect(EFFECT_DIFFUSION);
@@ -217,7 +217,8 @@ int main(int argc, char **argv)
                diffusion_effect->set_float("radius", blur_radius);
                diffusion_effect->set_float("blurred_mix_amount", blurred_mix_amount);
 
-               chain.render_to_screen(src_img);
+               input->set_pixel_data(src_img);
+               chain.render_to_screen();
                
                glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 1);
                check_error();