Second Life viewer sources 1.19.1.0

1 files changed, 107 insertions, 95 deletions

diff --git a/linden/indra/newview/pipeline.h b/linden/indra/newview/pipeline.h
index 9b0706f..0e3e1c0 100644
--- a/linden/indra/newview/pipeline.h
+++ b/linden/indra/newview/pipeline.h
@@ -32,20 +32,20 @@
 #ifndef LL_PIPELINE_H
 #define LL_PIPELINE_H
 
+#include "llerror.h"
 #include "lldarrayptr.h"
 #include "lldqueueptr.h"
 #include "llstat.h"
-#include "lllinkedqueue.h"
-#include "llskiplist.h"
 #include "lldrawpool.h"
 #include "llspatialpartition.h"
 #include "m4math.h"
 #include "llmemory.h"
 #include "lldrawpool.h"
 #include "llgl.h"
+#include "lldrawable.h"
+#include "llrendertarget.h"
 
 class LLViewerImage;
-class LLDrawable;
 class LLEdge;
 class LLFace;
 class LLViewerObject;
@@ -54,6 +54,8 @@ class LLDisplayPrimitive;
 class LLTextureEntry;
 class LLRenderFunc;
 class LLCubeMap;
+class LLCullResult;
+class LLVOAvatar;
 
 typedef enum e_avatar_skinning_method
 {
@@ -65,6 +67,11 @@ BOOL compute_min_max(LLMatrix4& box, LLVector2& min, LLVector2& max); // Shouldn
 bool LLRayAABB(const LLVector3 &center, const LLVector3 &size, const LLVector3& origin, const LLVector3& dir, LLVector3 &coord, F32 epsilon = 0);
 BOOL LLLineSegmentAABB(const LLVector3& start, const LLVector3& end, const LLVector3& center, const LLVector3& size);
 BOOL setup_hud_matrices(BOOL for_select);
+glh::matrix4f glh_get_current_modelview();
+void glh_set_current_modelview(glh::matrix4f& mat);
+glh::matrix4f glh_get_current_projection();
+void glh_set_current_projection(glh::matrix4f& mat);
+glh::matrix4f gl_ortho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat znear, GLfloat zfar);
 
 class LLPipeline
 {
@@ -75,16 +82,23 @@ public:
         void destroyGL();
         void restoreGL();
         void resetVertexBuffers();
+        void resizeScreenTexture();
         void releaseGLBuffers();
+        void createGLBuffers();
+
         void resetVertexBuffers(LLDrawable* drawable);
         void setUseVBO(BOOL use_vbo);
-        void generateReflectionMap(LLCubeMap* cube_map, LLCamera& camera, GLsizei res);
-        void blurReflectionMap(LLCubeMap* cube_in, LLCubeMap* cube_out, U32 res);
+        void generateImpostor(LLVOAvatar* avatar);
+        void generateReflectionMap(LLCubeMap* cube_map, LLCamera& camera);
+        void blurReflectionMap(LLCubeMap* cube_in, LLCubeMap* cube_out);
         void bindScreenToTexture();
-        void renderBloom(GLuint source, GLuint dest, GLuint buffer, U32 res, LLVector2 tc1, LLVector2 tc2);
+        void renderBloom(BOOL for_snapshot);
+
+        LLCubeMap* findReflectionMap(const LLVector3& location);
 
         void init();
         void cleanup();
+        BOOL isInit() { return mInitialized; };
 
         /// @brief Get a draw pool from pool type (POOL_SIMPLE, POOL_MEDIA) and texture.
         /// @return Draw pool, or NULL if not found.
@@ -107,14 +121,14 @@ public:
 
         // Object related methods
         void        markVisible(LLDrawable *drawablep, LLCamera& camera);
+        void            markOccluder(LLSpatialGroup* group);
         void            doOcclusion(LLCamera& camera);
-        void            markNotCulled(LLSpatialGroup* group, LLCamera &camera, BOOL active = FALSE);
+        void            markNotCulled(LLSpatialGroup* group, LLCamera &camera);
         void        markMoved(LLDrawable *drawablep, BOOL damped_motion = FALSE);
         void        markShift(LLDrawable *drawablep);
         void        markTextured(LLDrawable *drawablep);
         void        markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags flag = LLDrawable::REBUILD_ALL, BOOL priority = FALSE);
