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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file lltextureentry.h
  3.  * @brief LLTextureEntry base class
  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_LLTEXTUREENTRY_H
  33. #define LL_LLTEXTUREENTRY_H
  34. #include "lluuid.h"
  35. #include "v4color.h"
  36. #include "llsd.h"
  37. // These bits are used while unpacking TEM messages to tell which aspects of
  38. // the texture entry changed.
  39. const S32 TEM_CHANGE_NONE = 0x0;
  40. const S32 TEM_CHANGE_COLOR = 0x1;
  41. const S32 TEM_CHANGE_TEXTURE = 0x2;
  42. const S32 TEM_CHANGE_MEDIA = 0x4;
  43. const S32 TEM_INVALID = 0x8;
  44. const S32 TEM_BUMPMAP_COUNT = 32;
  45. // The Bump Shiny Fullbright values are bits in an eight bit field:
  46. // +----------+
  47. // | SSFBBBBB | S = Shiny, F = Fullbright, B = Bumpmap
  48. // | 76543210 |
  49. // +----------+
  50. const S32 TEM_BUMP_MASK  = 0x1f; // 5 bits
  51. const S32 TEM_FULLBRIGHT_MASK  = 0x01; // 1 bit
  52. const S32 TEM_SHINY_MASK  = 0x03; // 2 bits
  53. const S32 TEM_BUMP_SHINY_MASK  = (0xc0 | 0x1f);
  54. const S32 TEM_FULLBRIGHT_SHIFT  = 5;
  55. const S32 TEM_SHINY_SHIFT  = 6;
  56. // The Media Tex Gen values are bits in a bit field:
  57. // +----------+
  58. // | .....TTM | M = Media Flags (web page), T = LLTextureEntry::eTexGen, . = unused
  59. // | 76543210 |
  60. // +----------+
  61. const S32 TEM_MEDIA_MASK = 0x01;
  62. const S32 TEM_TEX_GEN_MASK = 0x06;
  63. const S32 TEM_TEX_GEN_SHIFT = 1;
  64. // forward declarations
  65. class LLMediaEntry;
  66. class LLTextureEntry
  67. {
  68. public:
  69. static LLTextureEntry* newTextureEntry();
  70. typedef enum e_texgen
  71. {
  72. TEX_GEN_DEFAULT = 0x00,
  73. TEX_GEN_PLANAR = 0x02,
  74. TEX_GEN_SPHERICAL = 0x04,
  75. TEX_GEN_CYLINDRICAL = 0x06
  76. } eTexGen;
  77. LLTextureEntry();
  78. LLTextureEntry(const LLUUID& tex_id);
  79. LLTextureEntry(const LLTextureEntry &rhs);
  80. LLTextureEntry &operator=(const LLTextureEntry &rhs);
  81.     virtual ~LLTextureEntry();
  82. bool operator==(const LLTextureEntry &rhs) const;
  83. bool operator!=(const LLTextureEntry &rhs) const;
  84. LLSD asLLSD() const;
  85. void asLLSD(LLSD& sd) const;
  86. operator LLSD() const { return asLLSD(); }
  87. bool fromLLSD(const LLSD& sd);
  88. virtual LLTextureEntry* newBlank() const;
  89. virtual LLTextureEntry* newCopy() const;
  90. void init(const LLUUID& tex_id, F32 scale_s, F32 scale_t, F32 offset_s, F32 offset_t, F32 rotation, U8 bump);
  91. // These return a TEM_ flag from above to indicate if something changed.
  92. S32  setID (const LLUUID &tex_id);
  93. S32  setColor(const LLColor4 &color);
  94. S32  setColor(const LLColor3 &color);
  95. S32  setAlpha(const F32 alpha);
  96. S32  setScale(F32 s, F32 t);
  97. S32  setScaleS(F32 s);
  98. S32  setScaleT(F32 t);
  99. S32  setOffset(F32 s, F32 t);
  100. S32  setOffsetS(F32 s);
  101. S32  setOffsetT(F32 t);
  102. S32  setRotation(F32 theta);
  103. S32  setBumpmap(U8 bump);
  104. S32  setFullbright(U8 bump);
  105. S32  setShiny(U8 bump);
  106. S32  setBumpShiny(U8 bump);
  107.   S32  setBumpShinyFullbright(U8 bump);
  108. S32  setMediaFlags(U8 media_flags);
  109. S32  setTexGen(U8 texGen);
  110. S32  setMediaTexGen(U8 media);
  111.     S32  setGlow(F32 glow);
  112. virtual const LLUUID &getID() const { return mID; }
  113. const LLColor4 &getColor() const { return mColor; }
  114. void getScale(F32 *s, F32 *t) const { *s = mScaleS; *t = mScaleT; }
  115. void getOffset(F32 *s, F32 *t) const { *s = mOffsetS; *t = mOffsetT; }
  116. F32  getRotation() const { return mRotation; }
  117. void getRotation(F32 *theta) const { *theta = mRotation; }
  118. U8  getBumpmap() const { return mBump & TEM_BUMP_MASK; }
  119. U8  getFullbright() const { return (mBump>>TEM_FULLBRIGHT_SHIFT) & TEM_FULLBRIGHT_MASK; }
  120. U8  getShiny() const { return (mBump>>TEM_SHINY_SHIFT) & TEM_SHINY_MASK; }
  121. U8  getBumpShiny() const { return mBump & TEM_BUMP_SHINY_MASK; }
  122.   U8  getBumpShinyFullbright() const { return mBump; }
  123. U8  getMediaFlags() const { return mMediaFlags & TEM_MEDIA_MASK; }
  124. U8  getTexGen() const { return mMediaFlags & TEM_TEX_GEN_MASK; }
  125. U8  getMediaTexGen() const { return mMediaFlags; }
  126.     F32  getGlow() const { return mGlow; }
  127.     // *NOTE: it is possible for hasMedia() to return true, but getMediaData() to return NULL.
  128.     // CONVERSELY, it is also possible for hasMedia() to return false, but getMediaData()
  129.     // to NOT return NULL.  
  130. bool hasMedia() const { return (bool)(mMediaFlags & MF_HAS_MEDIA); } 
  131. LLMediaEntry* getMediaData() const { return mMediaEntry; }
  132.     // Completely change the media data on this texture entry.
  133.     void setMediaData(const LLMediaEntry &media_entry);
  134. // Returns true if media data was updated, false if it was cleared
  135. bool updateMediaData(const LLSD& media_data);
  136.     // Clears media data, and sets the media flags bit to 0
  137.     void clearMediaData();
  138.     // Merges the given LLSD of media fields with this media entry.
  139.     // Only those fields that are set that match the keys in
  140.     // LLMediaEntry will be affected.  If no fields are set or if
  141.     // the LLSD is undefined, this is a no-op.
  142.     void mergeIntoMediaData(const LLSD& media_fields);
  143.     // Takes a media version string (an empty string or a previously-returned string)
  144.     // and returns a "touched" string, touched by agent_id
  145.     static std::string touchMediaVersionString(const std::string &in_version, const LLUUID &agent_id);
  146.     // Given a media version string, return the version
  147.     static U32 getVersionFromMediaVersionString(const std::string &version_string);
  148.     // Given a media version string, return the UUID of the agent
  149.     static LLUUID getAgentIDFromMediaVersionString(const std::string &version_string);
  150. // Return whether or not the given string is actually a media version
  151. static bool isMediaVersionString(const std::string &version_string);
  152. // Media flags
  153. enum { MF_NONE = 0x0, MF_HAS_MEDIA = 0x1 };
  154. public:
  155. F32                 mScaleS;                // S, T offset
  156. F32                 mScaleT;                // S, T offset
  157. F32                 mOffsetS;               // S, T offset
  158. F32                 mOffsetT;               // S, T offset
  159. F32                 mRotation;              // anti-clockwise rotation in rad about the bottom left corner
  160. static const LLTextureEntry null;
  161. // LLSD key defines
  162. static const char* OBJECT_ID_KEY;
  163. static const char* OBJECT_MEDIA_DATA_KEY;
  164.     static const char* MEDIA_VERSION_KEY;
  165. static const char* TEXTURE_INDEX_KEY;
  166. static const char* TEXTURE_MEDIA_DATA_KEY;
  167. protected:
  168. LLUUID mID; // Texture GUID
  169. LLColor4 mColor;
  170. U8 mBump; // Bump map, shiny, and fullbright
  171. U8 mMediaFlags; // replace with web page, movie, etc.
  172. F32                 mGlow;
  173. // Note the media data is not sent via the same message structure as the rest of the TE
  174. LLMediaEntry* mMediaEntry; // The media data for the face
  175. // NOTE: when adding new data to this class, in addition to adding it to the serializers asLLSD/fromLLSD and the
  176. // message packers (e.g. LLPrimitive::packTEMessage) you must also implement its copy in LLPrimitive::copyTEs()
  177. };
  178. #endif