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