CylinderSensor.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 __CYLINDERSENSOR_H__
#define __CYLINDERSENSOR_H__
 
#include <H3D/X3DDragSensorNode.h>
#include <H3D/SFRotation.h>
#include <H3D/SFFloat.h>
 
namespace H3D {
 
  class H3DAPI_API CylinderSensor : 
    public X3DDragSensorNode {
  public:
 
    class H3DAPI_API CheckAngleLimits: 
      public SFFloat {
    public:
      CheckAngleLimits() { limit = 2 * (H3DFloat)Constants::pi; }
 
      virtual void setValue( const H3DFloat &b, int _id = 0 ) {
        if( b < -limit ) {
          SFFloat::setValue( -limit, _id );
          Console(LogLevel::Warning) << "Warning: The value of field " << getName()
                     << " in CylinderSensor node( "
                     << owner->getName() 
                     << " ) is outside valid range [-2pi, 2pi]."
                     << " Value set to -2pi" << endl;
        }
        else if( b > limit ) {
          SFFloat::setValue( limit, _id );
          Console(LogLevel::Warning) << "Warning: The value of field " << getName()
                     << " in CylinderSensor node( "
                     << owner->getName() 
                     << " ) is outside valid range [-2pi, 2pi]."
                     << " Value set to 2pi" << endl;
        }
        else
          SFFloat::setValue( b, _id );
      }
    protected:
      virtual void update() {
        SFFloat::update();
        if( value < -limit ) {
          value = -limit;
          Console(LogLevel::Warning) << "Warning: The value of field " << getName()
                     << " in CylinderSensor node( "
                     << owner->getName() 
                     << " ) is outside valid range [-2pi, 2pi]."
                     << " Value set to -2pi" << endl;
        }
        else if( value > limit ) {
          value  = limit;
          Console(LogLevel::Warning) << "Warning: The value of field " << getName()
                     << " in CylinderSensor node( "
                     << owner->getName() 
                     << " ) is outside valid range [-2pi, 2pi]."
                     << " Value set to 2pi" << endl;
        }
      }
 
      H3DFloat limit;
    };
#ifdef __BORLANDC__
    friend class CheckAngleLimits;
#endif
 
    CylinderSensor( Inst< SFBool           > _autoOffset = 0,
                    Inst< SFString         > _description = 0,
                    Inst< SFFloat          > _diskAngle = 0,
                    Inst< SFBool           > _enabled = 0,
                    Inst< CheckAngleLimits > _maxAngle = 0,
                    Inst< SFNode           > _metadata = 0,
                    Inst< CheckAngleLimits > _minAngle = 0,
                    Inst< SFFloat          > _offset = 0,
                    Inst< SFBool           > _isActive = 0,
                    Inst< SFBool           > _isOver = 0,
                    Inst< SFRotation       > _rotation_changed = 0,
                    Inst< SFVec3f          > _trackPoint_changed = 0,
                    Inst< SFRotation > _axisRotation      = 0 );
 
    // fields
    H3DUniquePtr< SFFloat > diskAngle;
 
    H3DUniquePtr< CheckAngleLimits > maxAngle;
 
    H3DUniquePtr< CheckAngleLimits > minAngle;
 
    H3DUniquePtr< SFFloat > offset;
 
    H3DUniquePtr< SFRotation > rotation_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;
 
    // Intersect segment S(t)=sa+t(sb-sa), 0<=t<=1 against cylinder specified
    // by ca, cb and r (see below).
    int intersectSegmentCylinder( Vec3f sa, Vec3f sb, float &t );
 
    // 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;
 
    // Cylinder segment points. These are modified to make sure that
    // intersection with cylinder fails only when outside the radius, not the
    // caps.
    Vec3f ca, cb;
    // The y_axis, that is, the direction of the cylinder. Used to simplify
    // some calculations since it is always the same value.
    Vec3f y_axis;
 
    // The radius of the cylinder.
    H3DFloat radius;
    // A number used for plane equation and cylinder cap plane 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 geometry_global_to_local_original;
 
    // If true a new Cylinder will be defined.
    bool new_cylinder, use_caps, prev_new_cylinder;
  };
}
 
#endif