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