-        void        markRelight(LLDrawable *drawablep, const BOOL now = FALSE);
-        
+                
         //get the object between start and end that's closest to start.  Return the point of collision in collision.
         LLViewerObject* pickObject(const LLVector3 &start, const LLVector3 &end, LLVector3 &collision);
 
@@ -136,7 +150,9 @@ public:
         void            setUseVertexShaders(BOOL use_shaders);
         BOOL            getUseVertexShaders() const { return mVertexShadersEnabled; }
         BOOL            canUseVertexShaders();
-        
+        BOOL            canUseWindLightShaders() const;
+        BOOL            canUseWindLightShadersOnObjects() const;
+
         // phases
         void resetFrameStats();
 
@@ -144,26 +160,29 @@ public:
         void updateMoveNormalAsync(LLDrawable* drawablep);
         void updateMovedList(LLDrawable::drawable_vector_t& move_list);
         void updateMove();
-        void updateCull(LLCamera& camera);
+        void updateCull(LLCamera& camera, LLCullResult& result, S32 water_clip = 0);  //if water_clip is 0, ignore water plane, 1, cull to above plane, -1, cull to below plane
         void updateGeom(F32 max_dtime);
 
         //calculate pixel area of given box from vantage point of given camera
         static F32 calcPixelArea(LLVector3 center, LLVector3 size, LLCamera& camera);
 
-        void stateSort(LLCamera& camera);
+        void stateSort(LLCamera& camera, LLCullResult& result);
         void stateSort(LLSpatialGroup* group, LLCamera& camera);
         void stateSort(LLSpatialBridge* bridge, LLCamera& camera);
         void stateSort(LLDrawable* drawablep, LLCamera& camera);
         void postSort(LLCamera& camera);
-        void forAllDrawables(LLSpatialGroup::sg_vector_t& groups, void (*func)(LLDrawable*));
         void forAllVisibleDrawables(void (*func)(LLDrawable*));
 
         void renderObjects(U32 type, U32 mask, BOOL texture = TRUE);
+        void renderGroups(LLRenderPass* pass, U32 type, U32 mask, BOOL texture);
 
-        void renderGeom(LLCamera& camera);
+        void grabReferences(LLCullResult& result);
+
+        void renderGeom(LLCamera& camera, BOOL forceVBOUpdate = FALSE);
+        void processImagery(LLCamera& camera);
+        void generateWaterReflection(LLCamera& camera);
         void renderHighlights();
         void renderDebug();
-        void processOcclusion(LLCamera& camera);
 
         void renderForSelect(std::set<LLViewerObject*>& objects);
         void renderFaceForUVSelect(LLFace* facep);
@@ -172,29 +191,33 @@ public:
         void findReferences(LLDrawable *drawablep);     // Find the lists which have references to this object
         BOOL verify();                                          // Verify that all data in the pipeline is "correct"
 
-        S32  getVisibleCount() const { return mVisibleList.size(); }
         S32  getLightCount() const { return mLights.size(); }
 
         void calcNearbyLights(LLCamera& camera);
         void setupHWLights(LLDrawPool* pool);
         void setupAvatarLights(BOOL for_edit = FALSE);
-        void enableLights(U32 mask, F32 shadow_factor);
-        void enableLightsStatic(F32 shadow_factor);
-        void enableLightsDynamic(F32 shadow_factor);
-        void enableLightsAvatar(F32 shadow_factor);
+        void enableLights(U32 mask);
+        void enableLightsStatic();
+        void enableLightsDynamic();
+        void enableLightsAvatar();
         void enableLightsAvatarEdit(const LLColor4& color);
         void enableLightsFullbright(const LLColor4& color);
         void disableLights();
-        void setAmbient(const LLColor4& ambient);
 
         void shiftObjects(const LLVector3 &offset);
 
         void setLight(LLDrawable *drawablep, BOOL is_light);
         void setActive(LLDrawable *drawablep, BOOL active);
 
+        BOOL hasRenderBatches(const U32 type) const;
+        LLCullResult::drawinfo_list_t::iterator beginRenderMap(U32 type);
+        LLCullResult::drawinfo_list_t::iterator endRenderMap(U32 type);
+        LLCullResult::sg_list_t::iterator beginAlphaGroups();
+        LLCullResult::sg_list_t::iterator endAlphaGroups();
+
+        void addTrianglesDrawn(S32 count);
         BOOL hasRenderType(const U32 type) const                                { return (type && (mRenderTypeMask & (1<<type))) ? TRUE : FALSE; }
         BOOL hasRenderDebugFeatureMask(const U32 mask) const    { return (mRenderDebugFeatureMask & mask) ? TRUE : FALSE; }
