Print done when done.

1 files changed, 250 insertions, 0 deletions

diff --git a/indra/newview/llface.h b/indra/newview/llface.h
new file mode 100644
index 0000000000..0d017d6efe
--- /dev/null
+++ b/indra/newview/llface.h
@@ -0,0 +1,250 @@
+/** 
+ * @file llface.h
+ * @brief LLFace class definition
+ *
+ * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LLFACE_H
+#define LL_LLFACE_H
+
+#include "llstrider.h"
+
+#include "v2math.h"
+#include "v3math.h"
+#include "v4math.h"
+#include "m4math.h"
+#include "v4coloru.h"
+#include "llquaternion.h"
+#include "xform.h"
+#include "lldarrayptr.h"
+#include "llpagemem.h"
+#include "llstat.h"
+#include "lldrawable.h"
+
+#define ENABLE_FACE_LINKING 1 // Causes problems with snapshot rendering
+
+class LLDrawPool;
+class LLVolume;
+class LLViewerImage;
+class LLTextureEntry;
+class LLVertexProgram;
+class LLViewerImage;
+
+class LLFace
+{
+public:
+
+	enum EMasks
+	{
+		SHARED_GEOM	 = 0x0001,
+		LIGHT		 = 0x0002,
+		REBUILD		 = 0x0004,	
+		GLOBAL		 = 0x0008,
+		VISIBLE		 = 0x0010,
+		BACKLIST	 = 0x0020,
+		INTERP		 = 0x0040,
+		FULLBRIGHT	 = 0x0080,
+		HUD_RENDER	 = 0x0100,
+		USE_FACE_COLOR	 = 0x0200,
+
+		POINT_SPRITE = 0x10000,
+		BOARD_SPRITE = 0x20000,
+		FIXED_SPRITE = 0x40000,
+		DEPTH_SPRITE = 0x80000
+	};
+
+	enum EDirty
+	{
+		DIRTY = -2
+	};
+
+	static void initClass();
+
+public:
+	LLFace(LLDrawable* drawablep, LLViewerObject* objp)   { init(drawablep, objp); }
+	~LLFace()  { destroy(); }
+
+	const LLMatrix4& getWorldMatrix()	const	{ return mVObjp->getWorldMatrix(mXform); }
+	const LLMatrix4& getRenderMatrix() const;
+	const U32		getIndicesCount()	const	{ return mIndicesCount; };
+	const S32		getIndicesStart()	const	{ return mIndicesIndex; };
+	const S32		getGeomCount()		const	{ return mGeomCount; }		// vertex count for this face
+	const S32		getGeomIndex()		const	{ return mGeomIndex; }		// index into draw pool
+	const U32		getGeomStart()		const	{ return mGeomIndex; }		// index into draw pool
+	LLViewerImage*	getTexture()		const	{ return mTexture; }
+	LLXformMatrix*	getXform()			const	{ return mXform; }
+	BOOL			hasGeometry()		const	{ return mGeomCount > 0; }
+	LLVector3		getPositionAgent()	const;
+	void			setPrimType(U32 primType)	{ mPrimType = primType; }
+	const U32		getPrimType()		const	{ return mPrimType; }
+
+	U32				getState()			const	{ return mState; }
+	void			setState(U32 state)			{ mState |= state; }
+	void			clearState(U32 state)		{ mState &= ~state; }
+	BOOL			isState(U32 state)	const	{ return ((mState & state) != 0); }
+
+	void			bindTexture(S32 stage = 0)		const	{ LLViewerImage::bindTexture(mTexture, stage); }
+
+	void			enableLights() const;
+	void			renderSetColor() const;
+	S32				renderElements(const U32 *index_array) const;
+	S32				renderIndexed (const U32 *index_array) const;
+	S32				pushVertices(const U32* index_array) const;
+	
+	void			setWorldMatrix(const LLMatrix4& mat);
+	const LLTextureEntry* getTextureEntry()	const { return mVObjp->getTE(mTEOffset); }
+
+	LLDrawPool*		getPool()			const	{ return mDrawPoolp; }
+	S32				getStride()			const	{ return mDrawPoolp->getStride(); }
+	const U32*		getRawIndices()		const	{ return &mDrawPoolp->mIndices[mIndicesIndex]; }
+	LLDrawable*		getDrawable()		const	{ return mDrawablep; }
+	LLViewerObject*	getViewerObject()	const	{ return mVObjp; }
+
+	void			clearDirty() { mGeneration = mDrawPoolp->mGeneration; };
+
+	S32				backup();
+	void			restore();
+
+	void			setViewerObject(LLViewerObject* object);
+	void			setPool(LLDrawPool *pool, LLViewerImage *texturep);
+	void			setDrawable(LLDrawable *drawable);
+	void			setTEOffset(const S32 te_offset);
+	S32				getTEOffset() { return mTEOffset; }
+
+	void			setFaceColor(const LLColor4& color); // override material color
+	void			unsetFaceColor(); // switch back to material color
+	const LLColor4&	getFaceColor() const { return mFaceColor; } 
+	const LLColor4& getRenderColor() const;
+	
+	void unReserve();		// Set Removed from pool
+	
+	BOOL reserveIfNeeded(); // Reserves data if dirty.
+	
+	// For avatar
+	S32				 getGeometryAvatar(
+									LLStrider<LLVector3> &vertices,
+									LLStrider<LLVector3> &normals,
+									LLStrider<LLVector3> &binormals,
+								    LLStrider<LLVector2> &texCoords,
+									LLStrider<F32>		 &vertex_weights,
+									LLStrider<LLVector4> &clothing_weights);
+
+	// For terrain
+	S32				getGeometryTerrain(LLStrider<LLVector3> &vertices,
+									   LLStrider<LLVector3> &normals,
+									   LLStrider<LLColor4U> &colors,
+									   LLStrider<LLVector2> &texCoords0,
+									   LLStrider<LLVector2> &texCoords1,
+									   U32* &indices);
+
+	// For volumes, etc.
+	S32				getGeometry(LLStrider<LLVector3> &vertices,  
+								LLStrider<LLVector3> &normals,
+								LLStrider<LLVector2> &texCoords, 
+								U32*  &indices);
+
+	S32				getGeometryColors(LLStrider<LLVector3> &vertices,  
+									  LLStrider<LLVector3> &normals,
+									  LLStrider<LLVector2> &texCoords, 
+									  LLStrider<LLColor4U> &colors, 
+									  U32*  &indices);
+	
+	S32				getGeometryMultiTexture(LLStrider<LLVector3> &vertices,  
+											LLStrider<LLVector3> &normals,
+											LLStrider<LLVector3> &binormals,
+											LLStrider<LLVector2> &texCoords0, 
+											LLStrider<LLVector2> &texCoords1, 
+											U32*  &indices);
+
+
+	S32			getVertices	  (LLStrider<LLVector3> &vertices);
+	S32			getColors	  (LLStrider<LLColor4U> &colors);
+	S32			getIndices	  (U32*	 &indices);
+
+	void		setSize(const S32 numVertices, const S32 num_indices = 0);
+	BOOL		getDirty() const { return (mGeneration != mDrawPoolp->mGeneration); }
+
+	BOOL		genVolumeTriangles(const LLVolume &volume, S32 f,
+								   const LLMatrix4& mat, const LLMatrix3& inv_trans_mat, BOOL global_volume = FALSE);
+	BOOL		genVolumeTriangles(const LLVolume &volume, S32 fstart, S32 fend,
+								   const LLMatrix4& mat, const LLMatrix3& inv_trans_mat, BOOL global_volume = FALSE);
+	BOOL 		genLighting(const LLVolume* volume, const LLDrawable* drawablep, S32 fstart, S32 fend, 
+							const LLMatrix4& mat_vert, const LLMatrix3& mat_normal, BOOL do_lighting);
+
+	BOOL 		genShadows(const LLVolume* volume, const LLDrawable* drawablep, S32 fstart, S32 fend, 
+							const LLMatrix4& mat_vert, const LLMatrix3& mat_normal, BOOL use_shadow_factor);
+
+	void		init(LLDrawable* drawablep, LLViewerObject* objp);
+	void		destroy();
+	void		update();
+
+	void		updateCenterAgent(); // Update center when xform has changed.
+	void renderSelectedUV(const S32 offset = 0, const S32 count = 0);
+
+	void		renderForSelect() const;
+	void		renderSelected(LLImageGL *image, const LLColor4 &color, const S32 offset = 0, const S32 count = 0);
+
+	F32			getKey()					const	{ return mDistance; }
+
+	S32			getGeneration() 			const	{ return mGeneration; }
+	S32			getReferenceIndex() 		const	{ return mReferenceIndex; }
+	void		setReferenceIndex(const S32 index)	{ mReferenceIndex = index; }
+
+	BOOL		verify(const U32* indices_array = NULL) const;
+	void		printDebugInfo() const;
+
+	void		link(LLFace* facep);
+	
+protected:
+	S32			allocBackupMem();	// Allocate backup memory based on the draw pool information.
+	void		setDirty();
+
+public:
+	LLVector3		mCenterLocal;
+	LLVector3		mCenterAgent;
+	LLVector3		mExtents[2];
+	LLVector2		mTexExtents[2];
+	F32				mDistance;
+	F32				mAlphaFade;
+	LLFace*			mNextFace;
+	BOOL			mSkipRender;
+	
+protected:
+	S32			mGeneration;
+	U32			mState;
+	LLDrawPool*	mDrawPoolp;
+	S32			mGeomIndex;			// index into draw pool
+	LLColor4	mFaceColor;			// overrides material color if state |= USE_FACE_COLOR
+	
+	U32			mPrimType;
+	S32			mGeomCount;			// vertex count for this face
+	U32			mIndicesCount;
+	S32			mIndicesIndex;		// index into draw pool for indices (yeah, I know!)
+	LLXformMatrix* mXform;
+	LLPointer<LLViewerImage> mTexture;
+
+	U8				*mBackupMem;
+
+	LLPointer<LLDrawable> mDrawablep;
+	LLPointer<LLViewerObject> mVObjp;
+	S32			mTEOffset;
+
+	S32			mReferenceIndex;
+	
+protected:
+	static BOOL	sSafeRenderSelect;
+	
+public:
+	struct CompareDistanceGreater
+	{
+		bool operator()(const LLFace* const& lhs, const LLFace* const& rhs)
+		{
+			return lhs->mDistance > rhs->mDistance; // farthest = first
+		}
+	};
+	
+};
+
+#endif // LL_LLFACE_H