merge changes for 3.7.7-release

1 files changed, 165 insertions, 22 deletions

diff --git a/indra/newview/llvocache.h b/indra/newview/llvocache.h
index 14e3b4c793..082f5f0b1d 100755
--- a/indra/newview/llvocache.h
+++ b/indra/newview/llvocache.h
@@ -29,51 +29,199 @@
 
 #include "lluuid.h"
 #include "lldatapacker.h"
-#include "lldlinked.h"
 #include "lldir.h"
-
+#include "llvieweroctree.h"
+#include "llapr.h"
 
 //---------------------------------------------------------------------------
 // Cache entries
-class LLVOCacheEntry;
+class LLCamera;
 
-class LLVOCacheEntry
+class LLVOCacheEntry 
+:	public LLViewerOctreeEntryData,
+	public LLTrace::MemTrackable<LLVOCacheEntry, 16>
 {
 public:
+	enum 
+	{
+		//low 16-bit state
+		INACTIVE = 0x00000000,     //not visible
+		IN_QUEUE = 0x00000001,     //in visible queue, object to be created
+		WAITING  = 0x00000002,     //object creation request sent
+		ACTIVE   = 0x00000004,      //object created, and in rendering pipeline.
+
+		//high 16-bit state
+		IN_VO_TREE = 0x00010000,    //the entry is in the object cache tree.
+
+		LOW_BITS  = 0x0000ffff,
+		HIGH_BITS = 0xffff0000
+	};
+
+	struct CompareVOCacheEntry
+	{
+		bool operator()(const LLVOCacheEntry* const& lhs, const LLVOCacheEntry* const& rhs)
+		{
+			F32 lpa = lhs->getSceneContribution();
+			F32 rpa = rhs->getSceneContribution();
+
+			//larger pixel area first
+			if(lpa > rpa)		
+			{
+				return true;
+			}
+			else if(lpa < rpa)
+			{
+				return false;
+			}
+			else
+			{
+				return lhs < rhs;
+			}			
+		}
+	};
+protected:
+	~LLVOCacheEntry();
+public:
 	LLVOCacheEntry(U32 local_id, U32 crc, LLDataPackerBinaryBuffer &dp);
 	LLVOCacheEntry(LLAPRFile* apr_file);
-	LLVOCacheEntry();
-	~LLVOCacheEntry();
+	LLVOCacheEntry();	
+
+	void updateEntry(U32 crc, LLDataPackerBinaryBuffer &dp);
+
+	void clearState(U32 state) {mState &= ~state;}
+	bool hasState(U32 state)   {return mState & state;}	
+	void setState(U32 state);	
+	bool isState(U32 state)    {return (mState & LOW_BITS) == state;}	
+	U32  getState() const      {return mState & LOW_BITS;}
+	
+	bool isAnyVisible(const LLVector4a& camera_origin, const LLVector4a& local_camera_origin, F32 dist_threshold);
 
 	U32 getLocalID() const			{ return mLocalID; }
 	U32 getCRC() const				{ return mCRC; }
 	S32 getHitCount() const			{ return mHitCount; }
 	S32 getCRCChangeCount() const	{ return mCRCChangeCount; }
+	
+	void calcSceneContribution(const LLVector4a& camera_origin, bool needs_update, U32 last_update, F32 dist_threshold);
+	void setSceneContribution(F32 scene_contrib) {mSceneContrib = scene_contrib;}
+	F32 getSceneContribution() const             { return mSceneContrib;}
 
 	void dump() const;
 	BOOL writeToFile(LLAPRFile* apr_file) const;
-	void assignCRC(U32 crc, LLDataPackerBinaryBuffer &dp);
-	LLDataPackerBinaryBuffer *getDP(U32 crc);
+	LLDataPackerBinaryBuffer *getDP();
 	void recordHit();
 	void recordDupe() { mDupeCount++; }
+	
+	/*virtual*/ void setOctreeEntry(LLViewerOctreeEntry* entry);
+
+	void setParentID(U32 id);
+	U32  getParentID() const {return mParentID;}
+	bool isChild() const {return mParentID > 0;}
+
+	void addChild(LLVOCacheEntry* entry);
+	void removeChild(LLVOCacheEntry* entry);
+	void removeAllChildren();
+	LLVOCacheEntry* getChild(); //remove the first child, and return it.
+	S32  getNumOfChildren() const  {return mChildrenList.size();}
+	
+	void setBoundingInfo(const LLVector3& pos, const LLVector3& scale); //called from processing object update message	
+	void updateParentBoundingInfo();
+	void saveBoundingSphere();
+
+	void setValid(BOOL valid = TRUE) {mValid = valid;}
+	BOOL isValid() const {return mValid;}
+
+	void setUpdateFlags(U32 flags) {mUpdateFlags = flags;}
+	U32  getUpdateFlags() const    {return mUpdateFlags;}
+
+	static void updateDebugSettings();
+	static F32  getSquaredPixelThreshold(bool is_front);
+
+private:
+	void updateParentBoundingInfo(const LLVOCacheEntry* child);	
 
 public:
-	typedef std::map<U32, LLVOCacheEntry*>	vocache_entry_map_t;
+	typedef std::map<U32, LLPointer<LLVOCacheEntry> >	   vocache_entry_map_t;
+	typedef std::set<LLVOCacheEntry*>                      vocache_entry_set_t;
+	typedef std::set<LLVOCacheEntry*, CompareVOCacheEntry> vocache_entry_priority_list_t;	
 
+	S32                         mLastCameraUpdated;
 protected:
 	U32							mLocalID;
+	U32                         mParentID;
 	U32							mCRC;
+	U32                         mUpdateFlags; //receive from sim
 	S32							mHitCount;
 	S32							mDupeCount;
 	S32							mCRCChangeCount;
 	LLDataPackerBinaryBuffer	mDP;
 	U8							*mBuffer;
+
+	F32                         mSceneContrib; //projected scene contributuion of this object.
+	U32                         mState; //high 16 bits reserved for special use.
+	vocache_entry_set_t         mChildrenList; //children entries in a linked set.
+
+	BOOL                        mValid; //if set, this entry is valid, otherwise it is invalid and will be removed.
+
+	LLVector4a                  mBSphereCenter; //bounding sphere center
+	F32                         mBSphereRadius; //bounding sphere radius
+
+public:
+	static U32					sMinFrameRange;
+	static F32					sNearRadius;
+	static F32					sRearFarRadius;
+	static F32					sFrontPixelThreshold;
+	static F32					sRearPixelThreshold;
+};
+
+class LLVOCacheGroup : public LLOcclusionCullingGroup
+{
+public:
+	LLVOCacheGroup(OctreeNode* node, LLViewerOctreePartition* part) : LLOcclusionCullingGroup(node, part){}	
+
+	//virtual
+	void handleChildAddition(const OctreeNode* parent, OctreeNode* child);
+
+protected:
+	virtual ~LLVOCacheGroup();
+};
+
+class LLVOCachePartition : public LLViewerOctreePartition, public LLTrace::MemTrackable<LLVOCachePartition>
+{
+public:
+	LLVOCachePartition(LLViewerRegion* regionp);
+
+	bool addEntry(LLViewerOctreeEntry* entry);
+	void removeEntry(LLViewerOctreeEntry* entry);
+	/*virtual*/ S32 cull(LLCamera &camera, bool do_occlusion);
+	void addOccluders(LLViewerOctreeGroup* gp);
+	void resetOccluders();
+	void processOccluders(LLCamera* camera);
+	void removeOccluder(LLVOCacheGroup* group);
+
+	void setCullHistory(BOOL has_new_object);
+
+	bool isFrontCull() const {return mFrontCull;}
+
+private:
+	void selectBackObjects(LLCamera &camera, F32 projection_area_cutoff, bool use_occlusion); //select objects behind camera.
+
+public:
+	static BOOL sNeedsOcclusionCheck;
+
+private:
+	BOOL  mFrontCull; //the view frustum cull if set, otherwise is back sphere cull.
+	U32   mCullHistory;
+	U32   mCulledTime[LLViewerCamera::NUM_CAMERAS];
+	std::set<LLVOCacheGroup*> mOccludedGroups;
+
+	S32   mBackSlectionEnabled; //enable to select back objects if > 0.
+	U32   mIdleHash;
 };
 
 //
 //Note: LLVOCache is not thread-safe
 //
