transform3d.h

Go to the documentation of this file.

/*
 *  OGF/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000 Bruno Levy
 *
 *  This program 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.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy
 *
 *     levy@loria.fr
 *
 *     ISA Project
 *     LORIA, INRIA Lorraine,
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs.
 */
 
 
#ifndef H_OGF_SCENE_GRAPH_GFX_TRANSFORMS_TRANSFORM3D_H
#define H_OGF_SCENE_GRAPH_GFX_TRANSFORMS_TRANSFORM3D_H
 
#include <OGF/scene_graph_gfx/common/common.h>
#include <OGF/gom/types/node.h>
#include <OGF/basic/math/geometry.h>
 
namespace OGF {
 
//_________________________________________________________
 
 
    gom_class SCENE_GRAPH_GFX_API Transform3d : public Object {
    public:
        Transform3d();
 
         ~Transform3d() override;
 
 
    gom_properties:
        const vec3& get_look_at() const {
            return look_at_;
        }
 
        void set_look_at(const vec3& value) {
            look_at_ = value;
            update_matrix();
        }
        void set_look_at(const vec3& value) {…}
 
        const vec3& get_u() const {
            return u_;
        }
        const vec3& get_u() const  {…}
 
        void set_u(const vec3& value) {
            u_ = value;
            update_matrix();
        }
        void set_u(const vec3& value) {…}
 
        const vec3& get_v() const {
            return v_;
        }
        const vec3& get_v() const  {…}
 
        void set_v(const vec3& value) {
            v_ = value;
            update_matrix();
        }
        void set_v(const vec3& value) {…}
 
        const vec3& get_w() const {
            return w_;
        }
        const vec3& get_w() const  {…}
 
        void set_w(const vec3& value) {
            w_ = value;
            update_matrix();
        }
        void set_w(const vec3& value) {…}
 
        double get_delta_location() const {
            return delta_location_;
        }
        double get_delta_location() const  {…}
 
        void set_delta_location(double value) {
            delta_location_ = value;
        }
        void set_delta_location(double value) {…}
 
        double get_delta_angle() const {
            return delta_angle_;
        }
        double get_delta_angle() const  {…}
 
        void set_delta_angle(double value) {
            delta_angle_ = value;
        }
        void set_delta_angle(double value) {…}
 
        double get_zoom() const {
            return zoom_;
        }
        double get_zoom() const  {…}
 
        void set_zoom(double value) {
            zoom_ = value ;
            update_matrix() ;
        }
        void set_zoom(double value) {…}
 
        double get_delta_zoom() const {
            return delta_zoom_;
        }
        double get_delta_zoom() const  {…}
 
        void set_delta_zoom(double value) {
            delta_zoom_ = value;
        }
        void set_delta_zoom(double value) {…}
 
        const mat4& get_matrix() const {
            return matrix_;
        }
        const mat4& get_matrix() const  {…}
 
        void set_matrix(const mat4& value) {
            matrix_ = value;
        }
        void set_matrix(const mat4& value) {…}
 
        const mat4& get_rotation_matrix() const ;
 
        void set_rotation_matrix(const mat4& value) ;
 
        const vec3& get_default_look_at() const {
            return default_look_at_;
        }
        const vec3& get_default_look_at() const  {…}
 
        void set_default_look_at(const vec3& value) {
            default_look_at_ = value;
        }
        void set_default_look_at(const vec3& value) {…}
 
        const vec3& get_default_u() const {
            return default_u_;
        }
        const vec3& get_default_u() const  {…}
 
        void set_default_u(const vec3& value) {
            default_u_ = value;
        }
        void set_default_u(const vec3& value) {…}
 
        const vec3& get_default_v() const {
            return default_v_;
        }
        const vec3& get_default_v() const  {…}
 
        void set_default_v(const vec3& value) {
            default_v_ = value;
        }
        void set_default_v(const vec3& value) {…}
 
        const vec3& get_default_w() const {
            return default_w_;
        }
        const vec3& get_default_w() const  {…}
 
        void set_default_w(const vec3& value) {
            default_w_ = value;
        }
        void set_default_w(const vec3& value) {…}
 
        double get_default_zoom() const {
            return default_zoom_;
        }
        double get_default_zoom() const  {…}
 
        void set_default_zoom(double value) {
            default_zoom_ = value;
        }
        void set_default_zoom(double value) {…}
 
     gom_slots:
        void reset() ;
 
        void move_left(double value = 1.0) ;
 
        void move_right(double value = 1.0) ;
 
        void move_up(double value = 1.0) ;
 
        void move_down(double value = 1.0) ;
 
        void move_forward(double value = 1.0) ;
 
        void move_backward(double value = 1.0) ;
 
        void turn_left(double value = 1.0) ;
 
        void turn_right(double value = 1.0) ;
 
        void tilt_up(double value = 1.0) ;
 
        void tilt_down(double value = 1.0) ;
 
        void tilt_left(double value = 1.0) ;
 
        void tilt_right(double value = 1.0) ;
 
        void translate(const vec3& value) ;
 
        void rotate(const mat4& value) ;
 
        void zoom_in(double value = 1.0) ;
 
        void zoom_out(double value = 1.0) ;
 
        void zoom_mult(double value = 1.0) ;
 
    gom_signals:
        void value_changed(const mat4& value) ;
 
        void rotation_changed(const mat4& value) ;
 
    protected:
        void update_matrix(bool send_signal = true) ;
 
    private:
        vec3 look_at_ ;
        vec3 u_ ;
        vec3 v_ ;
        vec3 w_ ;
 
        vec3 default_look_at_ ;
        vec3 default_u_ ;
        vec3 default_v_ ;
        vec3 default_w_ ;
        double default_zoom_ ;
 
        double delta_location_ ;
        double delta_angle_ ;
        double zoom_ ;
        double delta_zoom_ ;
        mat4 matrix_ ;
    } ;
    gom_class SCENE_GRAPH_GFX_API Transform3d : public Object {…};
 
//_________________________________________________________
 
}
#endif