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

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

游戏引擎

开发平台：

C++ Builder

llviewertexture.h：源码内容
  1. /** 
  2.  * @file llviewertexture.h
  3.  * @brief Object for managing images and their textures
  4.  *
  5.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2000-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. #ifndef LL_LLVIEWERTEXTURE_H
  34. #define LL_LLVIEWERTEXTURE_H
  36. #include "lltexture.h"
  37. #include "lltimer.h"
  38. #include "llframetimer.h"
  39. #include "llhost.h"
  40. #include "llgltypes.h"
  41. #include "llrender.h"
  42. #include "llmetricperformancetester.h"
  44. #include <map>
  45. #include <list>
  47. #define MIN_VIDEO_RAM_IN_MEGA_BYTES    32
  48. #define MAX_VIDEO_RAM_IN_MEGA_BYTES    512 // 512MB max for performance reasons.
  50. class LLFace;
  51. class LLImageGL ;
  52. class LLImageRaw;
  53. class LLViewerObject;
  54. class LLViewerTexture;
  55. class LLViewerFetchedTexture ;
  56. class LLViewerMediaTexture ;
  57. class LLTexturePipelineTester ;
  60. typedef void (*loaded_callback_func)( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* src_aux, S32 discard_level, BOOL final, void* userdata );
  62. class LLVFile;
  63. class LLMessageSystem;
  64. class LLViewerMediaImpl ;
  65. class LLVOVolume ;
  67. class LLLoadedCallbackEntry
  68. {
  69. public:
  70. LLLoadedCallbackEntry(loaded_callback_func cb,
  71.   S32 discard_level,
  72.   BOOL need_imageraw, // Needs image raw for the callback
  73.   void* userdata );
  75. loaded_callback_func mCallback;
  76. S32 mLastUsedDiscard;
  77. S32 mDesiredDiscard;
  78. BOOL mNeedsImageRaw;
  79. void* mUserData;
  80. };
  82. class LLTextureBar;
  84. class LLViewerTexture : public LLTexture
  85. {
  86. public:
  87. enum
  88. {
  89. MAX_IMAGE_SIZE_DEFAULT = 1024,
  90. INVALID_DISCARD_LEVEL = 0x7fff
  91. };
  92. enum
  93. {
  94. LOCAL_TEXTURE,
  95. MEDIA_TEXTURE,
  96. DYNAMIC_TEXTURE,
  97. FETCHED_TEXTURE,
  98. LOD_TEXTURE,
  99. ATLAS_TEXTURE,
  100. INVALID_TEXTURE_TYPE
  101. };
  103. enum EBoostLevel
  104. {
  105. BOOST_NONE  = 0,
  106. BOOST_AVATAR_BAKED = 1,
  107. BOOST_AVATAR = 2,
  108. BOOST_CLOUDS = 3,
  109. BOOST_SCULPTED      = 4,
  111. BOOST_HIGH  = 10,
  112. BOOST_TERRAIN = 11, // has to be high priority for minimap / low detail
  113. BOOST_SELECTED = 12,
  114. BOOST_HUD = 13,
  115. BOOST_AVATAR_BAKED_SELF = 14,
  116. BOOST_ICON = 15,
  117. BOOST_UI = 16,
  118. BOOST_PREVIEW = 17,
  119. BOOST_MAP = 18,
  120. BOOST_MAP_VISIBLE = 19,
  121. BOOST_AVATAR_SELF = 20, // needed for baking avatar
  122. BOOST_MAX_LEVEL,
  124. //other texture Categories
  125. LOCAL = BOOST_MAX_LEVEL,
  126. AVATAR_SCRATCH_TEX,
  127. DYNAMIC_TEX,
  128. MEDIA,
  129. ATLAS,
  130. OTHER,
  131. MAX_GL_IMAGE_CATEGORY
  132. };
  133. static S32 getTotalNumOfCategories() ;
  134. static S32 getIndexFromCategory(S32 category) ;
  135. static S32 getCategoryFromIndex(S32 index) ;
  137. typedef std::vector<LLFace*> ll_face_list_t;
  138. typedef std::vector<LLVOVolume*> ll_volume_list_t;
  141. protected:
  142. virtual ~LLViewerTexture();
  143. LOG_CLASS(LLViewerTexture);
  145. public:
  146. static void initClass();
  147. static void cleanupClass();
  148. static void updateClass(const F32 velocity, const F32 angular_velocity) ;
  150. LLViewerTexture(BOOL usemipmaps = TRUE);
  151. LLViewerTexture(const LLUUID& id, BOOL usemipmaps) ;
  152. LLViewerTexture(const LLImageRaw* raw, BOOL usemipmaps) ;
  153. LLViewerTexture(const U32 width, const U32 height, const U8 components, BOOL usemipmaps) ;
  155. virtual S8 getType() const;
  156. virtual BOOL isMissingAsset()const ;
  157. virtual void dump(); // debug info to llinfos
  159. /*virtual*/ bool bindDefaultImage(const S32 stage = 0) ;
  160. /*virtual*/ void forceImmediateUpdate() ;
  162. const LLUUID& getID() const { return mID; }
  164. void setBoostLevel(S32 level);
  165. S32  getBoostLevel() { return mBoostLevel; }
  167. void addTextureStats(F32 virtual_size, BOOL needs_gltexture = TRUE) const;
  168. void resetTextureStats();
  170. virtual F32  getMaxVirtualSize() ;
  172. LLFrameTimer* getLastReferencedTimer() {return &mLastReferencedTimer ;}
  174. S32 getFullWidth() const { return mFullWidth; }
  175. S32 getFullHeight() const { return mFullHeight; }
  176. /*virtual*/ void setKnownDrawSize(S32 width, S32 height);
  178. virtual void addFace(LLFace* facep) ;
  179. virtual void removeFace(LLFace* facep) ; 
  180. S32 getNumFaces() const;
  181. const ll_face_list_t* getFaceList() const {return &mFaceList;}
  183. virtual void addVolume(LLVOVolume* volumep);
  184. virtual void removeVolume(LLVOVolume* volumep);
  185. S32 getNumVolumes() const;
  186. const ll_volume_list_t* getVolumeList() const { return &mVolumeList; }
  188. void generateGLTexture() ;
  189. void destroyGLTexture() ;
  191. //---------------------------------------------------------------------------------------------
  192. //functions to access LLImageGL
  193. //---------------------------------------------------------------------------------------------
  194. /*virtual*/S32        getWidth(S32 discard_level = -1) const;
  195. /*virtual*/S32        getHeight(S32 discard_level = -1) const;
  197. BOOL       hasGLTexture() const ;
  198. LLGLuint   getTexName() const ;
  199. BOOL       createGLTexture() ;
  200. BOOL       createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0, BOOL to_create = TRUE, S32 category = LLViewerTexture::OTHER);
  202. void       setFilteringOption(LLTexUnit::eTextureFilterOptions option);
  203. void       setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, BOOL swap_bytes = FALSE);
  204. void       setAddressMode(LLTexUnit::eTextureAddressMode mode);
  205. BOOL       setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height);
  206. BOOL       setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height);
  207. void       setGLTextureCreated (bool initialized);
  208. void       setCategory(S32 category) ;
  210. LLTexUnit::eTextureAddressMode getAddressMode(void) const ;
  211. S32        getMaxDiscardLevel() const;
  212. S32        getDiscardLevel() const;
  213. S8    getComponents() const ;
  214. BOOL       getBoundRecently() const;
  215. S32        getTextureMemory() const ;
  216. LLGLenum   getPrimaryFormat() const;
  217. BOOL       getIsAlphaMask() const ;
  218. LLTexUnit::eTextureType getTarget(void) const ;
  219. BOOL       getMask(const LLVector2 &tc);
  220. F32        getTimePassedSinceLastBound();
  221. BOOL       getMissed() const ;
  222. BOOL       isJustBound()const ;
  223. void       forceUpdateBindStats(void) const;
  225. U32        getTexelsInAtlas() const ;
  226. U32        getTexelsInGLTexture() const ;
  227. BOOL       isGLTextureCreated() const ;
  228. S32        getDiscardLevelInAtlas() const ;
  229. //---------------------------------------------------------------------------------------------
  230. //end of functions to access LLImageGL
  231. //---------------------------------------------------------------------------------------------
  233. //-----------------
  234. /*virtual*/ void setActive() ;
  235. void forceActive() ;
  236. void setNoDelete() ;
  237. void dontDiscard() { mDontDiscard = 1; mTextureState = NO_DELETE; }
  238. BOOL getDontDiscard() const { return mDontDiscard; }
  239. //-----------------
  241. BOOL isLargeImage() ;
  243. void setParcelMedia(LLViewerMediaTexture* media) {mParcelMedia = media;}
  244. BOOL hasParcelMedia() const { return mParcelMedia != NULL;}
  245. LLViewerMediaTexture* getParcelMedia() const { return mParcelMedia;}
  247. /*virtual*/ void updateBindStatsForTester() ;
  248. protected:
  249. void cleanup() ;
  250. void init(bool firstinit) ;
  251. void reorganizeFaceList() ;
  252. void reorganizeVolumeList() ;
  253. private:
  254. //note: do not make this function public.
  255. /*virtual*/ LLImageGL* getGLTexture() const ;
  256. virtual void switchToCachedImage();
  258. protected:
  259. LLUUID mID;
  260. S32 mBoostLevel; // enum describing priority level
  261. S32 mFullWidth;
  262. S32 mFullHeight;
  263. BOOL  mUseMipMaps ;
  264. S8  mComponents;
  265. mutable F32 mMaxVirtualSize; // The largest virtual size of the image, in pixels - how much data to we need?
  266. mutable S8  mNeedsGLTexture;
  267. mutable BOOL mNeedsResetMaxVirtualSize ;
  268. mutable F32 mAdditionalDecodePriority;  // priority add to mDecodePriority.
  269. LLFrameTimer mLastReferencedTimer;
  271. //GL texture
  272. LLPointer<LLImageGL> mGLTexturep ;
  273. S8 mDontDiscard; // Keep full res version of this image (for UI, etc)
  275. ll_face_list_t    mFaceList ; //reverse pointer pointing to the faces using this image as texture
  276. U32               mNumFaces ;
  277. LLFrameTimer      mLastFaceListUpdateTimer ;
  279. ll_volume_list_t  mVolumeList;
  280. U32 mNumVolumes;
  281. LLFrameTimer   mLastVolumeListUpdateTimer;
  283. //do not use LLPointer here.
  284. LLViewerMediaTexture* mParcelMedia ;
  286. protected:
  287. typedef enum 
  288. {
  289. DELETED = 0,         //removed from memory
  290. DELETION_CANDIDATE,  //ready to be removed from memory
  291. INACTIVE,            //not be used for the last certain period (i.e., 30 seconds).
  292. ACTIVE,              //just being used, can become inactive if not being used for a certain time (10 seconds).
  293. NO_DELETE = 99       //stay in memory, can not be removed.
  294. } LLGLTexureState;
  295. LLGLTexureState  mTextureState ;
  297. public:
  298. static const U32 sCurrentFileVersion;
  299. static S32 sImageCount;
  300. static S32 sRawCount;
  301. static S32 sAuxCount;
  302. static LLTimer sEvaluationTimer;
  303. static F32 sDesiredDiscardBias;
  304. static F32 sDesiredDiscardScale;
  305. static S32 sBoundTextureMemoryInBytes;
  306. static S32 sTotalTextureMemoryInBytes;
  307. static S32 sMaxBoundTextureMemInMegaBytes;
  308. static S32 sMaxTotalTextureMemInMegaBytes;
  309. static S32 sMaxDesiredTextureMemInBytes ;
  310. static S8  sCameraMovingDiscardBias;
  311. static S32 sMaxSculptRez ;
  312. static S32 sMinLargeImageSize ;
  313. static S32 sMaxSmallImageSize ;
  314. static BOOL sFreezeImageScalingDown ;//do not scale down image res if set.
  315. static F32  sCurrentTime ;
  316. static BOOL sUseTextureAtlas ;
  318. static LLPointer<LLViewerTexture> sNullImagep; // Null texture for non-textured objects.
  319. };
  322. //
  323. //textures are managed in gTextureList.
  324. //raw image data is fetched from remote or local cache
  325. //but the raw image this texture pointing to is fixed.
  326. //
  327. class LLViewerFetchedTexture : public LLViewerTexture
  328. {
  329. friend class LLTextureBar; // debug info only
  330. friend class LLTextureView; // debug info only
  332. protected:
  333. /*virtual*/ ~LLViewerFetchedTexture();
  334. public:
  335. LLViewerFetchedTexture(const LLUUID& id, const LLHost& host = LLHost::invalid, BOOL usemipmaps = TRUE);
  336. LLViewerFetchedTexture(const LLImageRaw* raw, BOOL usemipmaps);
  337. LLViewerFetchedTexture(const std::string& url, const LLUUID& id, BOOL usemipmaps = TRUE);
  339. public:
  340. static F32 maxDecodePriority();
  342. struct Compare
  343. {
  344. // lhs < rhs
  345. bool operator()(const LLPointer<LLViewerFetchedTexture> &lhs, const LLPointer<LLViewerFetchedTexture> &rhs) const
  346. {
  347. const LLViewerFetchedTexture* lhsp = (const LLViewerFetchedTexture*)lhs;
  348. const LLViewerFetchedTexture* rhsp = (const LLViewerFetchedTexture*)rhs;
  349. // greater priority is "less"
  350. const F32 lpriority = lhsp->getDecodePriority();
  351. const F32 rpriority = rhsp->getDecodePriority();
  352. if (lpriority > rpriority) // higher priority
  353. return true;
  354. if (lpriority < rpriority)
  355. return false;
  356. return lhsp < rhsp;
  357. }
  358. };
  360. public:
  361. /*virtual*/ S8 getType() const ;
  362. /*virtual*/ void forceImmediateUpdate() ;
  363. /*virtual*/ void dump() ;
  365. // Set callbacks to get called when the image gets updated with higher 
  366. // resolution versions.
  367. void setLoadedCallback(loaded_callback_func cb,
  368.    S32 discard_level, BOOL keep_imageraw, BOOL needs_aux,
  369.    void* userdata);
  370. bool hasCallbacks() { return mLoadedCallbackList.empty() ? false : true; }
  371. bool doLoadedCallbacks();
  373. void addToCreateTexture();
  375.  // ONLY call from LLViewerTextureList
  376. BOOL createTexture(S32 usename = 0);
  377. void destroyTexture() ;
  379. virtual void processTextureStats() ;
  380. F32  calcDecodePriority() ;
  382. BOOL needsAux() const { return mNeedsAux; }
  384. // Host we think might have this image, used for baked av textures.
  385. void setTargetHost(LLHost host) { mTargetHost = host; }
  386. LLHost getTargetHost() const { return mTargetHost; }
  388. // Set the decode priority for this image...
  389. // DON'T CALL THIS UNLESS YOU KNOW WHAT YOU'RE DOING, it can mess up
  390. // the priority list, and cause horrible things to happen.
  391. void setDecodePriority(F32 priority = -1.0f);
  392. F32 getDecodePriority() const { return mDecodePriority; };
  394. void setAdditionalDecodePriority(F32 priority) ;
  396. void updateVirtualSize() ;
  398. S32  getDesiredDiscardLevel()  { return mDesiredDiscardLevel; }
  399. void setMinDiscardLevel(S32 discard)  { mMinDesiredDiscardLevel = llmin(mMinDesiredDiscardLevel,(S8)discard); }
  401. bool updateFetch();
  403. // Override the computation of discard levels if we know the exact output
  404. // size of the image.  Used for UI textures to not decode, even if we have
  405. // more data.
  406. /*virtual*/ void setKnownDrawSize(S32 width, S32 height);
  408. void setIsMissingAsset();
  409. /*virtual*/ BOOL isMissingAsset() const { return mIsMissingAsset; }
  411. // returns dimensions of original image for local files (before power of two scaling)
  412. // and returns 0 for all asset system images
  413. S32 getOriginalWidth() { return mOrigWidth; }
  414. S32 getOriginalHeight() { return mOrigHeight; }
  416. BOOL isInImageList() const {return mInImageList ;}
  417. void setInImageList(BOOL flag) {mInImageList = flag ;}
  419. LLFrameTimer* getLastPacketTimer() {return &mLastPacketTimer;}
  421. U32 getFetchPriority() const { return mFetchPriority ;}
  422. F32 getDownloadProgress() const {return mDownloadProgress ;}
  424. LLImageRaw* reloadRawImage(S8 discard_level) ;
  425. void destroyRawImage();
  427. const std::string& getUrl() const {return mUrl;}
  428. //---------------
  429. BOOL isDeleted() ;
  430. BOOL isInactive() ;
  431. BOOL isDeletionCandidate();
  432. void setDeletionCandidate() ;
  433. void setInactive() ;
  434. BOOL getUseDiscard() const { return mUseMipMaps && !mDontDiscard; }
  435. //---------------
  437. void setForSculpt();
  438. BOOL forSculpt() const {return mForSculpt;}
  439. BOOL isForSculptOnly() const;
  441. //raw image management
  442. void        checkCachedRawSculptImage() ;
  443. LLImageRaw* getRawImage()const { return mRawImage ;}
  444. S32         getRawImageLevel() const {return mRawDiscardLevel;}
  445. LLImageRaw* getCachedRawImage() const { return mCachedRawImage ;}
  446. S32         getCachedRawImageLevel() const {return mCachedRawDiscardLevel;}
  447. BOOL        isCachedRawImageReady() const {return mCachedRawImageReady ;}
  448. BOOL        isRawImageValid()const { return mIsRawImageValid ; }
  449. void        forceToSaveRawImage(S32 desired_discard = 0) ;
  450. void        destroySavedRawImage() ;
  451. LLImageRaw* getSavedRawImage() ;
  452. BOOL        hasSavedRawImage() const ;
  453. F32         getElapsedLastReferencedSavedRawImageTime() const ;
  454. BOOL isFullyLoaded() const;
  456. protected:
  457. /*virtual*/ void switchToCachedImage();
  459. private:
  460. void init(bool firstinit) ;
  461. void cleanup() ;
  463. void saveRawImage() ;
  464. BOOL forceFetch() ;
  465. void setCachedRawImage() ;
  466. BOOL keepReuestedDiscardLevel();
  468. //for atlas
  469. void resetFaceAtlas() ;
  470. void invalidateAtlas(BOOL rebuild_geom) ;
  471. BOOL insertToAtlas() ;
  473. private:
  474. BOOL  mFullyLoaded;
  476. protected:
  477. std::string mLocalFileName;
  479. S32 mOrigWidth;
  480. S32 mOrigHeight;
  482. // Override the computation of discard levels if we know the exact output size of the image.
  483. // Used for UI textures to not decode, even if we have more data.
  484. S32 mKnownDrawWidth;
  485. S32 mKnownDrawHeight;
  486. BOOL mKnownDrawSizeChanged ;
  487. std::string mUrl;
  489. S32 mRequestedDiscardLevel;
  490. F32 mRequestedDownloadPriority;
  491. S32 mFetchState;
  492. U32 mFetchPriority;
  493. F32 mDownloadProgress;
  494. F32 mFetchDeltaTime;
  495. F32 mRequestDeltaTime;
  496. F32 mDecodePriority; // The priority for decoding this image.
  497. S32 mMinDiscardLevel;
  498. S8  mDesiredDiscardLevel; // The discard level we'd LIKE to have - if we have it and there's space
  499. S8  mMinDesiredDiscardLevel; // The minimum discard level we'd like to have
  501. S8  mNeedsAux; // We need to decode the auxiliary channels
  502. S8  mDecodingAux; // Are we decoding high components
  503. S8  mIsRawImageValid;
  504. S8  mHasFetcher; // We've made a fecth request
  505. S8  mIsFetching; // Fetch request is active
  507. mutable S8 mIsMissingAsset; // True if we know that there is no image asset with this image id in the database.
  509. typedef std::list<LLLoadedCallbackEntry*> callback_list_t;
  510. S8              mLoadedCallbackDesiredDiscardLevel;
  511. callback_list_t mLoadedCallbackList;
  513. LLPointer<LLImageRaw> mRawImage;
  514. S32 mRawDiscardLevel;
  516. // Used ONLY for cloth meshes right now.  Make SURE you know what you're 
  517. // doing if you use it for anything else! - djs
  518. LLPointer<LLImageRaw> mAuxRawImage;
  520. //keep a copy of mRawImage for some special purposes
  521. //when mForceToSaveRawImage is set.
  522. BOOL mForceToSaveRawImage ;
  523. LLPointer<LLImageRaw> mSavedRawImage;
  524. S32 mSavedRawDiscardLevel;
  525. S32 mDesiredSavedRawDiscardLevel;
  526. F32 mLastReferencedSavedRawImageTime ;
  528. //a small version of the copy of the raw image (<= 64 * 64)
  529. LLPointer<LLImageRaw> mCachedRawImage;
  530. S32 mCachedRawDiscardLevel;
  531. BOOL mCachedRawImageReady; //the rez of the mCachedRawImage reaches the upper limit.
  533. LLHost mTargetHost; // if LLHost::invalid, just request from agent's simulator
  535. // Timers
  536. LLFrameTimer mLastPacketTimer; // Time since last packet.
  538. BOOL  mInImageList; // TRUE if image is in list (in which case don't reset priority!)
  539. BOOL  mNeedsCreateTexture;
  541. BOOL   mForSculpt ; //a flag if the texture is used as sculpt data.
  542. BOOL   mIsFetched ; //is loaded from remote or from cache, not generated locally.
  544. public:
  545. static LLPointer<LLViewerFetchedTexture> sMissingAssetImagep; // Texture to show for an image asset that is not in the database
  546. static LLPointer<LLViewerFetchedTexture> sWhiteImagep; // Texture to show NOTHING (whiteness)
  547. static LLPointer<LLViewerFetchedTexture> sDefaultImagep; // "Default" texture for error cases, the only case of fetched texture which is generated in local.
  548. static LLPointer<LLViewerFetchedTexture> sSmokeImagep; // Old "Default" translucent texture
  549. };
  551. //
  552. //the image data is fetched from remote or from local cache
  553. //the resolution of the texture is adjustable: depends on the view-dependent parameters.
  554. //
  555. class LLViewerLODTexture : public LLViewerFetchedTexture
  556. {
  557. protected:
  558. /*virtual*/ ~LLViewerLODTexture(){}
  560. public:
  561. LLViewerLODTexture(const LLUUID& id, const LLHost& host = LLHost::invalid, BOOL usemipmaps = TRUE);
  562. LLViewerLODTexture(const std::string& url, const LLUUID& id, BOOL usemipmaps = TRUE);
  564. /*virtual*/ S8 getType() const;
  565. // Process image stats to determine priority/quality requirements.
  566. /*virtual*/ void processTextureStats();
  567. BOOL isUpdateFrozen() ;
  569. private:
  570. void init(bool firstinit) ;
  571. void scaleDown() ;
  573. private:
  575. F32 mTexelsPerImage; // Texels per image.
  576. F32 mDiscardVirtualSize; // Virtual size used to calculate desired discard
  577. F32 mCalculatedDiscardLevel;    // Last calculated discard level
  578. };
  580. //
  581. //the image data is fetched from the media pipeline periodically
  582. //the resolution of the texture is also adjusted by the media pipeline
  583. //
  584. class LLViewerMediaTexture : public LLViewerTexture
  585. {
  586. protected:
  587. /*virtual*/ ~LLViewerMediaTexture() ;
  589. public:
  590. LLViewerMediaTexture(const LLUUID& id, BOOL usemipmaps = TRUE, LLImageGL* gl_image = NULL) ;
  592. /*virtual*/ S8 getType() const;
  593. void reinit(BOOL usemipmaps = TRUE);
  595. BOOL  getUseMipMaps() {return mUseMipMaps ; }
  596. void  setUseMipMaps(BOOL mipmap) ;
  598. void setPlaying(BOOL playing) ;
  599. BOOL isPlaying() const {return mIsPlaying;}
  600. void setMediaImpl() ;
  602. void initVirtualSize() ;
  603. void invalidateMediaImpl() ;
  605. void addMediaToFace(LLFace* facep) ;
  606. void removeMediaFromFace(LLFace* facep) ;
  608. /*virtual*/ void addFace(LLFace* facep) ;
  609. /*virtual*/ void removeFace(LLFace* facep) ; 
  611. /*virtual*/ F32  getMaxVirtualSize() ;
  612. private:
  613. void switchTexture(LLFace* facep) ;
  614. BOOL findFaces() ;
  615. void stopPlaying() ;
  617. private:
  618. //
  619. //an instant list, recording all faces referencing or can reference to this media texture.
  620. //NOTE: it is NOT thread safe. 
  621. //
  622. std::list< LLFace* > mMediaFaceList ; 
  624. //an instant list keeping all textures which are replaced by the current media texture,
  625. //is only used to avoid the removal of those textures from memory.
  626. std::list< LLPointer<LLViewerTexture> > mTextureList ;
  628. LLViewerMediaImpl* mMediaImplp ;
  629. BOOL mIsPlaying ;
  630. U32  mUpdateVirtualSizeTime ;
  632. public:
  633. static void updateClass() ;
  634. static void cleanup() ;
  636. static LLViewerMediaTexture* findMediaTexture(const LLUUID& media_id) ;
  637. static void removeMediaImplFromTexture(const LLUUID& media_id) ;
  639. private:
  640. typedef std::map< LLUUID, LLPointer<LLViewerMediaTexture> > media_map_t ;
  641. static media_map_t sMediaMap ;
  642. };
  644. //just an interface class, do not create instance from this class.
  645. class LLViewerTextureManager
  646. {
  647. private:
  648. //make the constructor private to preclude creating instances from this class.
  649. LLViewerTextureManager(){}
  651. public:
  652.     //texture pipeline tester
  653. static LLTexturePipelineTester* sTesterp ;
  655. //returns NULL if tex is not a LLViewerFetchedTexture nor derived from LLViewerFetchedTexture.
  656. static LLViewerFetchedTexture*    staticCastToFetchedTexture(LLTexture* tex, BOOL report_error = FALSE) ;
  658. //
  659. //"find-texture" just check if the texture exists, if yes, return it, otherwise return null.
  660. //
  661. static LLViewerTexture*           findTexture(const LLUUID& id) ;
  662. static LLViewerMediaTexture*      findMediaTexture(const LLUUID& id) ;
  664. static LLViewerMediaTexture*      createMediaTexture(const LLUUID& id, BOOL usemipmaps = TRUE, LLImageGL* gl_image = NULL) ;
  666. //
  667. //"get-texture" will create a new texture if the texture does not exist.
  668. //
  669. static LLViewerMediaTexture*      getMediaTexture(const LLUUID& id, BOOL usemipmaps = TRUE, LLImageGL* gl_image = NULL) ;
  671. static LLPointer<LLViewerTexture> getLocalTexture(BOOL usemipmaps = TRUE, BOOL generate_gl_tex = TRUE);
  672. static LLPointer<LLViewerTexture> getLocalTexture(const LLUUID& id, BOOL usemipmaps, BOOL generate_gl_tex = TRUE) ;
  673. static LLPointer<LLViewerTexture> getLocalTexture(const LLImageRaw* raw, BOOL usemipmaps) ;
  674. static LLPointer<LLViewerTexture> getLocalTexture(const U32 width, const U32 height, const U8 components, BOOL usemipmaps, BOOL generate_gl_tex = TRUE) ;
  676. static LLViewerFetchedTexture* getFetchedTexture(const LLUUID &image_id,  
  677.  BOOL usemipmap = TRUE,
  678.  LLViewerTexture::EBoostLevel boost_priority = LLViewerTexture::BOOST_NONE, // Get the requested level immediately upon creation.
  679.  S8 texture_type = LLViewerTexture::FETCHED_TEXTURE,
  680.  LLGLint internal_format = 0,
  681.  LLGLenum primary_format = 0,
  682.  LLHost request_from_host = LLHost()
  683.  );
  685. static LLViewerFetchedTexture* getFetchedTextureFromFile(const std::string& filename,  
  686.  BOOL usemipmap = TRUE,
  687.  LLViewerTexture::EBoostLevel boost_priority = LLViewerTexture::BOOST_NONE,
  688.  S8 texture_type = LLViewerTexture::FETCHED_TEXTURE,
  689.  LLGLint internal_format = 0,
  690.  LLGLenum primary_format = 0,
  691.  const LLUUID& force_id = LLUUID::null
  692.  );
  694. static LLViewerFetchedTexture* getFetchedTextureFromUrl(const std::string& url,  
  695.  BOOL usemipmap = TRUE,
  696.  LLViewerTexture::EBoostLevel boost_priority = LLViewerTexture::BOOST_NONE,
  697.  S8 texture_type = LLViewerTexture::FETCHED_TEXTURE,
  698.  LLGLint internal_format = 0,
  699.  LLGLenum primary_format = 0,
  700.  const LLUUID& force_id = LLUUID::null
  701.  );
  703. static LLViewerFetchedTexture* getFetchedTextureFromHost(const LLUUID& image_id, LLHost host) ;
  705. static void init() ;
  706. static void cleanup() ;
  707. };
  708. //
  709. //this class is used for test/debug only
  710. //it tracks the activities of the texture pipeline
  711. //records them, and outputs them to log files
  712. //
  713. class LLTexturePipelineTester : public LLMetricPerformanceTester
  714. {
  715. enum
  716. {
  717. MIN_LARGE_IMAGE_AREA = 262144  //512 * 512
  718. };
  719. public:
  720. LLTexturePipelineTester() ;
  721. ~LLTexturePipelineTester() ;
  723. void update();
  724. void updateTextureBindingStats(const LLViewerTexture* imagep) ;
  725. void updateTextureLoadingStats(const LLViewerFetchedTexture* imagep, const LLImageRaw* raw_imagep, BOOL from_cache) ;
  726. void updateGrayTextureBinding() ;
  727. void setStablizingTime() ;
  729. /*virtual*/ void analyzePerformance(std::ofstream* os, LLSD* base, LLSD* current) ;
  731. private:
  732. void reset() ;
  733. void updateStablizingTime() ;
  735. /*virtual*/ void outputTestRecord(LLSD* sd) ;
  737. private:
  738. BOOL mPause ;
  739. private:
  740. BOOL mUsingDefaultTexture;            //if set, some textures are still gray.
  742. U32 mTotalBytesUsed ;                     //total bytes of textures bound/used for the current frame.
  743. U32 mTotalBytesUsedForLargeImage ;        //total bytes of textures bound/used for the current frame for images larger than 256 * 256.
  744. U32 mLastTotalBytesUsed ;                 //total bytes of textures bound/used for the previous frame.
  745. U32 mLastTotalBytesUsedForLargeImage ;    //total bytes of textures bound/used for the previous frame for images larger than 256 * 256.
  747. //
  748. //data size
  749. //
  750. U32 mTotalBytesLoaded ;               //total bytes fetched by texture pipeline
  751. U32 mTotalBytesLoadedFromCache ;      //total bytes fetched by texture pipeline from local cache
  752. U32 mTotalBytesLoadedForLargeImage ;  //total bytes fetched by texture pipeline for images larger than 256 * 256. 
  753. U32 mTotalBytesLoadedForSculpties ;   //total bytes fetched by texture pipeline for sculpties
  755. //
  756. //time
  757. //NOTE: the error tolerances of the following timers is one frame time.
  758. //
  759. F32 mStartFetchingTime ;
  760. F32 mTotalGrayTime ;                  //total loading time when no gray textures.
  761. F32 mTotalStablizingTime ;            //total stablizing time when texture memory overflows
  762. F32 mStartTimeLoadingSculpties ;      //the start moment of loading sculpty images.
  763. F32 mEndTimeLoadingSculpties ;        //the end moment of loading sculpty images.
  764. F32 mStartStablizingTime ;
  765. F32 mEndStablizingTime ;
  767. private:
  768. //
  769. //The following members are used for performance analyzing
  770. //
  771. class LLTextureTestSession : public LLTestSession
  772. {
  773. public:
  774. LLTextureTestSession() ;
  775. /*virtual*/ ~LLTextureTestSession() ;
  777. void reset() ;
  779. F32 mTotalFetchingTime ;
  780. F32 mTotalGrayTime ;
  781. F32 mTotalStablizingTime ;
  782. F32 mStartTimeLoadingSculpties ; 
  783. F32 mTotalTimeLoadingSculpties ;
  785. S32 mTotalBytesLoaded ; 
  786. S32 mTotalBytesLoadedFromCache ;
  787. S32 mTotalBytesLoadedForLargeImage ;
  788. S32 mTotalBytesLoadedForSculpties ; 
  790. typedef struct _texture_instant_preformance_t
  791. {
  792. S32 mAverageBytesUsedPerSecond ;         
  793. S32 mAverageBytesUsedForLargeImagePerSecond ;
  794. F32 mAveragePercentageBytesUsedPerSecond ;
  795. F32 mTime ;
  796. }texture_instant_preformance_t ;
  797. std::vector<texture_instant_preformance_t> mInstantPerformanceList ;
  798. S32 mInstantPerformanceListCounter ;
  799. };
  801. /*virtual*/ LLMetricPerformanceTester::LLTestSession* loadTestSession(LLSD* log) ;
  802. /*virtual*/ void compareTestSessions(std::ofstream* os) ;
  803. };
  805. #endif