SoShape.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      : 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-2022 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef  _SO_SHAPE_
#define  _SO_SHAPE_
 
#include <Inventor/SbBox.h>
#include <Inventor/SbMatrix.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/SbPImpl.h>
 
class SoDetail;
class SbVec2s;
class SoFaceDetail;
class SoPickedPoint;
class SoPrimitiveVertex;
class SoState;
class SoMFInt32;
class PickedPointListImpl;
 
typedef SoPrimitiveVertex *jySoPrimitiveVertexPtr;
typedef SoDetail *jySoDetailPtr;
 
SO_PIMPL_PUBLIC_DECLARATION(SoShape)
 
 
//
//  Class: SoShape
//
//  Abstract base shape node class, which provides some convenience
//  functions for its subclasses.
//
 
class  SoShape : public SoNode
{
  SO_NODE_ABSTRACT_HEADER(SoShape);
  SO_PIMPL_PUBLIC_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,
    SEGMENT_STRIP,
    POINT_SET
  };
 
  void beginShape( SoAction *action, TriangleShape shapeType,
                   SoFaceDetail *faceDetail = NULL);
 
  void shapeVertex(const SoPrimitiveVertex *v);
 
 
 
  void endShape();
  
  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);
  }
 
  inline virtual SbBool isBoundingBoxIgnoring() const
  { return boundingBoxIgnoring.getValue(); }
 
  virtual void getPrimitiveCount(SoGetPrimitiveCountAction *action);
 
  // 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 different 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();
 
  // 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;}
 
  static bool isVertexArrayAvailable(SoState* state=NULL);
  static bool isMultiDrawArrayAvailable(SoState* state=NULL);
  static bool isVertexBufferAvailable(SoState* state=NULL);
 
  // Returns 0 if not available, 1 if NV version, 2 if core
  static int getPrimitiveRestartMode(SoState* state = NULL);
 
  static int getMaxPrimitiveLoop();
 
  static int getMinVertexNumForVA();
 
  static int getMinVertexNumForVBO();
 
  static int getMinVertexNumForVAVBONoCache();
 
  static bool isDesindexingAllowed();
 
  static bool isTrisStripAllowedForQuadMesh();
 
  static SbBool isDetailDebugEnabled();
 
  static bool isCreaseAngleFixSet();
 
  // This endShape is used by SoIndexedFaceSet and SoFaceSet to create hole
  // in a face.
  void endShape( int wt, SoMFInt32* indexes );
 
  // 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);
 
  virtual int getNumVert(SoState *state = NULL ){ return getNumPrim( state ); }
 
  virtual int getNumPrim( SoState *state = NULL );
 
  inline SbBool isRenderable(SoGLRenderAction* action)
  {
    return shouldGLRender(action, FALSE);
  }
 
 private:
 
  SoShape();
 
  virtual SbBool checkShapeHints(SoGLRenderAction *action);
 
  inline virtual void countPrim( SoState *state = NULL );
 
  virtual SbBool checkTransparency(SoGLRenderAction *action, SbBool isPointsOrLines);
 
  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);
 
 
 
  // 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);
  
 
 
  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);
 
  // 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);
 
  // isProjectCoordNeeded = true if projection need to be done by SoShape
  // isProjectCoordNeeded = false if projection is already handled somewhere (ex: vertexShape)
  void setNeedToProjectCoord(bool isProjectCoordNeeded);
 
 private:
  
  static int s_keepReset;
  static int s_forceSend;
  static SbBool s_noClip;
 
private:
 
  // 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);
 
  void commonConstructor();
};
 
inline SbBool 
SoShape::checkShapeHints(SoGLRenderAction *)
{
  return FALSE;
}
 
void
SoShape::countPrim( SoState* /*state*/ )
{}
 
#endif /* _SO_SHAPE_ */