Extrusion.h

Go to the documentation of this file.

//    Copyright 2004, 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 __EXTRUSION_H__
#define __EXTRUSION_H__

#include "X3DGeometryNode.h"
#include "SFInt32.h"
#include "SFFloat.h"
#include "MFRotation.h"
#include "MFVec2f.h"

namespace H3D {

  class H3DAPI_API Extrusion : public X3DGeometryNode {
        protected:
                
                template <typename T>
                inline bool coinc(T a , T b) 
                                        { return H3DAbs( ( a - b ).lengthSqr()) < Constants::f_epsilon; }
                
                inline Vec3f calculateNormal( const vector < Vec3f > &vertex_vector,
                                                                                                                                        H3DInt32 right,
                                                                                                                                        H3DInt32 middle,
                                                                                                                                        H3DInt32 left) {
                        return ( vertex_vector[ right ] - vertex_vector[ middle ] ).crossProduct(
                                                         vertex_vector[ left ] - vertex_vector[ middle ] ); }

                vector< H3DInt32 > findSurroundingFaces( 
                                                                                                H3DInt32 i,
                                                                                                H3DInt32 j,
                                                                                                bool closedSpine,
                                                                                                H3DInt32 nrOfSpinePoints,
                                                                                                bool closedCrossSection,
                                                                                                H3DInt32 nrOfCrossSectionPoints);

                void generateNormalsPerVertex( 
                      vector < Vec3f > &normalVector,
                                                                                        const vector < Vec3f > &vertex_vector,
                                                                                        const vector < Vec2f > &cross_section,
                                                                                        vector < Vec3f > &yAxis,
                                                                                        bool ccwcheck,
                                                                                        H3DInt32 nrOfCrossSectionPoints,
                                                                                        H3DInt32 nrOfSpinePoints,
                                                                                        bool closedSpine,
                                                                                        H3DFloat crease_angle,
                                                                                        H3DInt32 &ifCapsAdd );
                
    void generateNormalsPerVertex( 
                      vector < Vec3f > &normalVector,
                                                                                        const vector < Vec3f > &vertex_vector,
                                                                                        const vector < Vec2f > &cross_section,
                                                                                        vector < Vec3f > &yAxis,
                                                                                        bool ccwcheck,
                                                                                        H3DInt32 nrOfCrossSectionPoints,
                                                                                        H3DInt32 nrOfSpinePoints,
                                                                                        bool closedSpine,
                                                                                        H3DInt32 &ifCapsAdd );

                vector< Vec3f > generateNormalsPerFace(  
                                                                                        const vector < Vec3f > &vertex_vector,
                                                                                        const vector < Vec2f > &cross_section,
                                                                                        vector < Vec3f > &yAxis,
                                                                                        bool ccwcheck,
                                                                                        H3DInt32 nrOfCrossSectionPoints,
                                                                                        H3DInt32 nrOfSpinePoints,
                                                                                        bool closedCrossSection,
                                                                                        H3DInt32 &ifCapsAdd );

  public:

    class H3DAPI_API SFBound: public TypedField< X3DGeometryNode::SFBound,
                                      Types< MFVec3f > >{
      virtual void update();
    };

    class H3DAPI_API VertexVectors: 
      public TypedField< MFVec3f,
                         Types< MFVec2f, 
                                MFRotation, 
                                MFVec2f, 
                                MFVec3f > > {
      virtual void update();
                };

    virtual void render();

#ifdef USE_HAPTICS
    virtual void traverseSG( TraverseInfo &ti );  
#endif

    Extrusion( Inst< SFNode           > _metadata        = 0,
               Inst< SFBound          > _bound           = 0,
               Inst< DisplayList      > _displayList     = 0,
               Inst< SFBool           > _beginCap                                = 0,
                                                         Inst< SFBool           > _ccw             = 0,
               Inst< SFBool           > _convex                                  = 0,
               Inst< SFFloat          > _creaseAngle     = 0,
               Inst< MFVec2f          > _crossSection    = 0,
               Inst< SFBool                                             > _endCap                = 0,
               Inst< MFRotation       > _orientation     = 0,
               Inst< MFVec2f          > _scale           = 0,
               Inst< SFBool           > _solid           = 0,
                                                         Inst< MFVec3f          > _spine           = 0,
                                                         Inst< VertexVectors    > _vertexVector    = 0 );

    auto_ptr< SFBool >  beginCap;

        
    auto_ptr< SFBool >  ccw;
    
    auto_ptr< SFBool >  convex;

    auto_ptr< SFFloat > creaseAngle;

    auto_ptr< MFVec2f >  crossSection;

    auto_ptr< SFBool >  endCap;

    auto_ptr< MFRotation >  orientation;

    auto_ptr< MFVec2f >  scale;

    auto_ptr< SFBool >  solid;

    auto_ptr< MFVec3f >  spine;

    auto_ptr< VertexVectors  >  vertexVector;

    static H3DNodeDatabase database;
  };
}

#endif

---