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

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

游戏引擎

开发平台：

C++ Builder

llui.cpp：源码内容
  1. /** 
  2.  * @file llui.cpp
  3.  * @brief UI implementation
  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. // Utilities functions the user interface needs
  35. #include "linden_common.h"
  37. #include <string>
  38. #include <map>
  40. // Linden library includes
  41. #include "v2math.h"
  42. #include "v4color.h"
  43. #include "llrender.h"
  44. #include "llrect.h"
  45. #include "lldir.h"
  46. #include "llgl.h"
  48. // Project includes
  49. #include "llcontrol.h"
  50. #include "llui.h"
  51. #include "lluicolortable.h"
  52. #include "llview.h"
  53. #include "lllineeditor.h"
  54. #include "llfloater.h"
  55. #include "llfloaterreg.h"
  56. #include "llmenugl.h"
  57. #include "llmenubutton.h"
  58. #include "llwindow.h"
  60. // for registration
  61. #include "llfiltereditor.h"
  62. #include "llflyoutbutton.h"
  63. #include "llsearcheditor.h"
  65. // for XUIParse
  66. #include "llquaternion.h"
  67. #include <boost/tokenizer.hpp>
  69. //
  70. // Globals
  71. //
  72. const LLColor4 UI_VERTEX_COLOR(1.f, 1.f, 1.f, 1.f);
  74. // Language for UI construction
  75. std::map<std::string, std::string> gTranslation;
  76. std::list<std::string> gUntranslated;
  77. /*static*/ LLUI::settings_map_t LLUI::sSettingGroups;
  78. /*static*/ LLImageProviderInterface* LLUI::sImageProvider = NULL;
  79. /*static*/ LLUIAudioCallback LLUI::sAudioCallback = NULL;
  80. /*static*/ LLVector2 LLUI::sGLScaleFactor(1.f, 1.f);
  81. /*static*/ LLWindow* LLUI::sWindow = NULL;
  82. /*static*/ LLView* LLUI::sRootView = NULL;
  83. /*static*/ BOOL                         LLUI::sDirty = FALSE;
  84. /*static*/ LLRect                       LLUI::sDirtyRect;
  85. /*static*/ LLHelp* LLUI::sHelpImpl = NULL;
  86. /*static*/ std::vector<std::string> LLUI::sXUIPaths;
  87. /*static*/ LLFrameTimer LLUI::sMouseIdleTimer;
  89. // register filtereditor here
  90. static LLDefaultChildRegistry::Register<LLFilterEditor> register_filter_editor("filter_editor");
  91. static LLDefaultChildRegistry::Register<LLFlyoutButton> register_flyout_button("flyout_button");
  92. static LLDefaultChildRegistry::Register<LLSearchEditor> register_search_editor("search_editor");
  93. static LLDefaultChildRegistry::Register<LLMenuButton> register_menu_button("menu_button");
  96. //
  97. // Functions
  98. //
  99. void make_ui_sound(const char* namep)
  100. {
  101. std::string name = ll_safe_string(namep);
  102. if (!LLUI::sSettingGroups["config"]->controlExists(name))
  103. {
  104. llwarns << "tried to make ui sound for unknown sound name: " << name << llendl;
  105. }
  106. else
  107. {
  108. LLUUID uuid(LLUI::sSettingGroups["config"]->getString(name));
  109. if (uuid.isNull())
  110. {
  111. if (LLUI::sSettingGroups["config"]->getString(name) == LLUUID::null.asString())
  112. {
  113. if (LLUI::sSettingGroups["config"]->getBOOL("UISndDebugSpamToggle"))
  114. {
  115. llinfos << "ui sound name: " << name << " triggered but silent (null uuid)" << llendl;
  116. }
  117. }
  118. else
  119. {
  120. llwarns << "ui sound named: " << name << " does not translate to a valid uuid" << llendl;
  121. }
  123. }
  124. else if (LLUI::sAudioCallback != NULL)
  125. {
  126. if (LLUI::sSettingGroups["config"]->getBOOL("UISndDebugSpamToggle"))
  127. {
  128. llinfos << "ui sound name: " << name << llendl;
  129. }
  130. LLUI::sAudioCallback(uuid);
  131. }
  132. }
  133. }
  135. BOOL ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom)
  136. {
  137. if (x < left || right < x) return FALSE;
  138. if (y < bottom || top < y) return FALSE;
  139. return TRUE;
  140. }
  143. // Puts GL into 2D drawing mode by turning off lighting, setting to an
  144. // orthographic projection, etc.
  145. void gl_state_for_2d(S32 width, S32 height)
  146. {
  147. stop_glerror();
  148. F32 window_width = (F32) width;//gViewerWindow->getWindowWidth();
  149. F32 window_height = (F32) height;//gViewerWindow->getWindowHeight();
  151. glMatrixMode(GL_PROJECTION);
  152. glLoadIdentity();
  153. glOrtho(0.0f, llmax(window_width, 1.f), 0.0f, llmax(window_height,1.f), -1.0f, 1.0f);
  154. glMatrixMode(GL_MODELVIEW);
  155. glLoadIdentity();
  156. stop_glerror();
  157. }
  160. void gl_draw_x(const LLRect& rect, const LLColor4& color)
  161. {
  162. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  164. gGL.color4fv( color.mV );
  166. gGL.begin( LLRender::LINES );
  167. gGL.vertex2i( rect.mLeft, rect.mTop );
  168. gGL.vertex2i( rect.mRight, rect.mBottom );
  169. gGL.vertex2i( rect.mLeft, rect.mBottom );
  170. gGL.vertex2i( rect.mRight, rect.mTop );
  171. gGL.end();
  172. }
  175. void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset, BOOL filled)
  176. {
  177. gGL.color4fv(color.mV);
  178. gl_rect_2d_offset_local(left, top, right, bottom, pixel_offset, filled);
  179. }
  181. void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset, BOOL filled)
  182. {
  183. gGL.pushMatrix();
  184. left += LLFontGL::sCurOrigin.mX;
  185. right += LLFontGL::sCurOrigin.mX;
  186. bottom += LLFontGL::sCurOrigin.mY;
  187. top += LLFontGL::sCurOrigin.mY;
  189. glLoadIdentity();
  190. gl_rect_2d(llfloor((F32)left * LLUI::sGLScaleFactor.mV[VX]) - pixel_offset,
  191. llfloor((F32)top * LLUI::sGLScaleFactor.mV[VY]) + pixel_offset,
  192. llfloor((F32)right * LLUI::sGLScaleFactor.mV[VX]) + pixel_offset,
  193. llfloor((F32)bottom * LLUI::sGLScaleFactor.mV[VY]) - pixel_offset,
  194. filled);
  195. gGL.popMatrix();
  196. }
  199. void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, BOOL filled )
  200. {
  201. stop_glerror();
  202. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  204. // Counterclockwise quad will face the viewer
  205. if( filled )
  206. {
  207. gGL.begin( LLRender::QUADS );
  208. gGL.vertex2i(left, top);
  209. gGL.vertex2i(left, bottom);
  210. gGL.vertex2i(right, bottom);
  211. gGL.vertex2i(right, top);
  212. gGL.end();
  213. }
  214. else
  215. {
  216. if( gGLManager.mATIOffsetVerticalLines )
  217. {
  218. // Work around bug in ATI driver: vertical lines are offset by (-1,-1)
  219. gGL.begin( LLRender::LINES );
  221. // Verticals 
  222. gGL.vertex2i(left + 1, top);
  223. gGL.vertex2i(left + 1, bottom);
  225. gGL.vertex2i(right, bottom);
  226. gGL.vertex2i(right, top);
  228. // Horizontals
  229. top--;
  230. right--;
  231. gGL.vertex2i(left, bottom);
  232. gGL.vertex2i(right, bottom);
  234. gGL.vertex2i(left, top);
  235. gGL.vertex2i(right, top);
  236. gGL.end();
  237. }
  238. else
  239. {
  240. top--;
  241. right--;
  242. gGL.begin( LLRender::LINE_STRIP );
  243. gGL.vertex2i(left, top);
  244. gGL.vertex2i(left, bottom);
  245. gGL.vertex2i(right, bottom);
  246. gGL.vertex2i(right, top);
  247. gGL.vertex2i(left, top);
  248. gGL.end();
  249. }
  250. }
  251. stop_glerror();
  252. }
  254. void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, BOOL filled )
  255. {
  256. gGL.color4fv( color.mV );
  257. gl_rect_2d( left, top, right, bottom, filled );
  258. }
  261. void gl_rect_2d( const LLRect& rect, const LLColor4& color, BOOL filled )
  262. {
  263. gGL.color4fv( color.mV );
  264. gl_rect_2d( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, filled );
  265. }
  267. // Given a rectangle on the screen, draws a drop shadow _outside_
  268. // the right and bottom edges of it.  Along the right it has width "lines"
  269. // and along the bottom it has height "lines".
  270. void gl_drop_shadow(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &start_color, S32 lines)
  271. {
  272. stop_glerror();
  273. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  275. // HACK: Overlap with the rectangle by a single pixel.
  276. right--;
  277. bottom++;
  278. lines++;
  280. LLColor4 end_color = start_color;
  281. end_color.mV[VALPHA] = 0.f;
  283. gGL.begin(LLRender::QUADS);
  285. // Right edge, CCW faces screen
  286. gGL.color4fv(start_color.mV);
  287. gGL.vertex2i(right, top-lines);
  288. gGL.vertex2i(right, bottom);
  289. gGL.color4fv(end_color.mV);
  290. gGL.vertex2i(right+lines, bottom);
  291. gGL.vertex2i(right+lines, top-lines);
  293. // Bottom edge, CCW faces screen
  294. gGL.color4fv(start_color.mV);
  295. gGL.vertex2i(right, bottom);
  296. gGL.vertex2i(left+lines, bottom);
  297. gGL.color4fv(end_color.mV);
  298. gGL.vertex2i(left+lines, bottom-lines);
  299. gGL.vertex2i(right, bottom-lines);
  301. // bottom left Corner
  302. gGL.color4fv(start_color.mV);
  303. gGL.vertex2i(left+lines, bottom);
  304. gGL.color4fv(end_color.mV);
  305. gGL.vertex2i(left, bottom);
  306. // make the bottom left corner not sharp
  307. gGL.vertex2i(left+1, bottom-lines+1);
  308. gGL.vertex2i(left+lines, bottom-lines);
  310. // bottom right corner
  311. gGL.color4fv(start_color.mV);
  312. gGL.vertex2i(right, bottom);
  313. gGL.color4fv(end_color.mV);
  314. gGL.vertex2i(right, bottom-lines);
  315. // make the rightmost corner not sharp
  316. gGL.vertex2i(right+lines-1, bottom-lines+1);
  317. gGL.vertex2i(right+lines, bottom);
  319. // top right corner
  320. gGL.color4fv(start_color.mV);
  321. gGL.vertex2i( right, top-lines );
  322. gGL.color4fv(end_color.mV);
  323. gGL.vertex2i( right+lines, top-lines );
  324. // make the corner not sharp
  325. gGL.vertex2i( right+lines-1, top-1 );
  326. gGL.vertex2i( right, top );
  328. gGL.end();
  329. stop_glerror();
  330. }
  332. void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2 )
  333. {
  334. // Work around bug in ATI driver: vertical lines are offset by (-1,-1)
  335. if( (x1 == x2) && gGLManager.mATIOffsetVerticalLines )
  336. {
  337. x1++;
  338. x2++;
  339. y1++;
  340. y2++;
  341. }
  343. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  345. gGL.begin(LLRender::LINES);
  346. gGL.vertex2i(x1, y1);
  347. gGL.vertex2i(x2, y2);
  348. gGL.end();
  349. }
  351. void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2, const LLColor4 &color )
  352. {
  353. // Work around bug in ATI driver: vertical lines are offset by (-1,-1)
  354. if( (x1 == x2) && gGLManager.mATIOffsetVerticalLines )
  355. {
  356. x1++;
  357. x2++;
  358. y1++;
  359. y2++;
  360. }
  362. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  364. gGL.color4fv( color.mV );
  366. gGL.begin(LLRender::LINES);
  367. gGL.vertex2i(x1, y1);
  368. gGL.vertex2i(x2, y2);
  369. gGL.end();
  370. }
  372. void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, BOOL filled)
  373. {
  374. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  376. gGL.color4fv(color.mV);
  378. if (filled)
  379. {
  380. gGL.begin(LLRender::TRIANGLES);
  381. }
  382. else
  383. {
  384. gGL.begin(LLRender::LINE_LOOP);
  385. }
  386. gGL.vertex2i(x1, y1);
  387. gGL.vertex2i(x2, y2);
  388. gGL.vertex2i(x3, y3);
  389. gGL.end();
  390. }
  392. void gl_corners_2d(S32 left, S32 top, S32 right, S32 bottom, S32 length, F32 max_frac)
  393. {
  394. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  396. length = llmin((S32)(max_frac*(right - left)), length);
  397. length = llmin((S32)(max_frac*(top - bottom)), length);
  398. gGL.begin(LLRender::LINES);
  399. gGL.vertex2i(left, top);
  400. gGL.vertex2i(left + length, top);
  402. gGL.vertex2i(left, top);
  403. gGL.vertex2i(left, top - length);
  405. gGL.vertex2i(left, bottom);
  406. gGL.vertex2i(left + length, bottom);
  408. gGL.vertex2i(left, bottom);
  409. gGL.vertex2i(left, bottom + length);
  411. gGL.vertex2i(right, top);
  412. gGL.vertex2i(right - length, top);
  414. gGL.vertex2i(right, top);
  415. gGL.vertex2i(right, top - length);
  417. gGL.vertex2i(right, bottom);
  418. gGL.vertex2i(right - length, bottom);
  420. gGL.vertex2i(right, bottom);
  421. gGL.vertex2i(right, bottom + length);
  422. gGL.end();
  423. }
  426. void gl_draw_image( S32 x, S32 y, LLTexture* image, const LLColor4& color, const LLRectf& uv_rect )
  427. {
  428. if (NULL == image)
  429. {
  430. llwarns << "image == NULL; aborting function" << llendl;
  431. return;
  432. }
  433. gl_draw_scaled_rotated_image( x, y, image->getWidth(0), image->getHeight(0), 0.f, image, color, uv_rect );
  434. }
  436. void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color, const LLRectf& uv_rect)
  437. {
  438. if (NULL == image)
  439. {
  440. llwarns << "image == NULL; aborting function" << llendl;
  441. return;
  442. }
  443. gl_draw_scaled_rotated_image( x, y, width, height, 0.f, image, color, uv_rect );
  444. }
  446. void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4& color, BOOL solid_color, const LLRectf& uv_rect)
  447. {
  448. if (NULL == image)
  449. {
  450. llwarns << "image == NULL; aborting function" << llendl;
  451. return;
  452. }
  454. // scale screen size of borders down
  455. F32 border_width_fraction = (F32)border_width / (F32)image->getWidth(0);
  456. F32 border_height_fraction = (F32)border_height / (F32)image->getHeight(0);
  458. LLRectf scale_rect(border_width_fraction, 1.f - border_height_fraction, 1.f - border_width_fraction, border_height_fraction);
  459. gl_draw_scaled_image_with_border(x, y, width, height, image, color, solid_color, uv_rect, scale_rect);
  460. }
  462. void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color, BOOL solid_color, const LLRectf& uv_rect, const LLRectf& scale_rect)
  463. {
  464. stop_glerror();
  466. if (NULL == image)
  467. {
  468. llwarns << "image == NULL; aborting function" << llendl;
  469. return;
  470. }
  472. // shrink scaling region to be proportional to clipped image region
  473. LLRectf scale_rect_uv(
  474. uv_rect.mLeft + (scale_rect.mLeft * uv_rect.getWidth()),
  475. uv_rect.mBottom + (scale_rect.mTop * uv_rect.getHeight()),
  476. uv_rect.mLeft + (scale_rect.mRight * uv_rect.getWidth()),
  477. uv_rect.mBottom + (scale_rect.mBottom * uv_rect.getHeight()));
  479. S32 image_natural_width = llround((F32)image->getWidth(0) * uv_rect.getWidth());
  480. S32 image_natural_height = llround((F32)image->getHeight(0) * uv_rect.getHeight());
  482. LLRect draw_rect(0, height, width, 0);
  483. LLRect draw_scale_rect(llround(scale_rect_uv.mLeft * (F32)image->getWidth(0)),
  484. llround(scale_rect_uv.mTop * (F32)image->getHeight(0)),
  485. llround(scale_rect_uv.mRight * (F32)image->getWidth(0)),
  486. llround(scale_rect_uv.mBottom * (F32)image->getHeight(0)));
  487. // scale fixed region of image to drawn region
  488. draw_scale_rect.mRight += width - image_natural_width;
  489. draw_scale_rect.mTop += height - image_natural_height;
  491. S32 border_shrink_width = llmax(0, draw_scale_rect.mLeft - draw_scale_rect.mRight);
  492. S32 border_shrink_height = llmax(0, draw_scale_rect.mBottom - draw_scale_rect.mTop);
  494. F32 shrink_width_ratio = scale_rect.getWidth() == 1.f ? 0.f : border_shrink_width / ((F32)image_natural_width * (1.f - scale_rect.getWidth()));
  495. F32 shrink_height_ratio = scale_rect.getHeight() == 1.f ? 0.f : border_shrink_height / ((F32)image_natural_height * (1.f - scale_rect.getHeight()));
  497. F32 shrink_scale = 1.f - llmax(shrink_width_ratio, shrink_height_ratio);
  498. draw_scale_rect.mLeft = llround((F32)draw_scale_rect.mLeft * shrink_scale);
  499. draw_scale_rect.mTop = llround(lerp((F32)height, (F32)draw_scale_rect.mTop, shrink_scale));
  500. draw_scale_rect.mRight = llround(lerp((F32)width, (F32)draw_scale_rect.mRight, shrink_scale));
  501. draw_scale_rect.mBottom = llround((F32)draw_scale_rect.mBottom * shrink_scale);
  503. LLGLSUIDefault gls_ui;
  505. if (solid_color)
  506. {
  507. gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_COLOR);
  508. gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_ALPHA, LLTexUnit::TBS_VERT_ALPHA);
  509. }
  511. gGL.pushMatrix();
  512. {
  513. gGL.translatef((F32)x, (F32)y, 0.f);
  515. gGL.getTexUnit(0)->bind(image);
  517. gGL.color4fv(color.mV);
  519. gGL.begin(LLRender::QUADS);
  520. {
  521. // draw bottom left
  522. gGL.texCoord2f(uv_rect.mLeft, uv_rect.mBottom);
  523. gGL.vertex2i(0, 0);
  525. gGL.texCoord2f(scale_rect_uv.mLeft, uv_rect.mBottom);
  526. gGL.vertex2i(draw_scale_rect.mLeft, 0);
  528. gGL.texCoord2f(scale_rect_uv.mLeft, scale_rect_uv.mBottom);
  529. gGL.vertex2i(draw_scale_rect.mLeft, draw_scale_rect.mBottom);
  531. gGL.texCoord2f(uv_rect.mLeft, scale_rect_uv.mBottom);
  532. gGL.vertex2i(0, draw_scale_rect.mBottom);
  534. // draw bottom middle
  535. gGL.texCoord2f(scale_rect_uv.mLeft, uv_rect.mBottom);
  536. gGL.vertex2i(draw_scale_rect.mLeft, 0);
  538. gGL.texCoord2f(scale_rect_uv.mRight, uv_rect.mBottom);
  539. gGL.vertex2i(draw_scale_rect.mRight, 0);
  541. gGL.texCoord2f(scale_rect_uv.mRight, scale_rect_uv.mBottom);
  542. gGL.vertex2i(draw_scale_rect.mRight, draw_scale_rect.mBottom);
  544. gGL.texCoord2f(scale_rect_uv.mLeft, scale_rect_uv.mBottom);
  545. gGL.vertex2i(draw_scale_rect.mLeft, draw_scale_rect.mBottom);
  547. // draw bottom right
  548. gGL.texCoord2f(scale_rect_uv.mRight, uv_rect.mBottom);
  549. gGL.vertex2i(draw_scale_rect.mRight, 0);
  551. gGL.texCoord2f(uv_rect.mRight, uv_rect.mBottom);
  552. gGL.vertex2i(width, 0);
  554. gGL.texCoord2f(uv_rect.mRight, scale_rect_uv.mBottom);
  555. gGL.vertex2i(width, draw_scale_rect.mBottom);
  557. gGL.texCoord2f(scale_rect_uv.mRight, scale_rect_uv.mBottom);
  558. gGL.vertex2i(draw_scale_rect.mRight, draw_scale_rect.mBottom);
  560. // draw left 
  561. gGL.texCoord2f(uv_rect.mLeft, scale_rect_uv.mBottom);
  562. gGL.vertex2i(0, draw_scale_rect.mBottom);
  564. gGL.texCoord2f(scale_rect_uv.mLeft, scale_rect_uv.mBottom);
  565. gGL.vertex2i(draw_scale_rect.mLeft, draw_scale_rect.mBottom);
  567. gGL.texCoord2f(scale_rect_uv.mLeft, scale_rect_uv.mTop);
  568. gGL.vertex2i(draw_scale_rect.mLeft, draw_scale_rect.mTop);
  570. gGL.texCoord2f(uv_rect.mLeft, scale_rect_uv.mTop);
  571. gGL.vertex2i(0, draw_scale_rect.mTop);
  573. // draw middle
  574. gGL.texCoord2f(scale_rect_uv.mLeft, scale_rect_uv.mBottom);
  575. gGL.vertex2i(draw_scale_rect.mLeft, draw_scale_rect.mBottom);
  577. gGL.texCoord2f(scale_rect_uv.mRight, scale_rect_uv.mBottom);
  578. gGL.vertex2i(draw_scale_rect.mRight, draw_scale_rect.mBottom);
  580. gGL.texCoord2f(scale_rect_uv.mRight, scale_rect_uv.mTop);
  581. gGL.vertex2i(draw_scale_rect.mRight, draw_scale_rect.mTop);
  583. gGL.texCoord2f(scale_rect_uv.mLeft, scale_rect_uv.mTop);
  584. gGL.vertex2i(draw_scale_rect.mLeft, draw_scale_rect.mTop);
  586. // draw right 
  587. gGL.texCoord2f(scale_rect_uv.mRight, scale_rect_uv.mBottom);
  588. gGL.vertex2i(draw_scale_rect.mRight, draw_scale_rect.mBottom);
  590. gGL.texCoord2f(uv_rect.mRight, scale_rect_uv.mBottom);
  591. gGL.vertex2i(width, draw_scale_rect.mBottom);
  593. gGL.texCoord2f(uv_rect.mRight, scale_rect_uv.mTop);
  594. gGL.vertex2i(width, draw_scale_rect.mTop);
  596. gGL.texCoord2f(scale_rect_uv.mRight, scale_rect_uv.mTop);
  597. gGL.vertex2i(draw_scale_rect.mRight, draw_scale_rect.mTop);
  599. // draw top left
  600. gGL.texCoord2f(uv_rect.mLeft, scale_rect_uv.mTop);
  601. gGL.vertex2i(0, draw_scale_rect.mTop);
  603. gGL.texCoord2f(scale_rect_uv.mLeft, scale_rect_uv.mTop);
  604. gGL.vertex2i(draw_scale_rect.mLeft, draw_scale_rect.mTop);
  606. gGL.texCoord2f(scale_rect_uv.mLeft, uv_rect.mTop);
  607. gGL.vertex2i(draw_scale_rect.mLeft, height);
  609. gGL.texCoord2f(uv_rect.mLeft, uv_rect.mTop);
  610. gGL.vertex2i(0, height);
  612. // draw top middle
  613. gGL.texCoord2f(scale_rect_uv.mLeft, scale_rect_uv.mTop);
  614. gGL.vertex2i(draw_scale_rect.mLeft, draw_scale_rect.mTop);
  616. gGL.texCoord2f(scale_rect_uv.mRight, scale_rect_uv.mTop);
  617. gGL.vertex2i(draw_scale_rect.mRight, draw_scale_rect.mTop);
  619. gGL.texCoord2f(scale_rect_uv.mRight, uv_rect.mTop);
  620. gGL.vertex2i(draw_scale_rect.mRight, height);
  622. gGL.texCoord2f(scale_rect_uv.mLeft, uv_rect.mTop);
  623. gGL.vertex2i(draw_scale_rect.mLeft, height);
  625. // draw top right
  626. gGL.texCoord2f(scale_rect_uv.mRight, scale_rect_uv.mTop);
  627. gGL.vertex2i(draw_scale_rect.mRight, draw_scale_rect.mTop);
  629. gGL.texCoord2f(uv_rect.mRight, scale_rect_uv.mTop);
  630. gGL.vertex2i(width, draw_scale_rect.mTop);
  632. gGL.texCoord2f(uv_rect.mRight, uv_rect.mTop);
  633. gGL.vertex2i(width, height);
  635. gGL.texCoord2f(scale_rect_uv.mRight, uv_rect.mTop);
  636. gGL.vertex2i(draw_scale_rect.mRight, height);
  637. }
  638. gGL.end();
  639. }
  640. gGL.popMatrix();
  642. if (solid_color)
  643. {
  644. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  645. }
  646. }
  648. void gl_draw_rotated_image(S32 x, S32 y, F32 degrees, LLTexture* image, const LLColor4& color, const LLRectf& uv_rect)
  649. {
  650. gl_draw_scaled_rotated_image( x, y, image->getWidth(0), image->getHeight(0), degrees, image, color, uv_rect );
  651. }
  653. void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degrees, LLTexture* image, const LLColor4& color, const LLRectf& uv_rect)
  654. {
  655. if (NULL == image)
  656. {
  657. llwarns << "image == NULL; aborting function" << llendl;
  658. return;
  659. }
  661. LLGLSUIDefault gls_ui;
  663. gGL.pushMatrix();
  664. {
  665. gGL.translatef((F32)x, (F32)y, 0.f);
  666. if( degrees )
  667. {
  668. F32 offset_x = F32(width/2);
  669. F32 offset_y = F32(height/2);
  670. gGL.translatef( offset_x, offset_y, 0.f);
  671. glRotatef( degrees, 0.f, 0.f, 1.f );
  672. gGL.translatef( -offset_x, -offset_y, 0.f );
  673. }
  675. gGL.getTexUnit(0)->bind(image);
  677. gGL.color4fv(color.mV);
  679. gGL.begin(LLRender::QUADS);
  680. {
  681. gGL.texCoord2f(uv_rect.mRight, uv_rect.mTop);
  682. gGL.vertex2i(width, height );
  684. gGL.texCoord2f(uv_rect.mLeft, uv_rect.mTop);
  685. gGL.vertex2i(0, height );
  687. gGL.texCoord2f(uv_rect.mLeft, uv_rect.mBottom);
  688. gGL.vertex2i(0, 0);
  690. gGL.texCoord2f(uv_rect.mRight, uv_rect.mBottom);
  691. gGL.vertex2i(width, 0);
  692. }
  693. gGL.end();
  694. }
  695. gGL.popMatrix();
  696. }
  699. void gl_stippled_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& color, F32 phase )
  700. {
  701. phase = fmod(phase, 1.f);
  703. S32 shift = S32(phase * 4.f) % 4;
  705. // Stippled line
  706. LLGLEnable stipple(GL_LINE_STIPPLE);
  708. gGL.color4f(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE], color.mV[VALPHA]);
  710. gGL.flush();
  711. glLineWidth(2.5f);
  712. glLineStipple(2, 0x3333 << shift);
  714. gGL.begin(LLRender::LINES);
  715. {
  716. gGL.vertex3fv( start.mV );
  717. gGL.vertex3fv( end.mV );
  718. }
  719. gGL.end();
  721. LLUI::setLineWidth(1.f);
  722. }
  725. void gl_rect_2d_xor(S32 left, S32 top, S32 right, S32 bottom)
  726. {
  727. gGL.color4fv( LLColor4::white.mV );
  728. glLogicOp( GL_XOR );
  729. stop_glerror();
  731. gGL.begin(LLRender::QUADS);
  732. gGL.vertex2i(left, top);
  733. gGL.vertex2i(left, bottom);
  734. gGL.vertex2i(right, bottom);
  735. gGL.vertex2i(right, top);
  736. gGL.end();
  738. glLogicOp( GL_COPY );
  739. stop_glerror();
  740. }
  743. void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F32 start_angle, F32 end_angle)
  744. {
  745. if (end_angle < start_angle)
  746. {
  747. end_angle += F_TWO_PI;
  748. }
  750. gGL.pushMatrix();
  751. {
  752. gGL.translatef(center_x, center_y, 0.f);
  754. // Inexact, but reasonably fast.
  755. F32 delta = (end_angle - start_angle) / steps;
  756. F32 sin_delta = sin( delta );
  757. F32 cos_delta = cos( delta );
  758. F32 x = cosf(start_angle) * radius;
  759. F32 y = sinf(start_angle) * radius;
  761. if (filled)
  762. {
  763. gGL.begin(LLRender::TRIANGLE_FAN);
  764. gGL.vertex2f(0.f, 0.f);
  765. // make sure circle is complete
  766. steps += 1;
  767. }
  768. else
  769. {
  770. gGL.begin(LLRender::LINE_STRIP);
  771. }
  773. while( steps-- )
  774. {
  775. // Successive rotations
  776. gGL.vertex2f( x, y );
  777. F32 x_new = x * cos_delta - y * sin_delta;
  778. y = x * sin_delta +  y * cos_delta;
  779. x = x_new;
  780. }
  781. gGL.end();
  782. }
  783. gGL.popMatrix();
  784. }
  786. void gl_circle_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled)
  787. {
  788. gGL.pushMatrix();
  789. {
  790. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  791. gGL.translatef(center_x, center_y, 0.f);
  793. // Inexact, but reasonably fast.
  794. F32 delta = F_TWO_PI / steps;
  795. F32 sin_delta = sin( delta );
  796. F32 cos_delta = cos( delta );
  797. F32 x = radius;
  798. F32 y = 0.f;
  800. if (filled)
  801. {
  802. gGL.begin(LLRender::TRIANGLE_FAN);
  803. gGL.vertex2f(0.f, 0.f);
  804. // make sure circle is complete
  805. steps += 1;
  806. }
  807. else
  808. {
  809. gGL.begin(LLRender::LINE_LOOP);
  810. }
  812. while( steps-- )
  813. {
  814. // Successive rotations
  815. gGL.vertex2f( x, y );
  816. F32 x_new = x * cos_delta - y * sin_delta;
  817. y = x * sin_delta +  y * cos_delta;
  818. x = x_new;
  819. }
  820. gGL.end();
  821. }
  822. gGL.popMatrix();
  823. }
  825. // Renders a ring with sides (tube shape)
  826. void gl_deep_circle( F32 radius, F32 depth, S32 steps )
  827. {
  828. F32 x = radius;
  829. F32 y = 0.f;
  830. F32 angle_delta = F_TWO_PI / (F32)steps;
  831. gGL.begin( LLRender::TRIANGLE_STRIP  );
  832. {
  833. S32 step = steps + 1; // An extra step to close the circle.
  834. while( step-- )
  835. {
  836. gGL.vertex3f( x, y, depth );
  837. gGL.vertex3f( x, y, 0.f );
  839. F32 x_new = x * cosf(angle_delta) - y * sinf(angle_delta);
  840. y = x * sinf(angle_delta) +  y * cosf(angle_delta);
  841. x = x_new;
  842. }
  843. }
  844. gGL.end();
  845. }
  847. void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, BOOL render_center )
  848. {
  849. gGL.pushMatrix();
  850. {
  851. gGL.translatef(0.f, 0.f, -width / 2);
  852. if( render_center )
  853. {
  854. gGL.color4fv(center_color.mV);
  855. gl_deep_circle( radius, width, steps );
  856. }
  857. else
  858. {
  859. gl_washer_2d(radius, radius - width, steps, side_color, side_color);
  860. gGL.translatef(0.f, 0.f, width);
  861. gl_washer_2d(radius - width, radius, steps, side_color, side_color);
  862. }
  863. }
  864. gGL.popMatrix();
  865. }
  867. // Draw gray and white checkerboard with black border
  868. void gl_rect_2d_checkerboard(const LLRect& rect)
  869. {
  870. // Initialize the first time this is called.
  871. const S32 PIXELS = 32;
  872. static GLubyte checkerboard[PIXELS * PIXELS];
  873. static BOOL first = TRUE;
  874. if( first )
  875. {
  876. for( S32 i = 0; i < PIXELS; i++ )
  877. {
  878. for( S32 j = 0; j < PIXELS; j++ )
  879. {
  880. checkerboard[i * PIXELS + j] = ((i & 1) ^ (j & 1)) * 0xFF;
  881. }
  882. }
  883. first = FALSE;
  884. }
  886. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  888. // ...white squares
  889. gGL.color3f( 1.f, 1.f, 1.f );
  890. gl_rect_2d(rect);
  892. // ...gray squares
  893. gGL.color3f( .7f, .7f, .7f );
  894. gGL.flush();
  895. glPolygonStipple( checkerboard );
  897. LLGLEnable polygon_stipple(GL_POLYGON_STIPPLE);
  898. gl_rect_2d(rect);
  899. gGL.flush();
  900. }
  903. // Draws the area between two concentric circles, like
  904. // a doughnut or washer.
  905. void gl_washer_2d(F32 outer_radius, F32 inner_radius, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color)
  906. {
  907. const F32 DELTA = F_TWO_PI / steps;
  908. const F32 SIN_DELTA = sin( DELTA );
  909. const F32 COS_DELTA = cos( DELTA );
  911. F32 x1 = outer_radius;
  912. F32 y1 = 0.f;
  913. F32 x2 = inner_radius;
  914. F32 y2 = 0.f;
  916. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  918. gGL.begin( LLRender::TRIANGLE_STRIP  );
  919. {
  920. steps += 1; // An extra step to close the circle.
  921. while( steps-- )
  922. {
  923. gGL.color4fv(outer_color.mV);
  924. gGL.vertex2f( x1, y1 );
  925. gGL.color4fv(inner_color.mV);
  926. gGL.vertex2f( x2, y2 );
  928. F32 x1_new = x1 * COS_DELTA - y1 * SIN_DELTA;
  929. y1 = x1 * SIN_DELTA +  y1 * COS_DELTA;
  930. x1 = x1_new;
  932. F32 x2_new = x2 * COS_DELTA - y2 * SIN_DELTA;
  933. y2 = x2 * SIN_DELTA +  y2 * COS_DELTA;
  934. x2 = x2_new;
  935. }
  936. }
  937. gGL.end();
  938. }
  940. // Draws the area between two concentric circles, like
  941. // a doughnut or washer.
  942. void gl_washer_segment_2d(F32 outer_radius, F32 inner_radius, F32 start_radians, F32 end_radians, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color)
  943. {
  944. const F32 DELTA = (end_radians - start_radians) / steps;
  945. const F32 SIN_DELTA = sin( DELTA );
  946. const F32 COS_DELTA = cos( DELTA );
  948. F32 x1 = outer_radius * cos( start_radians );
  949. F32 y1 = outer_radius * sin( start_radians );
  950. F32 x2 = inner_radius * cos( start_radians );
  951. F32 y2 = inner_radius * sin( start_radians );
  953. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  954. gGL.begin( LLRender::TRIANGLE_STRIP  );
  955. {
  956. steps += 1; // An extra step to close the circle.
  957. while( steps-- )
  958. {
  959. gGL.color4fv(outer_color.mV);
  960. gGL.vertex2f( x1, y1 );
  961. gGL.color4fv(inner_color.mV);
  962. gGL.vertex2f( x2, y2 );
  964. F32 x1_new = x1 * COS_DELTA - y1 * SIN_DELTA;
  965. y1 = x1 * SIN_DELTA +  y1 * COS_DELTA;
  966. x1 = x1_new;
  968. F32 x2_new = x2 * COS_DELTA - y2 * SIN_DELTA;
  969. y2 = x2 * SIN_DELTA +  y2 * COS_DELTA;
  970. x2 = x2_new;
  971. }
  972. }
  973. gGL.end();
  974. }
  976. // Draws spokes around a circle.
  977. void gl_washer_spokes_2d(F32 outer_radius, F32 inner_radius, S32 count, const LLColor4& inner_color, const LLColor4& outer_color)
  978. {
  979. const F32 DELTA = F_TWO_PI / count;
  980. const F32 HALF_DELTA = DELTA * 0.5f;
  981. const F32 SIN_DELTA = sin( DELTA );
  982. const F32 COS_DELTA = cos( DELTA );
  984. F32 x1 = outer_radius * cos( HALF_DELTA );
  985. F32 y1 = outer_radius * sin( HALF_DELTA );
  986. F32 x2 = inner_radius * cos( HALF_DELTA );
  987. F32 y2 = inner_radius * sin( HALF_DELTA );
  989. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  991. gGL.begin( LLRender::LINES  );
  992. {
  993. while( count-- )
  994. {
  995. gGL.color4fv(outer_color.mV);
  996. gGL.vertex2f( x1, y1 );
  997. gGL.color4fv(inner_color.mV);
  998. gGL.vertex2f( x2, y2 );
  1000. F32 x1_new = x1 * COS_DELTA - y1 * SIN_DELTA;
  1001. y1 = x1 * SIN_DELTA +  y1 * COS_DELTA;
  1002. x1 = x1_new;
  1004. F32 x2_new = x2 * COS_DELTA - y2 * SIN_DELTA;
  1005. y2 = x2 * SIN_DELTA +  y2 * COS_DELTA;
  1006. x2 = x2_new;
  1007. }
  1008. }
  1009. gGL.end();
  1010. }
  1012. void gl_rect_2d_simple_tex( S32 width, S32 height )
  1013. {
  1014. gGL.begin( LLRender::QUADS );
  1016. gGL.texCoord2f(1.f, 1.f);
  1017. gGL.vertex2i(width, height);
  1019. gGL.texCoord2f(0.f, 1.f);
  1020. gGL.vertex2i(0, height);
  1022. gGL.texCoord2f(0.f, 0.f);
  1023. gGL.vertex2i(0, 0);
  1025. gGL.texCoord2f(1.f, 0.f);
  1026. gGL.vertex2i(width, 0);
  1028. gGL.end();
  1029. }
  1031. void gl_rect_2d_simple( S32 width, S32 height )
  1032. {
  1033. gGL.begin( LLRender::QUADS );
  1034. gGL.vertex2i(width, height);
  1035. gGL.vertex2i(0, height);
  1036. gGL.vertex2i(0, 0);
  1037. gGL.vertex2i(width, 0);
  1038. gGL.end();
  1039. }
  1041. void gl_segmented_rect_2d_tex(const S32 left, 
  1042.   const S32 top, 
  1043.   const S32 right, 
  1044.   const S32 bottom, 
  1045.   const S32 texture_width, 
  1046.   const S32 texture_height, 
  1047.   const S32 border_size, 
  1048.   const U32 edges)
  1049. {
  1050. S32 width = llabs(right - left);
  1051. S32 height = llabs(top - bottom);
  1053. gGL.pushMatrix();
  1055. gGL.translatef((F32)left, (F32)bottom, 0.f);
  1056. LLVector2 border_uv_scale((F32)border_size / (F32)texture_width, (F32)border_size / (F32)texture_height);
  1058. if (border_uv_scale.mV[VX] > 0.5f)
  1059. {
  1060. border_uv_scale *= 0.5f / border_uv_scale.mV[VX];
  1061. }
  1062. if (border_uv_scale.mV[VY] > 0.5f)
  1063. {
  1064. border_uv_scale *= 0.5f / border_uv_scale.mV[VY];
  1065. }
  1067. F32 border_scale = llmin((F32)border_size, (F32)width * 0.5f, (F32)height * 0.5f);
  1068. LLVector2 border_width_left = ((edges & (~(U32)ROUNDED_RECT_RIGHT)) != 0) ? LLVector2(border_scale, 0.f) : LLVector2::zero;
  1069. LLVector2 border_width_right = ((edges & (~(U32)ROUNDED_RECT_LEFT)) != 0) ? LLVector2(border_scale, 0.f) : LLVector2::zero;
  1070. LLVector2 border_height_bottom = ((edges & (~(U32)ROUNDED_RECT_TOP)) != 0) ? LLVector2(0.f, border_scale) : LLVector2::zero;
  1071. LLVector2 border_height_top = ((edges & (~(U32)ROUNDED_RECT_BOTTOM)) != 0) ? LLVector2(0.f, border_scale) : LLVector2::zero;
  1072. LLVector2 width_vec((F32)width, 0.f);
  1073. LLVector2 height_vec(0.f, (F32)height);
  1075. gGL.begin(LLRender::QUADS);
  1076. {
  1077. // draw bottom left
  1078. gGL.texCoord2f(0.f, 0.f);
  1079. gGL.vertex2f(0.f, 0.f);
  1081. gGL.texCoord2f(border_uv_scale.mV[VX], 0.f);
  1082. gGL.vertex2fv(border_width_left.mV);
  1084. gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1085. gGL.vertex2fv((border_width_left + border_height_bottom).mV);
  1087. gGL.texCoord2f(0.f, border_uv_scale.mV[VY]);
  1088. gGL.vertex2fv(border_height_bottom.mV);
  1090. // draw bottom middle
  1091. gGL.texCoord2f(border_uv_scale.mV[VX], 0.f);
  1092. gGL.vertex2fv(border_width_left.mV);
  1094. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 0.f);
  1095. gGL.vertex2fv((width_vec - border_width_right).mV);
  1097. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1098. gGL.vertex2fv((width_vec - border_width_right + border_height_bottom).mV);
  1100. gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1101. gGL.vertex2fv((border_width_left + border_height_bottom).mV);
  1103. // draw bottom right
  1104. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 0.f);
  1105. gGL.vertex2fv((width_vec - border_width_right).mV);
  1107. gGL.texCoord2f(1.f, 0.f);
  1108. gGL.vertex2fv(width_vec.mV);
  1110. gGL.texCoord2f(1.f, border_uv_scale.mV[VY]);
  1111. gGL.vertex2fv((width_vec + border_height_bottom).mV);
  1113. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1114. gGL.vertex2fv((width_vec - border_width_right + border_height_bottom).mV);
  1116. // draw left 
  1117. gGL.texCoord2f(0.f, border_uv_scale.mV[VY]);
  1118. gGL.vertex2fv(border_height_bottom.mV);
  1120. gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1121. gGL.vertex2fv((border_width_left + border_height_bottom).mV);
  1123. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1124. gGL.vertex2fv((border_width_left + height_vec - border_height_top).mV);
  1126. gGL.texCoord2f(0.f, 1.f - border_uv_scale.mV[VY]);
  1127. gGL.vertex2fv((height_vec - border_height_top).mV);
  1129. // draw middle
  1130. gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1131. gGL.vertex2fv((border_width_left + border_height_bottom).mV);
  1133. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1134. gGL.vertex2fv((width_vec - border_width_right + border_height_bottom).mV);
  1136. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1137. gGL.vertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
  1139. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1140. gGL.vertex2fv((border_width_left + height_vec - border_height_top).mV);
  1142. // draw right 
  1143. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1144. gGL.vertex2fv((width_vec - border_width_right + border_height_bottom).mV);
  1146. gGL.texCoord2f(1.f, border_uv_scale.mV[VY]);
  1147. gGL.vertex2fv((width_vec + border_height_bottom).mV);
  1149. gGL.texCoord2f(1.f, 1.f - border_uv_scale.mV[VY]);
  1150. gGL.vertex2fv((width_vec + height_vec - border_height_top).mV);
  1152. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1153. gGL.vertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
  1155. // draw top left
  1156. gGL.texCoord2f(0.f, 1.f - border_uv_scale.mV[VY]);
  1157. gGL.vertex2fv((height_vec - border_height_top).mV);
  1159. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1160. gGL.vertex2fv((border_width_left + height_vec - border_height_top).mV);
  1162. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f);
  1163. gGL.vertex2fv((border_width_left + height_vec).mV);
  1165. gGL.texCoord2f(0.f, 1.f);
  1166. gGL.vertex2fv((height_vec).mV);
  1168. // draw top middle
  1169. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1170. gGL.vertex2fv((border_width_left + height_vec - border_height_top).mV);
  1172. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1173. gGL.vertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
  1175. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
  1176. gGL.vertex2fv((width_vec - border_width_right + height_vec).mV);
  1178. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f);
  1179. gGL.vertex2fv((border_width_left + height_vec).mV);
  1181. // draw top right
  1182. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1183. gGL.vertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
  1185. gGL.texCoord2f(1.f, 1.f - border_uv_scale.mV[VY]);
  1186. gGL.vertex2fv((width_vec + height_vec - border_height_top).mV);
  1188. gGL.texCoord2f(1.f, 1.f);
  1189. gGL.vertex2fv((width_vec + height_vec).mV);
  1191. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
  1192. gGL.vertex2fv((width_vec - border_width_right + height_vec).mV);
  1193. }
  1194. gGL.end();
  1196. gGL.popMatrix();
  1197. }
  1199. void gl_segmented_rect_2d_fragment_tex(const S32 left, 
  1200.    const S32 top, 
  1201.    const S32 right, 
  1202.    const S32 bottom, 
  1203.    const S32 texture_width, 
  1204.    const S32 texture_height, 
  1205.    const S32 border_size, 
  1206.    const F32 start_fragment, 
  1207.    const F32 end_fragment, 
  1208.    const U32 edges)
  1209. {
  1210. S32 width = llabs(right - left);
  1211. S32 height = llabs(top - bottom);
  1213. gGL.pushMatrix();
  1215. gGL.translatef((F32)left, (F32)bottom, 0.f);
  1216. LLVector2 border_uv_scale((F32)border_size / (F32)texture_width, (F32)border_size / (F32)texture_height);
  1218. if (border_uv_scale.mV[VX] > 0.5f)
  1219. {
  1220. border_uv_scale *= 0.5f / border_uv_scale.mV[VX];
  1221. }
  1222. if (border_uv_scale.mV[VY] > 0.5f)
  1223. {
  1224. border_uv_scale *= 0.5f / border_uv_scale.mV[VY];
  1225. }
  1227. F32 border_scale = llmin((F32)border_size, (F32)width * 0.5f, (F32)height * 0.5f);
  1228. LLVector2 border_width_left = ((edges & (~(U32)ROUNDED_RECT_RIGHT)) != 0) ? LLVector2(border_scale, 0.f) : LLVector2::zero;
  1229. LLVector2 border_width_right = ((edges & (~(U32)ROUNDED_RECT_LEFT)) != 0) ? LLVector2(border_scale, 0.f) : LLVector2::zero;
  1230. LLVector2 border_height_bottom = ((edges & (~(U32)ROUNDED_RECT_TOP)) != 0) ? LLVector2(0.f, border_scale) : LLVector2::zero;
  1231. LLVector2 border_height_top = ((edges & (~(U32)ROUNDED_RECT_BOTTOM)) != 0) ? LLVector2(0.f, border_scale) : LLVector2::zero;
  1232. LLVector2 width_vec((F32)width, 0.f);
  1233. LLVector2 height_vec(0.f, (F32)height);
  1235. F32 middle_start = border_scale / (F32)width;
  1236. F32 middle_end = 1.f - middle_start;
  1238. F32 u_min;
  1239. F32 u_max;
  1240. LLVector2 x_min;
  1241. LLVector2 x_max;
  1243. gGL.begin(LLRender::QUADS);
  1244. {
  1245. if (start_fragment < middle_start)
  1246. {
  1247. u_min = (start_fragment / middle_start) * border_uv_scale.mV[VX];
  1248. u_max = llmin(end_fragment / middle_start, 1.f) * border_uv_scale.mV[VX];
  1249. x_min = (start_fragment / middle_start) * border_width_left;
  1250. x_max = llmin(end_fragment / middle_start, 1.f) * border_width_left;
  1252. // draw bottom left
  1253. gGL.texCoord2f(u_min, 0.f);
  1254. gGL.vertex2fv(x_min.mV);
  1256. gGL.texCoord2f(border_uv_scale.mV[VX], 0.f);
  1257. gGL.vertex2fv(x_max.mV);
  1259. gGL.texCoord2f(u_max, border_uv_scale.mV[VY]);
  1260. gGL.vertex2fv((x_max + border_height_bottom).mV);
  1262. gGL.texCoord2f(u_min, border_uv_scale.mV[VY]);
  1263. gGL.vertex2fv((x_min + border_height_bottom).mV);
  1265. // draw left 
  1266. gGL.texCoord2f(u_min, border_uv_scale.mV[VY]);
  1267. gGL.vertex2fv((x_min + border_height_bottom).mV);
  1269. gGL.texCoord2f(u_max, border_uv_scale.mV[VY]);
  1270. gGL.vertex2fv((x_max + border_height_bottom).mV);
  1272. gGL.texCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
  1273. gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
  1275. gGL.texCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
  1276. gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
  1278. // draw top left
  1279. gGL.texCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
  1280. gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
  1282. gGL.texCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
  1283. gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
  1285. gGL.texCoord2f(u_max, 1.f);
  1286. gGL.vertex2fv((x_max + height_vec).mV);
  1288. gGL.texCoord2f(u_min, 1.f);
  1289. gGL.vertex2fv((x_min + height_vec).mV);
  1290. }
  1292. if (end_fragment > middle_start || start_fragment < middle_end)
  1293. {
  1294. x_min = border_width_left + ((llclamp(start_fragment, middle_start, middle_end) - middle_start)) * width_vec;
  1295. x_max = border_width_left + ((llclamp(end_fragment, middle_start, middle_end) - middle_start)) * width_vec;
  1297. // draw bottom middle
  1298. gGL.texCoord2f(border_uv_scale.mV[VX], 0.f);
  1299. gGL.vertex2fv(x_min.mV);
  1301. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 0.f);
  1302. gGL.vertex2fv((x_max).mV);
  1304. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1305. gGL.vertex2fv((x_max + border_height_bottom).mV);
  1307. gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1308. gGL.vertex2fv((x_min + border_height_bottom).mV);
  1310. // draw middle
  1311. gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1312. gGL.vertex2fv((x_min + border_height_bottom).mV);
  1314. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
  1315. gGL.vertex2fv((x_max + border_height_bottom).mV);
  1317. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1318. gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
  1320. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1321. gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
  1323. // draw top middle
  1324. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1325. gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
  1327. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
  1328. gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
  1330. gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
  1331. gGL.vertex2fv((x_max + height_vec).mV);
  1333. gGL.texCoord2f(border_uv_scale.mV[VX], 1.f);
  1334. gGL.vertex2fv((x_min + height_vec).mV);
  1335. }
  1337. if (end_fragment > middle_end)
  1338. {
  1339. u_min = (1.f - llmax(0.f, ((start_fragment - middle_end) / middle_start))) * border_uv_scale.mV[VX];
  1340. u_max = (1.f - ((end_fragment - middle_end) / middle_start)) * border_uv_scale.mV[VX];
  1341. x_min = width_vec - ((1.f - llmax(0.f, ((start_fragment - middle_end) / middle_start))) * border_width_right);
  1342. x_max = width_vec - ((1.f - ((end_fragment - middle_end) / middle_start)) * border_width_right);
  1344. // draw bottom right
  1345. gGL.texCoord2f(u_min, 0.f);
  1346. gGL.vertex2fv((x_min).mV);
  1348. gGL.texCoord2f(u_max, 0.f);
  1349. gGL.vertex2fv(x_max.mV);
  1351. gGL.texCoord2f(u_max, border_uv_scale.mV[VY]);
  1352. gGL.vertex2fv((x_max + border_height_bottom).mV);
  1354. gGL.texCoord2f(u_min, border_uv_scale.mV[VY]);
  1355. gGL.vertex2fv((x_min + border_height_bottom).mV);
  1357. // draw right 
  1358. gGL.texCoord2f(u_min, border_uv_scale.mV[VY]);
  1359. gGL.vertex2fv((x_min + border_height_bottom).mV);
  1361. gGL.texCoord2f(u_max, border_uv_scale.mV[VY]);
  1362. gGL.vertex2fv((x_max + border_height_bottom).mV);
  1364. gGL.texCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
  1365. gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
  1367. gGL.texCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
  1368. gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
  1370. // draw top right
  1371. gGL.texCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
  1372. gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
  1374. gGL.texCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
  1375. gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
  1377. gGL.texCoord2f(u_max, 1.f);
  1378. gGL.vertex2fv((x_max + height_vec).mV);
  1380. gGL.texCoord2f(u_min, 1.f);
  1381. gGL.vertex2fv((x_min + height_vec).mV);
  1382. }
  1383. }
  1384. gGL.end();
  1386. gGL.popMatrix();
  1387. }
  1389. void gl_segmented_rect_3d_tex(const LLVector2& border_scale, const LLVector3& border_width, 
  1390.   const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec,
  1391.   const U32 edges)
  1392. {
  1393. LLVector3 left_border_width = ((edges & (~(U32)ROUNDED_RECT_RIGHT)) != 0) ? border_width : LLVector3::zero;
  1394. LLVector3 right_border_width = ((edges & (~(U32)ROUNDED_RECT_LEFT)) != 0) ? border_width : LLVector3::zero;
  1396. LLVector3 top_border_height = ((edges & (~(U32)ROUNDED_RECT_BOTTOM)) != 0) ? border_height : LLVector3::zero;
  1397. LLVector3 bottom_border_height = ((edges & (~(U32)ROUNDED_RECT_TOP)) != 0) ? border_height : LLVector3::zero;
  1400. gGL.begin(LLRender::QUADS);
  1401. {
  1402. // draw bottom left
  1403. gGL.texCoord2f(0.f, 0.f);
  1404. gGL.vertex3f(0.f, 0.f, 0.f);
  1406. gGL.texCoord2f(border_scale.mV[VX], 0.f);
  1407. gGL.vertex3fv(left_border_width.mV);
  1409. gGL.texCoord2f(border_scale.mV[VX], border_scale.mV[VY]);
  1410. gGL.vertex3fv((left_border_width + bottom_border_height).mV);
  1412. gGL.texCoord2f(0.f, border_scale.mV[VY]);
  1413. gGL.vertex3fv(bottom_border_height.mV);
  1415. // draw bottom middle
  1416. gGL.texCoord2f(border_scale.mV[VX], 0.f);
  1417. gGL.vertex3fv(left_border_width.mV);
  1419. gGL.texCoord2f(1.f - border_scale.mV[VX], 0.f);
  1420. gGL.vertex3fv((width_vec - right_border_width).mV);
  1422. gGL.texCoord2f(1.f - border_scale.mV[VX], border_scale.mV[VY]);
  1423. gGL.vertex3fv((width_vec - right_border_width + bottom_border_height).mV);
  1425. gGL.texCoord2f(border_scale.mV[VX], border_scale.mV[VY]);
  1426. gGL.vertex3fv((left_border_width + bottom_border_height).mV);
  1428. // draw bottom right
  1429. gGL.texCoord2f(1.f - border_scale.mV[VX], 0.f);
  1430. gGL.vertex3fv((width_vec - right_border_width).mV);
  1432. gGL.texCoord2f(1.f, 0.f);
  1433. gGL.vertex3fv(width_vec.mV);
  1435. gGL.texCoord2f(1.f, border_scale.mV[VY]);
  1436. gGL.vertex3fv((width_vec + bottom_border_height).mV);
  1438. gGL.texCoord2f(1.f - border_scale.mV[VX], border_scale.mV[VY]);
  1439. gGL.vertex3fv((width_vec - right_border_width + bottom_border_height).mV);
  1441. // draw left 
  1442. gGL.texCoord2f(0.f, border_scale.mV[VY]);
  1443. gGL.vertex3fv(bottom_border_height.mV);
  1445. gGL.texCoord2f(border_scale.mV[VX], border_scale.mV[VY]);
  1446. gGL.vertex3fv((left_border_width + bottom_border_height).mV);
  1448. gGL.texCoord2f(border_scale.mV[VX], 1.f - border_scale.mV[VY]);
  1449. gGL.vertex3fv((left_border_width + height_vec - top_border_height).mV);
  1451. gGL.texCoord2f(0.f, 1.f - border_scale.mV[VY]);
  1452. gGL.vertex3fv((height_vec - top_border_height).mV);
  1454. // draw middle
  1455. gGL.texCoord2f(border_scale.mV[VX], border_scale.mV[VY]);
  1456. gGL.vertex3fv((left_border_width + bottom_border_height).mV);
  1458. gGL.texCoord2f(1.f - border_scale.mV[VX], border_scale.mV[VY]);
  1459. gGL.vertex3fv((width_vec - right_border_width + bottom_border_height).mV);
  1461. gGL.texCoord2f(1.f - border_scale.mV[VX], 1.f - border_scale.mV[VY]);
  1462. gGL.vertex3fv((width_vec - right_border_width + height_vec - top_border_height).mV);
  1464. gGL.texCoord2f(border_scale.mV[VX], 1.f - border_scale.mV[VY]);
  1465. gGL.vertex3fv((left_border_width + height_vec - top_border_height).mV);
  1467. // draw right 
  1468. gGL.texCoord2f(1.f - border_scale.mV[VX], border_scale.mV[VY]);
  1469. gGL.vertex3fv((width_vec - right_border_width + bottom_border_height).mV);
  1471. gGL.texCoord2f(1.f, border_scale.mV[VY]);
  1472. gGL.vertex3fv((width_vec + bottom_border_height).mV);
  1474. gGL.texCoord2f(1.f, 1.f - border_scale.mV[VY]);
  1475. gGL.vertex3fv((width_vec + height_vec - top_border_height).mV);
  1477. gGL.texCoord2f(1.f - border_scale.mV[VX], 1.f - border_scale.mV[VY]);
  1478. gGL.vertex3fv((width_vec - right_border_width + height_vec - top_border_height).mV);
  1480. // draw top left
  1481. gGL.texCoord2f(0.f, 1.f - border_scale.mV[VY]);
  1482. gGL.vertex3fv((height_vec - top_border_height).mV);
  1484. gGL.texCoord2f(border_scale.mV[VX], 1.f - border_scale.mV[VY]);
  1485. gGL.vertex3fv((left_border_width + height_vec - top_border_height).mV);
  1487. gGL.texCoord2f(border_scale.mV[VX], 1.f);
  1488. gGL.vertex3fv((left_border_width + height_vec).mV);
  1490. gGL.texCoord2f(0.f, 1.f);
  1491. gGL.vertex3fv((height_vec).mV);
  1493. // draw top middle
  1494. gGL.texCoord2f(border_scale.mV[VX], 1.f - border_scale.mV[VY]);
  1495. gGL.vertex3fv((left_border_width + height_vec - top_border_height).mV);
  1497. gGL.texCoord2f(1.f - border_scale.mV[VX], 1.f - border_scale.mV[VY]);
  1498. gGL.vertex3fv((width_vec - right_border_width + height_vec - top_border_height).mV);
  1500. gGL.texCoord2f(1.f - border_scale.mV[VX], 1.f);
  1501. gGL.vertex3fv((width_vec - right_border_width + height_vec).mV);
  1503. gGL.texCoord2f(border_scale.mV[VX], 1.f);
  1504. gGL.vertex3fv((left_border_width + height_vec).mV);
  1506. // draw top right
  1507. gGL.texCoord2f(1.f - border_scale.mV[VX], 1.f - border_scale.mV[VY]);
  1508. gGL.vertex3fv((width_vec - right_border_width + height_vec - top_border_height).mV);
  1510. gGL.texCoord2f(1.f, 1.f - border_scale.mV[VY]);
  1511. gGL.vertex3fv((width_vec + height_vec - top_border_height).mV);
  1513. gGL.texCoord2f(1.f, 1.f);
  1514. gGL.vertex3fv((width_vec + height_vec).mV);
  1516. gGL.texCoord2f(1.f - border_scale.mV[VX], 1.f);
  1517. gGL.vertex3fv((width_vec - right_border_width + height_vec).mV);
  1518. }
  1519. gGL.end();
  1521. }
  1523. void gl_segmented_rect_3d_tex_top(const LLVector2& border_scale, const LLVector3& border_width, const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec)
  1524. {
  1525. gl_segmented_rect_3d_tex(border_scale, border_width, border_height, width_vec, height_vec, ROUNDED_RECT_TOP);
  1526. }
  1528. void LLUI::initClass(const settings_map_t& settings,
  1529.  LLImageProviderInterface* image_provider,
  1530.  LLUIAudioCallback audio_callback,
  1531.  const LLVector2* scale_factor,
  1532.  const std::string& language)
  1533. {
  1534. sSettingGroups = settings;
  1536. if ((get_ptr_in_map(sSettingGroups, std::string("config")) == NULL) ||
  1537. (get_ptr_in_map(sSettingGroups, std::string("floater")) == NULL) ||
  1538. (get_ptr_in_map(sSettingGroups, std::string("ignores")) == NULL))
  1539. {
  1540. llerrs << "Failure to initialize configuration groups" << llendl;
  1541. }
  1543. sImageProvider = image_provider;
  1544. sAudioCallback = audio_callback;
  1545. sGLScaleFactor = (scale_factor == NULL) ? LLVector2(1.f, 1.f) : *scale_factor;
  1546. sWindow = NULL; // set later in startup
  1547. LLFontGL::sShadowColor = LLUIColorTable::instance().getColor("ColorDropShadow");
  1549. // Callbacks for associating controls with floater visibilty:
  1550. LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("Floater.Toggle", boost::bind(&LLFloaterReg::toggleFloaterInstance, _2));
  1551. LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("Floater.Show", boost::bind(&LLFloaterReg::showFloaterInstance, _2));
  1552. LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("Floater.Hide", boost::bind(&LLFloaterReg::hideFloaterInstance, _2));
  1553. LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("Floater.InitToVisibilityControl", boost::bind(&LLFloaterReg::initUICtrlToFloaterVisibilityControl, _1, _2));
  1555. // Button initialization callback for toggle buttons
  1556. LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("Button.SetFloaterToggle", boost::bind(&LLButton::setFloaterToggle, _1, _2));
  1558. // Button initialization callback for toggle buttons on dockale floaters
  1559. LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("Button.SetDockableFloaterToggle", boost::bind(&LLButton::setDockableFloaterToggle, _1, _2));
  1561. // Display the help topic for the current context
  1562. LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("Button.ShowHelp", boost::bind(&LLButton::showHelp, _1, _2));
  1564. // Currently unused, but kept for reference:
  1565. LLUICtrl::CommitCallbackRegistry::defaultRegistrar().add("Button.ToggleFloater", boost::bind(&LLButton::toggleFloaterAndSetToggleState, _1, _2));
  1567. // Used by menus along with Floater.Toggle to display visibility as a checkmark
  1568. LLUICtrl::EnableCallbackRegistry::defaultRegistrar().add("Floater.Visible", boost::bind(&LLFloaterReg::floaterInstanceVisible, _2));
  1569. }
  1571. void LLUI::cleanupClass()
  1572. {
  1573. sImageProvider->cleanUp();
  1574. }
  1576. //static
  1577. void LLUI::dirtyRect(LLRect rect)
  1578. {
  1579. if (!sDirty)
  1580. {
  1581. sDirtyRect = rect;
  1582. sDirty = TRUE;
  1583. }
  1584. else
  1585. {
  1586. sDirtyRect.unionWith(rect);
  1587. }
  1588. }
  1589.  
  1591. //static
  1592. void LLUI::translate(F32 x, F32 y, F32 z)
  1593. {
  1594. gGL.translatef(x,y,z);
  1595. LLFontGL::sCurOrigin.mX += (S32) x;
  1596. LLFontGL::sCurOrigin.mY += (S32) y;
  1597. LLFontGL::sCurOrigin.mZ += z;
  1598. }
  1600. //static
  1601. void LLUI::pushMatrix()
  1602. {
  1603. gGL.pushMatrix();
  1604. LLFontGL::sOriginStack.push_back(LLFontGL::sCurOrigin);
  1605. }
  1607. //static
  1608. void LLUI::popMatrix()
  1609. {
  1610. gGL.popMatrix();
  1611. LLFontGL::sCurOrigin = *LLFontGL::sOriginStack.rbegin();
  1612. LLFontGL::sOriginStack.pop_back();
  1613. }
  1615. //static 
  1616. void LLUI::loadIdentity()
  1617. {
  1618. glLoadIdentity();
  1619. LLFontGL::sCurOrigin.mX = 0;
  1620. LLFontGL::sCurOrigin.mY = 0;
  1621. LLFontGL::sCurOrigin.mZ = 0;
  1622. }
  1624. //static
  1625. void LLUI::setScaleFactor(const LLVector2 &scale_factor)
  1626. {
  1627. sGLScaleFactor = scale_factor;
  1628. }
  1630. //static
  1631. void LLUI::setLineWidth(F32 width)
  1632. {
  1633. gGL.flush();
  1634. glLineWidth(width * lerp(sGLScaleFactor.mV[VX], sGLScaleFactor.mV[VY], 0.5f));
  1635. }
  1637. //static 
  1638. void LLUI::setMousePositionScreen(S32 x, S32 y)
  1639. {
  1640. S32 screen_x, screen_y;
  1641. screen_x = llround((F32)x * sGLScaleFactor.mV[VX]);
  1642. screen_y = llround((F32)y * sGLScaleFactor.mV[VY]);
  1644. LLCoordWindow window_point;
  1645. LLView::getWindow()->convertCoords(LLCoordGL(screen_x, screen_y), &window_point);
  1647. LLView::getWindow()->setCursorPosition(window_point);
  1648. }
  1650. //static 
  1651. void LLUI::getMousePositionScreen(S32 *x, S32 *y)
  1652. {
  1653. LLCoordWindow cursor_pos_window;
  1654. getWindow()->getCursorPosition(&cursor_pos_window);
  1655. LLCoordGL cursor_pos_gl;
  1656. getWindow()->convertCoords(cursor_pos_window, &cursor_pos_gl);
  1657. *x = llround((F32)cursor_pos_gl.mX / sGLScaleFactor.mV[VX]);
  1658. *y = llround((F32)cursor_pos_gl.mY / sGLScaleFactor.mV[VX]);
  1659. }
  1661. //static 
  1662. void LLUI::setMousePositionLocal(const LLView* viewp, S32 x, S32 y)
  1663. {
  1664. S32 screen_x, screen_y;
  1665. viewp->localPointToScreen(x, y, &screen_x, &screen_y);
  1667. setMousePositionScreen(screen_x, screen_y);
  1668. }
  1670. //static 
  1671. void LLUI::getMousePositionLocal(const LLView* viewp, S32 *x, S32 *y)
  1672. {
  1673. S32 screen_x, screen_y;
  1674. getMousePositionScreen(&screen_x, &screen_y);
  1675. viewp->screenPointToLocal(screen_x, screen_y, x, y);
  1676. }
  1679. // On Windows, the user typically sets the language when they install the
  1680. // app (by running it with a shortcut that sets InstallLanguage).  On Mac,
  1681. // or on Windows if the SecondLife.exe executable is run directly, the 
  1682. // language follows the OS language.  In all cases the user can override
  1683. // the language manually in preferences. JC
  1684. // static
  1685. std::string LLUI::getLanguage()
  1686. {
  1687. std::string language = "en";
  1688. if (sSettingGroups["config"])
  1689. {
  1690. language = sSettingGroups["config"]->getString("Language");
  1691. if (language.empty() || language == "default")
  1692. {
  1693. language = sSettingGroups["config"]->getString("InstallLanguage");
  1694. }
  1695. if (language.empty() || language == "default")
  1696. {
  1697. language = sSettingGroups["config"]->getString("SystemLanguage");
  1698. }
  1699. if (language.empty() || language == "default")
  1700. {
  1701. language = "en";
  1702. }
  1703. }
  1704. return language;
  1705. }
  1707. //static
  1708. void LLUI::setupPaths()
  1709. {
  1710. std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, "paths.xml");
  1712. LLXMLNodePtr root;
  1713. BOOL success  = LLXMLNode::parseFile(filename, root, NULL);
  1714. sXUIPaths.clear();
  1716. if (success)
  1717. {
  1718. LLStringUtil::format_map_t path_args;
  1719. path_args["[LANGUAGE]"] = LLUI::getLanguage();
  1721. for (LLXMLNodePtr path = root->getFirstChild(); path.notNull(); path = path->getNextSibling())
  1722. {
  1723. std::string path_val_ui(path->getValue());
  1724. LLStringUtil::format(path_val_ui, path_args);
  1725. if (std::find(sXUIPaths.begin(), sXUIPaths.end(), path_val_ui) == sXUIPaths.end())
  1726. {
  1727. sXUIPaths.push_back(path_val_ui);
  1728. }
  1729. }
  1730. }
  1731. else // parsing failed
  1732. {
  1733. std::string slash = gDirUtilp->getDirDelimiter();
  1734. std::string dir = "xui" + slash + "en";
  1735. llwarns << "XUI::config file unable to open: " << filename << llendl;
  1736. sXUIPaths.push_back(dir);
  1737. }
  1738. }
  1741. //static
  1742. std::string LLUI::locateSkin(const std::string& filename)
  1743. {
  1744. std::string slash = gDirUtilp->getDirDelimiter();
  1745. std::string found_file = filename;
  1746. if (!gDirUtilp->fileExists(found_file))
  1747. {
  1748. found_file = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, filename); // Should be CUSTOM_SKINS?
  1749. }
  1750. if (sSettingGroups["config"] && sSettingGroups["config"]->controlExists("Language"))
  1751. {
  1752. if (!gDirUtilp->fileExists(found_file))
  1753. {
  1754. std::string localization = getLanguage();
  1755. std::string local_skin = "xui" + slash + localization + slash + filename;
  1756. found_file = gDirUtilp->findSkinnedFilename(local_skin);
  1757. }
  1758. }
  1759. if (!gDirUtilp->fileExists(found_file))
  1760. {
  1761. std::string local_skin = "xui" + slash + "en" + slash + filename;
  1762. found_file = gDirUtilp->findSkinnedFilename(local_skin);
  1763. }
  1764. if (!gDirUtilp->fileExists(found_file))
  1765. {
  1766. found_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, filename);
  1767. }
  1768. return found_file;
  1769. }
  1771. //static
  1772. LLVector2 LLUI::getWindowSize()
  1773. {
  1774. LLCoordWindow window_rect;
  1775. sWindow->getSize(&window_rect);
  1777. return LLVector2(window_rect.mX / sGLScaleFactor.mV[VX], window_rect.mY / sGLScaleFactor.mV[VY]);
  1778. }
  1780. //static
  1781. void LLUI::screenPointToGL(S32 screen_x, S32 screen_y, S32 *gl_x, S32 *gl_y)
  1782. {
  1783. *gl_x = llround((F32)screen_x * sGLScaleFactor.mV[VX]);
  1784. *gl_y = llround((F32)screen_y * sGLScaleFactor.mV[VY]);
  1785. }
  1787. //static
  1788. void LLUI::glPointToScreen(S32 gl_x, S32 gl_y, S32 *screen_x, S32 *screen_y)
  1789. {
  1790. *screen_x = llround((F32)gl_x / sGLScaleFactor.mV[VX]);
  1791. *screen_y = llround((F32)gl_y / sGLScaleFactor.mV[VY]);
  1792. }
  1794. //static
  1795. void LLUI::screenRectToGL(const LLRect& screen, LLRect *gl)
  1796. {
  1797. screenPointToGL(screen.mLeft, screen.mTop, &gl->mLeft, &gl->mTop);
  1798. screenPointToGL(screen.mRight, screen.mBottom, &gl->mRight, &gl->mBottom);
  1799. }
  1801. //static
  1802. void LLUI::glRectToScreen(const LLRect& gl, LLRect *screen)
  1803. {
  1804. glPointToScreen(gl.mLeft, gl.mTop, &screen->mLeft, &screen->mTop);
  1805. glPointToScreen(gl.mRight, gl.mBottom, &screen->mRight, &screen->mBottom);
  1806. }
  1808. //static
  1809. LLPointer<LLUIImage> LLUI::getUIImageByID(const LLUUID& image_id, S32 priority)
  1810. {
  1811. if (sImageProvider)
  1812. {
  1813. return sImageProvider->getUIImageByID(image_id, priority);
  1814. }
  1815. else
  1816. {
  1817. return NULL;
  1818. }
  1819. }
  1821. //static 
  1822. LLPointer<LLUIImage> LLUI::getUIImage(const std::string& name, S32 priority)
  1823. {
  1824. if (!name.empty() && sImageProvider)
  1825. return sImageProvider->getUIImage(name, priority);
  1826. else
  1827. return NULL;
  1828. }
  1830. LLControlGroup& LLUI::getControlControlGroup (const std::string& controlname)
  1831. {
  1832. for (settings_map_t::iterator itor = sSettingGroups.begin();
  1833.  itor != sSettingGroups.end(); ++itor)
  1834. {
  1835. LLControlGroup* control_group = itor->second;
  1836. if(control_group != NULL)
  1837. {
  1838. if (control_group->controlExists(controlname))
  1839. return *control_group;
  1840. }
  1841. }
  1843. return *sSettingGroups["config"]; // default group
  1844. }
  1846. //static
  1847. // spawn_x and spawn_y are top left corner of view in screen GL coordinates
  1848. void LLUI::positionViewNearMouse(LLView* view, S32 spawn_x, S32 spawn_y)
  1849. {
  1850. const S32 CURSOR_HEIGHT = 16; // Approximate "normal" cursor size
  1851. const S32 CURSOR_WIDTH = 8;
  1853. LLView* parent = view->getParent();
  1855. S32 mouse_x;
  1856. S32 mouse_y;
  1857. LLUI::getMousePositionScreen(&mouse_x, &mouse_y);
  1859. // If no spawn location provided, use mouse position
  1860. if (spawn_x == S32_MAX || spawn_y == S32_MAX)
  1861. {
  1862. spawn_x = mouse_x + CURSOR_WIDTH;
  1863. spawn_y = mouse_y - CURSOR_HEIGHT;
  1864. }
  1866. LLRect virtual_window_rect = parent->getLocalRect();
  1868. LLRect mouse_rect;
  1869. const S32 MOUSE_CURSOR_PADDING = 1;
  1870. mouse_rect.setLeftTopAndSize(mouse_x - MOUSE_CURSOR_PADDING, 
  1871. mouse_y + MOUSE_CURSOR_PADDING, 
  1872. CURSOR_WIDTH + MOUSE_CURSOR_PADDING * 2, 
  1873. CURSOR_HEIGHT + MOUSE_CURSOR_PADDING * 2);
  1875. S32 local_x, local_y;
  1876. // convert screen coordinates to tooltipview-local coordinates
  1877. parent->screenPointToLocal(spawn_x, spawn_y, &local_x, &local_y);
  1879. // Start at spawn position (using left/top)
  1880. view->setOrigin( local_x, local_y - view->getRect().getHeight());
  1881. // Make sure we're onscreen and not overlapping the mouse
  1882. view->translateIntoRectWithExclusion( virtual_window_rect, mouse_rect, FALSE );
  1883. }
  1886. // LLLocalClipRect and LLScreenClipRect moved to lllocalcliprect.h/cpp
  1888. namespace LLInitParam
  1889. {
  1890. TypedParam<LLUIColor >::TypedParam(BlockDescriptor& descriptor, const char* name, const LLUIColor& value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count)
  1891. : super_t(descriptor, name, value, func, min_count, max_count),
  1892. red("red"),
  1893. green("green"),
  1894. blue("blue"),
  1895. alpha("alpha"),
  1896. control("")
  1897. {
  1898. setBlockFromValue();
  1899. }
  1901. void TypedParam<LLUIColor>::setValueFromBlock() const
  1902. {
  1903. if (control.isProvided())
  1904. {
  1905. mData.mValue = LLUIColorTable::instance().getColor(control);
  1906. }
  1907. else
  1908. {
  1909. mData.mValue = LLColor4(red, green, blue, alpha);
  1910. }
  1911. }
  1913. void TypedParam<LLUIColor>::setBlockFromValue()
  1914. {
  1915. LLColor4 color = mData.mValue.get();
  1916. red.set(color.mV[VRED], false);
  1917. green.set(color.mV[VGREEN], false);
  1918. blue.set(color.mV[VBLUE], false);
  1919. alpha.set(color.mV[VALPHA], false);
  1920. control.set("", false);
  1921. }
  1923. void TypeValues<LLUIColor>::declareValues()
  1924. {
  1925. declare("white", LLColor4::white);
  1926. declare("black", LLColor4::black);
  1927. declare("red", LLColor4::red);
  1928. declare("green", LLColor4::green);
  1929. declare("blue", LLColor4::blue);
  1930. }
  1932. bool ParamCompare<const LLFontGL*, false>::equals(const LLFontGL* a, const LLFontGL* b)
  1933. {
  1934. return !(a->getFontDesc() < b->getFontDesc())
  1935. && !(b->getFontDesc() < a->getFontDesc());
  1936. }
  1938. TypedParam<const LLFontGL*>::TypedParam(BlockDescriptor& descriptor, const char* _name, const LLFontGL*const value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count)
  1939. : super_t(descriptor, _name, value, func, min_count, max_count),
  1940. name("name"),
  1941. size("size"),
  1942. style("style")
  1943. {
  1944. setBlockFromValue();
  1945. addSynonym(name, "");
  1946. }
  1948. void TypedParam<const LLFontGL*>::setValueFromBlock() const
  1949. {
  1950. const LLFontGL* res_fontp = LLFontGL::getFontByName(name);
  1951. if (res_fontp)
  1952. {
  1953. mData.mValue = res_fontp;
  1954. return;
  1955. }
  1957. U8 fontstyle = 0;
  1958. fontstyle = LLFontGL::getStyleFromString(style());
  1959. LLFontDescriptor desc(name(), size(), fontstyle);
  1960. const LLFontGL* fontp = LLFontGL::getFont(desc);
  1961. if (fontp)
  1962. {
  1963. mData.mValue = fontp;
  1964. }
  1965. }
  1967. void TypedParam<const LLFontGL*>::setBlockFromValue()
  1968. {
  1969. if (mData.mValue)
  1970. {
  1971. name.set(LLFontGL::nameFromFont(mData.mValue), false);
  1972. size.set(LLFontGL::sizeFromFont(mData.mValue), false);
  1973. style.set(LLFontGL::getStringFromStyle(mData.mValue->getFontDesc().getStyle()), false);
  1974. }
  1975. }
  1977. TypedParam<LLRect>::TypedParam(BlockDescriptor& descriptor, const char* name, const LLRect& value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count)
  1978. : super_t(descriptor, name, value, func, min_count, max_count),
  1979. left("left"),
  1980. top("top"),
  1981. right("right"),
  1982. bottom("bottom"),
  1983. width("width"),
  1984. height("height")
  1985. {
  1986. setBlockFromValue();
  1987. }
  1989. void TypedParam<LLRect>::setValueFromBlock() const
  1990. {
  1991. LLRect rect;
  1993. //calculate from params
  1994. // prefer explicit left and right
  1995. if (left.isProvided() && right.isProvided())
  1996. {
  1997. rect.mLeft = left;
  1998. rect.mRight = right;
  1999. }
  2000. // otherwise use width along with specified side, if any
  2001. else if (width.isProvided())
  2002. {
  2003. // only right + width provided
  2004. if (right.isProvided())
  2005. {
  2006. rect.mRight = right;
  2007. rect.mLeft = right - width;
  2008. }
  2009. else // left + width, or just width
  2010. {
  2011. rect.mLeft = left;
  2012. rect.mRight = left + width;
  2013. }
  2014. }
  2015. // just left, just right, or none
  2016. else
  2017. {
  2018. rect.mLeft = left;
  2019. rect.mRight = right;
  2020. }
  2022. // prefer explicit bottom and top
  2023. if (bottom.isProvided() && top.isProvided())
  2024. {
  2025. rect.mBottom = bottom;
  2026. rect.mTop = top;
  2027. }
  2028. // otherwise height along with specified side, if any
  2029. else if (height.isProvided())
  2030. {
  2031. // top + height provided
  2032. if (top.isProvided())
  2033. {
  2034. rect.mTop = top;
  2035. rect.mBottom = top - height;
  2036. }
  2037. // bottom + height or just height
  2038. else
  2039. {
  2040. rect.mBottom = bottom;
  2041. rect.mTop = bottom + height;
  2042. }
  2043. }
  2044. // just bottom, just top, or none
  2045. else
  2046. {
  2047. rect.mBottom = bottom;
  2048. rect.mTop = top;
  2049. }
  2050. mData.mValue = rect;
  2051. }
  2053. void TypedParam<LLRect>::setBlockFromValue()
  2054. {
  2055. // because of the ambiguity in specifying a rect by position and/or dimensions
  2056. // we clear the "provided" flag so that values from xui/etc have priority
  2057. // over those calculated from the rect object
  2059. left.set(mData.mValue.mLeft, false);
  2060. right.set(mData.mValue.mRight, false);
  2061. bottom.set(mData.mValue.mBottom, false);
  2062. top.set(mData.mValue.mTop, false);
  2063. width.set(mData.mValue.getWidth(), false);
  2064. height.set(mData.mValue.getHeight(), false);
  2065. }
  2067. TypedParam<LLCoordGL>::TypedParam(BlockDescriptor& descriptor, const char* name, LLCoordGL value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count)
  2068. : super_t(descriptor, name, value, func, min_count, max_count),
  2069. x("x"),
  2070. y("y")
  2071. {
  2072. setBlockFromValue();
  2073. }
  2075. void TypedParam<LLCoordGL>::setValueFromBlock() const
  2076. {
  2077. mData.mValue.set(x, y);
  2078. }
  2080. void TypedParam<LLCoordGL>::setBlockFromValue()
  2081. {
  2082. x.set(mData.mValue.mX, false);
  2083. y.set(mData.mValue.mY, false);
  2084. }
  2087. void TypeValues<LLFontGL::HAlign>::declareValues()
  2088. {
  2089. declare("left", LLFontGL::LEFT);
  2090. declare("right", LLFontGL::RIGHT);
  2091. declare("center", LLFontGL::HCENTER);
  2092. }
  2094. void TypeValues<LLFontGL::VAlign>::declareValues()
  2095. {
  2096. declare("top", LLFontGL::TOP);
  2097. declare("center", LLFontGL::VCENTER);
  2098. declare("baseline", LLFontGL::BASELINE);
  2099. declare("bottom", LLFontGL::BOTTOM);
  2100. }
  2102. void TypeValues<LLFontGL::ShadowType>::declareValues()
  2103. {
  2104. declare("none", LLFontGL::NO_SHADOW);
  2105. declare("hard", LLFontGL::DROP_SHADOW);
  2106. declare("soft", LLFontGL::DROP_SHADOW_SOFT);
  2107. }
  2108. }