-class LLVOCache
+class LLVOCache : public LLSingleton<LLVOCache>
 {
 private:
 	struct HeaderEntryInfo
@@ -106,19 +254,20 @@ private:
 	typedef std::set<HeaderEntryInfo*, header_entry_less> header_entry_queue_t;
 	typedef std::map<U64, HeaderEntryInfo*> handle_entry_map_t;
 private:
+    friend class LLSingleton<LLVOCache>;
 	LLVOCache() ;
 
 public:
 	~LLVOCache() ;
 
 	void initCache(ELLPath location, U32 size, U32 cache_version) ;
-	void removeCache(ELLPath location) ;
+	void removeCache(ELLPath location, bool started = false) ;
 
 	void readFromCache(U64 handle, const LLUUID& id, LLVOCacheEntry::vocache_entry_map_t& cache_entry_map) ;
-	void writeToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_entry_map_t& cache_entry_map, BOOL dirty_cache) ;
+	void writeToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_entry_map_t& cache_entry_map, BOOL dirty_cache, bool removal_enabled);
 	void removeEntry(U64 handle) ;
 
-	void setReadOnly(BOOL read_only) {mReadOnly = read_only;} 
+	void setReadOnly(bool read_only) {mReadOnly = read_only;} 
 
 private:
 	void setDirNames(ELLPath location);	
@@ -134,9 +283,9 @@ private:
 	BOOL updateEntry(const HeaderEntryInfo* entry);
 	
 private:
-	BOOL                 mEnabled;
-	BOOL                 mInitialized ;
-	BOOL                 mReadOnly ;
+	bool                 mEnabled;
+	bool                 mInitialized ;
+	bool                 mReadOnly ;
 	HeaderMetaInfo       mMetaInfo;
 	U32                  mCacheSize;
 	U32                  mNumEntries;
@@ -145,12 +294,6 @@ private:
 	LLVolatileAPRPool*   mLocalAPRFilePoolp ; 	
 	header_entry_queue_t mHeaderEntryQueue;
 	handle_entry_map_t   mHandleEntryMap;	
-
-	static LLVOCache* sInstance ;
-public:
-	static LLVOCache* getInstance() ;
-	static BOOL       hasInstance() ;	
-	static void       destroyClass() ;
 };
 
 #endif