sceneorbiter.inl

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep 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 2 of the License, or
    (at your option) any later version.

    Sheep 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 Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

inline
SceneOrbiter::SceneOrbiter(const Point3 &center,
                           Real azimuth,
                           Real elevation,
                           Real distance) :
    m_is_dragging(false)
{
    Configure(center, azimuth, elevation, distance);
}

inline
void SceneOrbiter::Configure(const Point3 &center,
                             Real azimuth,
                             Real elevation,
                             Real distance)
{
    assert(!m_is_dragging);

    m_center = center;
    m_azimuth = NormalizeAngle(azimuth);
    m_elevation = NormalizeAngle(elevation);
    m_distance = distance;
}

inline
void SceneOrbiter::BeginDrag(Movement m, const Vector2 &p) {
    assert(!m_is_dragging);

    m_old_center = m_center;
    m_old_azimuth = m_azimuth;
    m_old_elevation = m_elevation;
    m_old_distance = m_distance;

    m_movement = m;
    m_old_point = p;

#ifdef REVERSE_AZIMUTH
    if(m_movement == Movement::TUMBLE) {
        m_reverse_azimuth = (fabs(m_elevation) > PI / 2.0);
    }
#endif  // REVERSE_AZIMUTH

    m_is_dragging = true;
}

inline
void SceneOrbiter::UpdateDrag(const Vector2 &p) {
    assert(m_is_dragging);

    const Vector2 delta = p - m_old_point;

    m_old_point = p;

    switch(m_movement) {
    case Movement::TUMBLE:
        tumble(delta);
        break;
    case Movement::TRACK:
        track(delta);
        break;
    case Movement::DOLLY:
        dolly(delta);
        break;
    }
}

inline
void SceneOrbiter::EndDrag() {
    assert(m_is_dragging);
    m_is_dragging = false;
}

inline
void SceneOrbiter::CancelDrag() {
    assert(m_is_dragging);

    m_center = m_old_center;
    m_azimuth = m_old_azimuth;
    m_elevation = m_old_elevation;
    m_distance = m_old_distance;

    m_is_dragging = false;
}

inline
bool SceneOrbiter::IsTumbling() const {
    return
        m_is_dragging &&
        m_movement == Movement::TUMBLE;
}

inline
bool SceneOrbiter::IsTracking() const {
    return
        m_is_dragging &&
        m_movement == Movement::TRACK;
}

inline
bool SceneOrbiter::IsDollying() const {
    return
        m_is_dragging &&
        m_movement == Movement::DOLLY;
}

inline
bool SceneOrbiter::IsDragging() const {
    return m_is_dragging;
}

inline
void SceneOrbiter::SetCenter(const Point3 &center) {
    m_center = center;
}

inline
const Point3 &SceneOrbiter::GetCenter() const {
    return m_center;
}

inline
Point3 SceneOrbiter::GetEyePosition() const {
    Point3 eye = m_center;

    eye.m_x += m_distance * cos(m_elevation) * cos(m_azimuth);
    eye.m_y += m_distance * sin(m_elevation);
    eye.m_z += m_distance * cos(m_elevation) * sin(m_azimuth);

    return eye;
}

inline
Real SceneOrbiter::GetAzimuth() const {
    return m_azimuth;
}

inline
Real SceneOrbiter::GetElevation() const {
    return m_elevation;
}

inline
Real SceneOrbiter::GetDistance() const {
    return m_distance;
}

---