SoVolumeGeometry.h

/*=======================================================================
 *** 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-2023 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
 
#ifndef SO_VOLUME_GEOMETRY_H
#define SO_VOLUME_GEOMETRY_H
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4251)
#endif
 
#include <Inventor/SbBox.h>
#include <Inventor/STL/vector>
 
#include <VolumeViz/nodes/SoVolumeShape.h>
#include <VolumeViz/nodes/SoSlice.h>
 
#include <LDM/actions/SoLdmValuationActionInterface.h>
#include <LDM/SoLDMTileID.h>
#include <LDM/actions/SoLdmValuationActionInterface.h>
 
class SoVertexShape;
class SoVolumeGeometryVbo;
class SoGLRenderAction;
class SoAction;
class SoState;
class SoBoundingBoxCache;
class SoPrimitiveVertex;
class SoLdmValuationAction;
 
 
class  SoVolumeGeometry : public SoLdmValuationActionInterface
{
public:
 
  SoVolumeGeometry();
 
  virtual ~SoVolumeGeometry();
 
  virtual void setRenderProgress(SoProgressIndicator* ps) { m_renderProgress = ps; }
 
 
private:
 
  float intersectGeometry(const SoLDMTileID& tile) const;
 
  virtual void triangleCB(SoAction* action,
    const SoPrimitiveVertex *v0,
    const SoPrimitiveVertex *v1,
    const SoPrimitiveVertex *v2 ) const ;
 
  virtual void lineCB( SoAction* action,
    const SoPrimitiveVertex *v0,
    const SoPrimitiveVertex *v1 ) const ;
 
  virtual void pointCB( SoAction* action, const SoPrimitiveVertex *v ) const ;
 
  inline void setEnableBumMapping(bool flag);
 
  inline bool isBumpMappingEnabled();
 
  inline void setBumpScale(float scale);
 
  inline float getBumScale();
 
  inline void setAlphaUse (SoSlice::AlphaUse alphaUse);
 
  inline SoSlice::AlphaUse getAlphaUse();
 
  inline void setUseRGBA(bool flag);
 
  inline bool isUsingRGBA();
 
#if 1             SoDEPRECATED
  virtual SoVolumeShape::Interpolation getInteractiveInterpolationValue(SoState* state) const = 0;
#endif 
  SoVolumeState* getVolumeState() const;
 
private:
 
  inline void setClipGeometry(bool flag);
 
  virtual void GLRenderBoundingBox(SoGLRenderAction* action) = 0;
 
  virtual void shapeRender(SoGLRenderAction* action) = 0;
 
  virtual void shapeGeneratePrimitives(SoAction* action) = 0;
 
  void createRenderInterfaces(SoShape* bindedShape);
 
  virtual void getBBox(SoAction *action, SbBox3f &box, SbVec3f &center) = 0;
 
  virtual void getBBox(SoAction *action, SbXfBox3d &box, SbVec3d &center) = 0;
 
  void doRendering(SoGLRenderAction* action, float offset);
 
  void computeBBox(SoAction *action, SbBox3f &box, SbVec3f &center);
 
  void computeBBox(SoAction *action, SbXfBox3d &box, SbVec3d &center);
 
  virtual int getNumVertices(SoState* state) = 0;
 
  virtual int getIndexCoord(int index) const = 0;
 
  void invalidateBboxCache();
 
  SoVolumeGeometryVbo* m_volVbo;
 
  bool m_clipGeometry;
 
  friend class SoLdmValuationAction;
  friend class SoVolumeGeometryVbo;
  friend class SoVolumeStateGeometry;
  friend class SoFenceSlice;
 
  SoSlice::AlphaUse m_alphaUse;
 
  bool m_enableBumpMapping;
 
  float m_bumpScale;
 
  
  bool m_useRGBA;
 
  SoProgressIndicator* m_renderProgress;
 
SoINTERNAL private:
  virtual void ldmAction(SoLdmValuationAction* action);
 
private:
 
  void renderVbo(SoGLRenderAction *action);
 
  SoBoundingBoxCache* m_bboxCache[2];
 
 
 
};
 
/*******************************************************************************/
void
SoVolumeGeometry::setClipGeometry(bool flag)
{
  m_clipGeometry = flag;
}
 
bool 
SoVolumeGeometry::isBumpMappingEnabled()
{
  return m_enableBumpMapping;
}
 
float 
SoVolumeGeometry::getBumScale()
{
  return m_bumpScale;
}
 
SoSlice::AlphaUse 
SoVolumeGeometry::getAlphaUse()
{
  return m_alphaUse;
}
 
void 
SoVolumeGeometry::setEnableBumMapping(bool flag)
{
  m_enableBumpMapping = flag;
}
 
 
void 
SoVolumeGeometry::setBumpScale(float scale)
{
  m_bumpScale = scale;
}
 
void 
SoVolumeGeometry::setAlphaUse (SoSlice::AlphaUse alphaUse)
{
  m_alphaUse = alphaUse;
}
 
bool
SoVolumeGeometry::isUsingRGBA()
{
  return m_useRGBA;
}
 
void
SoVolumeGeometry::setUseRGBA(bool flag)
{
  m_useRGBA = flag;
}
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif