[occt.git] / src / OpenGl / OpenGl_TextFormatter.cxx

// Created on: 2013-01-29
// Created by: Kirill GAVRILOV
// Copyright (c) 2013-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <OpenGl_TextFormatter.hxx>

#include <OpenGl_VertexBuffer.hxx>

#include <cmath>

namespace
{

  //! Auxiliary function to translate rectangle by the vector.
  inline void move (Font_FTFont::Rect& theRect,
                    const OpenGl_Vec2& theVec)
  {
    theRect.Left   += theVec.x();
    theRect.Right  += theVec.x();
    theRect.Top    += theVec.y();
    theRect.Bottom += theVec.y();
  }

  //! Auxiliary function to translate rectangles by the vector.
  inline void move (NCollection_Vector<OpenGl_Font::Tile>& theRects,
                    const OpenGl_Vec2&                     theMoveVec,
                    Standard_Integer                       theCharLower,
                    const Standard_Integer                 theCharUpper)
  {
    for(; theCharLower <= theCharUpper; ++theCharLower)
    {
      Font_FTFont::Rect& aRect = theRects.ChangeValue (theCharLower).px;
      move (aRect, theMoveVec);
    }
  }

  //! Auxiliary function to translate rectangles in horizontal direction.
  /*inline void moveX (NCollection_Vector<OpenGl_Font::Tile>& theRects,
                     const Standard_ShortReal               theMoveVec,
                     Standard_Integer                       theCharLower,
                     const Standard_Integer                 theCharUpper)
  {
    for (; theCharLower <= theCharUpper; ++theCharLower)
    {
      Font_FTFont::Rect& aRect = theRects.ChangeValue (theCharLower).px;
      aRect.Left  += theMoveVec;
      aRect.Right += theMoveVec;
    }
  }*/

  //! Auxiliary function to translate rectangles in vertical direction.
  inline void moveY (NCollection_Vector<OpenGl_Font::Tile>& theRects,
                     const Standard_ShortReal               theMoveVec,
                     Standard_Integer                       theCharLower,
                     const Standard_Integer                 theCharUpper)
  {
    for(; theCharLower <= theCharUpper; ++theCharLower)
    {
      Font_FTFont::Rect& aRect = theRects.ChangeValue (theCharLower).px;
      aRect.Top    += theMoveVec;
      aRect.Bottom += theMoveVec;
    }
  }

  //! Apply floor to vector components.
  //! @param  theVec - vector to change (by reference!)
  //! @return modified vector
  inline OpenGl_Vec2& floor (OpenGl_Vec2& theVec)
  {
    theVec.x() = std::floor (theVec.x());
    theVec.y() = std::floor (theVec.y());
    return theVec;
  }

};

IMPLEMENT_STANDARD_HANDLE (OpenGl_TextFormatter, Standard_Transient)
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_TextFormatter, Standard_Transient)

// =======================================================================
// function : OpenGl_TextFormatter
// purpose  :
// =======================================================================
OpenGl_TextFormatter::OpenGl_TextFormatter()
: myAlignX (Graphic3d_HTA_LEFT),
  myAlignY (Graphic3d_VTA_TOP),
  myTabSize (8),
  //
  myPen (0.0f, 0.0f),
  myRectsNb (0),
  myLineSpacing (0.0f),
  myAscender (0.0f),
  myIsFormatted (false),
  //
  myLinesNb (0),
  myRectLineStart (0),
  myRectWordStart (0),
  myNewLineNb(0),
  myPenCurrLine (0.0f),
  myLineLeft (0.0f),
  myLineTail (0.0f),
  myBndTop   (0.0f),
  myBndWidth (0.0f),
  myMoveVec (0.0f, 0.0f)
{
  //
}

// =======================================================================
// function : SetupAlignment
// purpose  :
// =======================================================================
void OpenGl_TextFormatter::SetupAlignment (const Graphic3d_HorizontalTextAlignment theAlignX,
                                           const Graphic3d_VerticalTextAlignment   theAlignY)
{
  myAlignX = theAlignX;
  myAlignY = theAlignY;
}

// =======================================================================
// function : Reset
// purpose  :
// =======================================================================
void OpenGl_TextFormatter::Reset()
{
  myIsFormatted = false;
  myString.Clear();
  myPen.x() = myPen.y() = 0.0f;
  myRectsNb = 0;
  myLineSpacing = myAscender = 0.0f;
  myRects.Clear();
  myNewLines.Clear();
}

// =======================================================================
// function : Result
// purpose  :
// =======================================================================
void OpenGl_TextFormatter::Result (NCollection_Vector<GLuint>& theTextures,
                                   NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > >& theVertsPerTexture,
                                   NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > >& theTCrdsPerTexture) const
{
  OpenGl_Vec2 aVec (0.0f, 0.0f);
  theTextures.Clear();
  theVertsPerTexture.Clear();
  theTCrdsPerTexture.Clear();
  for (Standard_Integer aRectIter = 0; aRectIter < myRectsNb; ++aRectIter)
  {
    const Font_FTFont::Rect& aRect    = myRects.Value (aRectIter).px;
    const Font_FTFont::Rect& aRectUV  = myRects.Value (aRectIter).uv;
    const GLuint             aTexture = myRects.Value (aRectIter).texture;

    Standard_Integer aListId = 0;
    for (aListId = 0; aListId < theTextures.Length(); ++aListId)
    {
      if (theTextures.Value (aListId) == aTexture)
      {
        break;
      }
    }
    if (aListId >= theTextures.Length())
    {
      theTextures.Append (aTexture);
      theVertsPerTexture.Append (new NCollection_Vector<OpenGl_Vec2>());
      theTCrdsPerTexture.Append (new NCollection_Vector<OpenGl_Vec2>());
    }

    NCollection_Vector<OpenGl_Vec2>& aVerts = *theVertsPerTexture.ChangeValue (aListId);
    NCollection_Vector<OpenGl_Vec2>& aTCrds = *theTCrdsPerTexture.ChangeValue (aListId);

    // apply floor on position to avoid blurring issues
    // due to cross-pixel coordinates
    aVerts.Append (floor(aRect.BottomLeft (aVec)));
    aVerts.Append (floor(aRect.TopLeft    (aVec)));
    aVerts.Append (floor(aRect.TopRight   (aVec)));
    aTCrds.Append (aRectUV.BottomLeft (aVec));
    aTCrds.Append (aRectUV.TopLeft    (aVec));
    aTCrds.Append (aRectUV.TopRight   (aVec));

    aVerts.Append (floor(aRect.BottomLeft  (aVec)));
    aVerts.Append (floor(aRect.TopRight    (aVec)));
    aVerts.Append (floor(aRect.BottomRight (aVec)));
    aTCrds.Append (aRectUV.BottomLeft  (aVec));
    aTCrds.Append (aRectUV.TopRight    (aVec));
    aTCrds.Append (aRectUV.BottomRight (aVec));
  }
}

// =======================================================================
// function : Result
// purpose  :
// =======================================================================
void OpenGl_TextFormatter::Result (const Handle(OpenGl_Context)&                    theCtx,
                                   NCollection_Vector<GLuint>&                      theTextures,
                                   NCollection_Vector<Handle(OpenGl_VertexBuffer)>& theVertsPerTexture,
                                   NCollection_Vector<Handle(OpenGl_VertexBuffer)>& theTCrdsPerTexture) const
{
  NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > > aVertsPerTexture;
  NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > > aTCrdsPerTexture;
  Result (theTextures, aVertsPerTexture, aTCrdsPerTexture);

  if (theVertsPerTexture.Length() != theTextures.Length())
  {
    for (Standard_Integer aTextureIter = 0; aTextureIter < theVertsPerTexture.Length(); ++aTextureIter)
    {
      theVertsPerTexture.Value (aTextureIter)->Release (theCtx.operator->());
      theTCrdsPerTexture.Value (aTextureIter)->Release (theCtx.operator->());
    }
    theVertsPerTexture.Clear();
    theTCrdsPerTexture.Clear();

    while (theVertsPerTexture.Length() < theTextures.Length())
    {
      Handle(OpenGl_VertexBuffer) aVertsVbo = new OpenGl_VertexBuffer();
      Handle(OpenGl_VertexBuffer) aTcrdsVbo = new OpenGl_VertexBuffer();
      theVertsPerTexture.Append (aVertsVbo);
      theTCrdsPerTexture.Append (aTcrdsVbo);
      aVertsVbo->Create (theCtx);
      aTcrdsVbo->Create (theCtx);
    }
  }

  for (Standard_Integer aTextureIter = 0; aTextureIter < theTextures.Length(); ++aTextureIter)
  {
    const NCollection_Vector<OpenGl_Vec2>& aVerts = *aVertsPerTexture.Value (aTextureIter);
    Handle(OpenGl_VertexBuffer)& aVertsVbo = theVertsPerTexture.ChangeValue (aTextureIter);
    if (!aVertsVbo->Init (theCtx, 2, aVerts.Length(), (GLfloat* )NULL)
     || !myVboEditor.Init (theCtx, aVertsVbo))
    {
      continue;
    }
    for (Standard_Integer aVertIter = 0; aVertIter < aVerts.Length(); ++aVertIter, myVboEditor.Next())
    {
      myVboEditor.Value() = aVerts.Value (aVertIter);
    }
    myVboEditor.Flush();

    const NCollection_Vector<OpenGl_Vec2>& aTCrds = *aTCrdsPerTexture.Value (aTextureIter);
    Handle(OpenGl_VertexBuffer)& aTCrdsVbo = theTCrdsPerTexture.ChangeValue (aTextureIter);
    if (!aTCrdsVbo->Init (theCtx, 2, aVerts.Length(), (GLfloat* )NULL)
     || !myVboEditor.Init (theCtx, aTCrdsVbo))
    {
      continue;
    }
    for (Standard_Integer aVertIter = 0; aVertIter < aVerts.Length(); ++aVertIter, myVboEditor.Next())
    {
      myVboEditor.Value() = aTCrds.Value (aVertIter);
    }
    myVboEditor.Flush();
  }
  myVboEditor.Init (NULL, NULL);
}