-        BOOL hasRenderFeatureMask(const U32 mask) const                 { return (mRenderFeatureMask & mask) ? TRUE : FALSE; }
         BOOL hasRenderDebugMask(const U32 mask) const                   { return (mRenderDebugMask & mask) ? TRUE : FALSE; }
         void setRenderTypeMask(const U32 mask)                                  { mRenderTypeMask = mask; }
         U32  getRenderTypeMask() const                                                  { return mRenderTypeMask; }
@@ -240,13 +263,12 @@ public:
         static BOOL getProcessBeacons(void* data);
 
 private:
-        void initShaders(BOOL force);
         void unloadShaders();
-        BOOL loadShaders();
-        void saveVertexShaderLevel(S32 type, S32 level, S32 max);
         void addToQuickLookup( LLDrawPool* new_poolp );
         void removeFromQuickLookup( LLDrawPool* poolp );
         BOOL updateDrawableGeom(LLDrawable* drawable, BOOL priority);
+        void assertInitializedDoError();
+        bool assertInitialized() { const bool is_init = isInit(); if (!is_init) assertInitializedDoError(); return is_init; };
         
 public:
         enum {GPU_CLASS_MAX = 3 };
@@ -255,17 +277,18 @@ public:
         {
                 // Following are pool types (some are also object types)
                 RENDER_TYPE_SKY                 = LLDrawPool::POOL_SKY,
-                RENDER_TYPE_STARS               = LLDrawPool::POOL_STARS,
+                RENDER_TYPE_WL_SKY              = LLDrawPool::POOL_WL_SKY,
                 RENDER_TYPE_GROUND              = LLDrawPool::POOL_GROUND,      
                 RENDER_TYPE_TERRAIN             = LLDrawPool::POOL_TERRAIN,
                 RENDER_TYPE_SIMPLE              = LLDrawPool::POOL_SIMPLE,
                 RENDER_TYPE_BUMP                = LLDrawPool::POOL_BUMP,
                 RENDER_TYPE_AVATAR              = LLDrawPool::POOL_AVATAR,
                 RENDER_TYPE_TREE                = LLDrawPool::POOL_TREE,
+                RENDER_TYPE_INVISIBLE   = LLDrawPool::POOL_INVISIBLE,
                 RENDER_TYPE_WATER               = LLDrawPool::POOL_WATER,
                 RENDER_TYPE_ALPHA               = LLDrawPool::POOL_ALPHA,
                 RENDER_TYPE_GLOW                = LLDrawPool::POOL_GLOW,
-
+                
                 // Following are object types (only used in drawable mRenderType)
                 RENDER_TYPE_HUD = LLDrawPool::NUM_POOL_TYPES,
                 RENDER_TYPE_VOLUME,
@@ -288,58 +311,30 @@ public:
                 RENDER_DEBUG_FEATURE_FOOT_SHADOWS               = 0x0100,
         };
 
