X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.h;h=642f079201f037219b1ead3c02aebf3e85bfb28d;hp=f5064eb7b53bb8bfd8ea51919b33a4d9385649d4;hb=1f4a7aefd4a149e93a1dc41f85958e827670c98b;hpb=5d4c0425579de66b3e2dd7d0095e890278f8efcf diff --git a/effect_chain.h b/effect_chain.h index f5064eb..642f079 100644 --- a/effect_chain.h +++ b/effect_chain.h @@ -1,15 +1,37 @@ -#ifndef _EFFECT_CHAIN_H -#define _EFFECT_CHAIN_H 1 - +#ifndef _MOVIT_EFFECT_CHAIN_H +#define _MOVIT_EFFECT_CHAIN_H 1 + +// An EffectChain is the largest basic entity in Movit; it contains everything +// needed to connects a series of effects, from inputs to outputs, and render +// them. Generally you set up your effect chain once and then call its render +// functions once per frame; setting one up can be relatively expensive, +// but rendering is fast. +// +// Threading considerations: EffectChain is “thread-compatible”; you can use +// different EffectChains in multiple threads at the same time (assuming the +// threads do not use the same OpenGL context, but this is a good idea anyway), +// but you may not use one EffectChain from multiple threads simultaneously. +// You _are_ allowed to use one EffectChain from multiple threads as long as +// you only use it from one at a time (possibly by doing your own locking), +// but if so, the threads' contexts need to be set up to share resources, since +// the EffectChain holds textures and other OpenGL objects that are tied to the +// context. + +#include +#include +#include #include +#include #include -#include "effect.h" #include "image_format.h" -#include "input.h" -class EffectChain; +namespace movit { + +class Effect; +class Input; struct Phase; +class ResourcePool; // For internal use within Node. enum AlphaType { @@ -22,8 +44,8 @@ enum AlphaType { // Whether you want pre- or postmultiplied alpha in the output // (see effect.h for a discussion of pre- versus postmultiplied alpha). enum OutputAlphaFormat { - OUTPUT_ALPHA_PREMULTIPLIED, - OUTPUT_POSTMULTIPLIED_ALPHA, + OUTPUT_ALPHA_FORMAT_PREMULTIPLIED, + OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED, }; // A node in the graph; basically an effect and some associated information. @@ -37,9 +59,6 @@ public: std::vector incoming_links; private: - // Identifier used to create unique variables in GLSL. - std::string effect_id; - // Logical size of the output of this effect, ie. the resolution // you would get if you sampled it as a texture. If it is undefined // (since the inputs differ in resolution), it will be 0x0. @@ -47,11 +66,9 @@ private: // they will be equal. unsigned output_width, output_height; - // 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; + // If output goes to RTT, which phase it is in (otherwise unset). + // This is a bit ugly; we should probably fix so that Phase takes other + // phases as inputs, instead of Node. Phase *phase; // Used during the building of the effect chain. @@ -64,7 +81,7 @@ private: // A rendering phase; a single GLSL program rendering a single quad. struct Phase { - GLint glsl_program_num, vertex_shader, fragment_shader; + GLuint glsl_program_num; // Owned by the resource_pool. bool input_needs_mipmaps; // Inputs are only inputs from other phases (ie., those that come from RTT); @@ -73,11 +90,21 @@ struct Phase { std::vector effects; // In order. unsigned output_width, output_height, virtual_output_width, virtual_output_height; + + // Identifier used to create unique variables in GLSL. + // Unique per-phase to increase cacheability of compiled shaders. + std::map effect_ids; }; class EffectChain { public: - EffectChain(float aspect_nom, float aspect_denom); // E.g., 16.0f, 9.0f for 16:9. + // Aspect: e.g. 16.0f, 9.0f for 16:9. + // resource_pool is a pointer to a ResourcePool with which to share shaders + // and other resources (see resource_pool.h). If NULL (the default), + // will create its own that is not shared with anything else. Does not take + // ownership of the passed-in ResourcePool, but will naturally take ownership + // of its own internal one if created. + EffectChain(float aspect_nom, float aspect_denom, ResourcePool *resource_pool = NULL); ~EffectChain(); // User API: @@ -147,6 +174,12 @@ public: void replace_sender(Node *new_sender, Node *receiver); void insert_node_between(Node *sender, Node *middle, Node *receiver); + // Get the current resource pool assigned to this EffectChain. + // Primarily to let effects allocate textures as needed. + // Any resources you get from the pool must be returned to the pool + // no later than in the Effect's destructor. + ResourcePool *get_resource_pool() { return resource_pool; } + private: // Make sure the output rectangle is at least large enough to hold // the given input rectangle in both dimensions, and is of the @@ -226,12 +259,15 @@ private: Effect *dither_effect; std::vector inputs; // Also contained in nodes. - - GLuint fbo; std::vector phases; unsigned num_dither_bits; bool finalized; + + ResourcePool *resource_pool; + bool owns_resource_pool; }; -#endif // !defined(_EFFECT_CHAIN_H) +} // namespace movit + +#endif // !defined(_MOVIT_EFFECT_CHAIN_H)