// =======================================================================
// function : Result
// purpose  :
// =======================================================================
void OpenGl_TextFormatter::Result (const Handle(OpenGl_Context)&                 /*theCtx*/,
                                   NCollection_Vector<GLuint>&                   theTextures,
                                   NCollection_Vector<Handle(OpenGl_Vec2Array)>& theVertsPerTexture,
                                   NCollection_Vector<Handle(OpenGl_Vec2Array)>& theTCrdsPerTexture) const
{
  NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > > aVertsPerTexture;
  NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > > aTCrdsPerTexture;
  Result (theTextures, aVertsPerTexture, aTCrdsPerTexture);

  theVertsPerTexture.Clear();
  theTCrdsPerTexture.Clear();

  for (Standard_Integer aTextureIter = 0; aTextureIter < theTextures.Length(); ++aTextureIter)
  {
    const NCollection_Vector<OpenGl_Vec2>& aVerts = *aVertsPerTexture.Value (aTextureIter);
    const NCollection_Vector<OpenGl_Vec2>& aTCrds = *aTCrdsPerTexture.Value (aTextureIter);
    Handle(OpenGl_Vec2Array) aVertsArray = new OpenGl_Vec2Array (1, aVerts.Length());
    Handle(OpenGl_Vec2Array) aTCrdsArray = new OpenGl_Vec2Array (1, aVerts.Length());
    theVertsPerTexture.Append (aVertsArray);
    theTCrdsPerTexture.Append (aTCrdsArray);

    for (Standard_Integer aVertIter = 0; aVertIter < aVerts.Length(); ++aVertIter)
    {
      aVertsArray->ChangeValue (aVertIter + 1) = aVerts.Value (aVertIter);
    }
    for (Standard_Integer aVertIter = 0; aVertIter < aVerts.Length(); ++aVertIter)
    {
      aTCrdsArray->ChangeValue (aVertIter + 1) = aTCrds.Value (aVertIter);
    }
  }
}

// =======================================================================
// function : Append
// purpose  :
// =======================================================================
void OpenGl_TextFormatter::Append (const Handle(OpenGl_Context)& theCtx,
                                   const NCollection_String&     theString,
                                   OpenGl_Font&                  theFont)
{
  if (theString.IsEmpty())
  {
    return;
  }

  myAscender    = Max (myAscender,    theFont.Ascender());
  myLineSpacing = Max (myLineSpacing, theFont.LineSpacing());
  myString     += theString;

  int aSymbolsCounter = 0; // special counter to process tabulation symbols

  // first pass - render all symbols using associated font on single ZERO baseline
  OpenGl_Font::Tile aTile;
  memset (&aTile, 0, sizeof(aTile));
  for (NCollection_Utf8Iter anIter = theString.Iterator(); *anIter != 0;)
  {
    const Standard_Utf32Char aCharThis =   *anIter;
    const Standard_Utf32Char aCharNext = *++anIter;

    if (aCharThis == '\x0D' // CR  (carriage return)
     || aCharThis == '\a'   // BEL (alarm)
     || aCharThis == '\f'   // FF  (form feed) NP (new page)
     || aCharThis == '\b'   // BS  (backspace)
     || aCharThis == '\v')  // VT  (vertical tab)
    {
      continue; // skip unsupported carriage control codes
    }
    else if (aCharThis == '\x0A') // LF (line feed, new line)
    {
      aSymbolsCounter = 0;
      myNewLines.Append (myPen.x());
      continue; // will be processed on second pass
    }
    else if (aCharThis == ' ')
    {
      ++aSymbolsCounter;
      myPen.x() += theFont.AdvanceX (' ', aCharNext);
      continue;
    }
    else if (aCharThis == '\t')
    {
      const Standard_Integer aSpacesNum = (myTabSize - (aSymbolsCounter - 1) % myTabSize);
      myPen.x() += theFont.AdvanceX (' ', aCharNext) * Standard_ShortReal(aSpacesNum);
      aSymbolsCounter += aSpacesNum;
      continue;
    }

    ++aSymbolsCounter;
    theFont.RenderGlyph (theCtx,
                         aCharThis, aCharNext,
                         aTile, myPen);
    myRects.Append (aTile);

    ++myRectsNb;
  }
}

