---

sgluSphericalTransform.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************
 *     File: sgluSphericalTransform.hpp
 *  Created: 15 January 2001
 *  Summary: spherical behavior subclass (adding GLUT mouse functionality to
 *           sglSphericalTransform class
 *****************************************************************************/

#ifndef _SGLU_SPHERICAL_TRANSFORM_HPP
#define _SGLU_SPHERICAL_TRANSFORM_HPP

#include <sgl.h>
#include <sgluMouse.hpp>
#include <sglSphericalTransform.hpp>

template <class T>
class SGLU_DLL_API sgluSphericalTransform : public sglSphericalTransform<T>
{
public:
   sgluSphericalTransform()
         : sglSphericalTransform<T>(),
           m_first_time(true),
           m_last_button(0x0),
           m_last_pos(0,0),
           m_delta(0,0),
           m_trans_scale(1.0),
           m_rot_scale(1.0)
        {
        }
   virtual ~sgluSphericalTransform() {}

   virtual void reset()
      {
         sglSphericalTransform<T>::reset();

         m_first_time = true;
         m_last_button = 0x0;
         m_last_pos.set(0,0);
         m_delta.set(0,0);
         m_trans_scale = (T)1.0;
         m_rot_scale = (T)1.0;
      }

   void setTranslationScale(T scale) {m_trans_scale = scale;}
   T getTranslationScale() const {return m_trans_scale;}

   void setRotationScale(T scale) {m_rot_scale = scale;}
   T getRotationScale() const {return m_rot_scale;}

   // update the matrix using the pointer device information.
   virtual void update(sgluMouse *mouse);

private:  // not implemented
   sgluSphericalTransform(const sgluSphericalTransform&);
   sgluSphericalTransform &operator=(const sgluSphericalTransform&);

protected:
   // for update
   bool         m_first_time;
   int          m_last_button;
   sglVec2<int> m_last_pos;
   sglVec2<int> m_delta;
   T            m_trans_scale;
   T            m_rot_scale;
};

//----------------------------------------------------------------------------

template <class T>
void sgluSphericalTransform<T>::update(sgluMouse *mouse)
{
   if (mouse->in_window_flag)
   {
      if (mouse->button_flags & (sgluMouse::eLEFT_DOWN|
                                 sgluMouse::eMIDDLE_DOWN|
                                 sgluMouse::eRIGHT_DOWN))
      {
         if (m_first_time)
         {
            m_last_pos.set(mouse->xwin, mouse->ywin);
            m_first_time = false;
         }

         m_delta[0] = mouse->xwin - m_last_pos[0];
         m_delta[1] = mouse->ywin - m_last_pos[1];

         m_last_button = mouse->button_flags;
      }

      m_last_pos.set(mouse->xwin, mouse->ywin);
   }

   // change viewpoint if delta is non-zero
   if (m_delta.dot(m_delta) > 0.0)
   {
      if (m_last_button & sgluMouse::eLEFT_DOWN)
      {
         // mouse x position controls azimuth
         // mouse y position controls elevation
         updateAzimuth(-m_delta[0]*(M_PI/360.0)*m_rot_scale);
         updateElevation(-m_delta[1]*(M_PI/360.0)*m_rot_scale);
      }

      if (m_last_button & sgluMouse::eMIDDLE_DOWN)
      {
         m_delta_pos[0] = -m_trans_scale*m_delta[0];
         m_delta_pos[1] =  m_trans_scale*m_delta[1];
      }

      if (m_last_button & sgluMouse::eRIGHT_DOWN)
      {
         updateRadius(-m_trans_scale*m_delta[1]);
      }

      computeMatrix();
   }
}

#endif

---