Move Node and Phase out from being inner classes, given that we soon want to expose...
[movit] / effect_chain.h
1 #ifndef _EFFECT_CHAIN_H
2 #define _EFFECT_CHAIN_H 1
3
4 #include <set>
5 #include <vector>
6
7 #include "effect.h"
8 #include "image_format.h"
9 #include "input.h"
10
11 class EffectChain;
12 class Phase;
13
14 // A node in the graph; basically an effect and some associated information.
15 class Node {
16 public:
17         Effect *effect;
18
19         // Edges in the graph (forward and backward).
20         std::vector<Node *> outgoing_links;
21         std::vector<Node *> incoming_links;
22
23 private:
24         // Identifier used to create unique variables in GLSL.
25         std::string effect_id;
26
27         // If output goes to RTT (otherwise, none of these are set).
28         // The Phsae pointer is a but ugly; we should probably fix so
29         // that Phase takes other phases as inputs, instead of Node.
30         GLuint output_texture;
31         unsigned output_texture_width, output_texture_height;
32         Phase *phase;
33
34         // Used during the building of the effect chain.
35         ColorSpace output_color_space;
36         GammaCurve output_gamma_curve;
37
38         friend class EffectChain;
39 };
40
41 // A rendering phase; a single GLSL program rendering a single quad.
42 struct Phase {
43         GLint glsl_program_num;
44         bool input_needs_mipmaps;
45
46         // Inputs are only inputs from other phases (ie., those that come from RTT);
47         // input textures are not counted here.
48         std::vector<Node *> inputs;
49
50         std::vector<Node *> effects;  // In order.
51         unsigned output_width, output_height;
52 };
53
54 class EffectChain {
55 public:
56         EffectChain(unsigned width, unsigned height);
57
58         // User API:
59         // input, effects, output, finalize need to come in that specific order.
60
61         // EffectChain takes ownership of the given input.
62         // input is returned back for convenience.
63         Input *add_input(Input *input);
64
65         // EffectChain takes ownership of the given effect.
66         // effect is returned back for convenience.
67         Effect *add_effect(Effect *effect) {
68                 return add_effect(effect, last_added_effect());
69         }
70         Effect *add_effect(Effect *effect, Effect *input) {
71                 std::vector<Effect *> inputs;
72                 inputs.push_back(input);
73                 return add_effect(effect, inputs);
74         }
75         Effect *add_effect(Effect *effect, Effect *input1, Effect *input2) {
76                 std::vector<Effect *> inputs;
77                 inputs.push_back(input1);
78                 inputs.push_back(input2);
79                 return add_effect(effect, inputs);
80         }
81         Effect *add_effect(Effect *effect, const std::vector<Effect *> &inputs);
82
83         // Similar to add_effect, but:
84         //
85         //  * Does not insert any normalizing effects.
86         //  * Does not ask the effect to insert itself, so it won't work
87         //    with meta-effects.
88         //
89         // We should really separate out these two “sides” of Effect in the
90         // type system soon.
91         void add_effect_raw(Effect *effect, const std::vector<Effect *> &inputs);
92
93         void add_output(const ImageFormat &format);
94         void finalize();
95
96         //void render(unsigned char *src, unsigned char *dst);
97         void render_to_screen();
98
99         Effect *last_added_effect() {
100                 if (nodes.empty()) {
101                         return NULL;
102                 } else {
103                         return nodes.back()->effect;
104                 }       
105         }
106
107 private:
108         // Determine the preferred output size of a given phase.
109         // Requires that all input phases (if any) already have output sizes set.
110         void find_output_size(Phase *phase);
111
112         void find_all_nonlinear_inputs(Node *effect,
113                                        std::vector<Node *> *nonlinear_inputs,
114                                        std::vector<Node *> *intermediates);
115         Node *normalize_to_linear_gamma(Node *input);
116         Node *normalize_to_srgb(Node *input);
117
118         void draw_vertex(float x, float y, const std::vector<Effect *> &inputs);
119
120         // Create a GLSL program computing the given effects in order.
121         Phase *compile_glsl_program(const std::vector<Node *> &inputs,
122                                     const std::vector<Node *> &effects);
123
124         // Create all GLSL programs needed to compute the given effect, and all outputs
125         // that depends on it (whenever possible).
126         void construct_glsl_programs(Node *output);
127
128         unsigned width, height;
129         ImageFormat output_format;
130
131         std::vector<Node *> nodes;
132         std::map<Effect *, Node *> node_map;
133
134         std::vector<Input *> inputs;  // Also contained in nodes.
135
136         GLuint fbo;
137         std::vector<Phase *> phases;
138
139         GLenum format, bytes_per_pixel;
140         bool finalized;
141 };
142
143 #endif // !defined(_EFFECT_CHAIN_H)