From e2e37cced861b98de8c1a7c9c0d3a50d2d90e433 Mon Sep 17 00:00:00 2001 From: Ansariel Date: Wed, 22 May 2024 21:25:21 +0200 Subject: Fix line endlings --- indra/llprimitive/llprimitive.h | 1588 +++++++++++++++++++-------------------- 1 file changed, 794 insertions(+), 794 deletions(-) (limited to 'indra/llprimitive/llprimitive.h') diff --git a/indra/llprimitive/llprimitive.h b/indra/llprimitive/llprimitive.h index 1cbd6b242f..ce27dad346 100644 --- a/indra/llprimitive/llprimitive.h +++ b/indra/llprimitive/llprimitive.h @@ -1,794 +1,794 @@ -/** - * @file llprimitive.h - * @brief LLPrimitive base class - * - * $LicenseInfo:firstyear=2001&license=viewerlgpl$ - * Second Life Viewer Source Code - * Copyright (C) 2010, Linden Research, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; - * version 2.1 of the License only. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ - */ - -#ifndef LL_LLPRIMITIVE_H -#define LL_LLPRIMITIVE_H - -#include "lluuid.h" -#include "v3math.h" -#include "xform.h" -#include "message.h" -#include "llpointer.h" -#include "llvolume.h" -#include "lltextureentry.h" -#include "llprimtexturelist.h" - -// Moved to stdtypes.h --JC -// typedef U8 LLPCode; -class LLMessageSystem; -class LLVolumeParams; -class LLColor4; -class LLColor3; -class LLMaterialID; -class LLTextureEntry; -class LLDataPacker; -class LLVolumeMgr; - -enum LLGeomType // NOTE: same vals as GL Ids -{ - LLInvalid = 0, - LLLineLoop = 2, - LLLineStrip = 3, - LLTriangles = 4, - LLTriStrip = 5, - LLTriFan = 6, - LLQuads = 7, - LLQuadStrip = 8 -}; - -class LLVolume; - -/** - * exported constants - */ -extern const F32 OBJECT_CUT_MIN; -extern const F32 OBJECT_CUT_MAX; -extern const F32 OBJECT_CUT_INC; -extern const F32 OBJECT_MIN_CUT_INC; -extern const F32 OBJECT_ROTATION_PRECISION; - -extern const F32 OBJECT_TWIST_MIN; -extern const F32 OBJECT_TWIST_MAX; -extern const F32 OBJECT_TWIST_INC; - -// This is used for linear paths, -// since twist is used in a slightly different manner. -extern const F32 OBJECT_TWIST_LINEAR_MIN; -extern const F32 OBJECT_TWIST_LINEAR_MAX; -extern const F32 OBJECT_TWIST_LINEAR_INC; - -extern const F32 OBJECT_MIN_HOLE_SIZE; -extern const F32 OBJECT_MAX_HOLE_SIZE_X; -extern const F32 OBJECT_MAX_HOLE_SIZE_Y; - -// Revolutions parameters. -extern const F32 OBJECT_REV_MIN; -extern const F32 OBJECT_REV_MAX; -extern const F32 OBJECT_REV_INC; - -extern const LLUUID SCULPT_DEFAULT_TEXTURE; - -//============================================================================ - -// TomY: Base class for things that pack & unpack themselves -class LLNetworkData -{ -public: - // Extra parameter IDs - enum - { - PARAMS_FLEXIBLE = 0x10, - PARAMS_LIGHT = 0x20, - PARAMS_SCULPT = 0x30, - PARAMS_LIGHT_IMAGE = 0x40, - PARAMS_RESERVED = 0x50, // Used on server-side - PARAMS_MESH = 0x60, - PARAMS_EXTENDED_MESH = 0x70, - PARAMS_RENDER_MATERIAL = 0x80, - PARAMS_REFLECTION_PROBE = 0x90, - }; - -public: - U16 mType; - virtual ~LLNetworkData() {}; - virtual bool pack(LLDataPacker &dp) const = 0; - virtual bool unpack(LLDataPacker &dp) = 0; - virtual bool operator==(const LLNetworkData& data) const = 0; - virtual void copy(const LLNetworkData& data) = 0; - static bool isValid(U16 param_type, U32 size); -}; - -extern const F32 LIGHT_MIN_RADIUS; -extern const F32 LIGHT_DEFAULT_RADIUS; -extern const F32 LIGHT_MAX_RADIUS; -extern const F32 LIGHT_MIN_FALLOFF; -extern const F32 LIGHT_DEFAULT_FALLOFF; -extern const F32 LIGHT_MAX_FALLOFF; -extern const F32 LIGHT_MIN_CUTOFF; -extern const F32 LIGHT_DEFAULT_CUTOFF; -extern const F32 LIGHT_MAX_CUTOFF; - -class LLLightParams : public LLNetworkData -{ -private: - LLColor4 mColor; // linear color (not gamma corrected), alpha = intensity - F32 mRadius; - F32 mFalloff; - F32 mCutoff; - -public: - LLLightParams(); - /*virtual*/ bool pack(LLDataPacker &dp) const; - /*virtual*/ bool unpack(LLDataPacker &dp); - /*virtual*/ bool operator==(const LLNetworkData& data) const; - /*virtual*/ void copy(const LLNetworkData& data); - // LLSD implementations here are provided by Eddy Stryker. - // NOTE: there are currently unused in protocols - LLSD asLLSD() const; - operator LLSD() const { return asLLSD(); } - bool fromLLSD(LLSD& sd); - - // set the color by gamma corrected color value - // color - gamma corrected color value (directly taken from an on-screen color swatch) - void setSRGBColor(const LLColor4& color) { setLinearColor(linearColor4(color)); } - - // set the color by linear color value - // color - linear color value (value as it appears in shaders) - void setLinearColor(const LLColor4& color) { mColor = color; mColor.clamp(); } - void setRadius(F32 radius) { mRadius = llclamp(radius, LIGHT_MIN_RADIUS, LIGHT_MAX_RADIUS); } - void setFalloff(F32 falloff) { mFalloff = llclamp(falloff, LIGHT_MIN_FALLOFF, LIGHT_MAX_FALLOFF); } - void setCutoff(F32 cutoff) { mCutoff = llclamp(cutoff, LIGHT_MIN_CUTOFF, LIGHT_MAX_CUTOFF); } - - // get the linear space color of this light. This value can be fed directly to shaders - LLColor4 getLinearColor() const { return mColor; } - // get the sRGB (gamma corrected) color of this light, this is the value that should be displayed in the UI - LLColor4 getSRGBColor() const { return srgbColor4(mColor); } - - F32 getRadius() const { return mRadius; } - F32 getFalloff() const { return mFalloff; } - F32 getCutoff() const { return mCutoff; } -}; - -extern const F32 REFLECTION_PROBE_MIN_AMBIANCE; -extern const F32 REFLECTION_PROBE_MAX_AMBIANCE; -extern const F32 REFLECTION_PROBE_DEFAULT_AMBIANCE; -extern const F32 REFLECTION_PROBE_MIN_CLIP_DISTANCE; -extern const F32 REFLECTION_PROBE_MAX_CLIP_DISTANCE; -extern const F32 REFLECTION_PROBE_DEFAULT_CLIP_DISTANCE; - -class LLReflectionProbeParams : public LLNetworkData -{ -public: - enum EFlags : U8 - { - FLAG_BOX_VOLUME = 0x01, // use a box influence volume - FLAG_DYNAMIC = 0x02, // render dynamic objects (avatars) into this Reflection Probe - }; - -protected: - F32 mAmbiance = REFLECTION_PROBE_DEFAULT_AMBIANCE; - F32 mClipDistance = REFLECTION_PROBE_DEFAULT_CLIP_DISTANCE; - U8 mFlags = 0; - -public: - LLReflectionProbeParams(); - /*virtual*/ bool pack(LLDataPacker& dp) const; - /*virtual*/ bool unpack(LLDataPacker& dp); - /*virtual*/ bool operator==(const LLNetworkData& data) const; - /*virtual*/ void copy(const LLNetworkData& data); - // LLSD implementations here are provided by Eddy Stryker. - // NOTE: there are currently unused in protocols - LLSD asLLSD() const; - operator LLSD() const { return asLLSD(); } - bool fromLLSD(LLSD& sd); - - void setAmbiance(F32 ambiance) { mAmbiance = llclamp(ambiance, REFLECTION_PROBE_MIN_AMBIANCE, REFLECTION_PROBE_MAX_AMBIANCE); } - void setClipDistance(F32 distance) { mClipDistance = llclamp(distance, REFLECTION_PROBE_MIN_CLIP_DISTANCE, REFLECTION_PROBE_MAX_CLIP_DISTANCE); } - void setIsBox(bool is_box); - void setIsDynamic(bool is_dynamic); - - F32 getAmbiance() const { return mAmbiance; } - F32 getClipDistance() const { return mClipDistance; } - bool getIsBox() const { return (mFlags & FLAG_BOX_VOLUME) != 0; } - bool getIsDynamic() const { return (mFlags & FLAG_DYNAMIC) != 0; } -}; - -//------------------------------------------------- -// This structure is also used in the part of the -// code that creates new flexible objects. -//------------------------------------------------- - -// These were made into enums so that they could be used as fixed size -// array bounds. -enum EFlexibleObjectConst -{ - // "Softness" => [0,3], increments of 1 - // Represents powers of 2: 0 -> 1, 3 -> 8 - FLEXIBLE_OBJECT_MIN_SECTIONS = 0, - FLEXIBLE_OBJECT_DEFAULT_NUM_SECTIONS = 2, - FLEXIBLE_OBJECT_MAX_SECTIONS = 3 -}; - -// "Tension" => [0,10], increments of 0.1 -extern const F32 FLEXIBLE_OBJECT_MIN_TENSION; -extern const F32 FLEXIBLE_OBJECT_DEFAULT_TENSION; -extern const F32 FLEXIBLE_OBJECT_MAX_TENSION; - -// "Drag" => [0,10], increments of 0.1 -extern const F32 FLEXIBLE_OBJECT_MIN_AIR_FRICTION; -extern const F32 FLEXIBLE_OBJECT_DEFAULT_AIR_FRICTION; -extern const F32 FLEXIBLE_OBJECT_MAX_AIR_FRICTION; - -// "Gravity" = [-10,10], increments of 0.1 -extern const F32 FLEXIBLE_OBJECT_MIN_GRAVITY; -extern const F32 FLEXIBLE_OBJECT_DEFAULT_GRAVITY; -extern const F32 FLEXIBLE_OBJECT_MAX_GRAVITY; - -// "Wind" = [0,10], increments of 0.1 -extern const F32 FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY; -extern const F32 FLEXIBLE_OBJECT_DEFAULT_WIND_SENSITIVITY; -extern const F32 FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY; - -extern const F32 FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE; - -extern const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH; -extern const bool FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE; -extern const bool FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE; - - -class LLFlexibleObjectData : public LLNetworkData -{ -protected: - S32 mSimulateLOD; // 2^n = number of simulated sections - F32 mGravity; - F32 mAirFriction; // higher is more stable, but too much looks like it's underwater - F32 mWindSensitivity; // interacts with tension, air friction, and gravity - F32 mTension; //interacts in complex ways with other parameters - LLVector3 mUserForce; // custom user-defined force vector - //bool mUsingCollisionSphere; - //bool mRenderingCollisionSphere; - -public: - void setSimulateLOD(S32 lod) { mSimulateLOD = llclamp(lod, (S32)FLEXIBLE_OBJECT_MIN_SECTIONS, (S32)FLEXIBLE_OBJECT_MAX_SECTIONS); } - void setGravity(F32 gravity) { mGravity = llclamp(gravity, FLEXIBLE_OBJECT_MIN_GRAVITY, FLEXIBLE_OBJECT_MAX_GRAVITY); } - void setAirFriction(F32 friction) { mAirFriction = llclamp(friction, FLEXIBLE_OBJECT_MIN_AIR_FRICTION, FLEXIBLE_OBJECT_MAX_AIR_FRICTION); } - void setWindSensitivity(F32 wind) { mWindSensitivity = llclamp(wind, FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY, FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY); } - void setTension(F32 tension) { mTension = llclamp(tension, FLEXIBLE_OBJECT_MIN_TENSION, FLEXIBLE_OBJECT_MAX_TENSION); } - void setUserForce(LLVector3 &force) { mUserForce = force; } - - S32 getSimulateLOD() const { return mSimulateLOD; } - F32 getGravity() const { return mGravity; } - F32 getAirFriction() const { return mAirFriction; } - F32 getWindSensitivity() const { return mWindSensitivity; } - F32 getTension() const { return mTension; } - LLVector3 getUserForce() const { return mUserForce; } - - //------ the constructor for the structure ------------ - LLFlexibleObjectData(); - bool pack(LLDataPacker &dp) const; - bool unpack(LLDataPacker &dp); - bool operator==(const LLNetworkData& data) const; - void copy(const LLNetworkData& data); - LLSD asLLSD() const; - operator LLSD() const { return asLLSD(); } - bool fromLLSD(LLSD& sd); -};// end of attributes structure - - - -class LLSculptParams : public LLNetworkData -{ -protected: - LLUUID mSculptTexture; - U8 mSculptType; - -public: - LLSculptParams(); - /*virtual*/ bool pack(LLDataPacker &dp) const; - /*virtual*/ bool unpack(LLDataPacker &dp); - /*virtual*/ bool operator==(const LLNetworkData& data) const; - /*virtual*/ void copy(const LLNetworkData& data); - LLSD asLLSD() const; - operator LLSD() const { return asLLSD(); } - bool fromLLSD(LLSD& sd); - - void setSculptTexture(const LLUUID& texture_id, U8 sculpt_type); - LLUUID getSculptTexture() const { return mSculptTexture; } - U8 getSculptType() const { return mSculptType; } -}; - -class LLLightImageParams : public LLNetworkData -{ -protected: - LLUUID mLightTexture; - LLVector3 mParams; - -public: - LLLightImageParams(); - /*virtual*/ bool pack(LLDataPacker &dp) const; - /*virtual*/ bool unpack(LLDataPacker &dp); - /*virtual*/ bool operator==(const LLNetworkData& data) const; - /*virtual*/ void copy(const LLNetworkData& data); - LLSD asLLSD() const; - operator LLSD() const { return asLLSD(); } - bool fromLLSD(LLSD& sd); - - void setLightTexture(const LLUUID& id) { mLightTexture = id; } - LLUUID getLightTexture() const { return mLightTexture; } - bool isLightSpotlight() const { return mLightTexture.notNull(); } - void setParams(const LLVector3& params) { mParams = params; } - LLVector3 getParams() const { return mParams; } - -}; - -class LLExtendedMeshParams : public LLNetworkData -{ -protected: - U32 mFlags; - -public: - static const U32 ANIMATED_MESH_ENABLED_FLAG = 0x1 << 0; - - LLExtendedMeshParams(); - /*virtual*/ bool pack(LLDataPacker &dp) const; - /*virtual*/ bool unpack(LLDataPacker &dp); - /*virtual*/ bool operator==(const LLNetworkData& data) const; - /*virtual*/ void copy(const LLNetworkData& data); - LLSD asLLSD() const; - operator LLSD() const { return asLLSD(); } - bool fromLLSD(LLSD& sd); - - void setFlags(const U32& flags) { mFlags = flags; } - U32 getFlags() const { return mFlags; } - -}; - -class LLRenderMaterialParams : public LLNetworkData -{ -private: - struct Entry - { - U8 te_idx; - LLUUID id; - }; - std::vector< Entry > mEntries; - -public: - LLRenderMaterialParams(); - bool pack(LLDataPacker& dp) const override; - bool unpack(LLDataPacker& dp) override; - bool operator==(const LLNetworkData& data) const override; - void copy(const LLNetworkData& data) override; - - void setMaterial(U8 te_idx, const LLUUID& id); - const LLUUID& getMaterial(U8 te_idx) const; - - bool isEmpty() { return mEntries.empty(); } -}; - - -// This code is not naming-standards compliant. Leaving it like this for -// now to make the connection to code in -// bool packTEMessage(LLDataPacker &dp) const; -// more obvious. This should be refactored to remove the duplication, at which -// point we can fix the names as well. -// - Vir -struct LLTEContents -{ - static const U32 MAX_TES = 45; - - LLUUID image_data[MAX_TES]; - LLColor4U colors[MAX_TES]; - F32 scale_s[MAX_TES]; - F32 scale_t[MAX_TES]; - S16 offset_s[MAX_TES]; - S16 offset_t[MAX_TES]; - S16 image_rot[MAX_TES]; - U8 bump[MAX_TES]; - U8 media_flags[MAX_TES]; - U8 glow[MAX_TES]; - LLMaterialID material_ids[MAX_TES]; - - static const U32 MAX_TE_BUFFER = 4096; - U8 packed_buffer[MAX_TE_BUFFER]; - - U32 size; - U32 face_count; -}; - -class LLPrimitive : public LLXform -{ -public: - - // HACK for removing LLPrimitive's dependency on gVolumeMgr global. - // If a different LLVolumeManager is instantiated and set early enough - // then the LLPrimitive class will use it instead of gVolumeMgr. - static LLVolumeMgr* getVolumeManager() { return sVolumeManager; } - static void setVolumeManager( LLVolumeMgr* volume_manager); - static bool cleanupVolumeManager(); - - // these flags influence how the RigidBody representation is built - static const U32 PRIM_FLAG_PHANTOM = 0x1 << 0; - static const U32 PRIM_FLAG_VOLUME_DETECT = 0x1 << 1; - static const U32 PRIM_FLAG_DYNAMIC = 0x1 << 2; - static const U32 PRIM_FLAG_AVATAR = 0x1 << 3; - static const U32 PRIM_FLAG_SCULPT = 0x1 << 4; - // not used yet, but soon - static const U32 PRIM_FLAG_COLLISION_CALLBACK = 0x1 << 5; - static const U32 PRIM_FLAG_CONVEX = 0x1 << 6; - static const U32 PRIM_FLAG_DEFAULT_VOLUME = 0x1 << 7; - static const U32 PRIM_FLAG_SITTING = 0x1 << 8; - static const U32 PRIM_FLAG_SITTING_ON_GROUND = 0x1 << 9; // Set along with PRIM_FLAG_SITTING - - LLPrimitive(); - virtual ~LLPrimitive(); - - void clearTextureList(); - - static LLPrimitive *createPrimitive(LLPCode p_code); - void init_primitive(LLPCode p_code); - - void setPCode(const LLPCode pcode); - const LLVolume *getVolumeConst() const { return mVolumep; } // HACK for Windoze confusion about ostream operator in LLVolume - LLVolume *getVolume() const { return mVolumep; } - virtual bool setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false); - - // Modify texture entry properties - inline bool validTE(const U8 te_num) const; - LLTextureEntry* getTE(const U8 te_num) const; - - virtual void setNumTEs(const U8 num_tes); - virtual void setAllTESelected(bool sel); - virtual void setAllTETextures(const LLUUID &tex_id); - virtual void setTE(const U8 index, const LLTextureEntry& te); - virtual S32 setTEColor(const U8 te, const LLColor4 &color); - virtual S32 setTEColor(const U8 te, const LLColor3 &color); - virtual S32 setTEAlpha(const U8 te, const F32 alpha); - virtual S32 setTETexture(const U8 te, const LLUUID &tex_id); - virtual S32 setTEScale (const U8 te, const F32 s, const F32 t); - virtual S32 setTEScaleS(const U8 te, const F32 s); - virtual S32 setTEScaleT(const U8 te, const F32 t); - virtual S32 setTEOffset (const U8 te, const F32 s, const F32 t); - virtual S32 setTEOffsetS(const U8 te, const F32 s); - virtual S32 setTEOffsetT(const U8 te, const F32 t); - virtual S32 setTERotation(const U8 te, const F32 r); - virtual S32 setTEBumpShinyFullbright(const U8 te, const U8 bump); - virtual S32 setTEBumpShiny(const U8 te, const U8 bump); - virtual S32 setTEMediaTexGen(const U8 te, const U8 media); - virtual S32 setTEBumpmap(const U8 te, const U8 bump); - virtual S32 setTETexGen(const U8 te, const U8 texgen); - virtual S32 setTEShiny(const U8 te, const U8 shiny); - virtual S32 setTEFullbright(const U8 te, const U8 fullbright); - virtual S32 setTEMediaFlags(const U8 te, const U8 flags); - virtual S32 setTEGlow(const U8 te, const F32 glow); - virtual S32 setTEMaterialID(const U8 te, const LLMaterialID& pMaterialID); - virtual S32 setTEMaterialParams(const U8 index, const LLMaterialPtr pMaterialParams); - virtual bool setMaterial(const U8 material); // returns true if material changed - virtual void setTESelected(const U8 te, bool sel); - - LLMaterialPtr getTEMaterialParams(const U8 index); - - void copyTEs(const LLPrimitive *primitive); - S32 packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_face_index, EMsgVariableType type) const; - bool packTEMessage(LLMessageSystem *mesgsys) const; - bool packTEMessage(LLDataPacker &dp) const; - S32 unpackTEMessage(LLMessageSystem* mesgsys, char const* block_name, const S32 block_num); // Variable num of blocks - S32 unpackTEMessage(LLDataPacker &dp); - S32 parseTEMessage(LLMessageSystem* mesgsys, char const* block_name, const S32 block_num, LLTEContents& tec); - S32 applyParsedTEMessage(LLTEContents& tec); - -#ifdef CHECK_FOR_FINITE - inline void setPosition(const LLVector3& pos); - inline void setPosition(const F32 x, const F32 y, const F32 z); - inline void addPosition(const LLVector3& pos); - - inline void setAngularVelocity(const LLVector3& avel); - inline void setAngularVelocity(const F32 x, const F32 y, const F32 z); - inline void setVelocity(const LLVector3& vel); - inline void setVelocity(const F32 x, const F32 y, const F32 z); - inline void setVelocityX(const F32 x); - inline void setVelocityY(const F32 y); - inline void setVelocityZ(const F32 z); - inline void addVelocity(const LLVector3& vel); - inline void setAcceleration(const LLVector3& accel); - inline void setAcceleration(const F32 x, const F32 y, const F32 z); -#else - // Don't override the base LLXForm operators. - // Special case for setPosition. If not check-for-finite, fall through to LLXform method. - // void setPosition(F32 x, F32 y, F32 z) - // void setPosition(LLVector3) - - void setAngularVelocity(const LLVector3& avel) { mAngularVelocity = avel; } - void setAngularVelocity(const F32 x, const F32 y, const F32 z) { mAngularVelocity.setVec(x,y,z); } - void setVelocity(const LLVector3& vel) { mVelocity = vel; } - void setVelocity(const F32 x, const F32 y, const F32 z) { mVelocity.setVec(x,y,z); } - void setVelocityX(const F32 x) { mVelocity.mV[VX] = x; } - void setVelocityY(const F32 y) { mVelocity.mV[VY] = y; } - void setVelocityZ(const F32 z) { mVelocity.mV[VZ] = z; } - void addVelocity(const LLVector3& vel) { mVelocity += vel; } - void setAcceleration(const LLVector3& accel) { mAcceleration = accel; } - void setAcceleration(const F32 x, const F32 y, const F32 z) { mAcceleration.setVec(x,y,z); } -#endif - - LLPCode getPCode() const { return mPrimitiveCode; } - std::string getPCodeString() const { return pCodeToString(mPrimitiveCode); } - const LLVector3& getAngularVelocity() const { return mAngularVelocity; } - const LLVector3& getVelocity() const { return mVelocity; } - const LLVector3& getAcceleration() const { return mAcceleration; } - U8 getNumTEs() const { return mTextureList.size(); } - U8 getExpectedNumTEs() const; - - U8 getMaterial() const { return mMaterial; } - - void setVolumeType(const U8 code); - U8 getVolumeType(); - - // clears existing textures - // copies the contents of other_list into mEntryList - void copyTextureList(const LLPrimTextureList& other_list); - - // clears existing textures - // takes the contents of other_list and clears other_list - void takeTextureList(LLPrimTextureList& other_list); - - inline bool isAvatar() const; - inline bool isSittingAvatar() const; - inline bool isSittingAvatarOnGround() const; - inline bool hasBumpmap() const { return mNumBumpmapTEs > 0;} - - void setFlags(U32 flags) { mMiscFlags = flags; } - void addFlags(U32 flags) { mMiscFlags |= flags; } - void removeFlags(U32 flags) { mMiscFlags &= ~flags; } - U32 getFlags() const { return mMiscFlags; } - bool checkFlags(U32 flags) const { return (mMiscFlags & flags) != 0; } - - static std::string pCodeToString(const LLPCode pcode); - static LLPCode legacyToPCode(const U8 legacy); - static U8 pCodeToLegacy(const LLPCode pcode); - static bool getTESTAxes(const U8 face, U32* s_axis, U32* t_axis); - - bool hasRenderMaterialParams() const; - - inline static bool isPrimitive(const LLPCode pcode); - inline static bool isApp(const LLPCode pcode); - -private: - void updateNumBumpmap(const U8 index, const U8 bump); - -protected: - LLPCode mPrimitiveCode; // Primitive code - LLVector3 mVelocity; // how fast are we moving? - LLVector3 mAcceleration; // are we under constant acceleration? - LLVector3 mAngularVelocity; // angular velocity - LLPointer mVolumep; - LLPrimTextureList mTextureList; // list of texture GUIDs, scales, offsets - U8 mMaterial; // Material code - U8 mNumTEs; // # of faces on the primitve - U8 mNumBumpmapTEs; // number of bumpmap TEs. - U32 mMiscFlags; // home for misc bools - -public: - static LLVolumeMgr* sVolumeManager; - - enum - { - NO_LOD = -1 - }; -}; - -inline bool LLPrimitive::isAvatar() const -{ - return LL_PCODE_LEGACY_AVATAR == mPrimitiveCode; -} - -inline bool LLPrimitive::isSittingAvatar() const -{ - // this is only used server-side - return isAvatar() && checkFlags(PRIM_FLAG_SITTING | PRIM_FLAG_SITTING_ON_GROUND); -} - -inline bool LLPrimitive::isSittingAvatarOnGround() const -{ - // this is only used server-side - return isAvatar() && checkFlags(PRIM_FLAG_SITTING_ON_GROUND); -} - -// static -inline bool LLPrimitive::isPrimitive(const LLPCode pcode) -{ - LLPCode base_type = pcode & LL_PCODE_BASE_MASK; - - if (base_type && (base_type < LL_PCODE_APP)) - { - return true; - } - return false; -} - -// static -inline bool LLPrimitive::isApp(const LLPCode pcode) -{ - LLPCode base_type = pcode & LL_PCODE_BASE_MASK; - - return (base_type == LL_PCODE_APP); -} - - -#ifdef CHECK_FOR_FINITE -// Special case for setPosition. If not check-for-finite, fall through to LLXform method. -void LLPrimitive::setPosition(const F32 x, const F32 y, const F32 z) -{ - if (llfinite(x) && llfinite(y) && llfinite(z)) - { - LLXform::setPosition(x, y, z); - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setPosition(x,y,z) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; - } -} - -// Special case for setPosition. If not check-for-finite, fall through to LLXform method. -void LLPrimitive::setPosition(const LLVector3& pos) -{ - if (pos.isFinite()) - { - LLXform::setPosition(pos); - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setPosition(LLVector3) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; - } -} - -void LLPrimitive::setAngularVelocity(const LLVector3& avel) -{ - if (avel.isFinite()) - { - mAngularVelocity = avel; - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setAngularVelocity" << LL_ENDL; - } -} - -void LLPrimitive::setAngularVelocity(const F32 x, const F32 y, const F32 z) -{ - if (llfinite(x) && llfinite(y) && llfinite(z)) - { - mAngularVelocity.setVec(x,y,z); - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setAngularVelocity" << LL_ENDL; - } -} - -void LLPrimitive::setVelocity(const LLVector3& vel) -{ - if (vel.isFinite()) - { - mVelocity = vel; - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setVelocity(LLVector3) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; - } -} - -void LLPrimitive::setVelocity(const F32 x, const F32 y, const F32 z) -{ - if (llfinite(x) && llfinite(y) && llfinite(z)) - { - mVelocity.setVec(x,y,z); - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setVelocity(F32,F32,F32) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; - } -} - -void LLPrimitive::setVelocityX(const F32 x) -{ - if (llfinite(x)) - { - mVelocity.mV[VX] = x; - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setVelocityX" << LL_ENDL; - } -} - -void LLPrimitive::setVelocityY(const F32 y) -{ - if (llfinite(y)) - { - mVelocity.mV[VY] = y; - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setVelocityY" << LL_ENDL; - } -} - -void LLPrimitive::setVelocityZ(const F32 z) -{ - if (llfinite(z)) - { - mVelocity.mV[VZ] = z; - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setVelocityZ" << LL_ENDL; - } -} - -void LLPrimitive::addVelocity(const LLVector3& vel) -{ - if (vel.isFinite()) - { - mVelocity += vel; - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::addVelocity" << LL_ENDL; - } -} - -void LLPrimitive::setAcceleration(const LLVector3& accel) -{ - if (accel.isFinite()) - { - mAcceleration = accel; - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setAcceleration(LLVector3) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; - } -} - -void LLPrimitive::setAcceleration(const F32 x, const F32 y, const F32 z) -{ - if (llfinite(x) && llfinite(y) && llfinite(z)) - { - mAcceleration.setVec(x,y,z); - } - else - { - LL_ERRS() << "Non Finite in LLPrimitive::setAcceleration(F32,F32,F32) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; - } -} -#endif // CHECK_FOR_FINITE - -inline bool LLPrimitive::validTE(const U8 te_num) const -{ - return (mNumTEs && te_num < mNumTEs); -} - -#endif - +/** + * @file llprimitive.h + * @brief LLPrimitive base class + * + * $LicenseInfo:firstyear=2001&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2010, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#ifndef LL_LLPRIMITIVE_H +#define LL_LLPRIMITIVE_H + +#include "lluuid.h" +#include "v3math.h" +#include "xform.h" +#include "message.h" +#include "llpointer.h" +#include "llvolume.h" +#include "lltextureentry.h" +#include "llprimtexturelist.h" + +// Moved to stdtypes.h --JC +// typedef U8 LLPCode; +class LLMessageSystem; +class LLVolumeParams; +class LLColor4; +class LLColor3; +class LLMaterialID; +class LLTextureEntry; +class LLDataPacker; +class LLVolumeMgr; + +enum LLGeomType // NOTE: same vals as GL Ids +{ + LLInvalid = 0, + LLLineLoop = 2, + LLLineStrip = 3, + LLTriangles = 4, + LLTriStrip = 5, + LLTriFan = 6, + LLQuads = 7, + LLQuadStrip = 8 +}; + +class LLVolume; + +/** + * exported constants + */ +extern const F32 OBJECT_CUT_MIN; +extern const F32 OBJECT_CUT_MAX; +extern const F32 OBJECT_CUT_INC; +extern const F32 OBJECT_MIN_CUT_INC; +extern const F32 OBJECT_ROTATION_PRECISION; + +extern const F32 OBJECT_TWIST_MIN; +extern const F32 OBJECT_TWIST_MAX; +extern const F32 OBJECT_TWIST_INC; + +// This is used for linear paths, +// since twist is used in a slightly different manner. +extern const F32 OBJECT_TWIST_LINEAR_MIN; +extern const F32 OBJECT_TWIST_LINEAR_MAX; +extern const F32 OBJECT_TWIST_LINEAR_INC; + +extern const F32 OBJECT_MIN_HOLE_SIZE; +extern const F32 OBJECT_MAX_HOLE_SIZE_X; +extern const F32 OBJECT_MAX_HOLE_SIZE_Y; + +// Revolutions parameters. +extern const F32 OBJECT_REV_MIN; +extern const F32 OBJECT_REV_MAX; +extern const F32 OBJECT_REV_INC; + +extern const LLUUID SCULPT_DEFAULT_TEXTURE; + +//============================================================================ + +// TomY: Base class for things that pack & unpack themselves +class LLNetworkData +{ +public: + // Extra parameter IDs + enum + { + PARAMS_FLEXIBLE = 0x10, + PARAMS_LIGHT = 0x20, + PARAMS_SCULPT = 0x30, + PARAMS_LIGHT_IMAGE = 0x40, + PARAMS_RESERVED = 0x50, // Used on server-side + PARAMS_MESH = 0x60, + PARAMS_EXTENDED_MESH = 0x70, + PARAMS_RENDER_MATERIAL = 0x80, + PARAMS_REFLECTION_PROBE = 0x90, + }; + +public: + U16 mType; + virtual ~LLNetworkData() {}; + virtual bool pack(LLDataPacker &dp) const = 0; + virtual bool unpack(LLDataPacker &dp) = 0; + virtual bool operator==(const LLNetworkData& data) const = 0; + virtual void copy(const LLNetworkData& data) = 0; + static bool isValid(U16 param_type, U32 size); +}; + +extern const F32 LIGHT_MIN_RADIUS; +extern const F32 LIGHT_DEFAULT_RADIUS; +extern const F32 LIGHT_MAX_RADIUS; +extern const F32 LIGHT_MIN_FALLOFF; +extern const F32 LIGHT_DEFAULT_FALLOFF; +extern const F32 LIGHT_MAX_FALLOFF; +extern const F32 LIGHT_MIN_CUTOFF; +extern const F32 LIGHT_DEFAULT_CUTOFF; +extern const F32 LIGHT_MAX_CUTOFF; + +class LLLightParams : public LLNetworkData +{ +private: + LLColor4 mColor; // linear color (not gamma corrected), alpha = intensity + F32 mRadius; + F32 mFalloff; + F32 mCutoff; + +public: + LLLightParams(); + /*virtual*/ bool pack(LLDataPacker &dp) const; + /*virtual*/ bool unpack(LLDataPacker &dp); + /*virtual*/ bool operator==(const LLNetworkData& data) const; + /*virtual*/ void copy(const LLNetworkData& data); + // LLSD implementations here are provided by Eddy Stryker. + // NOTE: there are currently unused in protocols + LLSD asLLSD() const; + operator LLSD() const { return asLLSD(); } + bool fromLLSD(LLSD& sd); + + // set the color by gamma corrected color value + // color - gamma corrected color value (directly taken from an on-screen color swatch) + void setSRGBColor(const LLColor4& color) { setLinearColor(linearColor4(color)); } + + // set the color by linear color value + // color - linear color value (value as it appears in shaders) + void setLinearColor(const LLColor4& color) { mColor = color; mColor.clamp(); } + void setRadius(F32 radius) { mRadius = llclamp(radius, LIGHT_MIN_RADIUS, LIGHT_MAX_RADIUS); } + void setFalloff(F32 falloff) { mFalloff = llclamp(falloff, LIGHT_MIN_FALLOFF, LIGHT_MAX_FALLOFF); } + void setCutoff(F32 cutoff) { mCutoff = llclamp(cutoff, LIGHT_MIN_CUTOFF, LIGHT_MAX_CUTOFF); } + + // get the linear space color of this light. This value can be fed directly to shaders + LLColor4 getLinearColor() const { return mColor; } + // get the sRGB (gamma corrected) color of this light, this is the value that should be displayed in the UI + LLColor4 getSRGBColor() const { return srgbColor4(mColor); } + + F32 getRadius() const { return mRadius; } + F32 getFalloff() const { return mFalloff; } + F32 getCutoff() const { return mCutoff; } +}; + +extern const F32 REFLECTION_PROBE_MIN_AMBIANCE; +extern const F32 REFLECTION_PROBE_MAX_AMBIANCE; +extern const F32 REFLECTION_PROBE_DEFAULT_AMBIANCE; +extern const F32 REFLECTION_PROBE_MIN_CLIP_DISTANCE; +extern const F32 REFLECTION_PROBE_MAX_CLIP_DISTANCE; +extern const F32 REFLECTION_PROBE_DEFAULT_CLIP_DISTANCE; + +class LLReflectionProbeParams : public LLNetworkData +{ +public: + enum EFlags : U8 + { + FLAG_BOX_VOLUME = 0x01, // use a box influence volume + FLAG_DYNAMIC = 0x02, // render dynamic objects (avatars) into this Reflection Probe + }; + +protected: + F32 mAmbiance = REFLECTION_PROBE_DEFAULT_AMBIANCE; + F32 mClipDistance = REFLECTION_PROBE_DEFAULT_CLIP_DISTANCE; + U8 mFlags = 0; + +public: + LLReflectionProbeParams(); + /*virtual*/ bool pack(LLDataPacker& dp) const; + /*virtual*/ bool unpack(LLDataPacker& dp); + /*virtual*/ bool operator==(const LLNetworkData& data) const; + /*virtual*/ void copy(const LLNetworkData& data); + // LLSD implementations here are provided by Eddy Stryker. + // NOTE: there are currently unused in protocols + LLSD asLLSD() const; + operator LLSD() const { return asLLSD(); } + bool fromLLSD(LLSD& sd); + + void setAmbiance(F32 ambiance) { mAmbiance = llclamp(ambiance, REFLECTION_PROBE_MIN_AMBIANCE, REFLECTION_PROBE_MAX_AMBIANCE); } + void setClipDistance(F32 distance) { mClipDistance = llclamp(distance, REFLECTION_PROBE_MIN_CLIP_DISTANCE, REFLECTION_PROBE_MAX_CLIP_DISTANCE); } + void setIsBox(bool is_box); + void setIsDynamic(bool is_dynamic); + + F32 getAmbiance() const { return mAmbiance; } + F32 getClipDistance() const { return mClipDistance; } + bool getIsBox() const { return (mFlags & FLAG_BOX_VOLUME) != 0; } + bool getIsDynamic() const { return (mFlags & FLAG_DYNAMIC) != 0; } +}; + +//------------------------------------------------- +// This structure is also used in the part of the +// code that creates new flexible objects. +//------------------------------------------------- + +// These were made into enums so that they could be used as fixed size +// array bounds. +enum EFlexibleObjectConst +{ + // "Softness" => [0,3], increments of 1 + // Represents powers of 2: 0 -> 1, 3 -> 8 + FLEXIBLE_OBJECT_MIN_SECTIONS = 0, + FLEXIBLE_OBJECT_DEFAULT_NUM_SECTIONS = 2, + FLEXIBLE_OBJECT_MAX_SECTIONS = 3 +}; + +// "Tension" => [0,10], increments of 0.1 +extern const F32 FLEXIBLE_OBJECT_MIN_TENSION; +extern const F32 FLEXIBLE_OBJECT_DEFAULT_TENSION; +extern const F32 FLEXIBLE_OBJECT_MAX_TENSION; + +// "Drag" => [0,10], increments of 0.1 +extern const F32 FLEXIBLE_OBJECT_MIN_AIR_FRICTION; +extern const F32 FLEXIBLE_OBJECT_DEFAULT_AIR_FRICTION; +extern const F32 FLEXIBLE_OBJECT_MAX_AIR_FRICTION; + +// "Gravity" = [-10,10], increments of 0.1 +extern const F32 FLEXIBLE_OBJECT_MIN_GRAVITY; +extern const F32 FLEXIBLE_OBJECT_DEFAULT_GRAVITY; +extern const F32 FLEXIBLE_OBJECT_MAX_GRAVITY; + +// "Wind" = [0,10], increments of 0.1 +extern const F32 FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY; +extern const F32 FLEXIBLE_OBJECT_DEFAULT_WIND_SENSITIVITY; +extern const F32 FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY; + +extern const F32 FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE; + +extern const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH; +extern const bool FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE; +extern const bool FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE; + + +class LLFlexibleObjectData : public LLNetworkData +{ +protected: + S32 mSimulateLOD; // 2^n = number of simulated sections + F32 mGravity; + F32 mAirFriction; // higher is more stable, but too much looks like it's underwater + F32 mWindSensitivity; // interacts with tension, air friction, and gravity + F32 mTension; //interacts in complex ways with other parameters + LLVector3 mUserForce; // custom user-defined force vector + //bool mUsingCollisionSphere; + //bool mRenderingCollisionSphere; + +public: + void setSimulateLOD(S32 lod) { mSimulateLOD = llclamp(lod, (S32)FLEXIBLE_OBJECT_MIN_SECTIONS, (S32)FLEXIBLE_OBJECT_MAX_SECTIONS); } + void setGravity(F32 gravity) { mGravity = llclamp(gravity, FLEXIBLE_OBJECT_MIN_GRAVITY, FLEXIBLE_OBJECT_MAX_GRAVITY); } + void setAirFriction(F32 friction) { mAirFriction = llclamp(friction, FLEXIBLE_OBJECT_MIN_AIR_FRICTION, FLEXIBLE_OBJECT_MAX_AIR_FRICTION); } + void setWindSensitivity(F32 wind) { mWindSensitivity = llclamp(wind, FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY, FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY); } + void setTension(F32 tension) { mTension = llclamp(tension, FLEXIBLE_OBJECT_MIN_TENSION, FLEXIBLE_OBJECT_MAX_TENSION); } + void setUserForce(LLVector3 &force) { mUserForce = force; } + + S32 getSimulateLOD() const { return mSimulateLOD; } + F32 getGravity() const { return mGravity; } + F32 getAirFriction() const { return mAirFriction; } + F32 getWindSensitivity() const { return mWindSensitivity; } + F32 getTension() const { return mTension; } + LLVector3 getUserForce() const { return mUserForce; } + + //------ the constructor for the structure ------------ + LLFlexibleObjectData(); + bool pack(LLDataPacker &dp) const; + bool unpack(LLDataPacker &dp); + bool operator==(const LLNetworkData& data) const; + void copy(const LLNetworkData& data); + LLSD asLLSD() const; + operator LLSD() const { return asLLSD(); } + bool fromLLSD(LLSD& sd); +};// end of attributes structure + + + +class LLSculptParams : public LLNetworkData +{ +protected: + LLUUID mSculptTexture; + U8 mSculptType; + +public: + LLSculptParams(); + /*virtual*/ bool pack(LLDataPacker &dp) const; + /*virtual*/ bool unpack(LLDataPacker &dp); + /*virtual*/ bool operator==(const LLNetworkData& data) const; + /*virtual*/ void copy(const LLNetworkData& data); + LLSD asLLSD() const; + operator LLSD() const { return asLLSD(); } + bool fromLLSD(LLSD& sd); + + void setSculptTexture(const LLUUID& texture_id, U8 sculpt_type); + LLUUID getSculptTexture() const { return mSculptTexture; } + U8 getSculptType() const { return mSculptType; } +}; + +class LLLightImageParams : public LLNetworkData +{ +protected: + LLUUID mLightTexture; + LLVector3 mParams; + +public: + LLLightImageParams(); + /*virtual*/ bool pack(LLDataPacker &dp) const; + /*virtual*/ bool unpack(LLDataPacker &dp); + /*virtual*/ bool operator==(const LLNetworkData& data) const; + /*virtual*/ void copy(const LLNetworkData& data); + LLSD asLLSD() const; + operator LLSD() const { return asLLSD(); } + bool fromLLSD(LLSD& sd); + + void setLightTexture(const LLUUID& id) { mLightTexture = id; } + LLUUID getLightTexture() const { return mLightTexture; } + bool isLightSpotlight() const { return mLightTexture.notNull(); } + void setParams(const LLVector3& params) { mParams = params; } + LLVector3 getParams() const { return mParams; } + +}; + +class LLExtendedMeshParams : public LLNetworkData +{ +protected: + U32 mFlags; + +public: + static const U32 ANIMATED_MESH_ENABLED_FLAG = 0x1 << 0; + + LLExtendedMeshParams(); + /*virtual*/ bool pack(LLDataPacker &dp) const; + /*virtual*/ bool unpack(LLDataPacker &dp); + /*virtual*/ bool operator==(const LLNetworkData& data) const; + /*virtual*/ void copy(const LLNetworkData& data); + LLSD asLLSD() const; + operator LLSD() const { return asLLSD(); } + bool fromLLSD(LLSD& sd); + + void setFlags(const U32& flags) { mFlags = flags; } + U32 getFlags() const { return mFlags; } + +}; + +class LLRenderMaterialParams : public LLNetworkData +{ +private: + struct Entry + { + U8 te_idx; + LLUUID id; + }; + std::vector< Entry > mEntries; + +public: + LLRenderMaterialParams(); + bool pack(LLDataPacker& dp) const override; + bool unpack(LLDataPacker& dp) override; + bool operator==(const LLNetworkData& data) const override; + void copy(const LLNetworkData& data) override; + + void setMaterial(U8 te_idx, const LLUUID& id); + const LLUUID& getMaterial(U8 te_idx) const; + + bool isEmpty() { return mEntries.empty(); } +}; + + +// This code is not naming-standards compliant. Leaving it like this for +// now to make the connection to code in +// bool packTEMessage(LLDataPacker &dp) const; +// more obvious. This should be refactored to remove the duplication, at which +// point we can fix the names as well. +// - Vir +struct LLTEContents +{ + static const U32 MAX_TES = 45; + + LLUUID image_data[MAX_TES]; + LLColor4U colors[MAX_TES]; + F32 scale_s[MAX_TES]; + F32 scale_t[MAX_TES]; + S16 offset_s[MAX_TES]; + S16 offset_t[MAX_TES]; + S16 image_rot[MAX_TES]; + U8 bump[MAX_TES]; + U8 media_flags[MAX_TES]; + U8 glow[MAX_TES]; + LLMaterialID material_ids[MAX_TES]; + + static const U32 MAX_TE_BUFFER = 4096; + U8 packed_buffer[MAX_TE_BUFFER]; + + U32 size; + U32 face_count; +}; + +class LLPrimitive : public LLXform +{ +public: + + // HACK for removing LLPrimitive's dependency on gVolumeMgr global. + // If a different LLVolumeManager is instantiated and set early enough + // then the LLPrimitive class will use it instead of gVolumeMgr. + static LLVolumeMgr* getVolumeManager() { return sVolumeManager; } + static void setVolumeManager( LLVolumeMgr* volume_manager); + static bool cleanupVolumeManager(); + + // these flags influence how the RigidBody representation is built + static const U32 PRIM_FLAG_PHANTOM = 0x1 << 0; + static const U32 PRIM_FLAG_VOLUME_DETECT = 0x1 << 1; + static const U32 PRIM_FLAG_DYNAMIC = 0x1 << 2; + static const U32 PRIM_FLAG_AVATAR = 0x1 << 3; + static const U32 PRIM_FLAG_SCULPT = 0x1 << 4; + // not used yet, but soon + static const U32 PRIM_FLAG_COLLISION_CALLBACK = 0x1 << 5; + static const U32 PRIM_FLAG_CONVEX = 0x1 << 6; + static const U32 PRIM_FLAG_DEFAULT_VOLUME = 0x1 << 7; + static const U32 PRIM_FLAG_SITTING = 0x1 << 8; + static const U32 PRIM_FLAG_SITTING_ON_GROUND = 0x1 << 9; // Set along with PRIM_FLAG_SITTING + + LLPrimitive(); + virtual ~LLPrimitive(); + + void clearTextureList(); + + static LLPrimitive *createPrimitive(LLPCode p_code); + void init_primitive(LLPCode p_code); + + void setPCode(const LLPCode pcode); + const LLVolume *getVolumeConst() const { return mVolumep; } // HACK for Windoze confusion about ostream operator in LLVolume + LLVolume *getVolume() const { return mVolumep; } + virtual bool setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false); + + // Modify texture entry properties + inline bool validTE(const U8 te_num) const; + LLTextureEntry* getTE(const U8 te_num) const; + + virtual void setNumTEs(const U8 num_tes); + virtual void setAllTESelected(bool sel); + virtual void setAllTETextures(const LLUUID &tex_id); + virtual void setTE(const U8 index, const LLTextureEntry& te); + virtual S32 setTEColor(const U8 te, const LLColor4 &color); + virtual S32 setTEColor(const U8 te, const LLColor3 &color); + virtual S32 setTEAlpha(const U8 te, const F32 alpha); + virtual S32 setTETexture(const U8 te, const LLUUID &tex_id); + virtual S32 setTEScale (const U8 te, const F32 s, const F32 t); + virtual S32 setTEScaleS(const U8 te, const F32 s); + virtual S32 setTEScaleT(const U8 te, const F32 t); + virtual S32 setTEOffset (const U8 te, const F32 s, const F32 t); + virtual S32 setTEOffsetS(const U8 te, const F32 s); + virtual S32 setTEOffsetT(const U8 te, const F32 t); + virtual S32 setTERotation(const U8 te, const F32 r); + virtual S32 setTEBumpShinyFullbright(const U8 te, const U8 bump); + virtual S32 setTEBumpShiny(const U8 te, const U8 bump); + virtual S32 setTEMediaTexGen(const U8 te, const U8 media); + virtual S32 setTEBumpmap(const U8 te, const U8 bump); + virtual S32 setTETexGen(const U8 te, const U8 texgen); + virtual S32 setTEShiny(const U8 te, const U8 shiny); + virtual S32 setTEFullbright(const U8 te, const U8 fullbright); + virtual S32 setTEMediaFlags(const U8 te, const U8 flags); + virtual S32 setTEGlow(const U8 te, const F32 glow); + virtual S32 setTEMaterialID(const U8 te, const LLMaterialID& pMaterialID); + virtual S32 setTEMaterialParams(const U8 index, const LLMaterialPtr pMaterialParams); + virtual bool setMaterial(const U8 material); // returns true if material changed + virtual void setTESelected(const U8 te, bool sel); + + LLMaterialPtr getTEMaterialParams(const U8 index); + + void copyTEs(const LLPrimitive *primitive); + S32 packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_face_index, EMsgVariableType type) const; + bool packTEMessage(LLMessageSystem *mesgsys) const; + bool packTEMessage(LLDataPacker &dp) const; + S32 unpackTEMessage(LLMessageSystem* mesgsys, char const* block_name, const S32 block_num); // Variable num of blocks + S32 unpackTEMessage(LLDataPacker &dp); + S32 parseTEMessage(LLMessageSystem* mesgsys, char const* block_name, const S32 block_num, LLTEContents& tec); + S32 applyParsedTEMessage(LLTEContents& tec); + +#ifdef CHECK_FOR_FINITE + inline void setPosition(const LLVector3& pos); + inline void setPosition(const F32 x, const F32 y, const F32 z); + inline void addPosition(const LLVector3& pos); + + inline void setAngularVelocity(const LLVector3& avel); + inline void setAngularVelocity(const F32 x, const F32 y, const F32 z); + inline void setVelocity(const LLVector3& vel); + inline void setVelocity(const F32 x, const F32 y, const F32 z); + inline void setVelocityX(const F32 x); + inline void setVelocityY(const F32 y); + inline void setVelocityZ(const F32 z); + inline void addVelocity(const LLVector3& vel); + inline void setAcceleration(const LLVector3& accel); + inline void setAcceleration(const F32 x, const F32 y, const F32 z); +#else + // Don't override the base LLXForm operators. + // Special case for setPosition. If not check-for-finite, fall through to LLXform method. + // void setPosition(F32 x, F32 y, F32 z) + // void setPosition(LLVector3) + + void setAngularVelocity(const LLVector3& avel) { mAngularVelocity = avel; } + void setAngularVelocity(const F32 x, const F32 y, const F32 z) { mAngularVelocity.setVec(x,y,z); } + void setVelocity(const LLVector3& vel) { mVelocity = vel; } + void setVelocity(const F32 x, const F32 y, const F32 z) { mVelocity.setVec(x,y,z); } + void setVelocityX(const F32 x) { mVelocity.mV[VX] = x; } + void setVelocityY(const F32 y) { mVelocity.mV[VY] = y; } + void setVelocityZ(const F32 z) { mVelocity.mV[VZ] = z; } + void addVelocity(const LLVector3& vel) { mVelocity += vel; } + void setAcceleration(const LLVector3& accel) { mAcceleration = accel; } + void setAcceleration(const F32 x, const F32 y, const F32 z) { mAcceleration.setVec(x,y,z); } +#endif + + LLPCode getPCode() const { return mPrimitiveCode; } + std::string getPCodeString() const { return pCodeToString(mPrimitiveCode); } + const LLVector3& getAngularVelocity() const { return mAngularVelocity; } + const LLVector3& getVelocity() const { return mVelocity; } + const LLVector3& getAcceleration() const { return mAcceleration; } + U8 getNumTEs() const { return mTextureList.size(); } + U8 getExpectedNumTEs() const; + + U8 getMaterial() const { return mMaterial; } + + void setVolumeType(const U8 code); + U8 getVolumeType(); + + // clears existing textures + // copies the contents of other_list into mEntryList + void copyTextureList(const LLPrimTextureList& other_list); + + // clears existing textures + // takes the contents of other_list and clears other_list + void takeTextureList(LLPrimTextureList& other_list); + + inline bool isAvatar() const; + inline bool isSittingAvatar() const; + inline bool isSittingAvatarOnGround() const; + inline bool hasBumpmap() const { return mNumBumpmapTEs > 0;} + + void setFlags(U32 flags) { mMiscFlags = flags; } + void addFlags(U32 flags) { mMiscFlags |= flags; } + void removeFlags(U32 flags) { mMiscFlags &= ~flags; } + U32 getFlags() const { return mMiscFlags; } + bool checkFlags(U32 flags) const { return (mMiscFlags & flags) != 0; } + + static std::string pCodeToString(const LLPCode pcode); + static LLPCode legacyToPCode(const U8 legacy); + static U8 pCodeToLegacy(const LLPCode pcode); + static bool getTESTAxes(const U8 face, U32* s_axis, U32* t_axis); + + bool hasRenderMaterialParams() const; + + inline static bool isPrimitive(const LLPCode pcode); + inline static bool isApp(const LLPCode pcode); + +private: + void updateNumBumpmap(const U8 index, const U8 bump); + +protected: + LLPCode mPrimitiveCode; // Primitive code + LLVector3 mVelocity; // how fast are we moving? + LLVector3 mAcceleration; // are we under constant acceleration? + LLVector3 mAngularVelocity; // angular velocity + LLPointer mVolumep; + LLPrimTextureList mTextureList; // list of texture GUIDs, scales, offsets + U8 mMaterial; // Material code + U8 mNumTEs; // # of faces on the primitve + U8 mNumBumpmapTEs; // number of bumpmap TEs. + U32 mMiscFlags; // home for misc bools + +public: + static LLVolumeMgr* sVolumeManager; + + enum + { + NO_LOD = -1 + }; +}; + +inline bool LLPrimitive::isAvatar() const +{ + return LL_PCODE_LEGACY_AVATAR == mPrimitiveCode; +} + +inline bool LLPrimitive::isSittingAvatar() const +{ + // this is only used server-side + return isAvatar() && checkFlags(PRIM_FLAG_SITTING | PRIM_FLAG_SITTING_ON_GROUND); +} + +inline bool LLPrimitive::isSittingAvatarOnGround() const +{ + // this is only used server-side + return isAvatar() && checkFlags(PRIM_FLAG_SITTING_ON_GROUND); +} + +// static +inline bool LLPrimitive::isPrimitive(const LLPCode pcode) +{ + LLPCode base_type = pcode & LL_PCODE_BASE_MASK; + + if (base_type && (base_type < LL_PCODE_APP)) + { + return true; + } + return false; +} + +// static +inline bool LLPrimitive::isApp(const LLPCode pcode) +{ + LLPCode base_type = pcode & LL_PCODE_BASE_MASK; + + return (base_type == LL_PCODE_APP); +} + + +#ifdef CHECK_FOR_FINITE +// Special case for setPosition. If not check-for-finite, fall through to LLXform method. +void LLPrimitive::setPosition(const F32 x, const F32 y, const F32 z) +{ + if (llfinite(x) && llfinite(y) && llfinite(z)) + { + LLXform::setPosition(x, y, z); + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setPosition(x,y,z) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; + } +} + +// Special case for setPosition. If not check-for-finite, fall through to LLXform method. +void LLPrimitive::setPosition(const LLVector3& pos) +{ + if (pos.isFinite()) + { + LLXform::setPosition(pos); + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setPosition(LLVector3) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; + } +} + +void LLPrimitive::setAngularVelocity(const LLVector3& avel) +{ + if (avel.isFinite()) + { + mAngularVelocity = avel; + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setAngularVelocity" << LL_ENDL; + } +} + +void LLPrimitive::setAngularVelocity(const F32 x, const F32 y, const F32 z) +{ + if (llfinite(x) && llfinite(y) && llfinite(z)) + { + mAngularVelocity.setVec(x,y,z); + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setAngularVelocity" << LL_ENDL; + } +} + +void LLPrimitive::setVelocity(const LLVector3& vel) +{ + if (vel.isFinite()) + { + mVelocity = vel; + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setVelocity(LLVector3) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; + } +} + +void LLPrimitive::setVelocity(const F32 x, const F32 y, const F32 z) +{ + if (llfinite(x) && llfinite(y) && llfinite(z)) + { + mVelocity.setVec(x,y,z); + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setVelocity(F32,F32,F32) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; + } +} + +void LLPrimitive::setVelocityX(const F32 x) +{ + if (llfinite(x)) + { + mVelocity.mV[VX] = x; + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setVelocityX" << LL_ENDL; + } +} + +void LLPrimitive::setVelocityY(const F32 y) +{ + if (llfinite(y)) + { + mVelocity.mV[VY] = y; + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setVelocityY" << LL_ENDL; + } +} + +void LLPrimitive::setVelocityZ(const F32 z) +{ + if (llfinite(z)) + { + mVelocity.mV[VZ] = z; + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setVelocityZ" << LL_ENDL; + } +} + +void LLPrimitive::addVelocity(const LLVector3& vel) +{ + if (vel.isFinite()) + { + mVelocity += vel; + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::addVelocity" << LL_ENDL; + } +} + +void LLPrimitive::setAcceleration(const LLVector3& accel) +{ + if (accel.isFinite()) + { + mAcceleration = accel; + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setAcceleration(LLVector3) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; + } +} + +void LLPrimitive::setAcceleration(const F32 x, const F32 y, const F32 z) +{ + if (llfinite(x) && llfinite(y) && llfinite(z)) + { + mAcceleration.setVec(x,y,z); + } + else + { + LL_ERRS() << "Non Finite in LLPrimitive::setAcceleration(F32,F32,F32) for " << pCodeToString(mPrimitiveCode) << LL_ENDL; + } +} +#endif // CHECK_FOR_FINITE + +inline bool LLPrimitive::validTE(const U8 te_num) const +{ + return (mNumTEs && te_num < mNumTEs); +} + +#endif + -- cgit v1.2.3