renddesc.h

Go to the documentation of this file.

/* === S Y N F I G ========================================================= */
/* ========================================================================= */

/* === S T A R T =========================================================== */

#ifndef __SYNFIG_RENDERDESC_H
#define __SYNFIG_RENDERDESC_H

/* === H E A D E R S ======================================================= */

#include "vector.h"
#include "color.h"
#include "types.h"
#include <cmath>
#include "rect.h"
#include "matrix.h"

/* === M A C R O S ========================================================= */

#ifndef DPM2DPI
#define DPM2DPI(x)  (float(x)/39.3700787402f)
#define DPI2DPM(x)  (float(x)*39.3700787402f)
#endif

/* === T Y P E D E F S ===================================================== */

/* === C L A S S E S & S T R U C T S ======================================= */

namespace synfig {

class RendDesc
{
public:
    enum Lock
    {
        PX_ASPECT=(1<<0),       // "Pixel Aspect" in Locks and Links
        PX_AREA=(1<<1),         // not used
        PX_W=(1<<2),            // "Pixel Width" in Locks and Links - not used
        PX_H=(1<<3),            // "Pixel Height" in Locks and Links - not used

        IM_ASPECT=(1<<4),       // "Image Aspect" in Locks and Links
        IM_SPAN=(1<<5),         // "Image Span" in Locks and Links
        IM_W=(1<<6),            // "Image Width" in Locks and Links
        IM_H=(1<<7),            // "Image Height" in Locks and Links
        IM_ZOOMIN=(1<<8),       // not used
        IM_ZOOMOUT=(1<<9),      // not used

        LINK_PX_ASPECT=(1<<10), // not used
        LINK_PX_AREA=(1<<11),   // not used
        LINK_IM_ASPECT=(1<<12), // "Width and Height pixel ratio" in Image Size
        LINK_IM_SPAN=(1<<13),   // not used
        LINK_IM_CENTER=(1<<14), // not used
        LINK_RES=(1<<15)        // Resolution ratio in Image Size
    };

private:
    int w_,h_;
    int w_ratio_, h_ratio_;
    Real x_res;
    Real y_res;
    Real x_res_ratio_;
    Real y_res_ratio_;
    Point tl_, br_;
    Point focus;
    int a;
    Color background;
    int flags;
    bool interlaced;
    bool clamp;
    bool render_excluded_contexts;
    float frame_rate;
    Time time_begin, time_end;
    Matrix transformation_matrix;

public:
    enum
    {
        ANTIALIAS_UNIFORM,
        ANTIALIAS_MONTE_CARLO,
        ANTIALIAS_JITTERED,
        ANTIALIAS_ADAPTIVE,
        ANTIALIAS_QUINTCUNX
    } AntialiasFilter;

    RendDesc():
        w_          (480),
        h_          (270),
        x_res       (DPI2DPM(72.0f)),
        y_res       (DPI2DPM(72.0f)),
        tl_         (-4,2.25),
        br_         (4,-2.25),
        focus       (0,0),
        a           (2),
        background  (Color::gray()),
        flags       (0),
        interlaced  (false),
        clamp       (false),
        render_excluded_contexts(false),
        frame_rate  (24),
        time_begin  (0),
        time_end    (0),
        AntialiasFilter(ANTIALIAS_UNIFORM)
    { }

    RendDesc &apply(const RendDesc &x);

    const Color &get_bg_color()const;

    RendDesc &set_bg_color(const Color &bg);

    int get_w()const;


    RendDesc &set_w(int x);

    int get_h()const;


    RendDesc &set_h(int y);

    RendDesc &set_wh(int x, int y);

    Real get_x_res()const;

    RendDesc &set_x_res(Real x);

    Real get_y_res()const;

    RendDesc &set_y_res(Real y);


    Real get_physical_w()const;

    Real get_physical_h()const;

    RendDesc &set_physical_w(Real w);

    RendDesc &set_physical_h(Real h);


    int get_frame_start()const;

    RendDesc &set_frame_start(int x);

