modifier.h

Go to the documentation of this file.

#ifndef UGDK_GRAPHIC_MODIFIER_H_
#define UGDK_GRAPHIC_MODIFIER_H_

#include <vector>
#include <cstddef>
#include <ugdk/math/vector2D.h>
#include <ugdk/base/types.h>

namespace ugdk {
namespace graphic {

class Modifier {
  public:
    enum Flags {
        NOTHING                 =  0,
        HAS_TRANSFORMATION      =  1,
        HAS_COLOR               =  2,
        TRUNCATES_WHEN_APPLIED  = 16
    };

    Modifier();


    Modifier(const Vector2D& _offset, const Vector2D _scale = Vector2D(1.0, 1.0),
             double _rotation = 0.0, Mirror _mirror = MIRROR_NONE, const Color _color = WHITE, bool _visible = true) :
        
        offset_(_offset), scale_(_scale), rotation_(_rotation), mirror_(_mirror), 
        color_(_color), visible_(_visible), flags_(HAS_TRANSFORMATION | HAS_COLOR) {}

    // Destructor
    ~Modifier() {}

    // Getters.
    const Vector2D& offset()    const { return   offset_; }
    const Vector2D& scale()     const { return    scale_; }
    double          rotation()  const { return rotation_; }
    const Mirror&   mirror()    const { return   mirror_; }
    const Color&    color()     const { return    color_; }
    uint16          flags()     const { return    flags_; }
    bool            visible()   const { return  visible_; }

    // Setters.
    void set_offset(const Vector2D& _offset) { offset_ = _offset; flags_ |= HAS_TRANSFORMATION; }
    void set_scale(const Vector2D& _scale)   { scale_  = _scale;  flags_ |= HAS_TRANSFORMATION; }
    void set_rotation(const double rotation);
    void set_mirror(const Mirror mirror);
    void set_color(const Color& color);
    void set_visible(const bool _visible) { visible_ = _visible; }
    void ComposeOffset(const Vector2D& _offset) { offset_  += _offset;  flags_ |= HAS_TRANSFORMATION;}
    void ComposeScale(const Vector2D& _scale)   { scale_.x *= _scale.x;
                                                  scale_.y *= _scale.y; 
                                                  flags_ |= HAS_TRANSFORMATION; }

    void ToggleFlag(uint16 flag) { flags_ ^= flag; }
    void ComposeRotation(const double rotation);
    void ComposeMirror(const Mirror& mirror);
    void ComposeColor(const Color& color);
    void ComposeVisible(bool _visible) { visible_ = visible_ && _visible; }
    
    void ComposeOffset(   const Modifier* mod2 ) { if(mod2 == NULL) return; ComposeOffset(   mod2->offset_   ); }
    void ComposeScale(    const Modifier* mod2 ) { if(mod2 == NULL) return; ComposeScale(    mod2->scale_    ); }
    void ComposeRotation( const Modifier* mod2 ) { if(mod2 == NULL) return; ComposeRotation( mod2->rotation_ ); }
    void ComposeMirror(   const Modifier* mod2 ) { if(mod2 == NULL) return; ComposeMirror(   mod2->mirror_   ); }
    void ComposeColor(    const Modifier* mod2 ) { if(mod2 == NULL) return; ComposeColor(    mod2->color_    ); }
    void ComposeVisible(  const Modifier* mod2 ) { if(mod2 == NULL) return; ComposeVisible(  mod2->visible_  ); }

    void Compose(const Modifier* mod2);
    static Modifier* Compose(const Modifier* mod1, const Modifier* mod2);

    static Modifier* Copy(const Modifier* mod2);

  private:
    // Attributes
    Vector2D        offset_,
                    scale_;
    double          rotation_;
    Mirror          mirror_;
    Color           color_; //TODO: Modifier's "color_" is actually a light filter.
    bool            visible_;
    uint16          flags_;
};

}  // namespace graphic
}  // namespace ugdk

#endif /* UGDK_GRAPHIC_MODIFIER_H_ */