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

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

游戏引擎

开发平台：

C++ Builder

llvolume.h：源码内容
  1. /** 
  2.  * @file llvolume.h
  3.  * @brief LLVolume base class.
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #ifndef LL_LLVOLUME_H
  34. #define LL_LLVOLUME_H
  36. #include <iostream>
  38. class LLProfileParams;
  39. class LLPathParams;
  40. class LLVolumeParams;
  41. class LLProfile;
  42. class LLPath;
  43. class LLVolumeFace;
  44. class LLVolume;
  46. #include "lldarray.h"
  47. #include "lluuid.h"
  48. #include "v4color.h"
  49. //#include "vmath.h"
  50. #include "v2math.h"
  51. #include "v3math.h"
  52. #include "llquaternion.h"
  53. #include "llstrider.h"
  54. #include "v4coloru.h"
  55. #include "llrefcount.h"
  56. #include "llfile.h"
  58. //============================================================================
  60. const S32 MIN_DETAIL_FACES = 6;
  61. const S32 MIN_LOD = 0;
  62. const S32 MAX_LOD = 3;
  64. // These are defined here but are not enforced at this level,
  65. // rather they are here for the convenience of code that uses
  66. // the LLVolume class.
  67. const F32 MIN_VOLUME_PROFILE_WIDTH  = 0.05f;
  68. const F32 MIN_VOLUME_PATH_WIDTH  = 0.05f;
  70. const F32 CUT_QUANTA    = 0.00002f;
  71. const F32 SCALE_QUANTA  = 0.01f;
  72. const F32 SHEAR_QUANTA  = 0.01f;
  73. const F32 TAPER_QUANTA  = 0.01f;
  74. const F32 REV_QUANTA    = 0.015f;
  75. const F32 HOLLOW_QUANTA = 0.00002f;
  77. const S32 MAX_VOLUME_TRIANGLE_INDICES = 10000;
  79. //============================================================================
  81. // useful masks
  82. const LLPCode LL_PCODE_HOLLOW_MASK  = 0x80; // has a thickness
  83. const LLPCode LL_PCODE_SEGMENT_MASK = 0x40; // segments (1 angle)
  84. const LLPCode LL_PCODE_PATCH_MASK  = 0x20; // segmented segments (2 angles)
  85. const LLPCode LL_PCODE_HEMI_MASK  = 0x10; // half-primitives get their own type per PR's dictum
  86. const LLPCode LL_PCODE_BASE_MASK  = 0x0F;
  88. // primitive shapes
  89. const LLPCode LL_PCODE_CUBE  = 1;
  90. const LLPCode LL_PCODE_PRISM  = 2;
  91. const LLPCode LL_PCODE_TETRAHEDRON  = 3;
  92. const LLPCode LL_PCODE_PYRAMID  = 4;
  93. const LLPCode LL_PCODE_CYLINDER  = 5;
  94. const LLPCode LL_PCODE_CONE  = 6;
  95. const LLPCode LL_PCODE_SPHERE  = 7;
  96. const LLPCode LL_PCODE_TORUS  = 8;
  97. const LLPCode LL_PCODE_VOLUME = 9;
  99. // surfaces
  100. //const LLPCode LL_PCODE_SURFACE_TRIANGLE  = 10;
  101. //const LLPCode LL_PCODE_SURFACE_SQUARE  = 11;
  102. //const LLPCode LL_PCODE_SURFACE_DISC  = 12;
  104. const LLPCode LL_PCODE_APP = 14; // App specific pcode (for viewer/sim side only objects)
  105. const LLPCode LL_PCODE_LEGACY = 15;
  107. // Pcodes for legacy objects
  108. //const LLPCode LL_PCODE_LEGACY_ATOR = 0x10 | LL_PCODE_LEGACY; // ATOR
  109. const LLPCode LL_PCODE_LEGACY_AVATAR = 0x20 | LL_PCODE_LEGACY; // PLAYER
  110. //const LLPCode LL_PCODE_LEGACY_BIRD = 0x30 | LL_PCODE_LEGACY; // BIRD
  111. //const LLPCode LL_PCODE_LEGACY_DEMON = 0x40 | LL_PCODE_LEGACY; // DEMON
  112. const LLPCode LL_PCODE_LEGACY_GRASS = 0x50 | LL_PCODE_LEGACY; // GRASS
  113. const LLPCode LL_PCODE_TREE_NEW = 0x60 | LL_PCODE_LEGACY; // new trees
  114. //const LLPCode LL_PCODE_LEGACY_ORACLE = 0x70 | LL_PCODE_LEGACY; // ORACLE
  115. const LLPCode LL_PCODE_LEGACY_PART_SYS = 0x80 | LL_PCODE_LEGACY; // PART_SYS
  116. const LLPCode LL_PCODE_LEGACY_ROCK = 0x90 | LL_PCODE_LEGACY; // ROCK
  117. //const LLPCode LL_PCODE_LEGACY_SHOT = 0xA0 | LL_PCODE_LEGACY; // BASIC_SHOT
  118. //const LLPCode LL_PCODE_LEGACY_SHOT_BIG = 0xB0 | LL_PCODE_LEGACY;
  119. //const LLPCode LL_PCODE_LEGACY_SMOKE = 0xC0 | LL_PCODE_LEGACY; // SMOKE
  120. //const LLPCode LL_PCODE_LEGACY_SPARK = 0xD0 | LL_PCODE_LEGACY;// SPARK
  121. const LLPCode LL_PCODE_LEGACY_TEXT_BUBBLE = 0xE0 | LL_PCODE_LEGACY; // TEXTBUBBLE
  122. const LLPCode LL_PCODE_LEGACY_TREE = 0xF0 | LL_PCODE_LEGACY; // TREE
  124. // hemis
  125. const LLPCode LL_PCODE_CYLINDER_HEMI = LL_PCODE_CYLINDER | LL_PCODE_HEMI_MASK;
  126. const LLPCode LL_PCODE_CONE_HEMI = LL_PCODE_CONE | LL_PCODE_HEMI_MASK;
  127. const LLPCode LL_PCODE_SPHERE_HEMI = LL_PCODE_SPHERE | LL_PCODE_HEMI_MASK;
  128. const LLPCode LL_PCODE_TORUS_HEMI = LL_PCODE_TORUS | LL_PCODE_HEMI_MASK;
  131. // Volumes consist of a profile at the base that is swept around
  132. // a path to make a volume.
  133. // The profile code
  134. const U8 LL_PCODE_PROFILE_MASK = 0x0f;
  135. const U8 LL_PCODE_PROFILE_MIN = 0x00;
  136. const U8    LL_PCODE_PROFILE_CIRCLE = 0x00;
  137. const U8    LL_PCODE_PROFILE_SQUARE = 0x01;
  138. const U8 LL_PCODE_PROFILE_ISOTRI = 0x02;
  139. const U8    LL_PCODE_PROFILE_EQUALTRI = 0x03;
  140. const U8    LL_PCODE_PROFILE_RIGHTTRI = 0x04;
  141. const U8 LL_PCODE_PROFILE_CIRCLE_HALF = 0x05;
  142. const U8 LL_PCODE_PROFILE_MAX = 0x05;
  144. // Stored in the profile byte
  145. const U8 LL_PCODE_HOLE_MASK = 0xf0;
  146. const U8 LL_PCODE_HOLE_MIN = 0x00;   
  147. const U8 LL_PCODE_HOLE_SAME = 0x00; // same as outside profile
  148. const U8 LL_PCODE_HOLE_CIRCLE = 0x10;
  149. const U8 LL_PCODE_HOLE_SQUARE = 0x20;
  150. const U8 LL_PCODE_HOLE_TRIANGLE = 0x30;
  151. const U8 LL_PCODE_HOLE_MAX = 0x03; // min/max needs to be >> 4 of real min/max
  153. const U8    LL_PCODE_PATH_IGNORE    = 0x00;
  154. const U8 LL_PCODE_PATH_MIN = 0x01; // min/max needs to be >> 4 of real min/max
  155. const U8    LL_PCODE_PATH_LINE      = 0x10;
  156. const U8    LL_PCODE_PATH_CIRCLE    = 0x20;
  157. const U8    LL_PCODE_PATH_CIRCLE2   = 0x30;
  158. const U8    LL_PCODE_PATH_TEST      = 0x40;
  159. const U8    LL_PCODE_PATH_FLEXIBLE  = 0x80;
  160. const U8 LL_PCODE_PATH_MAX = 0x08;
  162. //============================================================================
  164. // face identifiers
  165. typedef U16 LLFaceID;
  167. const LLFaceID LL_FACE_PATH_BEGIN = 0x1 << 0;
  168. const LLFaceID LL_FACE_PATH_END = 0x1 << 1;
  169. const LLFaceID LL_FACE_INNER_SIDE = 0x1 << 2;
  170. const LLFaceID LL_FACE_PROFILE_BEGIN = 0x1 << 3;
  171. const LLFaceID LL_FACE_PROFILE_END = 0x1 << 4;
  172. const LLFaceID LL_FACE_OUTER_SIDE_0 = 0x1 << 5;
  173. const LLFaceID LL_FACE_OUTER_SIDE_1 = 0x1 << 6;
  174. const LLFaceID LL_FACE_OUTER_SIDE_2 = 0x1 << 7;
  175. const LLFaceID LL_FACE_OUTER_SIDE_3 = 0x1 << 8;
  177. //============================================================================
  179. // sculpt types + flags
  181. const U8 LL_SCULPT_TYPE_NONE      = 0;
  182. const U8 LL_SCULPT_TYPE_SPHERE    = 1;
  183. const U8 LL_SCULPT_TYPE_TORUS     = 2;
  184. const U8 LL_SCULPT_TYPE_PLANE     = 3;
  185. const U8 LL_SCULPT_TYPE_CYLINDER  = 4;
  187. const U8 LL_SCULPT_TYPE_MASK      = LL_SCULPT_TYPE_SPHERE | LL_SCULPT_TYPE_TORUS | LL_SCULPT_TYPE_PLANE | LL_SCULPT_TYPE_CYLINDER;
  189. const U8 LL_SCULPT_FLAG_INVERT    = 64;
  190. const U8 LL_SCULPT_FLAG_MIRROR    = 128;
  193. class LLProfileParams
  194. {
  195. public:
  196. LLProfileParams()
  197. : mCurveType(LL_PCODE_PROFILE_SQUARE),
  198.   mBegin(0.f),
  199.   mEnd(1.f),
  200.   mHollow(0.f),
  201.   mCRC(0)
  202. {
  203. }
  205. LLProfileParams(U8 curve, F32 begin, F32 end, F32 hollow)
  206. : mCurveType(curve),
  207.   mBegin(begin),
  208.   mEnd(end),
  209.   mHollow(hollow),
  210.   mCRC(0)
  211. {
  212. }
  214. LLProfileParams(U8 curve, U16 begin, U16 end, U16 hollow)
  215. {
  216. mCurveType = curve;
  217. F32 temp_f32 = begin * CUT_QUANTA;
  218. if (temp_f32 > 1.f)
  219. {
  220. temp_f32 = 1.f;
  221. }
  222. mBegin = temp_f32;
  223. temp_f32 = end * CUT_QUANTA;
  224. if (temp_f32 > 1.f)
  225. {
  226. temp_f32 = 1.f;
  227. }
  228. mEnd = 1.f - temp_f32;
  229. temp_f32 = hollow * HOLLOW_QUANTA;
  230. if (temp_f32 > 1.f)
  231. {
  232. temp_f32 = 1.f;
  233. }
  234. mHollow = temp_f32;
  235. mCRC = 0;
  236. }
  238. bool operator==(const LLProfileParams &params) const;
  239. bool operator!=(const LLProfileParams &params) const;
  240. bool operator<(const LLProfileParams &params) const;
  242. void copyParams(const LLProfileParams &params);
  244. BOOL importFile(LLFILE *fp);
  245. BOOL exportFile(LLFILE *fp) const;
  247. BOOL importLegacyStream(std::istream& input_stream);
  248. BOOL exportLegacyStream(std::ostream& output_stream) const;
  250. LLSD asLLSD() const;
  251. operator LLSD() const { return asLLSD(); }
  252. bool fromLLSD(LLSD& sd);
  254. const F32&  getBegin () const { return mBegin; }
  255. const F32&  getEnd   () const { return mEnd;   }
  256. const F32&  getHollow() const { return mHollow; }
  257. const U8&   getCurveType () const { return mCurveType; }
  259. void setCurveType(const U32 type) { mCurveType = type;}
  260. void setBegin(const F32 begin) { mBegin = (begin >= 1.0f) ? 0.0f : ((int) (begin * 100000))/100000.0f;}
  261. void setEnd(const F32 end) { mEnd   = (end   <= 0.0f) ? 1.0f : ((int) (end * 100000))/100000.0f;}
  262. void setHollow(const F32 hollow) { mHollow = ((int) (hollow * 100000))/100000.0f;}
  264. friend std::ostream& operator<<(std::ostream &s, const LLProfileParams &profile_params);
  266. protected:
  267. // Profile params
  268. U8   mCurveType;
  269. F32           mBegin;
  270. F32           mEnd;
  271. F32   mHollow;
  273. U32           mCRC;
  274. };
  276. inline bool LLProfileParams::operator==(const LLProfileParams &params) const
  277. {
  278. return 
  279. (getCurveType() == params.getCurveType()) &&
  280. (getBegin() == params.getBegin()) &&
  281. (getEnd() == params.getEnd()) &&
  282. (getHollow() == params.getHollow());
  283. }
  285. inline bool LLProfileParams::operator!=(const LLProfileParams &params) const
  286. {
  287. return 
  288. (getCurveType() != params.getCurveType()) ||
  289. (getBegin() != params.getBegin()) ||
  290. (getEnd() != params.getEnd()) ||
  291. (getHollow() != params.getHollow());
  292. }
  295. inline bool LLProfileParams::operator<(const LLProfileParams &params) const
  296. {
  297. if (getCurveType() != params.getCurveType())
  298. {
  299. return getCurveType() < params.getCurveType();
  300. }
  301. else
  302. if (getBegin() != params.getBegin())
  303. {
  304. return getBegin() < params.getBegin();
  305. }
  306. else
  307. if (getEnd() != params.getEnd())
  308. {
  309. return getEnd() < params.getEnd();
  310. }
  311. else
  312. {
  313. return getHollow() < params.getHollow();
  314. }
  315. }
  317. #define U8_TO_F32(x) (F32)(*((S8 *)&x))
  319. class LLPathParams
  320. {
  321. public:
  322. LLPathParams()
  323. :
  324. mCurveType(LL_PCODE_PATH_LINE),
  325. mBegin(0.f),
  326. mEnd(1.f),
  327. mScale(1.f,1.f),
  328. mShear(0.f,0.f),
  329. mTwistBegin(0.f),
  330. mTwistEnd(0.f),
  331. mRadiusOffset(0.f),
  332. mTaper(0.f,0.f),
  333. mRevolutions(1.f),
  334. mSkew(0.f),
  335. mCRC(0)
  336. {
  337. }
  339. LLPathParams(U8 curve, F32 begin, F32 end, F32 scx, F32 scy, F32 shx, F32 shy, F32 twistend, F32 twistbegin, F32 radiusoffset, F32 tx, F32 ty, F32 revolutions, F32 skew)
  340. : mCurveType(curve),
  341.   mBegin(begin),
  342.   mEnd(end),
  343.   mScale(scx,scy),
  344.   mShear(shx,shy),
  345.   mTwistBegin(twistbegin),
  346.   mTwistEnd(twistend), 
  347.   mRadiusOffset(radiusoffset),
  348.   mTaper(tx,ty),
  349.   mRevolutions(revolutions),
  350.   mSkew(skew),
  351.   mCRC(0)
  352. {
  353. }
  355. LLPathParams(U8 curve, U16 begin, U16 end, U8 scx, U8 scy, U8 shx, U8 shy, U8 twistend, U8 twistbegin, U8 radiusoffset, U8 tx, U8 ty, U8 revolutions, U8 skew)
  356. {
  357. mCurveType = curve;
  358. mBegin = (F32)(begin * CUT_QUANTA);
  359. mEnd = (F32)(100.f - end) * CUT_QUANTA;
  360. if (mEnd > 1.f)
  361. mEnd = 1.f;
  362. mScale.setVec((F32) (200 - scx) * SCALE_QUANTA,(F32) (200 - scy) * SCALE_QUANTA);
  363. mShear.setVec(U8_TO_F32(shx) * SHEAR_QUANTA,U8_TO_F32(shy) * SHEAR_QUANTA);
  364. mTwistBegin = U8_TO_F32(twistbegin) * SCALE_QUANTA;
  365. mTwistEnd = U8_TO_F32(twistend) * SCALE_QUANTA;
  366. mRadiusOffset = U8_TO_F32(radiusoffset) * SCALE_QUANTA;
  367. mTaper.setVec(U8_TO_F32(tx) * TAPER_QUANTA,U8_TO_F32(ty) * TAPER_QUANTA);
  368. mRevolutions = ((F32)revolutions) * REV_QUANTA + 1.0f;
  369. mSkew = U8_TO_F32(skew) * SCALE_QUANTA;
  371. mCRC = 0;
  372. }
  374. bool operator==(const LLPathParams &params) const;
  375. bool operator!=(const LLPathParams &params) const;
  376. bool operator<(const LLPathParams &params) const;
  378. void copyParams(const LLPathParams &params);
  380. BOOL importFile(LLFILE *fp);
  381. BOOL exportFile(LLFILE *fp) const;
  383. BOOL importLegacyStream(std::istream& input_stream);
  384. BOOL exportLegacyStream(std::ostream& output_stream) const;
  386. LLSD asLLSD() const;
  387. operator LLSD() const { return asLLSD(); }
  388. bool fromLLSD(LLSD& sd);
  390. const F32& getBegin() const { return mBegin; }
  391. const F32& getEnd() const { return mEnd; }
  392. const LLVector2 &getScale() const { return mScale; }
  393. const F32& getScaleX() const { return mScale.mV[0]; }
  394. const F32& getScaleY() const { return mScale.mV[1]; }
  395. const LLVector2 getBeginScale() const;
  396. const LLVector2 getEndScale() const;
  397. const LLVector2 &getShear() const { return mShear; }
  398. const F32& getShearX() const { return mShear.mV[0]; }
  399. const F32& getShearY() const { return mShear.mV[1]; }
  400. const U8& getCurveType () const { return mCurveType; }
  402. const F32& getTwistBegin() const { return mTwistBegin; }
  403. const F32& getTwistEnd() const { return mTwistEnd; }
  404. const F32& getTwist() const { return mTwistEnd; } // deprecated
  405. const F32& getRadiusOffset() const { return mRadiusOffset; }
  406. const LLVector2 &getTaper() const { return mTaper; }
  407. const F32& getTaperX() const { return mTaper.mV[0]; }
  408. const F32& getTaperY() const { return mTaper.mV[1]; }
  409. const F32& getRevolutions() const { return mRevolutions; }
  410. const F32& getSkew() const { return mSkew; }
  412. void setCurveType(const U8 type) { mCurveType = type; }
  413. void setBegin(const F32 begin) { mBegin     = begin; }
  414. void setEnd(const F32 end) { mEnd       = end; }
  416. void setScale(const F32 x, const F32 y) { mScale.setVec(x,y); }
  417. void setScaleX(const F32 v) { mScale.mV[VX] = v; }
  418. void setScaleY(const F32 v) { mScale.mV[VY] = v; }
  419. void setShear(const F32 x, const F32 y) { mShear.setVec(x,y); }
  420. void setShearX(const F32 v) { mShear.mV[VX] = v; }
  421. void setShearY(const F32 v) { mShear.mV[VY] = v; }
  423. void setTwistBegin(const F32 twist_begin) { mTwistBegin = twist_begin; }
  424. void setTwistEnd(const F32 twist_end) { mTwistEnd = twist_end; }
  425. void setTwist(const F32 twist) { setTwistEnd(twist); } // deprecated
  426. void setRadiusOffset(const F32 radius_offset){ mRadiusOffset = radius_offset; }
  427. void setTaper(const F32 x, const F32 y) { mTaper.setVec(x,y); }
  428. void setTaperX(const F32 v) { mTaper.mV[VX] = v; }
  429. void setTaperY(const F32 v) { mTaper.mV[VY] = v; }
  430. void setRevolutions(const F32 revolutions) { mRevolutions = revolutions; }
  431. void setSkew(const F32 skew) { mSkew = skew; }
  433. friend std::ostream& operator<<(std::ostream &s, const LLPathParams &path_params);
  435. protected:
  436. // Path params
  437. U8   mCurveType;
  438. F32           mBegin;
  439. F32           mEnd;
  440. LLVector2   mScale;
  441. LLVector2     mShear;
  443. F32   mTwistBegin;
  444. F32   mTwistEnd;
  445. F32   mRadiusOffset;
  446. LLVector2   mTaper;
  447. F32   mRevolutions;
  448. F32   mSkew;
  450. U32           mCRC;
  451. };
  453. inline bool LLPathParams::operator==(const LLPathParams &params) const
  454. {
  455. return
  456. (getCurveType() == params.getCurveType()) && 
  457. (getScale() == params.getScale()) &&
  458. (getBegin() == params.getBegin()) && 
  459. (getEnd() == params.getEnd()) && 
  460. (getShear() == params.getShear()) &&
  461. (getTwist() == params.getTwist()) &&
  462. (getTwistBegin() == params.getTwistBegin()) &&
  463. (getRadiusOffset() == params.getRadiusOffset()) &&
  464. (getTaper() == params.getTaper()) &&
  465. (getRevolutions() == params.getRevolutions()) &&
  466. (getSkew() == params.getSkew());
  467. }
  469. inline bool LLPathParams::operator!=(const LLPathParams &params) const
  470. {
  471. return
  472. (getCurveType() != params.getCurveType()) ||
  473. (getScale() != params.getScale()) ||
  474. (getBegin() != params.getBegin()) || 
  475. (getEnd() != params.getEnd()) || 
  476. (getShear() != params.getShear()) ||
  477. (getTwist() != params.getTwist()) ||
  478. (getTwistBegin() !=params.getTwistBegin()) ||
  479. (getRadiusOffset() != params.getRadiusOffset()) ||
  480. (getTaper() != params.getTaper()) ||
  481. (getRevolutions() != params.getRevolutions()) ||
  482. (getSkew() != params.getSkew());
  483. }
  486. inline bool LLPathParams::operator<(const LLPathParams &params) const
  487. {
  488. if( getCurveType() != params.getCurveType()) 
  489. {
  490. return getCurveType() < params.getCurveType();
  491. }
  492. else
  493. if( getScale() != params.getScale()) 
  494. {
  495. return getScale() < params.getScale();
  496. }
  497. else
  498. if( getBegin() != params.getBegin()) 
  499. {
  500. return getBegin() < params.getBegin();
  501. }
  502. else
  503. if( getEnd() != params.getEnd()) 
  504. {
  505. return getEnd() < params.getEnd();
  506. }
  507. else
  508. if( getShear() != params.getShear()) 
  509. {
  510. return getShear() < params.getShear();
  511. }
  512. else
  513. if( getTwist() != params.getTwist())
  514. {
  515. return getTwist() < params.getTwist();
  516. }
  517. else
  518. if( getTwistBegin() != params.getTwistBegin())
  519. {
  520. return getTwistBegin() < params.getTwistBegin();
  521. }
  522. else
  523. if( getRadiusOffset() != params.getRadiusOffset())
  524. {
  525. return getRadiusOffset() < params.getRadiusOffset();
  526. }
  527. else
  528. if( getTaper() != params.getTaper())
  529. {
  530. return getTaper() < params.getTaper();
  531. }
  532. else
  533. if( getRevolutions() != params.getRevolutions())
  534. {
  535. return getRevolutions() < params.getRevolutions();
  536. }
  537. else
  538. {
  539. return getSkew() < params.getSkew();
  540. }
  541. }
  543. typedef LLVolumeParams* LLVolumeParamsPtr;
  544. typedef const LLVolumeParams* const_LLVolumeParamsPtr;
  546. class LLVolumeParams
  547. {
  548. public:
  549. LLVolumeParams()
  550. : mSculptType(LL_SCULPT_TYPE_NONE)
  551. {
  552. }
  554. LLVolumeParams(LLProfileParams &profile, LLPathParams &path,
  555.    LLUUID sculpt_id = LLUUID::null, U8 sculpt_type = LL_SCULPT_TYPE_NONE)
  556. : mProfileParams(profile), mPathParams(path), mSculptID(sculpt_id), mSculptType(sculpt_type)
  557. {
  558. }
  560. bool operator==(const LLVolumeParams &params) const;
  561. bool operator!=(const LLVolumeParams &params) const;
  562. bool operator<(const LLVolumeParams &params) const;
  565. void copyParams(const LLVolumeParams &params);
  567. const LLProfileParams &getProfileParams() const {return mProfileParams;}
  568. LLProfileParams &getProfileParams() {return mProfileParams;}
  569. const LLPathParams &getPathParams() const {return mPathParams;}
  570. LLPathParams &getPathParams() {return mPathParams;}
  572. BOOL importFile(LLFILE *fp);
  573. BOOL exportFile(LLFILE *fp) const;
  575. BOOL importLegacyStream(std::istream& input_stream);
  576. BOOL exportLegacyStream(std::ostream& output_stream) const;
  578. LLSD asLLSD() const;
  579. operator LLSD() const { return asLLSD(); }
  580. bool fromLLSD(LLSD& sd);
  582. bool setType(U8 profile, U8 path);
  584. //void setBeginS(const F32 beginS) { mProfileParams.setBegin(beginS); } // range 0 to 1
  585. //void setBeginT(const F32 beginT) { mPathParams.setBegin(beginT); } // range 0 to 1
  586. //void setEndS(const F32 endS) { mProfileParams.setEnd(endS); } // range 0 to 1, must be greater than begin
  587. //void setEndT(const F32 endT) { mPathParams.setEnd(endT); } // range 0 to 1, must be greater than begin
  589. bool setBeginAndEndS(const F32 begin, const F32 end); // both range from 0 to 1, begin must be less than end
  590. bool setBeginAndEndT(const F32 begin, const F32 end); // both range from 0 to 1, begin must be less than end
  592. bool setHollow(const F32 hollow); // range 0 to 1
  593. bool setRatio(const F32 x) { return setRatio(x,x); } // 0 = point, 1 = same as base
  594. bool setShear(const F32 x) { return setShear(x,x); } // 0 = no movement, 
  595. bool setRatio(const F32 x, const F32 y); // 0 = point, 1 = same as base
  596. bool setShear(const F32 x, const F32 y); // 0 = no movement
  598. bool setTwistBegin(const F32 twist_begin); // range -1 to 1
  599. bool setTwistEnd(const F32 twist_end); // range -1 to 1
  600. bool setTwist(const F32 twist) { return setTwistEnd(twist); } // deprecated
  601. bool setTaper(const F32 x, const F32 y) { bool pass_x = setTaperX(x); bool pass_y = setTaperY(y); return pass_x && pass_y; }
  602. bool setTaperX(const F32 v); // -1 to 1
  603. bool setTaperY(const F32 v); // -1 to 1
  604. bool setRevolutions(const F32 revolutions); // 1 to 4
  605. bool setRadiusOffset(const F32 radius_offset);
  606. bool setSkew(const F32 skew);
  607. bool setSculptID(const LLUUID sculpt_id, U8 sculpt_type);
  609. static bool validate(U8 prof_curve, F32 prof_begin, F32 prof_end, F32 hollow,
  610. U8 path_curve, F32 path_begin, F32 path_end,
  611. F32 scx, F32 scy, F32 shx, F32 shy,
  612. F32 twistend, F32 twistbegin, F32 radiusoffset,
  613. F32 tx, F32 ty, F32 revolutions, F32 skew);
  615. const F32&  getBeginS()  const { return mProfileParams.getBegin(); }
  616.   const F32&  getBeginT()  const { return mPathParams.getBegin(); }
  617.   const F32&  getEndS()  const { return mProfileParams.getEnd(); }
  618.   const F32&  getEndT()  const { return mPathParams.getEnd(); }
  619.  
  620.   const F32&  getHollow()  const   { return mProfileParams.getHollow(); }
  621.   const F32&  getTwist()  const    { return mPathParams.getTwist(); }
  622.   const F32&  getRatio()  const { return mPathParams.getScaleX(); }
  623.   const F32&  getRatioX()  const   { return mPathParams.getScaleX(); }
  624.   const F32&  getRatioY()  const   { return mPathParams.getScaleY(); }
  625.   const F32&  getShearX()  const   { return mPathParams.getShearX(); }
  626.   const F32&  getShearY()  const   { return mPathParams.getShearY(); }
  628. const F32& getTwistBegin()const { return mPathParams.getTwistBegin(); }
  629. const F32&  getRadiusOffset() const { return mPathParams.getRadiusOffset(); }
  630. const F32&  getTaper() const { return mPathParams.getTaperX(); }
  631. const F32& getTaperX() const { return mPathParams.getTaperX(); }
  632. const F32&  getTaperY() const { return mPathParams.getTaperY(); }
  633. const F32&  getRevolutions() const { return mPathParams.getRevolutions(); }
  634. const F32&  getSkew() const { return mPathParams.getSkew(); }
  635. const LLUUID& getSculptID() const { return mSculptID; }
  636. const U8& getSculptType() const     { return mSculptType;                   }
  638. BOOL isConvex() const;
  640. // 'begin' and 'end' should be in range [0, 1] (they will be clamped)
  641. // (begin, end) = (0, 1) will not change the volume
  642. // (begin, end) = (0, 0.5) will reduce the volume to the first half of its profile/path (S/T)
  643. void reduceS(F32 begin, F32 end);
  644. void reduceT(F32 begin, F32 end);
  646. struct compare
  647. {
  648. bool operator()( const const_LLVolumeParamsPtr& first, const const_LLVolumeParamsPtr& second) const
  649. {
  650. return (*first < *second);
  651. }
  652. };
  654. friend std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params);
  656. // debug helper functions
  657. void setCube();
  659. protected:
  660. LLProfileParams mProfileParams;
  661. LLPathParams mPathParams;
  662. LLUUID mSculptID;
  663. U8 mSculptType;
  664. };
  667. class LLProfile
  668. {
  669. public:
  670. LLProfile()
  671. : mOpen(FALSE),
  672.   mConcave(FALSE),
  673.   mDirty(TRUE),
  674.   mTotalOut(0),
  675.   mTotal(2)
  676. {
  677. }
  679. ~LLProfile();
  681. S32  getTotal() const { return mTotal; }
  682. S32  getTotalOut() const { return mTotalOut; } // Total number of outside points
  683. BOOL isFlat(S32 face) const { return (mFaces[face].mCount == 2); }
  684. BOOL isOpen() const { return mOpen; }
  685. void setDirty() { mDirty     = TRUE; }
  686. BOOL generate(const LLProfileParams& params, BOOL path_open, F32 detail = 1.0f, S32 split = 0,
  687.   BOOL is_sculpted = FALSE, S32 sculpt_size = 0);
  688. BOOL isConcave() const { return mConcave; }
  689. public:
  690. struct Face
  691. {
  692. S32       mIndex;
  693. S32       mCount;
  694. F32       mScaleU;
  695. BOOL      mCap;
  696. BOOL      mFlat;
  697. LLFaceID  mFaceID;
  698. };
  700. std::vector<LLVector3> mProfile;
  701. std::vector<LLVector2> mNormals;
  702. std::vector<Face>      mFaces;
  703. std::vector<LLVector3> mEdgeNormals;
  704. std::vector<LLVector3> mEdgeCenters;
  706. friend std::ostream& operator<<(std::ostream &s, const LLProfile &profile);
  708. protected:
  709. void genNormals(const LLProfileParams& params);
  710. void genNGon(const LLProfileParams& params, S32 sides, F32 offset=0.0f, F32 bevel = 0.0f, F32 ang_scale = 1.f, S32 split = 0);
  712. Face* addHole(const LLProfileParams& params, BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split = 0);
  713. Face* addCap (S16 faceID);
  714. Face* addFace(S32 index, S32 count, F32 scaleU, S16 faceID, BOOL flat);
  716. protected:
  717. BOOL   mOpen;
  718. BOOL   mConcave;
  719. BOOL          mDirty;
  721. S32   mTotalOut;
  722. S32   mTotal;
  723. };
  725. //-------------------------------------------------------------------
  726. // SWEEP/EXTRUDE PATHS
  727. //-------------------------------------------------------------------
  729. class LLPath
  730. {
  731. public:
  732. struct PathPt
  733. {
  734. LLVector3  mPos;
  735. LLVector2    mScale;
  736. LLQuaternion mRot;
  737. F32  mTexT;
  738. PathPt() { mPos.setVec(0,0,0); mTexT = 0; mScale.setVec(0,0); mRot.loadIdentity(); }
  739. };
  741. public:
  742. LLPath()
  743. : mOpen(FALSE),
  744.   mTotal(0),
  745.   mDirty(TRUE),
  746.   mStep(1)
  747. {
  748. }
  750. virtual ~LLPath();
  752. void genNGon(const LLPathParams& params, S32 sides, F32 offset=0.0f, F32 end_scale = 1.f, F32 twist_scale = 1.f);
  753. virtual BOOL generate(const LLPathParams& params, F32 detail=1.0f, S32 split = 0,
  754.   BOOL is_sculpted = FALSE, S32 sculpt_size = 0);
  756. BOOL isOpen() const { return mOpen; }
  757. F32 getStep() const { return mStep; }
  758. void setDirty() { mDirty     = TRUE; }
  760. S32 getPathLength() const { return (S32)mPath.size(); }
  762. void resizePath(S32 length) { mPath.resize(length); }
  764. friend std::ostream& operator<<(std::ostream &s, const LLPath &path);
  766. public:
  767. std::vector<PathPt> mPath;
  769. protected:
  770. BOOL   mOpen;
  771. S32   mTotal;
  772. BOOL          mDirty;
  773. F32           mStep;
  774. };
  776. class LLDynamicPath : public LLPath
  777. {
  778. public:
  779. LLDynamicPath() : LLPath() { }
  780. /*virtual*/ BOOL generate(const LLPathParams& params, F32 detail=1.0f, S32 split = 0,
  781.   BOOL is_sculpted = FALSE, S32 sculpt_size = 0);
  782. };
  784. // Yet another "face" class - caches volume-specific, but not instance-specific data for faces)
  785. class LLVolumeFace
  786. {
  787. public:
  788. LLVolumeFace() : 
  789. mID(0),
  790. mTypeMask(0),
  791. mHasBinormals(FALSE),
  792. mBeginS(0),
  793. mBeginT(0),
  794. mNumS(0),
  795. mNumT(0)
  796. {
  797. }
  799. BOOL create(LLVolume* volume, BOOL partial_build = FALSE);
  800. void createBinormals();
  802. class VertexData
  803. {
  804. public:
  805. LLVector3 mPosition;
  806. LLVector3 mNormal;
  807. LLVector3 mBinormal;
  808. LLVector2 mTexCoord;
  809. };
  811. enum
  812. {
  813. SINGLE_MASK = 0x0001,
  814. CAP_MASK = 0x0002,
  815. END_MASK = 0x0004,
  816. SIDE_MASK = 0x0008,
  817. INNER_MASK = 0x0010,
  818. OUTER_MASK = 0x0020,
  819. HOLLOW_MASK = 0x0040,
  820. OPEN_MASK = 0x0080,
  821. FLAT_MASK = 0x0100,
  822. TOP_MASK = 0x0200,
  823. BOTTOM_MASK = 0x0400
  824. };
  826. public:
  827. S32 mID;
  828. U32 mTypeMask;
  829. LLVector3 mCenter;
  830. BOOL mHasBinormals;
  832. // Only used for INNER/OUTER faces
  833. S32 mBeginS;
  834. S32 mBeginT;
  835. S32 mNumS;
  836. S32 mNumT;
  838. LLVector3 mExtents[2]; //minimum and maximum point of face
  840. std::vector<VertexData> mVertices;
  841. std::vector<U16> mIndices;
  842. std::vector<S32> mEdge;
  844. private:
  845. BOOL createUnCutCubeCap(LLVolume* volume, BOOL partial_build = FALSE);
  846. BOOL createCap(LLVolume* volume, BOOL partial_build = FALSE);
  847. BOOL createSide(LLVolume* volume, BOOL partial_build = FALSE);
  848. };
  850. class LLVolume : public LLRefCount
  851. {
  852. friend class LLVolumeLODGroup;
  854. private:
  855. LLVolume(const LLVolume&);  // Don't implement
  856. ~LLVolume(); // use unref
  858. public:
  859. struct Point
  860. {
  861. LLVector3 mPos;
  862. };
  864. struct FaceParams
  865. {
  866. LLFaceID mFaceID;
  867. S32 mBeginS;
  868. S32 mCountS;
  869. S32 mBeginT;
  870. S32 mCountT;
  871. };
  873. LLVolume(const LLVolumeParams &params, const F32 detail, const BOOL generate_single_face = FALSE, const BOOL is_unique = FALSE);
  875. U8 getProfileType() const { return mParams.getProfileParams().getCurveType(); }
  876. U8 getPathType() const { return mParams.getPathParams().getCurveType(); }
  877. S32 getNumFaces() const { return (S32)mProfilep->mFaces.size(); }
  878. S32 getNumVolumeFaces() const { return mVolumeFaces.size(); }
  879. F32 getDetail() const { return mDetail; }
  880. const LLVolumeParams& getParams() const { return mParams; }
  881. LLVolumeParams getCopyOfParams() const { return mParams; }
  882. const LLProfile& getProfile() const { return *mProfilep; }
  883. LLPath& getPath() const { return *mPathp; }
  884. void resizePath(S32 length);
  885. const std::vector<Point>& getMesh() const { return mMesh; }
  886. const LLVector3& getMeshPt(const U32 i) const { return mMesh[i].mPos; }
  888. void setDirty() { mPathp->setDirty(); mProfilep->setDirty(); }
  890. void regen();
  891. void genBinormals(S32 face);
  893. BOOL isConvex() const;
  894. BOOL isCap(S32 face);
  895. BOOL isFlat(S32 face);
  896. BOOL isUnique() const { return mUnique; }
  898. S32 getSculptLevel() const                              { return mSculptLevel; }
  900. S32 *getTriangleIndices(U32 &num_indices) const;
  902. // returns number of triangle indeces required for path/profile mesh
  903. S32 getNumTriangleIndices() const;
  905. void generateSilhouetteVertices(std::vector<LLVector3> &vertices, 
  906. std::vector<LLVector3> &normals, 
  907. std::vector<S32> &segments, 
  908. const LLVector3& view_vec,
  909. const LLMatrix4& mat,
  910. const LLMatrix3& norm_mat,
  911. S32 face_index);
  913. //get the face index of the face that intersects with the given line segment at the point 
  914. //closest to start.  Moves end to the point of intersection.  Returns -1 if no intersection.
  915. //Line segment must be in volume space.
  916. S32 lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
  917.  S32 face = -1,                          // which face to check, -1 = ALL_SIDES
  918.  LLVector3* intersection = NULL,         // return the intersection point
  919.  LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
  920.  LLVector3* normal = NULL,               // return the surface normal at the intersection point
  921.  LLVector3* bi_normal = NULL             // return the surface bi-normal at the intersection point
  922. );
  924. // The following cleans up vertices and triangles,
  925. // getting rid of degenerate triangles and duplicate vertices,
  926. // and allocates new arrays with the clean data.
  927. static BOOL cleanupTriangleData( const S32 num_input_vertices,
  928. const std::vector<Point> &input_vertices,
  929. const S32 num_input_triangles,
  930. S32 *input_triangles,
  931. S32 &num_output_vertices,
  932. LLVector3 **output_vertices,
  933. S32 &num_output_triangles,
  934. S32 **output_triangles);
  935. LLFaceID generateFaceMask();
  937. BOOL isFaceMaskValid(LLFaceID face_mask);
  938. static S32 sNumMeshPoints;
  940. friend std::ostream& operator<<(std::ostream &s, const LLVolume &volume);
  941. friend std::ostream& operator<<(std::ostream &s, const LLVolume *volumep); // HACK to bypass Windoze confusion over 
  942. // conversion if *(LLVolume*) to LLVolume&
  943. const LLVolumeFace &getVolumeFace(const S32 f) const {return mVolumeFaces[f];} // DO NOT DELETE VOLUME WHILE USING THIS REFERENCE, OR HOLD A POINTER TO THIS VOLUMEFACE
  945. U32 mFaceMask; // bit array of which faces exist in this volume
  946. LLVector3 mLODScaleBias; // vector for biasing LOD based on scale
  948. void sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, S32 sculpt_level);
  949. private:
  950. void sculptGenerateMapVertices(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, U8 sculpt_type);
  951. F32 sculptGetSurfaceArea();
  952. void sculptGeneratePlaceholder();
  953. void sculptCalcMeshResolution(U16 width, U16 height, U8 type, S32& s, S32& t);
  956. protected:
  957. BOOL generate();
  958. void createVolumeFaces();
  960.  protected:
  961. BOOL mUnique;
  962. F32 mDetail;
  963. S32 mSculptLevel;
  965. LLVolumeParams mParams;
  966. LLPath *mPathp;
  967. LLProfile *mProfilep;
  968. std::vector<Point> mMesh;
  970. BOOL mGenerateSingleFace;
  971. typedef std::vector<LLVolumeFace> face_list_t;
  972. face_list_t mVolumeFaces;
  973. };
  975. std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params);
  977. LLVector3 calc_binormal_from_triangle(
  978. const LLVector3& pos0,
  979. const LLVector2& tex0,
  980. const LLVector3& pos1,
  981. const LLVector2& tex1,
  982. const LLVector3& pos2,
  983. const LLVector2& tex2);
  985. BOOL LLLineSegmentBoxIntersect(const LLVector3& start, const LLVector3& end, const LLVector3& center, const LLVector3& size);
  986. BOOL LLTriangleRayIntersect(const LLVector3& vert0, const LLVector3& vert1, const LLVector3& vert2, const LLVector3& orig, const LLVector3& dir,
  987. F32* intersection_a, F32* intersection_b, F32* intersection_t, BOOL two_sided);
  991. #endif