X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.h;h=48b60872173b283e6eba59c4ad97a2ba782566e3;hp=9622abc0eef1abf824b3b83f2c9fbdd151eef104;hb=9b4350ffc9c559b6ed666e1858ec7396455ff9ab;hpb=a592c55caca0fb654bad4ec43b84c46abcee21c2 diff --git a/effect_chain.h b/effect_chain.h index 9622abc..48b6087 100644 --- a/effect_chain.h +++ b/effect_chain.h @@ -1,62 +1,168 @@ #ifndef _EFFECT_CHAIN_H #define _EFFECT_CHAIN_H 1 +#include #include #include "effect.h" -#include "effect_id.h" +#include "image_format.h" +#include "input.h" -enum PixelFormat { FORMAT_RGB, FORMAT_RGBA }; +class EffectChain; +class Phase; -enum ColorSpace { - COLORSPACE_sRGB = 0, - COLORSPACE_REC_709 = 0, // Same as sRGB. - COLORSPACE_REC_601_525 = 1, - COLORSPACE_REC_601_625 = 2, -}; +// A node in the graph; basically an effect and some associated information. +class Node { +public: + Effect *effect; + bool disabled; + + // Edges in the graph (forward and backward). + std::vector outgoing_links; + std::vector incoming_links; + +private: + // Identifier used to create unique variables in GLSL. + std::string effect_id; + + // If output goes to RTT (otherwise, none of these are set). + // The Phase pointer is a but ugly; we should probably fix so + // that Phase takes other phases as inputs, instead of Node. + GLuint output_texture; + unsigned output_texture_width, output_texture_height; + Phase *phase; + + // Used during the building of the effect chain. + ColorSpace output_color_space; + GammaCurve output_gamma_curve; -enum GammaCurve { - GAMMA_LINEAR = 0, - GAMMA_sRGB = 1, - GAMMA_REC_601 = 2, - GAMMA_REC_709 = 2, // Same as Rec. 601. + friend class EffectChain; }; -struct ImageFormat { - PixelFormat pixel_format; - ColorSpace color_space; - GammaCurve gamma_curve; +// A rendering phase; a single GLSL program rendering a single quad. +struct Phase { + GLint glsl_program_num; + bool input_needs_mipmaps; + + // Inputs are only inputs from other phases (ie., those that come from RTT); + // input textures are not counted here. + std::vector inputs; + + std::vector effects; // In order. + unsigned output_width, output_height; }; class EffectChain { public: - EffectChain(unsigned width, unsigned height); + EffectChain(float aspect_nom, float aspect_denom); // E.g., 16.0f, 9.0f for 16:9. + // User API: // input, effects, output, finalize need to come in that specific order. - void add_input(const ImageFormat &format); - - // The returned pointer is owned by EffectChain. - Effect *add_effect(EffectId effect); + // EffectChain takes ownership of the given input. + // input is returned back for convenience. + Input *add_input(Input *input); + + // EffectChain takes ownership of the given effect. + // effect is returned back for convenience. + Effect *add_effect(Effect *effect) { + return add_effect(effect, last_added_effect()); + } + Effect *add_effect(Effect *effect, Effect *input) { + std::vector inputs; + inputs.push_back(input); + return add_effect(effect, inputs); + } + Effect *add_effect(Effect *effect, Effect *input1, Effect *input2) { + std::vector inputs; + inputs.push_back(input1); + inputs.push_back(input2); + return add_effect(effect, inputs); + } + Effect *add_effect(Effect *effect, const std::vector &inputs); void add_output(const ImageFormat &format); 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 (nodes.empty()) { + return NULL; + } else { + return nodes.back()->effect; + } + } + + // API for manipulating the graph directly. Intended to be used from + // effects and by EffectChain itself. + // + // Note that for nodes with multiple inputs, the order of calls to + // connect_nodes() will matter. + Node *add_node(Effect *effect); + void connect_nodes(Node *sender, Node *receiver); + void replace_receiver(Node *old_receiver, Node *new_receiver); + void replace_sender(Node *new_sender, Node *receiver); + void insert_node_between(Node *sender, Node *middle, Node *receiver); private: - unsigned width, height; - ImageFormat input_format, output_format; - std::vector effects; + // Fits a rectangle of the given size to the current aspect ratio + // (aspect_nom/aspect_denom) and returns the new width and height. + unsigned fit_rectangle_to_aspect(unsigned width, unsigned height); - int glsl_program_num; - bool finalized; + // Determine the preferred output size of a given phase. + // Requires that all input phases (if any) already have output sizes set. + void find_output_size(Phase *phase); - // Used during the building of the effect chain. - ColorSpace current_color_space; - GammaCurve current_gamma_curve; -}; + // Find all inputs eventually feeding into this effect that have + // output gamma different from GAMMA_LINEAR. + void find_all_nonlinear_inputs(Node *effect, std::vector *nonlinear_inputs); + // Create a GLSL program computing the given effects in order. + Phase *compile_glsl_program(const std::vector &inputs, + const std::vector &effects); + + // Create all GLSL programs needed to compute the given effect, and all outputs + // that depends on it (whenever possible). + void construct_glsl_programs(Node *output); + + // Output the current graph to the given file in a Graphviz-compatible format; + // only useful for debugging. + void output_dot(const char *filename); + + // Some of the graph algorithms assume that the nodes array is sorted + // topologically (inputs are always before outputs), but some operations + // (like graph rewriting) can change that. This function restores that order. + void sort_nodes_topologically(); + void topological_sort_visit_node(Node *node, std::set *visited_nodes, std::vector *sorted_list); + + // Used during finalize(). + void propagate_gamma_and_color_space(); + Node *find_output_node(); + + bool node_needs_colorspace_fix(Node *node); + void fix_internal_color_spaces(); + void fix_output_color_space(); + + bool node_needs_gamma_fix(Node *node); + void fix_internal_gamma_by_asking_inputs(unsigned step); + void fix_internal_gamma_by_inserting_nodes(unsigned step); + void fix_output_gamma(); + + float aspect_nom, aspect_denom; + ImageFormat output_format; + + std::vector nodes; + std::map node_map; + + std::vector inputs; // Also contained in nodes. + + GLuint fbo; + std::vector phases; + + GLenum format, bytes_per_pixel; + bool finalized; +}; #endif // !defined(_EFFECT_CHAIN_H)