hdicoreTransformMatrix.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_TRANSFORM_MATRIX__
#define __HDI_CORE_TRANSFORM_MATRIX__
 
#include <memory>
 
namespace hdi
{
    #if defined(HDI_CORE_AIP_MODE)
        namespace aip
        {
            class TransformMatrix;
        }
    #elif defined(HDI_CORE_PSP_MODE)
        namespace geo
        {
            class TransformMatrix;
        }
    #endif
 
    namespace core
    {
        class Angle;
    
        class TransformMatrix
        {
            public:
                double a;
 
                double b;
 
                double c;
 
                double d;
 
                double tx;
 
                double ty;
 
                TransformMatrix();
 
                TransformMatrix(
                    const double a_,
                    const double b_,
                    const double c_,
                    const double d_,
                    const double tx_,
                    const double ty_
                );
 
                TransformMatrix(const TransformMatrix& m_);
 
                virtual ~TransformMatrix();
 
                virtual void setIdentity();
 
                virtual bool isIdentity() const;
 
                virtual void setTranslate(const double tx_, const double ty_);
 
                virtual void setRotate(const Angle& angle_);
 
                virtual void setReflect(const Angle& angle_);
 
                virtual void setScale(const double sx_, const double sy_);
 
                virtual void concatTranslate(const double tx_, const double ty_);
 
                virtual void concatRotate(const Angle& angle_);
 
                virtual void concatReflect(const Angle& angle_);
 
                virtual void concatScale(const double sx_, const double sy_);
 
                virtual void concat(const TransformMatrix& matrix2_);
 
                virtual double determinant() const;
 
                virtual bool degenerate() const;
 
                virtual bool invert(TransformMatrix& inverse__) const;
 
                virtual bool operator==(const TransformMatrix& rhs_) const;
 
                virtual bool operator!=(const TransformMatrix& rhs_) const;
 
                virtual TransformMatrix& operator=(const TransformMatrix& rhs_);
 
                virtual TransformMatrix operator*(const TransformMatrix& rhs_) const;
 
                virtual TransformMatrix& operator*=(const TransformMatrix& rhs_);
 
 
            private:
                #if defined(HDI_CORE_AIP_MODE)
                    friend aip::TransformMatrix* __accessImpl(const TransformMatrix&);
                    friend TransformMatrix __accessCtor(const aip::TransformMatrix&);
 
                    aip::TransformMatrix* __impl;
 
                    TransformMatrix(const aip::TransformMatrix&);
                #elif defined(HDI_CORE_PSP_MODE)
                    friend geo::TransformMatrix* __accessImpl(const TransformMatrix&);
                    friend TransformMatrix __accessCtor(const geo::TransformMatrix&);
 
                    geo::TransformMatrix* __impl;
 
                    TransformMatrix(const geo::TransformMatrix&);
                #endif
        };
        
        typedef std::unique_ptr<TransformMatrix> TransformMatrixUP;
        typedef std::shared_ptr<TransformMatrix> TransformMatrixSP;
        typedef std::weak_ptr<TransformMatrix> TransformMatrixWP;
    
        #if defined(HDI_CORE_AIP_MODE)
            extern aip::TransformMatrix* __accessImpl(const TransformMatrix&);
            extern TransformMatrix __accessCtor(const aip::TransformMatrix&);
        #elif defined(HDI_CORE_PSP_MODE)
            extern geo::TransformMatrix* __accessImpl(const TransformMatrix&);
            extern TransformMatrix __accessCtor(const geo::TransformMatrix&);
        #endif
    }
}
 
#endif
// __HDI_CORE_TRANSFORM_MATRIX__