338 lines
12 KiB
C++
338 lines
12 KiB
C++
/**
|
|
* @file llvovolume.h
|
|
* @brief LLVOVolume class header file
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2001-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#ifndef LL_LLVOVOLUME_H
|
|
#define LL_LLVOVOLUME_H
|
|
|
|
#include "llviewerobject.h"
|
|
#include "llviewertexture.h"
|
|
#include "llframetimer.h"
|
|
#include "llapr.h"
|
|
#include "m3math.h" // LLMatrix3
|
|
#include "m4math.h" // LLMatrix4
|
|
#include <map>
|
|
|
|
class LLViewerTextureAnim;
|
|
class LLDrawPool;
|
|
class LLSelectNode;
|
|
class LLVOAvatar;
|
|
class LLMeshSkinInfo;
|
|
|
|
enum LLVolumeInterfaceType
|
|
{
|
|
INTERFACE_FLEXIBLE = 1,
|
|
};
|
|
|
|
#if MESH_ENABLED
|
|
class LLRiggedVolume : public LLVolume
|
|
{
|
|
public:
|
|
LLRiggedVolume(const LLVolumeParams& params)
|
|
: LLVolume(params, 0.f)
|
|
{
|
|
}
|
|
|
|
void update(const LLMeshSkinInfo* skin, LLVOAvatar* avatar, const LLVolume* src_volume);
|
|
};
|
|
#endif //MESH_ENABLED
|
|
|
|
// Base class for implementations of the volume - Primitive, Flexible Object, etc.
|
|
class LLVolumeInterface
|
|
{
|
|
public:
|
|
virtual ~LLVolumeInterface() { }
|
|
virtual LLVolumeInterfaceType getInterfaceType() const = 0;
|
|
virtual BOOL doIdleUpdate(LLAgent &agent, LLWorld &world, const F64 &time) = 0;
|
|
virtual BOOL doUpdateGeometry(LLDrawable *drawable) = 0;
|
|
virtual LLVector3 getPivotPosition() const = 0;
|
|
virtual void onSetVolume(const LLVolumeParams &volume_params, const S32 detail) = 0;
|
|
virtual void onSetScale(const LLVector3 &scale, BOOL damped) = 0;
|
|
virtual void onParameterChanged(U16 param_type, LLNetworkData *data, BOOL in_use, bool local_origin) = 0;
|
|
virtual void onShift(const LLVector4a &shift_vector) = 0;
|
|
virtual bool isVolumeUnique() const = 0; // Do we need a unique LLVolume instance?
|
|
virtual bool isVolumeGlobal() const = 0; // Are we in global space?
|
|
virtual bool isActive() const = 0; // Is this object currently active?
|
|
virtual const LLMatrix4& getWorldMatrix(LLXformMatrix* xform) const = 0;
|
|
virtual void updateRelativeXform() = 0;
|
|
virtual U32 getID() const = 0;
|
|
virtual void preRebuild() = 0;
|
|
};
|
|
|
|
// Class which embodies all Volume objects (with pcode LL_PCODE_VOLUME)
|
|
class LLVOVolume : public LLViewerObject
|
|
{
|
|
LOG_CLASS(LLVOVolume);
|
|
protected:
|
|
virtual ~LLVOVolume();
|
|
|
|
public:
|
|
static void initClass();
|
|
static void cleanupClass();
|
|
static void preUpdateGeom();
|
|
|
|
enum
|
|
{
|
|
VERTEX_DATA_MASK = (1 << LLVertexBuffer::TYPE_VERTEX) |
|
|
(1 << LLVertexBuffer::TYPE_NORMAL) |
|
|
(1 << LLVertexBuffer::TYPE_TEXCOORD0) |
|
|
(1 << LLVertexBuffer::TYPE_TEXCOORD1) |
|
|
(1 << LLVertexBuffer::TYPE_COLOR)
|
|
};
|
|
|
|
public:
|
|
LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp);
|
|
/*virtual*/ void markDead(); // Override (and call through to parent) to clean up media references
|
|
|
|
/*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
|
|
|
|
void deleteFaces();
|
|
|
|
void animateTextures();
|
|
/*virtual*/ BOOL idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
|
|
|
|
BOOL isVisible() const ;
|
|
/*virtual*/ BOOL isActive() const;
|
|
/*virtual*/ BOOL isAttachment() const;
|
|
/*virtual*/ BOOL isRootEdit() const; // overridden for sake of attachments treating themselves as a root object
|
|
/*virtual*/ BOOL isHUDAttachment() const;
|
|
|
|
void generateSilhouette(LLSelectNode* nodep, const LLVector3& view_point);
|
|
/*virtual*/ BOOL setParent(LLViewerObject* parent);
|
|
S32 getLOD() const { return mLOD; }
|
|
const LLVector3 getPivotPositionAgent() const;
|
|
const LLMatrix4& getRelativeXform() const { return mRelativeXform; }
|
|
const LLMatrix3& getRelativeXformInvTrans() const { return mRelativeXformInvTrans; }
|
|
/*virtual*/ const LLMatrix4 getRenderMatrix() const;
|
|
typedef std::map<LLUUID, S32> texture_cost_t;
|
|
U32 getRenderCost(texture_cost_t &textures) const;
|
|
#if MESH_ENABLED
|
|
/*virtual*/ F32 getStreamingCost(S32* bytes = NULL, S32* visible_bytes = NULL, F32* unscaled_value = NULL) const;
|
|
#endif //MESH_ENABLED
|
|
/*virtual*/ U32 getTriangleCount() const;
|
|
/*virtual*/ U32 getHighLODTriangleCount();
|
|
/*virtual*/ BOOL lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
|
|
S32 face = -1, // which face to check, -1 = ALL_SIDES
|
|
BOOL pick_transparent = FALSE,
|
|
S32* face_hit = NULL, // which face was hit
|
|
LLVector3* intersection = NULL, // return the intersection point
|
|
LLVector2* tex_coord = NULL, // return the texture coordinates of the intersection point
|
|
LLVector3* normal = NULL, // return the surface normal at the intersection point
|
|
LLVector3* bi_normal = NULL // return the surface bi-normal at the intersection point
|
|
);
|
|
|
|
LLVector3 agentPositionToVolume(const LLVector3& pos) const;
|
|
LLVector3 agentDirectionToVolume(const LLVector3& dir) const;
|
|
LLVector3 volumePositionToAgent(const LLVector3& dir) const;
|
|
LLVector3 volumeDirectionToAgent(const LLVector3& dir) const;
|
|
|
|
|
|
BOOL getVolumeChanged() const { return mVolumeChanged; }
|
|
|
|
/*virtual*/ F32 getRadius() const { return mVObjRadius; };
|
|
const LLMatrix4& getWorldMatrix(LLXformMatrix* xform) const;
|
|
|
|
void markForUpdate(BOOL priority) { LLViewerObject::markForUpdate(priority); mVolumeChanged = TRUE; }
|
|
|
|
/*virtual*/ void onShift(const LLVector4a &shift_vector); // Called when the drawable shifts
|
|
|
|
/*virtual*/ void parameterChanged(U16 param_type, bool local_origin);
|
|
/*virtual*/ void parameterChanged(U16 param_type, LLNetworkData* data, BOOL in_use, bool local_origin);
|
|
|
|
/*virtual*/ U32 processUpdateMessage(LLMessageSystem *mesgsys,
|
|
void **user_data,
|
|
U32 block_num, const EObjectUpdateType update_type,
|
|
LLDataPacker *dp);
|
|
|
|
/*virtual*/ void setSelected(BOOL sel);
|
|
/*virtual*/ BOOL setDrawableParent(LLDrawable* parentp);
|
|
|
|
/*virtual*/ void setScale(const LLVector3 &scale, BOOL damped);
|
|
|
|
/*virtual*/ void setTEImage(const U8 te, LLViewerTexture *imagep);
|
|
/*virtual*/ S32 setTETexture(const U8 te, const LLUUID &uuid);
|
|
/*virtual*/ S32 setTEColor(const U8 te, const LLColor3 &color);
|
|
/*virtual*/ S32 setTEColor(const U8 te, const LLColor4 &color);
|
|
/*virtual*/ S32 setTEBumpmap(const U8 te, const U8 bump);
|
|
/*virtual*/ S32 setTEShiny(const U8 te, const U8 shiny);
|
|
/*virtual*/ S32 setTEFullbright(const U8 te, const U8 fullbright);
|
|
/*virtual*/ S32 setTEBumpShinyFullbright(const U8 te, const U8 bump);
|
|
/*virtual*/ S32 setTEMediaFlags(const U8 te, const U8 media_flags);
|
|
/*virtual*/ S32 setTEGlow(const U8 te, const F32 glow);
|
|
/*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 setTETexGen(const U8 te, const U8 texgen);
|
|
/*virtual*/ S32 setTEMediaTexGen(const U8 te, const U8 media);
|
|
/*virtual*/ BOOL setMaterial(const U8 material);
|
|
|
|
void setTexture(const S32 face);
|
|
S32 getIndexInTex() const {return mIndexInTex ;}
|
|
/*virtual*/ BOOL setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false);
|
|
void updateSculptTexture();
|
|
void setIndexInTex(S32 index) { mIndexInTex = index ;}
|
|
void sculpt();
|
|
#if MESH_ENABLED
|
|
static void rebuildMeshAssetCallback(LLVFS *vfs,
|
|
const LLUUID& asset_uuid,
|
|
LLAssetType::EType type,
|
|
void* user_data, S32 status, LLExtStat ext_status);
|
|
#endif //MESH_ENABLED
|
|
void updateRelativeXform();
|
|
/*virtual*/ BOOL updateGeometry(LLDrawable *drawable);
|
|
/*virtual*/ void updateFaceSize(S32 idx);
|
|
/*virtual*/ BOOL updateLOD();
|
|
void updateRadius();
|
|
/*virtual*/ void updateTextures();
|
|
void updateTextureVirtualSize(bool forced = false);
|
|
|
|
void updateFaceFlags();
|
|
void regenFaces();
|
|
BOOL genBBoxes(BOOL force_global);
|
|
void preRebuild();
|
|
virtual void updateSpatialExtents(LLVector4a& min, LLVector4a& max);
|
|
virtual F32 getBinRadius();
|
|
|
|
virtual U32 getPartitionType() const;
|
|
|
|
// For Lights
|
|
void setIsLight(BOOL is_light);
|
|
void setLightColor(const LLColor3& color);
|
|
void setLightIntensity(F32 intensity);
|
|
void setLightRadius(F32 radius);
|
|
void setLightFalloff(F32 falloff);
|
|
void setLightCutoff(F32 cutoff);
|
|
void setLightTextureID(LLUUID id);
|
|
void setSpotLightParams(LLVector3 params);
|
|
|
|
BOOL getIsLight() const;
|
|
LLColor3 getLightBaseColor() const; // not scaled by intensity
|
|
LLColor3 getLightColor() const; // scaled by intensity
|
|
LLUUID getLightTextureID() const;
|
|
bool isLightSpotlight() const;
|
|
LLVector3 getSpotLightParams() const;
|
|
void updateSpotLightPriority();
|
|
F32 getSpotLightPriority() const;
|
|
|
|
LLViewerTexture* getLightTexture();
|
|
F32 getLightIntensity() const;
|
|
F32 getLightRadius() const;
|
|
F32 getLightFalloff() const;
|
|
F32 getLightCutoff() const;
|
|
|
|
// Flexible Objects
|
|
U32 getVolumeInterfaceID() const;
|
|
virtual BOOL isFlexible() const;
|
|
virtual BOOL isSculpted() const;
|
|
#if MESH_ENABLED
|
|
virtual BOOL isMesh() const;
|
|
#endif //MESH_ENABLED
|
|
virtual BOOL hasLightTexture() const;
|
|
|
|
BOOL isVolumeGlobal() const;
|
|
BOOL canBeFlexible() const;
|
|
BOOL setIsFlexible(BOOL is_flexible);
|
|
|
|
// tag: vaa emerald local_asset_browser
|
|
void setSculptChanged(BOOL has_changed) { mSculptChanged = has_changed; }
|
|
|
|
#if MESH_ENABLED
|
|
void notifyMeshLoaded();
|
|
|
|
// Returns 'true' iff the media data for this object is in flight
|
|
bool isMediaDataBeingFetched() const;
|
|
|
|
|
|
|
|
//rigged volume update (for raycasting)
|
|
void updateRiggedVolume();
|
|
LLRiggedVolume* getRiggedVolume();
|
|
|
|
//returns true if volume should be treated as a rigged volume
|
|
// - Build tools are open
|
|
// - object is an attachment
|
|
// - object is attached to self
|
|
// - object is rendered as rigged
|
|
bool treatAsRigged();
|
|
|
|
//clear out rigged volume and revert back to non-rigged state for picking/LOD/distance updates
|
|
void clearRiggedVolume();
|
|
#endif //MESH_ENABLED
|
|
|
|
protected:
|
|
S32 computeLODDetail(F32 distance, F32 radius);
|
|
BOOL calcLOD();
|
|
LLFace* addFace(S32 face_index);
|
|
void updateTEData();
|
|
|
|
// stats tracking for render complexity
|
|
static S32 mRenderComplexity_last;
|
|
static S32 mRenderComplexity_current;
|
|
public:
|
|
|
|
static S32 getRenderComplexityMax() {return mRenderComplexity_last;}
|
|
static void updateRenderComplexity();
|
|
LLViewerTextureAnim *mTextureAnimp;
|
|
U8 mTexAnimMode;
|
|
private:
|
|
friend class LLDrawable;
|
|
|
|
BOOL mFaceMappingChanged;
|
|
LLFrameTimer mTextureUpdateTimer;
|
|
S32 mLOD;
|
|
BOOL mLODChanged;
|
|
BOOL mSculptChanged;
|
|
F32 mSpotLightPriority;
|
|
LLMatrix4 mRelativeXform;
|
|
LLMatrix3 mRelativeXformInvTrans;
|
|
BOOL mVolumeChanged;
|
|
F32 mVObjRadius;
|
|
LLVolumeInterface *mVolumeImpl;
|
|
LLPointer<LLViewerFetchedTexture> mSculptTexture;
|
|
LLPointer<LLViewerFetchedTexture> mLightTexture;
|
|
S32 mIndexInTex;
|
|
#if MESH_ENABLED
|
|
LLPointer<LLRiggedVolume> mRiggedVolume;
|
|
#endif //MESH_ENABLED
|
|
// statics
|
|
public:
|
|
static F32 sLODSlopDistanceFactor;// Changing this to zero, effectively disables the LOD transition slop
|
|
static F32 sLODFactor; // LOD scale factor
|
|
static F32 sDistanceFactor; // LOD distance factor
|
|
|
|
protected:
|
|
static S32 sNumLODChanges;
|
|
|
|
friend class LLVolumeImplFlexible;
|
|
};
|
|
|
|
#endif // LL_LLVOVOLUME_H
|