// =======================================================================
// function : newLine
// purpose  :
// =======================================================================
void OpenGl_TextFormatter::newLine (const Standard_Integer theLastRect)
{
  if (myRectLineStart >= myRectsNb)
  {
    ++myLinesNb;
    myPenCurrLine -= myLineSpacing;
    return;
  }

  myMoveVec.y() = myPenCurrLine;
  switch (myAlignX)
  {
    default:
    case Graphic3d_HTA_LEFT:
    {
      myMoveVec.x() = (myNewLineNb > 0) ? -myNewLines.Value (myNewLineNb - 1) : 0.0f;
      break;
    }
    case Graphic3d_HTA_RIGHT:
    {
      myMoveVec.x() = (myNewLineNb < myNewLines.Length())
                    ? -myNewLines.Value (myNewLineNb)
                    : -myPen.x();
      break;
    }
    case Graphic3d_HTA_CENTER:
    {
      const Standard_ShortReal aFrom = (myNewLineNb > 0)
                                     ? myNewLines.Value (myNewLineNb - 1)
                                     : 0.0f;
      const Standard_ShortReal aTo   = (myNewLineNb < myNewLines.Length())
                                     ? myNewLines.Value (myNewLineNb)
                                     : myPen.x();
      myMoveVec.x() = -0.5f * (aFrom + aTo);
      break;
    }
  }

  move (myRects, myMoveVec, myRectLineStart, theLastRect);

  ++myLinesNb;
  myPenCurrLine -= myLineSpacing;
  myRectLineStart = myRectWordStart = theLastRect + 1;
  if (myRectLineStart < myRectsNb)
  {
    myLineLeft = myRects.Value (myRectLineStart).px.Left;
  }
}

// =======================================================================
// function : Format
// purpose  :
// =======================================================================
void OpenGl_TextFormatter::Format()
{
  if (myRectsNb == 0 || myIsFormatted)
  {
    return;
  }

  myIsFormatted = true;
  myLinesNb = myRectLineStart = myRectWordStart = 0;
  myLineLeft   = 0.0f;
  myLineTail   = 0.0f;
  myBndTop     = 0.0f;
  myBndWidth   = 0.0f;
  myMoveVec.x() = myMoveVec.y() = 0.0f;

  // split text into lines and apply horizontal alignment
  myPenCurrLine = -myAscender;
  Standard_Integer aRectIter = 0;
  myNewLineNb = 0;
  for (NCollection_Utf8Iter anIter = myString.Iterator(); *anIter != 0; ++anIter)
  {
    const Standard_Utf32Char aCharThis = *anIter;
    if (aCharThis == '\x0D' // CR  (carriage return)
     || aCharThis == '\a'   // BEL (alarm)
     || aCharThis == '\f'   // FF  (form feed) NP (new page)
     || aCharThis == '\b'   // BS  (backspace)
     || aCharThis == '\v')  // VT  (vertical tab)
    {
      continue; // skip unsupported carriage control codes
    }
    else if (aCharThis == '\x0A') // LF (line feed, new line)
    {
      const Standard_Integer aLastRect = aRectIter - 1; // last rect on current line
      newLine (aLastRect);
      ++myNewLineNb;
      continue;
    }
    else if (aCharThis == ' '
          || aCharThis == '\t')
    {
      myRectWordStart = aRectIter;
      continue;
    }

    Standard_ShortReal aWidth = myRects.Value (aRectIter).px.Right - myLineLeft;
    myBndWidth = Max (myBndWidth, aWidth);

    ++aRectIter;
  }

  // move last line
  newLine (myRectsNb - 1);

  // apply vertical alignment style
  if (myAlignY == Graphic3d_VTA_BOTTOM)
  {
    myBndTop = -myLineSpacing - myPenCurrLine;
    moveY (myRects, myBndTop, 0, myRectsNb - 1);
  }
  else if (myAlignY == Graphic3d_VTA_CENTER)
  {
    myBndTop = 0.5f * (myLineSpacing * Standard_ShortReal(myLinesNb));
    moveY (myRects, myBndTop, 0, myRectsNb - 1);
  }
}
Commit	Line	Data
a174a3c5	1	// Created on: 2013-01-29
a174a3c5	2	// Created by: Kirill GAVRILOV
d5f74e42	3	// Copyright (c) 2013-2014 OPEN CASCADE SAS
a174a3c5	4	//
973c2be1	5	// This file is part of Open CASCADE Technology software library.
a174a3c5	6	//
d5f74e42	7	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	8	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	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.
a174a3c5	12	//
973c2be1	13	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	14	// commercial license or contractual agreement.
a174a3c5	15
	16	#include <OpenGl_TextFormatter.hxx>
	17
	18	#include <OpenGl_VertexBuffer.hxx>
	19
	20	#include <cmath>
	21
	22	namespace
	23	{
	24
	25	//! Auxiliary function to translate rectangle by the vector.
	26	inline void move (Font_FTFont::Rect& theRect,
	27	const OpenGl_Vec2& theVec)
	28	{
	29	theRect.Left += theVec.x();
	30	theRect.Right += theVec.x();
	31	theRect.Top += theVec.y();
	32	theRect.Bottom += theVec.y();
	33	}
	34
	35	//! Auxiliary function to translate rectangles by the vector.
	36	inline void move (NCollection_Vector<OpenGl_Font::Tile>& theRects,
	37	const OpenGl_Vec2& theMoveVec,
	38	Standard_Integer theCharLower,
	39	const Standard_Integer theCharUpper)
	40	{
	41	for(; theCharLower <= theCharUpper; ++theCharLower)
	42	{
	43	Font_FTFont::Rect& aRect = theRects.ChangeValue (theCharLower).px;
	44	move (aRect, theMoveVec);
	45	}
	46	}
	47
	48	//! Auxiliary function to translate rectangles in horizontal direction.
30f0ad28	49	/*inline void moveX (NCollection_Vector<OpenGl_Font::Tile>& theRects,
a174a3c5	50	const Standard_ShortReal theMoveVec,
	51	Standard_Integer theCharLower,
	52	const Standard_Integer theCharUpper)
	53	{
	54	for (; theCharLower <= theCharUpper; ++theCharLower)
	55	{
	56	Font_FTFont::Rect& aRect = theRects.ChangeValue (theCharLower).px;
	57	aRect.Left += theMoveVec;
	58	aRect.Right += theMoveVec;
	59	}
30f0ad28	60	}*/
a174a3c5	61
	62	//! Auxiliary function to translate rectangles in vertical direction.
	63	inline void moveY (NCollection_Vector<OpenGl_Font::Tile>& theRects,
	64	const Standard_ShortReal theMoveVec,
	65	Standard_Integer theCharLower,
	66	const Standard_Integer theCharUpper)
	67	{
	68	for(; theCharLower <= theCharUpper; ++theCharLower)
	69	{
	70	Font_FTFont::Rect& aRect = theRects.ChangeValue (theCharLower).px;
	71	aRect.Top += theMoveVec;
	72	aRect.Bottom += theMoveVec;
	73	}
	74	}
	75
	76	//! Apply floor to vector components.
	77	//! @param theVec - vector to change (by reference!)
	78	//! @return modified vector
	79	inline OpenGl_Vec2& floor (OpenGl_Vec2& theVec)
	80	{
	81	theVec.x() = std::floor (theVec.x());
	82	theVec.y() = std::floor (theVec.y());
	83	return theVec;
	84	}
	85
	86	};
	87
	88	IMPLEMENT_STANDARD_HANDLE (OpenGl_TextFormatter, Standard_Transient)
	89	IMPLEMENT_STANDARD_RTTIEXT(OpenGl_TextFormatter, Standard_Transient)
	90
	91	// =======================================================================
	92	// function : OpenGl_TextFormatter
	93	// purpose :
	94	// =======================================================================
	95	OpenGl_TextFormatter::OpenGl_TextFormatter()
	96	: myAlignX (Graphic3d_HTA_LEFT),
	97	myAlignY (Graphic3d_VTA_TOP),
	98	myTabSize (8),
	99	//
	100	myPen (0.0f, 0.0f),
	101	myRectsNb (0),
	102	myLineSpacing (0.0f),
	103	myAscender (0.0f),
	104	myIsFormatted (false),
	105	//
	106	myLinesNb (0),
	107	myRectLineStart (0),
	108	myRectWordStart (0),
