llimagegl.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:12k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llimagegl.h
  3.  * @brief Object for managing images and their textures
  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.  */
  32. #ifndef LL_LLIMAGEGL_H
  33. #define LL_LLIMAGEGL_H
  34. #include "llimage.h"
  35. #include "llgltypes.h"
  36. #include "llpointer.h"
  37. #include "llrefcount.h"
  38. #include "v2math.h"
  39. #include "llrender.h"
  40. class LLTextureAtlas ;
  41. #define BYTES_TO_MEGA_BYTES(x) ((x) >> 20)
  42. #define MEGA_BYTES_TO_BYTES(x) ((x) << 20)
  43. //============================================================================
  44. class LLImageGL : public LLRefCount
  45. {
  46. friend class LLTexUnit;
  47. public:
  48. static std::list<U32> sDeadTextureList;
  49. static void deleteDeadTextures();
  50. // Size calculation
  51. static S32 dataFormatBits(S32 dataformat);
  52. static S32 dataFormatBytes(S32 dataformat, S32 width, S32 height);
  53. static S32 dataFormatComponents(S32 dataformat);
  54. BOOL updateBindStats(S32 tex_mem) const ;
  55. F32 getTimePassedSinceLastBound();
  56. void forceUpdateBindStats(void) const;
  57. // needs to be called every frame
  58. static void updateStats(F32 current_time);
  59. // Save off / restore GL textures
  60. static void destroyGL(BOOL save_state = TRUE);
  61. static void restoreGL();
  62. // Sometimes called externally for textures not using LLImageGL (should go away...)
  63. static S32 updateBoundTexMem(const S32 mem, const S32 ncomponents, S32 category) ;
  64. static bool checkSize(S32 width, S32 height);
  65. //for server side use only.
  66. // Not currently necessary for LLImageGL, but required in some derived classes,
  67. // so include for compatability
  68. static BOOL create(LLPointer<LLImageGL>& dest, BOOL usemipmaps = TRUE);
  69. static BOOL create(LLPointer<LLImageGL>& dest, U32 width, U32 height, U8 components, BOOL usemipmaps = TRUE);
  70. static BOOL create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, BOOL usemipmaps = TRUE);
  71. public:
  72. LLImageGL(BOOL usemipmaps = TRUE);
  73. LLImageGL(U32 width, U32 height, U8 components, BOOL usemipmaps = TRUE);
  74. LLImageGL(const LLImageRaw* imageraw, BOOL usemipmaps = TRUE);
  75. protected:
  76. virtual ~LLImageGL();
  77. void analyzeAlpha(const void* data_in, S32 w, S32 h);
  78. void calcAlphaChannelOffsetAndStride();
  79. public:
  80. virtual void dump(); // debugging info to llinfos
  81. void setSize(S32 width, S32 height, S32 ncomponents);
  82. void setComponents(S32 ncomponents) { mComponents = (S8)ncomponents ;}
  83. // These 3 functions currently wrap glGenTextures(), glDeleteTextures(), and glTexImage2D() 
  84. // for tracking purposes and will be deprecated in the future
  85. static void generateTextures(S32 numTextures, U32 *textures);
  86. static void deleteTextures(S32 numTextures, U32 *textures);
  87. static void setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels);
  88. BOOL createGLTexture() ;
  89. BOOL createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0, BOOL to_create = TRUE, 
  90. S32 category = sMaxCatagories - 1);
  91. BOOL createGLTexture(S32 discard_level, const U8* data, BOOL data_hasmips = FALSE, S32 usename = 0);
  92. void setImage(const LLImageRaw* imageraw);
  93. void setImage(const U8* data_in, BOOL data_hasmips = FALSE);
  94. BOOL setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update = FALSE);
  95. BOOL setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update = FALSE);
  96. BOOL setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height);
  97. // Read back a raw image for this discard level, if it exists
  98. BOOL readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok) const;
  99. void destroyGLTexture();
  100. void setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, BOOL swap_bytes = FALSE);
  101. void setComponents(S8 ncomponents) { mComponents = ncomponents; }
  102. S32  getDiscardLevel() const { return mCurrentDiscardLevel; }
  103. S32  getMaxDiscardLevel() const { return mMaxDiscardLevel; }
  104. S32  getCurrentWidth() const { return mWidth ;}
  105. S32  getCurrentHeight() const { return mHeight ;}
  106. S32  getWidth(S32 discard_level = -1) const;
  107. S32  getHeight(S32 discard_level = -1) const;
  108. U8  getComponents() const { return mComponents; }
  109. S32  getBytes(S32 discard_level = -1) const;
  110. S32  getMipBytes(S32 discard_level = -1) const;
  111. BOOL getBoundRecently() const;
  112. BOOL isJustBound() const;
  113. LLGLenum getPrimaryFormat() const { return mFormatPrimary; }
  114. LLGLenum getFormatType() const { return mFormatType; }
  115. BOOL getHasGLTexture() const { return mTexName != 0; }
  116. LLGLuint getTexName() const { return mTexName; }
  117. BOOL getIsAlphaMask() const { return mIsMask; }
  118. BOOL getIsResident(BOOL test_now = FALSE); // not const
  119. void setTarget(const LLGLenum target, const LLTexUnit::eTextureType bind_target);
  120. LLTexUnit::eTextureType getTarget(void) const { return mBindTarget; }
  121. bool isGLTextureCreated(void) const { return mGLTextureCreated ; }
  122. void setGLTextureCreated (bool initialized) { mGLTextureCreated = initialized; }
  123. BOOL getUseMipMaps() const { return mUseMipMaps; }
  124. void setUseMipMaps(BOOL usemips) { mUseMipMaps = usemips; }
  125. void updatePickMask(S32 width, S32 height, const U8* data_in);
  126. BOOL getMask(const LLVector2 &tc);
  127. void checkTexSize() const ;
  128. // Sets the addressing mode used to sample the texture 
  129. //  (such as wrapping, mirrored wrapping, and clamp)
  130. // Note: this actually gets set the next time the texture is bound.
  131. void setAddressMode(LLTexUnit::eTextureAddressMode mode);
  132. LLTexUnit::eTextureAddressMode getAddressMode(void) const { return mAddressMode; }
  133. // Sets the filtering options used to sample the texture 
  134. //  (such as point sampling, bilinear interpolation, mipmapping, and anisotropic filtering)
  135. // Note: this actually gets set the next time the texture is bound.
  136. void setFilteringOption(LLTexUnit::eTextureFilterOptions option);
  137. LLTexUnit::eTextureFilterOptions getFilteringOption(void) const { return mFilterOption; }
  138. LLGLenum getTexTarget()const { return mTarget ;}
  139. S8       getDiscardLevelInAtlas()const {return mDiscardLevelInAtlas;}
  140. U32      getTexelsInAtlas()const { return mTexelsInAtlas ;}
  141. U32      getTexelsInGLTexture()const {return mTexelsInGLTexture;}
  142. void init(BOOL usemipmaps);
  143. virtual void cleanup(); // Clean up the LLImageGL so it can be reinitialized.  Be careful when using this in derived class destructors
  144. void setNeedsAlphaAndPickMask(BOOL need_mask);
  145. BOOL preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image);
  146. void postAddToAtlas() ;
  147. public:
  148. // Various GL/Rendering options
  149. S32 mTextureMemory;
  150. mutable F32  mLastBindTime; // last time this was bound, by discard level
  151. private:
  152. LLPointer<LLImageRaw> mSaveData; // used for destroyGL/restoreGL
  153. U8* mPickMask;  //downsampled bitmap approximation of alpha channel.  NULL if no alpha channel
  154. U16 mPickMaskWidth;
  155. U16 mPickMaskHeight;
  156. S8 mUseMipMaps;
  157. S8 mHasExplicitFormat; // If false (default), GL format is f(mComponents)
  158. S8 mAutoGenMips;
  159. BOOL mIsMask;
  160. BOOL mNeedsAlphaAndPickMask;
  161. S8   mAlphaStride ;
  162. S8   mAlphaOffset ;
  163. bool     mGLTextureCreated ;
  164. LLGLuint mTexName;
  165. U16      mWidth;
  166. U16      mHeight;
  167. S8       mCurrentDiscardLevel;
  168. S8       mDiscardLevelInAtlas;
  169. U32      mTexelsInAtlas ;
  170. U32      mTexelsInGLTexture;
  171. protected:
  172. LLGLenum mTarget; // Normally GL_TEXTURE2D, sometimes something else (ex. cube maps)
  173. LLTexUnit::eTextureType mBindTarget; // Normally TT_TEXTURE, sometimes something else (ex. cube maps)
  174. bool mHasMipMaps;
  175. LLGLboolean mIsResident;
  176. S8 mComponents;
  177. S8 mMaxDiscardLevel;
  178. bool mTexOptionsDirty;
  179. LLTexUnit::eTextureAddressMode mAddressMode; // Defaults to TAM_WRAP
  180. LLTexUnit::eTextureFilterOptions mFilterOption; // Defaults to TFO_ANISOTROPIC
  181. LLGLint  mFormatInternal; // = GL internalformat
  182. LLGLenum mFormatPrimary;  // = GL format (pixel data format)
  183. LLGLenum mFormatType;
  184. BOOL  mFormatSwapBytes;// if true, use glPixelStorei(GL_UNPACK_SWAP_BYTES, 1)
  185. // STATICS
  186. public:
  187. static std::set<LLImageGL*> sImageList;
  188. static S32 sCount;
  189. static F32 sLastFrameTime;
  190. static LLGLuint sCurrentBoundTextures[MAX_GL_TEXTURE_UNITS]; // Currently bound texture ID
  191. // Global memory statistics
  192. static S32 sGlobalTextureMemoryInBytes; // Tracks main memory texmem
  193. static S32 sBoundTextureMemoryInBytes; // Tracks bound texmem for last completed frame
  194. static S32 sCurBoundTextureMemory; // Tracks bound texmem for current frame
  195. static U32 sBindCount; // Tracks number of texture binds for current frame
  196. static U32 sUniqueCount; // Tracks number of unique texture binds for current frame
  197. static BOOL sGlobalUseAnisotropic;
  198. static LLImageGL* sDefaultGLTexture ;
  199. static BOOL sAutomatedTest;
  200. #if DEBUG_MISS
  201. BOOL mMissed; // Missed on last bind?
  202. BOOL getMissed() const { return mMissed; };
  203. #else
  204. BOOL getMissed() const { return FALSE; };
  205. #endif
  206. public:
  207. static void initClass(S32 num_catagories) ;
  208. static void cleanupClass() ;
  209. private:
  210. static S32 sMaxCatagories ;
  211. //the flag to allow to call readBackRaw(...).
  212. //can be removed if we do not use that function at all.
  213. static BOOL sAllowReadBackRaw ;
  214. //
  215. //****************************************************************************************************
  216. //The below for texture auditing use only
  217. //****************************************************************************************************
  218. private:
  219. S32 mCategory ;
  220. public:
  221. void setCategory(S32 category) ;
  222. S32  getCategory()const {return mCategory ;}
  223. //for debug use: show texture size distribution 
  224. //----------------------------------------
  225. static LLPointer<LLImageGL> sHighlightTexturep; //default texture to replace normal textures
  226. static std::vector<S32> sTextureLoadedCounter ;
  227. static std::vector<S32> sTextureBoundCounter ;
  228. static std::vector<S32> sTextureCurBoundCounter ;
  229. static S32 sCurTexSizeBar ;
  230. static S32 sCurTexPickSize ;
  231. static void setHighlightTexture(S32 category) ;
  232. static S32 getTextureCounterIndex(U32 val) ;
  233. static void incTextureCounter(U32 val, S32 ncomponents, S32 category) ;
  234. static void decTextureCounter(U32 val, S32 ncomponents, S32 category) ;
  235. static void setCurTexSizebar(S32 index, BOOL set_pick_size = TRUE) ;
  236. static void resetCurTexSizebar();
  237. //----------------------------------------
  238. //for debug use: show texture category distribution 
  239. //----------------------------------------
  240. static std::vector<S32> sTextureMemByCategory;
  241. static std::vector<S32> sTextureMemByCategoryBound ;
  242. static std::vector<S32> sTextureCurMemByCategoryBound ;
  243. //----------------------------------------
  244. //****************************************************************************************************
  245. //End of definitions for texture auditing use only
  246. //****************************************************************************************************
  247. };
  248. extern BOOL gAuditTexture;
  249. #endif // LL_LLIMAGEGL_H