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

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

游戏引擎

开发平台：

C++ Builder

lltextureentry.cpp：源码内容
  1. /** 
  2.  * @file lltextureentry.cpp
  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.  */
  33. #include "linden_common.h"
  35. #include "lluuid.h"
  36. #include "llmediaentry.h"
  37. #include "lltextureentry.h"
  38. #include "llsdutil_math.h"
  39. #include "v4color.h"
  41. const U8 DEFAULT_BUMP_CODE = 0;  // no bump or shininess
  43. const LLTextureEntry LLTextureEntry::null;
  45. // Some LLSD keys.  Do not change these!
  46. #define OBJECT_ID_KEY_STR "object_id"
  47. #define TEXTURE_INDEX_KEY_STR "texture_index"
  48. #define OBJECT_MEDIA_VERSION_KEY_STR "object_media_version"
  49. #define OBJECT_MEDIA_DATA_KEY_STR "object_media_data"
  50. #define TEXTURE_MEDIA_DATA_KEY_STR "media_data"
  52. /*static*/ const char* LLTextureEntry::OBJECT_ID_KEY = OBJECT_ID_KEY_STR;
  53. /*static*/ const char* LLTextureEntry::OBJECT_MEDIA_DATA_KEY = OBJECT_MEDIA_DATA_KEY_STR;
  54. /*static*/ const char* LLTextureEntry::MEDIA_VERSION_KEY = OBJECT_MEDIA_VERSION_KEY_STR;
  55. /*static*/ const char* LLTextureEntry::TEXTURE_INDEX_KEY = TEXTURE_INDEX_KEY_STR;
  56. /*static*/ const char* LLTextureEntry::TEXTURE_MEDIA_DATA_KEY = TEXTURE_MEDIA_DATA_KEY_STR;
  58. static const std::string MEDIA_VERSION_STRING_PREFIX = "x-mv:";
  60. // static 
  61. LLTextureEntry* LLTextureEntry::newTextureEntry()
  62. {
  63. return new LLTextureEntry();
  64. }
  66. //===============================================================
  67. LLTextureEntry::LLTextureEntry()
  68.   : mMediaEntry(NULL)
  69. {
  70. init(LLUUID::null,1.f,1.f,0.f,0.f,0.f,DEFAULT_BUMP_CODE);
  71. }
  73. LLTextureEntry::LLTextureEntry(const LLUUID& tex_id)
  74.   : mMediaEntry(NULL)
  75. {
  76. init(tex_id,1.f,1.f,0.f,0.f,0.f,DEFAULT_BUMP_CODE);
  77. }
  79. LLTextureEntry::LLTextureEntry(const LLTextureEntry &rhs)
  80.   : mMediaEntry(NULL)
  81. {
  82. mID = rhs.mID;
  83. mScaleS = rhs.mScaleS;
  84. mScaleT = rhs.mScaleT;
  85. mOffsetS = rhs.mOffsetS;
  86. mOffsetT = rhs.mOffsetT;
  87. mRotation = rhs.mRotation;
  88. mColor = rhs.mColor;
  89. mBump = rhs.mBump;
  90. mMediaFlags = rhs.mMediaFlags;
  91. mGlow = rhs.mGlow;
  92. if (rhs.mMediaEntry != NULL) {
  93. // Make a copy
  94. mMediaEntry = new LLMediaEntry(*rhs.mMediaEntry);
  95. }
  96. }
  98. LLTextureEntry &LLTextureEntry::operator=(const LLTextureEntry &rhs)
  99. {
  100. if (this != &rhs)
  101. {
  102. mID = rhs.mID;
  103. mScaleS = rhs.mScaleS;
  104. mScaleT = rhs.mScaleT;
  105. mOffsetS = rhs.mOffsetS;
  106. mOffsetT = rhs.mOffsetT;
  107. mRotation = rhs.mRotation;
  108. mColor = rhs.mColor;
  109. mBump = rhs.mBump;
  110. mMediaFlags = rhs.mMediaFlags;
  111. mGlow = rhs.mGlow;
  112. if (mMediaEntry != NULL) {
  113. delete mMediaEntry;
  114. }
  115. if (rhs.mMediaEntry != NULL) {
  116. // Make a copy
  117. mMediaEntry = new LLMediaEntry(*rhs.mMediaEntry);
  118. }
  119. else {
  120. mMediaEntry = NULL;
  121. }
  122. }
  124. return *this;
  125. }
  127. void LLTextureEntry::init(const LLUUID& tex_id, F32 scale_s, F32 scale_t, F32 offset_s, F32 offset_t, F32 rotation, U8 bump)
  128. {
  129. setID(tex_id);
  131. mScaleS = scale_s;
  132. mScaleT = scale_t;
  133. mOffsetS = offset_s;
  134. mOffsetT = offset_t;
  135. mRotation = rotation;
  136. mBump = bump;
  137. mMediaFlags = 0x0;
  138.     mGlow = 0;
  140. setColor(LLColor4(1.f, 1.f, 1.f, 1.f));
  141. if (mMediaEntry != NULL) {
  142.     delete mMediaEntry;
  143. }
  144. mMediaEntry = NULL;
  145. }
  147. LLTextureEntry::~LLTextureEntry()
  148. {
  149. if(mMediaEntry)
  150. {
  151. delete mMediaEntry;
  152. mMediaEntry = NULL;
  153. }
  154. }
  156. bool LLTextureEntry::operator!=(const LLTextureEntry &rhs) const
  157. {
  158. if (mID != rhs.mID) return(true);
  159. if (mScaleS != rhs.mScaleS) return(true);
  160. if (mScaleT != rhs.mScaleT) return(true);
  161. if (mOffsetS != rhs.mOffsetS) return(true);
  162. if (mOffsetT != rhs.mOffsetT) return(true);
  163. if (mRotation != rhs.mRotation) return(true);
  164. if (mColor != rhs.mColor) return (true);
  165. if (mBump != rhs.mBump) return (true);
  166. if (mMediaFlags != rhs.mMediaFlags) return (true);
  167. if (mGlow != rhs.mGlow) return (true);
  168. return(false);
  169. }
  171. bool LLTextureEntry::operator==(const LLTextureEntry &rhs) const
  172. {
  173. if (mID != rhs.mID) return(false);
  174. if (mScaleS != rhs.mScaleS) return(false);
  175. if (mScaleT != rhs.mScaleT) return(false);
  176. if (mOffsetS != rhs.mOffsetS) return(false);
  177. if (mOffsetT != rhs.mOffsetT) return(false);
  178. if (mRotation != rhs.mRotation) return(false);
  179. if (mColor != rhs.mColor) return (false);
  180. if (mBump != rhs.mBump) return (false);
  181. if (mMediaFlags != rhs.mMediaFlags) return false;
  182. if (mGlow != rhs.mGlow) return false;
  183. return(true);
  184. }
  186. LLSD LLTextureEntry::asLLSD() const
  187. {
  188. LLSD sd;
  189. asLLSD(sd);
  190. return sd;
  191. }
  193. void LLTextureEntry::asLLSD(LLSD& sd) const
  194. {
  195. sd["imageid"] = mID;
  196. sd["colors"] = ll_sd_from_color4(mColor);
  197. sd["scales"] = mScaleS;
  198. sd["scalet"] = mScaleT;
  199. sd["offsets"] = mOffsetS;
  200. sd["offsett"] = mOffsetT;
  201. sd["imagerot"] = mRotation;
  202. sd["bump"] = getBumpShiny();
  203. sd["fullbright"] = getFullbright();
  204. sd["media_flags"] = mMediaFlags;
  205. if (hasMedia()) {
  206. LLSD mediaData;
  207.         if (NULL != getMediaData()) {
  208.             getMediaData()->asLLSD(mediaData);
  209.         }
  210. sd[TEXTURE_MEDIA_DATA_KEY] = mediaData;
  211. }
  212. sd["glow"] = mGlow;
  213. }
  215. bool LLTextureEntry::fromLLSD(const LLSD& sd)
  216. {
  217. const char *w, *x;
  218. w = "imageid";
  219. if (sd.has(w))
  220. {
  221. setID( sd[w] );
  222. } else goto fail;
  223. w = "colors";
  224. if (sd.has(w))
  225. {
  226. setColor( ll_color4_from_sd(sd["colors"]) );
  227. } else goto fail;
  228. w = "scales";
  229. x = "scalet";
  230. if (sd.has(w) && sd.has(x))
  231. {
  232. setScale( (F32)sd[w].asReal(), (F32)sd[x].asReal() );
  233. } else goto fail;
  234. w = "offsets";
  235. x = "offsett";
  236. if (sd.has(w) && sd.has(x))
  237. {
  238. setOffset( (F32)sd[w].asReal(), (F32)sd[x].asReal() );
  239. } else goto fail;
  240. w = "imagerot";
  241. if (sd.has(w))
  242. {
  243. setRotation( (F32)sd[w].asReal() );
  244. } else goto fail;
  245. w = "bump";
  246. if (sd.has(w))
  247. {
  248. setBumpShiny( sd[w].asInteger() );
  249. } else goto fail;
  250. w = "fullbright";
  251. if (sd.has(w))
  252. {
  253. setFullbright( sd[w].asInteger() );
  254. } else goto fail;
  255. w = "media_flags";
  256. if (sd.has(w))
  257. {
  258. setMediaTexGen( sd[w].asInteger() );
  259. } else goto fail;
  260. // If the "has media" flag doesn't match the fact that 
  261. // media data exists, updateMediaData will "fix" it
  262. // by either clearing or setting the flag
  263. w = TEXTURE_MEDIA_DATA_KEY;
  264. if (hasMedia() != sd.has(w))
  265. {
  266. llwarns << "LLTextureEntry::fromLLSD: media_flags (" << hasMedia() <<
  267. ") does not match presence of media_data (" << sd.has(w) << ").  Fixing." << llendl;
  268. }
  269. updateMediaData(sd[w]);
  271. w = "glow";
  272. if (sd.has(w))
  273. {
  274. setGlow((F32)sd[w].asReal() );
  275. }
  277. return true;
  278. fail:
  279. return false;
  280. }
  282. // virtual 
  283. // override this method for each derived class
  284. LLTextureEntry* LLTextureEntry::newBlank() const
  285. {
  286. return new LLTextureEntry();
  287. }
  289. // virtual 
  290. LLTextureEntry* LLTextureEntry::newCopy() const
  291. {
  292. return new LLTextureEntry(*this);
  293. }
  295. S32 LLTextureEntry::setID(const LLUUID &tex_id)
  296. {
  297. if (mID != tex_id)
  298. {
  299. mID = tex_id;
  300. return TEM_CHANGE_TEXTURE;
  301. }
  302. return TEM_CHANGE_NONE;
  303. }
  305. S32 LLTextureEntry::setScale(F32 s, F32 t)
  306. {
  307. S32 retval = 0;
  309. if (  (mScaleS != s)
  310. ||(mScaleT != t))
  311. {
  312. mScaleS = s;
  313. mScaleT = t;
  315. retval = TEM_CHANGE_TEXTURE;
  316. }
  317. return retval;
  318. }
  320. S32 LLTextureEntry::setScaleS(F32 s)
  321. {
  322. S32 retval = TEM_CHANGE_NONE;
  323. if (mScaleS != s)
  324. {
  325. mScaleS = s;
  326. retval = TEM_CHANGE_TEXTURE;
  327. }
  328. return retval;
  329. }
  331. S32 LLTextureEntry::setScaleT(F32 t)
  332. {
  333. S32 retval = TEM_CHANGE_NONE;
  334. if (mScaleT != t)
  335. {
  336. mScaleT = t;
  337. retval = TEM_CHANGE_TEXTURE;
  338. }
  339. return retval;
  340. }
  342. S32 LLTextureEntry::setColor(const LLColor4 &color)
  343. {
  344. if (mColor != color)
  345. {
  346. mColor = color;
  347. return TEM_CHANGE_COLOR;
  348. }
  349. return TEM_CHANGE_NONE;
  350. }
  352. S32 LLTextureEntry::setColor(const LLColor3 &color)
  353. {
  354. if (mColor != color)
  355. {
  356. // This preserves alpha.
  357. mColor.setVec(color);
  358. return TEM_CHANGE_COLOR;
  359. }
  360. return TEM_CHANGE_NONE;
  361. }
  363. S32 LLTextureEntry::setAlpha(const F32 alpha)
  364. {
  365. if (mColor.mV[VW] != alpha)
  366. {
  367. mColor.mV[VW] = alpha;
  368. return TEM_CHANGE_COLOR;
  369. }
  370. return TEM_CHANGE_NONE;
  371. }
  373. S32 LLTextureEntry::setOffset(F32 s, F32 t)
  374. {
  375. S32 retval = 0;
  377. if (  (mOffsetS != s)
  378. ||(mOffsetT != t))
  379. {
  380. mOffsetS = s;
  381. mOffsetT = t;
  383. retval = TEM_CHANGE_TEXTURE;
  384. }
  385. return retval;
  386. }
  388. S32 LLTextureEntry::setOffsetS(F32 s)
  389. {
  390. S32 retval = 0;
  391. if (mOffsetS != s)
  392. {
  393. mOffsetS = s;
  394. retval = TEM_CHANGE_TEXTURE;
  395. }
  396. return retval;
  397. }
  399. S32 LLTextureEntry::setOffsetT(F32 t)
  400. {
  401. S32 retval = 0;
  402. if (mOffsetT != t)
  403. {
  404. mOffsetT = t;
  405. retval = TEM_CHANGE_TEXTURE;
  406. }
  407. return retval;
  408. }
  410. S32 LLTextureEntry::setRotation(F32 theta)
  411. {
  412. if (mRotation != theta)
  413. {
  414. mRotation = theta;
  415. return TEM_CHANGE_TEXTURE;
  416. }
  417. return TEM_CHANGE_NONE;
  418. }
  420. S32 LLTextureEntry::setBumpShinyFullbright(U8 bump)
  421. {
  422. if (mBump != bump)
  423. {
  424. mBump = bump;
  425. return TEM_CHANGE_TEXTURE;
  426. }
  427. return TEM_CHANGE_NONE;
  428. }
  430. S32 LLTextureEntry::setMediaTexGen(U8 media)
  431. {
  432. if (mMediaFlags != media)
  433. {
  434. mMediaFlags = media;
  436. // Special code for media handling
  437. if( hasMedia() && mMediaEntry == NULL)
  438. {
  439. mMediaEntry = new LLMediaEntry;
  440. }
  441.         else if ( ! hasMedia() && mMediaEntry != NULL)
  442.         {
  443.             delete mMediaEntry;
  444.             mMediaEntry = NULL;
  445.         }
  447. return TEM_CHANGE_MEDIA;
  448. }
  449. return TEM_CHANGE_NONE;
  450. }
  452. S32 LLTextureEntry::setBumpmap(U8 bump)
  453. {
  454. bump &= TEM_BUMP_MASK;
  455. if (getBumpmap() != bump)
  456. {
  457. mBump &= ~TEM_BUMP_MASK;
  458. mBump |= bump;
  459. return TEM_CHANGE_TEXTURE;
  460. }
  461. return TEM_CHANGE_NONE;
  462. }
  464. S32 LLTextureEntry::setFullbright(U8 fullbright)
  465. {
  466. fullbright &= TEM_FULLBRIGHT_MASK;
  467. if (getFullbright() != fullbright)
  468. {
  469. mBump &= ~(TEM_FULLBRIGHT_MASK<<TEM_FULLBRIGHT_SHIFT);
  470. mBump |= fullbright << TEM_FULLBRIGHT_SHIFT;
  471. return TEM_CHANGE_TEXTURE;
  472. }
  473. return TEM_CHANGE_NONE;
  474. }
  476. S32 LLTextureEntry::setShiny(U8 shiny)
  477. {
  478. shiny &= TEM_SHINY_MASK;
  479. if (getShiny() != shiny)
  480. {
  481. mBump &= ~(TEM_SHINY_MASK<<TEM_SHINY_SHIFT);
  482. mBump |= shiny << TEM_SHINY_SHIFT;
  483. return TEM_CHANGE_TEXTURE;
  484. }
  485. return TEM_CHANGE_NONE;
  486. }
  488. S32 LLTextureEntry::setBumpShiny(U8 bump_shiny)
  489. {
  490. bump_shiny &= TEM_BUMP_SHINY_MASK;
  491. if (getBumpShiny() != bump_shiny)
  492. {
  493. mBump &= ~TEM_BUMP_SHINY_MASK;
  494. mBump |= bump_shiny;
  495. return TEM_CHANGE_TEXTURE;
  496. }
  497. return TEM_CHANGE_NONE;
  498. }
  500. S32 LLTextureEntry::setMediaFlags(U8 media_flags)
  501. {
  502. media_flags &= TEM_MEDIA_MASK;
  503. if (getMediaFlags() != media_flags)
  504. {
  505. mMediaFlags &= ~TEM_MEDIA_MASK;
  506. mMediaFlags |= media_flags;
  507.         
  508. // Special code for media handling
  509. if( hasMedia() && mMediaEntry == NULL)
  510. {
  511. mMediaEntry = new LLMediaEntry;
  512. }
  513.         else if ( ! hasMedia() && mMediaEntry != NULL)
  514.         {
  515.             delete mMediaEntry;
  516.             mMediaEntry = NULL;
  517.         }
  518.         
  519. return TEM_CHANGE_MEDIA;
  520. }
  521. return TEM_CHANGE_NONE;
  522. }
  524. S32 LLTextureEntry::setTexGen(U8 tex_gen)
  525. {
  526. tex_gen &= TEM_TEX_GEN_MASK;
  527. if (getTexGen() != tex_gen)
  528. {
  529. mMediaFlags &= ~TEM_TEX_GEN_MASK;
  530. mMediaFlags |= tex_gen;
  531. return TEM_CHANGE_TEXTURE;
  532. }
  533. return TEM_CHANGE_NONE;
  534. }
  536. S32 LLTextureEntry::setGlow(F32 glow)
  537. {
  538. if (mGlow != glow)
  539. {
  540. mGlow = glow;
  541. return TEM_CHANGE_TEXTURE;
  542. }
  543. return TEM_CHANGE_NONE;
  544. }
  546. void LLTextureEntry::setMediaData(const LLMediaEntry &media_entry)
  547. {
  548.     mMediaFlags |= MF_HAS_MEDIA;
  549.     if (NULL != mMediaEntry)
  550.     {
  551.         delete mMediaEntry;
  552.     }
  553.     mMediaEntry = new LLMediaEntry(media_entry);
  554. }
  556. bool LLTextureEntry::updateMediaData(const LLSD& media_data)
  557. {
  558. if (media_data.isUndefined())
  559. {
  560. // clear the media data
  561.         clearMediaData();
  562. return false;
  563. }
  564. else {
  565. mMediaFlags |= MF_HAS_MEDIA;
  566. if (mMediaEntry == NULL)
  567. {
  568. mMediaEntry = new LLMediaEntry;
  569. }
  570.         // *NOTE: this will *clobber* all of the fields in mMediaEntry 
  571.         // with whatever fields are present (or not present) in media_data!
  572.   mMediaEntry->fromLLSD(media_data);
  573. return true;
  574. }
  575. }
  577. void LLTextureEntry::clearMediaData()
  578. {
  579.     mMediaFlags &= ~MF_HAS_MEDIA;
  580.     if (mMediaEntry != NULL) {
  581.         delete mMediaEntry;
  582.     }
  583.     mMediaEntry = NULL;
  584. }    
  586. void LLTextureEntry::mergeIntoMediaData(const LLSD& media_fields)
  587. {
  588.     mMediaFlags |= MF_HAS_MEDIA;
  589.     if (mMediaEntry == NULL)
  590.     {
  591.         mMediaEntry = new LLMediaEntry;
  592.     }
  593.     // *NOTE: this will *merge* the data in media_fields
  594.     // with the data in our media entry
  595.     mMediaEntry->mergeFromLLSD(media_fields);
  596. }
  598. //static
  599. std::string LLTextureEntry::touchMediaVersionString(const std::string &in_version, const LLUUID &agent_id)
  600. {
  601.     // XXX TODO: make media version string binary (base64-encoded?)
  602.     // Media "URL" is a representation of a version and the last-touched agent
  603.     // x-mv:nnnnn/agent-id
  604.     // where "nnnnn" is version number
  605.     // *NOTE: not the most efficient code in the world...
  606.     U32 current_version = getVersionFromMediaVersionString(in_version) + 1;
  607.     const size_t MAX_VERSION_LEN = 10; // 2^32 fits in 10 decimal digits
  608.     char buf[MAX_VERSION_LEN+1];
  609.     snprintf(buf, (int)MAX_VERSION_LEN+1, "%0*u", (int)MAX_VERSION_LEN, current_version);  // added int cast to fix warning/breakage on mac.
  610.     return MEDIA_VERSION_STRING_PREFIX + buf + "/" + agent_id.asString();
  611. }
  613. //static
  614. U32 LLTextureEntry::getVersionFromMediaVersionString(const std::string &version_string)
  615. {
  616.     U32 version = 0;
  617.     if (!version_string.empty()) 
  618.     {
  619.         size_t found = version_string.find(MEDIA_VERSION_STRING_PREFIX);
  620.         if (found != std::string::npos) 
  621.         {
  622.             found = version_string.find_first_of("/", found);
  623.             std::string v = version_string.substr(MEDIA_VERSION_STRING_PREFIX.length(), found);
  624.             version = strtoul(v.c_str(),NULL,10);
  625.         }
  626.     }
  627.     return version;
  628. }
  630. //static
  631. LLUUID LLTextureEntry::getAgentIDFromMediaVersionString(const std::string &version_string)
  632. {
  633.     LLUUID id;
  634.     if (!version_string.empty()) 
  635.     {
  636.         size_t found = version_string.find(MEDIA_VERSION_STRING_PREFIX);
  637.         if (found != std::string::npos) 
  638.         {
  639.             found = version_string.find_first_of("/", found);
  640.             if (found != std::string::npos) 
  641.             {
  642.                 std::string v = version_string.substr(found + 1);
  643.                 id.set(v);
  644.             }
  645.         }
  646.     }
  647.     return id;
  648. }
  650. //static
  651. bool LLTextureEntry::isMediaVersionString(const std::string &version_string)
  652. {
  653. return std::string::npos != version_string.find(MEDIA_VERSION_STRING_PREFIX);
  654. }