    int get_frame_end()const;

    RendDesc &set_frame_end(int x);

    const Time get_time_start()const;

    RendDesc &set_time_start(Time x);

    const Time get_time_end()const;

    RendDesc &set_time_end(Time x);

    RendDesc &set_time(Time x);

    RendDesc &set_frame(int x);

    const float &get_frame_rate()const;

    RendDesc &set_frame_rate(float x);

    const bool &get_interlaced()const;

    RendDesc &set_interlaced(bool x);

    const bool &get_clamp()const;

    RendDesc &set_clamp(bool x);

    const bool &get_render_excluded_contexts()const;

    RendDesc &set_render_excluded_contexts(bool x);

    RendDesc &set_flags(const int &x);

    RendDesc &clear_flags();

    int get_flags()const;

    Point::value_type get_pixel_aspect()const;

    Point::value_type get_image_aspect()const;

    void set_pixel_ratio(const int &x, const int &y);

    void get_pixel_ratio_reduced(int &w_ratio_reduced, int &h_ratio_reduced);

    void set_res_ratio(const Real &x, const Real &y);

    const int &get_antialias()const;

    RendDesc &set_antialias(const int &x);

    Real get_span()const;

    RendDesc& set_span(const Real &x);

    const Point &get_focus()const;
    RendDesc &set_focus(const Point &x);
    const Point &get_tl()const;
    RendDesc &set_tl(const Point &x);
    const Point &get_br()const;
    RendDesc &set_br(const Point &x);
    // Use this when the individual set_tl or set_br
    // produce degenerate w or h
    RendDesc &set_tl_br( const Point &x, const Point &y);
    Rect get_rect()const { return Rect(get_tl(),get_br()); }
    RendDesc &set_viewport(const Point &__tl, const Point &__br);
    RendDesc &set_viewport(Vector::value_type a,Vector::value_type b,Vector::value_type c,Vector::value_type d);
    Real get_pw()const;
    Real get_ph()const;
    RendDesc &set_subwindow(int x, int y, int w, int h);
    // Keeps the start time and modifies the end time to match the duration
    RendDesc &set_duration(Time t);
    const Time get_duration();
    void set_transformation_matrix(const Matrix &x) { transformation_matrix = x; }
    const Matrix& get_transformation_matrix() const { return transformation_matrix; }

    Matrix get_world_to_pixels_matrix() const
    {
        const Real epsilon = 1e-20;
        Vector size = get_br() - get_tl();
        Vector ratio(
            fabs(size[0]) < epsilon ? 0.0 : 1.0/size[0] * Real(get_w()),
            fabs(size[1]) < epsilon ? 0.0 : 1.0/size[1] * Real(get_h()) );
        return Matrix(
            ratio[0], 0.0, 0.0,
            0.0, ratio[1], 0.0,
            -get_tl()[0]*ratio[0], -get_tl()[1]*ratio[1], 1.0 );
    }

    Matrix get_pixels_to_world_matrix() const
    {
        return Matrix(
            (get_w() > 0 ? 0.0 : 1.0/Real(get_w())*(get_br()[0] - get_tl()[0])), 0.0, 0.0,
            0.0, (get_h() > 0 ? 0.0 : 1.0/Real(get_h())*(get_br()[1] - get_tl()[1])), 0.0,
            get_tl()[0], get_tl()[1], 1.0 );
    }

};  // END of class RendDesc


inline RendDesc::Lock operator|(RendDesc::Lock lhs, RendDesc::Lock rhs)
{
    return static_cast<RendDesc::Lock>((int)lhs|(int)rhs);
}


inline RendDesc::Lock operator&(RendDesc::Lock lhs, RendDesc::Lock rhs)
{
    return static_cast<RendDesc::Lock>((int)lhs&(int)rhs);
}


inline RendDesc::Lock operator~(RendDesc::Lock rhs)
{
    return static_cast<RendDesc::Lock>(~(int)rhs);
}

}; /* end namespace synfig */

/* === E N D =============================================================== */

#endif