Inventor/nodes/SoShape.h

Go to the documentation of this file.

/*=======================================================================
 * 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      : 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-2020 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/


#ifndef  _SO_SHAPE_
#define  _SO_SHAPE_

#include <Inventor/SbLinear.h>
#include <Inventor/SbMatrix.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/fields/SoSFBool.h>

#include <Inventor/sys/SoGLType.h>

class SoCube;
class SoDetail;
class SoFaceDetail;
class SoMaterialBundle;
class SoPickedPoint;
class SoPointDetail;
class SoPrimitiveVertex;
class SoState;
class SoMFInt32;
class SoMultiPassManagerOld ;
class GLUtesselator;

class SbBoxPartition;
class SbBoxPartitionIntersectionInfo;
class SoBBoxShapeCache;

typedef SoPrimitiveVertex *jySoPrimitiveVertexPtr;
typedef SoDetail *jySoDetailPtr;

//
//  Class: SoShape
//
//  Abstract base shape node class, which provides some convenience
//  functions for its subclasses.
//

class  SoShape : public SoNode {

  SO_NODE_ABSTRACT_HEADER(SoShape);

 public:
  SoSFBool boundingBoxIgnoring;

  virtual SbBool affectsState() const;

  enum ShapeType {
    POINTS,
    LINES,
    POLYGONS,
    TEXT
  };

  ShapeType getShapeType();

  static SbBool isPrimitiveRestartAvailable(SoState* state = NULL);

 private:

  enum TriangleShape {
    TRIANGLE_STRIP,
    TRIANGLE_FAN,
    TRIANGLES,
    POLYGON
  };

  void beginShape(SoAction *action, TriangleShape shapeType,
    SoFaceDetail *faceDetail = NULL);

  void shapeVertex(const SoPrimitiveVertex *v);

  void endShape();

 private:
  virtual void getBoundingBox(SoGetBoundingBoxAction *action);

  virtual void GLRender(SoGLRenderAction *action);

  virtual void rayPick(SoRayPickAction *action);

  virtual void callback(SoCallbackAction *action);

  static void getScreenSize(SoState *state, const SbBox3f &boundingBox, SbVec2s &rectSize);

  static float getDecimatedComplexity(SoState *state, float complexity);

  virtual void computeBBox(SoAction *action, SbBox3f &box, SbVec3f &center) = 0;

  virtual void computeBBox(SoAction *action, SbXfBox3d &box, SbVec3d &center)
  {
    // SubClass did not redefine this function so by default use AABB version
    SbBox3f boxf;
    SbVec3f centerf;
    computeBBox(action, boxf, centerf);

    box.setTransform(SbMatrixd::identity());
    box.makeEmpty();
    box.setBounds(SbVec3d(boxf.getMin().getValue()),SbVec3d(boxf.getMax().getValue()));
    center.setValue(centerf);
  }

  virtual void getPrimitiveCount(SoGetPrimitiveCountAction *action);

  static void setRasterPos( SbVec3f &pos, SoState *state );

  virtual SbMatrix3* computeVtxTangentSpaceMat(const float *, int &) const
    {return NULL ;}

  // Gets multi-texturing info:
  //    - Indicates if the multi-texturing is active
  //    - The list of texture units where texture coordinate should be sent (that is
  //       where texture coordinates differents from a function.)
  static SbBool getMultiTextureInfo(SoState *state, SbIntList &imageTextUnitList) ;
                                   
  void setShapeType(SoShape::ShapeType st);

  // These methods invoke whatever callbacks are registered with the
  // primitive generation procedures. If primitives are being
  // generated for picking or rendering purposes, the appropriate
  // SoShape methods are called. If primitives are being generated
  // for the SoCallbackAction, the callbacks registered with the
  // action are called.
  void invokeTriangleCallbacks(SoAction *action,
                               const SoPrimitiveVertex *v1,
                               const SoPrimitiveVertex *v2,
                               const SoPrimitiveVertex *v3);
  void invokeLineSegmentCallbacks(SoAction *action,
                                  const SoPrimitiveVertex *v1,
                                  const SoPrimitiveVertex *v2);
  void invokePointCallbacks(SoAction *action,
                            const SoPrimitiveVertex *v);

 private:
  static void initClass();
  static void exitClass();

  // redefined for Shapes
  virtual void GLRenderP(SoGLRenderAction *action);

  SB_THREAD_TLS_HEADER();

  inline virtual SbBool isBoundingBoxIgnoring() const
  { return boundingBoxIgnoring.getValue(); }

  // It is possible to disable projection for a given shape even if the element is set
  SbBool m_forceDisableProjection;

  void setForceDisableProjection( SbBool disable ){m_forceDisableProjection = disable;}

  SbBool getTTSA();
  // set Triangles Transparency Sorting Availability
  void setTTSA(SbBool enable);

  static bool isVertexArrayAvailable(SoState* state=NULL);
  static bool isMultiDrawArrayAvailable(SoState* state=NULL);
  static bool isVertexBufferAvailable(SoState* state=NULL);

  // Returns true if the caller should use Vertex array to render
  // according to some conditions like the number of vertices, SoPreference...
  static bool shouldUseVertexArray(SoState* state, size_t numVertices);

  // Do the correct operation on caching when the vertex arrays are used.
  static void setupCacheForVertexArray(SoState* state, size_t numVertices);

  // Returns 0 if not available, 1 if NV version, 2 if core
  static int getPrimitiveRestartMode(SoState* state = NULL);

  bool renderTransparentSortedTriangles( SoGLRenderAction* );

 private:

  // Constructor
  SoShape();

  virtual SbBool checkShapeHints(SoGLRenderAction *action,SbThreadAutoWriteLock *autolock=0);

  virtual void countPrim(){}

  virtual int getNumPrim(){return 0;}

  virtual SbBool checkTransparency(SoGLRenderAction *action, SbBool isPointsOrLines);

  virtual int getNumVert(){return getNumPrim();}

  virtual SbBool numPrimInvalid(){return FALSE;}

  virtual SbBool isRenderingPointsOrLines(SoGLRenderAction *action);

  virtual SbBool shouldRenderNow(SoGLRenderAction *action,SbBool &isPointsOrLines);

  //-------------------------------------------------------------------------------

  // This method MUST be defined by each subclass to generate
  // primitives (triangles, line segments, points) that represent
  // the shape.
  virtual void generatePrimitives(SoAction *action) = 0;

  // Returns TRUE if the shape should be rendered. Subclasses can
  // call this in their rendering methods to determine whether to
  // continue.  
  virtual SbBool shouldGLRender(SoGLRenderAction *action,
                                SbBool isPointsOrLines = FALSE);

  // Implementation of shouldGLRender to split the general case
  // to tessellationShader support case. shouldGLRender always
  // return false if tessellation shaders are on the state. This
  // method is called for every shape with no tessellation shaders on the
  // state and bufferedShape.
  SbBool shouldGLRenderCore(SoGLRenderAction *action,
                      SbBool isPointsOrLines = FALSE,
                      SbBool hasTessellationShader = FALSE);

  // Returns FALSE if the shape is invisible. If the complexity
  // is BOUNDING_BOX, it renders the cuboid and returns FALSE.
  // Otherwise returns TRUE.
  SbBool handleInvisibleOrBBox(SoGLRenderAction *action,
                                SbBool isPointsOrLines = FALSE);

  // Returns TRUE if the shape may be picked. Subclasses can call
  // this in their picking methods to determine whether to continue.
  SbBool shouldRayPick(SoRayPickAction *action);

  // Returns TRUE if the shape should be rendered. Subclasses can
  // call this in their rendering methods to determine whether to
  // continue. 
  SbBool shouldPrimitiveCount(SoGetPrimitiveCountAction *action);

  // rendering. They take care of setting up shape hints in the
  // state. Calls to these two methods should bracket the rendering
  // code.
  void beginSolidShape(SoGLRenderAction *action);
  void endSolidShape(SoGLRenderAction *action);

  // Computes a picking ray in the object space of the shape
  // instance. The picking ray is stored in the SoRayPickAction for
  // later access by the subclass. The second form takes a matrix to
  // concatenate with the current transformation matrix. It can be
  // used, for example, if a shape has sizing or positioning info
  // built into it.
  void computeObjectSpaceRay(SoRayPickAction *action);
  void computeObjectSpaceRay(SoRayPickAction *action,
                             const SbMatrix &matrix);

  // These methods are called during picking to create details
  // representing extra info about a pick intersection. The default
  // methods implemented in SoShape return NULL. Subclasses can
  // override these methods to set up specific detail instances that
  // contain the extra info. Subclasses can get whatever information
  // they need from the SoPickedPoint, and can set information in it
  // as well.
  virtual SoDetail *createTriangleDetail(SoRayPickAction *action,
                                         const SoPrimitiveVertex *v1,
                                         const SoPrimitiveVertex *v2,
                                         const SoPrimitiveVertex *v3,
                                         SoPickedPoint *pp);
  virtual SoDetail *createLineSegmentDetail(SoRayPickAction *action,
                                            const SoPrimitiveVertex *v1,
                                            const SoPrimitiveVertex *v2,
                                            SoPickedPoint *pp);
  virtual SoDetail *createPointDetail(SoRayPickAction *action,
                                      const SoPrimitiveVertex *v,
                                      SoPickedPoint *pp);
  
  // 
  // This endShape is used by SoIndexedFaceSet and SoFaceSet to create hole 
  // in a face.
  void endShape( int wt, SoMFInt32* indexes );

  virtual ~SoShape();
    
  // Applies GLRender action to the bounding box surrounding the shape.
  // This is used to render shapes when BOUNDING_BOX complexity is on.
  virtual void GLRenderBoundingBox(SoGLRenderAction *action);

  // Fill a matrix with the transformation from Modelling coordinate to tangent space 
  // (facet space).
  void fillOneVtxTangentSpaceMat(const SbVec3f &s, SbVec3f &normal, SbMatrix3 &tgtSpaceMat) const ;

  // Changes the GL_MULTISAMPLE_ARB OpenGL bit value. This method is used to filter the
  // antialiasing when traversing the shape. (See SoFullSceneAntialiasing for more).
  virtual void applyFullSceneAntialiasingFilter(SoState* state);

 private:
   // below are variables related to vertex arrays
   //typedef std::list< SoAction* > SoApplyingList;
   typedef SbPList SoApplyingList;
   struct MTstruct
   {
     unsigned int *vaIndices;
     float *vaVertex;
     float *vaNormal;
     float *vaTexture;
     unsigned char *vaColor1;
     int *vaColor2;

     int vaIndicesSize;
     int vaVertexSize;
     int vaNormalSize;
     int vaTextureSize;
     int vaColor1Size;
     int vaColor2Size;

     GLUtesselator *tobj;        // Tesselator (for concave polygons)
     SoPrimitiveVertex *polyVerts;        // Array of saved poly vertices
     SoPointDetail     *polyDetails;// Array of poly details
     SoPrimitiveVertex *primVerts;        // Array of saved vertices
     SoPointDetail     *vertDetails;// Array of vertex details
     int numPolyVertsAllocated;        // Size of polyVerts array

     TriangleShape       primShapeType;        // Type of shape generated
     SoFaceDetail        *faceDetail;        // Detail used for each primitive
     int         nestLevel;        // Level of beginShape() nesting
     SoAction    *primAction;        // Action primitives generated for
     SoApplyingList* applyingList;
     int         primVertNum;        // Number of vertices so far
     int         polyVertNum;        // Number of poly vertices so far
     SoShape     *primShape;        // Shape primitives generated for

     jySoPrimitiveVertexPtr *jy_v;
     jySoPrimitiveVertexPtr *jy_v_tmp;
     int jy_v_count;
     int jy_v_count_max;

     jySoDetailPtr *jy_dp;
     jySoDetailPtr *jy_dp_tmp;

     SbBool sendTexCoords;        // TRUE if coords should be sent
     SoMaterialBundle *matlBundle; // Bundle used to send materials
   };
  static int s_keepReset;
  static int s_forceSend;
  static SbBool s_noClip;

  // below are variables related to auto caching
  static int autoCacheMinValue;
  static int autoCacheMaxValue;

  SoMultiPassManagerOld *m_multiPassMgr ;

  // static accessor
  static int getMaxPrimitiveLoop()
  {return s_maxPrimitiveLoop; };

  static int getMinVertexNumForVA()
  { return s_minVertexNumForVA; }

  static int getMinVertexNumForVBO()
  { return s_minVertexNumForVBO; }

  static int getMinVertexNumForVAVBONoCache()
  { return s_minVertexNumForVAVBONoCache; }

  static bool isDesindexingAllowed()
  { return s_allowDesIndexing; }

  static float getForceDesindexingReuseFactor()
  { return s_forceDesindexingReuseFactor; }


  static bool isTrisStripAllowedForQuadMesh()
  { return s_useTriangleForQuadMesh; }

  static SbBool isDetailDebugEnabled()
  { return s_detailDebug; }

  static SbThreadRWMutex *getSharedMutex()
  { return s_sharedCacheMutex; }

  static bool isCreaseAngleFixSet()
  { return s_creaseAngleFix; }

SoINTERNAL private:

  // returns the size of partition to use for a given number of points
  static bool useBBoxPartioning(size_t numPoints);

  // Returns TRUE if the shape object space bbox partition (if available) intersect the ray.
  // Subclasses can call this in their picking methods to determine whether to continue.
  // Note: must be called after computeObjectSpaceRay()
  SbBool checkLocalBBox(SoRayPickAction* action);

  // Returns the list of partition id that intersect with the ray
  void getPartitionIntersection(SoRayPickAction* action, SbBoxPartitionIntersectionInfo* partitionIntersection);

  // Large shape bbox partition cache
  SbBoxPartition* createBBoxPartitionCache(SoState* state, size_t numPoints, const SbBox3f& bbox, const SbVec3f& center);
  void deleteBBoxPartitionCache();
  SoBBoxShapeCache* m_bboxPartitionCache;

private:
  ShapeType m_shapeType;
  SbBool m_TriTranspSort;

  // These are used when rendering or picking a shape whose
  // complexity is set to BOUNDING_BOX. The SoGetBoundingBoxAction
  // is used to compute the bounding box of the shape, and the cube
  // is used as a surrogate object when rendering it.
  static SoGetBoundingBoxAction *bboxAct;
  static SoCube *bboxCube;

  // These methods are used to render primitives generated by
  // subclasses. The userData pointer points to the SoShape instance.
  void GLRenderTriangle(SoGLRenderAction *action,
                        const SoPrimitiveVertex *v1,
                        const SoPrimitiveVertex *v2,
                        const SoPrimitiveVertex *v3);
  void GLRenderLineSegment(SoGLRenderAction *action,
                           const SoPrimitiveVertex *v1,
                           const SoPrimitiveVertex *v2);
  void GLRenderPoint(SoGLRenderAction *action,
                     const SoPrimitiveVertex *v);

  // These methods are used to pick primitives generated by
  // subclasses. The userData pointer points to the SoShape instance.
  void rayPickTriangle(SoRayPickAction *action,
                       const SoPrimitiveVertex *v1,
                       const SoPrimitiveVertex *v2,
                       const SoPrimitiveVertex *v3);
  void rayPickLineSegment(SoRayPickAction *action,
                          const SoPrimitiveVertex *v1,
                          const SoPrimitiveVertex *v2);
  void rayPickPoint(SoRayPickAction *action,
                    const SoPrimitiveVertex *v);


  // Applies rayPick action to the bounding box surrounding the shape.
  // This is used to pick shapes when BOUNDING_BOX complexity is on.
  void rayPickBoundingBox(SoRayPickAction *action);

  // Implements shapeVertex() for one of the three triangle-based types
  void triangleVertex(struct SoShape::MTstruct *mtstruct, const SoPrimitiveVertex *v, int vertToReplace);

  // Helper routine that allocate space for concave polygon vertices
  void allocateVerts();

  // add picked point to action selection list 
  void addIntersectedPoint(SoRayPickAction *action, const SoPrimitiveVertex *v);

  // encapsulates the code to get the "client" external SoShape in case of forwardTraversal
  const SoShape* getExternalShape(SoAction* action) const;

  // Static methods called by the GLU tesselation routines
  static  void CALLBACK beginCB(GLenum primType);
  static void CALLBACK vtxCB(void *vertex);
  static void CALLBACK endCB();
  static void CALLBACK errorCB(GLenum err);
  static void CALLBACK combineCB(GLdouble coords[3], SoPrimitiveVertex *vd[4],
                                 GLfloat wt[4], SoPrimitiveVertex **data);

  // transforms vertices with the given matrix.
  // this is used to transform points during a forward traversal for callback actions
  static void transformForwardTraversedVertices(const SbMatrix& model, size_t numVertices, SoPrimitiveVertex** vertices);

  static SbMatrix computeInternalSceneGraphTransforms(SoState *state, const SoPath* path);

  // Should we use shared mutex instead of per-instance. (v3.1)
  static int s_useSharedCacheMutex;

  // Shared mutex to protect access to normalCache/vpCache. (v3.1)
  static SbThreadRWMutex *s_sharedCacheMutex;

  static int    s_maxPrimitiveLoop;
  static int    s_minVertexNumForVA;
  static int    s_minVertexNumForVBO;
  static int    s_minVertexNumForVAVBONoCache;
  static float  s_forceDesindexingReuseFactor;
  static bool   s_allowDesIndexing;
  static bool   s_useTriangleForQuadMesh;
  static SbBool s_detailDebug;
  static bool   s_creaseAngleFix;
  static int    s_vertex_array_extensionID;
  static int    s_vertex_buffer_extensionID;
  static int    s_multi_draw_array_extensionID;
  static int    s_primitive_restart_extensionID;
  static int    s_primitive_restartNV_extensionID;
  static int    s_opengl_30_extensionID;
  static size_t s_numPointsForBBoxPartioning;
};

inline SbBool 
SoShape::checkShapeHints(SoGLRenderAction *,SbThreadAutoWriteLock *)
{
  return FALSE;
}


#endif /* _SO_SHAPE_ */

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/