开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llfontgl.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：28k
源码类别：

游戏引擎

开发平台：

C++ Builder

llfontgl.cpp：源码内容
  1. /** 
  2.  * @file llfontgl.cpp
  3.  * @brief Wrapper around FreeType
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. #include "llfontgl.h"
  37. // Linden library includes
  38. #include "llfontfreetype.h"
  39. #include "llfontbitmapcache.h"
  40. #include "llfontregistry.h"
  41. #include "llgl.h"
  42. #include "llimagegl.h"
  43. #include "llrender.h"
  44. #include "llstl.h"
  45. #include "v4color.h"
  46. #include "lltexture.h"
  47. #include "lldir.h"
  49. // Third party library includes
  50. #include <boost/tokenizer.hpp>
  52. const S32 BOLD_OFFSET = 1;
  54. // static class members
  55. F32 LLFontGL::sVertDPI = 96.f;
  56. F32 LLFontGL::sHorizDPI = 96.f;
  57. F32 LLFontGL::sScaleX = 1.f;
  58. F32 LLFontGL::sScaleY = 1.f;
  59. BOOL LLFontGL::sDisplayFont = TRUE ;
  60. std::string LLFontGL::sAppDir;
  62. LLColor4 LLFontGL::sShadowColor(0.f, 0.f, 0.f, 1.f);
  63. LLFontRegistry* LLFontGL::sFontRegistry = NULL;
  65. LLCoordFont LLFontGL::sCurOrigin;
  66. std::vector<LLCoordFont> LLFontGL::sOriginStack;
  68. const F32 EXT_X_BEARING = 1.f;
  69. const F32 EXT_Y_BEARING = 0.f;
  70. const F32 EXT_KERNING = 1.f;
  71. const F32 PIXEL_BORDER_THRESHOLD = 0.0001f;
  72. const F32 PIXEL_CORRECTION_DISTANCE = 0.01f;
  74. const F32 PAD_UVY = 0.5f; // half of vertical padding between glyphs in the glyph texture
  75. const F32 DROP_SHADOW_SOFT_STRENGTH = 0.3f;
  77. static F32 llfont_round_x(F32 x)
  78. {
  79. //return llfloor((x-LLFontGL::sCurOrigin.mX)/LLFontGL::sScaleX+0.5f)*LLFontGL::sScaleX+LLFontGL::sCurOrigin.mX;
  80. //return llfloor(x/LLFontGL::sScaleX+0.5f)*LLFontGL::sScaleY;
  81. return x;
  82. }
  84. static F32 llfont_round_y(F32 y)
  85. {
  86. //return llfloor((y-LLFontGL::sCurOrigin.mY)/LLFontGL::sScaleY+0.5f)*LLFontGL::sScaleY+LLFontGL::sCurOrigin.mY;
  87. //return llfloor(y+0.5f);
  88. return y;
  89. }
  91. LLFontGL::LLFontGL()
  92. {
  93. }
  95. LLFontGL::~LLFontGL()
  96. {
  97. }
  99. void LLFontGL::reset()
  100. {
  101. mFontFreetype->reset(sVertDPI, sHorizDPI);
  102. }
  104. void LLFontGL::destroyGL()
  105. {
  106. mFontFreetype->destroyGL();
  107. }
  109. BOOL LLFontGL::loadFace(const std::string& filename, F32 point_size, F32 vert_dpi, F32 horz_dpi, S32 components, BOOL is_fallback)
  110. {
  111. if(mFontFreetype == reinterpret_cast<LLFontFreetype*>(NULL))
  112. {
  113. mFontFreetype = new LLFontFreetype;
  114. }
  116. return mFontFreetype->loadFace(filename, point_size, vert_dpi, horz_dpi, components, is_fallback);
  117. }
  119. static LLFastTimer::DeclareTimer FTM_RENDER_FONTS("Fonts");
  121. S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, const LLColor4 &color, HAlign halign, VAlign valign, U8 style, 
  122.  ShadowType shadow, S32 max_chars, S32 max_pixels, F32* right_x, BOOL use_ellipses) const
  123. {
  124. if(!sDisplayFont) //do not display texts
  125. {
  126. return wstr.length() ;
  127. }
  129. if (wstr.empty())
  130. {
  131. return 0;
  132. } 
  134. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  136. S32 scaled_max_pixels = max_pixels == S32_MAX ? S32_MAX : llceil((F32)max_pixels * sScaleX);
  138. // determine which style flags need to be added programmatically by stripping off the
  139. // style bits that are drawn by the underlying Freetype font
  140. U8 style_to_add = (style | mFontDescriptor.getStyle()) & ~mFontFreetype->getStyle();
  142. F32 drop_shadow_strength = 0.f;
  143. if (shadow != NO_SHADOW)
  144. {
  145. F32 luminance;
  146. color.calcHSL(NULL, NULL, &luminance);
  147. drop_shadow_strength = clamp_rescale(luminance, 0.35f, 0.6f, 0.f, 1.f);
  148. if (luminance < 0.35f)
  149. {
  150. shadow = NO_SHADOW;
  151. }
  152. }
  154. gGL.pushMatrix();
  155. glLoadIdentity();
  156. gGL.translatef(floorf(sCurOrigin.mX*sScaleX), floorf(sCurOrigin.mY*sScaleY), sCurOrigin.mZ);
  158. // this code snaps the text origin to a pixel grid to start with
  159. F32 pixel_offset_x = llround((F32)sCurOrigin.mX) - (sCurOrigin.mX);
  160. F32 pixel_offset_y = llround((F32)sCurOrigin.mY) - (sCurOrigin.mY);
  161. gGL.translatef(-pixel_offset_x, -pixel_offset_y, 0.f);
  163. LLFastTimer t(FTM_RENDER_FONTS);
  165. gGL.color4fv( color.mV );
  167. S32 chars_drawn = 0;
  168. S32 i;
  169. S32 length;
  171. if (-1 == max_chars)
  172. {
  173. length = (S32)wstr.length() - begin_offset;
  174. }
  175. else
  176. {
  177. length = llmin((S32)wstr.length() - begin_offset, max_chars );
  178. }
  180. F32 cur_x, cur_y, cur_render_x, cur_render_y;
  182.   // Not guaranteed to be set correctly
  183. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  185. cur_x = ((F32)x * sScaleX);
  186. cur_y = ((F32)y * sScaleY);
  188. // Offset y by vertical alignment.
  189. switch (valign)
  190. {
  191. case TOP:
  192. cur_y -= mFontFreetype->getAscenderHeight();
  193. break;
  194. case BOTTOM:
  195. cur_y += mFontFreetype->getDescenderHeight();
  196. break;
  197. case VCENTER:
  198. cur_y -= (mFontFreetype->getAscenderHeight() - mFontFreetype->getDescenderHeight()) / 2.f;
  199. break;
  200. case BASELINE:
  201. // Baseline, do nothing.
  202. break;
  203. default:
  204. break;
  205. }
  207. switch (halign)
  208. {
  209. case LEFT:
  210. break;
  211. case RIGHT:
  212.    cur_x -= llmin(scaled_max_pixels, llround(getWidthF32(wstr.c_str(), begin_offset, length) * sScaleX));
  213. break;
  214. case HCENTER:
  215.     cur_x -= llmin(scaled_max_pixels, llround(getWidthF32(wstr.c_str(), begin_offset, length) * sScaleX)) / 2;
  216. break;
  217. default:
  218. break;
  219. }
  221. cur_render_y = cur_y;
  222. cur_render_x = cur_x;
  224. F32 start_x = llround(cur_x);
  226. const LLFontBitmapCache* font_bitmap_cache = mFontFreetype->getFontBitmapCache();
  228. F32 inv_width = 1.f / font_bitmap_cache->getBitmapWidth();
  229. F32 inv_height = 1.f / font_bitmap_cache->getBitmapHeight();
  231. const S32 LAST_CHARACTER = LLFontFreetype::LAST_CHAR_FULL;
  234. BOOL draw_ellipses = FALSE;
  235. if (use_ellipses)
  236. {
  237. // check for too long of a string
  238. S32 string_width = llround(getWidthF32(wstr.c_str(), begin_offset, max_chars) * sScaleX);
  239. if (string_width > scaled_max_pixels)
  240. {
  241. // use four dots for ellipsis width to generate padding
  242. const LLWString dots(utf8str_to_wstring(std::string("....")));
  243. scaled_max_pixels = llmax(0, scaled_max_pixels - llround(getWidthF32(dots.c_str())));
  244. draw_ellipses = TRUE;
  245. }
  246. }
  249. // Remember last-used texture to avoid unnecesssary bind calls.
  250. LLImageGL *last_bound_texture = NULL;
  252. const LLFontGlyphInfo* next_glyph = NULL;
  254. for (i = begin_offset; i < begin_offset + length; i++)
  255. {
  256. llwchar wch = wstr[i];
  258. const LLFontGlyphInfo* fgi = next_glyph;
  259. next_glyph = NULL;
  260. if(!fgi)
  261. {
  262. fgi = mFontFreetype->getGlyphInfo(wch);
  263. }
  264. if (!fgi)
  265. {
  266. llerrs << "Missing Glyph Info" << llendl;
  267. break;
  268. }
  269. // Per-glyph bitmap texture.
  270. LLImageGL *image_gl = mFontFreetype->getFontBitmapCache()->getImageGL(fgi->mBitmapNum);
  271. if (last_bound_texture != image_gl)
  272. {
  273. gGL.getTexUnit(0)->bind(image_gl);
  274. last_bound_texture = image_gl;
  275. }
  277. if ((start_x + scaled_max_pixels) < (cur_x + fgi->mXBearing + fgi->mWidth))
  278. {
  279. // Not enough room for this character.
  280. break;
  281. }
  283. // Draw the text at the appropriate location
  284. //Specify vertices and texture coordinates
  285. LLRectf uv_rect((fgi->mXBitmapOffset) * inv_width,
  286. (fgi->mYBitmapOffset + fgi->mHeight + PAD_UVY) * inv_height,
  287. (fgi->mXBitmapOffset + fgi->mWidth) * inv_width,
  288. (fgi->mYBitmapOffset - PAD_UVY) * inv_height);
  289. // snap glyph origin to whole screen pixel
  290. LLRectf screen_rect(llround(cur_render_x + (F32)fgi->mXBearing),
  291.     llround(cur_render_y + (F32)fgi->mYBearing),
  292.     llround(cur_render_x + (F32)fgi->mXBearing) + (F32)fgi->mWidth,
  293.     llround(cur_render_y + (F32)fgi->mYBearing) - (F32)fgi->mHeight);
  295. drawGlyph(screen_rect, uv_rect, color, style_to_add, shadow, drop_shadow_strength);
  297. chars_drawn++;
  298. cur_x += fgi->mXAdvance;
  299. cur_y += fgi->mYAdvance;
  301. llwchar next_char = wstr[i+1];
  302. if (next_char && (next_char < LAST_CHARACTER))
  303. {
  304. // Kern this puppy.
  305. next_glyph = mFontFreetype->getGlyphInfo(next_char);
  306. cur_x += mFontFreetype->getXKerning(fgi, next_glyph);
  307. }
  309. // Round after kerning.
  310. // Must do this to cur_x, not just to cur_render_x, otherwise you
  311. // will squish sub-pixel kerned characters too close together.
  312. // For example, "CCCCC" looks bad.
  313. cur_x = (F32)llround(cur_x);
  314. //cur_y = (F32)llround(cur_y);
  316. cur_render_x = cur_x;
  317. cur_render_y = cur_y;
  318. }
  320. if (right_x)
  321. {
  322. *right_x = cur_x / sScaleX;
  323. }
  325. if (style_to_add & UNDERLINE)
  326. {
  327. F32 descender = mFontFreetype->getDescenderHeight();
  329. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  330. gGL.begin(LLRender::LINES);
  331. gGL.vertex2f(start_x, cur_y - (descender));
  332. gGL.vertex2f(cur_x, cur_y - (descender));
  333. gGL.end();
  334. }
  336. if (draw_ellipses)
  337. {
  339. // recursively render ellipses at end of string
  340. // we've already reserved enough room
  341. gGL.pushMatrix();
  342. //glLoadIdentity();
  343. //gGL.translatef(sCurOrigin.mX, sCurOrigin.mY, 0.0f);
  344. //glScalef(sScaleX, sScaleY, 1.f);
  345. renderUTF8(std::string("..."), 
  346. 0,
  347. cur_x / sScaleX, (F32)y,
  348. color,
  349. LEFT, valign,
  350. style_to_add,
  351. shadow,
  352. S32_MAX, max_pixels,
  353. right_x,
  354. FALSE); 
  355. gGL.popMatrix();
  356. }
  358. gGL.popMatrix();
  360. return chars_drawn;
  361. }
  363. S32 LLFontGL::render(const LLWString &text, S32 begin_offset, F32 x, F32 y, const LLColor4 &color) const
  364. {
  365. return render(text, begin_offset, x, y, color, LEFT, BASELINE, NORMAL, NO_SHADOW, S32_MAX, S32_MAX, NULL, FALSE);
  366. }
  368. S32 LLFontGL::renderUTF8(const std::string &text, S32 begin_offset, F32 x, F32 y, const LLColor4 &color, HAlign halign,  VAlign valign, U8 style, ShadowType shadow, S32 max_chars, S32 max_pixels,  F32* right_x, BOOL use_ellipses) const
  369. {
  370. return render(utf8str_to_wstring(text), begin_offset, x, y, color, halign, valign, style, shadow, max_chars, max_pixels, right_x, use_ellipses);
  371. }
  373. S32 LLFontGL::renderUTF8(const std::string &text, S32 begin_offset, S32 x, S32 y, const LLColor4 &color) const
  374. {
  375. return renderUTF8(text, begin_offset, (F32)x, (F32)y, color, LEFT, BASELINE, NORMAL, NO_SHADOW, S32_MAX, S32_MAX, NULL, FALSE);
  376. }
  378. S32 LLFontGL::renderUTF8(const std::string &text, S32 begin_offset, S32 x, S32 y, const LLColor4 &color, HAlign halign, VAlign valign, U8 style, ShadowType shadow) const
  379. {
  380. return renderUTF8(text, begin_offset, (F32)x, (F32)y, color, halign, valign, style, shadow, S32_MAX, S32_MAX, NULL, FALSE);
  381. }
  383. // font metrics - override for LLFontFreetype that returns units of virtual pixels
  384. F32 LLFontGL::getLineHeight() const
  385. { 
  386. return (F32)llround(mFontFreetype->getLineHeight() / sScaleY); 
  387. }
  389. F32 LLFontGL::getAscenderHeight() const
  390. { 
  391. return (F32)llround(mFontFreetype->getAscenderHeight() / sScaleY); 
  392. }
  394. F32 LLFontGL::getDescenderHeight() const
  395. { 
  396. return (F32)llround(mFontFreetype->getDescenderHeight() / sScaleY); 
  397. }
  399. S32 LLFontGL::getWidth(const std::string& utf8text) const
  400. {
  401. LLWString wtext = utf8str_to_wstring(utf8text);
  402. return getWidth(wtext.c_str(), 0, S32_MAX);
  403. }
  405. S32 LLFontGL::getWidth(const llwchar* wchars) const
  406. {
  407. return getWidth(wchars, 0, S32_MAX);
  408. }
  410. S32 LLFontGL::getWidth(const std::string& utf8text, S32 begin_offset, S32 max_chars) const
  411. {
  412. LLWString wtext = utf8str_to_wstring(utf8text);
  413. return getWidth(wtext.c_str(), begin_offset, max_chars);
  414. }
  416. S32 LLFontGL::getWidth(const llwchar* wchars, S32 begin_offset, S32 max_chars) const
  417. {
  418. F32 width = getWidthF32(wchars, begin_offset, max_chars);
  419. return llround(width);
  420. }
  422. F32 LLFontGL::getWidthF32(const std::string& utf8text) const
  423. {
  424. LLWString wtext = utf8str_to_wstring(utf8text);
  425. return getWidthF32(wtext.c_str(), 0, S32_MAX);
  426. }
  428. F32 LLFontGL::getWidthF32(const llwchar* wchars) const
  429. {
  430. return getWidthF32(wchars, 0, S32_MAX);
  431. }
  433. F32 LLFontGL::getWidthF32(const std::string& utf8text, S32 begin_offset, S32 max_chars ) const
  434. {
  435. LLWString wtext = utf8str_to_wstring(utf8text);
  436. return getWidthF32(wtext.c_str(), begin_offset, max_chars);
  437. }
  439. F32 LLFontGL::getWidthF32(const llwchar* wchars, S32 begin_offset, S32 max_chars) const
  440. {
  441. const S32 LAST_CHARACTER = LLFontFreetype::LAST_CHAR_FULL;
  443. F32 cur_x = 0;
  444. const S32 max_index = begin_offset + max_chars;
  446. const LLFontGlyphInfo* next_glyph = NULL;
  448. F32 width_padding = 0.f;
  449. for (S32 i = begin_offset; i < max_index && wchars[i] != 0; i++)
  450. {
  451. llwchar wch = wchars[i];
  453. const LLFontGlyphInfo* fgi = next_glyph;
  454. next_glyph = NULL;
  455. if(!fgi)
  456. {
  457. fgi = mFontFreetype->getGlyphInfo(wch);
  458. }
  460. F32 advance = mFontFreetype->getXAdvance(fgi);
  462. // for the last character we want to measure the greater of its width and xadvance values
  463. // so keep track of the difference between these values for the each character we measure
  464. // so we can fix things up at the end
  465. width_padding = llmax( 0.f, // always use positive padding amount
  466. width_padding - advance, // previous padding left over after advance of current character
  467. (F32)(fgi->mWidth + fgi->mXBearing) - advance); // difference between width of this character and advance to next character
  469. cur_x += advance;
  470. llwchar next_char = wchars[i+1];
  472. if (((i + 1) < begin_offset + max_chars) 
  473. && next_char 
  474. && (next_char < LAST_CHARACTER))
  475. {
  476. // Kern this puppy.
  477. next_glyph = mFontFreetype->getGlyphInfo(next_char);
  478. cur_x += mFontFreetype->getXKerning(fgi, next_glyph);
  479. }
  480. // Round after kerning.
  481. cur_x = (F32)llround(cur_x);
  482. }
  484. // add in extra pixels for last character's width past its xadvance
  485. cur_x += width_padding;
  487. return cur_x / sScaleX;
  488. }
  490. // Returns the max number of complete characters from text (up to max_chars) that can be drawn in max_pixels
  491. S32 LLFontGL::maxDrawableChars(const llwchar* wchars, F32 max_pixels, S32 max_chars, EWordWrapStyle end_on_word_boundary) const
  492. {
  493. if (!wchars || !wchars[0] || max_chars == 0)
  494. {
  495. return 0;
  496. }
  498. llassert(max_pixels >= 0.f);
  499. llassert(max_chars >= 0);
  501. BOOL clip = FALSE;
  502. F32 cur_x = 0;
  503. F32 drawn_x = 0;
  505. S32 start_of_last_word = 0;
  506. BOOL in_word = FALSE;
  508. // avoid S32 overflow when max_pixels == S32_MAX by staying in floating point
  509. F32 scaled_max_pixels = ceil(max_pixels * sScaleX);
  510. F32 width_padding = 0.f;
  512. LLFontGlyphInfo* next_glyph = NULL;
  514. S32 i;
  515. for (i=0; (i < max_chars); i++)
  516. {
  517. llwchar wch = wchars[i];
  519. if(wch == 0)
  520. {
  521. // Null terminator.  We're done.
  522. break;
  523. }
  525. if (in_word)
  526. {
  527. if (iswspace(wch))
  528. {
  529. if(wch !=(0x00A0))
  530. {
  531. in_word = FALSE;
  532. }
  533. }
  534. if (iswindividual(wch))
  535. {
  536. if (iswpunct(wchars[i+1]))
  537. {
  538. in_word=TRUE;
  539. }
  540. else
  541. {
  542. in_word=FALSE;
  543. start_of_last_word = i;
  544. }
  545. }
  546. }
  547. else
  548. {
  549. start_of_last_word = i;
  550. if (!iswspace(wch)||!iswindividual(wch))
  551. {
  552. in_word = TRUE;
  553. }
  554. }
  556. LLFontGlyphInfo* fgi = next_glyph;
  557. next_glyph = NULL;
  558. if(!fgi)
  559. {
  560. fgi = mFontFreetype->getGlyphInfo(wch);
  561. }
  563. // account for glyphs that run beyond the starting point for the next glyphs
  564. width_padding = llmax( 0.f, // always use positive padding amount
  565. width_padding - fgi->mXAdvance, // previous padding left over after advance of current character
  566. (F32)(fgi->mWidth + fgi->mXBearing) - fgi->mXAdvance); // difference between width of this character and advance to next character
  568. cur_x += fgi->mXAdvance;
  570. // clip if current character runs past scaled_max_pixels (using width_padding)
  571. if (scaled_max_pixels < cur_x + width_padding)
  572. {
  573. clip = TRUE;
  574. break;
  575. }
  577. if (((i+1) < max_chars) && wchars[i+1])
  578. {
  579. // Kern this puppy.
  580. next_glyph = mFontFreetype->getGlyphInfo(wchars[i+1]);
  581. cur_x += mFontFreetype->getXKerning(fgi, next_glyph);
  582. }
  584. // Round after kerning.
  585. cur_x = llround(cur_x);
  586. drawn_x = cur_x;
  587. }
  589. if( clip )
  590. {
  591. switch (end_on_word_boundary)
  592. {
  593. case ONLY_WORD_BOUNDARIES:
  594. i = start_of_last_word;
  595. break;
  596. case WORD_BOUNDARY_IF_POSSIBLE:
  597. if (start_of_last_word != 0)
  598. {
  599. i = start_of_last_word;
  600. }
  601. break;
  602. default:
  603. case ANYWHERE:
  604. // do nothing
  605. break;
  606. }
  607. }
  608. return i;
  609. }
  611. S32 LLFontGL::firstDrawableChar(const llwchar* wchars, F32 max_pixels, S32 text_len, S32 start_pos, S32 max_chars) const
  612. {
  613. if (!wchars || !wchars[0] || max_chars == 0)
  614. {
  615. return 0;
  616. }
  618. F32 total_width = 0.0;
  619. S32 drawable_chars = 0;
  621. F32 scaled_max_pixels = max_pixels * sScaleX;
  623. S32 start = llmin(start_pos, text_len - 1);
  624. for (S32 i = start; i >= 0; i--)
  625. {
  626. llwchar wch = wchars[i];
  628. const LLFontGlyphInfo* fgi= mFontFreetype->getGlyphInfo(wch);
  630. // last character uses character width, since the whole character needs to be visible
  631. // other characters just use advance
  632. F32 width = (i == start) 
  633. ? (F32)(fgi->mWidth + fgi->mXBearing)   // use actual width for last character
  634. : fgi->mXAdvance; // use advance for all other characters
  636. if( scaled_max_pixels < (total_width + width) )
  637. {
  638. break;
  639. }
  641. total_width += width;
  642. drawable_chars++;
  644. if( max_chars >= 0 && drawable_chars >= max_chars )
  645. {
  646. break;
  647. }
  649. if ( i > 0 )
  650. {
  651. // kerning
  652. total_width += mFontFreetype->getXKerning(wchars[i-1], wch);
  653. }
  655. // Round after kerning.
  656. total_width = llround(total_width);
  657. }
  659. if (drawable_chars == 0)
  660. {
  661. return start_pos; // just draw last character
  662. }
  663. else
  664. {
  665. // if only 1 character is drawable, we want to return start_pos as the first character to draw
  666. // if 2 are drawable, return start_pos and character before start_pos, etc.
  667. return start_pos + 1 - drawable_chars;
  668. }
  670. }
  672. S32 LLFontGL::charFromPixelOffset(const llwchar* wchars, S32 begin_offset, F32 target_x, F32 max_pixels, S32 max_chars, BOOL round) const
  673. {
  674. if (!wchars || !wchars[0] || max_chars == 0)
  675. {
  676. return 0;
  677. }
  679. F32 cur_x = 0;
  681. target_x *= sScaleX;
  683. // max_chars is S32_MAX by default, so make sure we don't get overflow
  684. const S32 max_index = begin_offset + llmin(S32_MAX - begin_offset, max_chars);
  686. F32 scaled_max_pixels = max_pixels * sScaleX;
  688. const LLFontGlyphInfo* next_glyph = NULL;
  690. S32 pos;
  691. for (pos = begin_offset; pos < max_index; pos++)
  692. {
  693. llwchar wch = wchars[pos];
  694. if (!wch)
  695. {
  696. break; // done
  697. }
  699. const LLFontGlyphInfo* glyph = next_glyph;
  700. next_glyph = NULL;
  701. if(!glyph)
  702. {
  703. glyph = mFontFreetype->getGlyphInfo(wch);
  704. }
  706. F32 char_width = mFontFreetype->getXAdvance(glyph);
  708. if (round)
  709. {
  710. // Note: if the mouse is on the left half of the character, the pick is to the character's left
  711. // If it's on the right half, the pick is to the right.
  712. if (target_x  < cur_x + char_width*0.5f)
  713. {
  714. break;
  715. }
  716. }
  717. else if (target_x  < cur_x + char_width)
  718. {
  719. break;
  720. }
  722. if (scaled_max_pixels < cur_x + char_width)
  723. {
  724. break;
  725. }
  727. cur_x += char_width;
  729. if (((pos + 1) < max_index)
  730. && (wchars[(pos + 1)]))
  731. {
  732. // Kern this puppy.
  733. next_glyph = mFontFreetype->getGlyphInfo(wchars[pos + 1]);
  734. cur_x += mFontFreetype->getXKerning(glyph, next_glyph);
  735. }
  738. // Round after kerning.
  739. cur_x = llround(cur_x);
  740. }
  742. return llmin(max_chars, pos - begin_offset);
  743. }
  745. const LLFontDescriptor& LLFontGL::getFontDesc() const
  746. {
  747. return mFontDescriptor;
  748. }
  750. // static
  751. void LLFontGL::initClass(F32 screen_dpi, F32 x_scale, F32 y_scale, const std::string& app_dir, const std::vector<std::string>& xui_paths, bool create_gl_textures)
  752. {
  753. sVertDPI = (F32)llfloor(screen_dpi * y_scale);
  754. sHorizDPI = (F32)llfloor(screen_dpi * x_scale);
  755. sScaleX = x_scale;
  756. sScaleY = y_scale;
  757. sAppDir = app_dir;
  759. // Font registry init
  760. if (!sFontRegistry)
  761. {
  762. sFontRegistry = new LLFontRegistry(xui_paths, create_gl_textures);
  763. sFontRegistry->parseFontInfo("fonts.xml");
  764. }
  765. else
  766. {
  767. sFontRegistry->reset();
  768. }
  769. }
  771. // Force standard fonts to get generated up front.
  772. // This is primarily for error detection purposes.
  773. // Don't do this during initClass because it can be slow and we want to get
  774. // the viewer window on screen first. JC
  775. // static
  776. bool LLFontGL::loadDefaultFonts()
  777. {
  778. bool succ = true;
  779. succ &= (NULL != getFontSansSerifSmall());
  780. succ &= (NULL != getFontSansSerif());
  781. succ &= (NULL != getFontSansSerifBig());
  782. succ &= (NULL != getFontSansSerifHuge());
  783. succ &= (NULL != getFontSansSerifBold());
  784. succ &= (NULL != getFontMonospace());
  785. succ &= (NULL != getFontExtChar());
  786. return succ;
  787. }
  789. // static
  790. void LLFontGL::destroyDefaultFonts()
  791. {
  792. // Remove the actual fonts.
  793. delete sFontRegistry;
  794. sFontRegistry = NULL;
  795. }
  797. //static 
  798. void LLFontGL::destroyAllGL()
  799. {
  800. if (sFontRegistry)
  801. {
  802. sFontRegistry->destroyGL();
  803. }
  804. }
  806. // static
  807. U8 LLFontGL::getStyleFromString(const std::string &style)
  808. {
  809. S32 ret = 0;
  810. if (style.find("NORMAL") != style.npos)
  811. {
  812. ret |= NORMAL;
  813. }
  814. if (style.find("BOLD") != style.npos)
  815. {
  816. ret |= BOLD;
  817. }
  818. if (style.find("ITALIC") != style.npos)
  819. {
  820. ret |= ITALIC;
  821. }
  822. if (style.find("UNDERLINE") != style.npos)
  823. {
  824. ret |= UNDERLINE;
  825. }
  826. return ret;
  827. }
  829. // static
  830. std::string LLFontGL::getStringFromStyle(U8 style)
  831. {
  832. std::string style_string;
  833. if (style & NORMAL)
  834. {
  835. style_string += "|NORMAL";
  836. }
  837. if (style & BOLD)
  838. {
  839. style_string += "|BOLD";
  840. }
  841. if (style & ITALIC)
  842. {
  843. style_string += "|ITALIC";
  844. }
  845. if (style & UNDERLINE)
  846. {
  847. style_string += "|UNDERLINE";
  848. }
  849. return style_string;
  850. }
  852. // static
  853. std::string LLFontGL::nameFromFont(const LLFontGL* fontp)
  854. {
  855. return fontp->mFontDescriptor.getName();
  856. }
  859. // static
  860. std::string LLFontGL::sizeFromFont(const LLFontGL* fontp)
  861. {
  862. return fontp->mFontDescriptor.getSize();
  863. }
  865. // static
  866. std::string LLFontGL::nameFromHAlign(LLFontGL::HAlign align)
  867. {
  868. if (align == LEFT) return std::string("left");
  869. else if (align == RIGHT) return std::string("right");
  870. else if (align == HCENTER) return std::string("center");
  871. else return std::string();
  872. }
  874. // static
  875. LLFontGL::HAlign LLFontGL::hAlignFromName(const std::string& name)
  876. {
  877. LLFontGL::HAlign gl_hfont_align = LLFontGL::LEFT;
  878. if (name == "left")
  879. {
  880. gl_hfont_align = LLFontGL::LEFT;
  881. }
  882. else if (name == "right")
  883. {
  884. gl_hfont_align = LLFontGL::RIGHT;
  885. }
  886. else if (name == "center")
  887. {
  888. gl_hfont_align = LLFontGL::HCENTER;
  889. }
  890. //else leave left
  891. return gl_hfont_align;
  892. }
  894. // static
  895. std::string LLFontGL::nameFromVAlign(LLFontGL::VAlign align)
  896. {
  897. if (align == TOP) return std::string("top");
  898. else if (align == VCENTER) return std::string("center");
  899. else if (align == BASELINE) return std::string("baseline");
  900. else if (align == BOTTOM) return std::string("bottom");
  901. else return std::string();
  902. }
  904. // static
  905. LLFontGL::VAlign LLFontGL::vAlignFromName(const std::string& name)
  906. {
  907. LLFontGL::VAlign gl_vfont_align = LLFontGL::BASELINE;
  908. if (name == "top")
  909. {
  910. gl_vfont_align = LLFontGL::TOP;
  911. }
  912. else if (name == "center")
  913. {
  914. gl_vfont_align = LLFontGL::VCENTER;
  915. }
  916. else if (name == "baseline")
  917. {
  918. gl_vfont_align = LLFontGL::BASELINE;
  919. }
  920. else if (name == "bottom")
  921. {
  922. gl_vfont_align = LLFontGL::BOTTOM;
  923. }
  924. //else leave baseline
  925. return gl_vfont_align;
  926. }
  928. //static
  929. LLFontGL* LLFontGL::getFontMonospace()
  930. {
  931. return getFont(LLFontDescriptor("Monospace","Monospace",0));
  932. }
  934. //static
  935. LLFontGL* LLFontGL::getFontSansSerifSmall()
  936. {
  937. return getFont(LLFontDescriptor("SansSerif","Small",0));
  938. }
  940. //static
  941. LLFontGL* LLFontGL::getFontSansSerif()
  942. {
  943. return getFont(LLFontDescriptor("SansSerif","Medium",0));
  944. }
  946. //static
  947. LLFontGL* LLFontGL::getFontSansSerifBig()
  948. {
  949. return getFont(LLFontDescriptor("SansSerif","Large",0));
  950. }
  952. //static 
  953. LLFontGL* LLFontGL::getFontSansSerifHuge()
  954. {
  955. return getFont(LLFontDescriptor("SansSerif","Huge",0));
  956. }
  958. //static 
  959. LLFontGL* LLFontGL::getFontSansSerifBold()
  960. {
  961. return getFont(LLFontDescriptor("SansSerif","Medium",BOLD));
  962. }
  964. //static
  965. LLFontGL* LLFontGL::getFontExtChar()
  966. {
  967. return getFontSansSerif();
  968. }
  970. //static 
  971. LLFontGL* LLFontGL::getFont(const LLFontDescriptor& desc)
  972. {
  973. return sFontRegistry->getFont(desc);
  974. }
  976. //static
  977. LLFontGL* LLFontGL::getFontByName(const std::string& name)
  978. {
  979. // check for most common fonts first
  980. if (name == "SANSSERIF")
  981. {
  982. return getFontSansSerif();
  983. }
  984. else if (name == "SANSSERIF_SMALL")
  985. {
  986. return getFontSansSerifSmall();
  987. }
  988. else if (name == "SANSSERIF_BIG")
  989. {
  990. return getFontSansSerifBig();
  991. }
  992. else if (name == "SMALL" || name == "OCRA")
  993. {
  994. // *BUG: Should this be "MONOSPACE"?  Do we use "OCRA" anymore?
  995. // Does "SMALL" mean "SERIF"?
  996. return getFontMonospace();
  997. }
  998. else
  999. {
  1000. return NULL;
  1001. }
  1002. }
  1004. //static
  1005. LLFontGL* LLFontGL::getFontDefault()
  1006. {
  1007. return getFontSansSerif(); // Fallback to sans serif as default font
  1008. }
  1011. // static 
  1012. std::string LLFontGL::getFontPathSystem()
  1013. {
  1014. std::string system_path;
  1016. // Try to figure out where the system's font files are stored.
  1017. char *system_root = NULL;
  1018. #if LL_WINDOWS
  1019. system_root = getenv("SystemRoot"); /* Flawfinder: ignore */
  1020. if (!system_root)
  1021. {
  1022. llwarns << "SystemRoot not found, attempting to load fonts from default path." << llendl;
  1023. }
  1024. #endif
  1026. if (system_root)
  1027. {
  1028. system_path = llformat("%s/fonts/", system_root);
  1029. }
  1030. else
  1031. {
  1032. #if LL_WINDOWS
  1033. // HACK for windows 98/Me
  1034. system_path = "/WINDOWS/FONTS/";
  1035. #elif LL_DARWIN
  1036. // HACK for Mac OS X
  1037. system_path = "/System/Library/Fonts/";
  1038. #endif
  1039. }
  1040. return system_path;
  1041. }
  1044. // static 
  1045. std::string LLFontGL::getFontPathLocal()
  1046. {
  1047. std::string local_path;
  1049. // Backup files if we can't load from system fonts directory.
  1050. // We could store this in an end-user writable directory to allow
  1051. // end users to switch fonts.
  1052. if (LLFontGL::sAppDir.length())
  1053. {
  1054. // use specified application dir to look for fonts
  1055. local_path = LLFontGL::sAppDir + "/fonts/";
  1056. }
  1057. else
  1058. {
  1059. // assume working directory is executable directory
  1060. local_path = "./fonts/";
  1061. }
  1062. return local_path;
  1063. }
  1065. LLFontGL::LLFontGL(const LLFontGL &source)
  1066. {
  1067. llerrs << "Not implemented!" << llendl;
  1068. }
  1070. LLFontGL &LLFontGL::operator=(const LLFontGL &source)
  1071. {
  1072. llerrs << "Not implemented" << llendl;
  1073. return *this;
  1074. }
  1076. void LLFontGL::renderQuad(const LLRectf& screen_rect, const LLRectf& uv_rect, F32 slant_amt) const
  1077. {
  1078. gGL.texCoord2f(uv_rect.mRight, uv_rect.mTop);
  1079. gGL.vertex2f(llfont_round_x(screen_rect.mRight), 
  1080. llfont_round_y(screen_rect.mTop));
  1082. gGL.texCoord2f(uv_rect.mLeft, uv_rect.mTop);
  1083. gGL.vertex2f(llfont_round_x(screen_rect.mLeft), 
  1084. llfont_round_y(screen_rect.mTop));
  1086. gGL.texCoord2f(uv_rect.mLeft, uv_rect.mBottom);
  1087. gGL.vertex2f(llfont_round_x(screen_rect.mLeft + slant_amt), 
  1088. llfont_round_y(screen_rect.mBottom));
  1090. gGL.texCoord2f(uv_rect.mRight, uv_rect.mBottom);
  1091. gGL.vertex2f(llfont_round_x(screen_rect.mRight + slant_amt), 
  1092. llfont_round_y(screen_rect.mBottom));
  1093. }
  1095. void LLFontGL::drawGlyph(const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4& color, U8 style, ShadowType shadow, F32 drop_shadow_strength) const
  1096. {
  1097. F32 slant_offset;
  1098. slant_offset = ((style & ITALIC) ? ( -mFontFreetype->getAscenderHeight() * 0.2f) : 0.f);
  1100. gGL.begin(LLRender::QUADS);
  1101. {
  1102. //FIXME: bold and drop shadow are mutually exclusive only for convenience
  1103. //Allow both when we need them.
  1104. if (style & BOLD)
  1105. {
  1106. gGL.color4fv(color.mV);
  1107. for (S32 pass = 0; pass < 2; pass++)
  1108. {
  1109. LLRectf screen_rect_offset = screen_rect;
  1111. screen_rect_offset.translate((F32)(pass * BOLD_OFFSET), 0.f);
  1112. renderQuad(screen_rect_offset, uv_rect, slant_offset);
  1113. }
  1114. }
  1115. else if (shadow == DROP_SHADOW_SOFT)
  1116. {
  1117. LLColor4 shadow_color = LLFontGL::sShadowColor;
  1118. shadow_color.mV[VALPHA] = color.mV[VALPHA] * drop_shadow_strength * DROP_SHADOW_SOFT_STRENGTH;
  1119. gGL.color4fv(shadow_color.mV);
  1120. for (S32 pass = 0; pass < 5; pass++)
  1121. {
  1122. LLRectf screen_rect_offset = screen_rect;
  1124. switch(pass)
  1125. {
  1126. case 0:
  1127. screen_rect_offset.translate(-1.f, -1.f);
  1128. break;
  1129. case 1:
  1130. screen_rect_offset.translate(1.f, -1.f);
  1131. break;
  1132. case 2:
  1133. screen_rect_offset.translate(1.f, 1.f);
  1134. break;
  1135. case 3:
  1136. screen_rect_offset.translate(-1.f, 1.f);
  1137. break;
  1138. case 4:
  1139. screen_rect_offset.translate(0, -2.f);
  1140. break;
  1141. }
  1143. renderQuad(screen_rect_offset, uv_rect, slant_offset);
  1144. }
  1145. gGL.color4fv(color.mV);
  1146. renderQuad(screen_rect, uv_rect, slant_offset);
  1147. }
  1148. else if (shadow == DROP_SHADOW)
  1149. {
  1150. LLColor4 shadow_color = LLFontGL::sShadowColor;
  1151. shadow_color.mV[VALPHA] = color.mV[VALPHA] * drop_shadow_strength;
  1152. gGL.color4fv(shadow_color.mV);
  1153. LLRectf screen_rect_shadow = screen_rect;
  1154. screen_rect_shadow.translate(1.f, -1.f);
  1155. renderQuad(screen_rect_shadow, uv_rect, slant_offset);
  1156. gGL.color4fv(color.mV);
  1157. renderQuad(screen_rect, uv_rect, slant_offset);
  1158. }
  1159. else // normal rendering
  1160. {
  1161. gGL.color4fv(color.mV);
  1162. renderQuad(screen_rect, uv_rect, slant_offset);
  1163. }
  1165. }
  1166. gGL.end();
  1167. }