-        enum LLRenderFeatureMask
-        {
-                RENDER_FEATURE_LOCAL_LIGHTING           = 0x02,
-                RENDER_FEATURE_OBJECT_BUMP                      = 0x04,
-                RENDER_FEATURE_AVATAR_BUMP                      = 0x08,
-//              RENDER_FEATURE_SHADOWS                          = 0x10,
-                RENDER_FEATURE_RIPPLE_WATER                     = 0X20
-        };
-
         enum LLRenderDebugMask
         {
-                RENDER_DEBUG_LIGHT_TRACE                = 0x00001,
-                RENDER_DEBUG_COMPOSITION                = 0x00020,
-                RENDER_DEBUG_VERIFY                             = 0x00080,
-                RENDER_DEBUG_SHADOW_MAP                 = 0x00100,
-                RENDER_DEBUG_BBOXES                             = 0x00200,
-                RENDER_DEBUG_OCTREE                             = 0x00400,
-                RENDER_DEBUG_PICKING                    = 0x00800,
-                RENDER_DEBUG_OCCLUSION                  = 0x01000,
-                RENDER_DEBUG_POINTS                             = 0x02000,
-                RENDER_DEBUG_TEXTURE_PRIORITY   = 0x04000,
-                RENDER_DEBUG_TEXTURE_AREA               = 0x08000,
-                RENDER_DEBUG_FACE_AREA                  = 0x10000,
-                RENDER_DEBUG_PARTICLES                  = 0x20000,
-                RENDER_DEBUG_GLOW                               = 0x40000,
-                RENDER_DEBUG_TEXTURE_ANIM               = 0x80000,
+                RENDER_DEBUG_COMPOSITION                = 0x000020,
+                RENDER_DEBUG_VERIFY                             = 0x000080,
+                RENDER_DEBUG_BBOXES                             = 0x000200,
+                RENDER_DEBUG_OCTREE                             = 0x000400,
+                RENDER_DEBUG_PICKING                    = 0x000800,
+                RENDER_DEBUG_OCCLUSION                  = 0x001000,
+                RENDER_DEBUG_POINTS                             = 0x002000,
+                RENDER_DEBUG_TEXTURE_PRIORITY   = 0x004000,
+                RENDER_DEBUG_TEXTURE_AREA               = 0x008000,
+                RENDER_DEBUG_FACE_AREA                  = 0x010000,
+                RENDER_DEBUG_PARTICLES                  = 0x020000,
+                RENDER_DEBUG_GLOW                               = 0x040000,
+                RENDER_DEBUG_TEXTURE_ANIM               = 0x080000,
+                RENDER_DEBUG_LIGHTS                             = 0x100000,
+                RENDER_DEBUG_BATCH_SIZE                 = 0x200000,
         };
 
         LLPointer<LLViewerImage>        mAlphaSizzleImagep;
 
-        //MUST MATCH THE ORDER OF DECLARATION IN LLPipeline::init()
-        typedef enum 
-        {
-                PARTITION_VOLUME = 0,
-                PARTITION_BRIDGE,
-                PARTITION_HUD,
-                PARTITION_TERRAIN,
-                PARTITION_WATER,
-                PARTITION_TREE,
-                PARTITION_PARTICLE,
-                PARTITION_CLOUD,
-                PARTITION_GRASS,
-                PARTITION_NONE,
-                NUM_PARTITIONS
-        } eObjectPartitions;
-
-private:
-        std::vector<LLSpatialPartition*> mObjectPartition;
 public:
         
         LLSpatialPartition* getSpatialPartition(LLViewerObject* vobj);
-        LLSpatialPartition* getSpatialPartition(U32 index);
 
         void updateCamera(BOOL reset = FALSE);
         
@@ -347,7 +342,14 @@ public:
         LLQuaternion                    mFlyCamRotation;
 
         BOOL                                     mBackfaceCull;
+        S32                                              mBatchCount;
+        S32                                              mMatrixOpCount;
+        S32                                              mTextureMatrixOps;
+        S32                                              mMaxBatchSize;
+        S32                                              mMinBatchSize;
+        S32                                              mMeanBatchSize;
         S32                                              mTrianglesDrawn;
+        S32                                              mNumVisibleNodes;
         LLStat                   mTrianglesDrawnStat;
         S32                                              mVerticesRelit;
 
@@ -359,25 +361,48 @@ public:
         static S32                              sCompiles;
 
         static BOOL                             sShowHUDAttachments;
-        static BOOL                             sUseOcclusion;
+        static S32                              sUseOcclusion;  // 0 = no occlusion, 1 = read only, 2 = read/write
+        static BOOL                             sFastAlpha;
+        static BOOL                             sDisableShaders; // if TRUE, rendering will be done without shaders
+        static BOOL                             sRenderBump;
+        static BOOL                             sUseFBO;
+        static BOOL                             sUseFarClip;
         static BOOL                             sSkipUpdate; //skip lod updates
         static BOOL                             sDynamicReflections;
+        static BOOL                             sWaterReflections;
+        static BOOL                             sDynamicLOD;
+        static BOOL                             sReflectionRender;
+        static BOOL                             sImpostorRender;
+        static BOOL                             sUnderWaterRender;
         static BOOL                             sRenderGlow;
-
+        static BOOL                             sTextureBindTest;
+        static BOOL                             sRenderFrameTest;
+        
         //screen texture
-        GLuint                                  mScreenTex;
+        LLRenderTarget                  mScreen;
+        
         LLVector2                               mScreenScale;
 
