Remove some unused samplers from ycbcr_conversion_effect.frag.

[movit] / effect_chain.h

diff --git a/effect_chain.h b/effect_chain.h
index ee387a954613edc8629b49762d720e339479d9ab..09b9aedc85ac78aa405b5c37042f5a56fa6feaf5 100644 (file)
--- a/effect_chain.h
+++ b/effect_chain.h
@@ -112,6 +112,12 @@ enum FramebufferTransformation {
        SQUARE_ROOT_FRAMEBUFFER_TRANSFORMATION,
 };
 
+// Whether a link is into another phase or not; see Node::incoming_link_type.
+enum NodeLinkType {
+       IN_ANOTHER_PHASE,
+       IN_SAME_PHASE
+};
+
 // A node in the graph; basically an effect and some associated information.
 class Node {
 public:
@@ -143,16 +149,29 @@ private:
        // sampler state here.
        int bound_sampler_num;
 
+       // For each node in incoming_links, whether it comes from another phase
+       // or not. This is required because in some rather obscure cases,
+       // it is possible to have an input twice in the same phase; both by
+       // itself and as a bounced input.
+       //
+       // TODO: It is possible that we might even need to bounce multiple
+       // times and thus disambiguate also between different external phases,
+       // but we'll deal with that when we need to care about it, if ever.
+       std::vector<NodeLinkType> incoming_link_type;
+
        // Used during the building of the effect chain.
        Colorspace output_color_space;
        GammaCurve output_gamma_curve;
        AlphaType output_alpha_type;
-       bool needs_mipmaps;  // Directly or indirectly.
+       Effect::MipmapRequirements needs_mipmaps;  // Directly or indirectly.
 
        // Set if this effect, and all effects consuming output from this node
        // (in the same phase) have one_to_one_sampling() set.
        bool one_to_one_sampling;
 
+       // Same, for strong_one_to_one_sampling().
+       bool strong_one_to_one_sampling;
+
        friend class EffectChain;
 };
 
@@ -166,8 +185,6 @@ struct Phase {
        // which is which, because they contain the same data.
        std::set<GLint> attribute_indexes;
 
-       bool input_needs_mipmaps;
-
        // Inputs are only inputs from other phases (ie., those that come from RTT);
        // input textures are counted as part of <effects>.
        std::vector<Phase *> inputs;
@@ -181,6 +198,7 @@ struct Phase {
        // Whether this phase is compiled as a compute shader, ie., the last effect is
        // marked as one.
        bool is_compute_shader;
+       Node *compute_shader_node;
 
        // If <is_compute_shader>, which image unit the output buffer is bound to.
        // This is used as source for a Uniform<int> below.
@@ -188,17 +206,19 @@ struct Phase {
 
        // These are used in transforming from unnormalized to normalized coordinates
        // in compute shaders.
+       int uniform_output_size[2];
        Point2D inv_output_size, output_texcoord_adjust;
 
        // Identifier used to create unique variables in GLSL.
        // Unique per-phase to increase cacheability of compiled shaders.
-       std::map<Node *, std::string> effect_ids;
+       std::map<std::pair<Node *, NodeLinkType>, std::string> effect_ids;
 
        // Uniforms for this phase; combined from all the effects.
        std::vector<Uniform<int>> uniforms_image2d;
        std::vector<Uniform<int>> uniforms_sampler2d;
        std::vector<Uniform<bool>> uniforms_bool;
        std::vector<Uniform<int>> uniforms_int;
+       std::vector<Uniform<int>> uniforms_ivec2;
        std::vector<Uniform<float>> uniforms_float;
        std::vector<Uniform<float>> uniforms_vec2;
        std::vector<Uniform<float>> uniforms_vec3;
@@ -394,10 +414,15 @@ public:
        // except that it is more efficient if the last phase contains a compute shader.
        // Thus, prefer this to render_to_fbo() where possible.
        //
-       // The format must currently be GL_RGBA16F, and only one destination
-       // texture is supported. Both of these restrictions will be lifted in the future.
+       // Only one destination texture is supported. This restriction will be lifted
+       // in the future.
+       //
+       // All destination textures must be exactly of size <width> x <height>,
+       // and must either come from the same ResourcePool the effect uses, or outlive
+       // the EffectChain (otherwise, we could be allocating FBOs that end up being
+       // stale). Textures must also have valid state; in particular, they must either
+       // be mipmap complete or have a non-mipmapped minification mode.
        //
-       // All destination textures must be exactly of size <width> x <height>.
        // width and height can not be zero.
        struct DestinationTexture {
                GLuint texnum;
@@ -481,11 +506,11 @@ private:
                    unsigned x, unsigned y, unsigned width, unsigned height);
 
        // Execute one phase, ie. set up all inputs, effects and outputs, and render the quad.
-       // If dest_texture is 0, uses whatever output is current (and the phase must not be
+       // If <destinations> is empty, uses whatever output is current (and the phase must not be
        // a compute shader).
        void execute_phase(Phase *phase,
                           const std::map<Phase *, GLuint> &output_textures,
-                          GLuint dest_texture,
+                          const std::vector<DestinationTexture> &destinations,
                           std::set<Phase *> *generated_mipmaps);
 
        // Set up uniforms for one phase. The program must already be bound.