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