0024590: Crash when processing OpenGl_BndBoxPrs objects
[occt.git] / src / OpenGl / OpenGl_Text.cxx
1 // Created on: 2011-07-13
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2013 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and / or modify it
8 // under the terms of the GNU Lesser General Public version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <OpenGl_AspectText.hxx>
17 #include <OpenGl_GlCore11.hxx>
18 #include <OpenGl_GraphicDriver.hxx>
19 #include <OpenGl_ShaderManager.hxx>
20 #include <OpenGl_ShaderProgram.hxx>
21 #include <OpenGl_ShaderStates.hxx>
22 #include <OpenGl_Text.hxx>
23 #include <OpenGl_Workspace.hxx>
24
25 #include <Font_FontMgr.hxx>
26 #include <TCollection_HAsciiString.hxx>
27
28 #ifdef HAVE_CONFIG_H
29   #include <config.h>
30 #endif
31
32 #ifdef HAVE_GL2PS
33   #include <gl2ps.h>
34 #endif
35
36 namespace
37 {
38   static const GLdouble THE_IDENTITY_MATRIX[4][4] =
39   {
40     {1.,0.,0.,0.},
41     {0.,1.,0.,0.},
42     {0.,0.,1.,0.},
43     {0.,0.,0.,1.}
44   };
45
46 #ifdef HAVE_GL2PS
47   static char const* TheFamily[] = {"Helvetica", "Courier", "Times"};
48   static char const* TheItalic[] = {"Oblique",   "Oblique", "Italic"};
49   static char const* TheBase[]   = {"", "", "-Roman"};
50
51   //! Convert font name used for rendering to some "good" font names
52   //! that produce good vector text.
53   static void getGL2PSFontName (const char* theSrcFont,
54                                 char*       thePsFont)
55   {
56     if (strstr (theSrcFont, "Symbol"))
57     {
58       sprintf (thePsFont, "%s", "Symbol");
59       return;
60     }
61     else if (strstr (theSrcFont, "ZapfDingbats"))
62     {
63       sprintf (thePsFont, "%s", "WingDings");
64       return;
65     }
66
67     int  aFontId  = 0;
68     bool isBold   = false;
69     bool isItalic = false;
70     if (strstr (theSrcFont, "Courier"))
71     {
72       aFontId = 1;
73     }
74     else if (strstr (theSrcFont, "Times"))
75     {
76       aFontId = 2;
77     }
78
79     if (strstr (theSrcFont, "Bold"))
80     {
81       isBold = true;
82     }
83     if (strstr (theSrcFont, "Italic")
84      || strstr (theSrcFont, "Oblique"))
85     {
86       isItalic = true;
87     }
88
89     if (isBold)
90     {
91       if (isItalic)
92       {
93         sprintf (thePsFont, "%s-Bold%s", TheFamily[aFontId], TheItalic[aFontId]);
94       }
95       else
96       {
97         sprintf (thePsFont, "%s-Bold", TheFamily[aFontId]);
98       }
99     }
100     else if (isItalic)
101     {
102       sprintf (thePsFont, "%s-%s", TheFamily[aFontId], TheItalic[aFontId]);
103     }
104     else
105     {
106       sprintf (thePsFont, "%s%s", TheFamily[aFontId], TheBase[aFontId]);
107     }
108   }
109
110   static void exportText (const NCollection_String& theText,
111                           const Standard_Boolean    theIs2d,
112                           const OpenGl_AspectText&  theAspect,
113                           const Standard_Integer    theHeight)
114   {
115
116     char aPsFont[64];
117     getGL2PSFontName (theAspect.FontName().ToCString(), aPsFont);
118
119     if (theIs2d)
120     {
121       glRasterPos2f (0.0f, 0.0f);
122     }
123     else
124     {
125       glRasterPos3f (0.0f, 0.0f, 0.0f);
126     }
127
128     GLubyte aZero = 0;
129     glBitmap (1, 1, 0, 0, 0, 0, &aZero);
130
131     // Standard GL2PS's alignment isn't used, because it doesn't work correctly
132     // for all formats, therefore alignment is calculated manually relative
133     // to the bottom-left corner, which corresponds to the GL2PS_TEXT_BL value
134     gl2psTextOpt (theText.ToCString(), aPsFont, (GLshort)theHeight, GL2PS_TEXT_BL, theAspect.Angle());
135   }
136 #endif
137
138 };
139
140 // =======================================================================
141 // function : OpenGl_Text
142 // purpose  :
143 // =======================================================================
144 OpenGl_Text::OpenGl_Text()
145 : myWinX (0.0f),
146   myWinY (0.0f),
147   myWinZ (0.0f),
148   myScaleHeight (1.0f),
149   myPoint  (0.0f, 0.0f, 0.0f),
150   myIs2d   (false)
151 {
152   myParams.Height = 10;
153   myParams.HAlign = Graphic3d_HTA_LEFT;
154   myParams.VAlign = Graphic3d_VTA_BOTTOM;
155 }
156
157 // =======================================================================
158 // function : OpenGl_Text
159 // purpose  :
160 // =======================================================================
161 OpenGl_Text::OpenGl_Text (const TCollection_ExtendedString& theText,
162                           const OpenGl_Vec3&                thePoint,
163                           const OpenGl_TextParam&           theParams)
164 : myWinX (0.0f),
165   myWinY (0.0f),
166   myWinZ (0.0f),
167   myScaleHeight  (1.0f),
168   myExportHeight (1.0f),
169   myParams (theParams),
170   myString ((Standard_Utf16Char* )theText.ToExtString()),
171   myPoint  (thePoint),
172   myIs2d   (false)
173 {
174   //
175 }
176
177 // =======================================================================
178 // function : SetPosition
179 // purpose  :
180 // =======================================================================
181 void OpenGl_Text::SetPosition (const OpenGl_Vec3& thePoint)
182 {
183   myPoint = thePoint;
184 }
185
186 // =======================================================================
187 // function : SetFontSize
188 // purpose  :
189 // =======================================================================
190 void OpenGl_Text::SetFontSize (const Handle(OpenGl_Context)& theCtx,
191                                const Standard_Integer        theFontSize)
192 {
193   if (myParams.Height != theFontSize)
194   {
195     Release (theCtx);
196   }
197   myParams.Height = theFontSize;
198 }
199
200 // =======================================================================
201 // function : Init
202 // purpose  :
203 // =======================================================================
204 void OpenGl_Text::Init (const Handle(OpenGl_Context)& theCtx,
205                         const Standard_Utf8Char*      theText,
206                         const OpenGl_Vec3&            thePoint)
207 {
208   releaseVbos (theCtx);
209   myIs2d   = false;
210   myPoint  = thePoint;
211   myString.FromUnicode (theText);
212 }
213
214 // =======================================================================
215 // function : Init
216 // purpose  :
217 // =======================================================================
218 void OpenGl_Text::Init (const Handle(OpenGl_Context)& theCtx,
219                         const Standard_Utf8Char*      theText,
220                         const OpenGl_Vec3&            thePoint,
221                         const OpenGl_TextParam&       theParams)
222 {
223   if (myParams.Height != theParams.Height)
224   {
225     Release (theCtx);
226   }
227   else
228   {
229     releaseVbos (theCtx);
230   }
231   myIs2d   = false;
232   myParams = theParams;
233   myPoint  = thePoint;
234   myString.FromUnicode (theText);
235 }
236
237 // =======================================================================
238 // function : Init
239 // purpose  :
240 // =======================================================================
241 void OpenGl_Text::Init (const Handle(OpenGl_Context)&     theCtx,
242                         const TCollection_ExtendedString& theText,
243                         const OpenGl_Vec2&                thePoint,
244                         const OpenGl_TextParam&           theParams)
245 {
246   if (myParams.Height != theParams.Height)
247   {
248     Release (theCtx);
249   }
250   else
251   {
252     releaseVbos (theCtx);
253   }
254   myIs2d       = true;
255   myParams     = theParams;
256   myPoint.xy() = thePoint;
257   myPoint.z()  = 0.0f;
258   myString.FromUnicode ((Standard_Utf16Char* )theText.ToExtString());
259 }
260
261 // =======================================================================
262 // function : ~OpenGl_Text
263 // purpose  :
264 // =======================================================================
265 OpenGl_Text::~OpenGl_Text()
266 {
267   //
268 }
269
270 // =======================================================================
271 // function : releaseVbos
272 // purpose  :
273 // =======================================================================
274 void OpenGl_Text::releaseVbos (const Handle(OpenGl_Context)& theCtx)
275 {
276   for (Standard_Integer anIter = 0; anIter < myVertsVbo.Length(); ++anIter)
277   {
278     Handle(OpenGl_VertexBuffer)& aVerts = myVertsVbo.ChangeValue (anIter);
279     Handle(OpenGl_VertexBuffer)& aTCrds = myTCrdsVbo.ChangeValue (anIter);
280
281     if (!theCtx.IsNull())
282     {
283       theCtx->DelayedRelease (aVerts);
284       theCtx->DelayedRelease (aTCrds);
285     }
286     aVerts.Nullify();
287     aTCrds.Nullify();
288   }
289   myTextures.Clear();
290   myVertsVbo.Clear();
291   myTCrdsVbo.Clear();
292   myVertsArray.Clear();
293   myTCrdsArray.Clear();
294 }
295
296 // =======================================================================
297 // function : Release
298 // purpose  :
299 // =======================================================================
300 void OpenGl_Text::Release (const Handle(OpenGl_Context)& theCtx)
301 {
302   releaseVbos (theCtx);
303   if (!myFont.IsNull())
304   {
305     Handle(OpenGl_Context) aCtx = theCtx;
306     const TCollection_AsciiString aKey = myFont->ResourceKey();
307     myFont.Nullify();
308     aCtx->ReleaseResource (aKey, Standard_True);
309   }
310 }
311
312 // =======================================================================
313 // function : StringSize
314 // purpose  :
315 // =======================================================================
316 void OpenGl_Text::StringSize (const Handle(OpenGl_Context)& theCtx,
317                               const NCollection_String&     theText,
318                               const OpenGl_AspectText&      theTextAspect,
319                               const OpenGl_TextParam&       theParams,
320                               Standard_ShortReal&           theWidth,
321                               Standard_ShortReal&           theAscent,
322                               Standard_ShortReal&           theDescent)
323 {
324   theWidth   = 0.0f;
325   theAscent  = 0.0f;
326   theDescent = 0.0f;
327   const TCollection_AsciiString aFontKey = FontKey (theTextAspect, theParams.Height);
328   Handle(OpenGl_Font) aFont = FindFont (theCtx, theTextAspect, theParams.Height, aFontKey);
329   if (aFont.IsNull() || !aFont->IsValid())
330   {
331     return;
332   }
333
334   theAscent  = aFont->Ascender();
335   theDescent = aFont->Descender();
336
337   GLfloat aWidth = 0.0f;
338   for (NCollection_Utf8Iter anIter = theText.Iterator(); *anIter != 0;)
339   {
340     const Standard_Utf32Char aCharThis =   *anIter;
341     const Standard_Utf32Char aCharNext = *++anIter;
342
343     if (aCharThis == '\x0D' // CR  (carriage return)
344      || aCharThis == '\a'   // BEL (alarm)
345      || aCharThis == '\f'   // FF  (form feed) NP (new page)
346      || aCharThis == '\b'   // BS  (backspace)
347      || aCharThis == '\v')  // VT  (vertical tab)
348     {
349       continue; // skip unsupported carriage control codes
350     }
351     else if (aCharThis == '\x0A') // LF (line feed, new line)
352     {
353       theWidth = Max (theWidth, aWidth);
354       aWidth   = 0.0f;
355       continue;
356     }
357     else if (aCharThis == ' ')
358     {
359       aWidth += aFont->AdvanceX (aCharThis, aCharNext);
360       continue;
361     }
362     else if (aCharThis == '\t')
363     {
364       aWidth += aFont->AdvanceX (' ', aCharNext) * 8.0f;
365       continue;
366     }
367
368     aWidth += aFont->AdvanceX (aCharThis, aCharNext);
369   }
370   theWidth = Max (theWidth, aWidth);
371
372   Handle(OpenGl_Context) aCtx = theCtx;
373   aFont.Nullify();
374   aCtx->ReleaseResource (aFontKey, Standard_True);
375 }
376
377 // =======================================================================
378 // function : Render
379 // purpose  :
380 // =======================================================================
381 void OpenGl_Text::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
382 {
383   const OpenGl_AspectText* aTextAspect = theWorkspace->AspectText (Standard_True);
384   const Handle(OpenGl_Texture) aPrevTexture = theWorkspace->DisableTexture();
385
386   const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
387
388   if (aCtx->IsGlGreaterEqual (2, 0))
389   {
390     Handle(OpenGl_ShaderProgram) aProgram = aTextAspect->ShaderProgramRes (theWorkspace);
391
392     if (!aProgram.IsNull())
393     {
394       aProgram->BindWithVariables (aCtx);
395
396       const OpenGl_MaterialState* aMaterialState = aCtx->ShaderManager()->MaterialState (aProgram);
397
398       if (aMaterialState == NULL || aMaterialState->Aspect() != aTextAspect)
399         aCtx->ShaderManager()->UpdateMaterialStateTo (aProgram, aTextAspect);
400
401       aCtx->ShaderManager()->PushState (aProgram);
402     }
403     else
404     {
405       OpenGl_ShaderProgram::Unbind (aCtx);
406     }
407   }
408
409   // use highlight color or colors from aspect
410   if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
411   {
412     render (theWorkspace->PrinterContext(),
413             aCtx,
414             *aTextAspect,
415             *theWorkspace->HighlightColor,
416             *theWorkspace->HighlightColor);
417   }
418   else
419   {
420     render (theWorkspace->PrinterContext(),
421             aCtx,
422             *aTextAspect,
423             aTextAspect->Color(),
424             aTextAspect->SubtitleColor());
425   }
426
427   // restore aspects
428   if (!aPrevTexture.IsNull())
429   {
430     theWorkspace->EnableTexture (aPrevTexture);
431   }
432 }
433
434 // =======================================================================
435 // function : Render
436 // purpose  :
437 // =======================================================================
438 void OpenGl_Text::Render (const Handle(OpenGl_PrinterContext)& thePrintCtx,
439                           const Handle(OpenGl_Context)&        theCtx,
440                           const OpenGl_AspectText&             theTextAspect) const
441 {
442   render (thePrintCtx, theCtx, theTextAspect, theTextAspect.Color(), theTextAspect.SubtitleColor());
443 }
444
445 // =======================================================================
446 // function : setupMatrix
447 // purpose  :
448 // =======================================================================
449 void OpenGl_Text::setupMatrix (const Handle(OpenGl_PrinterContext)& thePrintCtx,
450                                const Handle(OpenGl_Context)&        /*theCtx*/,
451                                const OpenGl_AspectText&             theTextAspect,
452                                const OpenGl_Vec3                    theDVec) const
453 {
454   // setup matrix
455   if (myIs2d)
456   {
457     glLoadIdentity();
458     glTranslatef (myPoint.x() + theDVec.x(), myPoint.y() + theDVec.y(), 0.0f);
459     glRotatef (180.0f, 1.0f, 0.0f, 0.0f);
460   }
461   else
462   {
463     // align coordinates to the nearest integer
464     // to avoid extra interpolation issues
465     GLdouble anObjX, anObjY, anObjZ;
466     gluUnProject (std::floor (myWinX + (GLdouble )theDVec.x()),
467                   std::floor (myWinY + (GLdouble )theDVec.y()),
468                   myWinZ + (GLdouble )theDVec.z(),
469                   (GLdouble* )THE_IDENTITY_MATRIX, myProjMatrix, myViewport,
470                   &anObjX, &anObjY, &anObjZ);
471
472     glLoadIdentity();
473     glTranslated (anObjX, anObjY, anObjZ);
474     glRotated (theTextAspect.Angle(), 0.0, 0.0, 1.0);
475     if (!theTextAspect.IsZoomable())
476     {
477     #ifdef _WIN32
478       // if the context has assigned printer context, use it's parameters
479       if (!thePrintCtx.IsNull())
480       {
481         // get printing scaling in x and y dimensions
482         GLfloat aTextScalex = 1.0f, aTextScaley = 1.0f;
483         thePrintCtx->GetScale (aTextScalex, aTextScaley);
484
485         // text should be scaled in all directions with same
486         // factor to save its proportions, so use height (y) scaling
487         // as it is better for keeping text/3d graphics proportions
488         glScalef (aTextScaley, aTextScaley, aTextScaley);
489       }
490     #endif
491       glScaled (myScaleHeight, myScaleHeight, myScaleHeight);
492     }
493   }
494 }
495
496 // =======================================================================
497 // function : drawText
498 // purpose  :
499 // =======================================================================
500
501 void OpenGl_Text::drawText (const Handle(OpenGl_PrinterContext)& ,
502                             const Handle(OpenGl_Context)&        theCtx,
503                           #ifdef HAVE_GL2PS
504                             const OpenGl_AspectText&             theTextAspect) const
505                           #else
506                             const OpenGl_AspectText&                          ) const
507                           #endif
508 {
509 #ifdef HAVE_GL2PS
510   if (theCtx->IsFeedback())
511   {
512     // position of the text and alignment is calculated by transformation matrix
513     exportText (myString, myIs2d, theTextAspect, (Standard_Integer )myExportHeight);
514     return;
515   }
516 #endif
517
518   if (myVertsVbo.Length() == myTextures.Length())
519   {
520     for (Standard_Integer anIter = 0; anIter < myTextures.Length(); ++anIter)
521     {
522       const GLuint aTexId = myTextures.Value (anIter);
523       const Handle(OpenGl_VertexBuffer)& aVerts = myVertsVbo.Value (anIter);
524       const Handle(OpenGl_VertexBuffer)& aTCrds = myTCrdsVbo.Value (anIter);
525       aVerts->BindFixed (theCtx, GL_VERTEX_ARRAY);
526       aTCrds->BindFixed (theCtx, GL_TEXTURE_COORD_ARRAY);
527       glBindTexture (GL_TEXTURE_2D, aTexId);
528
529       glDrawArrays (GL_TRIANGLES, 0, GLsizei(aVerts->GetElemsNb()));
530
531       glBindTexture (GL_TEXTURE_2D, 0);
532       aTCrds->UnbindFixed (theCtx, GL_TEXTURE_COORD_ARRAY);
533       aVerts->UnbindFixed (theCtx, GL_VERTEX_ARRAY);
534     }
535   }
536   else if (myVertsArray.Length() == myTextures.Length())
537   {
538     glEnableClientState (GL_VERTEX_ARRAY);
539     glEnableClientState (GL_TEXTURE_COORD_ARRAY);
540     for (Standard_Integer anIter = 0; anIter < myTextures.Length(); ++anIter)
541     {
542       const GLuint aTexId = myTextures.Value (anIter);
543       const Handle(OpenGl_Vec2Array)& aVerts = myVertsArray.Value (anIter);
544       const Handle(OpenGl_Vec2Array)& aTCrds = myTCrdsArray.Value (anIter);
545
546       glVertexPointer   (2, GL_FLOAT, 0, (GLfloat* )&aVerts->First());
547       glTexCoordPointer (2, GL_FLOAT, 0, (GLfloat* )&aTCrds->First());
548       glBindTexture (GL_TEXTURE_2D, aTexId);
549
550       glDrawArrays (GL_TRIANGLES, 0, aVerts->Length());
551
552       glBindTexture (GL_TEXTURE_2D, 0);
553     }
554     glDisableClientState (GL_TEXTURE_COORD_ARRAY);
555     glDisableClientState (GL_VERTEX_ARRAY);
556   }
557 }
558
559 // =======================================================================
560 // function : FontKey
561 // purpose  :
562 // =======================================================================
563 TCollection_AsciiString OpenGl_Text::FontKey (const OpenGl_AspectText& theAspect,
564                                               const Standard_Integer   theHeight)
565 {
566   const Font_FontAspect anAspect = (theAspect.FontAspect() != Font_FA_Undefined) ? theAspect.FontAspect() : Font_FA_Regular;
567   return theAspect.FontName()
568        + TCollection_AsciiString(":") + Standard_Integer(anAspect)
569        + TCollection_AsciiString(":") + theHeight;
570 }
571
572 // =======================================================================
573 // function : FindFont
574 // purpose  :
575 // =======================================================================
576 Handle(OpenGl_Font) OpenGl_Text::FindFont (const Handle(OpenGl_Context)& theCtx,
577                                            const OpenGl_AspectText&      theAspect,
578                                            const Standard_Integer        theHeight,
579                                            const TCollection_AsciiString theKey)
580 {
581   Handle(OpenGl_Font) aFont;
582   if (theHeight < 2)
583   {
584     return aFont; // invalid parameters
585   }
586
587   if (!theCtx->GetResource (theKey, aFont))
588   {
589     Handle(Font_FontMgr) aFontMgr = Font_FontMgr::GetInstance();
590     const Handle(TCollection_HAsciiString) aFontName = new TCollection_HAsciiString (theAspect.FontName());
591     const Font_FontAspect anAspect = (theAspect.FontAspect() != Font_FA_Undefined) ? theAspect.FontAspect() : Font_FA_Regular;
592     Handle(Font_SystemFont) aRequestedFont = aFontMgr->FindFont (aFontName, anAspect, theHeight);
593     if (aRequestedFont.IsNull())
594     {
595       return aFont;
596     }
597
598     Handle(Font_FTFont) aFontFt = new Font_FTFont (NULL);
599     if (!aFontFt->Init (aRequestedFont->FontPath()->ToCString(), theHeight))
600     {
601       return aFont;
602     }
603
604     Handle(OpenGl_Context) aCtx = theCtx;
605     glPushAttrib (GL_TEXTURE_BIT);
606     aFont = new OpenGl_Font (aFontFt, theKey);
607     if (!aFont->Init (aCtx))
608     {
609       //glPopAttrib();
610       //return aFont; // out of resources?
611     }
612     glPopAttrib(); // texture bit
613
614     aCtx->ShareResource (theKey, aFont);
615   }
616   return aFont;
617 }
618
619 // =======================================================================
620 // function : render
621 // purpose  :
622 // =======================================================================
623 void OpenGl_Text::render (const Handle(OpenGl_PrinterContext)& thePrintCtx,
624                           const Handle(OpenGl_Context)&        theCtx,
625                           const OpenGl_AspectText&             theTextAspect,
626                           const TEL_COLOUR&                    theColorText,
627                           const TEL_COLOUR&                    theColorSubs) const
628 {
629   if (myString.IsEmpty())
630   {
631     return;
632   }
633
634   const TCollection_AsciiString aFontKey = FontKey (theTextAspect, myParams.Height);
635   if (!myFont.IsNull()
636    && !myFont->ResourceKey().IsEqual (aFontKey))
637   {
638     // font changed
639     const_cast<OpenGl_Text* > (this)->Release (theCtx);
640   }
641
642   if (myFont.IsNull())
643   {
644     myFont = FindFont (theCtx, theTextAspect, myParams.Height, aFontKey);
645     if (myFont.IsNull())
646     {
647       return;
648     }
649   }
650
651   if (myTextures.IsEmpty())
652   {
653     OpenGl_TextFormatter aFormatter;
654     aFormatter.SetupAlignment (myParams.HAlign, myParams.VAlign);
655     aFormatter.Reset();
656     aFormatter.Append (theCtx, myString, *myFont.operator->());
657     aFormatter.Format();
658
659     if (!theCtx->caps->vboDisable && theCtx->core15 != NULL)
660     {
661       aFormatter.Result (theCtx, myTextures, myVertsVbo, myTCrdsVbo);
662     }
663     else
664     {
665       aFormatter.Result (theCtx, myTextures, myVertsArray, myTCrdsArray);
666     }
667     aFormatter.BndBox (myBndBox);
668   }
669
670   if (myTextures.IsEmpty())
671   {
672     return;
673   }
674
675   myExportHeight = 1.0f;
676   myScaleHeight  = 1.0f;
677
678   glMatrixMode (GL_MODELVIEW);
679   glPushMatrix();
680   if (!myIs2d)
681   {
682     // retrieve active matrices for project/unproject calls
683     glGetDoublev  (GL_MODELVIEW_MATRIX,  myModelMatrix);
684     glGetDoublev  (GL_PROJECTION_MATRIX, myProjMatrix);
685     glGetIntegerv (GL_VIEWPORT,          myViewport);
686     gluProject (myPoint.x(), myPoint.y(), myPoint.z(),
687                 myModelMatrix, myProjMatrix, myViewport,
688                 &myWinX, &myWinY, &myWinZ);
689
690     // compute scale factor for constant text height
691     GLdouble x1, y1, z1;
692     gluUnProject (myWinX, myWinY, myWinZ,
693                   (GLdouble* )THE_IDENTITY_MATRIX, myProjMatrix, myViewport,
694                   &x1, &y1, &z1);
695
696     GLdouble x2, y2, z2;
697     const GLdouble h = (GLdouble )myFont->FTFont()->PointSize();
698     gluUnProject (myWinX, myWinY + h - 1.0, myWinZ,
699                   (GLdouble* )THE_IDENTITY_MATRIX, myProjMatrix, myViewport,
700                   &x2, &y2, &z2);
701
702     myScaleHeight = (y2 - y1) / h;
703     if (theTextAspect.IsZoomable())
704     {
705       myExportHeight = (float )h;
706     }
707   }
708   myExportHeight = (float )myFont->FTFont()->PointSize() / myExportHeight;
709
710   // push enabled flags to the stack
711   glPushAttrib (GL_ENABLE_BIT);
712   glDisable (GL_LIGHTING);
713
714   // setup depth test
715   if (!myIs2d
716    && theTextAspect.StyleType() != Aspect_TOST_ANNOTATION)
717   {
718     glEnable (GL_DEPTH_TEST);
719   }
720   else
721   {
722     glDisable (GL_DEPTH_TEST);
723   }
724
725   // setup alpha test
726   GLint aTexEnvParam = GL_REPLACE;
727   glGetTexEnviv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &aTexEnvParam);
728   if (aTexEnvParam != GL_REPLACE)
729   {
730     glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
731   }
732   glAlphaFunc (GL_GEQUAL, 0.285f);
733   glEnable (GL_ALPHA_TEST);
734
735   // setup blending
736   glEnable (GL_BLEND);
737   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
738
739   // activate texture unit
740   glDisable (GL_TEXTURE_1D);
741   glEnable  (GL_TEXTURE_2D);
742   if (theCtx->core13 != NULL)
743   {
744     theCtx->core13->glActiveTexture (GL_TEXTURE0);
745   }
746
747   // extra drawings
748   switch (theTextAspect.DisplayType())
749   {
750     case Aspect_TODT_BLEND:
751     {
752       glEnable  (GL_COLOR_LOGIC_OP);
753       glLogicOp (GL_XOR);
754       break;
755     }
756     case Aspect_TODT_SUBTITLE:
757     {
758       glColor3fv  (theColorSubs.rgb);
759       setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (0.0f, 0.0f, 0.00001f));
760
761       glBindTexture (GL_TEXTURE_2D, 0);
762       glBegin (GL_QUADS);
763       glVertex2f (myBndBox.Left,  myBndBox.Top);
764       glVertex2f (myBndBox.Right, myBndBox.Top);
765       glVertex2f (myBndBox.Right, myBndBox.Bottom);
766       glVertex2f (myBndBox.Left,  myBndBox.Bottom);
767       glEnd();
768       break;
769     }
770     case Aspect_TODT_DEKALE:
771     {
772       glColor3fv  (theColorSubs.rgb);
773       setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (+1.0f, +1.0f, 0.00001f));
774       drawText    (thePrintCtx, theCtx, theTextAspect);
775       setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (-1.0f, -1.0f, 0.00001f));
776       drawText    (thePrintCtx, theCtx, theTextAspect);
777       setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (-1.0f, +1.0f, 0.00001f));
778       drawText    (thePrintCtx, theCtx, theTextAspect);
779       setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (+1.0f, -1.0f, 0.00001f));
780       drawText    (thePrintCtx, theCtx, theTextAspect);
781       break;
782     }
783     case Aspect_TODT_DIMENSION:
784     case Aspect_TODT_NORMAL:
785     {
786       break;
787     }
788   }
789
790   // main draw call
791   glColor3fv  (theColorText.rgb);
792   setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (0.0f, 0.0f, 0.0f));
793   drawText    (thePrintCtx, theCtx, theTextAspect);
794
795   glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, aTexEnvParam);
796
797   if (theTextAspect.DisplayType() == Aspect_TODT_DIMENSION)
798   {
799     setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (0.0f, 0.0f, 0.00001f));
800
801     glDisable (GL_BLEND);
802     glDisable (GL_TEXTURE_2D);
803     glDisable (GL_ALPHA_TEST);
804     if (!myIs2d)
805     {
806       glDisable (GL_DEPTH_TEST);
807     }
808     glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
809
810     glClear (GL_STENCIL_BUFFER_BIT);
811     glEnable (GL_STENCIL_TEST);
812     glStencilFunc (GL_ALWAYS, 1, 0xFF);
813     glStencilOp (GL_KEEP, GL_KEEP, GL_REPLACE);
814
815     glBegin (GL_QUADS);
816     glVertex2f (myBndBox.Left,  myBndBox.Top);
817     glVertex2f (myBndBox.Right, myBndBox.Top);
818     glVertex2f (myBndBox.Right, myBndBox.Bottom);
819     glVertex2f (myBndBox.Left,  myBndBox.Bottom);
820     glEnd();
821
822     glStencilFunc (GL_ALWAYS, 0, 0xFF);
823     // glPopAttrib() will reset state for us
824     //glDisable (GL_STENCIL_TEST);
825     //if (!myIs2d) glEnable (GL_DEPTH_TEST);
826
827     glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
828   }
829
830   // revert OpenGL state
831   glPopAttrib(); // enable bit
832   glPopMatrix(); // model view matrix was modified
833 }