0029286: Visualization, TKOpenGl - do not update FFP state when OpenGl_Caps::ffpEnabl...
[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_Workspace.hxx>
24 #include <OpenGl_View.hxx>
25 #include <OpenGl_VertexBufferCompat.hxx>
26
27 #include <Font_FontMgr.hxx>
28 #include <Font_FTFont.hxx>
29 #include <Graphic3d_TransformUtils.hxx>
30 #include <TCollection_HAsciiString.hxx>
31
32 #ifdef HAVE_GL2PS
33   #include <gl2ps.h>
34 #endif
35
36 namespace
37 {
38   static const GLdouble THE_IDENTITY_MATRIX[16] =
39   {
40     1.0, 0.0, 0.0, 0.0,
41     0.0, 1.0, 0.0, 0.0,
42     0.0, 0.0, 1.0, 0.0,
43     0.0, 0.0, 0.0, 1.0
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.Aspect()->Font().ToCString(), aPsFont);
118
119     (void)theIs2d;
120   #if !defined(GL_ES_VERSION_2_0)
121     if (theIs2d)
122     {
123       glRasterPos2f (0.0f, 0.0f);
124     }
125     else
126     {
127       glRasterPos3f (0.0f, 0.0f, 0.0f);
128     }
129
130     GLubyte aZero = 0;
131     glBitmap (1, 1, 0, 0, 0, 0, &aZero);
132   #endif
133
134     // Standard GL2PS's alignment isn't used, because it doesn't work correctly
135     // for all formats, therefore alignment is calculated manually relative
136     // to the bottom-left corner, which corresponds to the GL2PS_TEXT_BL value
137     gl2psTextOpt (theText.ToCString(), aPsFont, (GLshort)theHeight, GL2PS_TEXT_BL, (float )theAspect.Aspect()->GetTextAngle());
138   }
139 #endif
140
141 } // anonymous namespace
142
143 // =======================================================================
144 // function : OpenGl_Text
145 // purpose  :
146 // =======================================================================
147 OpenGl_Text::OpenGl_Text()
148 : myWinX (0.0f),
149   myWinY (0.0f),
150   myWinZ (0.0f),
151   myScaleHeight (1.0f),
152   myPoint  (0.0f, 0.0f, 0.0f),
153   myIs2d   (false),
154   myHasPlane (false),
155   myHasAnchorPoint (true)
156 {
157   myParams.Height = 10;
158   myParams.HAlign = Graphic3d_HTA_LEFT;
159   myParams.VAlign = Graphic3d_VTA_BOTTOM;
160 }
161
162 // =======================================================================
163 // function : OpenGl_Text
164 // purpose  :
165 // =======================================================================
166 OpenGl_Text::OpenGl_Text (const Standard_Utf8Char* theText,
167                           const OpenGl_Vec3&       thePoint,
168                           const OpenGl_TextParam&  theParams)
169 : myWinX (0.0f),
170   myWinY (0.0f),
171   myWinZ (0.0f),
172   myScaleHeight  (1.0f),
173   myExportHeight (1.0f),
174   myParams (theParams),
175   myString (theText),
176   myPoint  (thePoint),
177   myIs2d   (false),
178   myHasPlane (false),
179   myHasAnchorPoint (true)
180 {
181   //
182 }
183
184 // =======================================================================
185 // function : OpenGl_Text
186 // purpose  :
187 // =======================================================================
188 OpenGl_Text::OpenGl_Text (const Standard_Utf8Char* theText,
189                           const gp_Ax2&            theOrientation,
190                           const OpenGl_TextParam&  theParams,
191                           const bool               theHasOwnAnchor)
192 : myWinX         (0.0),
193   myWinY         (0.0),
194   myWinZ         (0.0),
195   myScaleHeight  (1.0),
196   myExportHeight (1.0),
197   myParams       (theParams),
198   myString       (theText),
199   myIs2d         (false),
200   myOrientation  (theOrientation),
201   myHasPlane     (true),
202   myHasAnchorPoint (theHasOwnAnchor)
203 {
204   const gp_Pnt& aPoint = theOrientation.Location();
205   myPoint = OpenGl_Vec3 (static_cast<Standard_ShortReal> (aPoint.X()),
206                          static_cast<Standard_ShortReal> (aPoint.Y()),
207                          static_cast<Standard_ShortReal> (aPoint.Z()));
208 }
209
210 // =======================================================================
211 // function : SetPosition
212 // purpose  :
213 // =======================================================================
214 void OpenGl_Text::SetPosition (const OpenGl_Vec3& thePoint)
215 {
216   myPoint = thePoint;
217 }
218
219 // =======================================================================
220 // function : SetFontSize
221 // purpose  :
222 // =======================================================================
223 void OpenGl_Text::SetFontSize (const Handle(OpenGl_Context)& theCtx,
224                                const Standard_Integer        theFontSize)
225 {
226   if (myParams.Height != theFontSize)
227   {
228     Release (theCtx.operator->());
229   }
230   myParams.Height = theFontSize;
231 }
232
233 // =======================================================================
234 // function : Init
235 // purpose  :
236 // =======================================================================
237 void OpenGl_Text::Init (const Handle(OpenGl_Context)& theCtx,
238                         const Standard_Utf8Char*      theText,
239                         const OpenGl_Vec3&            thePoint)
240 {
241   releaseVbos (theCtx.operator->());
242   myIs2d   = false;
243   myPoint  = thePoint;
244   myString.FromUnicode (theText);
245 }
246
247 // =======================================================================
248 // function : Init
249 // purpose  :
250 // =======================================================================
251 void OpenGl_Text::Init (const Handle(OpenGl_Context)& theCtx,
252                         const Standard_Utf8Char*      theText,
253                         const OpenGl_Vec3&            thePoint,
254                         const OpenGl_TextParam&       theParams)
255 {
256   if (myParams.Height != theParams.Height)
257   {
258     Release (theCtx.operator->());
259   }
260   else
261   {
262     releaseVbos (theCtx.operator->());
263   }
264   myIs2d   = false;
265   myParams = theParams;
266   myPoint  = thePoint;
267   myString.FromUnicode (theText);
268 }
269
270 // =======================================================================
271 // function : Init
272 // purpose  :
273 // =======================================================================
274 void OpenGl_Text::Init (const Handle(OpenGl_Context)&     theCtx,
275                         const TCollection_ExtendedString& theText,
276                         const OpenGl_Vec2&                thePoint,
277                         const OpenGl_TextParam&           theParams)
278 {
279   if (myParams.Height != theParams.Height)
280   {
281     Release (theCtx.operator->());
282   }
283   else
284   {
285     releaseVbos (theCtx.operator->());
286   }
287   myIs2d       = true;
288   myParams     = theParams;
289   myPoint.xy() = thePoint;
290   myPoint.z()  = 0.0f;
291   myString.FromUnicode (theText.ToExtString());
292 }
293
294 // =======================================================================
295 // function : ~OpenGl_Text
296 // purpose  :
297 // =======================================================================
298 OpenGl_Text::~OpenGl_Text()
299 {
300   //
301 }
302
303 // =======================================================================
304 // function : releaseVbos
305 // purpose  :
306 // =======================================================================
307 void OpenGl_Text::releaseVbos (OpenGl_Context* theCtx)
308 {
309   for (Standard_Integer anIter = 0; anIter < myVertsVbo.Length(); ++anIter)
310   {
311     Handle(OpenGl_VertexBuffer)& aVerts = myVertsVbo.ChangeValue (anIter);
312     Handle(OpenGl_VertexBuffer)& aTCrds = myTCrdsVbo.ChangeValue (anIter);
313
314     if (theCtx != NULL)
315     {
316       theCtx->DelayedRelease (aVerts);
317       theCtx->DelayedRelease (aTCrds);
318     }
319     aVerts.Nullify();
320     aTCrds.Nullify();
321   }
322   if (theCtx != NULL
323   && !myBndVertsVbo.IsNull())
324   {
325     theCtx->DelayedRelease (myBndVertsVbo);
326   }
327
328   myTextures.Clear();
329   myVertsVbo.Clear();
330   myTCrdsVbo.Clear();
331   myBndVertsVbo.Nullify();
332 }
333
334 // =======================================================================
335 // function : Release
336 // purpose  :
337 // =======================================================================
338 void OpenGl_Text::Release (OpenGl_Context* theCtx)
339 {
340   releaseVbos (theCtx);
341   if (!myFont.IsNull())
342   {
343     const TCollection_AsciiString aKey = myFont->ResourceKey();
344     myFont.Nullify();
345     if (theCtx != NULL)
346     {
347       theCtx->ReleaseResource (aKey, Standard_True);
348     }
349   }
350 }
351
352 // =======================================================================
353 // function : StringSize
354 // purpose  :
355 // =======================================================================
356 void OpenGl_Text::StringSize (const Handle(OpenGl_Context)& theCtx,
357                               const NCollection_String&     theText,
358                               const OpenGl_AspectText&      theTextAspect,
359                               const OpenGl_TextParam&       theParams,
360                               const unsigned int            theResolution,
361                               Standard_ShortReal&           theWidth,
362                               Standard_ShortReal&           theAscent,
363                               Standard_ShortReal&           theDescent)
364 {
365   theWidth   = 0.0f;
366   theAscent  = 0.0f;
367   theDescent = 0.0f;
368   const TCollection_AsciiString aFontKey = FontKey (theTextAspect, theParams.Height, theResolution);
369   Handle(OpenGl_Font) aFont = FindFont (theCtx, theTextAspect, theParams.Height, theResolution, aFontKey);
370   if (aFont.IsNull() || !aFont->IsValid())
371   {
372     return;
373   }
374
375   theAscent  = aFont->Ascender();
376   theDescent = aFont->Descender();
377
378   GLfloat aWidth = 0.0f;
379   for (NCollection_Utf8Iter anIter = theText.Iterator(); *anIter != 0;)
380   {
381     const Standard_Utf32Char aCharThis =   *anIter;
382     const Standard_Utf32Char aCharNext = *++anIter;
383
384     if (aCharThis == '\x0D' // CR  (carriage return)
385      || aCharThis == '\a'   // BEL (alarm)
386      || aCharThis == '\f'   // FF  (form feed) NP (new page)
387      || aCharThis == '\b'   // BS  (backspace)
388      || aCharThis == '\v')  // VT  (vertical tab)
389     {
390       continue; // skip unsupported carriage control codes
391     }
392     else if (aCharThis == '\x0A') // LF (line feed, new line)
393     {
394       theWidth = Max (theWidth, aWidth);
395       aWidth   = 0.0f;
396       continue;
397     }
398     else if (aCharThis == ' ')
399     {
400       aWidth += aFont->FTFont()->AdvanceX (aCharThis, aCharNext);
401       continue;
402     }
403     else if (aCharThis == '\t')
404     {
405       aWidth += aFont->FTFont()->AdvanceX (' ', aCharNext) * 8.0f;
406       continue;
407     }
408
409     aWidth += aFont->FTFont()->AdvanceX (aCharThis, aCharNext);
410   }
411   theWidth = Max (theWidth, aWidth);
412
413   Handle(OpenGl_Context) aCtx = theCtx;
414   aFont.Nullify();
415   aCtx->ReleaseResource (aFontKey, Standard_True);
416 }
417
418 // =======================================================================
419 // function : Render
420 // purpose  :
421 // =======================================================================
422 void OpenGl_Text::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
423 {
424   const OpenGl_AspectText*      aTextAspect  = theWorkspace->ApplyAspectText();
425   const Handle(OpenGl_Context)& aCtx         = theWorkspace->GetGlContext();
426   const Handle(OpenGl_TextureSet) aPrevTexture = aCtx->BindTextures (Handle(OpenGl_TextureSet)());
427 #if !defined(GL_ES_VERSION_2_0)
428   const Standard_Integer aPrevPolygonMode  = aCtx->SetPolygonMode (GL_FILL);
429   const bool             aPrevHatchingMode = aCtx->SetPolygonHatchEnabled (false);
430 #endif
431
432   // Bind custom shader program or generate default version
433   aCtx->ShaderManager()->BindFontProgram (aTextAspect->ShaderProgramRes (aCtx));
434
435   myOrientationMatrix = theWorkspace->View()->Camera()->OrientationMatrix();
436   myProjMatrix.Convert (aCtx->ProjectionState.Current());
437
438   // use highlight color or colors from aspect
439   render (aCtx,
440           *aTextAspect,
441           theWorkspace->TextColor(),
442           theWorkspace->TextSubtitleColor(),
443           aCtx->Resolution());
444
445   // restore aspects
446   if (!aPrevTexture.IsNull())
447   {
448     aCtx->BindTextures (aPrevTexture);
449   }
450 #if !defined(GL_ES_VERSION_2_0)
451   aCtx->SetPolygonMode         (aPrevPolygonMode);
452   aCtx->SetPolygonHatchEnabled (aPrevHatchingMode);
453 #endif
454
455   // restore Z buffer settings
456   if (theWorkspace->UseZBuffer())
457   {
458     glEnable (GL_DEPTH_TEST);
459   }
460 }
461
462 // =======================================================================
463 // function : Render
464 // purpose  :
465 // =======================================================================
466 void OpenGl_Text::Render (const Handle(OpenGl_Context)& theCtx,
467                           const OpenGl_AspectText&      theTextAspect,
468                           const unsigned int            theResolution) const
469 {
470   render (theCtx, theTextAspect,
471           theTextAspect.Aspect()->ColorRGBA(),
472           theTextAspect.Aspect()->ColorSubTitleRGBA(),
473           theResolution);
474 }
475
476 // =======================================================================
477 // function : setupMatrix
478 // purpose  :
479 // =======================================================================
480 void OpenGl_Text::setupMatrix (const Handle(OpenGl_Context)& theCtx,
481                                const OpenGl_AspectText&      theTextAspect,
482                                const OpenGl_Vec3             theDVec) const
483 {
484   OpenGl_Mat4d aModViewMat;
485   OpenGl_Mat4d aProjectMat;
486   if (myHasPlane && myHasAnchorPoint)
487   {
488     aProjectMat = myProjMatrix * myOrientationMatrix;
489   }
490   else
491   {
492     aProjectMat = myProjMatrix;
493   }
494
495   if (myIs2d)
496   {
497     Graphic3d_TransformUtils::Translate<GLdouble> (aModViewMat, myPoint.x() + theDVec.x(), myPoint.y() + theDVec.y(), 0.f);
498     Graphic3d_TransformUtils::Scale<GLdouble> (aModViewMat, 1.f, -1.f, 1.f);
499     Graphic3d_TransformUtils::Rotate<GLdouble> (aModViewMat, theTextAspect.Aspect()->GetTextAngle(), 0.f, 0.f, 1.f);
500   }
501   else
502   {
503     // align coordinates to the nearest integer
504     // to avoid extra interpolation issues
505     GLdouble anObjX, anObjY, anObjZ;
506     Graphic3d_TransformUtils::UnProject<Standard_Real> (std::floor (myWinX + theDVec.x()),
507                                                         std::floor (myWinY + theDVec.y()),
508                                                         myWinZ + theDVec.z(),
509                                                         OpenGl_Mat4d::Map (THE_IDENTITY_MATRIX),
510                                                         OpenGl_Mat4d::Map (aProjectMat),
511                                                         theCtx->Viewport(),
512                                                         anObjX,
513                                                         anObjY,
514                                                         anObjZ);
515
516     if (myHasPlane)
517     {
518       const gp_Dir& aVectorDir   = myOrientation.XDirection();
519       const gp_Dir& aVectorUp    = myOrientation.Direction();
520       const gp_Dir& aVectorRight = myOrientation.YDirection();
521
522       aModViewMat.SetColumn (2, OpenGl_Vec3d (aVectorUp.X(), aVectorUp.Y(), aVectorUp.Z()));
523       aModViewMat.SetColumn (1, OpenGl_Vec3d (aVectorRight.X(), aVectorRight.Y(), aVectorRight.Z()));
524       aModViewMat.SetColumn (0, OpenGl_Vec3d (aVectorDir.X(), aVectorDir.Y(), aVectorDir.Z()));
525
526       if (!myHasAnchorPoint)
527       {
528         OpenGl_Mat4d aPosMat;
529         aPosMat.SetColumn (3, OpenGl_Vec3d (myPoint.x(), myPoint.y(), myPoint.z()));
530         aPosMat *= aModViewMat;
531         aModViewMat.SetColumn (3, aPosMat.GetColumn (3));
532       }
533       else
534       {
535         aModViewMat.SetColumn (3, OpenGl_Vec3d (anObjX, anObjY, anObjZ));
536       }
537     }
538     else
539     {
540       Graphic3d_TransformUtils::Translate<GLdouble> (aModViewMat, anObjX, anObjY, anObjZ);
541       Graphic3d_TransformUtils::Rotate<GLdouble> (aModViewMat, theTextAspect.Aspect()->GetTextAngle(), 0.0, 0.0, 1.0);
542     }
543
544     if (!theTextAspect.Aspect()->GetTextZoomable())
545     {
546       Graphic3d_TransformUtils::Scale<GLdouble> (aModViewMat, myScaleHeight, myScaleHeight, myScaleHeight);
547     }
548     else if (theCtx->HasRenderScale())
549     {
550       Graphic3d_TransformUtils::Scale<GLdouble> (aModViewMat, theCtx->RenderScaleInv(), theCtx->RenderScaleInv(), theCtx->RenderScaleInv());
551     }
552   }
553
554   if (myHasPlane && !myHasAnchorPoint)
555   {
556     OpenGl_Mat4d aCurrentWorldViewMat;
557     aCurrentWorldViewMat.Convert (theCtx->WorldViewState.Current());
558     theCtx->WorldViewState.SetCurrent<Standard_Real> (aCurrentWorldViewMat * aModViewMat);
559   }
560   else
561   {
562     theCtx->WorldViewState.SetCurrent<Standard_Real> (aModViewMat);
563   }
564   theCtx->ApplyWorldViewMatrix();
565
566   if (!myIs2d)
567   {
568     theCtx->ProjectionState.SetCurrent<Standard_Real> (aProjectMat);
569     theCtx->ApplyProjectionMatrix();
570   }
571
572   // Upload updated state to shader program
573   theCtx->ShaderManager()->PushState (theCtx->ActiveProgram());
574 }
575
576 // =======================================================================
577 // function : drawText
578 // purpose  :
579 // =======================================================================
580 void OpenGl_Text::drawText (const Handle(OpenGl_Context)& theCtx,
581                             const OpenGl_AspectText&      theTextAspect) const
582 {
583 #ifdef HAVE_GL2PS
584   if (theCtx->IsFeedback())
585   {
586     // position of the text and alignment is calculated by transformation matrix
587     exportText (myString, myIs2d, theTextAspect, (Standard_Integer )myExportHeight);
588     return;
589   }
590 #else
591   (void )theTextAspect;
592 #endif
593
594   if (myVertsVbo.Length() != myTextures.Length()
595    || myTextures.IsEmpty())
596   {
597     return;
598   }
599
600   for (Standard_Integer anIter = 0; anIter < myTextures.Length(); ++anIter)
601   {
602     const GLuint aTexId = myTextures.Value (anIter);
603     glBindTexture (GL_TEXTURE_2D, aTexId);
604
605     const Handle(OpenGl_VertexBuffer)& aVerts = myVertsVbo.Value (anIter);
606     const Handle(OpenGl_VertexBuffer)& aTCrds = myTCrdsVbo.Value (anIter);
607     aVerts->BindAttribute (theCtx, Graphic3d_TOA_POS);
608     aTCrds->BindAttribute (theCtx, Graphic3d_TOA_UV);
609
610     glDrawArrays (GL_TRIANGLES, 0, GLsizei(aVerts->GetElemsNb()));
611
612     aTCrds->UnbindAttribute (theCtx, Graphic3d_TOA_UV);
613     aVerts->UnbindAttribute (theCtx, Graphic3d_TOA_POS);
614   }
615   glBindTexture (GL_TEXTURE_2D, 0);
616 }
617
618 // =======================================================================
619 // function : FontKey
620 // purpose  :
621 // =======================================================================
622 TCollection_AsciiString OpenGl_Text::FontKey (const OpenGl_AspectText& theAspect,
623                                               const Standard_Integer   theHeight,
624                                               const unsigned int       theResolution)
625 {
626   const Font_FontAspect anAspect = theAspect.Aspect()->GetTextFontAspect() != Font_FA_Undefined
627                                  ? theAspect.Aspect()->GetTextFontAspect()
628                                  : Font_FA_Regular;
629   return theAspect.Aspect()->Font()
630        + TCollection_AsciiString(":") + Standard_Integer(anAspect)
631        + TCollection_AsciiString(":") + Standard_Integer(theResolution)
632        + TCollection_AsciiString(":") + theHeight;
633 }
634
635 // =======================================================================
636 // function : FindFont
637 // purpose  :
638 // =======================================================================
639 Handle(OpenGl_Font) OpenGl_Text::FindFont (const Handle(OpenGl_Context)& theCtx,
640                                            const OpenGl_AspectText&      theAspect,
641                                            const Standard_Integer        theHeight,
642                                            const unsigned int            theResolution,
643                                            const TCollection_AsciiString theKey)
644 {
645   Handle(OpenGl_Font) aFont;
646   if (theHeight < 2)
647   {
648     return aFont; // invalid parameters
649   }
650
651   if (!theCtx->GetResource (theKey, aFont))
652   {
653     Handle(Font_FontMgr) aFontMgr = Font_FontMgr::GetInstance();
654     const Handle(TCollection_HAsciiString) aFontName = new TCollection_HAsciiString (theAspect.Aspect()->Font());
655     const Font_FontAspect anAspect = theAspect.Aspect()->GetTextFontAspect() != Font_FA_Undefined
656                                    ? theAspect.Aspect()->GetTextFontAspect()
657                                    : Font_FA_Regular;
658     Handle(Font_SystemFont) aRequestedFont = aFontMgr->FindFont (aFontName, anAspect, theHeight);
659     Handle(Font_FTFont) aFontFt;
660     if (!aRequestedFont.IsNull())
661     {
662       aFontFt = new Font_FTFont (Handle(Font_FTLibrary)());
663
664       if (aFontFt->Init (aRequestedFont->FontPath()->ToCString(), theHeight, theResolution))
665       {
666         aFont = new OpenGl_Font (aFontFt, theKey);
667         if (!aFont->Init (theCtx))
668         {
669           TCollection_ExtendedString aMsg;
670           aMsg += "Font '";
671           aMsg += theAspect.Aspect()->Font();
672           aMsg += "' - initialization of GL resources has failed!";
673           theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
674           aFontFt.Nullify();
675           aFont->Release (theCtx.operator->());
676           aFont = new OpenGl_Font (aFontFt, theKey);
677         }
678       }
679       else
680       {
681         TCollection_ExtendedString aMsg;
682         aMsg += "Font '";
683         aMsg += theAspect.Aspect()->Font();
684         aMsg += "' is broken or has incompatible format! File path: ";
685         aMsg += aRequestedFont->FontPath()->ToCString();
686         theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
687         aFontFt.Nullify();
688         aFont = new OpenGl_Font (aFontFt, theKey);
689       }
690     }
691     else
692     {
693       TCollection_ExtendedString aMsg;
694       aMsg += "Font '";
695       aMsg += theAspect.Aspect()->Font();
696       aMsg += "' is not found in the system!";
697       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
698       aFont = new OpenGl_Font (aFontFt, theKey);
699     }
700
701     theCtx->ShareResource (theKey, aFont);
702   }
703   return aFont;
704 }
705
706 // =======================================================================
707 // function : drawRect
708 // purpose  :
709 // =======================================================================
710 void OpenGl_Text::drawRect (const Handle(OpenGl_Context)& theCtx,
711                             const OpenGl_AspectText&      theTextAspect,
712                             const OpenGl_Vec4&            theColorSubs) const
713 {
714   Handle(OpenGl_ShaderProgram) aPrevProgram = theCtx->ActiveProgram();
715   if (myBndVertsVbo.IsNull())
716   {
717     OpenGl_Vec2 aQuad[4] =
718     {
719       OpenGl_Vec2(myBndBox.Right, myBndBox.Bottom),
720       OpenGl_Vec2(myBndBox.Right, myBndBox.Top),
721       OpenGl_Vec2(myBndBox.Left,  myBndBox.Bottom),
722       OpenGl_Vec2(myBndBox.Left,  myBndBox.Top)
723     };
724     if (theCtx->ToUseVbo())
725     {
726       myBndVertsVbo = new OpenGl_VertexBuffer();
727     }
728     else
729     {
730       myBndVertsVbo = new OpenGl_VertexBufferCompat();
731     }
732     myBndVertsVbo->Init (theCtx, 2, 4, aQuad[0].GetData());
733   }
734
735   // bind flat program
736   theCtx->ShaderManager()->BindFaceProgram (Handle(OpenGl_TextureSet)(), Standard_False, Standard_False, Standard_False, Handle(OpenGl_ShaderProgram)());
737
738 #if !defined(GL_ES_VERSION_2_0)
739   if (theCtx->core11 != NULL
740    && theCtx->ActiveProgram().IsNull())
741   {
742     glBindTexture (GL_TEXTURE_2D, 0);
743   }
744 #endif
745   theCtx->SetColor4fv (theColorSubs);
746   setupMatrix (theCtx, theTextAspect, OpenGl_Vec3 (0.0f, 0.0f, 0.00001f));
747   myBndVertsVbo->BindAttribute (theCtx, Graphic3d_TOA_POS);
748
749   theCtx->core20fwd->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
750
751   myBndVertsVbo->UnbindAttribute (theCtx, Graphic3d_TOA_POS);
752   theCtx->BindProgram (aPrevProgram);
753 }
754
755 // =======================================================================
756 // function : render
757 // purpose  :
758 // =======================================================================
759 void OpenGl_Text::render (const Handle(OpenGl_Context)& theCtx,
760                           const OpenGl_AspectText&      theTextAspect,
761                           const OpenGl_Vec4&            theColorText,
762                           const OpenGl_Vec4&            theColorSubs,
763                           const unsigned int            theResolution) const
764 {
765   if (myString.IsEmpty())
766   {
767     return;
768   }
769
770   // Note that using difference resolution in different Views in same Viewer
771   // will lead to performance regression (for example, text will be recreated every time).
772   const TCollection_AsciiString aFontKey = FontKey (theTextAspect, myParams.Height, theResolution);
773   if (!myFont.IsNull()
774    && !myFont->ResourceKey().IsEqual (aFontKey))
775   {
776     // font changed
777     const_cast<OpenGl_Text* > (this)->Release (theCtx.operator->());
778   }
779
780   if (myFont.IsNull())
781   {
782     myFont = FindFont (theCtx, theTextAspect, myParams.Height, theResolution, aFontKey);
783   }
784   if (!myFont->WasInitialized())
785   {
786     return;
787   }
788
789   if (myTextures.IsEmpty())
790   {
791     Font_TextFormatter aFormatter;
792     aFormatter.SetupAlignment (myParams.HAlign, myParams.VAlign);
793     aFormatter.Reset();
794
795     aFormatter.Append (myString, *myFont->FTFont().operator->());
796     aFormatter.Format();
797
798     OpenGl_TextBuilder aBuilder;
799     aBuilder.Perform (aFormatter,
800                       theCtx,
801                       *myFont.operator->(),
802                       myTextures,
803                       myVertsVbo,
804                       myTCrdsVbo);
805
806     aFormatter.BndBox (myBndBox);
807     if (!myBndVertsVbo.IsNull())
808     {
809       myBndVertsVbo->Release (theCtx.get());
810       myBndVertsVbo.Nullify();
811     }
812   }
813
814   if (myTextures.IsEmpty())
815   {
816     return;
817   }
818
819   myExportHeight = 1.0f;
820   myScaleHeight  = 1.0f;
821
822   theCtx->WorldViewState.Push();
823   myModelMatrix.Convert (theCtx->WorldViewState.Current() * theCtx->ModelWorldState.Current());
824
825   const GLdouble aPointSize = (GLdouble )myFont->FTFont()->PointSize();
826   if (!myIs2d)
827   {
828     Graphic3d_TransformUtils::Project<Standard_Real> (myPoint.x(), myPoint.y(), myPoint.z(),
829                                                       myModelMatrix, myProjMatrix, theCtx->Viewport(),
830                                                       myWinX, myWinY, myWinZ);
831
832     // compute scale factor for constant text height
833     if (theTextAspect.Aspect()->GetTextZoomable())
834     {
835       myExportHeight = aPointSize;
836     }
837     else
838     {
839       Graphic3d_Vec3d aPnt1, aPnt2;
840       Graphic3d_TransformUtils::UnProject<Standard_Real> (myWinX, myWinY, myWinZ,
841                                                           OpenGl_Mat4d::Map (THE_IDENTITY_MATRIX), myProjMatrix, theCtx->Viewport(),
842                                                           aPnt1.x(), aPnt1.y(), aPnt1.z());
843       Graphic3d_TransformUtils::UnProject<Standard_Real> (myWinX, myWinY + aPointSize, myWinZ,
844                                                           OpenGl_Mat4d::Map (THE_IDENTITY_MATRIX), myProjMatrix, theCtx->Viewport(),
845                                                           aPnt2.x(), aPnt2.y(), aPnt2.z());
846       myScaleHeight = (aPnt2.y() - aPnt1.y()) / aPointSize;
847     }
848   }
849   myExportHeight = aPointSize / myExportHeight;
850
851 #if !defined(GL_ES_VERSION_2_0)
852   if (theCtx->core11 != NULL
853    && theCtx->caps->ffpEnable)
854   {
855     glDisable (GL_LIGHTING);
856   }
857 #endif
858
859   // setup depth test
860   if (myIs2d
861    || theTextAspect.Aspect()->Style() == Aspect_TOST_ANNOTATION)
862   {
863     glDisable (GL_DEPTH_TEST);
864   }
865
866   if (theCtx->core15fwd != NULL)
867   {
868     theCtx->core15fwd->glActiveTexture (GL_TEXTURE0);
869   }
870 #if !defined(GL_ES_VERSION_2_0)
871   // activate texture unit
872   GLint aTexEnvParam = GL_REPLACE;
873   if (theCtx->core11 != NULL)
874   {
875     // setup alpha test
876     glAlphaFunc (GL_GEQUAL, 0.285f);
877     glEnable (GL_ALPHA_TEST);
878
879     glDisable (GL_TEXTURE_1D);
880     glEnable  (GL_TEXTURE_2D);
881     glGetTexEnviv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &aTexEnvParam);
882     if (aTexEnvParam != GL_REPLACE)
883     {
884       glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
885     }
886   }
887 #endif
888
889   // setup blending
890   glEnable (GL_BLEND);
891   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
892
893   // extra drawings
894   switch (theTextAspect.Aspect()->DisplayType())
895   {
896     case Aspect_TODT_BLEND:
897     {
898     #if !defined(GL_ES_VERSION_2_0)
899       glEnable  (GL_COLOR_LOGIC_OP);
900       glLogicOp (GL_XOR);
901     #endif
902       break;
903     }
904     case Aspect_TODT_SUBTITLE:
905     {
906       drawRect (theCtx, theTextAspect, theColorSubs);
907       break;
908     }
909     case Aspect_TODT_DEKALE:
910     {
911       theCtx->SetColor4fv (theColorSubs);
912       setupMatrix (theCtx, theTextAspect, OpenGl_Vec3 (+1.0f, +1.0f, 0.00001f));
913       drawText    (theCtx, theTextAspect);
914       setupMatrix (theCtx, theTextAspect, OpenGl_Vec3 (-1.0f, -1.0f, 0.00001f));
915       drawText    (theCtx, theTextAspect);
916       setupMatrix (theCtx, theTextAspect, OpenGl_Vec3 (-1.0f, +1.0f, 0.00001f));
917       drawText    (theCtx, theTextAspect);
918       setupMatrix (theCtx, theTextAspect, OpenGl_Vec3 (+1.0f, -1.0f, 0.00001f));
919       drawText    (theCtx, theTextAspect);
920       break;
921     }
922     case Aspect_TODT_DIMENSION:
923     case Aspect_TODT_NORMAL:
924     {
925       break;
926     }
927   }
928
929   // main draw call
930   theCtx->SetColor4fv (theColorText);
931   setupMatrix (theCtx, theTextAspect, OpenGl_Vec3 (0.0f, 0.0f, 0.0f));
932   drawText    (theCtx, theTextAspect);
933
934   if (!myIs2d)
935   {
936     theCtx->ProjectionState.SetCurrent<Standard_Real> (myProjMatrix);
937     theCtx->ApplyProjectionMatrix();
938   }
939
940 #if !defined(GL_ES_VERSION_2_0)
941   if (theCtx->core11 != NULL)
942   {
943     glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, aTexEnvParam);
944   }
945 #endif
946
947   if (theTextAspect.Aspect()->DisplayType() == Aspect_TODT_DIMENSION)
948   {
949     glDisable (GL_BLEND);
950     if (!myIs2d)
951     {
952       glDisable (GL_DEPTH_TEST);
953     }
954   #if !defined(GL_ES_VERSION_2_0)
955     if (theCtx->core11 != NULL)
956     {
957       glDisable (GL_TEXTURE_2D);
958       glDisable (GL_ALPHA_TEST);
959     }
960   #endif
961     glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
962
963     glClear (GL_STENCIL_BUFFER_BIT);
964     glEnable (GL_STENCIL_TEST);
965     glStencilFunc (GL_ALWAYS, 1, 0xFF);
966     glStencilOp (GL_KEEP, GL_KEEP, GL_REPLACE);
967
968     drawRect (theCtx, theTextAspect, OpenGl_Vec4 (1.0f, 1.0f, 1.0f, 1.0f));
969
970     glStencilFunc (GL_ALWAYS, 0, 0xFF);
971
972     glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
973   }
974
975   // reset OpenGL state
976   glDisable (GL_BLEND);
977   glDisable (GL_STENCIL_TEST);
978 #if !defined(GL_ES_VERSION_2_0)
979   if (theCtx->core11 != NULL)
980   {
981     glDisable (GL_ALPHA_TEST);
982   }
983   glDisable (GL_COLOR_LOGIC_OP);
984 #endif
985
986   // model view matrix was modified
987   theCtx->WorldViewState.Pop();
988   theCtx->ApplyModelViewMatrix();
989 }