FixedManipulator.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// 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.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#ifndef INPUT_FIXED_MANIPULATOR_H
#define INPUT_FIXED_MANIPULATOR_H

#include <osgGA/MatrixManipulator>
#include <PVLE/Util/Util.h>
#include <math.h>


class FixedManipulator : public osgGA::MatrixManipulator {
public:
    FixedManipulator() : Dir(-1,-.2,-1), EyePos(50,100,50), Up(0,1,0) {
        Dir.normalize();
        Up.normalize();

        _homeCenter = EyePos;
        _homeEye = EyePos + Dir;
        _homeUp = Up;
    }

    FixedManipulator(const osg::Vec3 & EyePos, const osg::Vec3 & Dir, const osg::Vec3 & Up) { setByFrame(EyePos, Dir, Up); }
    FixedManipulator(const osg::Matrix & matrix) { setByMatrix(matrix); }

    void setByFrame(const osg::Vec3 & EyePos, const osg::Vec3 & Dir, const osg::Vec3 & Up) {
        this->EyePos = EyePos;
        this->Dir = Dir;
        this->Up = Up;

        this->Dir.normalize();
        this->Up.normalize();
        switchLeftRightFrame();
    }

    virtual void setByMatrix(const osg::Matrix & matrix) {
        osg::Vec3 Center;
        matrix.getLookAt(EyePos, Center, Up, 1);
        Dir = Center - EyePos;
        Dir.normalize();
        Up.normalize();

        switchLeftRightFrame();
    }

    virtual void setByInverseMatrix(const osg::Matrix & matrix) {
        setByMatrix(osg::Matrix::inverse(matrix));
    }

    // Returns an OpenGL (Right-hand, Y up) matrix
    virtual osg::Matrix getMatrix() const { return osg::Matrix::inverse(getInverseMatrix()); }

    virtual osg::Matrix getInverseMatrix() const {
        // Going from left to right-handed (Invert Y and Z)
        osg::Vec3 e = EyePos, c = EyePos + Dir, u = Up;
        std::swap(e._v[1], e._v[2]);
        std::swap(c._v[1], c._v[2]);
        std::swap(u._v[1], u._v[2]);
        return osg::Matrix::lookAt(e, c, u);
/*
        // I don't know why, but :
        osg::Vec3 e = EyePos, c = EyePos + Dir, u = Up;
        osg::Matrix m = osg::Matrix::rotate(osg::PI_2, osg::Vec3(1,0,0));
        return osg::Matrix::lookAt(-e*m, -c*m, u*m);

        // ... seems equivalent to :
        return osg::Matrix::lookAt(-EyePos, -EyePos - Dir, Up);
*/
    }

protected:
    osg::Vec3 EyePos, Dir, Up;          

    void switchLeftRightFrame() {
        std::swap(EyePos._v[1], EyePos._v[2]);
        std::swap(Dir._v[1], Dir._v[2]);
        std::swap(Up._v[1], Up._v[2]);
    }
};


#endif  // INPUT_FIXED_MANIPULATOR_H

---