VTK
vtkOpenGLContextDevice2DPrivate.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkOpenGLContextDevice2DPrivate.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 
32 #ifndef vtkOpenGLContextDevice2DPrivate_h
33 #define vtkOpenGLContextDevice2DPrivate_h
34 
36 
37 #include "vtkColor.h"
38 #include "vtkTextProperty.h"
39 #include "vtkFreeTypeTools.h"
40 #include "vtkStdString.h"
41 #include "vtkUnicodeString.h"
42 
43 #include <algorithm>
44 #include <list>
45 #include <utility>
46 
47 // .NAME vtkTextureImageCache - store vtkTexture and vtkImageData identified by
48 // a unique key.
49 // .SECTION Description
50 // Creating and initializing a texture can be time consuming,
51 // vtkTextureImageCache offers the ability to reuse them as much as possible.
52 template <class Key>
54 {
55 public:
56  struct CacheData
57  {
60  // Dimensions of the text. Used for generating texture coords when the image
61  // dimensions are scaled to a power of two.
62  int TextWidth;
64  };
65 
67 
68  struct CacheElement: public std::pair<Key, CacheData>
69  {
70  // Default constructor
72  : std::pair<Key, CacheData>(Key(), CacheData()){}
73  // Construct a partial CacheElement with no CacheData
74  // This can be used for temporary CacheElement used to search a given
75  // key into the cache list.
76  CacheElement(const Key& key)
77  : std::pair<Key, CacheData>(key, CacheData()){}
78  // Standard constructor of CacheElement
79  CacheElement(const Key& key, const CacheData& cacheData)
80  : std::pair<Key, CacheData>(key, cacheData){}
81  // Operator tuned to be used when searching into the cache list using
82  // std::find()
83  bool operator==(const CacheElement& other)const
84  {
85  // Here we cheat and make the comparison only on the key, this allows
86  // us to use std::find() to search for a given key.
87  return this->first == other.first;
88  }
89  };
91 
93 
96  {
97  this->MaxSize = 50;
98  }
100 
102 
104  bool IsKeyInCache(const Key& key)const
105  {
106  return std::find(this->Cache.begin(), this->Cache.end(), key) != this->Cache.end();
107  }
109 
114  CacheData& GetCacheData(const Key& key);
115 
117 
120  {
121  typename std::list<CacheElement >::iterator it;
122  for (it = this->Cache.begin(); it != this->Cache.end(); ++it)
123  {
124  it->second.Texture->ReleaseGraphicsResources(window);
125  }
126  }
128 
129 protected:
131 
133  CacheData& AddCacheData(const Key& key, const CacheData& cacheData)
134  {
135  assert(!this->IsKeyInCache(key));
136  if (this->Cache.size() >= this->MaxSize)
137  {
138  this->Cache.pop_back();
139  }
140  this->Cache.push_front(CacheElement(key, cacheData));
141  return this->Cache.begin()->second;
142  }
144 
146  std::list<CacheElement > Cache;
148 
149  size_t MaxSize;
150 };
152 
153 template<class Key>
155 ::GetCacheData(const Key& key)
156 {
157  typename std::list<CacheElement>::iterator it =
158  std::find(this->Cache.begin(), this->Cache.end(), CacheElement(key));
159  if (it != this->Cache.end())
160  {
161  return it->second;
162  }
163  CacheData cacheData;
166  cacheData.Texture->SetInputData(cacheData.ImageData);
167  cacheData.TextWidth = 0;
168  cacheData.TextHeight = 0;
169  return this->AddCacheData(key, cacheData);
170 }
171 
172 // .NAME TextPropertyKey - unique key for a vtkTextProperty and text
173 // .SECTION Description
174 // Uniquely describe a pair of vtkTextProperty and text.
175 template <class StringType>
177 {
179 
180  static unsigned int GetIdFromTextProperty(vtkTextProperty* textProperty)
181  {
182  unsigned long id;
184  return static_cast<unsigned int>(id);
185  }
187 
189 
190  TextPropertyKey(vtkTextProperty* textProperty, const StringType& text)
191  {
192  this->TextPropertyId = GetIdFromTextProperty(textProperty);
193  this->FontSize = textProperty->GetFontSize();
194  double color[3];
195  textProperty->GetColor(color);
196  this->Color.Set(static_cast<unsigned char>(color[0] * 255),
197  static_cast<unsigned char>(color[1] * 255),
198  static_cast<unsigned char>(color[2] * 255),
199  static_cast<unsigned char>(textProperty->GetOpacity() * 255));
200  this->Text = text;
201  }
203 
205 
207  bool operator==(const TextPropertyKey& other)const
208  {
209  return this->TextPropertyId == other.TextPropertyId &&
210  this->FontSize == other.FontSize &&
211  this->Text == other.Text &&
212  this->Color[0] == other.Color[0] &&
213  this->Color[1] == other.Color[1] &&
214  this->Color[2] == other.Color[2] &&
215  this->Color[3] == other.Color[3];
216  }
218 
219  unsigned short FontSize;
221  // States in the function not to use more than 32 bits - int works fine here.
222  unsigned int TextPropertyId;
223  StringType Text;
224 };
225 
228 
230 {
231 public:
233  {
234  this->Texture = NULL;
237  this->SpriteTexture = NULL;
238  this->SavedLighting = GL_TRUE;
239  this->SavedDepthTest = GL_TRUE;
240  this->SavedAlphaTest = GL_TRUE;
241  this->SavedStencilTest = GL_TRUE;
242  this->SavedBlend = GL_TRUE;
243  this->SavedDrawBuffer = 0;
244  this->SavedClearColor[0] = this->SavedClearColor[1] =
245  this->SavedClearColor[2] =
246  this->SavedClearColor[3] = 0.0f;
247  this->TextCounter = 0;
248  this->GLExtensionsLoaded = false;
249  this->OpenGL15 = false;
250  this->OpenGL20 = false;
251  this->GLSL = false;
252  this->PowerOfTwoTextures = true;
253  }
254 
256  {
257  if (this->Texture)
258  {
259  this->Texture->Delete();
260  this->Texture = NULL;
261  }
262  if (this->SpriteTexture)
263  {
264  this->SpriteTexture->Delete();
265  this->SpriteTexture = NULL;
266  }
267  }
268 
269  void SaveGLState(bool colorBuffer = false)
270  {
271  this->SavedLighting = glIsEnabled(GL_LIGHTING);
272  this->SavedDepthTest = glIsEnabled(GL_DEPTH_TEST);
273 
274  if (colorBuffer)
275  {
276  this->SavedAlphaTest = glIsEnabled(GL_ALPHA_TEST);
277  this->SavedStencilTest = glIsEnabled(GL_STENCIL_TEST);
278  this->SavedBlend = glIsEnabled(GL_BLEND);
279  glGetFloatv(GL_COLOR_CLEAR_VALUE, this->SavedClearColor);
280  glGetIntegerv(GL_DRAW_BUFFER, &this->SavedDrawBuffer);
281  }
282  }
283 
284  void RestoreGLState(bool colorBuffer = false)
285  {
286  this->SetGLCapability(GL_LIGHTING, this->SavedLighting);
287  this->SetGLCapability(GL_DEPTH_TEST, this->SavedDepthTest);
288 
289  if (colorBuffer)
290  {
291  this->SetGLCapability(GL_ALPHA_TEST, this->SavedAlphaTest);
292  this->SetGLCapability(GL_STENCIL_TEST, this->SavedStencilTest);
293  this->SetGLCapability(GL_BLEND, this->SavedBlend);
294 
295  if(this->SavedDrawBuffer != GL_BACK_LEFT)
296  {
297  glDrawBuffer(this->SavedDrawBuffer);
298  }
299 
300  int i = 0;
301  bool colorDiffer = false;
302  while(!colorDiffer && i < 4)
303  {
304  colorDiffer=this->SavedClearColor[i++] != 0.0;
305  }
306  if(colorDiffer)
307  {
308  glClearColor(this->SavedClearColor[0],
309  this->SavedClearColor[1],
310  this->SavedClearColor[2],
311  this->SavedClearColor[3]);
312  }
313  }
314  }
315 
316  void SetGLCapability(GLenum capability, GLboolean state)
317  {
318  if (state)
319  {
320  glEnable(capability);
321  }
322  else
323  {
324  glDisable(capability);
325  }
326  }
327 
328  float* TexCoords(float* f, int n)
329  {
330  float* texCoord = new float[2*n];
331  float minX = f[0]; float minY = f[1];
332  float maxX = f[0]; float maxY = f[1];
333  float* fptr = f;
334  for(int i = 0; i < n; ++i)
335  {
336  minX = fptr[0] < minX ? fptr[0] : minX;
337  maxX = fptr[0] > maxX ? fptr[0] : maxX;
338  minY = fptr[1] < minY ? fptr[1] : minY;
339  maxY = fptr[1] > maxY ? fptr[1] : maxY;
340  fptr+=2;
341  }
342  fptr = f;
344  {
345  double* textureBounds = this->Texture->GetInput()->GetBounds();
346  float rangeX = (textureBounds[1] - textureBounds[0]) ?
347  textureBounds[1] - textureBounds[0] : 1.;
348  float rangeY = (textureBounds[3] - textureBounds[2]) ?
349  textureBounds[3] - textureBounds[2] : 1.;
350  for (int i = 0; i < n; ++i)
351  {
352  texCoord[i*2] = (fptr[0]-minX) / rangeX;
353  texCoord[i*2+1] = (fptr[1]-minY) / rangeY;
354  fptr+=2;
355  }
356  }
357  else // this->TextureProperties & vtkContextDevice2D::Stretch
358  {
359  float rangeX = (maxX - minX)? maxX - minX : 1.f;
360  float rangeY = (maxY - minY)? maxY - minY : 1.f;
361  for (int i = 0; i < n; ++i)
362  {
363  texCoord[i*2] = (fptr[0]-minX)/rangeX;
364  texCoord[i*2+1] = (fptr[1]-minY)/rangeY;
365  fptr+=2;
366  }
367  }
368  return texCoord;
369  }
370 
372  {
373  vtkVector2i pow2(1, 1);
374  for (int i = 0; i < 2; ++i)
375  {
376  while (pow2[i] < size[i])
377  {
378  pow2[i] *= 2;
379  }
380  }
381  return pow2;
382  }
383 
385  {
386  if (image->GetScalarType() != VTK_UNSIGNED_CHAR)
387  {
388  cout << "Error = not an unsigned char..." << endl;
389  return 0;
390  }
391  int bytesPerPixel = image->GetNumberOfScalarComponents();
392  int size[3];
393  image->GetDimensions(size);
394  vtkVector2i newImg = this->FindPowerOfTwo(vtkVector2i(size[0], size[1]));
395 
396  for (int i = 0; i < 2; ++i)
397  {
398  texCoords[i] = size[i] / float(newImg[i]);
399  }
400 
401  unsigned char *dataPtr =
402  new unsigned char[newImg[0] * newImg[1] * bytesPerPixel];
403  unsigned char *origPtr =
404  static_cast<unsigned char*>(image->GetScalarPointer());
405 
406  for (int i = 0; i < newImg[0]; ++i)
407  {
408  for (int j = 0; j < newImg[1]; ++j)
409  {
410  for (int k = 0; k < bytesPerPixel; ++k)
411  {
412  if (i < size[0] && j < size[1])
413  {
414  dataPtr[i * bytesPerPixel + j * newImg[0] * bytesPerPixel + k] =
415  origPtr[i * bytesPerPixel + j * size[0] * bytesPerPixel + k];
416  }
417  else
418  {
419  dataPtr[i * bytesPerPixel + j * newImg[0] * bytesPerPixel + k] =
420  k == 3 ? 0 : 255;
421  }
422  }
423  }
424  }
425 
426  GLuint tmpIndex(0);
427  GLint glFormat = bytesPerPixel == 3 ? GL_RGB : GL_RGBA;
428  GLint glInternalFormat = bytesPerPixel == 3 ? GL_RGB8 : GL_RGBA8;
429 
430  glGenTextures(1, &tmpIndex);
431  glBindTexture(GL_TEXTURE_2D, tmpIndex);
432 
433  glTexEnvf(GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, GL_REPLACE);
434  glTexEnvf(GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, GL_REPLACE);
435 
436  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
437  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
438  glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
440  glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
442 
443  glTexImage2D(GL_TEXTURE_2D, 0 , glInternalFormat,
444  newImg[0], newImg[1], 0, glFormat,
445  GL_UNSIGNED_BYTE, static_cast<const GLvoid *>(dataPtr));
446  glAlphaFunc(GL_GREATER, static_cast<GLclampf>(0));
447  glEnable(GL_ALPHA_TEST);
448  glMatrixMode(GL_TEXTURE);
449  glLoadIdentity();
450  glMatrixMode(GL_MODELVIEW);
451  glEnable(GL_TEXTURE_2D);
452  delete [] dataPtr;
453  return tmpIndex;
454  }
455 
457  {
458  if (image->GetScalarType() != VTK_UNSIGNED_CHAR)
459  {
460  cout << "Error = not an unsigned char..." << endl;
461  return 0;
462  }
463  int bytesPerPixel = image->GetNumberOfScalarComponents();
464  int size[3];
465  image->GetDimensions(size);
466 
467  unsigned char *dataPtr =
468  static_cast<unsigned char*>(image->GetScalarPointer());
469  GLuint tmpIndex(0);
470  GLint glFormat = bytesPerPixel == 3 ? GL_RGB : GL_RGBA;
471  GLint glInternalFormat = bytesPerPixel == 3 ? GL_RGB8 : GL_RGBA8;
472 
473  glGenTextures(1, &tmpIndex);
474  glBindTexture(GL_TEXTURE_2D, tmpIndex);
475 
476  glTexEnvf(GL_TEXTURE_ENV, vtkgl::COMBINE_RGB, GL_REPLACE);
477  glTexEnvf(GL_TEXTURE_ENV, vtkgl::COMBINE_ALPHA, GL_REPLACE);
478 
479  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
480  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
481  glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
483  glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
485 
486  glTexImage2D(GL_TEXTURE_2D, 0 , glInternalFormat,
487  size[0], size[1], 0, glFormat,
488  GL_UNSIGNED_BYTE, static_cast<const GLvoid *>(dataPtr));
489  glAlphaFunc(GL_GREATER, static_cast<GLclampf>(0));
490  glEnable(GL_ALPHA_TEST);
491  glMatrixMode(GL_TEXTURE);
492  glLoadIdentity();
493  glMatrixMode(GL_MODELVIEW);
494  glEnable(GL_TEXTURE_2D);
495  return tmpIndex;
496  }
497 
499  unsigned int TextureProperties;
501  // Store the previous GL state so that we can restore it when complete
508  GLfloat SavedClearColor[4];
509 
514  bool OpenGL15;
515  bool OpenGL20;
516  bool GLSL;
518 
520 
524 };
526 
527 #endif // VTKOPENGLCONTEXTDEVICE2DPRIVATE_H
528 // VTK-HeaderTest-Exclude: vtkOpenGLContextDevice2DPrivate.h
GLsizeiptr size
Definition: vtkgl.h:11843
TextPropertyKey(vtkTextProperty *textProperty, const StringType &text)
std::list< CacheElement > Cache
bool operator==(const CacheElement &other) const
GLclampf f
Definition: vtkgl.h:14181
const GLint * first
Definition: vtkgl.h:11686
GLenum GLsizei GLenum GLenum const GLvoid * image
Definition: vtkgl.h:11341
void SetGLCapability(GLenum capability, GLboolean state)
double * GetBounds()
typedef GLuint(APIENTRYP PFNGLCREATEPROGRAMPROC)(void)
static int GetNumberOfScalarComponents(vtkInformation *meta_data)
GLuint TextureFromImage(vtkImageData *image, vtkVector2f &texCoords)
bool IsKeyInCache(const Key &key) const
typedef GLboolean(APIENTRYP PFNGLISQUERYPROC)(GLuint id)
static vtkSmartPointer< T > New()
CacheElement(const Key &key, const CacheData &cacheData)
void SetInputData(vtkDataObject *)
void ReleaseGraphicsResources(vtkWindow *window)
vtkSmartPointer< vtkImageData > ImageData
bool operator==(const TextPropertyKey &other) const
TextPropertyKey< vtkStdString > UTF8TextPropertyKey
window superclass for vtkRenderWindow
Definition: vtkWindow.h:33
virtual int * GetDimensions()
static int GetScalarType(vtkInformation *meta_data)
topologically and geometrically regular array of data
Definition: vtkImageData.h:44
vtkImageData * GetInput()
CacheData & GetCacheData(const Key &key)
void Set(const T &red, const T &green, const T &blue)
Definition: vtkColor.h:123
handles properties associated with a texture map
Definition: vtkTexture.h:69
virtual double GetOpacity()
represent text properties.
static vtkFreeTypeTools * GetInstance()
vtkTextureImageCache< UTF16TextPropertyKey > TextTextureCache
static unsigned int GetIdFromTextProperty(vtkTextProperty *textProperty)
typedef GLint(APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program
virtual double * GetColor()
#define VTK_UNSIGNED_CHAR
Definition: vtkType.h:28
typedef GLenum(APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target)
void MapTextPropertyToId(vtkTextProperty *tprop, unsigned long *tprop_cache_id)
virtual void * GetScalarPointer(int coordinates[3])
GLuint color
Definition: vtkgl.h:12351
GLclampd n
Definition: vtkgl.h:14370
vtkVector2i FindPowerOfTwo(const vtkVector2i &size)
virtual int GetFontSize()
TextPropertyKey< vtkUnicodeString > UTF16TextPropertyKey
CacheData & AddCacheData(const Key &key, const CacheData &cacheData)
GLuint id
Definition: vtkgl.h:11834
const GLenum COMBINE_RGB
Definition: vtkgl.h:11570
const GLenum CLAMP_TO_EDGE
Definition: vtkgl.h:11303
virtual void Delete()
const GLenum COMBINE_ALPHA
Definition: vtkgl.h:11571
vtkTextureImageCache< UTF8TextPropertyKey > MathTextTextureCache