SWFMatrix.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

// 
//
// Original author: Thatcher Ulrich <tu@tulrich.com> 2003
//
//

#ifndef GNASH_MATRIX_H
#define GNASH_MATRIX_H

#include "dsodefs.h" // for DSOEXPORT

#include <iosfwd> 
#include <boost/cstdint.hpp>

// Forward declarations
namespace gnash {
    class SWFRect;
    namespace geometry {
        class Point2d;
        template<typename T> class Range2d;
    }
}


namespace gnash {

class DSOEXPORT SWFMatrix
{
public:

    SWFMatrix()
        :
        _a(65536),
        _b(0),
        _c(0),
        _d(65536),
        _tx(0),
        _ty(0)
    {}

    SWFMatrix(int a, int b, int c, int d, int x, int y)
        :
        _a(a),
        _b(b),
        _c(c),
        _d(d),
        _tx(x),
        _ty(y)
    {}

    boost::int32_t a() const {
        return _a;
    }

    boost::int32_t b() const {
        return _b;
    }

    boost::int32_t c() const {
        return _c;
    }

    boost::int32_t d() const {
        return _d;
    }

    boost::int32_t tx() const {
        return _tx;
    }

    boost::int32_t ty() const {
        return _ty;
    }

    void set_identity();

    //
    void concatenate(const SWFMatrix& m);

    //
    void concatenate_translation(int _tx, int _ty);

    //
    void concatenate_scale(double x, double y);

    void set_lerp(const SWFMatrix& m1, const SWFMatrix& m2, float t);

    void set_scale_rotation(double x_scale, double y_scale, double rotation);

    void set_scale(double x_scale, double y_scale);

    void set_x_scale(double scale);

    void set_y_scale(double scale);

    void set_rotation(double rotation);

    void set_x_translation(int x) {
        _tx = x;
    }

    void set_y_translation(int y) {
        _ty = y;
    }

    void set_translation(int x, int y) {
        _tx = x;
        _ty = y;
    }

    void transform(geometry::Point2d& p) const;

    void transform(boost::int32_t& x, boost::int32_t& y) const;
    
    //
    void transform(geometry::Point2d* result, const geometry::Point2d& p) const;

    //
    void transform(geometry::Range2d<boost::int32_t>& r) const;

    void transform(SWFRect& r) const;
    
    SWFMatrix& invert();
    
    double get_x_scale() const;

    double get_y_scale() const;

    double get_rotation() const;

    int get_x_translation() const {
        return _tx;
    }

    int get_y_translation() const {
        return _ty;
    }

    friend bool operator==(const SWFMatrix& a, const SWFMatrix& b);

private: 

    boost::int64_t  determinant() const;

    boost::int32_t _a; 

    boost::int32_t _b;

    boost::int32_t _c;

    boost::int32_t _d; 

    boost::int32_t _tx; 

    boost::int32_t _ty; 
             

}; //end of SWFMatrix

inline bool
operator==(const SWFMatrix& a, const SWFMatrix& b)
{
    return  
        a.a()  == b._a  &&
        a._b == b._b &&
        a._tx  == b._tx  &&
        a._d  == b._d  &&
        a._c == b._c &&
        a._ty  == b._ty;
}

std::ostream& operator<<(std::ostream& o, const SWFMatrix& m);

} // namespace gnash

#endif 


// Local Variables:
// mode: C++
// indent-tabs-mode: t
// End:
//