path: root/indra/newview/lldrawable.h

/** 
 * @file lldrawable.h
 * @brief LLDrawable class definition
 *
 * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
 * $License$
 */

#ifndef LL_DRAWABLE_H
#define LL_DRAWABLE_H

#include <vector>
#include <map>

#include "v2math.h"
#include "v3math.h"
#include "v4math.h"
#include "m4math.h"
#include "v4coloru.h"
#include "llquaternion.h"
#include "xform.h"
#include "llmemtype.h"
#include "llprimitive.h"
#include "lldarray.h"
#include "llstat.h"
#include "llviewerobject.h"
#include "llrect.h"

class LLDrawPool;
class LLDrawable;
class LLFace;
class LLSpatialGroup;
class LLSpatialBridge;
class LLSpatialPartition;
class LLVOVolume;
class LLViewerImage;

extern F32 gFrameTimeSeconds;

// Can have multiple silhouettes for each object
const U32 SILHOUETTE_HIGHLIGHT = 0;


// All data for new renderer goes into this class.
class LLDrawable : public LLRefCount
{
public:
	static void initClass();

	LLDrawable()				{ init(); }
	MEM_TYPE_NEW(LLMemType::MTYPE_DRAWABLE);
	
	void markDead();			// Mark this drawable as dead
	BOOL isDead() const			{ return isState(DEAD); }
	BOOL isNew() const			{ return !isState(BUILT); }

	BOOL isLight() const;

	BOOL isVisible() const;		
	virtual void setVisible(LLCamera& camera_in, std::vector<LLDrawable*>* results = NULL, BOOL for_select = FALSE);


	const LLViewerRegion* getRegion()               const { return mVObjp->getRegion(); }
	const LLTextureEntry* getTextureEntry(U8 which) const { return mVObjp->getTE(which); }
	LLViewerObject* getVObj()							  { return mVObjp; }
	const LLViewerObject* getVObj() const				  { return mVObjp; }
	LLVOVolume*	getVOVolume() const; // cast mVObjp tp LLVOVolume if OK

	const LLMatrix4&      getWorldMatrix() const		{ return mXform.getWorldMatrix(); }
	const LLMatrix4&	  getRenderMatrix() const		{ return isRoot() ? getWorldMatrix() : getParent()->getWorldMatrix(); }
	const void			  setPosition(LLVector3 v) const { }
	const LLVector3&	  getPosition() const			{ return mXform.getPosition(); }
	const LLVector3&      getWorldPosition() const		{ return mXform.getPositionW(); }
	const LLVector3		  getPositionAgent() const;
	const LLVector3d&	  getPositionGroup() const		{ return mPositionGroup; }
	const LLVector3&	  getScale() const				{ return mCurrentScale; }
	const LLQuaternion&   getWorldRotation() const		{ return mXform.getWorldRotation(); }
	const LLQuaternion&   getRotation() const			{ return mXform.getRotation(); }
	const F32             getIntensity() const			{ return llmin(mXform.getScale().mV[0], 4.f); }
	const S32			  getLOD() const				{ return mVObjp ? mVObjp->getLOD() : 1; }
	const F64			  getBinRadius() const			{ return mBinRadius; }
	void  getMinMax(LLVector3& min,LLVector3& max) const { mXform.getMinMax(min,max); }
	LLXformMatrix*		getXform() { return &mXform; }

	const U32 			getState()           const { return mState; }
	const BOOL          isState   (U32 bits) const { return ((mState & bits) != 0); }
	void                setState  (U32 bits)       { mState |= bits; }
	void                clearState(U32 bits)       { mState &= ~bits; }

	BOOL				isAvatar()	const			{ return mVObjp.notNull() && mVObjp->isAvatar(); }
	BOOL				isRoot() const				{ return !mParent || mParent->isAvatar(); }
	BOOL				isSpatialRoot() const		{ return !mParent || mParent->isAvatar(); }
	virtual BOOL		isSpatialBridge() const		{ return FALSE; }
	virtual LLSpatialPartition* asPartition()		{ return NULL; }
	LLDrawable*			getParent() const			{ return mParent; }
	LLDrawable*			getChild(U32 index)			{ return mVObjp->mChildList[index]->mDrawable; }
	U32					getChildCount()				{ return mVObjp ? mVObjp->mChildList.size() : 0; }
	
	// must set parent through LLViewerObject::		()
	//BOOL                setParent(LLDrawable *parent);
	