-        //texture for making the glow
-        GLuint                                  mGlowMap;
-        GLuint                                  mGlowBuffer;
+        //water reflection texture
+        LLRenderTarget                          mWaterRef;
+
+        //water distortion texture (refraction)
+        LLRenderTarget                          mWaterDis;
 
+        //texture for making the glow
+        LLRenderTarget                          mGlow[3];
+        
         //framebuffer objects for off-screen scratch space
-        GLuint                                  mFramebuffer[2];
+        //GLuint                                        mFramebuffer[4];
+        //GLuint                                        mDepthbuffer[2];
 
         //dynamic cube map scratch space
         LLPointer<LLCubeMap>    mCubeBuffer;
 
+        //cube map anti-aliasing buffers
+        GLuint                                  mBlurCubeBuffer[3];
+        GLuint                                  mBlurCubeTexture[3];
+
         //frambuffer object for rendering dynamic cube maps
         GLuint                                  mCubeFrameBuffer;
         
@@ -388,22 +413,12 @@ public:
         LLColor4                                mSunDiffuse;
         LLVector3                               mSunDir;
 
-        LLSpatialGroup::sg_vector_t mActiveGroups;
-        LLSpatialGroup::drawmap_elem_t mRenderMap[LLRenderPass::NUM_RENDER_TYPES];      
-        std::vector<LLSpatialGroup* > mAlphaGroups;
-        std::vector<LLSpatialGroup* > mAlphaGroupsPostWater;
-        LLSpatialGroup::sg_vector_t mVisibleGroups;
-        LLSpatialGroup::sg_vector_t mDrawableGroups;
-
-        void clearRenderMap();
-
         BOOL                                    mInitialized;
         BOOL                                    mVertexShadersEnabled;
         S32                                             mVertexShadersLoaded; // 0 = no, 1 = yes, -1 = failed
 
 protected:
         U32                                             mRenderTypeMask;
-        U32                                             mRenderFeatureMask;
         U32                                             mRenderDebugFeatureMask;
         U32                                             mRenderDebugMask;
 
@@ -412,9 +427,6 @@ protected:
         /////////////////////////////////////////////
         //
         //
-        LLDrawable::drawable_vector_t   mVisibleList;
-        LLSpatialBridge::bridge_vector_t mVisibleBridge;
-        LLSpatialBridge::bridge_vector_t mOccludedBridge;
         LLDrawable::drawable_vector_t   mMovedList;
         LLDrawable::drawable_vector_t mMovedBridge;
         LLDrawable::drawable_vector_t   mShiftList;
@@ -457,7 +469,7 @@ protected:
         //
         LLDrawable::drawable_list_t     mBuildQ1; // priority
         LLDrawable::drawable_list_t     mBuildQ2; // non-priority
-        
+                
         LLDrawable::drawable_set_t              mActiveQ;
         
         LLDrawable::drawable_set_t              mRetexturedList;
@@ -496,15 +508,15 @@ protected:
         std::map<uintptr_t, LLDrawPool*>        mTerrainPools;
         std::map<uintptr_t, LLDrawPool*>        mTreePools;
         LLDrawPool*                                     mAlphaPool;
-        LLDrawPool*                                     mAlphaPoolPostWater;
         LLDrawPool*                                     mSkyPool;
-        LLDrawPool*                                     mStarsPool;
         LLDrawPool*                                     mTerrainPool;
         LLDrawPool*                                     mWaterPool;
         LLDrawPool*                                     mGroundPool;
         LLRenderPass*                           mSimplePool;
+        LLDrawPool*                                     mInvisiblePool;
         LLDrawPool*                                     mGlowPool;
         LLDrawPool*                                     mBumpPool;
+        LLDrawPool*                                     mWLSkyPool;
         // Note: no need to keep an quick-lookup to avatar pools, since there's only one per avatar
         
 public:
@@ -519,8 +531,7 @@ protected:
         U32                                             mLightMask;
         U32                                             mLightMovingMask;
         S32                                             mLightingDetail;
-        F32                                             mSunShadowFactor;
-        
+                
         static BOOL                             sRenderPhysicalBeacons;
         static BOOL                             sRenderScriptedTouchBeacons;
         static BOOL                             sRenderScriptedBeacons;
@@ -536,5 +547,6 @@ void render_bbox(const LLVector3 &min, const LLVector3 &max);
 
 extern LLPipeline gPipeline;
 extern BOOL gRenderForSelect;
+extern const LLMatrix4* gGLLastMatrix;
 
 #endif