c24d4017	109	myNewLineNb(0),
a174a3c5	110	myPenCurrLine (0.0f),
	111	myLineLeft (0.0f),
	112	myLineTail (0.0f),
	113	myBndTop (0.0f),
	114	myBndWidth (0.0f),
	115	myMoveVec (0.0f, 0.0f)
	116	{
	117	//
	118	}
	119
	120	// =======================================================================
	121	// function : SetupAlignment
	122	// purpose :
	123	// =======================================================================
	124	void OpenGl_TextFormatter::SetupAlignment (const Graphic3d_HorizontalTextAlignment theAlignX,
	125	const Graphic3d_VerticalTextAlignment theAlignY)
	126	{
	127	myAlignX = theAlignX;
	128	myAlignY = theAlignY;
	129	}
	130
	131	// =======================================================================
	132	// function : Reset
	133	// purpose :
	134	// =======================================================================
	135	void OpenGl_TextFormatter::Reset()
	136	{
	137	myIsFormatted = false;
	138	myString.Clear();
	139	myPen.x() = myPen.y() = 0.0f;
	140	myRectsNb = 0;
	141	myLineSpacing = myAscender = 0.0f;
	142	myRects.Clear();
	143	myNewLines.Clear();
	144	}
	145
	146	// =======================================================================
	147	// function : Result
	148	// purpose :
	149	// =======================================================================
	150	void OpenGl_TextFormatter::Result (NCollection_Vector<GLuint>& theTextures,
	151	NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > >& theVertsPerTexture,
	152	NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > >& theTCrdsPerTexture) const
	153	{
	154	OpenGl_Vec2 aVec (0.0f, 0.0f);
	155	theTextures.Clear();
	156	theVertsPerTexture.Clear();
	157	theTCrdsPerTexture.Clear();
	158	for (Standard_Integer aRectIter = 0; aRectIter < myRectsNb; ++aRectIter)
	159	{
	160	const Font_FTFont::Rect& aRect = myRects.Value (aRectIter).px;
	161	const Font_FTFont::Rect& aRectUV = myRects.Value (aRectIter).uv;
	162	const GLuint aTexture = myRects.Value (aRectIter).texture;
	163
	164	Standard_Integer aListId = 0;
	165	for (aListId = 0; aListId < theTextures.Length(); ++aListId)
	166	{
	167	if (theTextures.Value (aListId) == aTexture)
	168	{
	169	break;
	170	}
	171	}
	172	if (aListId >= theTextures.Length())
	173	{
174	theTextures.Append (aTexture);
175	theVertsPerTexture.Append (new NCollection_Vector<OpenGl_Vec2>());
176	theTCrdsPerTexture.Append (new NCollection_Vector<OpenGl_Vec2>());
177	}
178
179	NCollection_Vector<OpenGl_Vec2>& aVerts = *theVertsPerTexture.ChangeValue (aListId);
180	NCollection_Vector<OpenGl_Vec2>& aTCrds = *theTCrdsPerTexture.ChangeValue (aListId);
181
182	// apply floor on position to avoid blurring issues
183	// due to cross-pixel coordinates
184	aVerts.Append (floor(aRect.BottomLeft (aVec)));
185	aVerts.Append (floor(aRect.TopLeft (aVec)));
186	aVerts.Append (floor(aRect.TopRight (aVec)));
187	aTCrds.Append (aRectUV.BottomLeft (aVec));
188	aTCrds.Append (aRectUV.TopLeft (aVec));
189	aTCrds.Append (aRectUV.TopRight (aVec));
190
191	aVerts.Append (floor(aRect.BottomLeft (aVec)));
192	aVerts.Append (floor(aRect.TopRight (aVec)));
193	aVerts.Append (floor(aRect.BottomRight (aVec)));
194	aTCrds.Append (aRectUV.BottomLeft (aVec));
195	aTCrds.Append (aRectUV.TopRight (aVec));
196	aTCrds.Append (aRectUV.BottomRight (aVec));
197	}
198	}
199
200	// =======================================================================
201	// function : Result
202	// purpose :
203	// =======================================================================
204	void OpenGl_TextFormatter::Result (const Handle(OpenGl_Context)& theCtx,
205	NCollection_Vector<GLuint>& theTextures,
206	NCollection_Vector<Handle(OpenGl_VertexBuffer)>& theVertsPerTexture,
207	NCollection_Vector<Handle(OpenGl_VertexBuffer)>& theTCrdsPerTexture) const
208	{
209	NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > > aVertsPerTexture;
210	NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > > aTCrdsPerTexture;
211	Result (theTextures, aVertsPerTexture, aTCrdsPerTexture);
212
213	if (theVertsPerTexture.Length() != theTextures.Length())
214	{
215	for (Standard_Integer aTextureIter = 0; aTextureIter < theVertsPerTexture.Length(); ++aTextureIter)
216	{
217	theVertsPerTexture.Value (aTextureIter)->Release (theCtx.operator->());
218	theTCrdsPerTexture.Value (aTextureIter)->Release (theCtx.operator->());
219	}
220	theVertsPerTexture.Clear();
221	theTCrdsPerTexture.Clear();
222
223	while (theVertsPerTexture.Length() < theTextures.Length())
224	{
225	Handle(OpenGl_VertexBuffer) aVertsVbo = new OpenGl_VertexBuffer();
226	Handle(OpenGl_VertexBuffer) aTcrdsVbo = new OpenGl_VertexBuffer();
227	theVertsPerTexture.Append (aVertsVbo);
228	theTCrdsPerTexture.Append (aTcrdsVbo);
229	aVertsVbo->Create (theCtx);
230	aTcrdsVbo->Create (theCtx);
231	}
232	}
233
234	for (Standard_Integer aTextureIter = 0; aTextureIter < theTextures.Length(); ++aTextureIter)
235	{
236	const NCollection_Vector<OpenGl_Vec2>& aVerts = *aVertsPerTexture.Value (aTextureIter);
237	Handle(OpenGl_VertexBuffer)& aVertsVbo = theVertsPerTexture.ChangeValue (aTextureIter);
238	if (!aVertsVbo->Init (theCtx, 2, aVerts.Length(), (GLfloat* )NULL)
239	\|\| !myVboEditor.Init (theCtx, aVertsVbo))
240	{
241	continue;
242	}
243	for (Standard_Integer aVertIter = 0; aVertIter < aVerts.Length(); ++aVertIter, myVboEditor.Next())
244	{
245	myVboEditor.Value() = aVerts.Value (aVertIter);
246	}
247	myVboEditor.Flush();
248
249	const NCollection_Vector<OpenGl_Vec2>& aTCrds = *aTCrdsPerTexture.Value (aTextureIter);
250	Handle(OpenGl_VertexBuffer)& aTCrdsVbo = theTCrdsPerTexture.ChangeValue (aTextureIter);
251	if (!aTCrdsVbo->Init (theCtx, 2, aVerts.Length(), (GLfloat* )NULL)
252	\|\| !myVboEditor.Init (theCtx, aTCrdsVbo))
253	{
254	continue;
255	}
256	for (Standard_Integer aVertIter = 0; aVertIter < aVerts.Length(); ++aVertIter, myVboEditor.Next())
257	{
258	myVboEditor.Value() = aTCrds.Value (aVertIter);
259	}
260	myVboEditor.Flush();
261	}
262	myVboEditor.Init (NULL, NULL);
263	}
264
265	// =======================================================================
266	// function : Result
267	// purpose :
268	// =======================================================================
35e08fe8	269	void OpenGl_TextFormatter::Result (const Handle(OpenGl_Context)& /theCtx/,
a174a3c5	270	NCollection_Vector<GLuint>& theTextures,
	271	NCollection_Vector<Handle(OpenGl_Vec2Array)>& theVertsPerTexture,
	272	NCollection_Vector<Handle(OpenGl_Vec2Array)>& theTCrdsPerTexture) const
	273	{
	274	NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > > aVertsPerTexture;
	275	NCollection_Vector< NCollection_Handle <NCollection_Vector <OpenGl_Vec2> > > aTCrdsPerTexture;
	276	Result (theTextures, aVertsPerTexture, aTCrdsPerTexture);
	277
	278	theVertsPerTexture.Clear();
	279	theTCrdsPerTexture.Clear();
	280
	281	for (Standard_Integer aTextureIter = 0; aTextureIter < theTextures.Length(); ++aTextureIter)
	282	{
	283	const NCollection_Vector<OpenGl_Vec2>& aVerts = *aVertsPerTexture.Value (aTextureIter);
	284	const NCollection_Vector<OpenGl_Vec2>& aTCrds = *aTCrdsPerTexture.Value (aTextureIter);
	285	Handle(OpenGl_Vec2Array) aVertsArray = new OpenGl_Vec2Array (1, aVerts.Length());
	286	Handle(OpenGl_Vec2Array) aTCrdsArray = new OpenGl_Vec2Array (1, aVerts.Length());
	287	theVertsPerTexture.Append (aVertsArray);
	288	theTCrdsPerTexture.Append (aTCrdsArray);
	289
	290	for (Standard_Integer aVertIter = 0; aVertIter < aVerts.Length(); ++aVertIter)
	291	{
	292	aVertsArray->ChangeValue (aVertIter + 1) = aVerts.Value (aVertIter);
	293	}
	294	for (Standard_Integer aVertIter = 0; aVertIter < aVerts.Length(); ++aVertIter)
	295	{
	296	aTCrdsArray->ChangeValue (aVertIter + 1) = aTCrds.Value (aVertIter);
	297	}
	298	}
	299	}
	300
	301	// =======================================================================
	302	// function : Append
	303	// purpose :
	304	// =======================================================================
	305	void OpenGl_TextFormatter::Append (const Handle(OpenGl_Context)& theCtx,
	306	const NCollection_String& theString,
	307	OpenGl_Font& theFont)
	308	{
	309	if (theString.IsEmpty())
	310	{
	311	return;
	312	}
	313
	314	myAscender = Max (myAscender, theFont.Ascender());
	315	myLineSpacing = Max (myLineSpacing, theFont.LineSpacing());
	316	myString += theString;
	317
	318	int aSymbolsCounter = 0; // special counter to process tabulation symbols
	319
	320	// first pass - render all symbols using associated font on single ZERO baseline
	321	OpenGl_Font::Tile aTile;
	322	memset (&aTile, 0, sizeof(aTile));
	323	for (NCollection_Utf8Iter anIter = theString.Iterator(); *anIter != 0;)
	324	{
	325	const Standard_Utf32Char aCharThis = *anIter;
	326	const Standard_Utf32Char aCharNext = *++anIter;
	327
	328	if (aCharThis == '\x0D' // CR (carriage return)
	329	\|\| aCharThis == '\a' // BEL (alarm)
	330	\|\| aCharThis == '\f' // FF (form feed) NP (new page)
	331	\|\| aCharThis == '\b' // BS (backspace)
	332	\|\| aCharThis == '\v') // VT (vertical tab)
	333	{
334	continue; // skip unsupported carriage control codes
335	}
336	else if (aCharThis == '\x0A') // LF (line feed, new line)
337	{
338	aSymbolsCounter = 0;
339	myNewLines.Append (myPen.x());
340	continue; // will be processed on second pass
341	}
342	else if (aCharThis == ' ')
343	{
344	++aSymbolsCounter;
345	myPen.x() += theFont.AdvanceX (' ', aCharNext);
346	continue;
347	}
348	else if (aCharThis == '\t')
349	{
350	const Standard_Integer aSpacesNum = (myTabSize - (aSymbolsCounter - 1) % myTabSize);
351	myPen.x() += theFont.AdvanceX (' ', aCharNext) * Standard_ShortReal(aSpacesNum);
352	aSymbolsCounter += aSpacesNum;
353	continue;
354	}
355
356	++aSymbolsCounter;
357	theFont.RenderGlyph (theCtx,
358	aCharThis, aCharNext,
359	aTile, myPen);
360	myRects.Append (aTile);
361
362	++myRectsNb;
363	}
364	}
365
366	// =======================================================================
367	// function : newLine
368	// purpose :
369	// =======================================================================
370	void OpenGl_TextFormatter::newLine (const Standard_Integer theLastRect)
371	{
372	if (myRectLineStart >= myRectsNb)
373	{
374	++myLinesNb;
375	myPenCurrLine -= myLineSpacing;
376	return;
377	}
378
379	myMoveVec.y() = myPenCurrLine;
380	switch (myAlignX)
381	{
382	default:
383	case Graphic3d_HTA_LEFT:
384	{
385	myMoveVec.x() = (myNewLineNb > 0) ? -myNewLines.Value (myNewLineNb - 1) : 0.0f;
386	break;
387	}
388	case Graphic3d_HTA_RIGHT:
389	{
390	myMoveVec.x() = (myNewLineNb < myNewLines.Length())
391	? -myNewLines.Value (myNewLineNb)
392	: -myPen.x();
393	break;
394	}
395	case Graphic3d_HTA_CENTER:
396	{
397	const Standard_ShortReal aFrom = (myNewLineNb > 0)
398	? myNewLines.Value (myNewLineNb - 1)
399	: 0.0f;
400	const Standard_ShortReal aTo = (myNewLineNb < myNewLines.Length())
401	? myNewLines.Value (myNewLineNb)
402	: myPen.x();
403	myMoveVec.x() = -0.5f * (aFrom + aTo);
404	break;
405	}
406	}
407
408	move (myRects, myMoveVec, myRectLineStart, theLastRect);
409
410	++myLinesNb;
411	myPenCurrLine -= myLineSpacing;
412	myRectLineStart = myRectWordStart = theLastRect + 1;
413	if (myRectLineStart < myRectsNb)
414	{
415	myLineLeft = myRects.Value (myRectLineStart).px.Left;
416	}
417	}
418
419	// =======================================================================
420	// function : Format
421	// purpose :
422	// =======================================================================
423	void OpenGl_TextFormatter::Format()
424	{
425	if (myRectsNb == 0 \|\| myIsFormatted)
426	{
427	return;
428	}
429
430	myIsFormatted = true;
431	myLinesNb = myRectLineStart = myRectWordStart = 0;
432	myLineLeft = 0.0f;
433	myLineTail = 0.0f;
434	myBndTop = 0.0f;
435	myBndWidth = 0.0f;
436	myMoveVec.x() = myMoveVec.y() = 0.0f;
437
438	// split text into lines and apply horizontal alignment
439	myPenCurrLine = -myAscender;
440	Standard_Integer aRectIter = 0;
441	myNewLineNb = 0;
442	for (NCollection_Utf8Iter anIter = myString.Iterator(); *anIter != 0; ++anIter)
443	{
444	const Standard_Utf32Char aCharThis = *anIter;
445	if (aCharThis == '\x0D' // CR (carriage return)
446	\|\| aCharThis == '\a' // BEL (alarm)
447	\|\| aCharThis == '\f' // FF (form feed) NP (new page)
448	\|\| aCharThis == '\b' // BS (backspace)
449	\|\| aCharThis == '\v') // VT (vertical tab)
450	{
451	continue; // skip unsupported carriage control codes
452	}
453	else if (aCharThis == '\x0A') // LF (line feed, new line)
454	{
455	const Standard_Integer aLastRect = aRectIter - 1; // last rect on current line
456	newLine (aLastRect);
457	++myNewLineNb;
458	continue;
459	}
460	else if (aCharThis == ' '
461	\|\| aCharThis == '\t')
462	{
463	myRectWordStart = aRectIter;
464	continue;
465	}
466
467	Standard_ShortReal aWidth = myRects.Value (aRectIter).px.Right - myLineLeft;
468	myBndWidth = Max (myBndWidth, aWidth);
469
470	++aRectIter;
471	}
472
473	// move last line
474	newLine (myRectsNb - 1);
475
476	// apply vertical alignment style
477	if (myAlignY == Graphic3d_VTA_BOTTOM)
478	{
479	myBndTop = -myLineSpacing - myPenCurrLine;
480	moveY (myRects, myBndTop, 0, myRectsNb - 1);
481	}
482	else if (myAlignY == Graphic3d_VTA_CENTER)
483	{
484	myBndTop = 0.5f * (myLineSpacing * Standard_ShortReal(myLinesNb));
485	moveY (myRects, myBndTop, 0, myRectsNb - 1);
486	}
487	}