HumanMatrixGetter.cpp

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.
//
//-----------------------------------------------------------------------------------

#include <PVLE/Input/HumanMatrixGetter.h>
#include <PVLE/Input/Control.h>
#include <PVLE/Util/Assert.h>
#include <math.h>

const osg::Vec3::value_type HumanMatrixGetter::AlphaMin = 0.008;


void HumanMatrixGetter::handleFrame(double elapsed) {
    ASSERT(pControler);

    // --- Events ---
    for(ControlEventList::const_iterator it = pControler->getEventBegin(), itEnd = pControler->getEventEnd(); it!=itEnd; ++it) {
        if (it->getType() == ControlEvent::SWITCH_DOWN) {
            if (it->getSwitchId() == ControlState::FASTER) MovingSpeed *= 2;
            else if (it->getSwitchId() == ControlState::SLOWER) MovingSpeed /= 2;
        }
    }

    // Nothing else to do but clear them
    pControler->clearEvents();


    // --- Switches ---
    ControlState & cs = pControler->getControlState();
    //compute right unitary vector
    osg::Vec3 SpeedVec, Right;
    Right = Dir ^ Up;
    Right.normalize();      // For precision problems

    if (cs[ControlState::FORWARD]) SpeedVec += Dir * MovingSpeed;
    else if (cs[ControlState::BACKWARD]) SpeedVec += Dir * -MovingSpeed;

    if (cs[ControlState::STRAFE_RIGHT]) SpeedVec += Right * MovingSpeed;
    else if (cs[ControlState::STRAFE_LEFT]) SpeedVec += Right * -MovingSpeed;

    if (cs[ControlState::UP] || cs[ControlState::JUMP]) SpeedVec += Up * MovingSpeed;
    else if (cs[ControlState::DOWN] || cs[ControlState::CROUCH]) SpeedVec += Up * -MovingSpeed;

    osg::Vec3::value_type Speed = SpeedVec.length();
    if (Speed > MovingSpeed) SpeedVec *= (MovingSpeed / Speed);         // Normalize speed (when doing FW + Strafe, for example)

    if (cs[ControlState::FAST_TOGGLE]) SpeedVec /= 25;

    // Update
    EyePos += SpeedVec * elapsed;


    // --- Axis ---
    Dir = Dir * yawPitchRoll(cs.getAxis(ControlState::AXIS_X) * elapsed, cs.getAxis(ControlState::AXIS_Y) * elapsed, 0);
    Dir.normalize();
}


osg::Matrix HumanMatrixGetter::yawPitchRoll(osg::Vec3::value_type yaw, osg::Vec3::value_type pitch, osg::Vec3::value_type roll) const {
    osg::Matrix Mx;

    // Yaw : Up axis
    // Bank / Roll : Dir axis

    // Pitch : Right axis
    if (pitch) {
        // Compute angle between Up and Dir
        ASSERT(Dir.length2() > 0.99 && Dir.length2() < 1.01 && Up.length2() > 0.99 && Up.length2() < 1.01);     // normalized +/- error ?
        osg::Vec3::value_type CosAlpha = Dir * Up;
        osg::Vec3::value_type Alpha = acos(CosAlpha);

        // Check that we're not out of limit
        if (Alpha < osg::PI_2 && pitch<0) {
            if ((Alpha + pitch) <= AlphaMin) {
                pitch = AlphaMin - Alpha;
                if (pitch>0) pitch = 0;
            }
        }
        if (Alpha > osg::PI_2 && pitch>0) {
            if ((Alpha + pitch) >= (osg::PI - AlphaMin)) {
                pitch = (osg::PI - AlphaMin) - Alpha;
                if (pitch<0) pitch = 0;
            }
        }
    }

    // Compute Right axis
    osg::Vec3 Right = Dir ^ Up;
    Right.normalize();              // For precision problems

    // Note that Matrix::rotate uses a left handed frame (I think... :P) 
    return osg::Matrix::rotate(
        -yaw, Up,
        -pitch, Right,
        -roll, Dir
    );
}

---