control.hpp

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
*/

#ifndef CONTROL_HPP
#define CONTROL_HPP

#include "renderstack/rs.h"
#include "renderstack/quaternion.hpp"

namespace renderstack {

class frame;

class control
{
protected:
    static const int bit_more            =   1;
    static const int bit_less            =   2;
    static const int bit_stop            =   4;
    static const int bit_active          =   8;
    static const int bit_inhibit         =  16;
    static const int bit_dampen_linear   =  32;
    static const int bit_dampen_multiply =  64;
    static const int bit_dampen_master   = 128; 
    static const int bitmask_clear       = bit_more | bit_less | bit_stop | bit_active | bit_inhibit;

public:
    control();

    void clear  ();
    void update ();
    void adjust (float delta);
    void dampen ();
    void more   (bool apply);
    void less   (bool apply);
    void stop   (bool apply);
    void inhibit(bool apply);

    void set_max_delta  (float max_delta){ m_max_delta = max_delta; }
    void set_damp       (float damp){ m_damp = damp; }

    float current_delta() const { return m_current_delta; }
    float current_value() const { return m_current_value; }

private:
    int     m_options;
    float   m_damp;
    float   m_max_delta;
    float   m_max_value;
    float   m_min_value;
    float   m_current_delta;
    float   m_current_value;
};

class frame_controls
{
public:
    frame_controls(frame &slave_frame);

private:
    frame_controls(frame_controls const &other);
    frame_controls &operator=(frame_controls const &);

public:
    control &rotate_x() { return m_rotate_x; }
    control &rotate_y() { return m_rotate_y; }
    control &rotate_z() { return m_rotate_z; }
    control &translate_x() { return m_translate_x; }
    control &translate_y() { return m_translate_y; }
    control &translate_z() { return m_translate_z; }

    void fixed_update();
    void once_per_frame_update();

private:
    frame       &m_frame;
    control     m_rotate_x;
    control     m_rotate_y;
    control     m_rotate_z;
    control     m_translate_x;
    control     m_translate_y;
    control     m_translate_z;
    quaternion  m_rotation;
    vec3        m_position_in_world;
};

}

#endif