SoNormalGenerator.h

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Thad Beier (MMM yyyy)
** Modified by : Paul S. Strauss (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2014 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
 
#ifndef  _SO_NORMAL_GENERATOR_
#define  _SO_NORMAL_GENERATOR_
 
#include <Inventor/SbLinear.h>
#include <Inventor/elements/SoNeighborToleranceElement.h>
 
 
#include <Inventor/STL/vector>
#include <Inventor/STL/utility>
 
{
 
 public:
 
   SoNormalGenerator(
     const SbBool isCCW,
     const int approxNumVertices=16,
     const int approxNumFaces=6,
     const float creaseAngle =0.0f,
     const float toleranceFactor = SoNeighborToleranceElement::getDefault()
     );
 
   ~SoNormalGenerator();
 
   void setupApproxShapeSize(const int32_t approxNumVertices,const int32_t approxNumFaces);
 
   void beginPolygon();
   void polygonVertex(const SbVec3f &point);
   void endPolygon();
 
   void triangle(const SbVec3f &p1,const SbVec3f &p2,const SbVec3f &p3);
 
   void setupIndexedVertexArray(const SbVec3f* pointArray);
 
   void setupIndexedConnectivity(const int32_t* connectivityArray);
 
   void polygonVertex(const int32_t pointIndex);
 
   void triangle(const int32_t index1,const int32_t index2,const int32_t index3);
 
   void generate();
 
   int getNumNormals() const   { return numVertNormals; }
 
   void setNumNormals(int newNum);
 
   const SbVec3f *getNormals() const
  { return vertNormals; }
 
   const SbVec3f & getNormal(int32_t i) const
  { return vertNormals[i]; }
 
   void setNormal(int32_t index, const SbVec3f &newNormal);
 
   int32_t numNormalCrack() const
  {return m_numNormalCrack; };
 
private:
  /*
   * Some shapes may need to adjust or reorder all normals after
   * generation. This method can be used to change all normal in one 
   * shot without any copy. 
   */
   void setNormalBuffer(int32_t numNormals, const SbVec3f *normals);
 
   bool isIndexedMode() const
  {return m_isIndexedMode; }
 
private: 
  void endPolygon_( int32_t numVertices );
 
  inline void addPolygonNormal( const SbVec3f &vec1, const SbVec3f &vec2 )
  {  polygonSum += (vec1).cross(vec2); }
 
 private:
  // Arrays of vertex points, face normals, and vertex normals. The
  // face normals are stored one per vertex. The other vars are the
  // number of items in the arrays, and the allocated sizes of the
  // arrays. Since the points and faceNormals arrays are always the
  // same size, no need for extra variables.
  // Depending on setupIndexedVertexArray call or not, data are used 
  // from points or pointsIndex array.
  SbVec3f             *points, *faceNormals, *vertNormals;
  int32_t             *pointIndexes;
  int32_t             numPoints, numVertNormals;
  int32_t             maxPoints, maxFaceNormals, maxVertNormals;
  SbVec3f             polygonSum;
 
  // Flag: if TRUE, polygons are oriented counter-clockwise
  SbBool              m_isCCW;
  float               m_creaseAngle;
  float               m_toleranceFactor;
 
  int32_t             m_approxNumVertices;
  int32_t             m_approxNumFaces;
  int32_t             m_faceIndex;
  int32_t             m_pointIndex;
 
  // Index into points array where current polygon started
  int32_t             beginPolygonIndex;
  SbBox3f               m_bbox;
 
  // 
  int                 m_numNormalCrack;
  bool                m_isIndexedMode;
  int32_t             *m_userConnectivity;
 
  // grow point or pointsIndexes array depending on current number of point.
  void growPointsArray(const int requestedMaxPoints);
  // grow current facenormals array .
  void growNormalFaceArray(const int requestedNormalFaceArraySize);
 
 
  inline bool needToComputeConnectivity( ) const
  { return (( m_creaseAngle != 0.0f ) && ( m_userConnectivity == NULL )); }
 
  // compute a double link list of points that are connected.
  // the resulting array has numPoints size
  // the caller is responsible to release the array allocated by this method
  int32_t* computeConnectivity( std::vector < std::pair< int, size_t > > &indicesClasses );
 
  // determine point equivalence class length
  void evalConnectedVerticesIndicesClasses( int32_t* indirect, size_t numPoints,  
                                            std::vector < std::pair< int, size_t > > &indicesClasses ) const;
 
  // Returns TRUE if the two points are the same within given tolerance
  static SbBool equal(const SbVec3f &a, const SbVec3f &b, const float tol);
 
  static SbBool s_useOldTolerance;
};
 
#endif /* _SO_NORMAL_GENERATOR_ */