Inventor/nodes/SoBufferedShape.h

Go to the documentation of this file.

/*=======================================================================
 *** 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                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
#if !defined SOBUFFEREDSHAPE_H
#define SOBUFFEREDSHAPE_H

#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoMFEnum.h>
#include <Inventor/fields/SoSFInt32.h>
#include <Inventor/fields/SoMFInt32.h>
#include <Inventor/fields/SoSFShort.h>
#include <Inventor/fields/SoSFBox3f.h>
#include <Inventor/fields/SoSFBufferObject.h>
#include <Inventor/fields/SoMFBufferObject.h>

#include <Inventor/nodes/SoNode.h>
#include <Inventor/nodes/SoVertexProperty.h>
#include <Inventor/nodes/SoShape.h>

#include <Inventor/caches/SoContextedObjectCache.h>
#include <Inventor/threads/SbThreadRWMutex.h>
#include <Inventor/elements/SoDrawStyleElement.h>


class SoBufferObject;
class SoGLBufferObject;
class SoCube;
class SoDetail;
class SoAction;
class SoGLDevice;

namespace inventor
{
  namespace cache
  {
    class VertexProperty;
  }
}

namespace OpenInventorInternal {
  class GLBufferedShapeCache;
}
class  SoBufferedShape : public SoShape 
{
  SO_NODE_HEADER( SoBufferedShape );

  // ----------------------- Public usage --------------------------------------

public:

  enum Type
  {
    POINTS,

    LINE_STRIP,

    LINE_LOOP,

    LINES,

    TRIANGLE_STRIP,

    TRIANGLE_FAN,

    TRIANGLES,

    QUAD_STRIP,

    QUADS,

    POLYGON
  };

  enum Usage
  {
    STATIC,
    DYNAMIC
  };

  SoBufferedShape();

  SoSFEnum shapeUsage;

  SoSFBool primitiveRestartEnabled;

  SoSFInt32 primitiveRestartValue;

  SoSFBool useNormalsGenerator;

  SoSFEnum shapeType;

  SoMFInt32 numVertices;

  SoSFBufferObject vertexBuffer;

  SoSFShort vertexComponentsCount;

  SoSFEnum vertexComponentsType;

  SoSFShort vertexStride;

  SoSFInt32 vertexOffset;

  SoSFBufferObject normalBuffer;

  SoSFEnum normalComponentsType;

  SoSFShort normalStride;

  SoSFInt32 normalOffset;

  SoSFBufferObject indexBuffer;

  SoSFEnum indexType;

  SoSFInt32 indexOffset;

  SoSFBufferObject colorBuffer;

  SoSFEnum colorComponentsType;

  SoSFInt32 colorStride;

  SoSFInt32 colorOffset;

  SoSFInt32 colorComponentsCount;

  SoMFBufferObject texCoordsBuffer;

  SoMFEnum texCoordsComponentsType;

  SoMFInt32 texCoordsStride;

  SoMFInt32 texCoordsOffset;

  SoMFInt32 texCoordsComponentsCount;
 
private:
  virtual void GLRender(SoGLRenderAction *action );

  virtual void getBoundingBox( SoGetBoundingBoxAction *action );

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

  virtual void computeBBox(SoAction *action, SbXfBox3d &box, SbVec3d &center);

  virtual void rayPick(SoRayPickAction *action );

  virtual void getPrimitiveCount(SoGetPrimitiveCountAction *action );

// ----------------------- Private usage -------------------------------------
// INTERNAL 
private:
  virtual SbMatrix3* computeVtxTangentSpaceMat( const float *bumpTexCoords, int &numMat ) const;

  static void initClass();

  static void exitClass();

  virtual SbBool readInstance(SoInput *in, unsigned short flags );

  void notify( SoNotList* list );

  inline inventor::cache::VertexProperty* getVpCache();

  inline void lockVpCacheMutex() const;

  inline void unlockVpCacheMutex() const;

  // ----------------------- Protected usage -------------------------------------

private:

  virtual ~SoBufferedShape();

  virtual SbBool shouldCheckShapeHints();

  virtual SbBool shouldGLRender( SoGLRenderAction *action, SbBool isPointsOrLines = FALSE );

  virtual SbBool isLightingUsable( const SoState* state, const void* normalBufferPtr );

  virtual SbBool isTransparent(SoState* state) const;

  virtual void generatePrimitives( SoAction *action );


  virtual void GLRenderBoundingBox( SoGLRenderAction *action );

  virtual int getNumPrim();

  virtual SbBool numPrimInvalid();

  // Overrides standard method to create an SoFaceDetail instance
  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 );

  //Transforms the polygons into lines before rendering them.
  //It can be used if :
  //- shapeStyle = TRIANGLE, TRIANGLE_STRIP, TRIANGLE_FAN, TRIANGLES, QUAD_STRIP, QUADS or POLYGON
  //- SoDrawStyle::style = LINES
  void renderExtraData( SoGLRenderAction* );
  void renderExtra_NonIndexed_TriangleStrip( SoGLRenderAction* );
  void renderExtra_NonIndexed_QuadStrip( SoGLRenderAction* );
  void renderExtra_NonIndexed_Triangles( SoGLRenderAction* );
  void renderExtra_NonIndexed_Quads( SoGLRenderAction* );
  void renderExtra_NonIndexed_TriangleFan( SoGLRenderAction* );
  void renderExtra_Indexed_TriangleStrip( SoGLRenderAction* );
  void renderExtra_Indexed_QuadStrip( SoGLRenderAction* );
  void renderExtra_Indexed_Triangles( SoGLRenderAction* );
  void renderExtra_Indexed_Quads( SoGLRenderAction* );
  void renderExtra_Indexed_TriangleFan( SoGLRenderAction* );

  // ----------------------- Private usage -------------------------------------

private:
  struct InstancesInfos
  {
    unsigned int numInstances;
    unsigned int numBatches;
    unsigned int smallestBatchSize;
    unsigned int instancesPerBatch;
    unsigned int instancesInLastBatch;
  };

  void getInstanceInfos( SoState* state, InstancesInfos& instancesInfo );

  void drawElementsInstanced(SoGLRenderAction* action, const InstancesInfos& instanceInfos,
                             GLenum mode, GLsizei count, GLenum type, 
                             const void * indices);

  void drawArraysInstanced(SoGLRenderAction* action, const InstancesInfos& instanceInfos,
                           GLenum mode, GLint first, GLsizei count);

  unsigned int computeSmallestBatchSize(const SoNodeList* vertexAttribsList, unsigned int numInstances);

  SbBool isPointsOrLines() const;

  //In some cases primitives need to be transformed to POINTS to have a correct rendering
  //with POINTS as drawStyle.
  bool arePointsNeededAsPrimitives( SoDrawStyleElement::Style drawStyle ) const;

  bool isTargetValid( SoBufferObject* bufferObject, int expectedTarget ) const;

  int getOpenGLShapeType( SoAction* ) const;

  bool setupVertices( SoState* state, SoBufferObject* vertexBufferPtr );

  bool setupNormals( SoState* state, SoBufferObject* normalBufferPtr );

  bool setupColors( SoState* state,  SoBufferObject* colorBufferPtr  );

  void setupTexCoords( SoState* state,  SoBufferObject* texCoordsBufferPtr, int unit  );

  void setupVertexAttribs( SoState* state, const InstancesInfos& instancesInfo, int curBatch );

  void disableVertexAttribs( SoState* state );

  void generateDefaultNormals( SoAction* action );

  template< class T > void generateDefaultNormalsTemplate(  SoState* state );
  template< class T > void generateDefaultNormalsTemplate_BASE( SoState* state, const int vertPerPrim );
  template< class T > void generateDefaultNormalsTemplate_STRIP( SoState* state, const int vertPerPrim );

  unsigned int getIndex( const void* indicesBuffer, const unsigned int index ) const;
  template< class T > unsigned int getIndexTemplate( const void* indicesBuffer, const unsigned int index ) const;

  SbVec3f getNormal( const void* normalsBuffer, const unsigned int index ) const;
  template< class T > SbVec3f getNormalTemplate( const void* normalsBuffer, const unsigned int index, const unsigned int stride ) const;

  SbVec4f getTexCoord( const void* texCoordsBuffer, const int unit, const unsigned int index ) const;
  template< class T > SbVec4f getTexCoordTemplate( const void* texCoordsBuffer, const unsigned int index, const unsigned int stride, const unsigned int componentsCount ) const;

  template< class T > void getVertex( const void* verticesBuffer, const short componentsCount, const unsigned int stride, const unsigned int index, T& x, T& y, T& z ) const;
  template< class T > SbVec3f getVertex( const void* verticesBuffer, const short componentsCount, const unsigned int stride, const unsigned int index ) const;

  template< class T > void computeBBoxTemplate( SoAction *action, SbBox3f &box, SbVec3f &center );

  template< class T > void computeBBoxTemplate_POINTS( SoAction *action, SbBox3f &box, SbVec3f &center );

  template< class T > void computeBBoxTemplate( SoAction *action, SbBox3f &box, SbVec3f &center, const SbVec2d &psize );

  template< class T > void computeBBoxTemplateSP( SoAction *action, SbBox3f &box, SbVec3f &center, const SbVec2d &psize );

  template< class T, int MODE > void computeBBoxTemplate_( SoAction *, SbBox3f &box, SbVec3f &center, const SbVec2d &pSize );
  
  template< class T > void rayPickQuad( void* indicesPtr, void* verticesPtr, int verticesStride, SoRayPickAction *action, bool isStrip );

  template< class T > void rayPickTriangle( void* indicesPtr, void* verticesPtr, int verticesStride, SoRayPickAction *action, bool isStrip, bool isFan );

  template< class T > void rayPickLine( void* indicesPtr, void* verticesPtr, int verticesStride, SoRayPickAction *action, bool isStrip, bool isLoop );

  template< class T > void rayPickPoint( void* indicesPtr, void* verticesPtr, int verticesStride, SoRayPickAction *action );

  template< class T > void pointPicking( void* indicesPtr, void* verticesPtr, SoRayPickAction* action );

  template< class T > void generatePrimitives(size_t verticesCount, SoAction *action);

  template< class T > void generatePrimitives_POLYGONS(size_t verticesCount, SoAction *action);

  // Returns TRUE if we don't see any issue in the fields
  SbBool checkFieldsContent(bool forGLRender);

  int getGLShapeUsage() const;

  //A GL context must exist to use this method.
  bool isRenderExtraDataNeededInCurrentContext() const;

  //A GL context must exist to use this method.
  bool isRenderExtraDataNeededByGraphicCardInCurrentContext() const;

  //For some shapeType values, the render extra data process must be launched ( without considering
  //OIV_SHAPES_PRIMITIVES_OPTIM ) in order to have a correct rendering with LINES as drawStyle.
  bool isRenderExtraDataNeededByShapeType() const;

  // Update the target according to the source and the modifications counter and update the counter is needed.
  static void mapToCache(SoBufferObject* source, SoGLBufferObject* target, uint64_t& modificationsCounter);

  // Some buffers requires a release so this method is used to with mapToCache to be sure that we release the buffers.
  static void unmapFromCache(SoBufferObject* source, SoGLBufferObject* target);

  static void initNumGraphicCards();
  static void initUseShapeOptim();

  //Some graphic cards has bad performance when glPolygonMode is used to render the
  //shape with LINES as draw style.
  //
  //Returns true if the polygons must be transformed in lines before rendering them.
  static bool isRenderExtraDataNeededByGraphicCard( const SbString& graphicCardName );

  // ----------------------- Private usage -------------------------------------

private:
  static bool canBeMapped(SoDeviceContext* context, SoBufferObject* bufferObject);

  SbBox3f m_computedBoundingBox;

  void** m_primitivesOffset;
  int* m_primitivesOffsetInt;

  int m_primitivesOffsetArraySize;

  int m_vertexCount;

  float m_usedCreaseAngle;

  // Vp cache data

  inventor::cache::VertexProperty* m_vpCache;

  // Per-instance mutex to protect access to the vpCache
  SbThreadRWMutex* m_vpCacheMutex;

  // Buffer cache
  SoContextedObjectCache<OpenInventorInternal::GLBufferedShapeCache> *m_cacheList;

  GLint* m_indicesArray;
  GLsizei* m_countArray;
  GLvoid** m_indicesElement;
  int m_numPrimitives;

  bool m_checkFields;
  bool m_lastFieldsCheckResult;

  static bool s_useShapeOptim;
  static unsigned int s_numGraphicCards;
};


//------------------------------------------------------------------------------
inline inventor::cache::VertexProperty*
SoBufferedShape::getVpCache()
{
  return m_vpCache;
}

//------------------------------------------------------------------------------
inline void
SoBufferedShape::lockVpCacheMutex() const
{
  m_vpCacheMutex->writelock();
}

//------------------------------------------------------------------------------
inline void
SoBufferedShape::unlockVpCacheMutex() const
{
  m_vpCacheMutex->writeunlock();
}

//------------------------------------------------------------------------------
inline int 
SoBufferedShape::getNumPrim()
{
  return m_vertexCount;
}

//------------------------------------------------------------------------------
inline SbBool 
SoBufferedShape::numPrimInvalid()
{
  return (m_vertexCount<0)?TRUE:FALSE;
}


//------------------------------------------------------------------------------
inline SbBool 
SoBufferedShape::shouldCheckShapeHints()
{
  return TRUE;
}


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

#endif // SOBUFFEREDSHAPE_H

---

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