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