Texture Font class inherits SLGLTexture for alpha blended font rendering. More...

#include <SLTexFont.h>

Inheritance diagram for SLTexFont:

Classes
struct	SLTexFontChar
	Single Character info struct w. min. and max. texcoords. More...

Public Member Functions
	SLTexFont (SLstring fontFilename, SLGLProgram *fontTexProgram)

	SLTexFont (SLstring fontFilename, SLstring shaderDir)

	~SLTexFont ()

void	create (SLstring fontFilename)

SLVec2f	calcTextSize (const SLstring &text, SLfloat maxWidth=0.0f, SLfloat lineHeightFactor=1.5f)

SLVstring	wrapTextToLines (SLstring text, SLfloat maxW)

void	buildTextBuffers (SLGLVertexArray &vao, const SLstring &text, SLfloat maxWidth=0.0f, SLfloat lineHeight=1.5f)

SLGLProgram *	fontTexProgram ()

Public Member Functions inherited from SLGLTexture
	SLGLTexture ()
	Default ctor for all stack instances (not created with new) More...

	SLGLTexture (SLAssetManager *assetMgr, const SLVCol4f &colors, SLint min_filter=GL_LINEAR, SLint mag_filter=GL_LINEAR, SLint wrapS=GL_REPEAT, const SLstring &name="2D-Texture")
	ctor for 1D texture with internal image allocation More...

	SLGLTexture (SLAssetManager *assetMgr, SLint min_filter, SLint mag_filter, SLint wrapS, SLint wrapT, SLenum target=GL_TEXTURE_2D)
	ctor for empty 2D textures More...

	SLGLTexture (SLAssetManager assetMgr, unsigned char data, int width, int height, int cvtype, SLint min_filter, SLint mag_filter, SLTextureType type, SLint wrapS, SLint wrapT)
	ctor for 2D textures from byte pointer More...

	SLGLTexture (SLAssetManager *assetMgr, const SLstring &imageFilename, SLint min_filter=GL_LINEAR_MIPMAP_LINEAR, SLint mag_filter=GL_LINEAR, SLTextureType type=TT_unknown, SLint wrapS=GL_REPEAT, SLint wrapT=GL_REPEAT)
	ctor for 2D textures with internal image allocation More...

	SLGLTexture (SLAssetManager *assetMgr, const SLVstring &imageFilenames, SLint min_filter=GL_LINEAR, SLint mag_filter=GL_LINEAR, SLint wrapS=GL_REPEAT, SLint wrapT=GL_REPEAT, const SLstring &name="3D-Texture", SLbool loadGrayscaleIntoAlpha=false)
	ctor for 3D texture with internal image allocation More...

	SLGLTexture (SLAssetManager *assetMgr, SLint depth, const SLstring &imageFilename, SLint min_filter=GL_LINEAR, SLint mag_filter=GL_LINEAR, SLint wrapS=GL_REPEAT, SLint wrapT=GL_REPEAT, const SLstring &name="3D-Texture", SLbool loadGrayscaleIntoAlpha=false)
	ctor for 3D texture from a single file with depth as 3rd dimension More...

	SLGLTexture (SLAssetManager *assetMgr, const SLstring &imageFilenameXPos, const SLstring &imageFilenameXNeg, const SLstring &imageFilenameYPos, const SLstring &imageFilenameYNeg, const SLstring &imageFilenameZPos, const SLstring &imageFilenameZNeg, SLint min_filter=GL_LINEAR, SLint mag_filter=GL_LINEAR, SLTextureType type=TT_unknown)
	ctor for cube mapping with internal image allocation More...

	~SLGLTexture () override

virtual void	build (SLint texUnit)

void	deleteData (SLbool deleteAlsoOnGPU)
	Delete all data (CVImages and GPU textures) More...

void	deleteDataGpu ()
	Deletes the OpenGL texture objects and releases the memory on the GPU. More...

