PlaneSensor.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API 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.
//
//    H3D API 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 H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __PLANESENSOR_H__
#define __PLANESENSOR_H__
 
#include <H3D/X3DDragSensorNode.h>
#include <H3D/SFVec2f.h>
#include <H3D/SFRotation.h>
 
namespace H3D {
 
  // NOTE: If the scenegraph is changed while isActive is true for a 
  // planeSensor the planeSensor might not be working correctly anymore.
  class H3DAPI_API PlaneSensor : 
    public X3DDragSensorNode {
  public:
 
    class H3DAPI_API SFOffset :
      public OnValueChangeSField< AutoUpdate< SFVec3f > > {
    public:
    protected:
      virtual void onValueChange( const Vec3f &/*_new_value*/ ) {
        PlaneSensor * ps = static_cast< PlaneSensor * >(getOwner());
        ps->last_offset_axis_rotation_inv =
          Matrix4f( ps->axisRotation->getValue() ).inverse();
      }
    };
 
    PlaneSensor(  Inst< SFBool >  _autoOffset           = 0,
                  Inst< SFString > _description         = 0,
                  Inst< SFBool >  _enabled              = 0,
                  Inst< SFVec2f > _maxPosition          = 0,
                  Inst< SFNode >  _metadata             = 0,
                  Inst< SFVec2f > _minPosition          = 0,
                  Inst< SFOffset > _offset               = 0,
                  Inst< SFBool >  _isActive             = 0,
                  Inst< SFBool > _isOver                = 0,
                  Inst< SFVec3f >  _trackPoint_changed  = 0,
                  Inst< SFVec3f >  _translation_changed = 0,
                  Inst< SFRotation > _axisRotation      = 0 );
 
    // fields
    H3DUniquePtr< SFVec2f > maxPosition;
 
    H3DUniquePtr< SFVec2f > minPosition;
 
    H3DUniquePtr< SFOffset > offset;
 
    H3DUniquePtr< SFVec3f > translation_changed;
 
    H3DUniquePtr< SFRotation > axisRotation;
 
    static H3DNodeDatabase database;
 
  protected:
    // Virtual function that should check the isActive field and if it
    // is true then update specific fields. If isActive field is false then
    // reset state of internal variables. Do not call enabled->getValue() in
    // this function.
    // _enabled - Should be treated as enabled->getValue().
    // from - The start of the line segment for which to intersect with.
    // to - The end of the line segment for which to intersect with.
    virtual void setDragOutputEvents( bool _enabled,
                                      const Vec3f &from,
                                      const Vec3f &to );
 
    // Called to generate isOver events and other events which dependens on
    // isOver.
    virtual void onIsOver( NodeIntersectResult *result = 0, unsigned int closest_index = 0,
                           Matrix4f *global_to_local = 0 );    
    
    // Stores points of intersection with any of the geometry which causes this
    // sensor to generate isOver events.
    Vec3f geometry_intersection;
 
    // Stores global_to_local matrix of the geometry which causes this
    // sensor to generate isOver events.
    Matrix4f geometry_global_to_local;
 
    // intersection between the segment from a to b and the plane defined
    // by planeD and planeNormal (see below). Results are stored in
    // t and q.
    int intersectLinePlane( Vec3f a, Vec3f b, float &t, Vec3f &q );
 
    // Last intersection point with the cylinder. Only used when sensor is
    // active.
    Vec3f last_intersection;
 
    // Normal of the plane to intersect with.
    Vec3f plane_normal;
    // A number used for plane equation and intersections.
    H3DFloat plane_d;
    // The transformation from global to local of the geometry for which this
    // sensor is active. It will not change while sensor is active.
    Matrix4f active_global_to_local_matrix;
    // If true a new plane will be defined.
    bool new_plane;
    // The last rotation used when offset was set.
    Matrix4f last_offset_axis_rotation_inv;
  };
}
 
#endif