src/PIPELINE/VISU_OpenGLPointSpriteMapper.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

//  VISU OBJECT : interactive object for VISU entities implementation
// File:    VISU_OpenGLPointSpriteMapper.hxx
// Author:  
// Module : VISU
//
#ifndef VISU_OpenGLPointSpriteMapper_HeaderFile
#define VISU_OpenGLPointSpriteMapper_HeaderFile

#if defined(_MSC_VER)
# pragma warning ( disable : 4275 )
#endif

#ifdef WIN32
#include <windows.h>
#endif

#include <GL/gl.h>

#include <vtkSmartPointer.h>
#include <vtkConfigure.h>

#include "VTKViewer.h"

class vtkCellArray;
class vtkPoints;
class vtkProperty;
class vtkImageData;
class vtkXMLImageDataReader;

#ifndef VTK_IMPLEMENT_MESA_CXX
#include <vtkOpenGLPolyDataMapper.h>
#define MAPPER_SUPERCLASS vtkOpenGLPolyDataMapper
#else
#include <vtkMesaPolyDataMapper.h>
#define MAPPER_SUPERCLASS vtkMesaPolyDataMapper
#endif

#ifndef GL_ARB_shader_objects
typedef GLuint GLhandleARB;
#endif

#include "VISUPipeline.hxx"

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

class VISU_PIPELINE_EXPORT VISU_OpenGLPointSpriteMapper : public MAPPER_SUPERCLASS
{
public:

  enum RenderModes { Accumulate = 0, Occlude };

  enum PrimitiveTypes { PointSprite = 0, OpenGLPoint, GeomSphere };

  static VISU_OpenGLPointSpriteMapper *New();
  vtkTypeRevisionMacro(VISU_OpenGLPointSpriteMapper,MAPPER_SUPERCLASS);



  vtkGetMacro(DefaultPointSize, float);

  void
  SetAverageCellSize(float theSize);

  vtkGetMacro(AverageCellSize, float);

  vtkSetMacro(RenderMode, int);

  vtkGetMacro(RenderMode, int);

  virtual void RenderPiece(vtkRenderer *ren, vtkActor *a);

  void ReleaseGraphicsResources(vtkWindow *);

  virtual int Draw(vtkRenderer *ren, vtkActor *a);

  static float GetMaximumSupportedSize();


  vtkSetMacro(UseOpenGLMapper, bool);

  vtkGetMacro(UseOpenGLMapper, bool);

  vtkSetMacro(UsePointSprites, bool);

  vtkGetMacro(UsePointSprites, bool);


  vtkSetMacro(UseTextures, bool);

  vtkGetMacro(UseTextures, bool);


  vtkSetMacro(UseShader, bool);

  vtkGetMacro(UseShader, bool);


  vtkGetMacro(PointSpriteMode, int);
  void SetPointSpriteMode( int );

  vtkGetMacro(PrimitiveType, int);

  void SetPrimitiveType( int );

  void SetPointSpriteClamp( float );

  vtkGetMacro(PointSpriteClamp, float);

  void SetPointSpriteSize( float );

  vtkGetMacro(PointSpriteSize, float);

  void SetPointSpriteMinSize( float );

  vtkGetMacro(PointSpriteMinSize, float);

  void SetPointSpriteMaxSize( float );

  vtkGetMacro(PointSpriteMaxSize, float);

  void SetPointSpriteMagnification( float );

  vtkGetMacro(PointSpriteMagnification, float);

  void SetPointSpriteAlphaThreshold( float );

  vtkGetMacro(PointSpriteAlphaThreshold, float);

  vtkSetMacro(PointSpriteOpacity, float);

  vtkGetMacro(PointSpriteOpacity, float);

  void SetImageData(vtkImageData* theImageData);

  vtkImageData* GetImageData();

protected:
  VISU_OpenGLPointSpriteMapper();
  ~VISU_OpenGLPointSpriteMapper();

  bool              InitExtensions();

  void              InitPointSprites();

  void              CleanupPointSprites();

  void              InitTextures();

  void              InitShader();

  void              SetShaderVariable( const char* variable, float value );

  void              PrintInfoLog( GLhandleARB );

private:
  bool              UseOpenGLMapper;

  bool              UsePointSprites;
  bool              UseTextures;
  bool              UseShader;

  int               RenderMode;
  int               ListId;
  vtkIdType         TotalCells;
  int               ExtensionsInitialized;
  float             DefaultPointSize;

  GLhandleARB       VertexProgram;

  int               PrimitiveType;

  int               PointSpriteMode;

  float             PointSpriteClamp;
  float             PointSpriteSize;
  float             PointSpriteMinSize;
  float             PointSpriteMaxSize;
  float             PointSpriteMagnification;

  GLuint            PointSpriteTexture;
  float             PointSpriteAlphaThreshold;
  float             PointSpriteOpacity;

  float             AverageCellSize;

  vtkSmartPointer<vtkImageData> ImageData;
};

#endif