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

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

游戏引擎

开发平台：

C++ Builder

lltextureview.cpp：源码内容
  1. /** 
  2.  * @file lltextureview.cpp
  3.  * @brief LLTextureView class 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. #include "llviewerprecompiledheaders.h"
  35. #include <set>
  37. #include "lltextureview.h"
  39. #include "llrect.h"
  40. #include "llerror.h"
  41. #include "lllfsthread.h"
  42. #include "llui.h"
  43. #include "llimageworker.h"
  44. #include "llrender.h"
  46. #include "lltooltip.h"
  47. #include "llappviewer.h"
  48. #include "llselectmgr.h"
  49. #include "lltexlayer.h"
  50. #include "lltexturecache.h"
  51. #include "lltexturefetch.h"
  52. #include "llviewercontrol.h"
  53. #include "llviewerobject.h"
  54. #include "llviewertexture.h"
  55. #include "llviewertexturelist.h"
  56. #include "llvovolume.h"
  57. extern F32 texmem_lower_bound_scale;
  59. LLTextureView *gTextureView = NULL;
  60. LLTextureSizeView *gTextureSizeView = NULL;
  61. LLTextureSizeView *gTextureCategoryView = NULL;
  63. //static
  64. std::set<LLViewerFetchedTexture*> LLTextureView::sDebugImages;
  66. ////////////////////////////////////////////////////////////////////////////
  68. static std::string title_string1a("Tex UUID Area  DDis(Req)  DecodePri(Fetch)     [download] pk/max");
  69. static std::string title_string1b("Tex UUID Area  DDis(Req)  Fetch(DecodePri)     [download] pk/max");
  70. static std::string title_string2("State");
  71. static std::string title_string3("Pkt Bnd");
  72. static std::string title_string4("  W x H (Dis) Mem");
  74. static S32 title_x1 = 0;
  75. static S32 title_x2 = 460;
  76. static S32 title_x3 = title_x2 + 40;
  77. static S32 title_x4 = title_x3 + 50;
  78. static S32 texture_bar_height = 8;
  80. ////////////////////////////////////////////////////////////////////////////
  82. class LLTextureBar : public LLView
  83. {
  84. public:
  85. LLPointer<LLViewerFetchedTexture> mImagep;
  86. S32 mHilite;
  88. public:
  89. struct Params : public LLInitParam::Block<Params, LLView::Params>
  90. {
  91. Mandatory<LLTextureView*> texture_view;
  92. Params()
  93. : texture_view("texture_view")
  94. {
  95. mouse_opaque(false);
  96. }
  97. };
  98. LLTextureBar(const Params& p)
  99. : LLView(p),
  100. mHilite(0),
  101. mTextureView(p.texture_view)
  102. {}
  104. virtual void draw();
  105. virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
  106. virtual LLRect getRequiredRect(); // Return the height of this object, given the set options.
  108. // Used for sorting
  109. struct sort
  110. {
  111. bool operator()(const LLView* i1, const LLView* i2)
  112. {
  113. LLTextureBar* bar1p = (LLTextureBar*)i1;
  114. LLTextureBar* bar2p = (LLTextureBar*)i2;
  115. LLViewerFetchedTexture *i1p = bar1p->mImagep;
  116. LLViewerFetchedTexture *i2p = bar2p->mImagep;
  117. F32 pri1 = i1p->getDecodePriority(); // i1p->mRequestedDownloadPriority
  118. F32 pri2 = i2p->getDecodePriority(); // i2p->mRequestedDownloadPriority
  119. if (pri1 > pri2)
  120. return true;
  121. else if (pri2 > pri1)
  122. return false;
  123. else
  124. return i1p->getID() < i2p->getID();
  125. }
  126. };
  128. struct sort_fetch
  129. {
  130. bool operator()(const LLView* i1, const LLView* i2)
  131. {
  132. LLTextureBar* bar1p = (LLTextureBar*)i1;
  133. LLTextureBar* bar2p = (LLTextureBar*)i2;
  134. LLViewerFetchedTexture *i1p = bar1p->mImagep;
  135. LLViewerFetchedTexture *i2p = bar2p->mImagep;
  136. U32 pri1 = i1p->getFetchPriority() ;
  137. U32 pri2 = i2p->getFetchPriority() ;
  138. if (pri1 > pri2)
  139. return true;
  140. else if (pri2 > pri1)
  141. return false;
  142. else
  143. return i1p->getID() < i2p->getID();
  144. }
  145. };
  146. private:
  147. LLTextureView* mTextureView;
  148. };
  150. void LLTextureBar::draw()
  151. {
  152. if (!mImagep)
  153. {
  154. return;
  155. }
  157. LLColor4 color;
  158. if (mImagep->getID() == LLAppViewer::getTextureFetch()->mDebugID)
  159. {
  160. color = LLColor4::cyan2;
  161. }
  162. else if (mHilite)
  163. {
  164. S32 idx = llclamp(mHilite,1,3);
  165. if (idx==1) color = LLColor4::orange;
  166. else if (idx==2) color = LLColor4::yellow;
  167. else color = LLColor4::pink2;
  168. }
  169. else if (mImagep->mDontDiscard)
  170. {
  171. color = LLColor4::green4;
  172. }
  173. else if (mImagep->getBoostLevel() > LLViewerTexture::BOOST_NONE)
  174. {
  175. color = LLColor4::magenta;
  176. }
  177. else if (mImagep->getDecodePriority() <= 0.0f)
  178. {
  179. color = LLColor4::grey; color[VALPHA] = .7f;
  180. }
  181. else
  182. {
  183. color = LLColor4::white; color[VALPHA] = .7f;
  184. }
  186. // We need to draw:
  187. // The texture UUID or name
  188. // The progress bar for the texture, highlighted if it's being download
  189. // Various numerical stats.
  190. std::string tex_str;
  191. S32 left, right;
  192. S32 top = 0;
  193. S32 bottom = top + 6;
  194. LLColor4 clr;
  196. LLGLSUIDefault gls_ui;
  198. // Name, pixel_area, requested pixel area, decode priority
  199. std::string uuid_str;
  200. mImagep->mID.toString(uuid_str);
  201. uuid_str = uuid_str.substr(0,7);
  202. if (mTextureView->mOrderFetch)
  203. {
  204. tex_str = llformat("%s %7.0f %d(%d) 0x%08x(%8.0f)",
  205.    uuid_str.c_str(),
  206.    mImagep->mMaxVirtualSize,
  207.    mImagep->mDesiredDiscardLevel,
  208.    mImagep->mRequestedDiscardLevel,
  209.    mImagep->mFetchPriority,
  210.    mImagep->getDecodePriority());
  211. }
  212. else
  213. {
  214. tex_str = llformat("%s %7.0f %d(%d) %8.0f(0x%08x)",
  215.    uuid_str.c_str(),
  216.    mImagep->mMaxVirtualSize,
  217.    mImagep->mDesiredDiscardLevel,
  218.    mImagep->mRequestedDiscardLevel,
  219.    mImagep->getDecodePriority(),
  220.    mImagep->mFetchPriority);
  221. }
  223. LLFontGL::getFontMonospace()->renderUTF8(tex_str, 0, title_x1, getRect().getHeight(),
  224.  color, LLFontGL::LEFT, LLFontGL::TOP);
  226. // State
  227. // Hack: mirrored from lltexturefetch.cpp
  228. struct { const std::string desc; LLColor4 color; } fetch_state_desc[] = {
  229. { "---", LLColor4::red }, // INVALID
  230. { "INI", LLColor4::white }, // INIT
  231. { "DSK", LLColor4::cyan }, // LOAD_FROM_TEXTURE_CACHE
  232. { "DSK", LLColor4::blue }, // CACHE_POST
  233. { "NET", LLColor4::green }, // LOAD_FROM_NETWORK
  234. { "SIM", LLColor4::green }, // LOAD_FROM_SIMULATOR
  235. { "REQ", LLColor4::yellow },// SEND_HTTP_REQ
  236. { "HTP", LLColor4::green }, // WAIT_HTTP_REQ
  237. { "DEC", LLColor4::yellow },// DECODE_IMAGE
  238. { "DEC", LLColor4::green }, // DECODE_IMAGE_UPDATE
  239. { "WRT", LLColor4::purple },// WRITE_TO_CACHE
  240. { "WRT", LLColor4::orange },// WAIT_ON_WRITE
  241. { "END", LLColor4::red },   // DONE
  242. #define LAST_STATE 12
  243. { "CRE", LLColor4::magenta }, // LAST_STATE+1
  244. { "FUL", LLColor4::green }, // LAST_STATE+2
  245. { "BAD", LLColor4::red }, // LAST_STATE+3
  246. { "MIS", LLColor4::red }, // LAST_STATE+4
  247. { "---", LLColor4::white }, // LAST_STATE+5
  248. };
  249. const S32 fetch_state_desc_size = (S32)LL_ARRAY_SIZE(fetch_state_desc);
  250. S32 state =
  251. mImagep->mNeedsCreateTexture ? LAST_STATE+1 :
  252. mImagep->mFullyLoaded ? LAST_STATE+2 :
  253. mImagep->mMinDiscardLevel > 0 ? LAST_STATE+3 :
  254. mImagep->mIsMissingAsset ? LAST_STATE+4 :
  255. !mImagep->mIsFetching ? LAST_STATE+5 :
  256. mImagep->mFetchState;
  257. state = llclamp(state,0,fetch_state_desc_size-1);
  259. LLFontGL::getFontMonospace()->renderUTF8(fetch_state_desc[state].desc, 0, title_x2, getRect().getHeight(),
  260.  fetch_state_desc[state].color,
  261.  LLFontGL::LEFT, LLFontGL::TOP);
  262. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  264. // Draw the progress bar.
  265. S32 bar_width = 100;
  266. S32 bar_left = 260;
  267. left = bar_left;
  268. right = left + bar_width;
  270. gGL.color4f(0.f, 0.f, 0.f, 0.75f);
  271. gl_rect_2d(left, top, right, bottom);
  273. F32 data_progress = mImagep->mDownloadProgress;
  275. if (data_progress > 0.0f)
  276. {
  277. // Downloaded bytes
  278. right = left + llfloor(data_progress * (F32)bar_width);
  279. if (right > left)
  280. {
  281. gGL.color4f(0.f, 0.f, 1.f, 0.75f);
  282. gl_rect_2d(left, top, right, bottom);
  283. }
  284. }
  286. S32 pip_width = 6;
  287. S32 pip_space = 14;
  288. S32 pip_x = title_x3 + pip_space/2;
  290. // Draw the packet pip
  291. const F32 pip_max_time = 5.f;
  292. F32 last_event = mImagep->mLastPacketTimer.getElapsedTimeF32();
  293. if (last_event < pip_max_time)
  294. {
  295. clr = LLColor4::white; 
  296. }
  297. else
  298. {
  299. last_event = mImagep->mRequestDeltaTime;
  300. if (last_event < pip_max_time)
  301. {
  302. clr = LLColor4::green;
  303. }
  304. else
  305. {
  306. last_event = mImagep->mFetchDeltaTime;
  307. if (last_event < pip_max_time)
  308. {
  309. clr = LLColor4::yellow;
  310. }
  311. }
  312. }
  313. if (last_event < pip_max_time)
  314. {
  315. clr.setAlpha(1.f - last_event/pip_max_time);
  316. gGL.color4fv(clr.mV);
  317. gl_rect_2d(pip_x, top, pip_x + pip_width, bottom);
  318. }
  319. pip_x += pip_width + pip_space;
  321. // we don't want to show bind/resident pips for textures using the default texture
  322. if (mImagep->hasGLTexture())
  323. {
  324. // Draw the bound pip
  325. last_event = mImagep->getTimePassedSinceLastBound();
  326. if (last_event < 1.f)
  327. {
  328. clr = mImagep->getMissed() ? LLColor4::red : LLColor4::magenta1;
  329. clr.setAlpha(1.f - last_event);
  330. gGL.color4fv(clr.mV);
  331. gl_rect_2d(pip_x, top, pip_x + pip_width, bottom);
  332. }
  333. }
  334. pip_x += pip_width + pip_space;
  337. {
  338. LLGLSUIDefault gls_ui;
  339. // draw the packet data
  340. //  {
  341. //  std::string num_str = llformat("%3d/%3d", mImagep->mLastPacket+1, mImagep->mPackets);
  342. //  LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, bar_left + 100, getRect().getHeight(), color,
  343. //   LLFontGL::LEFT, LLFontGL::TOP);
  344. //  }
  346. // draw the image size at the end
  347. {
  348. std::string num_str = llformat("%3dx%3d (%d) %7d", mImagep->getWidth(), mImagep->getHeight(),
  349. mImagep->getDiscardLevel(), mImagep->hasGLTexture() ? mImagep->getTextureMemory() : 0);
  350. LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, title_x4, getRect().getHeight(), color,
  351. LLFontGL::LEFT, LLFontGL::TOP);
  352. }
  353. }
  355. }
  357. BOOL LLTextureBar::handleMouseDown(S32 x, S32 y, MASK mask)
  358. {
  359. if ((mask & (MASK_CONTROL|MASK_SHIFT|MASK_ALT)) == MASK_ALT)
  360. {
  361. LLAppViewer::getTextureFetch()->mDebugID = mImagep->getID();
  362. return TRUE;
  363. }
  364. return LLView::handleMouseDown(x,y,mask);
  365. }
  367. LLRect LLTextureBar::getRequiredRect()
  368. {
  369. LLRect rect;
  371. rect.mTop = texture_bar_height;
  373. return rect;
  374. }
  376. ////////////////////////////////////////////////////////////////////////////
  378. class LLGLTexMemBar : public LLView
  379. {
  380. public:
  381. struct Params : public LLInitParam::Block<Params, LLView::Params>
  382. {
  383. Mandatory<LLTextureView*> texture_view;
  384. Params()
  385. : texture_view("texture_view")
  386. {
  387. S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
  388. rect(LLRect(0,0,100,line_height * 4));
  389. }
  390. };
  392. LLGLTexMemBar(const Params& p)
  393. : LLView(p),
  394. mTextureView(p.texture_view)
  395. {}
  397. virtual void draw();
  398. virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
  399. virtual LLRect getRequiredRect(); // Return the height of this object, given the set options.
  401. private:
  402. LLTextureView* mTextureView;
  403. };
  405. void LLGLTexMemBar::draw()
  406. {
  407. S32 bound_mem = BYTES_TO_MEGA_BYTES(LLViewerTexture::sBoundTextureMemoryInBytes);
  408.   S32 max_bound_mem = LLViewerTexture::sMaxBoundTextureMemInMegaBytes;
  409. S32 total_mem = BYTES_TO_MEGA_BYTES(LLViewerTexture::sTotalTextureMemoryInBytes);
  410. S32 max_total_mem = LLViewerTexture::sMaxTotalTextureMemInMegaBytes;
  411. F32 discard_bias = LLViewerTexture::sDesiredDiscardBias;
  412. F32 cache_usage = (F32)BYTES_TO_MEGA_BYTES(LLAppViewer::getTextureCache()->getUsage()) ;
  413. F32 cache_max_usage = (F32)BYTES_TO_MEGA_BYTES(LLAppViewer::getTextureCache()->getMaxUsage()) ;
  414. S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
  415. S32 v_offset = (S32)((texture_bar_height + 2.5f) * mTextureView->mNumTextureBars + 2.5f);
  416. //----------------------------------------------------------------------------
  417. LLGLSUIDefault gls_ui;
  418. LLColor4 text_color(1.f, 1.f, 1.f, 0.75f);
  419. LLColor4 color;
  421. std::string text;
  422. text = llformat("GL Tot: %d/%d MB Bound: %d/%d MB Raw Tot: %d MB Bias: %.2f Cache: %.1f/%.1f MB",
  423. total_mem,
  424. max_total_mem,
  425. bound_mem,
  426. max_bound_mem,
  427. LLImageRaw::sGlobalRawMemory >> 20, discard_bias,
  428. cache_usage, cache_max_usage);
  429. //, cache_entries, cache_max_entries
  431. LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height*3,
  432.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  434. //----------------------------------------------------------------------------
  435. #if 0
  436. S32 bar_left = 400;
  437. S32 bar_width = 200;
  438. S32 top = line_height*3 - 2 + v_offset;
  439. S32 bottom = top - 6;
  440. S32 left = bar_left;
  441. S32 right = left + bar_width;
  442. F32 bar_scale;
  444. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  446. // GL Mem Bar
  448. left = bar_left;
  449. text = "GL";
  450. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left, line_height*3,
  451.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  453. left = bar_left+20;
  454. right = left + bar_width;
  456. gGL.color4f(0.5f, 0.5f, 0.5f, 0.75f); // grey
  457. gl_rect_2d(left, top, right, bottom);
  459. bar_scale = (F32)bar_width / (max_total_mem * 1.5f);
  460. right = left + llfloor(total_mem * bar_scale);
  461. right = llclamp(right, bar_left, bar_left + bar_width);
  463. color = (total_mem < llfloor(max_total_mem * texmem_lower_bound_scale)) ? LLColor4::green :
  464.    (total_mem < max_total_mem) ? LLColor4::yellow : LLColor4::red;
  465. color[VALPHA] = .75f;
  466. glColor4fv(color.mV);
  468. gl_rect_2d(left, top, right, bottom); // red/yellow/green
  470. //
  471. bar_left += bar_width + bar_space;
  472. //top = bottom - 2; bottom = top - 6;
  474. // Bound Mem Bar
  476. left = bar_left;
  477. text = "GL";
  478. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left, line_height*3,
  479.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  480. left = bar_left + 20;
  481. right = left + bar_width;
  483. gGL.color4f(0.5f, 0.5f, 0.5f, 0.75f);
  484. gl_rect_2d(left, top, right, bottom);
  486. color = (bound_mem < llfloor(max_bound_mem * texmem_lower_bound_scale)) ? LLColor4::green :
  487.    (bound_mem < max_bound_mem) ? LLColor4::yellow : LLColor4::red;
  488. color[VALPHA] = .75f;
  489. glColor4fv(color.mV);
  491. gl_rect_2d(left, top, right, bottom);
  492. #else
  493. S32 left = 0 ;
  494. #endif
  495. //----------------------------------------------------------------------------
  497. text = llformat("Textures: %d Fetch: %d(%d) Pkts:%d(%d) Cache R/W: %d/%d LFS:%d RAW:%d HTP:%d DEC:%d CRE:%d",
  498. gTextureList.getNumImages(),
  499. LLAppViewer::getTextureFetch()->getNumRequests(), LLAppViewer::getTextureFetch()->getNumDeletes(),
  500. LLAppViewer::getTextureFetch()->mPacketCount, LLAppViewer::getTextureFetch()->mBadPacketCount, 
  501. LLAppViewer::getTextureCache()->getNumReads(), LLAppViewer::getTextureCache()->getNumWrites(),
  502. LLLFSThread::sLocal->getPending(),
  503. LLImageRaw::sRawImageCount,
  504. LLAppViewer::getTextureFetch()->getNumHTTPRequests(),
  505. LLAppViewer::getImageDecodeThread()->getPending(), 
  506. gTextureList.mCreateTextureList.size());
  508. LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height*2,
  509.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  512. left = 550;
  513. F32 bandwidth = LLAppViewer::getTextureFetch()->getTextureBandwidth();
  514. F32 max_bandwidth = gSavedSettings.getF32("ThrottleBandwidthKBPS");
  515. color = bandwidth > max_bandwidth ? LLColor4::red : bandwidth > max_bandwidth*.75f ? LLColor4::yellow : text_color;
  516. color[VALPHA] = text_color[VALPHA];
  517. text = llformat("BW:%.0f/%.0f",bandwidth, max_bandwidth);
  518. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left, v_offset + line_height*2,
  519.  color, LLFontGL::LEFT, LLFontGL::TOP);
  521. S32 dx1 = 0;
  522. if (LLAppViewer::getTextureFetch()->mDebugPause)
  523. {
  524. LLFontGL::getFontMonospace()->renderUTF8(std::string("!"), 0, title_x1, v_offset + line_height,
  525.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  526. dx1 += 8;
  527. }
  528. if (mTextureView->mFreezeView)
  529. {
  530. LLFontGL::getFontMonospace()->renderUTF8(std::string("*"), 0, title_x1, v_offset + line_height,
  531.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  532. dx1 += 8;
  533. }
  534. if (mTextureView->mOrderFetch)
  535. {
  536. LLFontGL::getFontMonospace()->renderUTF8(title_string1b, 0, title_x1+dx1, v_offset + line_height,
  537.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  538. }
  539. else
  540. {
  541. LLFontGL::getFontMonospace()->renderUTF8(title_string1a, 0, title_x1+dx1, v_offset + line_height,
  542.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  543. }
  545. LLFontGL::getFontMonospace()->renderUTF8(title_string2, 0, title_x2, v_offset + line_height,
  546.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  548. LLFontGL::getFontMonospace()->renderUTF8(title_string3, 0, title_x3, v_offset + line_height,
  549.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  551. LLFontGL::getFontMonospace()->renderUTF8(title_string4, 0, title_x4, v_offset + line_height,
  552.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  553. }
  555. BOOL LLGLTexMemBar::handleMouseDown(S32 x, S32 y, MASK mask)
  556. {
  557. return FALSE;
  558. }
  560. LLRect LLGLTexMemBar::getRequiredRect()
  561. {
  562. LLRect rect;
  563. rect.mTop = 8;
  564. return rect;
  565. }
  567. ////////////////////////////////////////////////////////////////////////////
  568. class LLGLTexSizeBar
  569. {
  570. public:
  571. LLGLTexSizeBar(S32 index, S32 left, S32 bottom, S32 right, S32 line_height)
  572. {
  573. mIndex = index ;
  574. mLeft = left ;
  575. mBottom = bottom ;
  576. mRight = right ;
  577. mLineHeight = line_height ;
  578. mTopLoaded = 0 ;
  579. mTopBound = 0 ;
  580. mScale = 1.0f ;
  581. }
  583. void setTop(S32 loaded, S32 bound, F32 scale) {mTopLoaded = loaded ; mTopBound = bound; mScale = scale ;}
  585. void draw();
  586. BOOL handleHover(S32 x, S32 y, MASK mask, BOOL set_pick_size) ;
  588. private:
  589. S32 mIndex ;
  590. S32 mLeft ;
  591. S32 mBottom ;
  592. S32 mRight ;
  593. S32 mTopLoaded ;
  594. S32 mTopBound ;
  595. S32 mLineHeight ;
  596. F32 mScale ;
  597. };
  599. BOOL LLGLTexSizeBar::handleHover(S32 x, S32 y, MASK mask, BOOL set_pick_size) 
  600. {
  601. if(y > mBottom && (y < mBottom + (S32)(mTopLoaded * mScale) || y < mBottom + (S32)(mTopBound * mScale)))
  602. {
  603. LLImageGL::setCurTexSizebar(mIndex, set_pick_size);
  604. }
  605. return TRUE ;
  606. }
  607. void LLGLTexSizeBar::draw()
  608. {
  609. LLGLSUIDefault gls_ui;
  611. if(LLImageGL::sCurTexSizeBar == mIndex)
  612. {
  613. F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};
  614. std::string text;
  616. text = llformat("%d", mTopLoaded) ;
  617. LLFontGL::getFontMonospace()->renderUTF8(text, 0, mLeft, mBottom + (S32)(mTopLoaded * mScale) + mLineHeight,
  618.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  620. text = llformat("%d", mTopBound) ;
  621. LLFontGL::getFontMonospace()->renderUTF8(text, 0, (mLeft + mRight) / 2, mBottom + (S32)(mTopBound * mScale) + mLineHeight,
  622.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  623. }
  625. F32 loaded_color[] = {1.0f, 0.0f, 0.0f, 0.75f};
  626. F32 bound_color[] = {1.0f, 1.0f, 0.0f, 0.75f};
  627. gl_rect_2d(mLeft, mBottom + (S32)(mTopLoaded * mScale), (mLeft + mRight) / 2, mBottom, loaded_color) ;
  628. gl_rect_2d((mLeft + mRight) / 2, mBottom + (S32)(mTopBound * mScale), mRight, mBottom, bound_color) ;
  629. }
  630. ////////////////////////////////////////////////////////////////////////////
  632. LLTextureView::LLTextureView(const LLTextureView::Params& p)
  633. : LLContainerView(p),
  634. mFreezeView(FALSE),
  635. mOrderFetch(FALSE),
  636. mPrintList(FALSE),
  637. mNumTextureBars(0)
  638. {
  639. setVisible(FALSE);
  641. setDisplayChildren(TRUE);
  642. mGLTexMemBar = 0;
  643. }
  645. LLTextureView::~LLTextureView()
  646. {
  647. // Children all cleaned up by default view destructor.
  648. delete mGLTexMemBar;
  649. mGLTexMemBar = 0;
  650. }
  652. typedef std::pair<F32,LLViewerFetchedTexture*> decode_pair_t;
  653. struct compare_decode_pair
  654. {
  655. bool operator()(const decode_pair_t& a, const decode_pair_t& b)
  656. {
  657. return a.first > b.first;
  658. }
  659. };
  661. void LLTextureView::draw()
  662. {
  663. if (!mFreezeView)
  664. {
  665. //  LLViewerObject *objectp;
  666. //  S32 te;
  668. for_each(mTextureBars.begin(), mTextureBars.end(), DeletePointer());
  669. mTextureBars.clear();
  671. delete mGLTexMemBar;
  672. mGLTexMemBar = 0;
  674. typedef std::multiset<decode_pair_t, compare_decode_pair > display_list_t;
  675. display_list_t display_image_list;
  677. if (mPrintList)
  678. {
  679. llinfos << "IDtMEMtBOOSTtPRItWIDTHtHEIGHTtDISCARD" << llendl;
  680. }
  682. for (LLViewerTextureList::image_priority_list_t::iterator iter = gTextureList.mImageList.begin();
  683.  iter != gTextureList.mImageList.end(); )
  684. {
  685. LLPointer<LLViewerFetchedTexture> imagep = *iter++;
  687. S32 cur_discard = imagep->getDiscardLevel();
  688. S32 desired_discard = imagep->mDesiredDiscardLevel;
  690. if (mPrintList)
  691. {
  692. S32 tex_mem = imagep->hasGLTexture() ? imagep->getTextureMemory() : 0 ;
  693. llinfos << imagep->getID()
  694. << "t" << tex_mem
  695. << "t" << imagep->getBoostLevel()
  696. << "t" << imagep->getDecodePriority()
  697. << "t" << imagep->getWidth()
  698. << "t" << imagep->getHeight()
  699. << "t" << cur_discard
  700. << llendl;
  701. }
  703. if (imagep->getID() == LLAppViewer::getTextureFetch()->mDebugID)
  704. {
  705. static S32 debug_count = 0;
  706. ++debug_count; // for breakpoints
  707. }
  709. #if 0
  710. if (imagep->getDontDiscard())
  711. {
  712. continue;
  713. }
  715. if (imagep->isMissingAsset())
  716. {
  717. continue;
  718. }
  719. #endif
  721. #define HIGH_PRIORITY 100000000.f
  722. F32 pri;
  723. if (mOrderFetch)
  724. {
  725. pri = ((F32)imagep->mFetchPriority)/256.f;
  726. }
  727. else
  728. {
  729. pri = imagep->getDecodePriority();
  730. }
  731. pri = llclamp(pri, 0.0f, HIGH_PRIORITY-1.f);
  733. if (sDebugImages.find(imagep) != sDebugImages.end())
  734. {
  735. pri += 4*HIGH_PRIORITY;
  736. }
  738. if (!mOrderFetch)
  739. {
  740. #if 1
  741. if (pri < HIGH_PRIORITY && LLSelectMgr::getInstance())
  742. {
  743. struct f : public LLSelectedTEFunctor
  744. {
  745. LLViewerFetchedTexture* mImage;
  746. f(LLViewerFetchedTexture* image) : mImage(image) {}
  747. virtual bool apply(LLViewerObject* object, S32 te)
  748. {
  749. return (mImage == object->getTEImage(te));
  750. }
  751. } func(imagep);
  752. const bool firstonly = true;
  753. bool match = LLSelectMgr::getInstance()->getSelection()->applyToTEs(&func, firstonly);
  754. if (match)
  755. {
  756. pri += 3*HIGH_PRIORITY;
  757. }
  758. }
  759. #endif
  760. #if 1
  761. if (pri < HIGH_PRIORITY && (cur_discard< 0 || desired_discard < cur_discard))
  762. {
  763. LLSelectNode* hover_node = LLSelectMgr::instance().getHoverNode();
  764. if (hover_node)
  765. {
  766. LLViewerObject *objectp = hover_node->getObject();
  767. if (objectp)
  768. {
  769. S32 tex_count = objectp->getNumTEs();
  770. for (S32 i = 0; i < tex_count; i++)
  771. {
  772. if (imagep == objectp->getTEImage(i))
  773. {
  774. pri += 2*HIGH_PRIORITY;
  775. break;
  776. }
  777. }
  778. }
  779. }
  780. }
  781. #endif
  782. #if 1
  783. if (pri > 0.f && pri < HIGH_PRIORITY)
  784. {
  785. if (imagep->mLastPacketTimer.getElapsedTimeF32() < 1.f ||
  786. imagep->mFetchDeltaTime < 0.25f)
  787. {
  788. pri += 1*HIGH_PRIORITY;
  789. }
  790. }
  791. #endif
  792. }
  794.   if (pri > 0.0f)
  795. {
  796. display_image_list.insert(std::make_pair(pri, imagep));
  797. }
  798. }
  800. if (mPrintList)
  801. {
  802. mPrintList = FALSE;
  803. }
  805. static S32 max_count = 50;
  806. S32 count = 0;
  807. mNumTextureBars = 0 ;
  808. for (display_list_t::iterator iter = display_image_list.begin();
  809.  iter != display_image_list.end(); iter++)
  810. {
  811. LLViewerFetchedTexture* imagep = iter->second;
  812. S32 hilite = 0;
  813. F32 pri = iter->first;
  814. if (pri >= 1 * HIGH_PRIORITY)
  815. {
  816. hilite = (S32)((pri+1) / HIGH_PRIORITY) - 1;
  817. }
  818. if ((hilite || count < max_count-10) && (count < max_count))
  819. {
  820. if (addBar(imagep, hilite))
  821. {
  822. count++;
  823. }
  824. }
  825. }
  827. if (mOrderFetch)
  828. sortChildren(LLTextureBar::sort_fetch());
  829. else
  830. sortChildren(LLTextureBar::sort());
  832. LLGLTexMemBar::Params tmbp;
  833. tmbp.name("gl texmem bar");
  834. tmbp.texture_view(this);
  835. mGLTexMemBar = LLUICtrlFactory::create<LLGLTexMemBar>(tmbp);
  836. addChild(mGLTexMemBar);
  838. reshape(getRect().getWidth(), getRect().getHeight(), TRUE);
  840. /*
  841.   count = gTextureList.getNumImages();
  842.   std::string info_string;
  843.   info_string = llformat("Global Info:nTexture Count: %d", count);
  844.   mInfoTextp->setText(info_string);
  845. */
  848. for (child_list_const_iter_t child_iter = getChildList()->begin();
  849.  child_iter != getChildList()->end(); ++child_iter)
  850. {
  851. LLView *viewp = *child_iter;
  852. if (viewp->getRect().mBottom < 0)
  853. {
  854. viewp->setVisible(FALSE);
  855. }
  856. }
  857. }
  859. LLContainerView::draw();
  861. }
  863. BOOL LLTextureView::addBar(LLViewerFetchedTexture *imagep, S32 hilite)
  864. {
  865. llassert(imagep);
  867. LLTextureBar *barp;
  868. LLRect r;
  870. mNumTextureBars++;
  872. LLTextureBar::Params tbp;
  873. tbp.name("texture bar");
  874. tbp.rect(r);
  875. tbp.texture_view(this);
  876. barp = LLUICtrlFactory::create<LLTextureBar>(tbp);
  877. barp->mImagep = imagep;
  878. barp->mHilite = hilite;
  880. addChild(barp);
  881. mTextureBars.push_back(barp);
  883. return TRUE;
  884. }
  886. BOOL LLTextureView::handleMouseDown(S32 x, S32 y, MASK mask)
  887. {
  888. if ((mask & (MASK_CONTROL|MASK_SHIFT|MASK_ALT)) == (MASK_ALT|MASK_SHIFT))
  889. {
  890. mPrintList = TRUE;
  891. return TRUE;
  892. }
  893. if ((mask & (MASK_CONTROL|MASK_SHIFT|MASK_ALT)) == (MASK_CONTROL|MASK_SHIFT))
  894. {
  895. LLAppViewer::getTextureFetch()->mDebugPause = !LLAppViewer::getTextureFetch()->mDebugPause;
  896. return TRUE;
  897. }
  898. if (mask & MASK_SHIFT)
  899. {
  900. mFreezeView = !mFreezeView;
  901. return TRUE;
  902. }
  903. if (mask & MASK_CONTROL)
  904. {
  905. mOrderFetch = !mOrderFetch;
  906. return TRUE;
  907. }
  908. return LLView::handleMouseDown(x,y,mask);
  909. }
  911. BOOL LLTextureView::handleMouseUp(S32 x, S32 y, MASK mask)
  912. {
  913. return FALSE;
  914. }
  916. BOOL LLTextureView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
  917. {
  918. return FALSE;
  919. }
  921. //-----------------------------------------------------------------
  922. LLTextureSizeView::LLTextureSizeView(const LLTextureSizeView::Params& p) : LLContainerView(p)
  923. {
  924. setVisible(FALSE) ;
  926. mTextureSizeBarWidth = 30 ;
  927. }
  929. LLTextureSizeView::~LLTextureSizeView()
  930. {
  931. if(mTextureSizeBar.size())
  932. {
  933. for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
  934. {
  935. delete mTextureSizeBar[i] ;
  936. }
  937. mTextureSizeBar.clear() ;
  938. }
  939. }
  940. void LLTextureSizeView::draw()
  941. {
  942. if(mType == TEXTURE_MEM_OVER_SIZE)
  943. {
  944. drawTextureSizeGraph();
  945. }
  946. else
  947. {
  948. drawTextureCategoryGraph() ;
  949. }
  951. LLView::draw();
  952. }
  954. BOOL LLTextureSizeView::handleHover(S32 x, S32 y, MASK mask) 
  955. {
  956. if(x > mTextureSizeBarRect.mLeft && x < mTextureSizeBarRect.mRight)
  957. {
  958. mTextureSizeBar[(x - mTextureSizeBarRect.mLeft) / mTextureSizeBarWidth]->handleHover(x, y, mask, (mType == TEXTURE_MEM_OVER_SIZE)) ;
  959. }
  961. return TRUE ;
  962. }
  964. //draw real-time texture mem bar over size
  965. void LLTextureSizeView::drawTextureSizeGraph()
  966. {
  967. if(mTextureSizeBar.size() == 0)
  968. {
  969. S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
  970. mTextureSizeBar.resize(LLImageGL::sTextureLoadedCounter.size()) ;
  971. mTextureSizeBarRect.set(700, line_height * 2 + 400, 700 + mTextureSizeBar.size() * mTextureSizeBarWidth, line_height * 2) ;
  973. for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
  974. {
  975. mTextureSizeBar[i] = new LLGLTexSizeBar(i, mTextureSizeBarRect.mLeft + i * mTextureSizeBarWidth , 
  976. line_height * 2, mTextureSizeBarRect.mLeft + (i + 1) * mTextureSizeBarWidth, line_height) ;
  977. }
  978. }
  980. F32 size_bar_scale = drawTextureSizeDistributionGraph() ;
  981. for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
  982. {
  983. mTextureSizeBar[i]->setTop(LLImageGL::sTextureLoadedCounter[i], LLImageGL::sTextureBoundCounter[i], size_bar_scale) ;
  984. mTextureSizeBar[i]->draw() ;
  985. }
  986. LLImageGL::resetCurTexSizebar();
  987. }
  989. //draw background of texture size bar graph
  990. F32 LLTextureSizeView::drawTextureSizeDistributionGraph()
  991. {
  992. //scale
  993. F32 scale = 1.0f ;
  995. LLGLSUIDefault gls_ui;
  997. {
  998. S32 count = 0 ;
  999. for(U32 i = 0 ; i < LLImageGL::sTextureLoadedCounter.size() ; i++)
  1000. {
  1001. if(LLImageGL::sTextureLoadedCounter[i] > count)
  1002. {
  1003. count = LLImageGL::sTextureLoadedCounter[i] ;
  1004. }
  1005. }
  1006. if(count > mTextureSizeBarRect.getHeight())
  1007. {
  1008. scale = (F32)mTextureSizeBarRect.getHeight() / count ;
  1009. }
  1010. }
  1012. S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
  1013. S32 left = mTextureSizeBarRect.mLeft ;
  1014. S32 bottom = mTextureSizeBarRect.mBottom ;
  1015. S32 right = mTextureSizeBarRect.mRight ;
  1016. S32 top = mTextureSizeBarRect.mTop ;
  1018. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1020. //background rect
  1021. gl_rect_2d(left - 25, top + 30, right + 100, bottom - 25, LLColor4(0.0f, 0.0f, 0.0f, 0.25f)) ;
  1023. //--------------------------------------------------
  1024. gGL.color4f(1.0f, 0.5f, 0.5f, 0.75f);
  1025. gl_line_2d(left, bottom, right, bottom) ; //x axis
  1026. gl_line_2d(left, bottom, left, top) ; //y axis
  1028. //ruler
  1029. //--------------------------------------------------
  1030. gGL.color4f(1.0f, 0.5f, 0.5f, 0.5f);
  1031. for(S32 i = bottom + 50 ; i <= top ; i += 50)
  1032. {
  1033. gl_line_2d(left, i, right, i) ;
  1034. }
  1036. //texts
  1037. //--------------------------------------------------
  1038. F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};
  1039. std::string text;
  1041. //-------
  1042. //x axis: size label
  1043. text = llformat("%d", 0) ;
  1044. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 12, bottom - line_height / 2,
  1045.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1046. for(U32 i = 1 ; i < mTextureSizeBar.size() ; i++)
  1047. {
  1048. text = llformat("%d", (1 << (i / 2)) + ((i & 1) ? ((1 << (i / 2)) >> 1) : 0)) ;
  1049. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + i * mTextureSizeBarWidth + 12, bottom - line_height / 2,
  1050.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1051. }
  1052. text = llformat("(w + h)/2") ;
  1053. LLFontGL::getFontMonospace()->renderUTF8(text, 0, right + 10, bottom - line_height / 2,
  1054.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1055. //-------
  1057. //y axis: number label
  1058. for(S32 i = bottom + 50 ; i <= top ; i += 50)
  1059. {
  1060. text = llformat("%d", (S32)((i - bottom) / scale)) ;
  1061. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left - 20, i + line_height / 2 ,
  1062.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1063. LLFontGL::getFontMonospace()->renderUTF8(text, 0, right + 5, i + line_height / 2 ,
  1064.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1065. }
  1067. //--------------------------------------------------
  1068. F32 loaded_color[] = {1.0f, 0.0f, 0.0f, 0.75f};
  1069. gl_rect_2d(left + 70, top + line_height * 2, left + 90, top + line_height, loaded_color) ;
  1070. text = llformat("Loaded") ;
  1071. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 100, top + line_height * 2,
  1072.  loaded_color, LLFontGL::LEFT, LLFontGL::TOP);
  1074. F32 bound_color[] = {1.0f, 1.0f, 0.0f, 0.75f};
  1075. gl_rect_2d(left + 170, top + line_height * 2, left + 190, top + line_height, bound_color) ;
  1076. text = llformat("Bound") ;
  1077. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 200, top + line_height * 2,
  1078.  bound_color, LLFontGL::LEFT, LLFontGL::TOP);
  1080. //--------------------------------------------------
  1082. //title
  1083. text = llformat("Texture Size Distribution") ;
  1084. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 250, top + line_height * 3,
  1085.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1086. return scale ;
  1087. }
  1089. //draw real-time texture mem bar over category
  1090. void LLTextureSizeView::drawTextureCategoryGraph()
  1091. {
  1092. if(mTextureSizeBar.size() == 0)
  1093. {
  1094. S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
  1095. mTextureSizeBar.resize(LLViewerTexture::getTotalNumOfCategories()) ;
  1096. mTextureSizeBarRect.set(700, line_height * 2 + 400, 700 + mTextureSizeBar.size() * mTextureSizeBarWidth, line_height * 2) ;
  1098. for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
  1099. {
  1100. mTextureSizeBar[i] = new LLGLTexSizeBar(i, mTextureSizeBarRect.mLeft + i * mTextureSizeBarWidth , 
  1101. line_height * 2, mTextureSizeBarRect.mLeft + (i + 1) * mTextureSizeBarWidth, line_height) ;
  1102. }
  1103. }
  1105. F32 size_bar_scale = drawTextureCategoryDistributionGraph() ;
  1106. for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
  1107. {
  1108. U32 k = LLViewerTexture::getIndexFromCategory(i) ;
  1109. mTextureSizeBar[i]->setTop(LLImageGL::sTextureMemByCategory[k] >> 20, LLImageGL::sTextureMemByCategoryBound[k] >> 20, size_bar_scale) ;
  1110. mTextureSizeBar[i]->draw() ;
  1111. }
  1112. LLImageGL::resetCurTexSizebar();
  1113. }
  1115. //draw background for TEXTURE_MEM_OVER_CATEGORY
  1116. F32 LLTextureSizeView::drawTextureCategoryDistributionGraph() 
  1117. {
  1118. //scale
  1119. F32 scale = 4.0f ;
  1121. LLGLSUIDefault gls_ui;
  1123. {
  1124. S32 count = 0 ;
  1125. for(U32 i = 0 ; i < LLImageGL::sTextureMemByCategory.size() ; i++)
  1126. {
  1127. S32 tmp = LLImageGL::sTextureMemByCategory[i] >> 20 ;
  1128. if(tmp > count)
  1129. {
  1130. count = tmp ;
  1131. }
  1132. }
  1133. if(count > mTextureSizeBarRect.getHeight() * 0.25f)
  1134. {
  1135. scale = (F32)mTextureSizeBarRect.getHeight() * 0.25f / count ;
  1136. }
  1137. }
  1139. S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
  1140. S32 left = mTextureSizeBarRect.mLeft ;
  1141. S32 bottom = mTextureSizeBarRect.mBottom ;
  1142. S32 right = mTextureSizeBarRect.mRight ;
  1143. S32 top = mTextureSizeBarRect.mTop ;
  1145. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1147. //background rect
  1148. gl_rect_2d(left - 25, top + 30, right + 100, bottom - 25, LLColor4(0.0f, 0.0f, 0.0f, 0.25f)) ;
  1150. //--------------------------------------------------
  1151. gGL.color4f(1.0f, 0.5f, 0.5f, 0.75f);
  1152. gl_line_2d(left, bottom, right, bottom) ; //x axis
  1153. gl_line_2d(left, bottom, left, top) ; //y axis
  1155. //ruler
  1156. //--------------------------------------------------
  1157. gGL.color4f(1.0f, 0.5f, 0.5f, 0.5f);
  1158. for(S32 i = bottom + 50 ; i <= top ; i += 50)
  1159. {
  1160. gl_line_2d(left, i, right, i) ;
  1161. }
  1163. //texts
  1164. //--------------------------------------------------
  1165. F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};
  1166. std::string text;
  1168. //-------
  1169. //x axis: size label
  1170. static char category[LLViewerTexture::MAX_GL_IMAGE_CATEGORY][4] = 
  1171. {"Non", "Bak", "Av", "Cld", "Scp", "Hi", "Trn", "Slt", "Hud", "Bsf", "UI", "Pvw", "Map", "Mvs", "Slf", "Loc", "Scr", "Dyn", "Mdi", "ALT", "Oth" } ;
  1173. text = llformat("%s", category[0]) ;
  1174. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 12, bottom - line_height / 2,
  1175.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1176. for(U32 i = 1 ; i < mTextureSizeBar.size() ; i++)
  1177. {
  1178. text = llformat("%s", category[i]) ;
  1179. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + i * mTextureSizeBarWidth + 12, bottom - line_height / 2,
  1180.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1181. }
  1182. //-------
  1184. //y axis: number label
  1185. for(S32 i = bottom + 50 ; i <= top ; i += 50)
  1186. {
  1187. text = llformat("%d", (S32)((i - bottom) / scale)) ;
  1188. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left - 20, i + line_height / 2 ,
  1189.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1190. LLFontGL::getFontMonospace()->renderUTF8(text, 0, right + 5, i + line_height / 2 ,
  1191.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1192. }
  1194. text = llformat("MB") ;
  1195. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left - 20, top + line_height * 2 ,
  1196.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1197. //--------------------------------------------------
  1198. F32 loaded_color[] = {1.0f, 0.0f, 0.0f, 0.75f};
  1199. gl_rect_2d(left + 70, top + line_height * 2, left + 90, top + line_height, loaded_color) ;
  1200. text = llformat("Loaded") ;
  1201. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 100, top + line_height * 2,
  1202.  loaded_color, 
  1203.  LLFontGL::LEFT, LLFontGL::TOP);
  1205. F32 bound_color[] = {1.0f, 1.0f, 0.0f, 0.75f};
  1206. gl_rect_2d(left + 170, top + line_height * 2, left + 190, top + line_height, bound_color) ;
  1207. text = llformat("Bound") ;
  1208. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 200, top + line_height * 2,
  1209.  bound_color, LLFontGL::LEFT, LLFontGL::TOP);
  1211. //--------------------------------------------------
  1213. //title
  1214. text = llformat("Texture Category Distribution") ;
  1215. LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 250, top + line_height * 3,
  1216.  text_color, LLFontGL::LEFT, LLFontGL::TOP);
  1218. return scale ;
  1219. }