random_racer/src/ThirdPersonCameraHelper.cpp

Go to the documentation of this file.

#include <stdio.h>

#include <vrs/lookat.h>
#include <vrs/rotation.h>

#include <vrsode/CollisionBody.h>

#include <random_utils/Macros.h>

#include "ThirdPersonCameraHelper.h"

using namespace VRS;
using namespace vrsode;


namespace random_racer
{

ThirdPersonCameraHelper::ThirdPersonCameraHelper(
    SO<LookAt> p_lookAt, SO<CollisionBody> p_hook,
    const VRS::Vector& p_initialDirection,
    double p_distX, double p_distY, double p_correctY,
    bool p_staticY, double p_smoothing, unsigned int p_delay)
{
    m_lookAt        = p_lookAt;
    m_hook          = p_hook;
    m_distX         = p_distX;
    m_distY         = p_distY;
    m_correctY      = p_correctY;
    m_staticY       = p_staticY;
    m_delay         = p_delay;

    m_lastDirection = p_initialDirection;
    setSmoothing(p_smoothing);

    startTimer(m_delay);
}

void
ThirdPersonCameraHelper::setSmoothing(double p_smoothing)
{
    m_smoothing = random_utils::inRange(0.0, p_smoothing, 1.0);
}

ThirdPersonCameraHelper::~ThirdPersonCameraHelper()
{
}

void ThirdPersonCameraHelper::updateLookAt()
{
    Vector pos = m_hook->position(), v(m_distX, 0.0, 0.0);

    // look a bit over the car to see more of the sky and less of the ground
    pos[1] += m_correctY;

    // rotate a default vector with the rotation to get the direction of the car
    v = m_hook->rotation() * v;

    // correct the heigth component to be m_distY units above the car
    v[1] = (m_staticY) ? -m_distY : (v[1] - m_distY);

    // calulate a smooth look direction
    v = v*(1.0-m_smoothing) + m_lastDirection*m_smoothing;

    // remeber this direction for the next time
    m_lastDirection = v;

    // write the calculations to the LookAt
    m_lookAt->setTo(pos);
    m_lookAt->setFrom(pos - v);
}

void
ThirdPersonCameraHelper::setDelay(unsigned int p_msecs)
{
    m_delay = p_msecs;
    startTimer(p_msecs);
}

void
ThirdPersonCameraHelper::timerTick()
{
    updateLookAt();
}

} // namespace random_racer

---