Source/Contrib/Rhino3DLoader/OSGrhino2osb.h

   1 /*---------------------------------------------------------------------------*\
   2  *                        OpenSG openNURBS SceneFileType                     *
   3  *                                                                           *
   4  *                                                                           *
   5  * Copyright (C) 2007-2008 by Seac02 S.r.l.     http://www.seac02.it         *
   6  * Copyright (C) 2008  by Patrik Mueller    muellerptr@users.sourceforge.net *
   7  * Copyright (C) 2008  by Akos Balazs       edhellon@cs.uni-bonn.de          *
   8  *                                                                           *
   9 \*---------------------------------------------------------------------------*/
  10 /*---------------------------------------------------------------------------*\
  11  *                                License                                    *
  12  *                                                                           *
  13  * This library is free software; you can redistribute it and/or modify it   *
  14  * under the terms of the GNU Library General Public License as published    *
  15  * by the Free Software Foundation, version 2.                               *
  16  *                                                                           *
  17  * This library is distributed in the hope that it will be useful, but       *
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  20  * Library General Public License for more details.                          *
  21  *                                                                           *
  22  * You should have received a copy of the GNU Library General Public         *
  23  * License along with this library; if not, write to the Free Software       *
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  25  *                                                                           *
  26 \*---------------------------------------------------------------------------*/
  27 /*
  28 // Some portions are based on example_gl.h in the openNURBS distribution:
  29 //
  30 // Copyright (c) 1993-2007 Robert McNeel & Associates. All rights reserved.
  31 // Rhinoceros is a registered trademark of Robert McNeel & Assoicates.
  32 //
  33 // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
  34 // ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
  35 // MERCHANTABILITY ARE HEREBY DISCLAIMED.
  36 //
  37 // For complete openNURBS copyright information see <http://www.opennurbs.org>.
  38 //
  39 ////////////////////////////////////////////////////////////////
  40 */
  41
  42 #ifndef RHINO2OSB_H_
  43 #define RHINO2OSB_H_
  44
  45 #if __GNUC__ >= 4 || __GNUC_MINOR__ >=3
  46 #pragma GCC diagnostic warning "-Wold-style-cast"
  47 #pragma GCC diagnostic warning "-Wignored-qualifiers"
  48 #endif
  49
  50 #include <string>
  51 #include <map>
  52
  53 #include <opennurbs/opennurbs.h>
  54 #include <OSGNode.h>
  55 #include <OSGSimpleMaterial.h>
  56 #include <OSGSurface.h>
  57
  58 class rhino2osb
  59 {
  60   public:
  61
  62     rhino2osb(int   curveInterpolationSteps = 100,
  63               float tessError               = 0.1f,
  64               bool  doTessellation          = true,
  65               bool  importRenderMeshes      = false);
  66
  67     virtual ~rhino2osb(void);
  68
  69     OSG::NodeTransitPtr load(const OSG::Char8 *fileName);
  70
  71   protected:
  72
  73     void                doTess      (      OSG::Node *node);
  74
  75     OSG::NodeTransitPtr process_brep(const ON_Brep   &);
  76
  77     // optional transformation applied to curve
  78     OSG::NodeTransitPtr process_curve(const ON_Curve &,
  79                                             double[][4] = NULL);
  80
  81     OSG::NodeTransitPtr process_surface( const ON_Surface& );
  82
  83     OSG::NodeTransitPtr process_trimcurve( // low level NURBS curve render
  84             int,                // dim
  85             int,                // is_rat
  86             int,                // cv_count
  87             int,                // order
  88       const double *,           // knot_vector[]
  89             int,                // cv_stride
  90       const double *,           // cv
  91             int         = 1,    // bPermitKnotScaling - If TRUE, curve knots
  92                                 // maybe rescaled to avoid knot vectors GL
  93                                 // cannot handle.
  94             double *    = NULL, // knot_scale[2] - If not NULL and
  95                                 // bPermitKnotScaling, the scaling applied to
  96                                 // the knot vector is returned here.
  97             double[][4] = NULL // optional transformation applied to curve
  98                                          );
  99
 100     OSG::NodeTransitPtr process_NURBS_surface(
 101         const ON_NurbsSurface &,
 102               int               = 1,       // bPermitKnotScaling - If TRUE,
 103                                            // surface knots may be rescaled to
 104                                            // avoid knot vectors GL cannot
 105                                            // handle.
 106         double                * = NULL,    // knot_scale0[2] - If not NULL and
 107                                            // bPermitKnotScaling, the scaleing
 108                                            // applied to the first parameter
 109                                            // is returned here.
 110         double                * = NULL     // knot_scale0[2] - If not NULL and
 111                                            // bPermitKnotScaling, the scaleing
 112                                            // applied to the second parameter
 113                                            // is returned here.
 114                                              );
 115
 116     OSG::NodeTransitPtr process_brepface(const ON_BrepFace &);
 117
 118     OSG::NodeTransitPtr convert_knots(
 119           const int,             // order, ON_NurbsCurve... order
 120           const int,             // cv_count, ON_NurbsCurve... cv count
 121           const double  *,       // knot, ON_NurbsCurve... knot vector
 122                 GLfloat *,       // glknot[] - GL knot vector
 123                 int       = 0,   // bPermitScaling - TRUE if re-scaling is
 124                                  // allowed
 125                 double  * = NULL // scale[2] - If not NULL and bPermitScaling is
 126                                  // TRUE, then the scaling parameters are
 127                                  // returned here.
 128                                  // ( glknot = (knot = scale[0])*scale[1] )
 129                                      );
 130
 131     void process_material                     (const ONX_Model        &model,
 132                                                      int               index );
 133
 134
 135     OSG::NodeTransitPtr buildNode             (const ONX_Model        &model,
 136                                                      int               index );
 137     OSG::NodeTransitPtr convert_surface_to_osg(const ON_NurbsSurface  &s,
 138                                                      GLfloat          *sknot,
 139                                                      GLfloat          *tknot );
 140     OSG::NodeTransitPtr process_point         (const ON_Point         *theGeo);
 141     OSG::NodeTransitPtr process_pointcloud    (const ON_PointCloud    *theGeo);
 142     OSG::NodeTransitPtr process_pointgrid     (const ON_PointGrid     *theGeo);
 143     OSG::NodeTransitPtr process_points        (const ON_Geometry      *theGeo);
 144     OSG::NodeTransitPtr process_curve         (const ON_Geometry      *theGeo);
 145     OSG::NodeTransitPtr process_nurbscurve    (const ON_NurbsCurve    *theGeo);
 146     OSG::NodeTransitPtr process_linecurve     (const ON_LineCurve     *theGeo);
 147     OSG::NodeTransitPtr process_polylinecurve (const ON_PolylineCurve *theGeo);
 148     OSG::NodeTransitPtr process_mesh          (const ON_Mesh          *theGeo);
 149
 150
 151     // member variables
 152     OSG::NodeUnrecPtr           m_pRootNode;
 153     OSG::SimpleMaterialUnrecPtr m_actMaterial;
 154     OSG::SurfaceUnrecPtr        m_cCurrentSurface;
 155     bool                        m_bNewTrimLoop;
 156
 157     // member variables that influence the loading/conversion
 158     int   m_curveInterpolationSteps;
 159     float m_tessellationError;
 160     bool  m_bDoTessellation;
 161     bool  m_bImportRenderMeshes;
 162
 163     std::map<int, OSG::SimpleMaterialUnrecPtr> m_materials;
 164 };
 165 #endif // RHINO2OSB_H_