control.cpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    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 Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "renderstack/control.hpp"
#include "renderstack/frame.hpp"

namespace renderstack {

void control::update()
{
    if(
        ((m_options & bit_active ) == bit_active) &&
        ((m_options & bit_inhibit) == 0         )
    )
    {
        adjust(m_current_delta);
    }
    dampen();
}

void control::adjust(float delta)
{
    m_current_value += delta;

    if(m_current_value > m_max_value)
    {
        m_current_value = m_max_value;
    }
    else if(m_current_value < m_min_value)
    {
        m_current_value = m_min_value;
    }
}

void control::dampen()
{
    if(
        (m_options & bit_dampen_multiply) == bit_dampen_multiply
    )
    {
        float old_value = m_current_value;
        m_current_value = m_current_value * m_damp;
        if(m_current_value == old_value)
        {
            m_current_value = 0;
        }
    }
    else if(
        ((m_options & bit_dampen_linear) == bit_dampen_linear) &&
        ((m_options & bit_active       ) == 0                )
    )

    {
        if(m_current_value > m_max_delta)
        {
            m_current_value -= m_max_delta;
            if(m_current_value < m_max_delta)
            {
                m_current_value = 0;
            }
        }
        else if(m_current_value < -m_max_delta)
        {
            m_current_value += m_max_delta;
            if(m_current_value > -m_max_delta)
            {
                m_current_value = 0;
            }
        }
        else
        {
            m_current_value *= m_damp;
        }
    }
}

void control::more(bool apply)
{
    if(apply)
    {
        m_options       |= bit_more | bit_active;
        m_current_delta  = m_max_delta;
    }
    else
    {
        m_options &= ~bit_more;
        if(
            (m_options & bit_less) == bit_less
        )
        {
            m_current_delta = -m_max_delta;
        }
        else
        {
            m_options       &= ~bit_active;
            m_current_delta  = 0;
        }
    }
}

void control::less(bool apply)
{
    if(apply)
    {
        m_options       |= bit_less | bit_active;
        m_current_delta  = -m_max_delta;
    }
    else
    {
        m_options &= ~bit_less;
        if(
            (m_options & bit_more) == bit_more)
        {
            m_current_delta = m_max_delta;
        }
        else
        {
            m_options       &= ~bit_active;
            m_current_delta  = 0;
        }
    }
}

void control::inhibit(bool apply)
{
    if(apply)
    {
        m_options |= bit_inhibit;
    }
    else
    {
        m_options &= ~bit_inhibit;
    }
}

void control::stop(bool apply)
{
    if(apply)
    {
        m_options |= bit_stop;
        if(m_current_value > 0)
        {
            m_current_delta = -m_max_delta;
        }
        else if(m_current_value < 0)
        {
            m_current_delta = m_max_delta;
        }
    }
    else
    {
        m_options &= ~bit_stop;
        if(
            ((m_options & bit_less) == bit_less) &&
            ((m_options & bit_more) == 0       )
        )
        {
            m_current_delta = -m_max_delta;
        }
        else if(
            ((m_options & bit_less) == 0       ) &&
            ((m_options & bit_more) == bit_more)
        )
        {
            m_current_delta = m_max_delta;
        }
    }
}

control::control()
{
    clear();
}

void control::clear()
{
    m_damp           =  0.950f;
    m_max_delta      =  0.004f;
    m_max_value      =  1.000f;
    m_min_value      = -1.000f;
    m_current_delta  = 0;
    m_current_value  = 0;
    m_options       &= ~bitmask_clear;
    m_options       |=  bit_dampen_multiply;
}


frame_controls::frame_controls(frame &slave_frame)
:   m_frame(slave_frame)
{
    m_translate_x.clear();
    m_translate_y.clear();
    m_translate_z.clear();
    m_rotate_x.clear();
    m_rotate_y.clear();
    m_rotate_z.clear();

    m_rotate_x.set_damp     (0.900f);
    m_rotate_y.set_damp     (0.900f);
    m_rotate_y.set_max_delta(0.002f);
    m_rotate_z.set_damp     (0.900f);
    m_rotate_z.set_max_delta(0.001f);

    m_translate_x.set_damp     (0.9700f);
    m_translate_y.set_damp     (0.9700f);
    m_translate_z.set_damp     (0.9700f);
    m_translate_x.set_max_delta(0.0040f);
    m_translate_y.set_max_delta(0.0040f);
    m_translate_z.set_max_delta(0.0040f);

    m_rotation = quaternion(m_frame.local_to_world());

    m_position_in_world = m_frame.position_in_world();
}


void frame_controls::fixed_update()
{
    float       rotation_delta;
    float       half_angle_sin;
    float       half_angle_cos;
    quaternion  rotq;
    vec3        axis;

    m_translate_x.update();
    m_translate_y.update();
    m_translate_z.update();
    m_rotate_x.update();
    m_rotate_y.update();
    m_rotate_z.update();

    if(m_translate_x.current_value() != 0.0f)
    {
        float value = m_translate_x.current_value();

        axis = m_rotation.right_axis();
        m_position_in_world += axis * value;
    }

    if(m_translate_z.current_value() != 0.0f)
    {
        float value = m_translate_z.current_value();

        axis = m_rotation.view_axis();
        m_position_in_world += axis * value;
    }

    if(m_translate_y.current_value() != 0.0f)
    {
        float value = m_translate_y.current_value();

        axis = m_rotation.up_axis();
        m_position_in_world += axis * value;
    }

    if(m_rotate_y.current_value() != 0.0f)
    {
        rotation_delta = radian_mod_2pi(m_rotate_y.current_value());

        half_angle_sin = sinf(rotation_delta);
        half_angle_cos = cosf(rotation_delta);

        axis = m_rotation.up_axis();
        rotq = quaternion(axis, half_angle_sin, half_angle_cos);
        m_rotation = rotq * m_rotation;
        m_rotation = normalize(m_rotation);
    }

    if(m_rotate_x.current_value() != 0.0f)
    {
        rotation_delta = radian_mod_2pi(m_rotate_x.current_value());

        half_angle_sin = sinf(rotation_delta);
        half_angle_cos = cosf(rotation_delta);

        axis = m_rotation.right_axis();
        rotq = quaternion(axis, half_angle_sin, half_angle_cos);
        m_rotation = rotq * m_rotation;
        m_rotation = normalize(m_rotation);
    }

    if(m_rotate_z.current_value() != 0.0f)
    {
        rotation_delta = radian_mod_2pi(m_rotate_z.current_value());

        half_angle_sin = sinf(rotation_delta);
        half_angle_cos = cosf(rotation_delta);

        axis = m_rotation.view_axis();
        rotq = quaternion(axis, half_angle_sin, half_angle_cos);
        //m_rotation *= rotq;
        m_rotation = rotq * m_rotation;
        m_rotation = normalize(m_rotation);
    }
}

void frame_controls::once_per_frame_update()
{
    make_matrix_quaternion_xyz(
        m_frame.local_to_world(),
        m_frame.world_to_local(),
        m_rotation,
        m_position_in_world
    );
}

}