single_tweener.cpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful

  CLAW is a free library without any particular aim but being useful to 
  anyone.

  Copyright (C) 2005-2011 Julien Jorge

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  contact: julien.jorge@gamned.org
*/
#include <claw/tween/single_tweener.hpp>

#include <algorithm>
#include <boost/bind.hpp>

static void local_swap( double& a, double& b )
{
  const double t(a);
  a = b;
  b = t;
} // local_swap()

#ifndef CLAW_TWEENER_DEFINE_BOOST_THROW_EXCEPTION

#ifndef WORKAROUND_BOOST_THROW_EXCEPTION
#define WORKAROUND_BOOST_THROW_EXCEPTION

#include "boost/throw_exception.hpp"

namespace boost {

  void throw_exception( std::exception const& exc ) {
    // nothing
  } // throw_exception()

} // namespace boost

#endif // WORKAROUND_BOOST_THROW_EXCEPTION
#endif // ifdef CLAW_TWEENER_DEFINE_BOOST_THROW_EXCEPTION

/*----------------------------------------------------------------------------*/
claw::tween::single_tweener::single_tweener()
  : m_date(0), m_easing( easing_none::ease_in_out )
{

} // single_tweener::single_tweener()

/*----------------------------------------------------------------------------*/
claw::tween::single_tweener::single_tweener
( double init, double end, double duration, update_function callback,
  easing_function e )
  : m_init(init), m_end(end), m_date(0), m_duration(duration),
    m_callback(callback), m_easing(e)
{

} // single_tweener::single_tweener()

/*----------------------------------------------------------------------------*/
claw::tween::single_tweener::single_tweener
( double& val, double end, double duration, easing_function e )
  : m_init(val), m_end(end), m_date(0), m_duration(duration), m_easing(e)
{
  m_callback = boost::bind( &local_swap, boost::ref(val), _1 );
} // single_tweener::single_tweener()

/*----------------------------------------------------------------------------*/
void claw::tween::single_tweener::set_init( double v )
{
  m_init = v;
} // single_tweener::set_init()

/*----------------------------------------------------------------------------*/
void claw::tween::single_tweener::set_end( double v )
{
  m_end = v;
} // single_tweener::set_end()

/*----------------------------------------------------------------------------*/
void claw::tween::single_tweener::set_duration( double v )
{
  m_duration = v;
} // single_tweener::set_duration()

/*----------------------------------------------------------------------------*/
void claw::tween::single_tweener::set_callback( update_function f )
{
  m_callback = f;
} // single_tweener::set_callback()

/*----------------------------------------------------------------------------*/
void claw::tween::single_tweener::set_easing( easing_function f )
{
  m_easing = f;
} // single_tweener::set_easing()

/*----------------------------------------------------------------------------*/
claw::tween::single_tweener* claw::tween::single_tweener::do_clone() const
{
  return new single_tweener(*this);
} // single_tweener::do_clone()

/*----------------------------------------------------------------------------*/
bool claw::tween::single_tweener::do_is_finished() const
{
  return m_date >= m_duration;
} // single_tweener::do_is_finished()

/*----------------------------------------------------------------------------*/
double claw::tween::single_tweener::do_update( double dt )
{
  const double t( std::min(m_duration - m_date, dt) );
  const double result = dt - t;
  m_date += t;

  const double coeff = m_easing( m_date / m_duration );
  const double val = m_init + coeff * (m_end - m_init);

  m_callback(val);

  return result;
} // single_tweener::do_update()