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

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

游戏引擎

开发平台：

C++ Builder

llhudtext.cpp：源码内容
  2. /** 
  3.  * @file llhudtext.cpp
  4.  * @brief LLHUDText class implementation
  5.  *
  6.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2002-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #include "llviewerprecompiledheaders.h"
  36. #include "llhudtext.h"
  38. #include "llrender.h"
  40. #include "llagent.h"
  41. #include "llviewercontrol.h"
  42. #include "llcriticaldamp.h"
  43. #include "lldrawable.h"
  44. #include "llfontgl.h"
  45. #include "llglheaders.h"
  46. #include "llhudrender.h"
  47. #include "llui.h"
  48. #include "llviewercamera.h"
  49. #include "llviewertexturelist.h"
  50. #include "llviewerobject.h"
  51. #include "llvovolume.h"
  52. #include "llviewerwindow.h"
  53. #include "llstatusbar.h"
  54. #include "llmenugl.h"
  55. #include "pipeline.h"
  56. #include <boost/tokenizer.hpp>
  59. const F32 SPRING_STRENGTH = 0.7f;
  60. const F32 RESTORATION_SPRING_TIME_CONSTANT = 0.1f;
  61. const F32 HORIZONTAL_PADDING = 15.f;
  62. const F32 VERTICAL_PADDING = 12.f;
  63. const F32 BUFFER_SIZE = 2.f;
  64. const F32 MIN_EDGE_OVERLAP = 3.f;
  65. F32 HUD_TEXT_MAX_WIDTH = 190.f;
  66. const F32 HUD_TEXT_MAX_WIDTH_NO_BUBBLE = 1000.f;
  67. const F32 RESIZE_TIME = 0.f;
  68. const S32 NUM_OVERLAP_ITERATIONS = 10;
  69. const F32 NEIGHBOR_FORCE_FRACTION = 1.f;
  70. const F32 POSITION_DAMPING_TC = 0.2f;
  71. const F32 MAX_STABLE_CAMERA_VELOCITY = 0.1f;
  72. const F32 LOD_0_SCREEN_COVERAGE = 0.15f;
  73. const F32 LOD_1_SCREEN_COVERAGE = 0.30f;
  74. const F32 LOD_2_SCREEN_COVERAGE = 0.40f;
  76. std::set<LLPointer<LLHUDText> > LLHUDText::sTextObjects;
  77. std::vector<LLPointer<LLHUDText> > LLHUDText::sVisibleTextObjects;
  78. std::vector<LLPointer<LLHUDText> > LLHUDText::sVisibleHUDTextObjects;
  79. BOOL LLHUDText::sDisplayText = TRUE ;
  81. bool lltextobject_further_away::operator()(const LLPointer<LLHUDText>& lhs, const LLPointer<LLHUDText>& rhs) const
  82. {
  83. return (lhs->getDistance() > rhs->getDistance()) ? true : false;
  84. }
  87. LLHUDText::LLHUDText(const U8 type) :
  88. LLHUDObject(type),
  89. mUseBubble(FALSE),
  90. mUsePixelSize(TRUE),
  91. mVisibleOffScreen(FALSE),
  92. mWidth(0.f),
  93. mHeight(0.f),
  94. mFontp(LLFontGL::getFontSansSerifSmall()),
  95. mBoldFontp(LLFontGL::getFontSansSerifBold()),
  96. mMass(1.f),
  97. mMaxLines(10),
  98. mOffsetY(0),
  99. mTextAlignment(ALIGN_TEXT_CENTER),
  100. mVertAlignment(ALIGN_VERT_CENTER),
  101. mLOD(0),
  102. mHidden(FALSE)
  103. {
  104. mColor = LLColor4(1.f, 1.f, 1.f, 1.f);
  105. mDoFade = TRUE;
  106. mFadeDistance = 8.f;
  107. mFadeRange = 4.f;
  108. mZCompare = TRUE;
  109. mDropShadow = TRUE;
  110. mOffscreen = FALSE;
  111. mRadius = 0.1f;
  112. LLPointer<LLHUDText> ptr(this);
  113. sTextObjects.insert(ptr);
  114. }
  116. LLHUDText::~LLHUDText()
  117. {
  118. }
  121. BOOL LLHUDText::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, LLVector3& intersection, BOOL debug_render)
  122. {
  123. if (!mVisible || mHidden)
  124. {
  125. return FALSE;
  126. }
  128. // don't pick text that isn't bound to a viewerobject or isn't in a bubble
  129. if (!mSourceObject || mSourceObject->mDrawable.isNull() || !mUseBubble)
  130. {
  131. return FALSE;
  132. }
  134. F32 alpha_factor = 1.f;
  135. LLColor4 text_color = mColor;
  136. if (mDoFade)
  137. {
  138. if (mLastDistance > mFadeDistance)
  139. {
  140. alpha_factor = llmax(0.f, 1.f - (mLastDistance - mFadeDistance)/mFadeRange);
  141. text_color.mV[3] = text_color.mV[3]*alpha_factor;
  142. }
  143. }
  144. if (text_color.mV[3] < 0.01f)
  145. {
  146. return FALSE;
  147. }
  149. mOffsetY = lltrunc(mHeight * ((mVertAlignment == ALIGN_VERT_CENTER) ? 0.5f : 1.f));
  151. // scale screen size of borders down
  152. //RN: for now, text on hud objects is never occluded
  154. LLVector3 x_pixel_vec;
  155. LLVector3 y_pixel_vec;
  157. if (mOnHUDAttachment)
  158. {
  159. x_pixel_vec = LLVector3::y_axis / (F32)gViewerWindow->getWindowWidthScaled();
  160. y_pixel_vec = LLVector3::z_axis / (F32)gViewerWindow->getWindowHeightScaled();
  161. }
  162. else
  163. {
  164. LLViewerCamera::getInstance()->getPixelVectors(mPositionAgent, y_pixel_vec, x_pixel_vec);
  165. }
  167. LLVector3 width_vec = mWidth * x_pixel_vec;
  168. LLVector3 height_vec = mHeight * y_pixel_vec;
  170. LLCoordGL screen_pos;
  171. LLViewerCamera::getInstance()->projectPosAgentToScreen(mPositionAgent, screen_pos, FALSE);
  173. LLVector2 screen_offset;
  174. screen_offset = updateScreenPos(mPositionOffset);
  176. LLVector3 render_position = mPositionAgent  
  177. + (x_pixel_vec * screen_offset.mV[VX])
  178. + (y_pixel_vec * screen_offset.mV[VY]);
  181. if (mUseBubble)
  182. {
  183. LLVector3 bg_pos = render_position
  184. + (F32)mOffsetY * y_pixel_vec
  185. - (width_vec / 2.f)
  186. - (height_vec);
  187. //LLUI::translate(bg_pos.mV[VX], bg_pos.mV[VY], bg_pos.mV[VZ]);
  189. LLVector3 v[] = 
  190. {
  191. bg_pos,
  192. bg_pos + width_vec,
  193. bg_pos + width_vec + height_vec,
  194. bg_pos + height_vec,
  195. };
  197. if (debug_render)
  198. {
  199. gGL.begin(LLRender::LINE_STRIP);
  200. gGL.vertex3fv(v[0].mV);
  201. gGL.vertex3fv(v[1].mV);
  202. gGL.vertex3fv(v[2].mV);
  203. gGL.vertex3fv(v[3].mV);
  204. gGL.vertex3fv(v[0].mV);
  205. gGL.vertex3fv(v[2].mV);
  206. gGL.end();
  207. }
  209. LLVector3 dir = end-start;
  210. F32 t = 0.f;
  212. if (LLTriangleRayIntersect(v[0], v[1], v[2], start, dir, NULL, NULL, &t, FALSE) ||
  213. LLTriangleRayIntersect(v[2], v[3], v[0], start, dir, NULL, NULL, &t, FALSE) )
  214. {
  215. if (t <= 1.f)
  216. {
  217. intersection = start + dir*t;
  218. return TRUE;
  219. }
  220. }
  221. }
  223. return FALSE;
  224. }
  226. void LLHUDText::render()
  227. {
  228. if (!mOnHUDAttachment && sDisplayText)
  229. {
  230. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  231. renderText(FALSE);
  232. }
  233. }
  235. void LLHUDText::renderForSelect()
  236. {
  237. if (!mOnHUDAttachment)
  238. {
  239. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  240. renderText(TRUE);
  241. }
  242. }
  244. void LLHUDText::renderText(BOOL for_select)
  245. {
  246. if (!mVisible || mHidden)
  247. {
  248. return;
  249. }
  251. // don't pick text that isn't bound to a viewerobject or isn't in a bubble
  252. if (for_select && 
  253. (!mSourceObject || mSourceObject->mDrawable.isNull() || !mUseBubble))
  254. {
  255. return;
  256. }
  258. if (for_select)
  259. {
  260. gGL.getTexUnit(0)->disable();
  261. }
  262. else
  263. {
  264. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  265. }
  267. LLGLState gls_blend(GL_BLEND, for_select ? FALSE : TRUE);
  268. LLGLState gls_alpha(GL_ALPHA_TEST, for_select ? FALSE : TRUE);
  270. LLColor4 shadow_color(0.f, 0.f, 0.f, 1.f);
  271. F32 alpha_factor = 1.f;
  272. LLColor4 text_color = mColor;
  273. if (mDoFade)
  274. {
  275. if (mLastDistance > mFadeDistance)
  276. {
  277. alpha_factor = llmax(0.f, 1.f - (mLastDistance - mFadeDistance)/mFadeRange);
  278. text_color.mV[3] = text_color.mV[3]*alpha_factor;
  279. }
  280. }
  281. if (text_color.mV[3] < 0.01f)
  282. {
  283. return;
  284. }
  285. shadow_color.mV[3] = text_color.mV[3];
  287. mOffsetY = lltrunc(mHeight * ((mVertAlignment == ALIGN_VERT_CENTER) ? 0.5f : 1.f));
  289. // *TODO: cache this image
  290. LLUIImagePtr imagep = LLUI::getUIImage("Rounded_Square");
  292. // *TODO: make this a per-text setting
  293. LLColor4 bg_color = LLUIColorTable::instance().getColor("BackgroundChatColor");
  294. bg_color.setAlpha(gSavedSettings.getF32("ChatBubbleOpacity") * alpha_factor);
  296. const S32 border_height = 16;
  297. const S32 border_width = 16;
  299. // *TODO move this into helper function
  300. F32 border_scale = 1.f;
  302. if (border_height * 2 > mHeight)
  303. {
  304. border_scale = (F32)mHeight / ((F32)border_height * 2.f);
  305. }
  306. if (border_width * 2 > mWidth)
  307. {
  308. border_scale = llmin(border_scale, (F32)mWidth / ((F32)border_width * 2.f));
  309. }
  311. // scale screen size of borders down
  312. //RN: for now, text on hud objects is never occluded
  314. LLVector3 x_pixel_vec;
  315. LLVector3 y_pixel_vec;
  317. if (mOnHUDAttachment)
  318. {
  319. x_pixel_vec = LLVector3::y_axis / (F32)gViewerWindow->getWorldViewWidthRaw();
  320. y_pixel_vec = LLVector3::z_axis / (F32)gViewerWindow->getWorldViewHeightRaw();
  321. }
  322. else
  323. {
  324. LLViewerCamera::getInstance()->getPixelVectors(mPositionAgent, y_pixel_vec, x_pixel_vec);
  325. }
  327. LLVector2 border_scale_vec((F32)border_width / (F32)imagep->getTextureWidth(), (F32)border_height / (F32)imagep->getTextureHeight());
  328. LLVector3 width_vec = mWidth * x_pixel_vec;
  329. LLVector3 height_vec = mHeight * y_pixel_vec;
  330. LLVector3 scaled_border_width = (F32)llfloor(border_scale * (F32)border_width) * x_pixel_vec;
  331. LLVector3 scaled_border_height = (F32)llfloor(border_scale * (F32)border_height) * y_pixel_vec;
  333. mRadius = (width_vec + height_vec).magVec() * 0.5f;
  335. LLCoordGL screen_pos;
  336. LLViewerCamera::getInstance()->projectPosAgentToScreen(mPositionAgent, screen_pos, FALSE);
  338. LLVector2 screen_offset;
  339. if (!mUseBubble)
  340. {
  341. screen_offset = mPositionOffset;
  342. }
  343. else
  344. {
  345. screen_offset = updateScreenPos(mPositionOffset);
  346. }
  348. LLVector3 render_position = mPositionAgent  
  349. + (x_pixel_vec * screen_offset.mV[VX])
  350. + (y_pixel_vec * screen_offset.mV[VY]);
  352. //if (mOnHUD)
  353. //{
  354. // render_position.mV[VY] -= fmodf(render_position.mV[VY], 1.f / (F32)gViewerWindow->getWindowWidthScaled());
  355. // render_position.mV[VZ] -= fmodf(render_position.mV[VZ], 1.f / (F32)gViewerWindow->getWindowHeightScaled());
  356. //}
  357. //else
  358. //{
  359. // render_position = LLViewerCamera::getInstance()->roundToPixel(render_position);
  360. //}
  362. if (mUseBubble)
  363. {
  364. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  365. LLUI::pushMatrix();
  366. {
  367. LLVector3 bg_pos = render_position
  368. + (F32)mOffsetY * y_pixel_vec
  369. - (width_vec / 2.f)
  370. - (height_vec);
  371. LLUI::translate(bg_pos.mV[VX], bg_pos.mV[VY], bg_pos.mV[VZ]);
  373. if (for_select)
  374. {
  375. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  376. S32 name = mSourceObject->mGLName;
  377. LLColor4U coloru((U8)(name >> 16), (U8)(name >> 8), (U8)name);
  378. gGL.color4ubv(coloru.mV);
  379. gl_segmented_rect_3d_tex(border_scale_vec, scaled_border_width, scaled_border_height, width_vec, height_vec);
  380. LLUI::popMatrix();
  381. return;
  382. }
  383. else
  384. {
  385. gGL.getTexUnit(0)->bind(imagep->getImage());
  387. gGL.color4fv(bg_color.mV);
  388. gl_segmented_rect_3d_tex(border_scale_vec, scaled_border_width, scaled_border_height, width_vec, height_vec);
  390. if ( mLabelSegments.size())
  391. {
  392. LLUI::pushMatrix();
  393. {
  394. gGL.color4f(text_color.mV[VX], text_color.mV[VY], text_color.mV[VZ], gSavedSettings.getF32("ChatBubbleOpacity") * alpha_factor);
  395. LLVector3 label_height = (mFontp->getLineHeight() * mLabelSegments.size() + (VERTICAL_PADDING / 3.f)) * y_pixel_vec;
  396. LLVector3 label_offset = height_vec - label_height;
  397. LLUI::translate(label_offset.mV[VX], label_offset.mV[VY], label_offset.mV[VZ]);
  398. gl_segmented_rect_3d_tex_top(border_scale_vec, scaled_border_width, scaled_border_height, width_vec, label_height);
  399. }
  400. LLUI::popMatrix();
  401. }
  402. }
  404. BOOL outside_width = llabs(mPositionOffset.mV[VX]) > mWidth * 0.5f;
  405. BOOL outside_height = llabs(mPositionOffset.mV[VY] + (mVertAlignment == ALIGN_VERT_TOP ? mHeight * 0.5f : 0.f)) > mHeight * (mVertAlignment == ALIGN_VERT_TOP ? mHeight * 0.75f : 0.5f);
  407. // draw line segments pointing to parent object
  408. if (!mOffscreen && (outside_width || outside_height))
  409. {
  410. LLUI::pushMatrix();
  411. {
  412. gGL.color4fv(bg_color.mV);
  413. LLVector3 target_pos = -1.f * (mPositionOffset.mV[VX] * x_pixel_vec + mPositionOffset.mV[VY] * y_pixel_vec);
  414. target_pos += (width_vec / 2.f);
  415. target_pos += mVertAlignment == ALIGN_VERT_CENTER ? (height_vec * 0.5f) : LLVector3::zero;
  416. target_pos -= 3.f * x_pixel_vec;
  417. target_pos -= 6.f * y_pixel_vec;
  418. LLUI::translate(target_pos.mV[VX], target_pos.mV[VY], target_pos.mV[VZ]);
  419. gl_segmented_rect_3d_tex(border_scale_vec, 3.f * x_pixel_vec, 3.f * y_pixel_vec, 6.f * x_pixel_vec, 6.f * y_pixel_vec);
  420. }
  421. LLUI::popMatrix();
  423. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  424. LLGLDepthTest gls_depth(mZCompare ? GL_TRUE : GL_FALSE, GL_FALSE);
  426. LLVector3 box_center_offset;
  427. box_center_offset = (width_vec * 0.5f) + (height_vec * 0.5f);
  428. LLUI::translate(box_center_offset.mV[VX], box_center_offset.mV[VY], box_center_offset.mV[VZ]);
  429. gGL.color4fv(bg_color.mV);
  430. LLUI::setLineWidth(2.0);
  431. gGL.begin(LLRender::LINES);
  432. {
  433. if (outside_width)
  434. {
  435. LLVector3 vert;
  436. // draw line in x then y
  437. if (mPositionOffset.mV[VX] < 0.f)
  438. {
  439. // start at right edge
  440. vert = width_vec * 0.5f;
  441. gGL.vertex3fv(vert.mV);
  442. }
  443. else
  444. {
  445. // start at left edge
  446. vert = width_vec * -0.5f;
  447. gGL.vertex3fv(vert.mV);
  448. }
  449. vert = -mPositionOffset.mV[VX] * x_pixel_vec;
  450. gGL.vertex3fv(vert.mV);
  451. gGL.vertex3fv(vert.mV);
  452. vert -= mPositionOffset.mV[VY] * y_pixel_vec;
  453. vert -= ((mVertAlignment == ALIGN_VERT_TOP) ? (height_vec * 0.5f) : LLVector3::zero);
  454. gGL.vertex3fv(vert.mV);
  455. }
  456. else
  457. {
  458. LLVector3 vert;
  459. // draw line in y then x
  460. if (mPositionOffset.mV[VY] < 0.f)
  461. {
  462. // start at top edge
  463. vert = (height_vec * 0.5f) - (mPositionOffset.mV[VX] * x_pixel_vec);
  464. gGL.vertex3fv(vert.mV);
  465. }
  466. else
  467. {
  468. // start at bottom edge
  469. vert = (height_vec * -0.5f)  - (mPositionOffset.mV[VX] * x_pixel_vec);
  470. gGL.vertex3fv(vert.mV);
  471. }
  472. vert = -mPositionOffset.mV[VY] * y_pixel_vec - mPositionOffset.mV[VX] * x_pixel_vec;
  473. vert -= ((mVertAlignment == ALIGN_VERT_TOP) ? (height_vec * 0.5f) : LLVector3::zero);
  474. gGL.vertex3fv(vert.mV);
  475. }
  476. }
  477. gGL.end();
  478. LLUI::setLineWidth(1.0);
  480. }
  481. }
  482. LLUI::popMatrix();
  483. }
  485. F32 y_offset = (F32)mOffsetY;
  487. // Render label
  488. {
  489. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  491. for(std::vector<LLHUDTextSegment>::iterator segment_iter = mLabelSegments.begin();
  492. segment_iter != mLabelSegments.end(); ++segment_iter )
  493. {
  494. const LLFontGL* fontp = (segment_iter->mStyle == LLFontGL::BOLD) ? mBoldFontp : mFontp;
  495. y_offset -= fontp->getLineHeight();
  497. F32 x_offset;
  498. if (mTextAlignment == ALIGN_TEXT_CENTER)
  499. {
  500. x_offset = -0.5f*segment_iter->getWidth(fontp);
  501. }
  502. else // ALIGN_LEFT
  503. {
  504. x_offset = -0.5f * mWidth + (HORIZONTAL_PADDING / 2.f);
  505. }
  507. LLColor4 label_color(0.f, 0.f, 0.f, 1.f);
  508. label_color.mV[VALPHA] = alpha_factor;
  509. hud_render_text(segment_iter->getText(), render_position, *fontp, segment_iter->mStyle, LLFontGL::NO_SHADOW, x_offset, y_offset, label_color, mOnHUDAttachment);
  510. }
  511. }
  513. // Render text
  514. {
  515. // -1 mMaxLines means unlimited lines.
  516. S32 start_segment;
  517. S32 max_lines = getMaxLines();
  519. if (max_lines < 0) 
  520. {
  521. start_segment = 0;
  522. }
  523. else 
  524. {
  525. start_segment = llmax((S32)0, (S32)mTextSegments.size() - max_lines);
  526. }
  528. for (std::vector<LLHUDTextSegment>::iterator segment_iter = mTextSegments.begin() + start_segment;
  529.  segment_iter != mTextSegments.end(); ++segment_iter )
  530. {
  531. const LLFontGL* fontp = (segment_iter->mStyle == LLFontGL::BOLD) ? mBoldFontp : mFontp;
  532. y_offset -= fontp->getLineHeight();
  534. U8 style = segment_iter->mStyle;
  535. LLFontGL::ShadowType shadow = LLFontGL::NO_SHADOW;
  536. if (mDropShadow)
  537. {
  538. shadow = LLFontGL::DROP_SHADOW;
  539. }
  541. F32 x_offset;
  542. if (mTextAlignment== ALIGN_TEXT_CENTER)
  543. {
  544. x_offset = -0.5f*segment_iter->getWidth(fontp);
  545. }
  546. else // ALIGN_LEFT
  547. {
  548. x_offset = -0.5f * mWidth + (HORIZONTAL_PADDING / 2.f);
  549. }
  551. text_color = segment_iter->mColor;
  552. text_color.mV[VALPHA] *= alpha_factor;
  554. hud_render_text(segment_iter->getText(), render_position, *fontp, style, shadow, x_offset, y_offset, text_color, mOnHUDAttachment);
  555. }
  556. }
  557. /// Reset the default color to white.  The renderer expects this to be the default. 
  558. glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
  559. if (for_select)
  560. {
  561. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  562. }
  563. }
  565. void LLHUDText::setStringUTF8(const std::string &wtext)
  566. {
  567. setString(utf8str_to_wstring(wtext));
  568. }
  570. void LLHUDText::setString(const LLWString &wtext)
  571. {
  572. mTextSegments.clear();
  573. addLine(wtext, mColor);
  574. }
  576. void LLHUDText::clearString()
  577. {
  578. mTextSegments.clear();
  579. }
  582. void LLHUDText::addLine(const std::string &str, const LLColor4& color, const LLFontGL::StyleFlags style)
  583. {
  584. addLine(utf8str_to_wstring(str), color, style);
  585. }
  588. void LLHUDText::addLine(const LLWString &wstr, const LLColor4& color, const LLFontGL::StyleFlags style)
  589. {
  590. if (gNoRender)
  591. {
  592. return;
  593. }
  594. if (!wstr.empty())
  595. {
  596. LLWString wline(wstr);
  597. typedef boost::tokenizer<boost::char_separator<llwchar>, LLWString::const_iterator, LLWString > tokenizer;
  598. LLWString seps(utf8str_to_wstring("rn"));
  599. boost::char_separator<llwchar> sep(seps.c_str());
  601. tokenizer tokens(wline, sep);
  602. tokenizer::iterator iter = tokens.begin();
  604. while (iter != tokens.end())
  605. {
  606. U32 line_length = 0;
  607. do
  608. {
  609. S32 segment_length = mFontp->maxDrawableChars(iter->substr(line_length).c_str(), mUseBubble ? HUD_TEXT_MAX_WIDTH : HUD_TEXT_MAX_WIDTH_NO_BUBBLE, wline.length(), LLFontGL::WORD_BOUNDARY_IF_POSSIBLE);
  610. mTextSegments.push_back(LLHUDTextSegment(iter->substr(line_length, segment_length), style, color));
  611. line_length += segment_length;
  612. }
  613. while (line_length != iter->size());
  614. ++iter;
  615. }
  616. }
  617. }
  619. void LLHUDText::setLabel(const std::string &label)
  620. {
  621. setLabel(utf8str_to_wstring(label));
  622. }
  624. void LLHUDText::setLabel(const LLWString &wlabel)
  625. {
  626. mLabelSegments.clear();
  628. if (!wlabel.empty())
  629. {
  630. LLWString wstr(wlabel);
  631. LLWString seps(utf8str_to_wstring("rn"));
  632. LLWString empty;
  634. typedef boost::tokenizer<boost::char_separator<llwchar>, LLWString::const_iterator, LLWString > tokenizer;
  635. boost::char_separator<llwchar> sep(seps.c_str(), empty.c_str(), boost::keep_empty_tokens);
  637. tokenizer tokens(wstr, sep);
  638. tokenizer::iterator iter = tokens.begin();
  640. while (iter != tokens.end())
  641. {
  642. U32 line_length = 0;
  643. do
  644. {
  645. S32 segment_length = mFontp->maxDrawableChars(iter->substr(line_length).c_str(), mUseBubble ? HUD_TEXT_MAX_WIDTH : HUD_TEXT_MAX_WIDTH_NO_BUBBLE, wstr.length(), LLFontGL::WORD_BOUNDARY_IF_POSSIBLE);
  646. mLabelSegments.push_back(LLHUDTextSegment(iter->substr(line_length, segment_length), LLFontGL::NORMAL, mColor));
  647. line_length += segment_length;
  648. }
  649. while (line_length != iter->size());
  650. ++iter;
  651. }
  652. }
  653. }
  655. void LLHUDText::setDropShadow(const BOOL do_shadow)
  656. {
  657. mDropShadow = do_shadow;
  658. }
  660. void LLHUDText::setZCompare(const BOOL zcompare)
  661. {
  662. mZCompare = zcompare;
  663. }
  665. void LLHUDText::setFont(const LLFontGL* font)
  666. {
  667. mFontp = font;
  668. }
  671. void LLHUDText::setColor(const LLColor4 &color)
  672. {
  673. mColor = color;
  674. for (std::vector<LLHUDTextSegment>::iterator segment_iter = mTextSegments.begin();
  675.  segment_iter != mTextSegments.end(); ++segment_iter )
  676. {
  677. segment_iter->mColor = color;
  678. }
  679. }
  682. void LLHUDText::setUsePixelSize(const BOOL use_pixel_size)
  683. {
  684. mUsePixelSize = use_pixel_size;
  685. }
  687. void LLHUDText::setDoFade(const BOOL do_fade)
  688. {
  689. mDoFade = do_fade;
  690. }
  692. void LLHUDText::updateVisibility()
  693. {
  694. if (mSourceObject)
  695. {
  696. mSourceObject->updateText();
  697. }
  699. mPositionAgent = gAgent.getPosAgentFromGlobal(mPositionGlobal);
  701. if (!mSourceObject)
  702. {
  703. //llwarns << "LLHUDText::updateScreenPos -- mSourceObject is NULL!" << llendl;
  704. mVisible = TRUE;
  705. if (mOnHUDAttachment)
  706. {
  707. sVisibleHUDTextObjects.push_back(LLPointer<LLHUDText> (this));
  708. }
  709. else
  710. {
  711. sVisibleTextObjects.push_back(LLPointer<LLHUDText> (this));
  712. }
  713. return;
  714. }
  716. // Not visible if parent object is dead
  717. if (mSourceObject->isDead())
  718. {
  719. mVisible = FALSE;
  720. return;
  721. }
  723. // for now, all text on hud objects is visible
  724. if (mOnHUDAttachment)
  725. {
  726. mVisible = TRUE;
  727. sVisibleHUDTextObjects.push_back(LLPointer<LLHUDText> (this));
  728. mLastDistance = mPositionAgent.mV[VX];
  729. return;
  730. }
  732. // push text towards camera by radius of object, but not past camera
  733. LLVector3 vec_from_camera = mPositionAgent - LLViewerCamera::getInstance()->getOrigin();
  734. LLVector3 dir_from_camera = vec_from_camera;
  735. dir_from_camera.normVec();
  737. if (dir_from_camera * LLViewerCamera::getInstance()->getAtAxis() <= 0.f)
  738. { //text is behind camera, don't render
  739. mVisible = FALSE;
  740. return;
  741. }
  743. if (vec_from_camera * LLViewerCamera::getInstance()->getAtAxis() <= LLViewerCamera::getInstance()->getNear() + 0.1f + mSourceObject->getVObjRadius())
  744. {
  745. mPositionAgent = LLViewerCamera::getInstance()->getOrigin() + vec_from_camera * ((LLViewerCamera::getInstance()->getNear() + 0.1f) / (vec_from_camera * LLViewerCamera::getInstance()->getAtAxis()));
  746. }
  747. else
  748. {
  749. mPositionAgent -= dir_from_camera * mSourceObject->getVObjRadius();
  750. }
  752. mLastDistance = (mPositionAgent - LLViewerCamera::getInstance()->getOrigin()).magVec();
  754. if (mLOD >= 3 || !mTextSegments.size() || (mDoFade && (mLastDistance > mFadeDistance + mFadeRange)))
  755. {
  756. mVisible = FALSE;
  757. return;
  758. }
  760. LLVector3 x_pixel_vec;
  761. LLVector3 y_pixel_vec;
  763. LLViewerCamera::getInstance()->getPixelVectors(mPositionAgent, y_pixel_vec, x_pixel_vec);
  765. LLVector3 render_position = mPositionAgent + 
  766. (x_pixel_vec * mPositionOffset.mV[VX]) +
  767. (y_pixel_vec * mPositionOffset.mV[VY]);
  769. mOffscreen = FALSE;
  770. if (!LLViewerCamera::getInstance()->sphereInFrustum(render_position, mRadius))
  771. {
  772. if (!mVisibleOffScreen)
  773. {
  774. mVisible = FALSE;
  775. return;
  776. }
  777. else
  778. {
  779. mOffscreen = TRUE;
  780. }
  781. }
  783. mVisible = TRUE;
  784. sVisibleTextObjects.push_back(LLPointer<LLHUDText> (this));
  785. }
  787. LLVector2 LLHUDText::updateScreenPos(LLVector2 &offset)
  788. {
  789. LLCoordGL screen_pos;
  790. LLVector2 screen_pos_vec;
  791. LLVector3 x_pixel_vec;
  792. LLVector3 y_pixel_vec;
  793. LLViewerCamera::getInstance()->getPixelVectors(mPositionAgent, y_pixel_vec, x_pixel_vec);
  794. LLVector3 world_pos = mPositionAgent + (offset.mV[VX] * x_pixel_vec) + (offset.mV[VY] * y_pixel_vec);
  795. if (!LLViewerCamera::getInstance()->projectPosAgentToScreen(world_pos, screen_pos, FALSE) && mVisibleOffScreen)
  796. {
  797. // bubble off-screen, so find a spot for it along screen edge
  798. LLViewerCamera::getInstance()->projectPosAgentToScreenEdge(world_pos, screen_pos);
  799. }
  801. screen_pos_vec.setVec((F32)screen_pos.mX, (F32)screen_pos.mY);
  803. LLRect world_rect = gViewerWindow->getWorldViewRectScaled();
  804. S32 bottom = world_rect.mBottom + STATUS_BAR_HEIGHT;
  806. LLVector2 screen_center;
  807. screen_center.mV[VX] = llclamp((F32)screen_pos_vec.mV[VX], (F32)world_rect.mLeft + mWidth * 0.5f, (F32)world_rect.mRight - mWidth * 0.5f);
  809. if(mVertAlignment == ALIGN_VERT_TOP)
  810. {
  811. screen_center.mV[VY] = llclamp((F32)screen_pos_vec.mV[VY], 
  812. (F32)bottom, 
  813. (F32)world_rect.mTop - mHeight - (F32)MENU_BAR_HEIGHT);
  814. mSoftScreenRect.setLeftTopAndSize(screen_center.mV[VX] - (mWidth + BUFFER_SIZE) * 0.5f, 
  815. screen_center.mV[VY] + (mHeight + BUFFER_SIZE), mWidth + BUFFER_SIZE, mHeight + BUFFER_SIZE);
  816. }
  817. else
  818. {
  819. screen_center.mV[VY] = llclamp((F32)screen_pos_vec.mV[VY], 
  820. (F32)bottom + mHeight * 0.5f, 
  821. (F32)world_rect.mTop - mHeight * 0.5f - (F32)MENU_BAR_HEIGHT);
  822. mSoftScreenRect.setCenterAndSize(screen_center.mV[VX], screen_center.mV[VY], mWidth + BUFFER_SIZE, mHeight + BUFFER_SIZE);
  823. }
  825. return offset + (screen_center - LLVector2((F32)screen_pos.mX, (F32)screen_pos.mY));
  826. }
  828. void LLHUDText::updateSize()
  829. {
  830. F32 width = 0.f;
  832. S32 max_lines = getMaxLines();
  833. S32 lines = (max_lines < 0) ? (S32)mTextSegments.size() : llmin((S32)mTextSegments.size(), max_lines);
  835. F32 height = (F32)mFontp->getLineHeight() * (lines + mLabelSegments.size());
  837. S32 start_segment;
  838. if (max_lines < 0) start_segment = 0;
  839. else start_segment = llmax((S32)0, (S32)mTextSegments.size() - max_lines);
  841. std::vector<LLHUDTextSegment>::iterator iter = mTextSegments.begin() + start_segment;
  842. while (iter != mTextSegments.end())
  843. {
  844. width = llmax(width, llmin(iter->getWidth(mFontp), HUD_TEXT_MAX_WIDTH));
  845. ++iter;
  846. }
  848. iter = mLabelSegments.begin();
  849. while (iter != mLabelSegments.end())
  850. {
  851. width = llmax(width, llmin(iter->getWidth(mFontp), HUD_TEXT_MAX_WIDTH));
  852. ++iter;
  853. }
  855. if (width == 0.f)
  856. {
  857. return;
  858. }
  860. width += HORIZONTAL_PADDING;
  861. height += VERTICAL_PADDING;
  863. if (!mResizeTimer.getStarted() && (width != mWidth || height != mHeight))
  864. {
  865. mResizeTimer.start();
  866. }
  868. // *NOTE: removed logic which did a divide by zero.
  869. F32 u = 1.f;//llclamp(mResizeTimer.getElapsedTimeF32() / RESIZE_TIME, 0.f, 1.f);
  870. if (u == 1.f)
  871. {
  872. mResizeTimer.stop();
  873. }
  875. mWidth = llmax(width, lerp(mWidth, (F32)width, u));
  876. mHeight = llmax(height, lerp(mHeight, (F32)height, u));
  877. }
  879. void LLHUDText::updateAll()
  880. {
  881. // iterate over all text objects, calculate their restoration forces,
  882. // and add them to the visible set if they are on screen and close enough
  883. sVisibleTextObjects.clear();
  884. sVisibleHUDTextObjects.clear();
  886. TextObjectIterator text_it;
  887. for (text_it = sTextObjects.begin(); text_it != sTextObjects.end(); ++text_it)
  888. {
  889. LLHUDText* textp = (*text_it);
  890. textp->mTargetPositionOffset.clearVec();
  891. textp->updateSize();
  892. textp->updateVisibility();
  893. }
  895. // sort back to front for rendering purposes
  896. std::sort(sVisibleTextObjects.begin(), sVisibleTextObjects.end(), lltextobject_further_away());
  897. std::sort(sVisibleHUDTextObjects.begin(), sVisibleHUDTextObjects.end(), lltextobject_further_away());
  899. // iterate from front to back, and set LOD based on current screen coverage
  900. F32 screen_area = (F32)(gViewerWindow->getWindowWidthScaled() * gViewerWindow->getWindowHeightScaled());
  901. F32 current_screen_area = 0.f;
  902. std::vector<LLPointer<LLHUDText> >::reverse_iterator r_it;
  903. for (r_it = sVisibleTextObjects.rbegin(); r_it != sVisibleTextObjects.rend(); ++r_it)
  904. {
  905. LLHUDText* textp = (*r_it);
  906. if (textp->mUseBubble)
  907. {
  908. if (current_screen_area / screen_area > LOD_2_SCREEN_COVERAGE)
  909. {
  910. textp->setLOD(3);
  911. }
  912. else if (current_screen_area / screen_area > LOD_1_SCREEN_COVERAGE)
  913. {
  914. textp->setLOD(2);
  915. }
  916. else if (current_screen_area / screen_area > LOD_0_SCREEN_COVERAGE)
  917. {
  918. textp->setLOD(1);
  919. }
  920. else
  921. {
  922. textp->setLOD(0);
  923. }
  924. textp->updateSize();
  925. // find on-screen position and initialize collision rectangle
  926. textp->mTargetPositionOffset = textp->updateScreenPos(LLVector2::zero);
  927. current_screen_area += (F32)(textp->mSoftScreenRect.getWidth() * textp->mSoftScreenRect.getHeight());
  928. }
  929. }
  931. LLStat* camera_vel_stat = LLViewerCamera::getInstance()->getVelocityStat();
  932. F32 camera_vel = camera_vel_stat->getCurrent();
  933. if (camera_vel > MAX_STABLE_CAMERA_VELOCITY)
  934. {
  935. return;
  936. }
  938. VisibleTextObjectIterator src_it;
  940. for (S32 i = 0; i < NUM_OVERLAP_ITERATIONS; i++)
  941. {
  942. for (src_it = sVisibleTextObjects.begin(); src_it != sVisibleTextObjects.end(); ++src_it)
  943. {
  944. LLHUDText* src_textp = (*src_it);
  946. if (!src_textp->mUseBubble)
  947. {
  948. continue;
  949. }
  950. VisibleTextObjectIterator dst_it = src_it;
  951. ++dst_it;
  952. for (; dst_it != sVisibleTextObjects.end(); ++dst_it)
  953. {
  954. LLHUDText* dst_textp = (*dst_it);
  956. if (!dst_textp->mUseBubble)
  957. {
  958. continue;
  959. }
  960. if (src_textp->mSoftScreenRect.overlaps(dst_textp->mSoftScreenRect))
  961. {
  962. LLRectf intersect_rect = src_textp->mSoftScreenRect;
  963. intersect_rect.intersectWith(dst_textp->mSoftScreenRect);
  964. intersect_rect.stretch(-BUFFER_SIZE * 0.5f);
  966. F32 src_center_x = src_textp->mSoftScreenRect.getCenterX();
  967. F32 src_center_y = src_textp->mSoftScreenRect.getCenterY();
  968. F32 dst_center_x = dst_textp->mSoftScreenRect.getCenterX();
  969. F32 dst_center_y = dst_textp->mSoftScreenRect.getCenterY();
  970. F32 intersect_center_x = intersect_rect.getCenterX();
  971. F32 intersect_center_y = intersect_rect.getCenterY();
  972. LLVector2 force = lerp(LLVector2(dst_center_x - intersect_center_x, dst_center_y - intersect_center_y), 
  973. LLVector2(intersect_center_x - src_center_x, intersect_center_y - src_center_y),
  974. 0.5f);
  975. force.setVec(dst_center_x - src_center_x, dst_center_y - src_center_y);
  976. force.normVec();
  978. LLVector2 src_force = -1.f * force;
  979. LLVector2 dst_force = force;
  981. LLVector2 force_strength;
  982. F32 src_mult = dst_textp->mMass / (dst_textp->mMass + src_textp->mMass); 
  983. F32 dst_mult = 1.f - src_mult;
  984. F32 src_aspect_ratio = src_textp->mSoftScreenRect.getWidth() / src_textp->mSoftScreenRect.getHeight();
  985. F32 dst_aspect_ratio = dst_textp->mSoftScreenRect.getWidth() / dst_textp->mSoftScreenRect.getHeight();
  986. src_force.mV[VY] *= src_aspect_ratio;
  987. src_force.normVec();
  988. dst_force.mV[VY] *= dst_aspect_ratio;
  989. dst_force.normVec();
  991. src_force.mV[VX] *= llmin(intersect_rect.getWidth() * src_mult, intersect_rect.getHeight() * SPRING_STRENGTH);
  992. src_force.mV[VY] *= llmin(intersect_rect.getHeight() * src_mult, intersect_rect.getWidth() * SPRING_STRENGTH);
  993. dst_force.mV[VX] *=  llmin(intersect_rect.getWidth() * dst_mult, intersect_rect.getHeight() * SPRING_STRENGTH);
  994. dst_force.mV[VY] *=  llmin(intersect_rect.getHeight() * dst_mult, intersect_rect.getWidth() * SPRING_STRENGTH);
  996. src_textp->mTargetPositionOffset += src_force;
  997. dst_textp->mTargetPositionOffset += dst_force;
  998. src_textp->mTargetPositionOffset = src_textp->updateScreenPos(src_textp->mTargetPositionOffset);
  999. dst_textp->mTargetPositionOffset = dst_textp->updateScreenPos(dst_textp->mTargetPositionOffset);
  1000. }
  1001. }
  1002. }
  1003. }
  1005. VisibleTextObjectIterator this_object_it;
  1006. for (this_object_it = sVisibleTextObjects.begin(); this_object_it != sVisibleTextObjects.end(); ++this_object_it)
  1007. {
  1008. if (!(*this_object_it)->mUseBubble)
  1009. {
  1010. continue;
  1011. }
  1012. (*this_object_it)->mPositionOffset = lerp((*this_object_it)->mPositionOffset, (*this_object_it)->mTargetPositionOffset, LLCriticalDamp::getInterpolant(POSITION_DAMPING_TC));
  1013. }
  1014. }
  1016. void LLHUDText::setLOD(S32 lod)
  1017. {
  1018. mLOD = lod;
  1019. //RN: uncomment this to visualize LOD levels
  1020. //std::string label = llformat("%d", lod);
  1021. //setLabel(label);
  1022. }
  1024. S32 LLHUDText::getMaxLines()
  1025. {
  1026. switch(mLOD)
  1027. {
  1028. case 0:
  1029. return mMaxLines;
  1030. case 1:
  1031. return mMaxLines > 0 ? mMaxLines / 2 : 5;
  1032. case 2:
  1033. return mMaxLines > 0 ? mMaxLines / 3 : 2;
  1034. default:
  1035. // label only
  1036. return 0;
  1037. }
  1038. }
  1040. void LLHUDText::markDead()
  1041. {
  1042. sTextObjects.erase(LLPointer<LLHUDText>(this));
  1043. LLHUDObject::markDead();
  1044. }
  1046. void LLHUDText::renderAllHUD()
  1047. {
  1048. LLGLState::checkStates();
  1049. LLGLState::checkTextureChannels();
  1050. LLGLState::checkClientArrays();
  1052. {
  1053. LLGLEnable color_mat(GL_COLOR_MATERIAL);
  1054. LLGLDepthTest depth(GL_FALSE, GL_FALSE);
  1056. VisibleTextObjectIterator text_it;
  1058. for (text_it = sVisibleHUDTextObjects.begin(); text_it != sVisibleHUDTextObjects.end(); ++text_it)
  1059. {
  1060. (*text_it)->renderText(FALSE);
  1061. }
  1062. }
  1064. LLVertexBuffer::unbind();
  1066.     LLVertexBuffer::unbind();
  1068. LLGLState::checkStates();
  1069. LLGLState::checkTextureChannels();
  1070. LLGLState::checkClientArrays();
  1071. }
  1073. void LLHUDText::shiftAll(const LLVector3& offset)
  1074. {
  1075. TextObjectIterator text_it;
  1076. for (text_it = sTextObjects.begin(); text_it != sTextObjects.end(); ++text_it)
  1077. {
  1078. LLHUDText *textp = text_it->get();
  1079. textp->shift(offset);
  1080. }
  1081. }
  1083. void LLHUDText::shift(const LLVector3& offset)
  1084. {
  1085. mPositionAgent += offset;
  1086. }
  1088. //static 
  1089. void LLHUDText::addPickable(std::set<LLViewerObject*> &pick_list)
  1090. {
  1091. //this might put an object on the pick list a second time, overriding it's mGLName, which is ok
  1092. // *FIX: we should probably cull against pick frustum
  1093. VisibleTextObjectIterator text_it;
  1094. for (text_it = sVisibleTextObjects.begin(); text_it != sVisibleTextObjects.end(); ++text_it)
  1095. {
  1096. if (!(*text_it)->mUseBubble)
  1097. {
  1098. continue;
  1099. }
  1100. pick_list.insert((*text_it)->mSourceObject);
  1101. }
  1102. }
  1104. //static
  1105. // called when UI scale changes, to flush font width caches
  1106. void LLHUDText::reshape()
  1107. {
  1108. TextObjectIterator text_it;
  1109. for (text_it = sTextObjects.begin(); text_it != sTextObjects.end(); ++text_it)
  1110. {
  1111. LLHUDText* textp = (*text_it);
  1112. std::vector<LLHUDTextSegment>::iterator segment_iter; 
  1113. for (segment_iter = textp->mTextSegments.begin();
  1114.  segment_iter != textp->mTextSegments.end(); ++segment_iter )
  1115. {
  1116. segment_iter->clearFontWidthMap();
  1117. }
  1118. for(segment_iter = textp->mLabelSegments.begin();
  1119. segment_iter != textp->mLabelSegments.end(); ++segment_iter )
  1120. {
  1121. segment_iter->clearFontWidthMap();
  1122. }
  1123. }
  1124. }
  1126. //============================================================================
  1128. F32 LLHUDText::LLHUDTextSegment::getWidth(const LLFontGL* font)
  1129. {
  1130. std::map<const LLFontGL*, F32>::iterator iter = mFontWidthMap.find(font);
  1131. if (iter != mFontWidthMap.end())
  1132. {
  1133. return iter->second;
  1134. }
  1135. else
  1136. {
  1137. F32 width = font->getWidthF32(mText.c_str());
  1138. mFontWidthMap[font] = width;
  1139. return width;
  1140. }
  1141. }