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

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

游戏引擎

开发平台：

C++ Builder

llprimitive.cpp：源码内容
  1. /** 
  2.  * @file llprimitive.cpp
  3.  * @brief LLPrimitive 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 "material_codes.h"
  36. #include "llmemtype.h"
  37. #include "llerror.h"
  38. #include "message.h"
  39. #include "llprimitive.h"
  40. #include "llvolume.h"
  41. #include "legacy_object_types.h"
  42. #include "v4coloru.h"
  43. #include "llvolumemgr.h"
  44. #include "llstring.h"
  45. #include "lldatapacker.h"
  46. #include "llsdutil_math.h"
  47. #include "llprimtexturelist.h"
  49. /**
  50.  * exported constants
  51.  */
  53. const F32 OBJECT_CUT_MIN = 0.f;
  54. const F32 OBJECT_CUT_MAX = 1.f;
  55. const F32 OBJECT_CUT_INC = 0.05f;
  56. const F32 OBJECT_MIN_CUT_INC = 0.02f;
  57. const F32 OBJECT_ROTATION_PRECISION = 0.05f;
  59. const F32 OBJECT_TWIST_MIN = -360.f;
  60. const F32 OBJECT_TWIST_MAX =  360.f;
  61. const F32 OBJECT_TWIST_INC =   18.f;
  63. // This is used for linear paths,
  64. // since twist is used in a slightly different manner.
  65. const F32 OBJECT_TWIST_LINEAR_MIN = -180.f;
  66. const F32 OBJECT_TWIST_LINEAR_MAX =  180.f;
  67. const F32 OBJECT_TWIST_LINEAR_INC =    9.f;
  69. const F32 OBJECT_MIN_HOLE_SIZE = 0.05f;
  70. const F32 OBJECT_MAX_HOLE_SIZE_X = 1.0f;
  71. const F32 OBJECT_MAX_HOLE_SIZE_Y = 0.5f;
  73. // Revolutions parameters.
  74. const F32 OBJECT_REV_MIN = 1.0f;
  75. const F32 OBJECT_REV_MAX = 4.0f;
  76. const F32 OBJECT_REV_INC = 0.1f;
  78. // lights
  79. const F32 LIGHT_MIN_RADIUS = 0.0f;
  80. const F32 LIGHT_DEFAULT_RADIUS = 5.0f;
  81. const F32 LIGHT_MAX_RADIUS = 20.0f;
  82. const F32 LIGHT_MIN_FALLOFF = 0.0f;
  83. const F32 LIGHT_DEFAULT_FALLOFF = 1.0f;
  84. const F32 LIGHT_MAX_FALLOFF = 2.0f;
  85. const F32 LIGHT_MIN_CUTOFF = 0.0f;
  86. const F32 LIGHT_DEFAULT_CUTOFF = 0.0f;
  87. const F32 LIGHT_MAX_CUTOFF = 180.f;
  89. // "Tension" => [0,10], increments of 0.1
  90. const F32 FLEXIBLE_OBJECT_MIN_TENSION = 0.0f;
  91. const F32 FLEXIBLE_OBJECT_DEFAULT_TENSION = 1.0f;
  92. const F32 FLEXIBLE_OBJECT_MAX_TENSION = 10.0f; 
  94. // "Drag" => [0,10], increments of 0.1
  95. const F32 FLEXIBLE_OBJECT_MIN_AIR_FRICTION = 0.0f;
  96. const F32 FLEXIBLE_OBJECT_DEFAULT_AIR_FRICTION = 2.0f;
  97. const F32 FLEXIBLE_OBJECT_MAX_AIR_FRICTION = 10.0f;
  99. // "Gravity" = [-10,10], increments of 0.1
  100. const F32 FLEXIBLE_OBJECT_MIN_GRAVITY = -10.0f;
  101. const F32 FLEXIBLE_OBJECT_DEFAULT_GRAVITY = 0.3f;
  102. const F32 FLEXIBLE_OBJECT_MAX_GRAVITY = 10.0f;
  104. // "Wind" = [0,10], increments of 0.1
  105. const F32 FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY = 0.0f;
  106. const F32 FLEXIBLE_OBJECT_DEFAULT_WIND_SENSITIVITY = 0.0f;
  107. const F32 FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY = 10.0f;
  109. // I'll explain later...
  110. const F32 FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE = 0.99f; 
  112. const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH = 1.0f;
  113. const BOOL FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE = FALSE;
  114. const BOOL FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE = FALSE;
  116. const S32 MAX_FACE_BITS = 9;
  118. const char *SCULPT_DEFAULT_TEXTURE = "be293869-d0d9-0a69-5989-ad27f1946fd4"; // old inverted texture: "7595d345-a24c-e7ef-f0bd-78793792133e";
  120. // Texture rotations are sent over the wire as a S16.  This is used to scale the actual float
  121. // value to a S16.   Don't use 7FFF as it introduces some odd rounding with 180 since it 
  122. // can't be divided by 2.   See DEV-19108
  123. const F32 TEXTURE_ROTATION_PACK_FACTOR = ((F32) 0x08000);
  125. //static 
  126. // LEGACY: by default we use the LLVolumeMgr::gVolumeMgr global
  127. // TODO -- eliminate this global from the codebase!
  128. LLVolumeMgr* LLPrimitive::sVolumeManager = NULL;
  130. // static
  131. void LLPrimitive::setVolumeManager( LLVolumeMgr* volume_manager )
  132. {
  133. if ( !volume_manager || sVolumeManager )
  134. {
  135. llerrs << "LLPrimitive::sVolumeManager attempting to be set to NULL or it already has been set." << llendl;
  136. }
  137. sVolumeManager = volume_manager;
  138. }
  140. // static
  141. bool LLPrimitive::cleanupVolumeManager()
  142. {
  143. BOOL res = FALSE;
  144. if (sVolumeManager) 
  145. {
  146. res = sVolumeManager->cleanup();
  147. delete sVolumeManager;
  148. sVolumeManager = NULL;
  149. }
  150. return res;
  151. }
  154. //===============================================================
  155. LLPrimitive::LLPrimitive()
  156. : mTextureList(),
  157. mNumTEs(0),
  158. mMiscFlags(0)
  159. {
  160. mPrimitiveCode = 0;
  162. mMaterial = LL_MCODE_STONE;
  163. mVolumep  = NULL;
  165. mChanged  = UNCHANGED;
  167. mPosition.setVec(0.f,0.f,0.f);
  168. mVelocity.setVec(0.f,0.f,0.f);
  169. mAcceleration.setVec(0.f,0.f,0.f);
  171. mRotation.loadIdentity();
  172. mAngularVelocity.setVec(0.f,0.f,0.f);
  174. mScale.setVec(1.f,1.f,1.f);
  175. }
  177. //===============================================================
  178. LLPrimitive::~LLPrimitive()
  179. {
  180. clearTextureList();
  181. // Cleanup handled by volume manager
  182. if (mVolumep)
  183. {
  184. sVolumeManager->unrefVolume(mVolumep);
  185. }
  186. mVolumep = NULL;
  187. }
  189. void LLPrimitive::clearTextureList()
  190. {
  191. }
  193. //===============================================================
  194. // static
  195. LLPrimitive *LLPrimitive::createPrimitive(LLPCode p_code)
  196. {
  197. LLMemType m1(LLMemType::MTYPE_PRIMITIVE);
  198. LLPrimitive *retval = new LLPrimitive();
  200. if (retval)
  201. {
  202. retval->init_primitive(p_code);
  203. }
  204. else
  205. {
  206. llerrs << "primitive allocation failed" << llendl;
  207. }
  209. return retval;
  210. }
  212. //===============================================================
  213. void LLPrimitive::init_primitive(LLPCode p_code)
  214. {
  215. LLMemType m1(LLMemType::MTYPE_PRIMITIVE);
  216. clearTextureList();
  217. mPrimitiveCode = p_code;
  218. }
  220. void LLPrimitive::setPCode(const U8 p_code)
  221. {
  222. mPrimitiveCode = p_code;
  223. }
  225. //===============================================================
  226. LLTextureEntry* LLPrimitive::getTE(const U8 index) const
  227. {
  228. return mTextureList.getTexture(index);
  229. }
  231. //===============================================================
  232. void LLPrimitive::setNumTEs(const U8 num_tes)
  233. {
  234. mTextureList.setSize(num_tes);
  235. }
  237. //===============================================================
  238. void  LLPrimitive::setAllTETextures(const LLUUID &tex_id)
  239. {
  240. mTextureList.setAllIDs(tex_id);
  241. }
  243. //===============================================================
  244. void LLPrimitive::setTE(const U8 index, const LLTextureEntry& te)
  245. {
  246. mTextureList.copyTexture(index, te);
  247. }
  249. S32  LLPrimitive::setTETexture(const U8 index, const LLUUID &id)
  250. {
  251. return mTextureList.setID(index, id);
  252. }
  254. S32  LLPrimitive::setTEColor(const U8 index, const LLColor4 &color)
  255. {
  256. return mTextureList.setColor(index, color);
  257. }
  259. S32  LLPrimitive::setTEColor(const U8 index, const LLColor3 &color)
  260. {
  261. return mTextureList.setColor(index, color);
  262. }
  264. S32  LLPrimitive::setTEAlpha(const U8 index, const F32 alpha)
  265. {
  266. return mTextureList.setAlpha(index, alpha);
  267. }
  269. //===============================================================
  270. S32  LLPrimitive::setTEScale(const U8 index, const F32 s, const F32 t)
  271. {
  272. return mTextureList.setScale(index, s, t);
  273. }
  276. // BUG: slow - done this way because texture entries have some
  277. // voodoo related to texture coords
  278. S32 LLPrimitive::setTEScaleS(const U8 index, const F32 s)
  279. {
  280. return mTextureList.setScaleS(index, s);
  281. }
  284. // BUG: slow - done this way because texture entries have some
  285. // voodoo related to texture coords
  286. S32 LLPrimitive::setTEScaleT(const U8 index, const F32 t)
  287. {
  288. return mTextureList.setScaleT(index, t);
  289. }
  292. //===============================================================
  293. S32  LLPrimitive::setTEOffset(const U8 index, const F32 s, const F32 t)
  294. {
  295. return mTextureList.setOffset(index, s, t);
  296. }
  299. // BUG: slow - done this way because texture entries have some
  300. // voodoo related to texture coords
  301. S32 LLPrimitive::setTEOffsetS(const U8 index, const F32 s)
  302. {
  303. return mTextureList.setOffsetS(index, s);
  304. }
  307. // BUG: slow - done this way because texture entries have some
  308. // voodoo related to texture coords
  309. S32 LLPrimitive::setTEOffsetT(const U8 index, const F32 t)
  310. {
  311. return mTextureList.setOffsetT(index, t);
  312. }
  315. //===============================================================
  316. S32  LLPrimitive::setTERotation(const U8 index, const F32 r)
  317. {
  318. return mTextureList.setRotation(index, r);
  319. }
  322. //===============================================================
  323. S32  LLPrimitive::setTEBumpShinyFullbright(const U8 index, const U8 bump)
  324. {
  325. return mTextureList.setBumpShinyFullbright(index, bump);
  326. }
  328. S32  LLPrimitive::setTEMediaTexGen(const U8 index, const U8 media)
  329. {
  330. return mTextureList.setMediaTexGen(index, media);
  331. }
  333. S32  LLPrimitive::setTEBumpmap(const U8 index, const U8 bump)
  334. {
  335. return mTextureList.setBumpMap(index, bump);
  336. }
  338. S32  LLPrimitive::setTEBumpShiny(const U8 index, const U8 bump_shiny)
  339. {
  340. return mTextureList.setBumpShiny(index, bump_shiny);
  341. }
  343. S32  LLPrimitive::setTETexGen(const U8 index, const U8 texgen)
  344. {
  345. return mTextureList.setTexGen(index, texgen);
  346. }
  348. S32  LLPrimitive::setTEShiny(const U8 index, const U8 shiny)
  349. {
  350. return mTextureList.setShiny(index, shiny);
  351. }
  353. S32  LLPrimitive::setTEFullbright(const U8 index, const U8 fullbright)
  354. {
  355. return mTextureList.setFullbright(index, fullbright);
  356. }
  358. S32  LLPrimitive::setTEMediaFlags(const U8 index, const U8 media_flags)
  359. {
  360. return mTextureList.setMediaFlags(index, media_flags);
  361. }
  363. S32 LLPrimitive::setTEGlow(const U8 index, const F32 glow)
  364. {
  365. return mTextureList.setGlow(index, glow);
  366. }
  369. LLPCode LLPrimitive::legacyToPCode(const U8 legacy)
  370. {
  371. // TODO: Should this default to something valid?
  372. // Maybe volume?
  373. LLPCode pcode = 0;
  375. switch (legacy)
  376. {
  377. /*
  378. case BOX:
  379. pcode = LL_PCODE_CUBE;
  380. break;
  381. case CYLINDER:
  382. pcode = LL_PCODE_CYLINDER;
  383. break;
  384. case CONE:
  385. pcode = LL_PCODE_CONE;
  386. break;
  387. case HALF_CONE:
  388. pcode = LL_PCODE_CONE_HEMI;
  389. break;
  390. case HALF_CYLINDER:
  391. pcode = LL_PCODE_CYLINDER_HEMI;
  392. break;
  393. case HALF_SPHERE:
  394. pcode = LL_PCODE_SPHERE_HEMI;
  395. break;
  396. case PRISM:
  397. pcode = LL_PCODE_PRISM;
  398. break;
  399. case PYRAMID:
  400. pcode = LL_PCODE_PYRAMID;
  401. break;
  402. case SPHERE:
  403. pcode = LL_PCODE_SPHERE;
  404. break;
  405. case TETRAHEDRON:
  406. pcode = LL_PCODE_TETRAHEDRON;
  407. break;
  408. case DEMON:
  409. pcode = LL_PCODE_LEGACY_DEMON;
  410. break;
  411. case LSL_TEST:
  412. pcode = LL_PCODE_LEGACY_LSL_TEST;
  413. break;
  414. case ORACLE:
  415. pcode = LL_PCODE_LEGACY_ORACLE;
  416. break;
  417. case TEXTBUBBLE:
  418. pcode = LL_PCODE_LEGACY_TEXT_BUBBLE;
  419. break;
  420. case ATOR:
  421. pcode = LL_PCODE_LEGACY_ATOR;
  422. break;
  423. case BASIC_SHOT:
  424. pcode = LL_PCODE_LEGACY_SHOT;
  425. break;
  426. case BIG_SHOT:
  427. pcode = LL_PCODE_LEGACY_SHOT_BIG;
  428. break;
  429. case BIRD:
  430. pcode = LL_PCODE_LEGACY_BIRD;
  431. break;
  432. case ROCK:
  433. pcode = LL_PCODE_LEGACY_ROCK;
  434. break;
  435. case SMOKE:
  436. pcode = LL_PCODE_LEGACY_SMOKE;
  437. break;
  438. case SPARK:
  439. pcode = LL_PCODE_LEGACY_SPARK;
  440. break;
  441. */
  442. case PRIMITIVE_VOLUME:
  443. pcode = LL_PCODE_VOLUME;
  444. break;
  445. case GRASS:
  446. pcode = LL_PCODE_LEGACY_GRASS;
  447. break;
  448. case PART_SYS:
  449. pcode = LL_PCODE_LEGACY_PART_SYS;
  450. break;
  451. case PLAYER:
  452. pcode = LL_PCODE_LEGACY_AVATAR;
  453. break;
  454. case TREE:
  455. pcode = LL_PCODE_LEGACY_TREE;
  456. break;
  457. case TREE_NEW:
  458. pcode = LL_PCODE_TREE_NEW;
  459. break;
  460. default:
  461. llwarns << "Unknown legacy code " << legacy << " [" << (S32)legacy << "]!" << llendl;
  462. }
  464. return pcode;
  465. }
  467. U8 LLPrimitive::pCodeToLegacy(const LLPCode pcode)
  468. {
  469. U8 legacy;
  470. switch (pcode)
  471. {
  472. /*
  473. case LL_PCODE_CUBE:
  474. legacy = BOX;
  475. break;
  476. case LL_PCODE_CYLINDER:
  477. legacy = CYLINDER;
  478. break;
  479. case LL_PCODE_CONE:
  480. legacy = CONE;
  481. break;
  482. case LL_PCODE_CONE_HEMI:
  483. legacy = HALF_CONE;
  484. break;
  485. case LL_PCODE_CYLINDER_HEMI:
  486. legacy = HALF_CYLINDER;
  487. break;
  488. case LL_PCODE_SPHERE_HEMI:
  489. legacy = HALF_SPHERE;
  490. break;
  491. case LL_PCODE_PRISM:
  492. legacy = PRISM;
  493. break;
  494. case LL_PCODE_PYRAMID:
  495. legacy = PYRAMID;
  496. break;
  497. case LL_PCODE_SPHERE:
  498. legacy = SPHERE;
  499. break;
  500. case LL_PCODE_TETRAHEDRON:
  501. legacy = TETRAHEDRON;
  502. break;
  503. case LL_PCODE_LEGACY_ATOR:
  504. legacy = ATOR;
  505. break;
  506. case LL_PCODE_LEGACY_SHOT:
  507. legacy = BASIC_SHOT;
  508. break;
  509. case LL_PCODE_LEGACY_SHOT_BIG:
  510. legacy = BIG_SHOT;
  511. break;
  512. case LL_PCODE_LEGACY_BIRD:
  513. legacy = BIRD;
  514. break;
  515. case LL_PCODE_LEGACY_DEMON:
  516. legacy = DEMON;
  517. break;
  518. case LL_PCODE_LEGACY_LSL_TEST:
  519. legacy = LSL_TEST;
  520. break;
  521. case LL_PCODE_LEGACY_ORACLE:
  522. legacy = ORACLE;
  523. break;
  524. case LL_PCODE_LEGACY_ROCK:
  525. legacy = ROCK;
  526. break;
  527. case LL_PCODE_LEGACY_TEXT_BUBBLE:
  528. legacy = TEXTBUBBLE;
  529. break;
  530. case LL_PCODE_LEGACY_SMOKE:
  531. legacy = SMOKE;
  532. break;
  533. case LL_PCODE_LEGACY_SPARK:
  534. legacy = SPARK;
  535. break;
  536. */
  537. case LL_PCODE_VOLUME:
  538. legacy = PRIMITIVE_VOLUME;
  539. break;
  540. case LL_PCODE_LEGACY_GRASS:
  541. legacy = GRASS;
  542. break;
  543. case LL_PCODE_LEGACY_PART_SYS:
  544. legacy = PART_SYS;
  545. break;
  546. case LL_PCODE_LEGACY_AVATAR:
  547. legacy = PLAYER;
  548. break;
  549. case LL_PCODE_LEGACY_TREE:
  550. legacy = TREE;
  551. break;
  552. case LL_PCODE_TREE_NEW:
  553. legacy = TREE_NEW;
  554. break;
  555. default:
  556. llwarns << "Unknown pcode " << (S32)pcode << ":" << pcode << "!" << llendl;
  557. return 0;
  558. }
  559. return legacy;
  560. }
  563. // static
  564. // Don't crash or llerrs here!  This function is used for debug strings.
  565. std::string LLPrimitive::pCodeToString(const LLPCode pcode)
  566. {
  567. std::string pcode_string;
  569. U8 base_code = pcode & LL_PCODE_BASE_MASK;
  570. if (!pcode)
  571. {
  572. pcode_string = "null";
  573. }
  574. else if ((base_code) == LL_PCODE_LEGACY)
  575. {
  576. // It's a legacy object
  577. switch (pcode)
  578. {
  579. case LL_PCODE_LEGACY_GRASS:
  580.   pcode_string = "grass";
  581. break;
  582. case LL_PCODE_LEGACY_PART_SYS:
  583.   pcode_string = "particle system";
  584. break;
  585. case LL_PCODE_LEGACY_AVATAR:
  586.   pcode_string = "avatar";
  587. break;
  588. case LL_PCODE_LEGACY_TEXT_BUBBLE:
  589.   pcode_string = "text bubble";
  590. break;
  591. case LL_PCODE_LEGACY_TREE:
  592.   pcode_string = "tree";
  593. break;
  594. case LL_PCODE_TREE_NEW:
  595.   pcode_string = "tree_new";
  596. break;
  597. default:
  598.   pcode_string = llformat( "unknown legacy pcode %i",(U32)pcode);
  599. }
  600. }
  601. else
  602. {
  603. std::string shape;
  604. std::string mask;
  605. if (base_code == LL_PCODE_CUBE)
  606. {
  607. shape = "cube";
  608. }
  609. else if (base_code == LL_PCODE_CYLINDER)
  610. {
  611. shape = "cylinder";
  612. }
  613. else if (base_code == LL_PCODE_CONE)
  614. {
  615. shape = "cone";
  616. }
  617. else if (base_code == LL_PCODE_PRISM)
  618. {
  619. shape = "prism";
  620. }
  621. else if (base_code == LL_PCODE_PYRAMID)
  622. {
  623. shape = "pyramid";
  624. }
  625. else if (base_code == LL_PCODE_SPHERE)
  626. {
  627. shape = "sphere";
  628. }
  629. else if (base_code == LL_PCODE_TETRAHEDRON)
  630. {
  631. shape = "tetrahedron";
  632. }
  633. else if (base_code == LL_PCODE_VOLUME)
  634. {
  635. shape = "volume";
  636. }
  637. else if (base_code == LL_PCODE_APP)
  638. {
  639. shape = "app";
  640. }
  641. else
  642. {
  643. llwarns << "Unknown base mask for pcode: " << base_code << llendl;
  644. }
  646. U8 mask_code = pcode & (~LL_PCODE_BASE_MASK);
  647. if (base_code == LL_PCODE_APP)
  648. {
  649. mask = llformat( "%x", mask_code);
  650. }
  651. else if (mask_code & LL_PCODE_HEMI_MASK)
  652. {
  653. mask = "hemi";
  654. }
  655. else 
  656. {
  657. mask = llformat( "%x", mask_code);
  658. }
  660. if (mask[0])
  661. {
  662. pcode_string = llformat( "%s-%s", shape.c_str(), mask.c_str());
  663. }
  664. else
  665. {
  666. pcode_string = llformat( "%s", shape.c_str());
  667. }
  668. }
  670. return pcode_string;
  671. }
  674. void LLPrimitive::copyTEs(const LLPrimitive *primitivep)
  675. {
  676. U32 i;
  677. if (primitivep->getExpectedNumTEs() != getExpectedNumTEs())
  678. {
  679. llwarns << "Primitives don't have same expected number of TE's" << llendl;
  680. }
  681. U32 num_tes = llmin(primitivep->getExpectedNumTEs(), getExpectedNumTEs());
  682. if (mTextureList.size() < getExpectedNumTEs())
  683. {
  684. mTextureList.setSize(getExpectedNumTEs());
  685. }
  686. for (i = 0; i < num_tes; i++)
  687. {
  688. mTextureList.copyTexture(i, *(primitivep->getTE(i)));
  689. }
  690. }
  692. S32 face_index_from_id(LLFaceID face_ID, const std::vector<LLProfile::Face>& faceArray)
  693. {
  694. S32 i;
  695. for (i = 0; i < (S32)faceArray.size(); i++)
  696. {
  697. if (faceArray[i].mFaceID == face_ID)
  698. {
  699. return i;
  700. }
  701. }
  702. return -1;
  703. }
  705. BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume)
  706. {
  707. LLMemType m1(LLMemType::MTYPE_VOLUME);
  708. LLVolume *volumep;
  709. if (unique_volume)
  710. {
  711. F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail);
  712. if (mVolumep.notNull() && volume_params == mVolumep->getParams() && (volume_detail == mVolumep->getDetail()))
  713. {
  714. return FALSE;
  715. }
  716. volumep = new LLVolume(volume_params, volume_detail, FALSE, TRUE);
  717. }
  718. else
  719. {
  720. if (mVolumep.notNull())
  721. {
  722. F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail);
  723. if (volume_params == mVolumep->getParams() && (volume_detail == mVolumep->getDetail()))
  724. {
  725. return FALSE;
  726. }
  727. }
  729. volumep = sVolumeManager->refVolume(volume_params, detail);
  730. if (volumep == mVolumep)
  731. {
  732. sVolumeManager->unrefVolume( volumep );  // LLVolumeMgr::refVolume() creates a reference, but we don't need a second one.
  733. return TRUE;
  734. }
  735. }
  737. setChanged(GEOMETRY);
  740. if (!mVolumep)
  741. {
  742. mVolumep = volumep;
  743. //mFaceMask = mVolumep->generateFaceMask();
  744. setNumTEs(mVolumep->getNumFaces());
  745. return TRUE;
  746. }
  748. U32 old_face_mask = mVolumep->mFaceMask;
  750. S32 face_bit = 0;
  751. S32 cur_mask = 0;
  753. // Grab copies of the old faces from the original shape, ordered by type.
  754. // We will use these to figure out what old texture info gets mapped to new
  755. // faces in the new shape.
  756. std::vector<LLProfile::Face> old_faces; 
  757. for (S32 face = 0; face < mVolumep->getNumFaces(); face++)
  758. {
  759. old_faces.push_back(mVolumep->getProfile().mFaces[face]);
  760. }
  762. // Copy the old texture info off to the side, but not in the order in which
  763. // they live in the mTextureList, rather in order of ther "face id" which
  764. // is the corresponding value of LLVolueParams::LLProfile::mFaces::mIndex.
  765. //
  766. // Hence, some elements of old_tes::mEntryList will be invalid.  It is
  767. // initialized to a size of 9 (max number of possible faces on a volume?)
  768. // and only the ones with valid types are filled in.
  769. LLPrimTextureList old_tes;
  770. old_tes.setSize(9);
  771. for (face_bit = 0; face_bit < 9; face_bit++)
  772. {
  773. cur_mask = 0x1 << face_bit;
  774. if (old_face_mask & cur_mask)
  775. {
  776. S32 te_index = face_index_from_id(cur_mask, old_faces);
  777. old_tes.copyTexture(face_bit, *(getTE(te_index)));
  778. //llinfos << face_bit << ":" << te_index << ":" << old_tes[face_bit].getID() << llendl;
  779. }
  780. }
  783. // build the new object
  784. sVolumeManager->unrefVolume(mVolumep);
  785. mVolumep = volumep;
  787. U32 new_face_mask = mVolumep->mFaceMask;
  788. S32 i;
  790. if (old_face_mask == new_face_mask) 
  791. {
  792. // nothing to do
  793. return TRUE;
  794. }
  796. if (mVolumep->getNumFaces() == 0 && new_face_mask != 0)
  797. {
  798. llwarns << "Object with 0 faces found...INCORRECT!" << llendl;
  799. setNumTEs(mVolumep->getNumFaces());
  800. return TRUE;
  801. }
  803. // initialize face_mapping
  804. S32 face_mapping[9];
  805. for (face_bit = 0; face_bit < 9; face_bit++)
  806. {
  807. face_mapping[face_bit] = face_bit;
  808. }
  810. // The new shape may have more faces than the original, but we can't just
  811. // add them to the end -- the ordering matters and it may be that we must
  812. // insert the new faces in the middle of the list.  When we add a face it
  813. // will pick up the texture/color info of one of the old faces an so we
  814. // now figure out which old face info gets mapped to each new face, and 
  815. // store in the face_mapping lookup table.
  816. for (face_bit = 0; face_bit < 9; face_bit++)
  817. {
  818. cur_mask = 0x1 << face_bit;
  819. if (!(new_face_mask & cur_mask))
  820. {
  821. // Face doesn't exist in new map.
  822. face_mapping[face_bit] = -1;
  823. continue;
  824. }
  825. else if (old_face_mask & cur_mask)
  826. {
  827. // Face exists in new and old map.
  828. face_mapping[face_bit] = face_bit;
  829. continue;
  830. }
  832. // OK, how we've got a mismatch, where we have to fill a new face with one from
  833. // the old face.
  834. if (cur_mask & (LL_FACE_PATH_BEGIN | LL_FACE_PATH_END | LL_FACE_INNER_SIDE))
  835. {
  836. // It's a top/bottom/hollow interior face.
  837. if (old_face_mask & LL_FACE_PATH_END)
  838. {
  839. face_mapping[face_bit] = 1;
  840. continue;
  841. }
  842. else
  843. {
  844. S32 cur_outer_mask = LL_FACE_OUTER_SIDE_0;
  845. for (i = 0; i < 4; i++)
  846. {
  847. if (old_face_mask & cur_outer_mask)
  848. {
  849. face_mapping[face_bit] = 5 + i;
  850. break;
  851. }
  852. cur_outer_mask <<= 1;
  853. }
  854. if (i == 4)
  855. {
  856. llwarns << "No path end or outer face in volume!" << llendl;
  857. }
  858. continue;
  859. }
  860. }
  862. if (cur_mask & (LL_FACE_PROFILE_BEGIN | LL_FACE_PROFILE_END))
  863. {
  864. // A cut slice.  Use the hollow interior if we have it.
  865. if (old_face_mask & LL_FACE_INNER_SIDE)
  866. {
  867. face_mapping[face_bit] = 2;
  868. continue;
  869. }
  871. // No interior, use the bottom face.
  872. // Could figure out which of the outer faces was nearest, but that would be harder.
  873. if (old_face_mask & LL_FACE_PATH_END)
  874. {
  875. face_mapping[face_bit] = 1;
  876. continue;
  877. }
  878. else
  879. {
  880. S32 cur_outer_mask = LL_FACE_OUTER_SIDE_0;
  881. for (i = 0; i < 4; i++)
  882. {
  883. if (old_face_mask & cur_outer_mask)
  884. {
  885. face_mapping[face_bit] = 5 + i;
  886. break;
  887. }
  888. cur_outer_mask <<= 1;
  889. }
  890. if (i == 4)
  891. {
  892. llwarns << "No path end or outer face in volume!" << llendl;
  893. }
  894. continue;
  895. }
  896. }
  898. // OK, the face that's missing is an outer face...
  899. // Pull from the nearest adjacent outer face (there's always guaranteed to be one...
  900. S32 cur_outer = face_bit - 5;
  901. S32 min_dist = 5;
  902. S32 min_outer_bit = -1;
  903. S32 i;
  904. for (i = 0; i < 4; i++)
  905. {
  906. if (old_face_mask & (LL_FACE_OUTER_SIDE_0 << i))
  907. {
  908. S32 dist = abs(i - cur_outer);
  909. if (dist < min_dist)
  910. {
  911. min_dist = dist;
  912. min_outer_bit = i + 5;
  913. }
  914. }
  915. }
  916. if (-1 == min_outer_bit)
  917. {
  918. llinfos << (LLVolume *)mVolumep << llendl;
  919. llwarns << "Bad!  No outer faces, impossible!" << llendl;
  920. }
  921. face_mapping[face_bit] = min_outer_bit;
  922. }
  925. setNumTEs(mVolumep->getNumFaces());
  926. for (face_bit = 0; face_bit < 9; face_bit++)
  927. {
  928. // For each possible face type on the new shape we check to see if that
  929. // face exists and if it does we create a texture entry that is a copy
  930. // of one of the originals.  Since the originals might not have a
  931. // matching face, we use the face_mapping lookup table to figure out
  932. // which face information to copy.
  933. cur_mask = 0x1 << face_bit;
  934. if (new_face_mask & cur_mask)
  935. {
  936. if (-1 == face_mapping[face_bit])
  937. {
  938. llwarns << "No mapping from old face to new face!" << llendl;
  939. }
  941. S32 te_num = face_index_from_id(cur_mask, mVolumep->getProfile().mFaces);
  942. setTE(te_num, *(old_tes.getTexture(face_mapping[face_bit])));
  943. }
  944. }
  945. return TRUE;
  946. }
  948. BOOL LLPrimitive::setMaterial(U8 material)
  949. {
  950. if (material != mMaterial)
  951. {
  952. mMaterial = material;
  953. return TRUE;
  954. }
  955. else
  956. {
  957. return FALSE;
  958. }
  959. }
  961. const F32 LL_MAX_SCALE_S = 100.0f;
  962. const F32 LL_MAX_SCALE_T = 100.0f;
  963. S32 LLPrimitive::packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_face_index, EMsgVariableType type) const
  964. {
  965. S32 face_index;
  966. S32 i;
  967. U64 exception_faces;
  968. U8 *start_loc = cur_ptr;
  970. htonmemcpy(cur_ptr,data_ptr + (last_face_index * data_size), type, data_size);
  971. cur_ptr += data_size;
  973. for (face_index = last_face_index-1; face_index >= 0; face_index--)
  974. {
  975. BOOL already_sent = FALSE;
  976. for (i = face_index+1; i <= last_face_index; i++)
  977. { 
  978. if (!memcmp(data_ptr+(data_size *face_index), data_ptr+(data_size *i), data_size))
  979. {
  980. already_sent = TRUE;
  981. break;
  982. }
  983. }
  985. if (!already_sent)
  986. {
  987. exception_faces = 0;
  988. for (i = face_index; i >= 0; i--)
  989. { 
  990. if (!memcmp(data_ptr+(data_size *face_index), data_ptr+(data_size *i), data_size))
  991. {
  992. exception_faces |= ((U64)1 << i); 
  993. }
  994. }
  996. //assign exception faces to cur_ptr
  997. if (exception_faces >= (0x1 << 7))
  998. {
  999. if (exception_faces >= (0x1 << 14))
  1000. {
  1001. if (exception_faces >= (0x1 << 21))
  1002. {
  1003. if (exception_faces >= (0x1 << 28))
  1004. {
  1005. *cur_ptr++ = (U8)(((exception_faces >> 28) & 0x7F) | 0x80);
  1006. }
  1007. *cur_ptr++ = (U8)(((exception_faces >> 21) & 0x7F) | 0x80);
  1008. }
  1009. *cur_ptr++ = (U8)(((exception_faces >> 14) & 0x7F) | 0x80);
  1010. }
  1011. *cur_ptr++ = (U8)(((exception_faces >> 7) & 0x7F) | 0x80);
  1012. }
  1014. *cur_ptr++ = (U8)(exception_faces & 0x7F);
  1016. htonmemcpy(cur_ptr,data_ptr + (face_index * data_size), type, data_size);
  1017. cur_ptr += data_size;
  1018.     }
  1019. }
  1020. return (S32)(cur_ptr - start_loc);
  1021. }
  1023. S32 LLPrimitive::unpackTEField(U8 *cur_ptr, U8 *buffer_end, U8 *data_ptr, U8 data_size, U8 face_count, EMsgVariableType type)
  1024. {
  1025. U8 *start_loc = cur_ptr;
  1026. U64 i;
  1027. htonmemcpy(data_ptr,cur_ptr, type,data_size);
  1028. cur_ptr += data_size;
  1030. for (i = 1; i < face_count; i++)
  1031. {
  1032. // Already unswizzled, don't need to unswizzle it again!
  1033. memcpy(data_ptr+(i*data_size),data_ptr,data_size); /* Flawfinder: ignore */ 
  1034. }
  1036. while ((cur_ptr < buffer_end) && (*cur_ptr != 0))
  1037. {
  1038. // llinfos << "TE exception" << llendl;
  1039. i = 0;
  1040. while (*cur_ptr & 0x80)
  1041. {
  1042. i |= ((*cur_ptr++) & 0x7F);
  1043. i = i << 7;
  1044. }
  1046. i |= *cur_ptr++;
  1048. for (S32 j = 0; j < face_count; j++)
  1049. {
  1050. if (i & 0x01)
  1051. {
  1052. htonmemcpy(data_ptr+(j*data_size),cur_ptr,type,data_size);
  1053. // char foo[64];
  1054. // sprintf(foo,"%x %x",*(data_ptr+(j*data_size)), *(data_ptr+(j*data_size)+1));
  1055. // llinfos << "Assigning " << foo << " to face " << j << llendl;
  1056. }
  1057. i = i >> 1;
  1058. }
  1059. cur_ptr += data_size;
  1060. }
  1061. return (S32)(cur_ptr - start_loc);
  1062. }
  1065. // Pack information about all texture entries into container:
  1066. // { TextureEntry Variable 2 }
  1067. // Includes information about image ID, color, scale S,T, offset S,T and rotation
  1068. BOOL LLPrimitive::packTEMessage(LLMessageSystem *mesgsys) const
  1069. {
  1070. const U32 MAX_TES = 32;
  1072. U8     image_ids[MAX_TES*16];
  1073. U8     colors[MAX_TES*4];
  1074. F32    scale_s[MAX_TES];
  1075. F32    scale_t[MAX_TES];
  1076. S16    offset_s[MAX_TES];
  1077. S16    offset_t[MAX_TES];
  1078. S16    image_rot[MAX_TES];
  1079. U8    bump[MAX_TES];
  1080. U8    media_flags[MAX_TES];
  1081.     U8     glow[MAX_TES];
  1083. const U32 MAX_TE_BUFFER = 4096;
  1084. U8 packed_buffer[MAX_TE_BUFFER];
  1085. U8 *cur_ptr = packed_buffer;
  1087. S32 last_face_index = getNumTEs() - 1;
  1089. if (last_face_index > -1)
  1090. {
  1091. // ...if we hit the front, send one image id
  1092. S8 face_index;
  1093. LLColor4U coloru;
  1094. for (face_index = 0; face_index <= last_face_index; face_index++)
  1095. {
  1096. // Directly sending image_ids is not safe!
  1097. memcpy(&image_ids[face_index*16],getTE(face_index)->getID().mData,16); /* Flawfinder: ignore */ 
  1099. // Cast LLColor4 to LLColor4U
  1100. coloru.setVec( getTE(face_index)->getColor() );
  1102. // Note:  This is an optimization to send common colors (1.f, 1.f, 1.f, 1.f)
  1103. // as all zeros.  However, the subtraction and addition must be done in unsigned
  1104. // byte space, not in float space, otherwise off-by-one errors occur. JC
  1105. colors[4*face_index]     = 255 - coloru.mV[0];
  1106. colors[4*face_index + 1] = 255 - coloru.mV[1];
  1107. colors[4*face_index + 2] = 255 - coloru.mV[2];
  1108. colors[4*face_index + 3] = 255 - coloru.mV[3];
  1110. const LLTextureEntry* te = getTE(face_index);
  1111. scale_s[face_index] = (F32) te->mScaleS;
  1112. scale_t[face_index] = (F32) te->mScaleT;
  1113. offset_s[face_index] = (S16) llround((llclamp(te->mOffsetS,-1.0f,1.0f) * (F32)0x7FFF)) ;
  1114. offset_t[face_index] = (S16) llround((llclamp(te->mOffsetT,-1.0f,1.0f) * (F32)0x7FFF)) ;
  1115. image_rot[face_index] = (S16) llround(((fmod(te->mRotation, F_TWO_PI)/F_TWO_PI) * TEXTURE_ROTATION_PACK_FACTOR));
  1116. bump[face_index] = te->getBumpShinyFullbright();
  1117. media_flags[face_index] = te->getMediaTexGen();
  1118. glow[face_index] = (U8) llround((llclamp(te->getGlow(), 0.0f, 1.0f) * (F32)0xFF));
  1119. }
  1121. cur_ptr += packTEField(cur_ptr, (U8 *)image_ids, sizeof(LLUUID),last_face_index, MVT_LLUUID);
  1122. *cur_ptr++ = 0;
  1123. cur_ptr += packTEField(cur_ptr, (U8 *)colors, 4 ,last_face_index, MVT_U8);
  1124. *cur_ptr++ = 0;
  1125. cur_ptr += packTEField(cur_ptr, (U8 *)scale_s, 4 ,last_face_index, MVT_F32);
  1126. *cur_ptr++ = 0;
  1127. cur_ptr += packTEField(cur_ptr, (U8 *)scale_t, 4 ,last_face_index, MVT_F32);
  1128. *cur_ptr++ = 0;
  1129. cur_ptr += packTEField(cur_ptr, (U8 *)offset_s, 2 ,last_face_index, MVT_S16Array);
  1130. *cur_ptr++ = 0;
  1131. cur_ptr += packTEField(cur_ptr, (U8 *)offset_t, 2 ,last_face_index, MVT_S16Array);
  1132. *cur_ptr++ = 0;
  1133. cur_ptr += packTEField(cur_ptr, (U8 *)image_rot, 2 ,last_face_index, MVT_S16Array);
  1134. *cur_ptr++ = 0;
  1135. cur_ptr += packTEField(cur_ptr, (U8 *)bump, 1 ,last_face_index, MVT_U8);
  1136. *cur_ptr++ = 0;
  1137. cur_ptr += packTEField(cur_ptr, (U8 *)media_flags, 1 ,last_face_index, MVT_U8);
  1138. *cur_ptr++ = 0;
  1139. cur_ptr += packTEField(cur_ptr, (U8 *)glow, 1 ,last_face_index, MVT_U8);
  1140. }
  1141.     mesgsys->addBinaryDataFast(_PREHASH_TextureEntry, packed_buffer, (S32)(cur_ptr - packed_buffer));
  1143. return FALSE;
  1144. }
  1147. BOOL LLPrimitive::packTEMessage(LLDataPacker &dp) const
  1148. {
  1149. const U32 MAX_TES = 32;
  1151. U8     image_ids[MAX_TES*16];
  1152. U8     colors[MAX_TES*4];
  1153. F32    scale_s[MAX_TES];
  1154. F32    scale_t[MAX_TES];
  1155. S16    offset_s[MAX_TES];
  1156. S16    offset_t[MAX_TES];
  1157. S16    image_rot[MAX_TES];
  1158. U8    bump[MAX_TES];
  1159. U8    media_flags[MAX_TES];
  1160.     U8     glow[MAX_TES];
  1162. const U32 MAX_TE_BUFFER = 4096;
  1163. U8 packed_buffer[MAX_TE_BUFFER];
  1164. U8 *cur_ptr = packed_buffer;
  1166. S32 last_face_index = getNumTEs() - 1;
  1168. if (last_face_index > -1)
  1169. {
  1170. // ...if we hit the front, send one image id
  1171. S8 face_index;
  1172. LLColor4U coloru;
  1173. for (face_index = 0; face_index <= last_face_index; face_index++)
  1174. {
  1175. // Directly sending image_ids is not safe!
  1176. memcpy(&image_ids[face_index*16],getTE(face_index)->getID().mData,16); /* Flawfinder: ignore */ 
  1178. // Cast LLColor4 to LLColor4U
  1179. coloru.setVec( getTE(face_index)->getColor() );
  1181. // Note:  This is an optimization to send common colors (1.f, 1.f, 1.f, 1.f)
  1182. // as all zeros.  However, the subtraction and addition must be done in unsigned
  1183. // byte space, not in float space, otherwise off-by-one errors occur. JC
  1184. colors[4*face_index]     = 255 - coloru.mV[0];
  1185. colors[4*face_index + 1] = 255 - coloru.mV[1];
  1186. colors[4*face_index + 2] = 255 - coloru.mV[2];
  1187. colors[4*face_index + 3] = 255 - coloru.mV[3];
  1189. const LLTextureEntry* te = getTE(face_index);
  1190. scale_s[face_index] = (F32) te->mScaleS;
  1191. scale_t[face_index] = (F32) te->mScaleT;
  1192. offset_s[face_index] = (S16) llround((llclamp(te->mOffsetS,-1.0f,1.0f) * (F32)0x7FFF)) ;
  1193. offset_t[face_index] = (S16) llround((llclamp(te->mOffsetT,-1.0f,1.0f) * (F32)0x7FFF)) ;
  1194. image_rot[face_index] = (S16) llround(((fmod(te->mRotation, F_TWO_PI)/F_TWO_PI) * TEXTURE_ROTATION_PACK_FACTOR));
  1195. bump[face_index] = te->getBumpShinyFullbright();
  1196. media_flags[face_index] = te->getMediaTexGen();
  1197.             glow[face_index] = (U8) llround((llclamp(te->getGlow(), 0.0f, 1.0f) * (F32)0xFF));
  1198. }
  1200. cur_ptr += packTEField(cur_ptr, (U8 *)image_ids, sizeof(LLUUID),last_face_index, MVT_LLUUID);
  1201. *cur_ptr++ = 0;
  1202. cur_ptr += packTEField(cur_ptr, (U8 *)colors, 4 ,last_face_index, MVT_U8);
  1203. *cur_ptr++ = 0;
  1204. cur_ptr += packTEField(cur_ptr, (U8 *)scale_s, 4 ,last_face_index, MVT_F32);
  1205. *cur_ptr++ = 0;
  1206. cur_ptr += packTEField(cur_ptr, (U8 *)scale_t, 4 ,last_face_index, MVT_F32);
  1207. *cur_ptr++ = 0;
  1208. cur_ptr += packTEField(cur_ptr, (U8 *)offset_s, 2 ,last_face_index, MVT_S16Array);
  1209. *cur_ptr++ = 0;
  1210. cur_ptr += packTEField(cur_ptr, (U8 *)offset_t, 2 ,last_face_index, MVT_S16Array);
  1211. *cur_ptr++ = 0;
  1212. cur_ptr += packTEField(cur_ptr, (U8 *)image_rot, 2 ,last_face_index, MVT_S16Array);
  1213. *cur_ptr++ = 0;
  1214. cur_ptr += packTEField(cur_ptr, (U8 *)bump, 1 ,last_face_index, MVT_U8);
  1215. *cur_ptr++ = 0;
  1216. cur_ptr += packTEField(cur_ptr, (U8 *)media_flags, 1 ,last_face_index, MVT_U8);
  1217. *cur_ptr++ = 0;
  1218. cur_ptr += packTEField(cur_ptr, (U8 *)glow, 1 ,last_face_index, MVT_U8);
  1219. }
  1221. dp.packBinaryData(packed_buffer, (S32)(cur_ptr - packed_buffer), "TextureEntry");
  1222. return FALSE;
  1223. }
  1225. S32 LLPrimitive::unpackTEMessage(LLMessageSystem *mesgsys, char *block_name)
  1226. {
  1227. return(unpackTEMessage(mesgsys,block_name,-1));
  1228. }
  1230. S32 LLPrimitive::unpackTEMessage(LLMessageSystem *mesgsys, char *block_name, const S32 block_num)
  1231. {
  1232. // use a negative block_num to indicate a single-block read (a non-variable block)
  1233. S32 retval = 0;
  1234. const U32 MAX_TES = 32;
  1236. // Avoid construction of 32 UUIDs per call. JC
  1238. U8     image_data[MAX_TES*16];
  1239. U8   colors[MAX_TES*4];
  1240. F32    scale_s[MAX_TES];
  1241. F32    scale_t[MAX_TES];
  1242. S16    offset_s[MAX_TES];
  1243. S16    offset_t[MAX_TES];
  1244. S16    image_rot[MAX_TES];
  1245. U8    bump[MAX_TES];
  1246. U8    media_flags[MAX_TES];
  1247.     U8     glow[MAX_TES];
  1249. const U32 MAX_TE_BUFFER = 4096;
  1250. U8 packed_buffer[MAX_TE_BUFFER];
  1251. U8 *cur_ptr = packed_buffer;
  1253. U32 size;
  1254. U32 face_count = 0;
  1256. if (block_num < 0)
  1257. {
  1258. size = mesgsys->getSizeFast(block_name, _PREHASH_TextureEntry);
  1259. }
  1260. else
  1261. {
  1262. size = mesgsys->getSizeFast(block_name, block_num, _PREHASH_TextureEntry);
  1263. }
  1265. if (size == 0)
  1266. {
  1267. return retval;
  1268. }
  1270. if (block_num < 0)
  1271. {
  1272. mesgsys->getBinaryDataFast(block_name, _PREHASH_TextureEntry, packed_buffer, 0, 0, MAX_TE_BUFFER);
  1273. }
  1274. else
  1275. {
  1276. mesgsys->getBinaryDataFast(block_name, _PREHASH_TextureEntry, packed_buffer, 0, block_num, MAX_TE_BUFFER);
  1277. }
  1279. face_count = getNumTEs();
  1281. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)image_data, 16, face_count, MVT_LLUUID);
  1282. cur_ptr++;
  1283. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)colors, 4, face_count, MVT_U8);
  1284. cur_ptr++;
  1285. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)scale_s, 4, face_count, MVT_F32);
  1286. cur_ptr++;
  1287. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)scale_t, 4, face_count, MVT_F32);
  1288. cur_ptr++;
  1289. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)offset_s, 2, face_count, MVT_S16Array);
  1290. cur_ptr++;
  1291. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)offset_t, 2, face_count, MVT_S16Array);
  1292. cur_ptr++;
  1293. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)image_rot, 2, face_count, MVT_S16Array);
  1294. cur_ptr++;
  1295. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)bump, 1, face_count, MVT_U8);
  1296. cur_ptr++;
  1297. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)media_flags, 1, face_count, MVT_U8);
  1298. cur_ptr++;
  1299. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)glow, 1, face_count, MVT_U8);
  1301. LLColor4 color;
  1302. LLColor4U coloru;
  1303. for (U32 i = 0; i < face_count; i++)
  1304. {
  1305. retval |= setTETexture(i, ((LLUUID*)image_data)[i]);
  1306. retval |= setTEScale(i, scale_s[i], scale_t[i]);
  1307. retval |= setTEOffset(i, (F32)offset_s[i] / (F32)0x7FFF, (F32) offset_t[i] / (F32) 0x7FFF);
  1308. retval |= setTERotation(i, ((F32)image_rot[i] / TEXTURE_ROTATION_PACK_FACTOR) * F_TWO_PI);
  1309. retval |= setTEBumpShinyFullbright(i, bump[i]);
  1310. retval |= setTEMediaTexGen(i, media_flags[i]);
  1311. retval |= setTEGlow(i, (F32)glow[i] / (F32)0xFF);
  1312. coloru = LLColor4U(colors + 4*i);
  1314. // Note:  This is an optimization to send common colors (1.f, 1.f, 1.f, 1.f)
  1315. // as all zeros.  However, the subtraction and addition must be done in unsigned
  1316. // byte space, not in float space, otherwise off-by-one errors occur. JC
  1317. color.mV[VRED] = F32(255 - coloru.mV[VRED])   / 255.f;
  1318. color.mV[VGREEN] = F32(255 - coloru.mV[VGREEN]) / 255.f;
  1319. color.mV[VBLUE] = F32(255 - coloru.mV[VBLUE])  / 255.f;
  1320. color.mV[VALPHA] = F32(255 - coloru.mV[VALPHA]) / 255.f;
  1322. retval |= setTEColor(i, color);
  1324. }
  1326. return retval;
  1327. }
  1329. S32 LLPrimitive::unpackTEMessage(LLDataPacker &dp)
  1330. {
  1331. // use a negative block_num to indicate a single-block read (a non-variable block)
  1332. S32 retval = 0;
  1333. const U32 MAX_TES = 32;
  1335. // Avoid construction of 32 UUIDs per call
  1336. static LLUUID image_ids[MAX_TES];
  1338. U8     image_data[MAX_TES*16];
  1339. U8    colors[MAX_TES*4];
  1340. F32    scale_s[MAX_TES];
  1341. F32    scale_t[MAX_TES];
  1342. S16    offset_s[MAX_TES];
  1343. S16    offset_t[MAX_TES];
  1344. S16    image_rot[MAX_TES];
  1345. U8    bump[MAX_TES];
  1346. U8    media_flags[MAX_TES];
  1347.     U8     glow[MAX_TES];
  1349. const U32 MAX_TE_BUFFER = 4096;
  1350. U8 packed_buffer[MAX_TE_BUFFER];
  1351. U8 *cur_ptr = packed_buffer;
  1353. S32 size;
  1354. U32 face_count = 0;
  1356. if (!dp.unpackBinaryData(packed_buffer, size, "TextureEntry"))
  1357. {
  1358. retval = TEM_INVALID;
  1359. llwarns << "Bad texture entry block!  Abort!" << llendl;
  1360. return retval;
  1361. }
  1363. if (size == 0)
  1364. {
  1365. return retval;
  1366. }
  1368. face_count = getNumTEs();
  1369. U32 i;
  1371. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)image_data, 16, face_count, MVT_LLUUID);
  1372. cur_ptr++;
  1373. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)colors, 4, face_count, MVT_U8);
  1374. cur_ptr++;
  1375. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)scale_s, 4, face_count, MVT_F32);
  1376. cur_ptr++;
  1377. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)scale_t, 4, face_count, MVT_F32);
  1378. cur_ptr++;
  1379. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)offset_s, 2, face_count, MVT_S16Array);
  1380. cur_ptr++;
  1381. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)offset_t, 2, face_count, MVT_S16Array);
  1382. cur_ptr++;
  1383. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)image_rot, 2, face_count, MVT_S16Array);
  1384. cur_ptr++;
  1385. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)bump, 1, face_count, MVT_U8);
  1386. cur_ptr++;
  1387. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)media_flags, 1, face_count, MVT_U8);
  1388. cur_ptr++;
  1389. cur_ptr += unpackTEField(cur_ptr, packed_buffer+size, (U8 *)glow, 1, face_count, MVT_U8);
  1391. for (i = 0; i < face_count; i++)
  1392. {
  1393. memcpy(image_ids[i].mData,&image_data[i*16],16); /* Flawfinder: ignore */ 
  1394. }
  1396. LLColor4 color;
  1397. LLColor4U coloru;
  1398. for (i = 0; i < face_count; i++)
  1399. {
  1400. retval |= setTETexture(i, image_ids[i]);
  1401. retval |= setTEScale(i, scale_s[i], scale_t[i]);
  1402. retval |= setTEOffset(i, (F32)offset_s[i] / (F32)0x7FFF, (F32) offset_t[i] / (F32) 0x7FFF);
  1403. retval |= setTERotation(i, ((F32)image_rot[i] / TEXTURE_ROTATION_PACK_FACTOR) * F_TWO_PI);
  1404. retval |= setTEBumpShinyFullbright(i, bump[i]);
  1405. retval |= setTEMediaTexGen(i, media_flags[i]);
  1406. retval |= setTEGlow(i, (F32)glow[i] / (F32)0xFF);
  1407. coloru = LLColor4U(colors + 4*i);
  1409. // Note:  This is an optimization to send common colors (1.f, 1.f, 1.f, 1.f)
  1410. // as all zeros.  However, the subtraction and addition must be done in unsigned
  1411. // byte space, not in float space, otherwise off-by-one errors occur. JC
  1412. color.mV[VRED] = F32(255 - coloru.mV[VRED])   / 255.f;
  1413. color.mV[VGREEN] = F32(255 - coloru.mV[VGREEN]) / 255.f;
  1414. color.mV[VBLUE] = F32(255 - coloru.mV[VBLUE])  / 255.f;
  1415. color.mV[VALPHA] = F32(255 - coloru.mV[VALPHA]) / 255.f;
  1417. retval |= setTEColor(i, color);
  1418. }
  1420. return retval;
  1421. }
  1423. U8 LLPrimitive::getExpectedNumTEs() const
  1424. {
  1425. U8 expected_face_count = 0;
  1426. if (mVolumep)
  1427. {
  1428. expected_face_count = mVolumep->getNumFaces();
  1429. }
  1430. return expected_face_count;
  1431. }
  1433. void LLPrimitive::copyTextureList(const LLPrimTextureList& other_list)
  1434. {
  1435. mTextureList.copy(other_list);
  1436. }
  1438. void LLPrimitive::takeTextureList(LLPrimTextureList& other_list)
  1439. {
  1440. mTextureList.take(other_list);
  1441. }
  1443. //============================================================================
  1445. // Moved from llselectmgr.cpp
  1446. // BUG: Only works for boxes.
  1447. // Face numbering for flex boxes as of 1.14.2
  1449. // static
  1450. bool LLPrimitive::getTESTAxes(const U8 face, U32* s_axis, U32* t_axis)
  1451. {
  1452. if (face == 0)
  1453. {
  1454. *s_axis = VX; *t_axis = VY;
  1455. return true;
  1456. }
  1457. else if (face == 1)
  1458. {
  1459. *s_axis = VX; *t_axis = VZ;
  1460. return true;
  1461. }
  1462. else if (face == 2)
  1463. {
  1464. *s_axis = VY; *t_axis = VZ;
  1465. return true;
  1466. }
  1467. else if (face == 3)
  1468. {
  1469. *s_axis = VX; *t_axis = VZ;
  1470. return true;
  1471. }
  1472. else if (face == 4)
  1473. {
  1474. *s_axis = VY; *t_axis = VZ;
  1475. return true;
  1476. }
  1477. else if (face == 5)
  1478. {
  1479. *s_axis = VX; *t_axis = VY;
  1480. return true;
  1481. }
  1482. else
  1483. {
  1484. // unknown face
  1485. return false;
  1486. }
  1487. }
  1489. //============================================================================
  1491. //static 
  1492. BOOL LLNetworkData::isValid(U16 param_type, U32 size)
  1493. {
  1494. // ew - better mechanism needed
  1496. switch(param_type)
  1497. {
  1498. case PARAMS_FLEXIBLE:
  1499. return (size == 16);
  1500. case PARAMS_LIGHT:
  1501. return (size == 16);
  1502. case PARAMS_SCULPT:
  1503. return (size == 17);
  1504. case PARAMS_LIGHT_IMAGE:
  1505. return (size == 28);
  1506. }
  1508. return FALSE;
  1509. }
  1511. //============================================================================
  1513. LLLightParams::LLLightParams()
  1514. {
  1515. mColor.setToWhite();
  1516. mRadius = 10.f;
  1517. mCutoff = 0.0f;
  1518. mFalloff = 0.75f;
  1520. mType = PARAMS_LIGHT;
  1521. }
  1523. BOOL LLLightParams::pack(LLDataPacker &dp) const
  1524. {
  1525. LLColor4U color4u(mColor);
  1526. dp.packColor4U(color4u, "color");
  1527. dp.packF32(mRadius, "radius");
  1528. dp.packF32(mCutoff, "cutoff");
  1529. dp.packF32(mFalloff, "falloff");
  1530. return TRUE;
  1531. }
  1533. BOOL LLLightParams::unpack(LLDataPacker &dp)
  1534. {
  1535. LLColor4U color;
  1536. dp.unpackColor4U(color, "color");
  1537. setColor(LLColor4(color));
  1539. F32 radius;
  1540. dp.unpackF32(radius, "radius");
  1541. setRadius(radius);
  1543. F32 cutoff;
  1544. dp.unpackF32(cutoff, "cutoff");
  1545. setCutoff(cutoff);
  1547. F32 falloff;
  1548. dp.unpackF32(falloff, "falloff");
  1549. setFalloff(falloff);
  1551. return TRUE;
  1552. }
  1554. bool LLLightParams::operator==(const LLNetworkData& data) const
  1555. {
  1556. if (data.mType != PARAMS_LIGHT)
  1557. {
  1558. return false;
  1559. }
  1560. const LLLightParams *param = (const LLLightParams*)&data;
  1561. if (param->mColor != mColor ||
  1562. param->mRadius != mRadius ||
  1563. param->mCutoff != mCutoff ||
  1564. param->mFalloff != mFalloff)
  1565. {
  1566. return false;
  1567. }
  1568. return true;
  1569. }
  1571. void LLLightParams::copy(const LLNetworkData& data)
  1572. {
  1573. const LLLightParams *param = (LLLightParams*)&data;
  1574. mType = param->mType;
  1575. mColor = param->mColor;
  1576. mRadius = param->mRadius;
  1577. mCutoff = param->mCutoff;
  1578. mFalloff = param->mFalloff;
  1579. }
  1581. LLSD LLLightParams::asLLSD() const
  1582. {
  1583. LLSD sd;
  1585. sd["color"] = ll_sd_from_color4(getColor());
  1586. sd["radius"] = getRadius();
  1587. sd["falloff"] = getFalloff();
  1588. sd["cutoff"] = getCutoff();
  1590. return sd;
  1591. }
  1593. bool LLLightParams::fromLLSD(LLSD& sd)
  1594. {
  1595. const char *w;
  1596. w = "color";
  1597. if (sd.has(w))
  1598. {
  1599. setColor( ll_color4_from_sd(sd["color"]) );
  1600. } else goto fail;
  1601. w = "radius";
  1602. if (sd.has(w))
  1603. {
  1604. setRadius( (F32)sd[w].asReal() );
  1605. } else goto fail;
  1606. w = "falloff";
  1607. if (sd.has(w))
  1608. {
  1609. setFalloff( (F32)sd[w].asReal() );
  1610. } else goto fail;
  1611. w = "cutoff";
  1612. if (sd.has(w))
  1613. {
  1614. setCutoff( (F32)sd[w].asReal() );
  1615. } else goto fail;
  1617. return true;
  1618.  fail:
  1619. return false;
  1620. }
  1622. //============================================================================
  1624. LLFlexibleObjectData::LLFlexibleObjectData()
  1625. {
  1626. mSimulateLOD = FLEXIBLE_OBJECT_DEFAULT_NUM_SECTIONS;
  1627. mGravity = FLEXIBLE_OBJECT_DEFAULT_GRAVITY;
  1628. mAirFriction = FLEXIBLE_OBJECT_DEFAULT_AIR_FRICTION;
  1629. mWindSensitivity = FLEXIBLE_OBJECT_DEFAULT_WIND_SENSITIVITY;
  1630. mTension = FLEXIBLE_OBJECT_DEFAULT_TENSION;
  1631. //mUsingCollisionSphere = FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE;
  1632. //mRenderingCollisionSphere = FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE;
  1633. mUserForce = LLVector3(0.f, 0.f, 0.f);
  1635. mType = PARAMS_FLEXIBLE;
  1636. }
  1638. BOOL LLFlexibleObjectData::pack(LLDataPacker &dp) const
  1639. {
  1640. // Custom, uber-svelte pack "softness" in upper bits of tension & drag
  1641. U8 bit1 = (mSimulateLOD & 2) << 6;
  1642. U8 bit2 = (mSimulateLOD & 1) << 7;
  1643. dp.packU8((U8)(mTension*10.01f) + bit1, "tension");
  1644. dp.packU8((U8)(mAirFriction*10.01f) + bit2, "drag");
  1645. dp.packU8((U8)((mGravity+10.f)*10.01f), "gravity");
  1646. dp.packU8((U8)(mWindSensitivity*10.01f), "wind");
  1647. dp.packVector3(mUserForce, "userforce");
  1648. return TRUE;
  1649. }
  1651. BOOL LLFlexibleObjectData::unpack(LLDataPacker &dp)
  1652. {
  1653. U8 tension, friction, gravity, wind;
  1654. U8 bit1, bit2;
  1655. dp.unpackU8(tension, "tension"); bit1 = (tension >> 6) & 2;
  1656. mTension = ((F32)(tension&0x7f))/10.f;
  1657. dp.unpackU8(friction, "drag"); bit2 = (friction >> 7) & 1;
  1658. mAirFriction = ((F32)(friction&0x7f))/10.f;
  1659. mSimulateLOD = bit1 | bit2;
  1660. dp.unpackU8(gravity, "gravity"); mGravity = ((F32)gravity)/10.f - 10.f;
  1661. dp.unpackU8(wind, "wind"); mWindSensitivity = ((F32)wind)/10.f;
  1662. if (dp.hasNext())
  1663. {
  1664. dp.unpackVector3(mUserForce, "userforce");
  1665. }
  1666. else
  1667. {
  1668. mUserForce.setVec(0.f, 0.f, 0.f);
  1669. }
  1670. return TRUE;
  1671. }
  1673. bool LLFlexibleObjectData::operator==(const LLNetworkData& data) const
  1674. {
  1675. if (data.mType != PARAMS_FLEXIBLE)
  1676. {
  1677. return false;
  1678. }
  1679. LLFlexibleObjectData *flex_data = (LLFlexibleObjectData*)&data;
  1680. return (mSimulateLOD == flex_data->mSimulateLOD &&
  1681. mGravity == flex_data->mGravity &&
  1682. mAirFriction == flex_data->mAirFriction &&
  1683. mWindSensitivity == flex_data->mWindSensitivity &&
  1684. mTension == flex_data->mTension &&
  1685. mUserForce == flex_data->mUserForce);
  1686. //mUsingCollisionSphere == flex_data->mUsingCollisionSphere &&
  1687. //mRenderingCollisionSphere == flex_data->mRenderingCollisionSphere
  1688. }
  1690. void LLFlexibleObjectData::copy(const LLNetworkData& data)
  1691. {
  1692. const LLFlexibleObjectData *flex_data = (LLFlexibleObjectData*)&data;
  1693. mSimulateLOD = flex_data->mSimulateLOD;
  1694. mGravity = flex_data->mGravity;
  1695. mAirFriction = flex_data->mAirFriction;
  1696. mWindSensitivity = flex_data->mWindSensitivity;
  1697. mTension = flex_data->mTension;
  1698. mUserForce = flex_data->mUserForce;
  1699. //mUsingCollisionSphere = flex_data->mUsingCollisionSphere;
  1700. //mRenderingCollisionSphere = flex_data->mRenderingCollisionSphere;
  1701. }
  1703. LLSD LLFlexibleObjectData::asLLSD() const
  1704. {
  1705. LLSD sd;
  1707. sd["air_friction"] = getAirFriction();
  1708. sd["gravity"] = getGravity();
  1709. sd["simulate_lod"] = getSimulateLOD();
  1710. sd["tension"] = getTension();
  1711. sd["user_force"] = getUserForce().getValue();
  1712. sd["wind_sensitivity"] = getWindSensitivity();
  1714. return sd;
  1715. }
  1717. bool LLFlexibleObjectData::fromLLSD(LLSD& sd)
  1718. {
  1719. const char *w;
  1720. w = "air_friction";
  1721. if (sd.has(w))
  1722. {
  1723. setAirFriction( (F32)sd[w].asReal() );
  1724. } else goto fail;
  1725. w = "gravity";
  1726. if (sd.has(w))
  1727. {
  1728. setGravity( (F32)sd[w].asReal() );
  1729. } else goto fail;
  1730. w = "simulate_lod";
  1731. if (sd.has(w))
  1732. {
  1733. setSimulateLOD( sd[w].asInteger() );
  1734. } else goto fail;
  1735. w = "tension";
  1736. if (sd.has(w))
  1737. {
  1738. setTension( (F32)sd[w].asReal() );
  1739. } else goto fail;
  1740. w = "user_force";
  1741. if (sd.has(w))
  1742. {
  1743. LLVector3 user_force = ll_vector3_from_sd(sd[w], 0);
  1744. setUserForce( user_force );
  1745. } else goto fail;
  1746. w = "wind_sensitivity";
  1747. if (sd.has(w))
  1748. {
  1749. setWindSensitivity( (F32)sd[w].asReal() );
  1750. } else goto fail;
  1752. return true;
  1753.  fail:
  1754. return false;
  1755. }
  1757. //============================================================================
  1759. LLSculptParams::LLSculptParams()
  1760. {
  1761. mType = PARAMS_SCULPT;
  1762. mSculptTexture.set(SCULPT_DEFAULT_TEXTURE);
  1763. mSculptType = LL_SCULPT_TYPE_SPHERE;
  1764. }
  1766. BOOL LLSculptParams::pack(LLDataPacker &dp) const
  1767. {
  1768. dp.packUUID(mSculptTexture, "texture");
  1769. dp.packU8(mSculptType, "type");
  1771. return TRUE;
  1772. }
  1774. BOOL LLSculptParams::unpack(LLDataPacker &dp)
  1775. {
  1776. dp.unpackUUID(mSculptTexture, "texture");
  1777. dp.unpackU8(mSculptType, "type");
  1779. return TRUE;
  1780. }
  1782. bool LLSculptParams::operator==(const LLNetworkData& data) const
  1783. {
  1784. if (data.mType != PARAMS_SCULPT)
  1785. {
  1786. return false;
  1787. }
  1789. const LLSculptParams *param = (const LLSculptParams*)&data;
  1790. if ( (param->mSculptTexture != mSculptTexture) ||
  1791.  (param->mSculptType != mSculptType) )
  1792.  
  1793. {
  1794. return false;
  1795. }
  1797. return true;
  1798. }
  1800. void LLSculptParams::copy(const LLNetworkData& data)
  1801. {
  1802. const LLSculptParams *param = (LLSculptParams*)&data;
  1803. mSculptTexture = param->mSculptTexture;
  1804. mSculptType = param->mSculptType;
  1805. }
  1809. LLSD LLSculptParams::asLLSD() const
  1810. {
  1811. LLSD sd;
  1813. sd["texture"] = mSculptTexture;
  1814. sd["type"] = mSculptType;
  1816. return sd;
  1817. }
  1819. bool LLSculptParams::fromLLSD(LLSD& sd)
  1820. {
  1821. const char *w;
  1822. w = "texture";
  1823. if (sd.has(w))
  1824. {
  1825. setSculptTexture( sd[w] );
  1826. } else goto fail;
  1827. w = "type";
  1828. if (sd.has(w))
  1829. {
  1830. setSculptType( (U8)sd[w].asInteger() );
  1831. } else goto fail;
  1833. return true;
  1834.  fail:
  1835. return false;
  1836. }
  1838. //============================================================================
  1840. LLLightImageParams::LLLightImageParams()
  1841. {
  1842. mType = PARAMS_LIGHT_IMAGE;
  1843. mParams.setVec(F_PI*0.5f, 0.f, 0.f);
  1844. }
  1846. BOOL LLLightImageParams::pack(LLDataPacker &dp) const
  1847. {
  1848. dp.packUUID(mLightTexture, "texture");
  1849. dp.packVector3(mParams, "params");
  1851. return TRUE;
  1852. }
  1854. BOOL LLLightImageParams::unpack(LLDataPacker &dp)
  1855. {
  1856. dp.unpackUUID(mLightTexture, "texture");
  1857. dp.unpackVector3(mParams, "params");
  1859. return TRUE;
  1860. }
  1862. bool LLLightImageParams::operator==(const LLNetworkData& data) const
  1863. {
  1864. if (data.mType != PARAMS_LIGHT_IMAGE)
  1865. {
  1866. return false;
  1867. }
  1869. const LLLightImageParams *param = (const LLLightImageParams*)&data;
  1870. if ( (param->mLightTexture != mLightTexture) )
  1871. {
  1872. return false;
  1873. }
  1875. if ( (param->mParams != mParams ) )
  1876. {
  1877. return false;
  1878. }
  1880. return true;
  1881. }
  1883. void LLLightImageParams::copy(const LLNetworkData& data)
  1884. {
  1885. const LLLightImageParams *param = (LLLightImageParams*)&data;
  1886. mLightTexture = param->mLightTexture;
  1887. mParams = param->mParams;
  1888. }
  1892. LLSD LLLightImageParams::asLLSD() const
  1893. {
  1894. LLSD sd;
  1896. sd["texture"] = mLightTexture;
  1897. sd["params"] = mParams.getValue();
  1899. return sd;
  1900. }
  1902. bool LLLightImageParams::fromLLSD(LLSD& sd)
  1903. {
  1904. if (sd.has("texture"))
  1905. {
  1906. setLightTexture( sd["texture"] );
  1907. setParams( LLVector3( sd["params"] ) );
  1908. return true;
  1909. } 
  1911. return false;
  1912. }