Allow an effect to have multiple inputs (although the graph still supports only one...
[movit] / blur_effect.cpp
1 #define GL_GLEXT_PROTOTYPES 1
2
3 #include <math.h>
4 #include <GL/gl.h>
5 #include <GL/glext.h>
6 #include <assert.h>
7
8 #include "blur_effect.h"
9 #include "util.h"
10
11 // Must match blur_effect.frag.
12 #define NUM_TAPS 16
13         
14 BlurEffect::BlurEffect() {
15         hpass = new SingleBlurPassEffect();
16         hpass->set_int("direction", SingleBlurPassEffect::HORIZONTAL);
17         vpass = new SingleBlurPassEffect();
18         vpass->set_int("direction", SingleBlurPassEffect::VERTICAL);
19 }
20
21 void BlurEffect::add_self_to_effect_chain(EffectChain *chain, const std::vector<Effect *> &inputs) {
22         assert(inputs.size() == 1);
23         hpass->add_self_to_effect_chain(chain, inputs);
24
25         std::vector<Effect *> vpass_inputs;
26         vpass_inputs.push_back(hpass);
27         vpass->add_self_to_effect_chain(chain, vpass_inputs);
28 }
29
30 bool BlurEffect::set_float(const std::string &key, float value) {
31         if (!hpass->set_float(key, value)) {
32                 return false;
33         }
34         return vpass->set_float(key, value);
35 }
36
37 SingleBlurPassEffect::SingleBlurPassEffect()
38         : radius(3.0f),
39           direction(HORIZONTAL)
40 {
41         register_float("radius", (float *)&radius);
42         register_int("direction", (int *)&direction);
43 }
44
45 std::string SingleBlurPassEffect::output_fragment_shader()
46 {
47         return read_file("blur_effect.frag");
48 }
49
50 void SingleBlurPassEffect::set_uniforms(GLuint glsl_program_num, const std::string &prefix, unsigned *sampler_num)
51 {
52         Effect::set_uniforms(glsl_program_num, prefix, sampler_num);
53
54         int base_texture_size, texture_size;
55         if (direction == HORIZONTAL) {
56                 base_texture_size = texture_size = 1280;  // FIXME
57         } else if (direction == VERTICAL) {
58                 base_texture_size = texture_size = 720;  // FIXME
59         } else {
60                 assert(false);
61         }
62
63         // We only have 16 taps to work with on each side, and we want that to
64         // reach out to about 2.5*sigma.  Bump up the mipmap levels (giving us
65         // box blurs) until we have what we need.
66         //
67         // FIXME: we really need to pick the same mipmap level for both horizontal and vertical!
68         unsigned base_mipmap_level = 0;
69         float adjusted_radius = radius;
70         while (texture_size > 1 && adjusted_radius * 2.5f > NUM_TAPS / 2) {
71                 ++base_mipmap_level;
72                 texture_size /= 2;  // Rounding down.
73                 adjusted_radius = radius * float(texture_size) / float(base_texture_size);
74         }
75
76         // In the second pass, we do the same, but don't sample from a mipmap;
77         // that would re-blur the other direction in an ugly fashion, and we already
78         // have the vertical box blur we need from that pass.
79         //
80         // TODO: We really need to present horizontal+vertical as a unit;
81         // currently, there's really no guarantee vertical blur is the second pass.
82         if (direction == VERTICAL) {
83                 base_mipmap_level = 0;
84         }
85
86         glActiveTexture(GL_TEXTURE0);
87         check_error();
88         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, base_mipmap_level);
89         check_error();
90         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, base_mipmap_level);
91         check_error();
92
93         // Compute the weights; they will be symmetrical, so we only compute
94         // the right side.
95         float weight[NUM_TAPS + 1];
96         if (radius < 1e-3) {
97                 weight[0] = 1.0f;
98                 for (unsigned i = 1; i < NUM_TAPS + 1; ++i) {
99                         weight[i] = 0.0f;
100                 }
101         } else {
102                 float sum = 0.0f;
103                 for (unsigned i = 0; i < NUM_TAPS + 1; ++i) {
104                         float z = i / adjusted_radius;
105
106                         // Gaussian blur is a common, but maybe not the prettiest choice;
107                         // it can feel a bit too blurry in the fine detail and too little
108                         // long-tail. This is a simple logistic distribution, which has
109                         // a narrower peak but longer tails.
110                         weight[i] = 1.0f / (cosh(z) * cosh(z));
111
112                         if (i == 0) {
113                                 sum += weight[i];
114                         } else {
115                                 sum += 2.0f * weight[i];
116                         }
117                 }
118                 for (unsigned i = 0; i < NUM_TAPS + 1; ++i) {
119                         weight[i] /= sum;
120                 }
121         }
122
123 #if 0
124         // NOTE: This is currently broken.
125
126         // Since the GPU gives us bilinear sampling for free, we can get two
127         // samples for the price of one (for every but the center sample,
128         // in which case this trick doesn't buy us anything). Simply sample
129         // between the two pixel centers, and we can do with fewer weights.
130         // (This is right even in the vertical pass where we don't actually
131         // sample between the pixels, because we have linear interpolation
132         // there too.)
133         //
134         // We pack the parameters into a float4: The relative sample coordinates
135         // in (x,y), and the weight in z. w is unused.
136         float samples[4 * (NUM_TAPS / 2 + 1)];
137
138         // Center sample.
139         samples[4 * 0 + 0] = 0.0f;
140         samples[4 * 0 + 1] = 0.0f;
141         samples[4 * 0 + 2] = weight[0];
142         samples[4 * 0 + 3] = 0.0f;
143
144         // All other samples.
145         for (unsigned i = 1; i < NUM_TAPS / 2 + 1; ++i) {
146                 unsigned base_pos = i * 2 - 1;
147                 float w1 = weight[base_pos];
148                 float w2 = weight[base_pos + 1];
149
150                 float offset, total_weight;
151                 if (w1 + w2 < 1e-6) {
152                         offset = 0.5f;
153                         total_weight = 0.0f;
154                 } else {
155                         offset = w2 / (w1 + w2);
156                         total_weight = w1 + w2;
157                 }
158 #if 0
159                 // hack for easier visualization
160                 offset = 0.5f;
161                 total_weight = 8.0f;
162 #endif
163                 float x = 0.0f, y = 0.0f;
164
165                 if (direction == HORIZONTAL) {
166                         x = (base_pos + offset) / (float)texture_size;
167                 } else if (direction == VERTICAL) {
168                         y = (base_pos + offset) / (float)texture_size;
169                 } else {
170                         assert(false);
171                 }
172
173                 samples[4 * i + 0] = x;
174                 samples[4 * i + 1] = y;
175                 samples[4 * i + 2] = total_weight;
176                 samples[4 * i + 3] = 0.0f;
177         }
178
179         set_uniform_vec4_array(glsl_program_num, prefix, "samples", samples, NUM_TAPS / 2 + 1);
180 #else
181         // Boring, at-whole-pixels sampling.
182         float samples[4 * NUM_TAPS];
183
184         // All other samples.
185         for (unsigned i = 0; i < NUM_TAPS + 1; ++i) {
186                 float x = 0.0f, y = 0.0f;
187
188                 if (direction == HORIZONTAL) {
189                         x = i / (float)texture_size;
190                 } else if (direction == VERTICAL) {
191                         y = i / (float)texture_size;
192                 } else {
193                         assert(false);
194                 }
195
196                 samples[4 * i + 0] = x;
197                 samples[4 * i + 1] = y;
198                 samples[4 * i + 2] = weight[i];
199                 samples[4 * i + 3] = 0.0f;
200         }
201
202         set_uniform_vec4_array(glsl_program_num, prefix, "samples", samples, NUM_TAPS + 1);
203 #endif
204 }