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

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

游戏引擎

开发平台：

C++ Builder

llimagegl.cpp：源码内容
  1. /** 
  2.  * @file llimagegl.cpp
  3.  * @brief Generic GL image handler
  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.  */
  34. // TODO: create 2 classes for images w/ and w/o discard levels?
  36. #include "linden_common.h"
  38. #include "llimagegl.h"
  40. #include "llerror.h"
  41. #include "llimage.h"
  43. #include "llmath.h"
  44. #include "llgl.h"
  45. #include "llrender.h"
  46. //----------------------------------------------------------------------------
  47. const F32 MIN_TEXTURE_LIFETIME = 10.f;
  49. //statics
  50. LLGLuint LLImageGL::sCurrentBoundTextures[MAX_GL_TEXTURE_UNITS] = { 0 };
  52. U32 LLImageGL::sUniqueCount = 0;
  53. U32 LLImageGL::sBindCount = 0;
  54. S32 LLImageGL::sGlobalTextureMemoryInBytes = 0;
  55. S32 LLImageGL::sBoundTextureMemoryInBytes = 0;
  56. S32 LLImageGL::sCurBoundTextureMemory = 0;
  57. S32 LLImageGL::sCount = 0;
  58. std::list<U32> LLImageGL::sDeadTextureList;
  60. BOOL LLImageGL::sGlobalUseAnisotropic = FALSE;
  61. F32 LLImageGL::sLastFrameTime = 0.f;
  62. BOOL LLImageGL::sAllowReadBackRaw       = FALSE ;
  63. LLImageGL* LLImageGL::sDefaultGLTexture = NULL ;
  65. std::set<LLImageGL*> LLImageGL::sImageList;
  67. //****************************************************************************************************
  68. //The below for texture auditing use only
  69. //****************************************************************************************************
  70. //-----------------------
  71. //debug use
  72. BOOL gAuditTexture = FALSE ;
  73. #define MAX_TEXTURE_LOG_SIZE 22 //2048 * 2048
  74. std::vector<S32> LLImageGL::sTextureLoadedCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
  75. std::vector<S32> LLImageGL::sTextureBoundCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
  76. std::vector<S32> LLImageGL::sTextureCurBoundCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
  77. S32 LLImageGL::sCurTexSizeBar = -1 ;
  78. S32 LLImageGL::sCurTexPickSize = -1 ;
  79. LLPointer<LLImageGL> LLImageGL::sHighlightTexturep = NULL;
  80. S32 LLImageGL::sMaxCatagories = 1 ;
  82. std::vector<S32> LLImageGL::sTextureMemByCategory;
  83. std::vector<S32> LLImageGL::sTextureMemByCategoryBound ;
  84. std::vector<S32> LLImageGL::sTextureCurMemByCategoryBound ;
  85. //------------------------
  86. //****************************************************************************************************
  87. //End for texture auditing use only
  88. //****************************************************************************************************
  90. //**************************************************************************************
  91. //below are functions for debug use
  92. //do not delete them even though they are not currently being used.
  93. void check_all_images()
  94. {
  95. for (std::set<LLImageGL*>::iterator iter = LLImageGL::sImageList.begin();
  96.  iter != LLImageGL::sImageList.end(); iter++)
  97. {
  98. LLImageGL* glimage = *iter;
  99. if (glimage->getTexName() && glimage->isGLTextureCreated())
  100. {
  101. gGL.getTexUnit(0)->bind(glimage) ;
  102. glimage->checkTexSize() ;
  103. gGL.getTexUnit(0)->unbind(glimage->getTarget()) ;
  104. }
  105. }
  106. }
  108. void LLImageGL::checkTexSize() const
  109. {
  110. if (gDebugGL && mTarget == GL_TEXTURE_2D)
  111. {
  112. GLint texname;
  113. glGetIntegerv(GL_TEXTURE_BINDING_2D, &texname);
  114. BOOL error = FALSE;
  115. if (texname != mTexName)
  116. {
  117. error = TRUE;
  118. if (gDebugSession)
  119. {
  120. gFailLog << "Invalid texture bound!" << std::endl;
  121. }
  122. else
  123. {
  124. llerrs << "Invalid texture bound!" << llendl;
  125. }
  126. }
  127. stop_glerror() ;
  128. LLGLint x = 0, y = 0 ;
  129. glGetTexLevelParameteriv(mTarget, 0, GL_TEXTURE_WIDTH, (GLint*)&x);
  130. glGetTexLevelParameteriv(mTarget, 0, GL_TEXTURE_HEIGHT, (GLint*)&y) ;
  131. stop_glerror() ;
  132. if(!x || !y)
  133. {
  134. return ;
  135. }
  136. if(x != (mWidth >> mCurrentDiscardLevel) || y != (mHeight >> mCurrentDiscardLevel))
  137. {
  138. error = TRUE;
  139. if (gDebugSession)
  140. {
  141. gFailLog << "wrong texture size and discard level!" << std::endl;
  142. }
  143. else
  144. {
  145. llerrs << "wrong texture size and discard level!" << llendl ;
  146. }
  147. }
  149. if (error)
  150. {
  151. ll_fail("LLImageGL::checkTexSize failed.");
  152. }
  153. }
  154. }
  155. //end of debug functions
  156. //**************************************************************************************
  158. //----------------------------------------------------------------------------
  159. BOOL is_little_endian()
  160. {
  161. S32 a = 0x12345678;
  162.     U8 *c = (U8*)(&a);
  163.     
  164. return (*c == 0x78) ;
  165. }
  166. //static 
  167. void LLImageGL::initClass(S32 num_catagories) 
  168. {
  169. sMaxCatagories = num_catagories ;
  171. sTextureMemByCategory.resize(sMaxCatagories);
  172. sTextureMemByCategoryBound.resize(sMaxCatagories) ;
  173. sTextureCurMemByCategoryBound.resize(sMaxCatagories) ;
  174. }
  176. //static 
  177. void LLImageGL::cleanupClass() 
  178. {
  179. sTextureMemByCategory.clear() ;
  180. sTextureMemByCategoryBound.clear() ;
  181. sTextureCurMemByCategoryBound.clear() ;
  182. }
  184. //static 
  185. void LLImageGL::setHighlightTexture(S32 category) 
  186. {
  187. const S32 dim = 128;
  188. sHighlightTexturep = new LLImageGL() ;
  189. LLPointer<LLImageRaw> image_raw = new LLImageRaw(dim,dim,3);
  190. U8* data = image_raw->getData();
  191. for (S32 i = 0; i<dim; i++)
  192. {
  193. for (S32 j = 0; j<dim; j++)
  194. {
  195. const S32 border = 2;
  196. if (i<border || j<border || i>=(dim-border) || j>=(dim-border))
  197. {
  198. *data++ = 0xff;
  199. *data++ = 0xff;
  200. *data++ = 0xff;
  201. }
  202. else
  203. {
  204. *data++ = 0xff;
  205. *data++ = 0xff;
  206. *data++ = 0x00;
  207. }
  208. }
  209. }
  210. sHighlightTexturep->createGLTexture(0, image_raw, 0, TRUE, category);
  211. image_raw = NULL;
  212. }
  214. //static
  215. S32 LLImageGL::dataFormatBits(S32 dataformat)
  216. {
  217. switch (dataformat)
  218. {
  219.   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: return 4;
  220.   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: return 8;
  221.   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: return 8;
  222.   case GL_LUMINANCE: return 8;
  223.   case GL_ALPHA: return 8;
  224.   case GL_COLOR_INDEX: return 8;
  225.   case GL_LUMINANCE_ALPHA: return 16;
  226.   case GL_RGB: return 24;
  227.   case GL_RGB8: return 24;
  228.   case GL_RGBA: return 32;
  229.   case GL_BGRA: return 32; // Used for QuickTime media textures on the Mac
  230.   default:
  231. llerrs << "LLImageGL::Unknown format: " << dataformat << llendl;
  232. return 0;
  233. }
  234. }
  236. //static
  237. S32 LLImageGL::dataFormatBytes(S32 dataformat, S32 width, S32 height)
  238. {
  239. if (dataformat >= GL_COMPRESSED_RGB_S3TC_DXT1_EXT &&
  240. dataformat <= GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
  241. {
  242. if (width < 4) width = 4;
  243. if (height < 4) height = 4;
  244. }
  245. S32 bytes ((width*height*dataFormatBits(dataformat)+7)>>3);
  246. S32 aligned = (bytes+3)&~3;
  247. return aligned;
  248. }
  250. //static
  251. S32 LLImageGL::dataFormatComponents(S32 dataformat)
  252. {
  253. switch (dataformat)
  254. {
  255.   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: return 3;
  256.   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: return 4;
  257.   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: return 4;
  258.   case GL_LUMINANCE: return 1;
  259.   case GL_ALPHA: return 1;
  260.   case GL_COLOR_INDEX: return 1;
  261.   case GL_LUMINANCE_ALPHA: return 2;
  262.   case GL_RGB: return 3;
  263.   case GL_RGBA: return 4;
  264.   case GL_BGRA: return 4; // Used for QuickTime media textures on the Mac
  265.   default:
  266. llerrs << "LLImageGL::Unknown format: " << dataformat << llendl;
  267. return 0;
  268. }
  269. }
  271. //----------------------------------------------------------------------------
  273. // static
  274. void LLImageGL::updateStats(F32 current_time)
  275. {
  276. sLastFrameTime = current_time;
  277. sBoundTextureMemoryInBytes = sCurBoundTextureMemory;
  278. sCurBoundTextureMemory = 0;
  280. if(gAuditTexture)
  281. {
  282. for(U32 i = 0 ; i < sTextureCurBoundCounter.size() ; i++)
  283. {
  284. sTextureBoundCounter[i] = sTextureCurBoundCounter[i] ;
  285. sTextureCurBoundCounter[i] = 0 ;
  286. }
  287. for(U32 i = 0 ; i < sTextureCurMemByCategoryBound.size() ; i++)
  288. {
  289. sTextureMemByCategoryBound[i] = sTextureCurMemByCategoryBound[i] ;
  290. sTextureCurMemByCategoryBound[i] = 0 ;
  291. }
  292. }
  293. }
  295. //static
  296. S32 LLImageGL::updateBoundTexMem(const S32 mem, const S32 ncomponents, S32 category)
  297. {
  298. if(gAuditTexture && ncomponents > 0 && category > -1)
  299. {
  300. sTextureCurBoundCounter[getTextureCounterIndex(mem / ncomponents)]++ ;
  301. sTextureCurMemByCategoryBound[category] += mem ;
  302. }
  304. LLImageGL::sCurBoundTextureMemory += mem ;
  305. return LLImageGL::sCurBoundTextureMemory;
  306. }
  308. //----------------------------------------------------------------------------
  310. //static 
  311. void LLImageGL::destroyGL(BOOL save_state)
  312. {
  313. for (S32 stage = 0; stage < gGLManager.mNumTextureUnits; stage++)
  314. {
  315. gGL.getTexUnit(stage)->unbind(LLTexUnit::TT_TEXTURE);
  316. }
  318. sAllowReadBackRaw = true ;
  319. for (std::set<LLImageGL*>::iterator iter = sImageList.begin();
  320.  iter != sImageList.end(); iter++)
  321. {
  322. LLImageGL* glimage = *iter;
  323. if (glimage->mTexName)
  324. {
  325. if (save_state && glimage->isGLTextureCreated() && glimage->mComponents)
  326. {
  327. glimage->mSaveData = new LLImageRaw;
  328. if(!glimage->readBackRaw(glimage->mCurrentDiscardLevel, glimage->mSaveData, false)) //necessary, keep it.
  329. {
  330. glimage->mSaveData = NULL ;
  331. }
  332. }
  334. glimage->destroyGLTexture();
  335. stop_glerror();
  336. }
  337. }
  338. sAllowReadBackRaw = false ;
  339. }
  341. //static 
  342. void LLImageGL::restoreGL()
  343. {
  344. for (std::set<LLImageGL*>::iterator iter = sImageList.begin();
  345.  iter != sImageList.end(); iter++)
  346. {
  347. LLImageGL* glimage = *iter;
  348. if(glimage->getTexName())
  349. {
  350. llerrs << "tex name is not 0." << llendl ;
  351. }
  352. if (glimage->mSaveData.notNull())
  353. {
  354. if (glimage->getComponents() && glimage->mSaveData->getComponents())
  355. {
  356. glimage->createGLTexture(glimage->mCurrentDiscardLevel, glimage->mSaveData, 0, TRUE, glimage->getCategory());
  357. stop_glerror();
  358. }
  359. glimage->mSaveData = NULL; // deletes data
  360. }
  361. }
  362. }
  364. //----------------------------------------------------------------------------
  366. //for server side use only.
  367. //static 
  368. BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, BOOL usemipmaps)
  369. {
  370. dest = new LLImageGL(usemipmaps);
  371. return TRUE;
  372. }
  374. //for server side use only.
  375. BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, U32 width, U32 height, U8 components, BOOL usemipmaps)
  376. {
  377. dest = new LLImageGL(width, height, components, usemipmaps);
  378. return TRUE;
  379. }
  381. //for server side use only.
  382. BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, BOOL usemipmaps)
  383. {
  384. dest = new LLImageGL(imageraw, usemipmaps);
  385. return TRUE;
  386. }
  388. //----------------------------------------------------------------------------
  390. LLImageGL::LLImageGL(BOOL usemipmaps)
  391. : mSaveData(0)
  392. {
  393. init(usemipmaps);
  394. setSize(0, 0, 0);
  395. sImageList.insert(this);
  396. sCount++;
  397. }
  399. LLImageGL::LLImageGL(U32 width, U32 height, U8 components, BOOL usemipmaps)
  400. : mSaveData(0)
  401. {
  402. llassert( components <= 4 );
  403. init(usemipmaps);
  404. setSize(width, height, components);
  405. sImageList.insert(this);
  406. sCount++;
  407. }
  409. LLImageGL::LLImageGL(const LLImageRaw* imageraw, BOOL usemipmaps)
  410. : mSaveData(0)
  411. {
  412. init(usemipmaps);
  413. setSize(0, 0, 0);
  414. sImageList.insert(this);
  415. sCount++;
  417. createGLTexture(0, imageraw); 
  418. }
  420. LLImageGL::~LLImageGL()
  421. {
  422. LLImageGL::cleanup();
  423. sImageList.erase(this);
  424. delete [] mPickMask;
  425. mPickMask = NULL;
  426. sCount--;
  427. }
  429. void LLImageGL::init(BOOL usemipmaps)
  430. {
  431. // keep these members in the same order as declared in llimagehl.h
  432. // so that it is obvious by visual inspection if we forgot to
  433. // init a field.
  435. mTextureMemory = 0;
  436. mLastBindTime = 0.f;
  438. mPickMask = NULL;
  439. mPickMaskWidth = 0;
  440. mPickMaskHeight = 0;
  441. mUseMipMaps = usemipmaps;
  442. mHasExplicitFormat = FALSE;
  443. mAutoGenMips = FALSE;
  445. mIsMask = FALSE;
  446. mNeedsAlphaAndPickMask = TRUE ;
  447. mAlphaStride = 0 ;
  448. mAlphaOffset = 0 ;
  450. mGLTextureCreated = FALSE ;
  451. mTexName = 0;
  452. mWidth = 0;
  453. mHeight = 0;
  454. mCurrentDiscardLevel = -1;
  456. mDiscardLevelInAtlas = -1 ;
  457. mTexelsInAtlas = 0 ;
  458. mTexelsInGLTexture = 0 ;
  460. mTarget = GL_TEXTURE_2D;
  461. mBindTarget = LLTexUnit::TT_TEXTURE;
  462. mHasMipMaps = false;
  464. mIsResident = 0;
  466. mComponents = 0;
  467. mMaxDiscardLevel = MAX_DISCARD_LEVEL;
  469. mTexOptionsDirty = true;
  470. mAddressMode = LLTexUnit::TAM_WRAP;
  471. mFilterOption = LLTexUnit::TFO_ANISOTROPIC;
  473. mFormatInternal = -1;
  474. mFormatPrimary = (LLGLenum) 0;
  475. mFormatType = GL_UNSIGNED_BYTE;
  476. mFormatSwapBytes = FALSE;
  478. #ifdef DEBUG_MISS
  479. mMissed = FALSE;
  480. #endif
  482. mCategory = -1;
  483. }
  485. void LLImageGL::cleanup()
  486. {
  487. if (!gGLManager.mIsDisabled)
  488. {
  489. destroyGLTexture();
  490. }
  491. mSaveData = NULL; // deletes data
  492. }
  494. //----------------------------------------------------------------------------
  496. //this function is used to check the size of a texture image.
  497. //so dim should be a positive number
  498. static bool check_power_of_two(S32 dim)
  499. {
  500. if(dim < 0)
  501. {
  502. return false ;
  503. }
  504. if(!dim)//0 is a power-of-two number
  505. {
  506. return true ;
  507. }
  508. return !(dim & (dim - 1)) ;
  509. }
  511. //static
  512. bool LLImageGL::checkSize(S32 width, S32 height)
  513. {
  514. return check_power_of_two(width) && check_power_of_two(height);
  515. }
  517. void LLImageGL::setSize(S32 width, S32 height, S32 ncomponents)
  518. {
  519. if (width != mWidth || height != mHeight || ncomponents != mComponents)
  520. {
  521. // Check if dimensions are a power of two!
  522. if (!checkSize(width,height))
  523. {
  524. llerrs << llformat("Texture has non power of two dimension: %dx%d",width,height) << llendl;
  525. }
  527. if (mTexName)
  528. {
  529. //  llwarns << "Setting Size of LLImageGL with existing mTexName = " << mTexName << llendl;
  530. destroyGLTexture();
  531. }
  533. // pickmask validity depends on old image size, delete it
  534. delete [] mPickMask;
  535. mPickMask = NULL;
  536. mPickMaskWidth = mPickMaskHeight = 0;
  538. mWidth = width;
  539. mHeight = height;
  540. mComponents = ncomponents;
  541. if (ncomponents > 0)
  542. {
  543. mMaxDiscardLevel = 0;
  544. while (width > 1 && height > 1 && mMaxDiscardLevel < MAX_DISCARD_LEVEL)
  545. {
  546. mMaxDiscardLevel++;
  547. width >>= 1;
  548. height >>= 1;
  549. }
  550. }
  551. else
  552. {
  553. mMaxDiscardLevel = MAX_DISCARD_LEVEL;
  554. }
  555. }
  556. }
  558. //----------------------------------------------------------------------------
  560. // virtual
  561. void LLImageGL::dump()
  562. {
  563. llinfos << "mMaxDiscardLevel " << S32(mMaxDiscardLevel)
  564. << " mLastBindTime " << mLastBindTime
  565. << " mTarget " << S32(mTarget)
  566. << " mBindTarget " << S32(mBindTarget)
  567. << " mUseMipMaps " << S32(mUseMipMaps)
  568. << " mHasMipMaps " << S32(mHasMipMaps)
  569. << " mCurrentDiscardLevel " << S32(mCurrentDiscardLevel)
  570. << " mFormatInternal " << S32(mFormatInternal)
  571. << " mFormatPrimary " << S32(mFormatPrimary)
  572. << " mFormatType " << S32(mFormatType)
  573. << " mFormatSwapBytes " << S32(mFormatSwapBytes)
  574. << " mHasExplicitFormat " << S32(mHasExplicitFormat)
  575. #if DEBUG_MISS
  576. << " mMissed " << mMissed
  577. #endif
  578. << llendl;
  580. llinfos << " mTextureMemory " << mTextureMemory
  581. << " mTexNames " << mTexName
  582. << " mIsResident " << S32(mIsResident)
  583. << llendl;
  584. }
  586. //----------------------------------------------------------------------------
  587. void LLImageGL::forceUpdateBindStats(void) const
  588. {
  589. mLastBindTime = sLastFrameTime;
  590. }
  592. BOOL LLImageGL::updateBindStats(S32 tex_mem) const
  593. {
  594. if (mTexName != 0)
  595. {
  596. #ifdef DEBUG_MISS
  597. mMissed = ! getIsResident(TRUE);
  598. #endif
  599. sBindCount++;
  600. if (mLastBindTime != sLastFrameTime)
  601. {
  602. // we haven't accounted for this texture yet this frame
  603. sUniqueCount++;
  604. updateBoundTexMem(tex_mem, mComponents, mCategory);
  605. mLastBindTime = sLastFrameTime;
  607. return TRUE ;
  608. }
  609. }
  610. return FALSE ;
  611. }
  613. F32 LLImageGL::getTimePassedSinceLastBound()
  614. {
  615. return sLastFrameTime - mLastBindTime ;
  616. }
  618. void LLImageGL::setExplicitFormat( LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format, BOOL swap_bytes )
  619. {
  620. // Note: must be called before createTexture()
  621. // Note: it's up to the caller to ensure that the format matches the number of components.
  622. mHasExplicitFormat = TRUE;
  623. mFormatInternal = internal_format;
  624. mFormatPrimary = primary_format;
  625. if(type_format == 0)
  626. mFormatType = GL_UNSIGNED_BYTE;
  627. else
  628. mFormatType = type_format;
  629. mFormatSwapBytes = swap_bytes;
  631. calcAlphaChannelOffsetAndStride() ;
  632. }
  634. //----------------------------------------------------------------------------
  636. void LLImageGL::setImage(const LLImageRaw* imageraw)
  637. {
  638. llassert((imageraw->getWidth() == getWidth(mCurrentDiscardLevel)) &&
  639.  (imageraw->getHeight() == getHeight(mCurrentDiscardLevel)) &&
  640.  (imageraw->getComponents() == getComponents()));
  641. const U8* rawdata = imageraw->getData();
  642. setImage(rawdata, FALSE);
  643. }
  645. void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
  646. {
  647. bool is_compressed = false;
  648. if (mFormatPrimary >= GL_COMPRESSED_RGBA_S3TC_DXT1_EXT && mFormatPrimary <= GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
  649. {
  650. is_compressed = true;
  651. }
  653. llverify(gGL.getTexUnit(0)->bind(this));
  655. if (mUseMipMaps)
  656. {
  657. if (data_hasmips)
  658. {
  659. // NOTE: data_in points to largest image; smaller images
  660. // are stored BEFORE the largest image
  661. for (S32 d=mCurrentDiscardLevel; d<=mMaxDiscardLevel; d++)
  662. {
  664. S32 w = getWidth(d);
  665. S32 h = getHeight(d);
  666. S32 gl_level = d-mCurrentDiscardLevel;
  667. if (d > mCurrentDiscardLevel)
  668. {
  669. data_in -= dataFormatBytes(mFormatPrimary, w, h); // see above comment
  670. }
  671. if (is_compressed)
  672. {
  673.   S32 tex_size = dataFormatBytes(mFormatPrimary, w, h);
  674. glCompressedTexImage2DARB(mTarget, gl_level, mFormatPrimary, w, h, 0, tex_size, (GLvoid *)data_in);
  675. stop_glerror();
  676. }
  677. else
  678. {
  679. //  LLFastTimer t2(FTM_TEMP4);
  681. if(mFormatSwapBytes)
  682. {
  683. glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
  684. stop_glerror();
  685. }
  687. LLImageGL::setManualImage(mTarget, gl_level, mFormatInternal, w, h, mFormatPrimary, GL_UNSIGNED_BYTE, (GLvoid*)data_in);
  688. if (gl_level == 0)
  689. {
  690. analyzeAlpha(data_in, w, h);
  691. }
  692. updatePickMask(w, h, data_in);
  694. if(mFormatSwapBytes)
  695. {
  696. glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
  697. stop_glerror();
  698. }
  700. stop_glerror();
  701. }
  702. stop_glerror();
  703. }
  704. }
  705. else if (!is_compressed)
  706. {
  707. if (mAutoGenMips)
  708. {
  709. glTexParameteri(LLTexUnit::getInternalType(mBindTarget), GL_GENERATE_MIPMAP_SGIS, TRUE);
  710. stop_glerror();
  711. {
  712. //  LLFastTimer t2(FTM_TEMP4);
  714. if(mFormatSwapBytes)
  715. {
  716. glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
  717. stop_glerror();
  718. }
  720. S32 w = getWidth(mCurrentDiscardLevel);
  721. S32 h = getHeight(mCurrentDiscardLevel);
  723. LLImageGL::setManualImage(mTarget, 0, mFormatInternal,
  724.  w, h, 
  725.  mFormatPrimary, mFormatType,
  726.  data_in);
  727. analyzeAlpha(data_in, w, h);
  728. stop_glerror();
  730. updatePickMask(w, h, data_in);
  732. if(mFormatSwapBytes)
  733. {
  734. glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
  735. stop_glerror();
  736. }
  737. }
  738. }
  739. else
  740. {
  741. // Create mips by hand
  742. // about 30% faster than autogen on ATI 9800, 50% slower on nVidia 4800
  743. // ~4x faster than gluBuild2DMipmaps
  744. S32 width = getWidth(mCurrentDiscardLevel);
  745. S32 height = getHeight(mCurrentDiscardLevel);
  746. S32 nummips = mMaxDiscardLevel - mCurrentDiscardLevel + 1;
  747. S32 w = width, h = height;
  748. const U8* prev_mip_data = 0;
  749. const U8* cur_mip_data = 0;
  750. S32 prev_mip_size = 0;
  751. S32 cur_mip_size = 0;
  752. for (int m=0; m<nummips; m++)
  753. {
  754. if (m==0)
  755. {
  756. cur_mip_data = data_in;
  757. cur_mip_size = width * height * mComponents; 
  758. }
  759. else
  760. {
  761. S32 bytes = w * h * mComponents;
  762. llassert(prev_mip_data);
  763. llassert(prev_mip_size == bytes*4);
  764. U8* new_data = new U8[bytes];
  765. llassert_always(new_data);
  766. LLImageBase::generateMip(prev_mip_data, new_data, w, h, mComponents);
  767. cur_mip_data = new_data;
  768. cur_mip_size = bytes; 
  769. }
  770. llassert(w > 0 && h > 0 && cur_mip_data);
  771. {
  772. //  LLFastTimer t1(FTM_TEMP4);
  773. if(mFormatSwapBytes)
  774. {
  775. glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
  776. stop_glerror();
  777. }
  779. LLImageGL::setManualImage(mTarget, m, mFormatInternal, w, h, mFormatPrimary, mFormatType, cur_mip_data);
  780. if (m == 0)
  781. {
  782. analyzeAlpha(data_in, w, h);
  783. }
  784. stop_glerror();
  785. if (m == 0)
  786. {
  787. updatePickMask(w, h, cur_mip_data);
  788. }
  790. if(mFormatSwapBytes)
  791. {
  792. glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
  793. stop_glerror();
  794. }
  795. }
  796. if (prev_mip_data && prev_mip_data != data_in)
  797. {
  798. delete[] prev_mip_data;
  799. }
  800. prev_mip_data = cur_mip_data;
  801. prev_mip_size = cur_mip_size;
  802. w >>= 1;
  803. h >>= 1;
  804. }
  805. if (prev_mip_data && prev_mip_data != data_in)
  806. {
  807. delete[] prev_mip_data;
  808. prev_mip_data = NULL;
  809. }
  810. }
  811. }
  812. else
  813. {
  814. llerrs << "Compressed Image has mipmaps but data does not (can not auto generate compressed mips)" << llendl;
  815. }
  816. mHasMipMaps = true;
  817. }
  818. else
  819. {
  820. S32 w = getWidth();
  821. S32 h = getHeight();
  822. if (is_compressed)
  823. {
  824. S32 tex_size = dataFormatBytes(mFormatPrimary, w, h);
  825. glCompressedTexImage2DARB(mTarget, 0, mFormatPrimary, w, h, 0, tex_size, (GLvoid *)data_in);
  826. stop_glerror();
  827. }
  828. else
  829. {
  830. if(mFormatSwapBytes)
  831. {
  832. glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
  833. stop_glerror();
  834. }
  836. LLImageGL::setManualImage(mTarget, 0, mFormatInternal, w, h,
  837.  mFormatPrimary, mFormatType, (GLvoid *)data_in);
  838. analyzeAlpha(data_in, w, h);
  840. updatePickMask(w, h, data_in);
  842. stop_glerror();
  844. if(mFormatSwapBytes)
  845. {
  846. glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
  847. stop_glerror();
  848. }
  850. }
  851. mHasMipMaps = false;
  852. }
  853. stop_glerror();
  854. mGLTextureCreated = true;
  855. }
  857. BOOL LLImageGL::preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image)
  858. {
  859. if (gGLManager.mIsDisabled)
  860. {
  861. llwarns << "Trying to create a texture while GL is disabled!" << llendl;
  862. return FALSE;
  863. }
  864. llassert(gGLManager.mInited);
  865. stop_glerror();
  867. if (discard_level < 0)
  868. {
  869. llassert(mCurrentDiscardLevel >= 0);
  870. discard_level = mCurrentDiscardLevel;
  871. }
  872. discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
  874. // Actual image width/height = raw image width/height * 2^discard_level
  875. S32 w = raw_image->getWidth() << discard_level;
  876. S32 h = raw_image->getHeight() << discard_level;
  878. // setSize may call destroyGLTexture if the size does not match
  879. setSize(w, h, raw_image->getComponents());
  881. if( !mHasExplicitFormat )
  882. {
  883. switch (mComponents)
  884. {
  885.   case 1:
  886. // Use luminance alpha (for fonts)
  887. mFormatInternal = GL_LUMINANCE8;
  888. mFormatPrimary = GL_LUMINANCE;
  889. mFormatType = GL_UNSIGNED_BYTE;
  890. break;
  891.   case 2:
  892. // Use luminance alpha (for fonts)
  893. mFormatInternal = GL_LUMINANCE8_ALPHA8;
  894. mFormatPrimary = GL_LUMINANCE_ALPHA;
  895. mFormatType = GL_UNSIGNED_BYTE;
  896. break;
  897.   case 3:
  898. mFormatInternal = GL_RGB8;
  899. mFormatPrimary = GL_RGB;
  900. mFormatType = GL_UNSIGNED_BYTE;
  901. break;
  902.   case 4:
  903. mFormatInternal = GL_RGBA8;
  904. mFormatPrimary = GL_RGBA;
  905. mFormatType = GL_UNSIGNED_BYTE;
  906. break;
  907.   default:
  908. llerrs << "Bad number of components for texture: " << (U32)getComponents() << llendl;
  909. }
  910. }
  912. mCurrentDiscardLevel = discard_level;
  913. mDiscardLevelInAtlas = discard_level;
  914. mTexelsInAtlas = raw_image->getWidth() * raw_image->getHeight() ;
  915. mLastBindTime = sLastFrameTime;
  916. mGLTextureCreated = false ;
  918. glPixelStorei(GL_UNPACK_ROW_LENGTH, raw_image->getWidth());
  919. stop_glerror();
  921. if(mFormatSwapBytes)
  922. {
  923. glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
  924. stop_glerror();
  925. }
  927. return TRUE ;
  928. }
  930. void LLImageGL::postAddToAtlas()
  931. {
  932. if(mFormatSwapBytes)
  933. {
  934. glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
  935. stop_glerror();
  936. }
  938. glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  939. gGL.getTexUnit(0)->setTextureFilteringOption(mFilterOption);
  940. stop_glerror();
  941. }
  943. BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update)
  944. {
  945. if (!width || !height)
  946. {
  947. return TRUE;
  948. }
  949. if (mTexName == 0)
  950. {
  951. llwarns << "Setting subimage on image without GL texture" << llendl;
  952. return FALSE;
  953. }
  954. if (datap == NULL)
  955. {
  956. llwarns << "Setting subimage on image with NULL datap" << llendl;
  957. return FALSE;
  958. }
  960. // HACK: allow the caller to explicitly force the fast path (i.e. using glTexSubImage2D here instead of calling setImage) even when updating the full texture.
  961. if (!force_fast_update && x_pos == 0 && y_pos == 0 && width == getWidth() && height == getHeight() && data_width == width && data_height == height)
  962. {
  963. setImage(datap, FALSE);
  964. }
  965. else
  966. {
  967. if (mUseMipMaps)
  968. {
  969. dump();
  970. llerrs << "setSubImage called with mipmapped image (not supported)" << llendl;
  971. }
  972. llassert_always(mCurrentDiscardLevel == 0);
  973. llassert_always(x_pos >= 0 && y_pos >= 0);
  975. if (((x_pos + width) > getWidth()) || 
  976. (y_pos + height) > getHeight())
  977. {
  978. dump();
  979. llerrs << "Subimage not wholly in target image!" 
  980.    << " x_pos " << x_pos
  981.    << " y_pos " << y_pos
  982.    << " width " << width
  983.    << " height " << height
  984.    << " getWidth() " << getWidth()
  985.    << " getHeight() " << getHeight()
  986.    << llendl;
  987. }
  989. if ((x_pos + width) > data_width || 
  990. (y_pos + height) > data_height)
  991. {
  992. dump();
  993. llerrs << "Subimage not wholly in source image!" 
  994.    << " x_pos " << x_pos
  995.    << " y_pos " << y_pos
  996.    << " width " << width
  997.    << " height " << height
  998.    << " source_width " << data_width
  999.    << " source_height " << data_height
  1000.    << llendl;
  1001. }
  1004. glPixelStorei(GL_UNPACK_ROW_LENGTH, data_width);
  1005. stop_glerror();
  1007. if(mFormatSwapBytes)
  1008. {
  1009. glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
  1010. stop_glerror();
  1011. }
  1013. datap += (y_pos * data_width + x_pos) * getComponents();
  1014. // Update the GL texture
  1015. BOOL res = gGL.getTexUnit(0)->bindManual(mBindTarget, mTexName);
  1016. if (!res) llerrs << "LLImageGL::setSubImage(): bindTexture failed" << llendl;
  1017. stop_glerror();
  1019. glTexSubImage2D(mTarget, 0, x_pos, y_pos, 
  1020. width, height, mFormatPrimary, mFormatType, datap);
  1021. gGL.getTexUnit(0)->disable();
  1022. stop_glerror();
  1024. if(mFormatSwapBytes)
  1025. {
  1026. glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
  1027. stop_glerror();
  1028. }
  1030. glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  1031. stop_glerror();
  1032. mGLTextureCreated = true;
  1033. }
  1034. return TRUE;
  1035. }
  1037. BOOL LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update)
  1038. {
  1039. return setSubImage(imageraw->getData(), imageraw->getWidth(), imageraw->getHeight(), x_pos, y_pos, width, height, force_fast_update);
  1040. }
  1042. // Copy sub image from frame buffer
  1043. BOOL LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height)
  1044. {
  1045. if (gGL.getTexUnit(0)->bind(this, false, true))
  1046. {
  1047. //checkTexSize() ;
  1048. glCopyTexSubImage2D(GL_TEXTURE_2D, 0, fb_x, fb_y, x_pos, y_pos, width, height);
  1049. mGLTextureCreated = true;
  1050. stop_glerror();
  1051. return TRUE;
  1052. }
  1053. else
  1054. {
  1055. return FALSE;
  1056. }
  1057. }
  1059. // static
  1060. void LLImageGL::generateTextures(S32 numTextures, U32 *textures)
  1061. {
  1062. glGenTextures(numTextures, (GLuint*)textures);
  1063. }
  1065. // static
  1066. void LLImageGL::deleteTextures(S32 numTextures, U32 *textures)
  1067. {
  1068. for (S32 i = 0; i < numTextures; i++)
  1069. {
  1070. sDeadTextureList.push_back(textures[i]);
  1071. }
  1072. }
  1074. // static
  1075. void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels)
  1076. {
  1077. glTexImage2D(target, miplevel, intformat, width, height, 0, pixformat, pixtype, pixels);
  1078. stop_glerror();
  1079. }
  1081. //create an empty GL texture: just create a texture name
  1082. //the texture is assiciate with some image by calling glTexImage outside LLImageGL
  1083. BOOL LLImageGL::createGLTexture()
  1084. {
  1085. if (gGLManager.mIsDisabled)
  1086. {
  1087. llwarns << "Trying to create a texture while GL is disabled!" << llendl;
  1088. return FALSE;
  1089. }
  1091. mGLTextureCreated = false ; //do not save this texture when gl is destroyed.
  1093. llassert(gGLManager.mInited);
  1094. stop_glerror();
  1096. if(mTexName)
  1097. {
  1098. glDeleteTextures(1, (reinterpret_cast<GLuint*>(&mTexName))) ;
  1099. }
  1101. glGenTextures(1, (GLuint*)&mTexName);
  1102. stop_glerror();
  1103. if (!mTexName)
  1104. {
  1105. llerrs << "LLImageGL::createGLTexture failed to make an empty texture" << llendl;
  1106. }
  1108. return TRUE ;
  1109. }
  1111. BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/, BOOL to_create, S32 category)
  1112. {
  1113. if (gGLManager.mIsDisabled)
  1114. {
  1115. llwarns << "Trying to create a texture while GL is disabled!" << llendl;
  1116. return FALSE;
  1117. }
  1119. mGLTextureCreated = false ;
  1120. llassert(gGLManager.mInited);
  1121. stop_glerror();
  1123. if (discard_level < 0)
  1124. {
  1125. llassert(mCurrentDiscardLevel >= 0);
  1126. discard_level = mCurrentDiscardLevel;
  1127. }
  1128. discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
  1130. // Actual image width/height = raw image width/height * 2^discard_level
  1131. S32 raw_w = imageraw->getWidth() ;
  1132. S32 raw_h = imageraw->getHeight() ;
  1133. S32 w = raw_w << discard_level;
  1134. S32 h = raw_h << discard_level;
  1136. // setSize may call destroyGLTexture if the size does not match
  1137. setSize(w, h, imageraw->getComponents());
  1139. if( !mHasExplicitFormat )
  1140. {
  1141. switch (mComponents)
  1142. {
  1143.   case 1:
  1144. // Use luminance alpha (for fonts)
  1145. mFormatInternal = GL_LUMINANCE8;
  1146. mFormatPrimary = GL_LUMINANCE;
  1147. mFormatType = GL_UNSIGNED_BYTE;
  1148. break;
  1149.   case 2:
  1150. // Use luminance alpha (for fonts)
  1151. mFormatInternal = GL_LUMINANCE8_ALPHA8;
  1152. mFormatPrimary = GL_LUMINANCE_ALPHA;
  1153. mFormatType = GL_UNSIGNED_BYTE;
  1154. break;
  1155.   case 3:
  1156. mFormatInternal = GL_RGB8;
  1157. mFormatPrimary = GL_RGB;
  1158. mFormatType = GL_UNSIGNED_BYTE;
  1159. break;
  1160.   case 4:
  1161. mFormatInternal = GL_RGBA8;
  1162. mFormatPrimary = GL_RGBA;
  1163. mFormatType = GL_UNSIGNED_BYTE;
  1164. break;
  1165.   default:
  1166. llerrs << "Bad number of components for texture: " << (U32)getComponents() << llendl;
  1167. }
  1169. calcAlphaChannelOffsetAndStride() ;
  1170. }
  1172. if(!to_create) //not create a gl texture
  1173. {
  1174. destroyGLTexture();
  1175. mCurrentDiscardLevel = discard_level;
  1176. mLastBindTime = sLastFrameTime;
  1177. return TRUE ;
  1178. }
  1180. setCategory(category) ;
  1181.   const U8* rawdata = imageraw->getData();
  1182. return createGLTexture(discard_level, rawdata, FALSE, usename);
  1183. }
  1185. BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_hasmips, S32 usename)
  1186. {
  1187. llassert(data_in);
  1189. if (discard_level < 0)
  1190. {
  1191. llassert(mCurrentDiscardLevel >= 0);
  1192. discard_level = mCurrentDiscardLevel;
  1193. }
  1194. discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
  1196. if (mTexName != 0 && discard_level == mCurrentDiscardLevel)
  1197. {
  1198. // This will only be true if the size has not changed
  1199. setImage(data_in, data_hasmips);
  1200. return TRUE;
  1201. }
  1203. U32 old_name = mTexName;
  1204. //  S32 old_discard = mCurrentDiscardLevel;
  1206. if (usename != 0)
  1207. {
  1208. mTexName = usename;
  1209. }
  1210. else
  1211. {
  1212. LLImageGL::generateTextures(1, &mTexName);
  1213. stop_glerror();
  1214. {
  1215. llverify(gGL.getTexUnit(0)->bind(this));
  1216. glTexParameteri(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_BASE_LEVEL, 0);
  1217. glTexParameteri(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_MAX_LEVEL,  mMaxDiscardLevel-discard_level);
  1218. }
  1219. }
  1220. if (!mTexName)
  1221. {
  1222. llerrs << "LLImageGL::createGLTexture failed to make texture" << llendl;
  1223. }
  1225. if (mUseMipMaps)
  1226. {
  1227. mAutoGenMips = gGLManager.mHasMipMapGeneration;
  1228. #if LL_DARWIN
  1229. // On the Mac GF2 and GF4MX drivers, auto mipmap generation doesn't work right with alpha-only textures.
  1230. if(gGLManager.mIsGF2or4MX && (mFormatInternal == GL_ALPHA8) && (mFormatPrimary == GL_ALPHA))
  1231. {
  1232. mAutoGenMips = FALSE;
  1233. }
  1234. #endif
  1235. }
  1237. mCurrentDiscardLevel = discard_level;
  1239. setImage(data_in, data_hasmips);
  1241. // Set texture options to our defaults.
  1242. gGL.getTexUnit(0)->setHasMipMaps(mHasMipMaps);
  1243. gGL.getTexUnit(0)->setTextureAddressMode(mAddressMode);
  1244. gGL.getTexUnit(0)->setTextureFilteringOption(mFilterOption);
  1246. // things will break if we don't unbind after creation
  1247. gGL.getTexUnit(0)->unbind(mBindTarget);
  1248. stop_glerror();
  1250. if (old_name != 0)
  1251. {
  1252. sGlobalTextureMemoryInBytes -= mTextureMemory;
  1254. if(gAuditTexture)
  1255. {
  1256. decTextureCounter(mTextureMemory, mComponents, mCategory) ;
  1257. }
  1259. LLImageGL::deleteTextures(1, &old_name);
  1261. stop_glerror();
  1262. }
  1264. mTextureMemory = getMipBytes(discard_level);
  1265. sGlobalTextureMemoryInBytes += mTextureMemory;
  1266. mTexelsInGLTexture = getWidth() * getHeight() ;
  1268. if(gAuditTexture)
  1269. {
  1270. incTextureCounter(mTextureMemory, mComponents, mCategory) ;
  1271. }
  1272. // mark this as bound at this point, so we don't throw it out immediately
  1273. mLastBindTime = sLastFrameTime;
  1274. return TRUE;
  1275. }
  1277. BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok) const
  1278. {
  1279. llassert_always(sAllowReadBackRaw) ;
  1280. //llerrs << "should not call this function!" << llendl ;
  1282. if (discard_level < 0)
  1283. {
  1284. discard_level = mCurrentDiscardLevel;
  1285. }
  1287. if (mTexName == 0 || discard_level < mCurrentDiscardLevel || discard_level > mMaxDiscardLevel )
  1288. {
  1289. return FALSE;
  1290. }
  1292. S32 gl_discard = discard_level - mCurrentDiscardLevel;
  1294. //explicitly unbind texture 
  1295. gGL.getTexUnit(0)->unbind(mBindTarget);
  1296. llverify(gGL.getTexUnit(0)->bindManual(mBindTarget, mTexName));
  1298. //debug code, leave it there commented.
  1299. //checkTexSize() ;
  1301. LLGLint glwidth = 0;
  1302. glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_WIDTH, (GLint*)&glwidth);
  1303. if (glwidth == 0)
  1304. {
  1305. // No mip data smaller than current discard level
  1306. return FALSE;
  1307. }
  1309. S32 width = getWidth(discard_level);
  1310. S32 height = getHeight(discard_level);
  1311. S32 ncomponents = getComponents();
  1312. if (ncomponents == 0)
  1313. {
  1314. return FALSE;
  1315. }
  1316. if(width < glwidth)
  1317. {
  1318. llwarns << "texture size is smaller than it should be." << llendl ;
  1319. llwarns << "width: " << width << " glwidth: " << glwidth << " mWidth: " << mWidth << 
  1320. " mCurrentDiscardLevel: " << (S32)mCurrentDiscardLevel << " discard_level: " << (S32)discard_level << llendl ;
  1321. return FALSE ;
  1322. }
  1324. if (width <= 0 || width > 2048 || height <= 0 || height > 2048 || ncomponents < 1 || ncomponents > 4)
  1325. {
  1326. llerrs << llformat("LLImageGL::readBackRaw: bogus params: %d x %d x %d",width,height,ncomponents) << llendl;
  1327. }
  1329. LLGLint is_compressed = 0;
  1330. if (compressed_ok)
  1331. {
  1332. glGetTexLevelParameteriv(mTarget, is_compressed, GL_TEXTURE_COMPRESSED, (GLint*)&is_compressed);
  1333. }
  1335. //-----------------------------------------------------------------------------------------------
  1336. GLenum error ;
  1337. while((error = glGetError()) != GL_NO_ERROR)
  1338. {
  1339. llwarns << "GL Error happens before reading back texture. Error code: " << error << llendl ;
  1340. }
  1341. //-----------------------------------------------------------------------------------------------
  1343. if (is_compressed)
  1344. {
  1345. LLGLint glbytes;
  1346. glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, (GLint*)&glbytes);
  1347. if(!imageraw->allocateDataSize(width, height, ncomponents, glbytes))
  1348. {
  1349. llwarns << "Memory allocation failed for reading back texture. Size is: " << glbytes << llendl ;
  1350. llwarns << "width: " << width << "height: " << height << "components: " << ncomponents << llendl ;
  1351. return FALSE ;
  1352. }
  1354. glGetCompressedTexImageARB(mTarget, gl_discard, (GLvoid*)(imageraw->getData()));
  1355. //stop_glerror();
  1356. }
  1357. else
  1358. {
  1359. if(!imageraw->allocateDataSize(width, height, ncomponents))
  1360. {
  1361. llwarns << "Memory allocation failed for reading back texture." << llendl ;
  1362. llwarns << "width: " << width << "height: " << height << "components: " << ncomponents << llendl ;
  1363. return FALSE ;
  1364. }
  1366. glGetTexImage(GL_TEXTURE_2D, gl_discard, mFormatPrimary, mFormatType, (GLvoid*)(imageraw->getData()));
  1367. //stop_glerror();
  1368. }
  1370. //-----------------------------------------------------------------------------------------------
  1371. if((error = glGetError()) != GL_NO_ERROR)
  1372. {
  1373. llwarns << "GL Error happens after reading back texture. Error code: " << error << llendl ;
  1374. imageraw->deleteData() ;
  1376. while((error = glGetError()) != GL_NO_ERROR)
  1377. {
  1378. llwarns << "GL Error happens after reading back texture. Error code: " << error << llendl ;
  1379. }
  1381. return FALSE ;
  1382. }
  1383. //-----------------------------------------------------------------------------------------------
  1385. return TRUE ;
  1386. }
  1388. void LLImageGL::deleteDeadTextures()
  1389. {
  1390. while (!sDeadTextureList.empty())
  1391. {
  1392. GLuint tex = sDeadTextureList.front();
  1393. sDeadTextureList.pop_front();
  1394. for (int i = 0; i < gGLManager.mNumTextureUnits; i++)
  1395. {
  1396. if (sCurrentBoundTextures[i] == tex)
  1397. {
  1398. gGL.getTexUnit(i)->unbind(LLTexUnit::TT_TEXTURE);
  1399. stop_glerror();
  1400. }
  1401. }
  1403. glDeleteTextures(1, &tex);
  1404. stop_glerror();
  1405. }
  1406. }
  1408. void LLImageGL::destroyGLTexture()
  1409. {
  1410. if (mTexName != 0)
  1411. {
  1412. if(mTextureMemory)
  1413. {
  1414. if(gAuditTexture)
  1415. {
  1416. decTextureCounter(mTextureMemory, mComponents, mCategory) ;
  1417. }
  1418. sGlobalTextureMemoryInBytes -= mTextureMemory;
  1419. mTextureMemory = 0;
  1420. }
  1422. LLImageGL::deleteTextures(1, &mTexName);
  1423. mTexName = 0;
  1424. mCurrentDiscardLevel = -1 ; //invalidate mCurrentDiscardLevel.
  1425. mGLTextureCreated = FALSE ;
  1426. }
  1427. }
  1431. //----------------------------------------------------------------------------
  1433. void LLImageGL::setAddressMode(LLTexUnit::eTextureAddressMode mode)
  1434. {
  1435. if (mAddressMode != mode)
  1436. {
  1437. mTexOptionsDirty = true;
  1438. mAddressMode = mode;
  1439. }
  1441. if (gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->getCurrTexture() == mTexName)
  1442. {
  1443. gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->setTextureAddressMode(mode);
  1444. mTexOptionsDirty = false;
  1445. }
  1446. }
  1448. void LLImageGL::setFilteringOption(LLTexUnit::eTextureFilterOptions option)
  1449. {
  1450. if (mFilterOption != option)
  1451. {
  1452. mTexOptionsDirty = true;
  1453. mFilterOption = option;
  1454. }
  1456. if (mTexName != 0 && gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->getCurrTexture() == mTexName)
  1457. {
  1458. gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->setTextureFilteringOption(option);
  1459. mTexOptionsDirty = false;
  1460. stop_glerror();
  1461. }
  1462. }
  1464. BOOL LLImageGL::getIsResident(BOOL test_now)
  1465. {
  1466. if (test_now)
  1467. {
  1468. if (mTexName != 0)
  1469. {
  1470. glAreTexturesResident(1, (GLuint*)&mTexName, &mIsResident);
  1471. }
  1472. else
  1473. {
  1474. mIsResident = FALSE;
  1475. }
  1476. }
  1478. return mIsResident;
  1479. }
  1481. S32 LLImageGL::getHeight(S32 discard_level) const
  1482. {
  1483. if (discard_level < 0)
  1484. {
  1485. discard_level = mCurrentDiscardLevel;
  1486. }
  1487. S32 height = mHeight >> discard_level;
  1488. if (height < 1) height = 1;
  1489. return height;
  1490. }
  1492. S32 LLImageGL::getWidth(S32 discard_level) const
  1493. {
  1494. if (discard_level < 0)
  1495. {
  1496. discard_level = mCurrentDiscardLevel;
  1497. }
  1498. S32 width = mWidth >> discard_level;
  1499. if (width < 1) width = 1;
  1500. return width;
  1501. }
  1503. S32 LLImageGL::getBytes(S32 discard_level) const
  1504. {
  1505. if (discard_level < 0)
  1506. {
  1507. discard_level = mCurrentDiscardLevel;
  1508. }
  1509. S32 w = mWidth>>discard_level;
  1510. S32 h = mHeight>>discard_level;
  1511. if (w == 0) w = 1;
  1512. if (h == 0) h = 1;
  1513. return dataFormatBytes(mFormatPrimary, w, h);
  1514. }
  1516. S32 LLImageGL::getMipBytes(S32 discard_level) const
  1517. {
  1518. if (discard_level < 0)
  1519. {
  1520. discard_level = mCurrentDiscardLevel;
  1521. }
  1522. S32 w = mWidth>>discard_level;
  1523. S32 h = mHeight>>discard_level;
  1524. S32 res = dataFormatBytes(mFormatPrimary, w, h);
  1525. if (mUseMipMaps)
  1526. {
  1527. while (w > 1 && h > 1)
  1528. {
  1529. w >>= 1; if (w == 0) w = 1;
  1530. h >>= 1; if (h == 0) h = 1;
  1531. res += dataFormatBytes(mFormatPrimary, w, h);
  1532. }
  1533. }
  1534. return res;
  1535. }
  1537. BOOL LLImageGL::isJustBound() const
  1538. {
  1539. return (BOOL)(sLastFrameTime - mLastBindTime < 0.5f);
  1540. }
  1542. BOOL LLImageGL::getBoundRecently() const
  1543. {
  1544. return (BOOL)(sLastFrameTime - mLastBindTime < MIN_TEXTURE_LIFETIME);
  1545. }
  1547. void LLImageGL::setTarget(const LLGLenum target, const LLTexUnit::eTextureType bind_target)
  1548. {
  1549. mTarget = target;
  1550. mBindTarget = bind_target;
  1551. }
  1553. const S8 INVALID_OFFSET = -99 ;
  1554. void LLImageGL::setNeedsAlphaAndPickMask(BOOL need_mask) 
  1555. {
  1556. if(mNeedsAlphaAndPickMask != need_mask)
  1557. {
  1558. mNeedsAlphaAndPickMask = need_mask;
  1560. if(mNeedsAlphaAndPickMask)
  1561. {
  1562. mAlphaOffset = 0 ;
  1563. }
  1564. else //do not need alpha mask
  1565. {
  1566. mAlphaOffset = INVALID_OFFSET ;
  1567. mIsMask = FALSE;
  1568. }
  1569. }
  1570. }
  1572. void LLImageGL::calcAlphaChannelOffsetAndStride()
  1573. {
  1574. if(mAlphaOffset == INVALID_OFFSET)//do not need alpha mask
  1575. {
  1576. return ;
  1577. }
  1579. mAlphaStride = -1 ;
  1580. switch (mFormatPrimary)
  1581. {
  1582. case GL_LUMINANCE:
  1583. case GL_ALPHA:
  1584. mAlphaStride = 1;
  1585. break;
  1586. case GL_LUMINANCE_ALPHA:
  1587. mAlphaStride = 2;
  1588. break;
  1589. case GL_RGB:
  1590. mNeedsAlphaAndPickMask = FALSE ;
  1591. mIsMask = FALSE;
  1592. return ; //no alpha channel.
  1593. case GL_RGBA:
  1594. mAlphaStride = 4;
  1595. break;
  1596. case GL_BGRA_EXT:
  1597. mAlphaStride = 4;
  1598. break;
  1599. default:
  1600. break;
  1601. }
  1603. mAlphaOffset = -1 ;
  1604. if (mFormatType == GL_UNSIGNED_BYTE)
  1605. {
  1606. mAlphaOffset = mAlphaStride - 1 ;
  1607. }
  1608. else if(is_little_endian())
  1609. {
  1610. if (mFormatType == GL_UNSIGNED_INT_8_8_8_8)
  1611. {
  1612. mAlphaOffset = 0 ;
  1613. }
  1614. else if (mFormatType == GL_UNSIGNED_INT_8_8_8_8_REV)
  1615. {
  1616. mAlphaOffset = 3 ;
  1617. }
  1618. }
  1619. else //big endian
  1620. {
  1621. if (mFormatType == GL_UNSIGNED_INT_8_8_8_8)
  1622. {
  1623. mAlphaOffset = 3 ;
  1624. }
  1625. else if (mFormatType == GL_UNSIGNED_INT_8_8_8_8_REV)
  1626. {
  1627. mAlphaOffset = 0 ;
  1628. }
  1629. }
  1631. if( mAlphaStride < 1 || //unsupported format
  1632. mAlphaOffset < 0 || //unsupported type
  1633. (mFormatPrimary == GL_BGRA_EXT && mFormatType != GL_UNSIGNED_BYTE)) //unknown situation
  1634. {
  1635. llwarns << "Cannot analyze alpha for image with format type " << std::hex << mFormatType << std::dec << llendl;
  1637. mNeedsAlphaAndPickMask = FALSE ;
  1638. mIsMask = FALSE;
  1639. }
  1640. }
  1642. void LLImageGL::analyzeAlpha(const void* data_in, S32 w, S32 h)
  1643. {
  1644. if(!mNeedsAlphaAndPickMask)
  1645. {
  1646. return ;
  1647. }
  1649. U32 length = w * h;
  1650. const GLubyte* current = ((const GLubyte*) data_in) + mAlphaOffset ;
  1652. S32 sample[16];
  1653. memset(sample, 0, sizeof(S32)*16);
  1655. for (U32 i = 0; i < length; i++)
  1656. {
  1657. ++sample[*current/16];
  1658. current += mAlphaStride ;
  1659. }
  1661. U32 total = 0;
  1662. for (U32 i = 4; i < 11; i++)
  1663. {
  1664. total += sample[i];
  1665. }
  1667. if (total > length/16)
  1668. {
  1669. mIsMask = FALSE;
  1670. }
  1671. else
  1672. {
  1673. mIsMask = TRUE;
  1674. }
  1675. }
  1677. //----------------------------------------------------------------------------
  1678. void LLImageGL::updatePickMask(S32 width, S32 height, const U8* data_in)
  1679. {
  1680. if(!mNeedsAlphaAndPickMask)
  1681. {
  1682. return ;
  1683. }
  1685. delete [] mPickMask;
  1686. mPickMask = NULL;
  1687. mPickMaskWidth = mPickMaskHeight = 0;
  1689. if (mFormatType != GL_UNSIGNED_BYTE ||
  1690.     mFormatPrimary != GL_RGBA)
  1691. {
  1692. //cannot generate a pick mask for this texture
  1693. return;
  1694. }
  1696. U32 pick_width = width/2 + 1;
  1697. U32 pick_height = height/2 + 1;
  1699. U32 size = pick_width * pick_height;
  1700. size = (size + 7) / 8; // pixelcount-to-bits
  1701. mPickMask = new U8[size];
  1702. mPickMaskWidth = pick_width;
  1703. mPickMaskHeight = pick_height;
  1705. memset(mPickMask, 0, sizeof(U8) * size);
  1707. U32 pick_bit = 0;
  1709. for (S32 y = 0; y < height; y += 2)
  1710. {
  1711. for (S32 x = 0; x < width; x += 2)
  1712. {
  1713. U8 alpha = data_in[(y*width+x)*4+3];
  1715. if (alpha > 32)
  1716. {
  1717. U32 pick_idx = pick_bit/8;
  1718. U32 pick_offset = pick_bit%8;
  1719. llassert(pick_idx < size);
  1721. mPickMask[pick_idx] |= 1 << pick_offset;
  1722. }
  1724. ++pick_bit;
  1725. }
  1726. }
  1727. }
  1729. BOOL LLImageGL::getMask(const LLVector2 &tc)
  1730. {
  1731. BOOL res = TRUE;
  1733. if (mPickMask)
  1734. {
  1735. F32 u = tc.mV[0] - floorf(tc.mV[0]);
  1736. F32 v = tc.mV[1] - floorf(tc.mV[1]);
  1738. if (LL_UNLIKELY(u < 0.f || u > 1.f ||
  1739. v < 0.f || v > 1.f))
  1740. {
  1741. LL_WARNS_ONCE("render") << "Ugh, u/v out of range in image mask pick" << LL_ENDL;
  1742. u = v = 0.f;
  1743. llassert(false);
  1744. }
  1746. llassert(mPickMaskWidth > 0 && mPickMaskHeight > 0);
  1748. S32 x = llfloor(u * mPickMaskWidth);
  1749. S32 y = llfloor(v * mPickMaskHeight);
  1751. if (LL_UNLIKELY(x >= mPickMaskWidth))
  1752. {
  1753. LL_WARNS_ONCE("render") << "Ooh, width overrun on pick mask read, that coulda been bad." << LL_ENDL;
  1754. x = llmax(0, mPickMaskWidth-1);
  1755. }
  1756. if (LL_UNLIKELY(y >= mPickMaskHeight))
  1757. {
  1758. LL_WARNS_ONCE("render") << "Ooh, height overrun on pick mask read, that woulda been bad." << LL_ENDL;
  1759. y = llmax(0, mPickMaskHeight-1);
  1760. }
  1762. S32 idx = y*mPickMaskWidth+x;
  1763. S32 offset = idx%8;
  1765. res = mPickMask[idx/8] & (1 << offset) ? TRUE : FALSE;
  1766. }
  1768. return res;
  1769. }
  1771. void LLImageGL::setCategory(S32 category) 
  1772. {
  1773. if(!gAuditTexture)
  1774. {
  1775. return ;
  1776. }
  1777. if(mCategory != category)
  1778. {
  1779. if(mCategory > -1)
  1780. {
  1781. sTextureMemByCategory[mCategory] -= mTextureMemory ;
  1782. }
  1783. if(category > -1 && category < sMaxCatagories)
  1784. {
  1785. sTextureMemByCategory[category] += mTextureMemory ;
  1786. mCategory = category;
  1787. }
  1788. else
  1789. {
  1790. mCategory = -1 ;
  1791. }
  1792. }
  1793. }
  1795. //for debug use 
  1796. //val is a "power of two" number
  1797. S32 LLImageGL::getTextureCounterIndex(U32 val) 
  1798. {
  1799. //index range is [0, MAX_TEXTURE_LOG_SIZE].
  1800. if(val < 2)
  1801. {
  1802. return 0 ;
  1803. }
  1804. else if(val >= (1 << MAX_TEXTURE_LOG_SIZE))
  1805. {
  1806. return MAX_TEXTURE_LOG_SIZE ;
  1807. }
  1808. else
  1809. {
  1810. S32 ret = 0 ;
  1811. while(val >>= 1)
  1812. {
  1813. ++ret;
  1814. }
  1815. return ret ;
  1816. }
  1817. }
  1819. //static
  1820. void LLImageGL::incTextureCounter(U32 val, S32 ncomponents, S32 category) 
  1821. {
  1822. sTextureLoadedCounter[getTextureCounterIndex(val)]++ ;
  1823. sTextureMemByCategory[category] += (S32)val * ncomponents ;
  1824. }
  1826. //static
  1827. void LLImageGL::decTextureCounter(U32 val, S32 ncomponents, S32 category) 
  1828. {
  1829. sTextureLoadedCounter[getTextureCounterIndex(val)]-- ;
  1830. sTextureMemByCategory[category] += (S32)val * ncomponents ;
  1831. }
  1833. void LLImageGL::setCurTexSizebar(S32 index, BOOL set_pick_size)
  1834. {
  1835. sCurTexSizeBar = index ;
  1837. if(set_pick_size)
  1838. {
  1839. sCurTexPickSize = (1 << index) ;
  1840. }
  1841. else
  1842. {
  1843. sCurTexPickSize = -1 ;
  1844. }
  1845. }
  1846. void LLImageGL::resetCurTexSizebar()
  1847. {
  1848. sCurTexSizeBar = -1 ;
  1849. sCurTexPickSize = -1 ;
  1850. }
  1851. //----------------------------------------------------------------------------
  1853. //----------------------------------------------------------------------------
  1856. // Manual Mip Generation
  1857. /*
  1858. S32 width = getWidth(discard_level);
  1859. S32 height = getHeight(discard_level);
  1860. S32 w = width, h = height;
  1861. S32 nummips = 1;
  1862. while (w > 4 && h > 4)
  1863. {
  1864. w >>= 1; h >>= 1;
  1865. nummips++;
  1866. }
  1867. stop_glerror();
  1868. w = width, h = height;
  1869. const U8* prev_mip_data = 0;
  1870. const U8* cur_mip_data = 0;
  1871. for (int m=0; m<nummips; m++)
  1872. {
  1873. if (m==0)
  1874. {
  1875. cur_mip_data = rawdata;
  1876. }
  1877. else
  1878. {
  1879. S32 bytes = w * h * mComponents;
  1880. U8* new_data = new U8[bytes];
  1881. LLImageBase::generateMip(prev_mip_data, new_data, w, h, mComponents);
  1882. cur_mip_data = new_data;
  1883. }
  1884. llassert(w > 0 && h > 0 && cur_mip_data);
  1885. U8 test = cur_mip_data[w*h*mComponents-1];
  1886. {
  1887. LLImageGL::setManualImage(mTarget, m, mFormatInternal, w, h, mFormatPrimary, mFormatType, cur_mip_data);
  1888. stop_glerror();
  1889. }
  1890. if (prev_mip_data && prev_mip_data != rawdata)
  1891. {
  1892. delete prev_mip_data;
  1893. }
  1894. prev_mip_data = cur_mip_data;
  1895. w >>= 1;
  1896. h >>= 1;
  1897. }
  1898. if (prev_mip_data && prev_mip_data != rawdata)
  1899. {
  1900. delete prev_mip_data;
  1901. }
  1902. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
  1903. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL,  nummips);
  1904. */