void	deleteImages ()
	Deletes the CVImages in _images. No more texture mapping in ray tracing. More...

void	bindActive (SLuint texUnit=0)

void	fullUpdate ()

void	drawSprite (SLbool doUpdate, SLfloat x, SLfloat y, SLfloat w, SLfloat h)
	Draws the texture as 2D sprite with OpenGL buffers. More...

void	cubeUV2XYZ (SLint index, SLfloat u, SLfloat v, SLfloat &x, SLfloat &y, SLfloat &z)
	Computes the unnormalised vector x,y,z from tex. coords. uv with cubemap index. More...

void	cubeXYZ2UV (SLfloat x, SLfloat y, SLfloat z, SLint &index, SLfloat &u, SLfloat &v)
	Computes the uv and cubemap image index from a unnormalised vector x,y,z. More...

SLstring	filterString (SLint glFilter)
	Returns OpenGL texture filter as string. More...

void	texType (SLTextureType bt)

void	uvIndex (SLbyte i)

void	bumpScale (SLfloat bs)

void	minFiler (SLint minF)

void	magFiler (SLint magF)

void	needsUpdate (SLbool update)

void	textureSize (int width, int height)

void	deleteImageAfterBuild (SLbool delImg)
	If deleteImageAfterBuild is set to true you won't be able to ray trace the scene. More...

SLuint	width ()

SLuint	height ()

SLuint	depth ()

SLbyte	uvIndex ()

SLint	bytesPerPixel ()

SLint	bytesOnGPU ()

SLint	bytesInFile ()

CVVImage &	images ()

SLenum	target () const

SLuint	texID () const

SLTextureType	texType ()

SLfloat	bumpScale () const

SLCol4f	getTexelf (SLfloat u, SLfloat v, SLuint imgIndex=0)
	SLGLTexture::getTexelf returns a pixel color from u & v texture coordinates. More...

SLCol4f	getTexelf (const SLVec3f &cubemapDir)
	SLGLTexture::getTexelf returns a pixel color at the specified cubemap direction. More...

SLbool	hasAlpha ()

SLMat4f	tm ()

SLbool	autoCalcTM3D () const

SLbool	needsUpdate ()

SLstring	typeName ()
	Returns the texture type as string. More...

SLstring	typeShortName ()
	Returns the texture type short. More...

bool	isTexture ()

SLstring	minificationFilterName ()

SLstring	magnificationFilterName ()

void	build2DMipmaps (SLint target, SLuint index)

SLbool	copyVideoImage (SLint camWidth, SLint camHeight, CVPixelFormatGL glFormat, SLuchar *data, SLbool isContinuous, SLbool isTopLeft)
	Copies the image data from a video camera into the current video image. More...

SLbool	copyVideoImage (SLint camWidth, SLint camHeight, CVPixelFormatGL srcFormat, CVPixelFormatGL dstFormat, SLuchar *data, SLbool isContinuous, SLbool isTopLeft)

void	calc3DGradients (SLint sampleRadius, const function< void(int)> &onUpdateProgress=nullptr)

void	smooth3DGradients (SLint smoothRadius, function< void(int)> onUpdateProgress=nullptr)

SLVec2f	dudv (SLfloat u, SLfloat v)

Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")

virtual	~SLObject ()

void	name (const SLstring &Name)

void	url (const SLstring &url)

const SLstring &	name () const

const SLstring &	url () const

Public Attributes
SLTexFontChar	chars [256]

SLint	charsHeight

SLGLProgram *	_fontTexProgram = nullptr

bool	_deleteProgram = false

Additional Inherited Members
Static Public Member Functions inherited from SLGLTexture
static SLTextureType	detectType (const SLstring &filename)
	Detects the texture type from the filename appendix (See SLTexType def.) More...

static string	internalFormatStr (int internalFormat)
	Returns the internal pixel format from OpenGL. More...