	inline LLFace*      getFace(const S32 i) const;
	inline S32			getNumFaces()      	 const;

	//void                removeFace(const S32 i); // SJB: Avoid using this, it's slow
	LLFace*				addFace(LLFacePool *poolp, LLViewerImage *texturep);
	LLFace*				addFace(const LLTextureEntry *te, LLViewerImage *texturep);
	void				deleteFaces(S32 offset, S32 count);
	void                setNumFaces(const S32 numFaces, LLFacePool *poolp, LLViewerImage *texturep);
	void                setNumFacesFast(const S32 numFaces, LLFacePool *poolp, LLViewerImage *texturep);
	void				mergeFaces(LLDrawable* src);

	void init();
	void destroy();

	void update();
	F32 updateXform(BOOL undamped);

	virtual void makeActive();
	virtual void makeStatic();

	BOOL isActive()	const							{ return isState(ACTIVE); }
	BOOL isStatic() const							{ return !isActive(); }
	BOOL isAnimating() const;

	virtual BOOL updateMove();
	virtual void movePartition();
	
	void updateTexture();
	void updateMaterial();
	virtual void updateDistance(LLCamera& camera);
	BOOL updateGeometry(BOOL priority);
	BOOL updateLighting(BOOL priority);
	void updateFaceSize(S32 idx);
	void updateLightSet();
	
	F32  getSunShadowFactor() const				{ return mSunShadowFactor; }
	void setSunShadowFactor(F32 factor)			{ mSunShadowFactor = factor; }
	void applyLightsAsPoint(LLColor4& result);
	void updateSpecialHoverCursor(BOOL enabled);

	virtual void shiftPos(const LLVector3 &shift_vector);

	S32 getGeneration() const					{ return mGeneration; }

	BOOL getLit() const							{ return isState(UNLIT) ? FALSE : TRUE; }
	void setLit(BOOL lit)						{ lit ? clearState(UNLIT) : setState(UNLIT); }

	void clearLightSet();
	virtual void cleanupReferences();

	void setRadius(const F32 radius);
	F32 getRadius() const						{ return mRadius; }
	F32 getVisibilityRadius() const;

	void updateUVMinMax();	// Updates the cache of sun space bounding box.

	const LLVector3& getBounds(LLVector3& min, LLVector3& max) const;
	virtual void updateSpatialExtents();
	virtual void updateBinRadius();
	const LLVector3* getSpatialExtents() const;
	void setSpatialExtents(LLVector3 min, LLVector3 max);
	void setPositionGroup(const LLVector3d& pos);
	void setPositionGroup(const LLVector3& pos) { setPositionGroup(LLVector3d(pos)); }

	void setRenderType(S32 type) 				{ mRenderType = type; }
	BOOL isRenderType(S32 type) 				{ return mRenderType == type; }
	S32  getRenderType()						{ return mRenderType; }
	
	// Debugging methods
	S32 findReferences(LLDrawable *drawablep); // Not const because of @#$! iterators...

	void setSpatialGroup(LLSpatialGroup *groupp, const S32 offset);
	LLSpatialGroup *getSpatialGroup() const			{ return mSpatialGroupp; }
	LLSpatialPartition* getSpatialPartition();
	
	// Statics
	static void incrementVisible();
	static void cleanupDeadDrawables();

protected:
	virtual ~LLDrawable() { destroy(); }
	void moveUpdatePipeline(BOOL moved);
	void updatePartition();
	BOOL updateMoveDamped();
	BOOL updateMoveUndamped();
	
public:
	friend class LLPipeline;
	friend class LLDrawPool;
	friend class LLSpatialBridge;
	
	typedef std::set<LLPointer<LLDrawable> > drawable_set_t;
	typedef std::vector<LLPointer<LLDrawable> > drawable_vector_t;
	typedef std::list<LLPointer<LLDrawable> > drawable_list_t;
	typedef std::queue<LLPointer<LLDrawable> > drawable_queue_t;
	
	struct CompareDistanceGreater
	{
		bool operator()(const LLDrawable* const& lhs, const LLDrawable* const& rhs)
		{
			return lhs->mDistanceWRTCamera < rhs->mDistanceWRTCamera; // farthest = last
		}
	};

