SWFMatrix.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 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 <ostream> 
#include <boost/cstdint.hpp>

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


namespace gnash {

class DSOEXPORT SWFMatrix
{
public:

    boost::int32_t sx; 

    boost::int32_t shx;

    boost::int32_t shy;

    boost::int32_t sy; 

    boost::int32_t tx; 

    boost::int32_t ty; 
             
    SWFMatrix()
        :
        sx(65536),
        shx(0),
        shy(0),
        sy(65536),
        tx(0),
        ty(0)
    {}

    SWFMatrix(int a, int b, int c, int d, int x, int y)
        :
        sx(a),
        shx(b),
        shy(c),
        sy(d),
        tx(x),
        ty(y)
    {}

    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;
    }

private: 

    boost::int64_t  determinant() const;

}; //end of SWFMatrix

SWFMatrix readSWFMatrix(SWFStream& in);

inline bool
operator==(const SWFMatrix& a, const SWFMatrix& b)
{
    return  
        a.sx  == b.sx  &&
        a.shx == b.shx &&
        a.tx  == b.tx  &&
        a.sy  == b.sy  &&
        a.shy == b.shy &&
        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:
//