Static Public Attributes inherited from SLGLTexture
static SLfloat	maxAnisotropy = -1.0f
	Returns the derivation as [s,t]. More...

static SLuint	totalNumBytesOnGPU = 0
	Total NO. of bytes used for textures on GPU. More...

Protected Member Functions inherited from SLGLTexture
void	load (const SLstring &filename, SLbool flipVertical=true, SLbool loadGrayscaleIntoAlpha=false)
	Loads the texture, converts color depth & applies vertical mirroring. More...

void	load (const SLVCol4f &colors)
	Loads the 1D color data into an image of height 1. More...

Protected Attributes inherited from SLGLTexture
CVVImage	_images
	Vector of CVImage pointers. More...

SLuint	_texID
	OpenGL texture ID. More...

SLTextureType	_texType
	See SLTextureType. More...

SLint	_width
	Texture image width in pixels (images exist either in _images or on the GPU or on both) More...

SLint	_height
	Texture image height in pixels (images exist either in _images or on the GPU or on both) More...

SLint	_depth
	3D Texture image depth (images exist either in _images or on the GPU or on both) More...

SLbyte	_uvIndex
	Texture coordinate index in SLMesh (0 = default) More...

SLint	_internalFormat
	Internal OpenGL format. More...

SLint	_bytesPerPixel
	Bytes per texture image pixel (images exist either in _images or on the GPU or on both) More...

SLint	_min_filter
	Minification filter. More...

SLint	_mag_filter
	Magnification filter. More...

SLint	_wrap_s
	Wrapping in s direction. More...

SLint	_wrap_t
	Wrapping in t direction. More...

SLenum	_target
	texture target More...

SLMat4f	_tm
	texture matrix More...

SLuint	_bytesOnGPU
	NO. of bytes on GPU. More...

SLuint	_bytesInFile
	NO. of bytes in file. More...

SLbool	_autoCalcTM3D
	Flag if texture matrix should be calculated from AABB for 3D mapping. More...

SLfloat	_bumpScale
	Bump mapping scale factor. More...

SLbool	_resizeToPow2
	Flag if image should be resized to n^2. More...

SLGLVertexArray	_vaoSprite
	Vertex array object for sprite rendering. More...

std::atomic< bool >	_needsUpdate {}
	Flag if image needs an single update. More...

std::mutex	_mutex
	Mutex to protect parallel access (used in ray tracing) More...

SLbool	_deleteImageAfterBuild
	Flag if images should be deleted after build on GPU. More...

SLbool	_compressedTexture = false
	True for compressed texture format on GPU. More...

Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...

SLstring	_url
	uniform resource locator More...

Detailed Description

Texture Font class inherits SLGLTexture for alpha blended font rendering.