	struct CompareDistanceGreaterVisibleFirst
	{
		bool operator()(const LLDrawable* const& lhs, const LLDrawable* const& rhs)
		{
			if (lhs->isVisible() && !rhs->isVisible())
			{
				return TRUE; //visible things come first
			}
			else if (!lhs->isVisible() && rhs->isVisible())
			{
				return FALSE; //rhs is visible, comes first
			}
			
			return lhs->mDistanceWRTCamera < rhs->mDistanceWRTCamera; // farthest = last
		}
	};
	
	typedef enum e_drawable_flags
	{
// 		TEXTURE			= 0x00000001,
 		IN_REBUILD_Q1	= 0x00000002,
 		IN_REBUILD_Q2	= 0x00000004,
 		IN_LIGHT_Q		= 0x00000008,
		EARLY_MOVE		= 0x00000010,
		MOVE_UNDAMPED	= 0x00000020,
		ON_MOVE_LIST	= 0x00000040,
		USE_BACKLIGHT	= 0x00000080,
		UV				= 0x00000100,
		UNLIT			= 0x00000200,
		LIGHT			= 0x00000400,
		LIGHTING_BUILT	= 0x00000800,
		REBUILD_VOLUME  = 0x00001000,	//volume changed LOD or parameters, or vertex buffer changed
		REBUILD_TCOORD	= 0x00002000,	//texture coordinates changed
		REBUILD_COLOR	= 0x00004000,	//color changed
		REBUILD_LIGHTING= 0x00008000,	//lighting information changed
		REBUILD_POSITION= 0x00010000,	//vertex positions/normals changed
		REBUILD_GEOMETRY= REBUILD_POSITION|REBUILD_TCOORD|REBUILD_COLOR,
		REBUILD_MATERIAL= REBUILD_TCOORD|REBUILD_COLOR,
		REBUILD_ALL		= REBUILD_GEOMETRY|REBUILD_LIGHTING|REBUILD_VOLUME,
		ON_SHIFT_LIST	= 0x00100000,
// 		NO_INTERP_COLOR = 0x00200000,
		BLOCKER			= 0x00400000,
		ACTIVE			= 0x00800000,
		DEAD			= 0x01000000,
		INVISIBLE		= 0x02000000, // stay invisible until flag is cleared
 		NEARBY_LIGHT	= 0x04000000, // In gPipeline.mNearbyLightSet
		BUILT			= 0x08000000,
		FORCE_INVISIBLE = 0x10000000, // stay invis until CLEAR_INVISIBLE is set (set of orphaned)
		CLEAR_INVISIBLE = 0x20000000, // clear FORCE_INVISIBLE next draw frame
		REBUILD_SHADOW =  0x40000000
	} EDrawableFlags;

	LLXformMatrix       mXform;

	// vis data
	LLPointer<LLDrawable> mParent;

	F32				mDistanceWRTCamera;

	LLRectf			mUVRect;
	F32				mUVZ;

	drawable_set_t	mLightSet;
	drawable_set_t	mBlockSet;

	LLVector3		mSavePos;
	S32				mQuietCount;

	static S32 getCurrentFrame() { return sCurVisible; }
	
	void setSpatialBridge(LLSpatialBridge* bridge) { mSpatialBridge = (LLDrawable*) bridge; }
	LLSpatialBridge* getSpatialBridge() { return (LLSpatialBridge*) (LLDrawable*) mSpatialBridge; }
	
	static F32 sCurPixelAngle; //current pixels per radian

protected:
	typedef std::vector<LLFace*> face_list_t;
	
	U32				mState;
	S32				mRenderType;
	LLPointer<LLViewerObject> mVObjp;
	face_list_t     mFaces;
	LLSpatialGroup* mSpatialGroupp;
	LLPointer<LLDrawable> mSpatialBridge;
	S32				mSpatialGroupOffset;
	
	mutable U32		mVisible;
	F32				mRadius;
	LLVector3		mExtents[2];
	LLVector3d		mPositionGroup;
	F64				mBinRadius;
	S32				mGeneration;

	F32				mSunShadowFactor;
	
	LLVector3		mCurrentScale;
	
	static U32 sCurVisible; // Counter for what value of mVisible means currently visible

	static U32 sNumZombieDrawables;
	static LLDynamicArrayPtr<LLPointer<LLDrawable> > sDeadList;
};


inline LLFace* LLDrawable::getFace(const S32 i) const
{
	llassert((U32)i < mFaces.size());
	llassert(mFaces[i]);
	return mFaces[i];
}


inline S32 LLDrawable::getNumFaces()const
{
	return (S32)mFaces.size();
}

#endif