vtkOpenGLContextDevice2D.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkOpenGLContextDevice2D.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef vtkOpenGLContextDevice2D_h
#define vtkOpenGLContextDevice2D_h
 
#include "vtkRenderingContextOpenGL2Module.h" // For export macro
#include "vtkContextDevice2D.h"
 
#include <vector> // STL Header
#include <list> // for std::list
 
class vtkMatrix4x4;
class vtkOpenGLExtensionManager;
class vtkOpenGLHelper;
class vtkOpenGLRenderWindow;
class vtkRenderer;
class vtkShaderProgram;
class vtkStringToImage;
class vtkTransform;
class vtkViewport;
class vtkWindow;
 
class VTKRENDERINGCONTEXTOPENGL2_EXPORT vtkOpenGLContextDevice2D : public vtkContextDevice2D
{
public:
  vtkTypeMacro(vtkOpenGLContextDevice2D, vtkContextDevice2D);
  virtual void PrintSelf(ostream &os, vtkIndent indent);
 
  static vtkOpenGLContextDevice2D *New();
 
 
  virtual void DrawPoly(float *f, int n, unsigned char *colors = 0,
                        int nc_comps = 0);
 
 
  virtual void DrawLines(float *f, int n, unsigned char *colors = 0,
                         int nc_comps = 0);
 
 
  virtual void DrawPoints(float *points, int n, unsigned char* colors = 0,
                          int nc_comps = 0);
 
 
  virtual void DrawPointSprites(vtkImageData *sprite, float *points, int n,
                                unsigned char* colors = 0, int nc_comps = 0);
 
 
  virtual void DrawMarkers(int shape, bool highlight, float *points, int n,
                           unsigned char *colors = 0, int nc_comps = 0);
 
 
  vtkSetMacro(MaximumMarkerCacheSize, int)
  vtkGetMacro(MaximumMarkerCacheSize, int)
 
  virtual void DrawQuad(float *points, int n);
 
  virtual void DrawQuadStrip(float *points, int n);
 
  virtual void DrawPolygon(float *, int);
 
 
  virtual void DrawEllipseWedge(float x, float y, float outRx, float outRy,
                                float inRx, float inRy, float startAngle,
                                float stopAngle);
 
 
  virtual void DrawEllipticArc(float x, float y, float rX, float rY,
                               float startAngle, float stopAngle);
 
 
  virtual void DrawString(float *point, const vtkStdString &string);
 
 
  virtual void ComputeStringBounds(const vtkStdString &string,
                                   float bounds[4]);
 
  virtual void DrawString(float *point, const vtkUnicodeString &string);
 
 
  virtual void ComputeStringBounds(const vtkUnicodeString &string,
                                   float bounds[4]);
 
  virtual void DrawMathTextString(float point[2], const vtkStdString &string);
 
  virtual void DrawImage(float p[2], float scale, vtkImageData *image);
 
  void DrawImage(const vtkRectf& pos, vtkImageData *image);
 
  virtual void SetColor4(unsigned char color[4]);
 
  virtual void SetColor(unsigned char color[3]);
 
  virtual void SetTexture(vtkImageData* image, int properties = 0);
 
  virtual void SetPointSize(float size);
 
  virtual void SetLineWidth(float width);
 
  virtual void SetLineType(int type);
 
  virtual void MultiplyMatrix(vtkMatrix3x3 *m);
 
  virtual void SetMatrix(vtkMatrix3x3 *m);
 
  virtual void GetMatrix(vtkMatrix3x3 *m);
 
  virtual void PushMatrix();
 
  virtual void PopMatrix();
 
  virtual void SetClipping(int *x);
 
  virtual void EnableClipping(bool enable);
 
  virtual void Begin(vtkViewport* viewport);
 
  virtual void End();
 
  virtual void BufferIdModeBegin(vtkAbstractContextBufferId *bufferId);
 
  virtual void BufferIdModeEnd();
 
  bool SetStringRendererToFreeType();
 
  bool SetStringRendererToQt();
 
  bool HasGLSL();
 
 
  vtkGetObjectMacro(RenderWindow, vtkOpenGLRenderWindow);
 
  virtual void ReleaseGraphicsResources(vtkWindow *window);
 
 
  vtkMatrix4x4 *GetProjectionMatrix();
  vtkMatrix4x4 *GetModelMatrix();
 
//BTX
protected:
  vtkOpenGLContextDevice2D();
  virtual ~vtkOpenGLContextDevice2D();
 
 
  int GetNumberOfArcIterations(float rX,
                               float rY,
                               float startAngle,
                               float stopAngle);
 
  int Geometry[2];
 
  vtkRenderer *Renderer;
 
  vtkStringToImage *TextRenderer;
 
  bool InRender;
 
 
  class Private;
  Private *Storage;
 
  vtkOpenGLRenderWindow* RenderWindow;
 
  vtkOpenGLHelper *VCBO;  // vertex + color
  void ReadyVCBOProgram();
  vtkOpenGLHelper *VBO;  // vertex
  void ReadyVBOProgram();
  vtkOpenGLHelper *VTBO;  // vertex + tcoord
  void ReadyVTBOProgram();
  vtkOpenGLHelper *SCBO;  // sprite + color
  void ReadySCBOProgram();
  vtkOpenGLHelper *SBO;  // sprite
  void ReadySBOProgram();
 
  void SetMatrices(vtkShaderProgram *prog);
  void BuildVBO(vtkOpenGLHelper *cbo,
    float *v, int nv,
    unsigned char *coolors, int nc,
    float *tcoords);
  void CoreDrawTriangles(std::vector<float> &tverts);
 
private:
  vtkOpenGLContextDevice2D(const vtkOpenGLContextDevice2D &); // Not implemented.
  void operator=(const vtkOpenGLContextDevice2D &);   // Not implemented.
 
  void AlignText(double orientation, float width, float height, float *p);
 
  vtkImageData *GetMarker(int shape, int size, bool highlight);
 
  class vtkMarkerCacheObject
  {
  public:
    vtkTypeUInt64 Key;
    vtkImageData *Value;
    bool operator==(vtkTypeUInt64 key)
    {
      return this->Key == key;
    }
  };
 
  vtkTransform *ProjectionMatrix;
  vtkTransform *ModelMatrix;
 
  std::list<vtkMarkerCacheObject> MarkerCache;
  int MaximumMarkerCacheSize;
 
  vtkImageData * GenerateMarker(int shape, int size, bool highlight);
 
//ETX
};
 
#endif //vtkOpenGLContextDevice2D_h