This texture font class was originally inspired by the the font class of the AntTweakBar library (http://www.antisphere.com/Wiki/tools:anttweakbar) The source bitmap includes 224 characters starting from ascii char 32 (space) to ascii char 255:

 !"#$%&'()*+,-./0123456789:;<=>?
@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_
`abcdefghijklmnopqrstuvwxyz{|}~
���������������������������������������������������������������
��������������������������������
��������������������������������

First column of a source bitmap is a delimiter with color=zero at the end of each line of characters. Last row of a line of characters is a delimiter with color=zero at the last pixel of each character. The source bitmaps for the fonts are in the folder _data/fonts. The where used for design only. Their data is directly included a binary array in the source file SLTexFont.cpp.

Definition at line 39 of file SLTexFont.h.

Constructor & Destructor Documentation

◆ SLTexFont() [1/2]

SLTexFont::SLTexFont	(	SLstring	fontFilename,
		SLGLProgram *	fontTexProgram
	)

Definition at line 19 of file SLTexFont.cpp.

 {
     assert(fontTexProgram);
     _fontTexProgram = fontTexProgram;
     _deleteProgram  = false;
  
     // Init texture members
     _texType    = TT_font;
     _wrap_s     = GL_CLAMP_TO_EDGE;
     _wrap_t     = GL_CLAMP_TO_EDGE;
     _min_filter = GL_NEAREST;
     _mag_filter = GL_NEAREST;
  
     for (auto& i : chars)
     {
         i.width = 0;
         i.tx1   = 0;
         i.tx2   = 0;
         i.ty1   = 0;
         i.ty2   = 0;
     }
     charsHeight = 0;
  
     create(std::move(fontFilename));
 }

◆ SLTexFont() [2/2]

SLTexFont::SLTexFont	(	SLstring	fontFilename,
		SLstring	shaderDir
	)

Definition at line 45 of file SLTexFont.cpp.

 {
     _fontTexProgram = new SLGLProgramGeneric(nullptr, shaderDir + "FontTex.vert", shaderDir + "FontTex.frag");
     _deleteProgram  = true;
  
     // Init texture members
     _texType    = TT_font;
     _wrap_s     = GL_CLAMP_TO_EDGE;
     _wrap_t     = GL_CLAMP_TO_EDGE;
     _min_filter = GL_NEAREST;
     _mag_filter = GL_NEAREST;
  
     for (auto& i : chars)
     {
         i.width = 0;
         i.tx1   = 0;
         i.tx2   = 0;
         i.ty1   = 0;
         i.ty2   = 0;
     }
     charsHeight = 0;
  
     create(std::move(fontFilename));
 }

◆ ~SLTexFont()

SLTexFont::~SLTexFont ( )

Definition at line 70 of file SLTexFont.cpp.

 {
     if (_deleteProgram && _fontTexProgram)
     {
         delete _fontTexProgram;
     }
 }

Member Function Documentation

◆ buildTextBuffers()

void SLTexFont::buildTextBuffers	(	SLGLVertexArray &	vao,
		const SLstring &	text,
		SLfloat	maxWidth = `0.0f`,
		SLfloat	lineHeight = `1.5f`
	)

Builds the vertex array object with 2 texture mapped triangles per character. The text width < maxWidth the text will be on one line. If it is wider it will be split into multiple lines with a height = font height * lineHeight.

Parameters

vao	external vertex array object
text	text to render
maxWidth	max. width for multi-line text
lineHeight	line height factor

Definition at line 345 of file SLTexFont.cpp.

 {
     SLVstring lines;    // Vector of text lines
     SLVVec2f  sizes;    // Sizes of text lines
     size_t    numP = 0; // No. of vertices
     size_t    numI = 0; // No. of indices (3 per triangle)
     SLfloat   x;        // current lower-left x position
     SLfloat   y;        // current lower-left y position
     SLuint    iV;       // current vertex index
     SLuint    iI;       // current vertex index index
  
     // Calculate number of vertices & indices
     if (maxWidth > 0.0f)
     {
         // multiple text lines
         lines = wrapTextToLines(text, maxWidth);
         for (auto& line : lines)
         {
             numP += line.length();
             sizes.push_back(calcTextSize(line));
         }
         numP *= 4;
         numI = numP * 2 * 3;
     }
     else
     {
         // single text line
         lines.push_back(text);
         numP = text.length() * 4;
         numI = text.length() * 2 * 3;
     }
  
     SLVVec3f P;
     P.resize(numP); // Vertex positions
     SLVVec2f T;
     T.resize(numP); // Vertex texture coords.
     SLVushort I;
     I.resize(numI); // Indexes
  
     iV = iI = 0;
     y       = ((SLfloat)lines.size() - 1) * (SLfloat)charsHeight * lineHeight;
  
     for (auto& line : lines)
     {
         x = 0;
  
         // Loop through characters
         for (char c : line)
         {
             // Get width and height
             SLfloat w = chars[(SLuint)c].width;
             SLfloat h = (SLfloat)charsHeight;
  
             // Specify texture coordinates
             T[iV].set(chars[(SLuint)c].tx1, chars[(SLuint)c].ty2);
             T[iV + 1].set(chars[(SLuint)c].tx2, chars[(SLuint)c].ty2);
             T[iV + 2].set(chars[(SLuint)c].tx2, chars[(SLuint)c].ty1);
             T[iV + 3].set(chars[(SLuint)c].tx1, chars[(SLuint)c].ty1);
  
             // vertices of the character quad
             P[iV].set(x, y);
             P[iV + 1].set(x + w, y);
             P[iV + 2].set(x + w, y + h);
             P[iV + 3].set(x, y + h);
  
             // triangle indices of the character quad
             I[iI++] = (SLushort)iV;
             I[iI++] = (SLushort)iV + 1;
             I[iI++] = (SLushort)iV + 3;
             I[iI++] = (SLushort)iV + 1;
             I[iI++] = (SLushort)iV + 2;
             I[iI++] = (SLushort)iV + 3;
  
             // Move to next character
             iV += 4;
             x += w;
         }
  
         y -= (SLfloat)charsHeight * lineHeight;
     }
  
     // create buffers on GPU
     SLGLProgram* sp = _fontTexProgram;
     sp->useProgram();
     vao.setAttrib(AT_position, AT_position, &P);
     vao.setAttrib(AT_uv1, AT_uv1, &T);
     vao.setIndices(&I);
     vao.generate((SLuint)numP);
 }

◆ calcTextSize()

SLVec2f SLTexFont::calcTextSize	(	const SLstring &	text,
		SLfloat	maxWidth = `0.0f`,
		SLfloat	lineHeightFactor = `1.5f`
	)

Returns the size (width & height) of the full text in float pixels. If a max. width is passed the text is first wrapped into multiple lines. For multiline text the line height is calculate as the font height * lineHeightFactor.

Definition at line 243 of file SLTexFont.cpp.

 {
     SLVec2f size(0, 0);
  
     if (maxWidth > 0.0f)
     {
         SLfloat   maxX  = FLT_MIN;
         SLVstring lines = wrapTextToLines(text, maxWidth);
         for (const auto& line : lines)
         {
             SLVec2f sizeLine = calcTextSize(line);
             if (sizeLine.x > maxX) maxX = sizeLine.x;
         }
         size.x = maxX;
         size.y = (SLfloat)(lines.size() - 1) * (SLfloat)charsHeight * lineHeightFactor;
         size.y += (SLfloat)charsHeight;
     }
     else
     { // Loop through each character of text
         for (char c : text)
         {
             size.x += chars[(SLuint)c].width;
         }
         size.y = (SLfloat)charsHeight;
     }
     return size;
 }

◆ create()

void SLTexFont::create ( SLstring fontFilename )

SLTexFont::create creates the inherited texture map with the passed image file. The bitmap image is parsed for all 224 character positions to create the according texture coordinate.

Definition at line 83 of file SLTexFont.cpp.

 {
     // Check the font filename with path
     if (!SLFileStorage::exists(fontFilename, IOK_font))
     {
         SLstring msg = "SLTexFont::create: File not found: " + fontFilename;
         SL_EXIT_MSG(msg.c_str());
     }
  
     CVImage img;
     img.load(fontFilename, false);
  
     // find height of the font
     SLint    x, y;
     SLint    bmpW = img.cvMat().cols;
     SLint    bmpH = img.cvMat().rows;
     SLuchar* bmp  = img.cvMat().data;
     SLint    h = 0, hh = 0;
     SLint    r, NbRow  = 0;
  
     for (y = 0; y < bmpH; ++y)
     {
         if (bmp[y * bmpW] == 0)
         {
             if ((hh <= 0 && h <= 0) || (h != hh && h > 0 && hh > 0))
                 SL_EXIT_MSG("Cannot determine font height (check first pixel column)");
             else if (h <= 0)
                 h = hh;
             else if (hh <= 0)
                 break;
             hh = 0;
             ++NbRow;
         }
         else
             ++hh;
     }
  
     // find width and position of each character
     SLint x0[224], y0[224], x1[224], y1[224];
     SLint ch = 32;
     SLint start;
     for (r = 0; r < NbRow; ++r)
     {
         start = 1;
         for (x = 1; x < bmpW; ++x)
         {
             if (bmp[(r * (h + 1) + h) * bmpW + x] == 0 || x == bmpW - 1)
             {
                 if (x == start) break; // next row
                 if (ch < 256)
                 {
                     x0[ch - 32] = start;
                     x1[ch - 32] = x;
                     y0[ch - 32] = r * (h + 1);
                     y1[ch - 32] = r * (h + 1) + h - 1;
                     start       = x + 1;
                 }
                 ++ch;
             }
         }
     }
  
     for (x = ch - 32; x < 224; ++x)
     {
         x0[x] = 0;
         y0[x] = 0;
         x1[x] = 0;
         y1[x] = 0;
     }
  
     // Repack: build 14 rows of 16 characters. First, find the largest row
     SLint l, lmax = 1;
     for (r = 0; r < 14; ++r)
     {
         l = 0;
         for (x = 0; x < 16; ++x)
             l += x1[x + r * 16] - x0[x + r * 16] + 1;
         if (l > lmax) lmax = l;
     }
  
     // A little empty margin is added between chars to avoid artefact when anti aliasing is on
     const SLint MARGIN_X = 2;
     const SLint MARGIN_Y = 2;
     lmax += 16 * MARGIN_X;
  
     // 2) build the texture
     charsHeight      = h;
     SLuint texWidth  = Utils::nextPowerOf2((SLuint)lmax);
     SLuint texHeight = Utils::nextPowerOf2(14 * (SLuint)(h + MARGIN_Y));
  
     // Fill up with 0
     SLuchar* bits = new SLuchar[texWidth * texHeight];
     memset(bits, 0, texWidth * texHeight);
  
     SLfloat du = 0.0f;
     SLfloat dv = 0.0f;
  
     for (r = 0; r < 14; ++r)
     {
         for (SLint xx = 0, ch = r * 16; ch < (r + 1) * 16; ++ch)
         {
             if (y1[ch] - y0[ch] == h - 1)
             {
                 for (y = 0; y < h; ++y)
                 {
                     for (x = x0[ch]; x <= x1[ch]; ++x)
                     {
                         SLfloat alpha = ((SLfloat)(bmp[x + (y0[ch] + y) * bmpW])) / 256.0f;
                         // alpha = alpha*sqrtf(alpha); // powf(alpha, 1.5f);   // some gamma correction
                         bits[(SLuint)(xx + x - x0[ch]) +
                              (SLuint)(r * (h + MARGIN_Y) + y) * texWidth] = (SLuchar)(alpha * 256.0f);
                     }
                 }
                 chars[ch + 32].tx1 = ((SLfloat)xx + du) / (SLfloat)texWidth;
                 xx += x1[ch] - x0[ch] + 1;
                 chars[ch + 32].tx2   = ((SLfloat)xx + du) / (SLfloat)texWidth;
                 chars[ch + 32].ty1   = ((SLfloat)(r * (h + MARGIN_Y)) + dv) / (SLfloat)texHeight;
                 chars[ch + 32].ty2   = ((SLfloat)(r * (h + MARGIN_Y) + h) + dv) / (SLfloat)texHeight;
                 chars[ch + 32].width = (SLfloat)(x1[ch] - x0[ch] + 1);
                 xx += MARGIN_X;
             }
         }
     }
  
     // Allocate memory for image pixels using only the alpha channel
     _images.clear();
     SLGLState*      stateGL = SLGLState::instance();
     CVPixelFormatGL format  = stateGL->pixelFormatIsSupported(PF_luminance) ? PF_luminance : PF_red;
     _images.push_back(new CVImage((SLint)texWidth,
                                   (SLint)texHeight,
                                   format,
                                   fontFilename));
     _images[0]->load((SLint)texWidth,
                      (SLint)texHeight,
                      format,
                      format,
                      bits,
                      true,
                      false);
     delete[] bits;
     _width  = _images[0]->width();
     _height = _images[0]->height();
     _depth  = (SLint)_images.size();
  
     // Set characters below 32 to default
     const SLuchar Undef = 127; // default character used as for undifined ones (having ascii codes from 0 to 31)
     for (ch = 0; ch < 32; ++ch)
     {
         chars[ch].tx1   = chars[Undef].tx1;
         chars[ch].tx2   = chars[Undef].tx2;
         chars[ch].ty1   = chars[Undef].ty1;
         chars[ch].ty2   = chars[Undef].ty2;
         chars[ch].width = chars[Undef].width;
     }
 }

◆ fontTexProgram()

SLGLProgram* SLTexFont::fontTexProgram ( )

inline

Definition at line 56 of file SLTexFont.h.

56 { return _fontTexProgram; }

◆ wrapTextToLines()

SLVstring SLTexFont::wrapTextToLines	(	SLstring	text,
		SLfloat	maxW
	)

Returns a vector of strings of the text to be wrapped to a max. with of maxW. The sum of all characters in lines must be equal to the length of the input text

Definition at line 277 of file SLTexFont.cpp.

 {
     SLVstring lines;
     SLfloat   curX       = 0.0f;
     SLfloat   maxX       = FLT_MIN;
     SLfloat   xBlank     = 0.0f;
     SLuint    iBlank     = 0;
     SLuint    iLineStart = 0;
     SLuint    len        = (SLuint)text.length();
  
     // Loop through each character of text
     for (SLuint i = 0; i < len; ++i)
     {
         SLchar c = text[i];
  
         if (c == '\\' && i < len - 1 && text[i + 1] == 'n')
         {
             i++;
             if (curX > maxX) maxX = curX;
             lines.push_back(text.substr(iLineStart, i - iLineStart - 1) + "  ");
             iLineStart = i + 1;
             curX       = 0.0f;
         }
         else // add next character
         {
             // keep last blank x
             if (c == ' ')
             {
                 xBlank = curX;
                 iBlank = i;
             }
  
             curX += chars[(SLuint)c].width;
  
             // if width exceeded wrap at last blank position
             if (curX > maxW)
             { // wrap at last blank
                 if (xBlank > 0.0f)
                 {
                     // keep largest line width
                     if (xBlank > maxX) maxX = xBlank;
                     curX = curX - xBlank - chars[(SLuint)' '].width;
                     lines.push_back(text.substr(iLineStart, iBlank - iLineStart + 1));
                     iLineStart = iBlank + 1;
                 }
                 else // wrap in the word
                 {
                     if (curX - chars[(SLuint)c].width > maxX)
                         maxX = curX - chars[(SLuint)c].width;
                     lines.push_back(text.substr(iLineStart, i - iLineStart));
                     curX       = chars[(SLuint)c].width;
                     iLineStart = i + 1;
                 }
             }
         }
     }
     SLstring newLine = text.substr(iLineStart, len - iLineStart);
     lines.push_back(newLine);
     return lines;
 }

Member Data Documentation

◆ _deleteProgram

bool SLTexFont::_deleteProgram = false

Definition at line 72 of file SLTexFont.h.

◆ _fontTexProgram

SLGLProgram* SLTexFont::_fontTexProgram = nullptr

Definition at line 71 of file SLTexFont.h.

◆ chars

SLTexFontChar SLTexFont::chars[256]

Definition at line 68 of file SLTexFont.h.

◆ charsHeight

SLint SLTexFont::charsHeight

Definition at line 69 of file SLTexFont.h.

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Public Attributes

Additional Inherited Members