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

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

游戏引擎

开发平台：

C++ Builder

llprimitive.h：源码内容
  1. /** 
  2.  * @file llprimitive.h
  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. #ifndef LL_LLPRIMITIVE_H
  34. #define LL_LLPRIMITIVE_H
  36. #include "lluuid.h"
  37. #include "v3math.h"
  38. #include "xform.h"
  39. #include "message.h"
  40. #include "llpointer.h"
  41. #include "llvolume.h"
  42. #include "lltextureentry.h"
  43. #include "llprimtexturelist.h"
  45. // Moved to stdtypes.h --JC
  46. // typedef U8 LLPCode;
  47. class LLMessageSystem;
  48. class LLVolumeParams;
  49. class LLColor4;
  50. class LLColor3;
  51. class LLTextureEntry;
  52. class LLDataPacker;
  53. class LLVolumeMgr;
  55. enum LLGeomType // NOTE: same vals as GL Ids
  56. {
  57. LLInvalid   = 0,
  58. LLLineLoop  = 2,
  59. LLLineStrip = 3,
  60. LLTriangles = 4,
  61. LLTriStrip  = 5,
  62. LLTriFan    = 6,
  63. LLQuads     = 7, 
  64. LLQuadStrip = 8
  65. };
  67. class LLVolume;
  69. /**
  70.  * exported constants
  71.  */
  72. extern const F32 OBJECT_CUT_MIN;
  73. extern const F32 OBJECT_CUT_MAX;
  74. extern const F32 OBJECT_CUT_INC;
  75. extern const F32 OBJECT_MIN_CUT_INC;
  76. extern const F32 OBJECT_ROTATION_PRECISION;
  78. extern const F32 OBJECT_TWIST_MIN;
  79. extern const F32 OBJECT_TWIST_MAX;
  80. extern const F32 OBJECT_TWIST_INC;
  82. // This is used for linear paths,
  83. // since twist is used in a slightly different manner.
  84. extern const F32 OBJECT_TWIST_LINEAR_MIN;
  85. extern const F32 OBJECT_TWIST_LINEAR_MAX;
  86. extern const F32 OBJECT_TWIST_LINEAR_INC;
  88. extern const F32 OBJECT_MIN_HOLE_SIZE;
  89. extern const F32 OBJECT_MAX_HOLE_SIZE_X;
  90. extern const F32 OBJECT_MAX_HOLE_SIZE_Y;
  92. // Revolutions parameters.
  93. extern const F32 OBJECT_REV_MIN;
  94. extern const F32 OBJECT_REV_MAX;
  95. extern const F32 OBJECT_REV_INC;
  97. extern const char *SCULPT_DEFAULT_TEXTURE;
  99. //============================================================================
  101. // TomY: Base class for things that pack & unpack themselves
  102. class LLNetworkData
  103. {
  104. public:
  105. // Extra parameter IDs
  106. enum
  107. {
  108. PARAMS_FLEXIBLE = 0x10,
  109. PARAMS_LIGHT    = 0x20,
  110. PARAMS_SCULPT   = 0x30,
  111. PARAMS_LIGHT_IMAGE = 0x40,
  112. };
  114. public:
  115. U16 mType;
  116. virtual ~LLNetworkData() {};
  117. virtual BOOL pack(LLDataPacker &dp) const = 0;
  118. virtual BOOL unpack(LLDataPacker &dp) = 0;
  119. virtual bool operator==(const LLNetworkData& data) const = 0;
  120. virtual void copy(const LLNetworkData& data) = 0;
  121. static BOOL isValid(U16 param_type, U32 size);
  122. };
  124. extern const F32 LIGHT_MIN_RADIUS;
  125. extern const F32 LIGHT_DEFAULT_RADIUS;
  126. extern const F32 LIGHT_MAX_RADIUS;
  127. extern const F32 LIGHT_MIN_FALLOFF;
  128. extern const F32 LIGHT_DEFAULT_FALLOFF;
  129. extern const F32 LIGHT_MAX_FALLOFF;
  130. extern const F32 LIGHT_MIN_CUTOFF;
  131. extern const F32 LIGHT_DEFAULT_CUTOFF;
  132. extern const F32 LIGHT_MAX_CUTOFF;
  134. class LLLightParams : public LLNetworkData
  135. {
  136. protected:
  137. LLColor4 mColor; // alpha = intensity
  138. F32 mRadius;
  139. F32 mFalloff;
  140. F32 mCutoff;
  142. public:
  143. LLLightParams();
  144. /*virtual*/ BOOL pack(LLDataPacker &dp) const;
  145. /*virtual*/ BOOL unpack(LLDataPacker &dp);
  146. /*virtual*/ bool operator==(const LLNetworkData& data) const;
  147. /*virtual*/ void copy(const LLNetworkData& data);
  148. // LLSD implementations here are provided by Eddy Stryker.
  149. // NOTE: there are currently unused in protocols
  150. LLSD asLLSD() const;
  151. operator LLSD() const { return asLLSD(); }
  152. bool fromLLSD(LLSD& sd);
  155. void setColor(const LLColor4& color) { mColor = color; mColor.clamp(); }
  156. void setRadius(F32 radius) { mRadius = llclamp(radius, LIGHT_MIN_RADIUS, LIGHT_MAX_RADIUS); }
  157. void setFalloff(F32 falloff) { mFalloff = llclamp(falloff, LIGHT_MIN_FALLOFF, LIGHT_MAX_FALLOFF); }
  158. void setCutoff(F32 cutoff) { mCutoff = llclamp(cutoff, LIGHT_MIN_CUTOFF, LIGHT_MAX_CUTOFF); }
  160. LLColor4 getColor() const { return mColor; }
  161. F32 getRadius() const { return mRadius; }
  162. F32 getFalloff() const { return mFalloff; }
  163. F32 getCutoff() const { return mCutoff; }
  164. };
  166. //-------------------------------------------------
  167. // This structure is also used in the part of the 
  168. // code that creates new flexible objects.
  169. //-------------------------------------------------
  171. // These were made into enums so that they could be used as fixed size
  172. // array bounds.
  173. enum EFlexibleObjectConst
  174. {
  175. // "Softness" => [0,3], increments of 1
  176. // Represents powers of 2: 0 -> 1, 3 -> 8
  177. FLEXIBLE_OBJECT_MIN_SECTIONS = 0,
  178. FLEXIBLE_OBJECT_DEFAULT_NUM_SECTIONS = 2,
  179. FLEXIBLE_OBJECT_MAX_SECTIONS = 3
  180. };
  182. // "Tension" => [0,10], increments of 0.1
  183. extern const F32 FLEXIBLE_OBJECT_MIN_TENSION;
  184. extern const F32 FLEXIBLE_OBJECT_DEFAULT_TENSION;
  185. extern const F32 FLEXIBLE_OBJECT_MAX_TENSION;
  187. // "Drag" => [0,10], increments of 0.1
  188. extern const F32 FLEXIBLE_OBJECT_MIN_AIR_FRICTION;
  189. extern const F32 FLEXIBLE_OBJECT_DEFAULT_AIR_FRICTION;
  190. extern const F32 FLEXIBLE_OBJECT_MAX_AIR_FRICTION;
  192. // "Gravity" = [-10,10], increments of 0.1
  193. extern const F32 FLEXIBLE_OBJECT_MIN_GRAVITY;
  194. extern const F32 FLEXIBLE_OBJECT_DEFAULT_GRAVITY;
  195. extern const F32 FLEXIBLE_OBJECT_MAX_GRAVITY;
  197. // "Wind" = [0,10], increments of 0.1
  198. extern const F32 FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY;
  199. extern const F32 FLEXIBLE_OBJECT_DEFAULT_WIND_SENSITIVITY;
  200. extern const F32 FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY;
  202. extern const F32 FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE;
  204. extern const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH;
  205. extern const BOOL FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE;
  206. extern const BOOL FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE;
  209. class LLFlexibleObjectData : public LLNetworkData
  210. {
  211. protected:
  212. S32 mSimulateLOD; // 2^n = number of simulated sections
  213. F32 mGravity;
  214. F32 mAirFriction; // higher is more stable, but too much looks like it's underwater
  215. F32 mWindSensitivity; // interacts with tension, air friction, and gravity
  216. F32 mTension; //interacts in complex ways with other parameters
  217. LLVector3 mUserForce; // custom user-defined force vector
  218. //BOOL mUsingCollisionSphere;
  219. //BOOL mRenderingCollisionSphere;
  221. public:
  222. void setSimulateLOD(S32 lod) { mSimulateLOD = llclamp(lod, (S32)FLEXIBLE_OBJECT_MIN_SECTIONS, (S32)FLEXIBLE_OBJECT_MAX_SECTIONS); }
  223. void setGravity(F32 gravity) { mGravity = llclamp(gravity, FLEXIBLE_OBJECT_MIN_GRAVITY, FLEXIBLE_OBJECT_MAX_GRAVITY); }
  224. void setAirFriction(F32 friction) { mAirFriction = llclamp(friction, FLEXIBLE_OBJECT_MIN_AIR_FRICTION, FLEXIBLE_OBJECT_MAX_AIR_FRICTION); }
  225. void setWindSensitivity(F32 wind) { mWindSensitivity = llclamp(wind, FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY, FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY); }
  226. void setTension(F32 tension) { mTension = llclamp(tension, FLEXIBLE_OBJECT_MIN_TENSION, FLEXIBLE_OBJECT_MAX_TENSION); }
  227. void setUserForce(LLVector3 &force) { mUserForce = force; }
  229. S32 getSimulateLOD() const { return mSimulateLOD; }
  230. F32 getGravity() const { return mGravity; }
  231. F32 getAirFriction() const { return mAirFriction; }
  232. F32 getWindSensitivity() const { return mWindSensitivity; }
  233. F32 getTension() const { return mTension; }
  234. LLVector3 getUserForce() const { return mUserForce; }
  236. //------ the constructor for the structure ------------
  237. LLFlexibleObjectData();
  238. BOOL pack(LLDataPacker &dp) const;
  239. BOOL unpack(LLDataPacker &dp);
  240. bool operator==(const LLNetworkData& data) const;
  241. void copy(const LLNetworkData& data);
  242. LLSD asLLSD() const;
  243. operator LLSD() const { return asLLSD(); }
  244. bool fromLLSD(LLSD& sd);
  245. };// end of attributes structure
  249. class LLSculptParams : public LLNetworkData
  250. {
  251. protected:
  252. LLUUID mSculptTexture;
  253. U8 mSculptType;
  255. public:
  256. LLSculptParams();
  257. /*virtual*/ BOOL pack(LLDataPacker &dp) const;
  258. /*virtual*/ BOOL unpack(LLDataPacker &dp);
  259. /*virtual*/ bool operator==(const LLNetworkData& data) const;
  260. /*virtual*/ void copy(const LLNetworkData& data);
  261. LLSD asLLSD() const;
  262. operator LLSD() const { return asLLSD(); }
  263. bool fromLLSD(LLSD& sd);
  265. void setSculptTexture(const LLUUID& id) { mSculptTexture = id; }
  266. LLUUID getSculptTexture() const         { return mSculptTexture; }
  267. void setSculptType(U8 type)             { mSculptType = type; }
  268. U8 getSculptType() const                { return mSculptType; }
  269. };
  271. class LLLightImageParams : public LLNetworkData
  272. {
  273. protected:
  274. LLUUID mLightTexture;
  275. LLVector3 mParams;
  277. public:
  278. LLLightImageParams();
  279. /*virtual*/ BOOL pack(LLDataPacker &dp) const;
  280. /*virtual*/ BOOL unpack(LLDataPacker &dp);
  281. /*virtual*/ bool operator==(const LLNetworkData& data) const;
  282. /*virtual*/ void copy(const LLNetworkData& data);
  283. LLSD asLLSD() const;
  284. operator LLSD() const { return asLLSD(); }
  285. bool fromLLSD(LLSD& sd);
  287. void setLightTexture(const LLUUID& id) { mLightTexture = id; }
  288. LLUUID getLightTexture() const         { return mLightTexture; }
  289. void setParams(const LLVector3& params) { mParams = params; }
  290. LLVector3 getParams() const    { return mParams; }
  292. };
  295. class LLPrimitive : public LLXform
  296. {
  297. public:
  299. // HACK for removing LLPrimitive's dependency on gVolumeMgr global.
  300. // If a different LLVolumeManager is instantiated and set early enough
  301. // then the LLPrimitive class will use it instead of gVolumeMgr.
  302. static LLVolumeMgr* getVolumeManager() { return sVolumeManager; }
  303. static void setVolumeManager( LLVolumeMgr* volume_manager);
  304. static bool cleanupVolumeManager();
  306. // these flags influence how the RigidBody representation is built
  307. static const U32 PRIM_FLAG_PHANTOM  = 0x1 << 0;
  308. static const U32 PRIM_FLAG_VOLUME_DETECT  = 0x1 << 1;
  309. static const U32 PRIM_FLAG_DYNAMIC  = 0x1 << 2;
  310. static const U32 PRIM_FLAG_AVATAR  = 0x1 << 3;
  311. static const U32 PRIM_FLAG_SCULPT  = 0x1 << 4;
  312. // not used yet, but soon
  313. static const U32 PRIM_FLAG_COLLISION_CALLBACK  = 0x1 << 5;
  314. static const U32 PRIM_FLAG_CONVEX  = 0x1 << 6;
  315. static const U32 PRIM_FLAG_DEFAULT_VOLUME = 0x1 << 7;
  316. static const U32 PRIM_FLAG_SITTING = 0x1 << 8;
  317. static const U32 PRIM_FLAG_SITTING_ON_GROUND = 0x1 << 9; // Set along with PRIM_FLAG_SITTING
  319. LLPrimitive();
  320. virtual ~LLPrimitive();
  322. void clearTextureList();
  324. static LLPrimitive *createPrimitive(LLPCode p_code);
  325. void init_primitive(LLPCode p_code);
  327. void setPCode(const LLPCode pcode);
  328. const LLVolume *getVolumeConst() const { return mVolumep; } // HACK for Windoze confusion about ostream operator in LLVolume
  329. LLVolume *getVolume() const { return mVolumep; }
  330. virtual BOOL setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false);
  332. // Modify texture entry properties
  333. inline BOOL validTE(const U8 te_num) const;
  334. LLTextureEntry* getTE(const U8 te_num) const;
  336. virtual void setNumTEs(const U8 num_tes);
  337. virtual void setAllTETextures(const LLUUID &tex_id);
  338. virtual void setTE(const U8 index, const LLTextureEntry& te);
  339. virtual S32 setTEColor(const U8 te, const LLColor4 &color);
  340. virtual S32 setTEColor(const U8 te, const LLColor3 &color);
  341. virtual S32 setTEAlpha(const U8 te, const F32 alpha);
  342. virtual S32 setTETexture(const U8 te, const LLUUID &tex_id);
  343. virtual S32 setTEScale (const U8 te, const F32 s, const F32 t);
  344. virtual S32 setTEScaleS(const U8 te, const F32 s);
  345. virtual S32 setTEScaleT(const U8 te, const F32 t);
  346. virtual S32 setTEOffset (const U8 te, const F32 s, const F32 t);
  347. virtual S32 setTEOffsetS(const U8 te, const F32 s);
  348. virtual S32 setTEOffsetT(const U8 te, const F32 t);
  349. virtual S32 setTERotation(const U8 te, const F32 r);
  350. virtual S32 setTEBumpShinyFullbright(const U8 te, const U8 bump);
  351. virtual S32 setTEBumpShiny(const U8 te, const U8 bump);
  352. virtual S32 setTEMediaTexGen(const U8 te, const U8 media);
  353. virtual S32 setTEBumpmap(const U8 te, const U8 bump);
  354. virtual S32 setTETexGen(const U8 te, const U8 texgen);
  355. virtual S32 setTEShiny(const U8 te, const U8 shiny);
  356. virtual S32 setTEFullbright(const U8 te, const U8 fullbright);
  357. virtual S32 setTEMediaFlags(const U8 te, const U8 flags);
  358. virtual S32 setTEGlow(const U8 te, const F32 glow);
  359. virtual BOOL setMaterial(const U8 material); // returns TRUE if material changed
  361. void copyTEs(const LLPrimitive *primitive);
  362. S32 packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_face_index, EMsgVariableType type) const;
  363. S32 unpackTEField(U8 *cur_ptr, U8 *buffer_end, U8 *data_ptr, U8 data_size, U8 face_count, EMsgVariableType type);
  364. BOOL packTEMessage(LLMessageSystem *mesgsys) const;
  365. BOOL packTEMessage(LLDataPacker &dp) const;
  366. S32 unpackTEMessage(LLMessageSystem *mesgsys, char *block_name);
  367. S32 unpackTEMessage(LLMessageSystem *mesgsys, char *block_name, const S32 block_num); // Variable num of blocks
  368. BOOL unpackTEMessage(LLDataPacker &dp);
  370. #ifdef CHECK_FOR_FINITE
  371. inline void setPosition(const LLVector3& pos);
  372. inline void setPosition(const F32 x, const F32 y, const F32 z);
  373. inline void addPosition(const LLVector3& pos);
  375. inline void setAngularVelocity(const LLVector3& avel);
  376. inline void setAngularVelocity(const F32 x, const F32 y, const F32 z);
  377. inline void setVelocity(const LLVector3& vel);
  378. inline void setVelocity(const F32 x, const F32 y, const F32 z);
  379. inline void setVelocityX(const F32 x);
  380. inline void setVelocityY(const F32 y);
  381. inline void setVelocityZ(const F32 z);
  382. inline void addVelocity(const LLVector3& vel);
  383. inline void setAcceleration(const LLVector3& accel);
  384. inline void setAcceleration(const F32 x, const F32 y, const F32 z);
  385. #else
  386. // Don't override the base LLXForm operators.
  387. // Special case for setPosition.  If not check-for-finite, fall through to LLXform method.
  388. // void setPosition(F32 x, F32 y, F32 z)
  389. // void setPosition(LLVector3)
  391. void  setAngularVelocity(const LLVector3& avel) { mAngularVelocity = avel; }
  392. void  setAngularVelocity(const F32 x, const F32 y, const F32 z) { mAngularVelocity.setVec(x,y,z); }
  393. void  setVelocity(const LLVector3& vel) { mVelocity = vel; }
  394. void  setVelocity(const F32 x, const F32 y, const F32 z) { mVelocity.setVec(x,y,z); }
  395. void  setVelocityX(const F32 x) { mVelocity.mV[VX] = x; }
  396. void  setVelocityY(const F32 y) { mVelocity.mV[VY] = y; }
  397. void  setVelocityZ(const F32 z) { mVelocity.mV[VZ] = z; }
  398. void  addVelocity(const LLVector3& vel) { mVelocity += vel; }
  399. void  setAcceleration(const LLVector3& accel) { mAcceleration = accel; }
  400. void  setAcceleration(const F32 x, const F32 y, const F32 z) { mAcceleration.setVec(x,y,z); }
  401. #endif
  403. LLPCode getPCode() const { return mPrimitiveCode; }
  404. std::string getPCodeString() const { return pCodeToString(mPrimitiveCode); }
  405. const LLVector3& getAngularVelocity() const { return mAngularVelocity; }
  406. const LLVector3& getVelocity() const { return mVelocity; }
  407. const LLVector3& getAcceleration() const { return mAcceleration; }
  408. U8 getNumTEs() const { return mTextureList.size(); }
  409. U8 getExpectedNumTEs() const;
  411. U8 getMaterial() const { return mMaterial; }
  413. void setVolumeType(const U8 code);
  414. U8 getVolumeType();
  416. // clears existing textures
  417. // copies the contents of other_list into mEntryList
  418. void copyTextureList(const LLPrimTextureList& other_list);
  420. // clears existing textures
  421. // takes the contents of other_list and clears other_list
  422. void takeTextureList(LLPrimTextureList& other_list);
  424. inline BOOL isAvatar() const;
  425. inline BOOL isSittingAvatar() const;
  426. inline BOOL isSittingAvatarOnGround() const;
  428. void setFlags(U32 flags) { mMiscFlags = flags; }
  429. void addFlags(U32 flags) { mMiscFlags |= flags; }
  430. void removeFlags(U32 flags) { mMiscFlags &= ~flags; }
  431. U32 getFlags() const { return mMiscFlags; }
  433. static std::string pCodeToString(const LLPCode pcode);
  434. static LLPCode legacyToPCode(const U8 legacy);
  435. static U8 pCodeToLegacy(const LLPCode pcode);
  436. static bool getTESTAxes(const U8 face, U32* s_axis, U32* t_axis);
  438. inline static BOOL isPrimitive(const LLPCode pcode);
  439. inline static BOOL isApp(const LLPCode pcode);
  441. protected:
  442. LLPCode mPrimitiveCode; // Primitive code
  443. LLVector3 mVelocity; // how fast are we moving?
  444. LLVector3 mAcceleration; // are we under constant acceleration?
  445. LLVector3 mAngularVelocity; // angular velocity
  446. LLPointer<LLVolume> mVolumep;
  447. LLPrimTextureList mTextureList; // list of texture GUIDs, scales, offsets
  448. U8 mMaterial; // Material code
  449. U8 mNumTEs; // # of faces on the primitve
  450. U32  mMiscFlags; // home for misc bools
  452. static LLVolumeMgr* sVolumeManager;
  453. };
  455. inline BOOL LLPrimitive::isAvatar() const
  456. {
  457. return ( LL_PCODE_LEGACY_AVATAR == mPrimitiveCode ) ? TRUE : FALSE;
  458. }
  460. inline BOOL LLPrimitive::isSittingAvatar() const
  461. {
  462. // this is only used server-side
  463. return ( LL_PCODE_LEGACY_AVATAR == mPrimitiveCode 
  464.  &&  ((getFlags() & (PRIM_FLAG_SITTING | PRIM_FLAG_SITTING_ON_GROUND)) != 0) ) ? TRUE : FALSE;
  465. }
  467. inline BOOL LLPrimitive::isSittingAvatarOnGround() const
  468. {
  469. // this is only used server-side
  470. return ( LL_PCODE_LEGACY_AVATAR == mPrimitiveCode 
  471.  &&  ((getFlags() & PRIM_FLAG_SITTING_ON_GROUND) != 0) ) ? TRUE : FALSE;
  472. }
  474. // static
  475. inline BOOL LLPrimitive::isPrimitive(const LLPCode pcode)
  476. {
  477. LLPCode base_type = pcode & LL_PCODE_BASE_MASK;
  479. if (base_type && (base_type < LL_PCODE_APP))
  480. {
  481. return TRUE;
  482. }
  483. return FALSE;
  484. }
  486. // static
  487. inline BOOL LLPrimitive::isApp(const LLPCode pcode)
  488. {
  489. LLPCode base_type = pcode & LL_PCODE_BASE_MASK;
  491. return (base_type == LL_PCODE_APP);
  492. }
  495. #ifdef CHECK_FOR_FINITE
  496. // Special case for setPosition.  If not check-for-finite, fall through to LLXform method.
  497. void LLPrimitive::setPosition(const F32 x, const F32 y, const F32 z)
  498. {
  499. if (llfinite(x) && llfinite(y) && llfinite(z))
  500. {
  501. LLXform::setPosition(x, y, z);
  502. }
  503. else
  504. {
  505. llerrs << "Non Finite in LLPrimitive::setPosition(x,y,z) for " << pCodeToString(mPrimitiveCode) << llendl;
  506. }
  507. }
  509. // Special case for setPosition.  If not check-for-finite, fall through to LLXform method.
  510. void LLPrimitive::setPosition(const LLVector3& pos)
  511. {
  512. if (pos.isFinite())
  513. {
  514. LLXform::setPosition(pos);
  515. }
  516. else
  517. {
  518. llerrs << "Non Finite in LLPrimitive::setPosition(LLVector3) for " << pCodeToString(mPrimitiveCode) << llendl;
  519. }
  520. }
  522. void LLPrimitive::setAngularVelocity(const LLVector3& avel)
  523. { 
  524. if (avel.isFinite())
  525. {
  526. mAngularVelocity = avel;
  527. }
  528. else
  529. {
  530. llerror("Non Finite in LLPrimitive::setAngularVelocity", 0);
  531. }
  532. }
  534. void LLPrimitive::setAngularVelocity(const F32 x, const F32 y, const F32 z)
  535. { 
  536. if (llfinite(x) && llfinite(y) && llfinite(z))
  537. {
  538. mAngularVelocity.setVec(x,y,z);
  539. }
  540. else
  541. {
  542. llerror("Non Finite in LLPrimitive::setAngularVelocity", 0);
  543. }
  544. }
  546. void LLPrimitive::setVelocity(const LLVector3& vel)
  547. { 
  548. if (vel.isFinite())
  549. {
  550. mVelocity = vel; 
  551. }
  552. else
  553. {
  554. llerrs << "Non Finite in LLPrimitive::setVelocity(LLVector3) for " << pCodeToString(mPrimitiveCode) << llendl;
  555. }
  556. }
  558. void LLPrimitive::setVelocity(const F32 x, const F32 y, const F32 z)
  559. { 
  560. if (llfinite(x) && llfinite(y) && llfinite(z))
  561. {
  562. mVelocity.setVec(x,y,z); 
  563. }
  564. else
  565. {
  566. llerrs << "Non Finite in LLPrimitive::setVelocity(F32,F32,F32) for " << pCodeToString(mPrimitiveCode) << llendl;
  567. }
  568. }
  570. void LLPrimitive::setVelocityX(const F32 x)
  571. { 
  572. if (llfinite(x))
  573. {
  574. mVelocity.mV[VX] = x;
  575. }
  576. else
  577. {
  578. llerror("Non Finite in LLPrimitive::setVelocityX", 0);
  579. }
  580. }
  582. void LLPrimitive::setVelocityY(const F32 y)
  583. { 
  584. if (llfinite(y))
  585. {
  586. mVelocity.mV[VY] = y;
  587. }
  588. else
  589. {
  590. llerror("Non Finite in LLPrimitive::setVelocityY", 0);
  591. }
  592. }
  594. void LLPrimitive::setVelocityZ(const F32 z)
  595. { 
  596. if (llfinite(z))
  597. {
  598. mVelocity.mV[VZ] = z;
  599. }
  600. else
  601. {
  602. llerror("Non Finite in LLPrimitive::setVelocityZ", 0);
  603. }
  604. }
  606. void LLPrimitive::addVelocity(const LLVector3& vel)
  607. { 
  608. if (vel.isFinite())
  609. {
  610. mVelocity += vel;
  611. }
  612. else
  613. {
  614. llerror("Non Finite in LLPrimitive::addVelocity", 0);
  615. }
  616. }
  618. void LLPrimitive::setAcceleration(const LLVector3& accel)
  619. { 
  620. if (accel.isFinite())
  621. {
  622. mAcceleration = accel; 
  623. }
  624. else
  625. {
  626. llerrs << "Non Finite in LLPrimitive::setAcceleration(LLVector3) for " << pCodeToString(mPrimitiveCode) << llendl;
  627. }
  628. }
  630. void LLPrimitive::setAcceleration(const F32 x, const F32 y, const F32 z)
  631. { 
  632. if (llfinite(x) && llfinite(y) && llfinite(z))
  633. {
  634. mAcceleration.setVec(x,y,z); 
  635. }
  636. else
  637. {
  638. llerrs << "Non Finite in LLPrimitive::setAcceleration(F32,F32,F32) for " << pCodeToString(mPrimitiveCode) << llendl;
  639. }
  640. }
  641. #endif // CHECK_FOR_FINITE
  643. inline BOOL LLPrimitive::validTE(const U8 te_num) const
  644. {
  645. return (mNumTEs && te_num < mNumTEs);
  646. }
  648. #endif