Post-merge spaces fix

1 files changed, 185 insertions, 185 deletions

diff --git a/indra/newview/lldrawpool.h b/indra/newview/lldrawpool.h
index c69f386c6d..789d8d45c9 100644
--- a/indra/newview/lldrawpool.h
+++ b/indra/newview/lldrawpool.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file lldrawpool.h
  * @brief LLDrawPool class definition
  *
  * $LicenseInfo:firstyear=2002&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -43,87 +43,87 @@ class LLMeshSkinInfo;
 class LLDrawPool
 {
 public:
-	static S32 sNumDrawPools;
+    static S32 sNumDrawPools;
 
-	enum
-	{
-		// Correspond to LLPipeline render type
+    enum
+    {
+        // Correspond to LLPipeline render type
         // Also controls render order, so passes that don't use alpha masking/blending should come before
         // other passes to preserve hierarchical Z for occlusion queries.  Occlusion queries happen just
         // before grass, so grass should be the first alpha masked pool.  Other ordering should be done
         // based on fill rate and likelihood to occlude future passes (faster, large occluders first).
-        //  
+        //
         POOL_SKY = 1,
         POOL_WL_SKY,
-		POOL_SIMPLE,
-		POOL_FULLBRIGHT,
-		POOL_BUMP,
+        POOL_SIMPLE,
+        POOL_FULLBRIGHT,
+        POOL_BUMP,
         POOL_MATERIALS,
         POOL_GLTF_PBR,
-		POOL_TERRAIN,
+        POOL_TERRAIN,
         POOL_GRASS,
         POOL_GLTF_PBR_ALPHA_MASK,
-		POOL_TREE,
-		POOL_ALPHA_MASK,
-		POOL_FULLBRIGHT_ALPHA_MASK,
-		POOL_AVATAR,
-		POOL_CONTROL_AV, // Animesh
-		POOL_GLOW,
-		POOL_ALPHA_PRE_WATER,
+        POOL_TREE,
+        POOL_ALPHA_MASK,
+        POOL_FULLBRIGHT_ALPHA_MASK,
+        POOL_AVATAR,
+        POOL_CONTROL_AV, // Animesh
+        POOL_GLOW,
+        POOL_ALPHA_PRE_WATER,
         POOL_VOIDWATER,
         POOL_WATER,
         POOL_ALPHA_POST_WATER,
         POOL_ALPHA, // note there is no actual "POOL_ALPHA" but pre-water and post-water pools consume POOL_ALPHA faces
-		NUM_POOL_TYPES,
-	};
-	
-	LLDrawPool(const U32 type);
-	virtual ~LLDrawPool();
-
-	virtual BOOL isDead() = 0;
-
-	S32 getId() const { return mId; }
-	U32 getType() const { return mType; }
-
-	BOOL getSkipRenderFlag() const { return mSkipRender;}
-	void setSkipRenderFlag( BOOL flag ) { mSkipRender = flag; }
-
-	virtual LLViewerTexture *getDebugTexture();
-	virtual void beginRenderPass( S32 pass );
-	virtual void endRenderPass( S32 pass );
-	virtual S32	 getNumPasses();
-	
-	virtual void beginDeferredPass(S32 pass);
-	virtual void endDeferredPass(S32 pass);
-	virtual S32 getNumDeferredPasses();
-	virtual void renderDeferred(S32 pass = 0);
-
-	virtual void beginPostDeferredPass(S32 pass);
-	virtual void endPostDeferredPass(S32 pass);
-	virtual S32 getNumPostDeferredPasses();
-	virtual void renderPostDeferred(S32 pass = 0);
-
-	virtual void beginShadowPass(S32 pass);
-	virtual void endShadowPass(S32 pass);
-	virtual S32 getNumShadowPasses();
-	virtual void renderShadow(S32 pass = 0);
+        NUM_POOL_TYPES,
+    };
+
+    LLDrawPool(const U32 type);
+    virtual ~LLDrawPool();
+
+    virtual BOOL isDead() = 0;
+
+    S32 getId() const { return mId; }
+    U32 getType() const { return mType; }
+
+    BOOL getSkipRenderFlag() const { return mSkipRender;}
+    void setSkipRenderFlag( BOOL flag ) { mSkipRender = flag; }
+
+    virtual LLViewerTexture *getDebugTexture();
+    virtual void beginRenderPass( S32 pass );
+    virtual void endRenderPass( S32 pass );
+    virtual S32  getNumPasses();
+
+    virtual void beginDeferredPass(S32 pass);
+    virtual void endDeferredPass(S32 pass);
+    virtual S32 getNumDeferredPasses();
+    virtual void renderDeferred(S32 pass = 0);
+
+    virtual void beginPostDeferredPass(S32 pass);
+    virtual void endPostDeferredPass(S32 pass);
+    virtual S32 getNumPostDeferredPasses();
+    virtual void renderPostDeferred(S32 pass = 0);
+
+    virtual void beginShadowPass(S32 pass);
+    virtual void endShadowPass(S32 pass);
+    virtual S32 getNumShadowPasses();
+    virtual void renderShadow(S32 pass = 0);
 
     virtual void render(S32 pass = 0) {};
     virtual void prerender() {};
     virtual U32 getVertexDataMask() { return 0; } // DEPRECATED -- draw pool doesn't actually determine vertex data mask any more
-	virtual BOOL verify() const { return TRUE; }		// Verify that all data in the draw pool is correct!
-	virtual S32 getShaderLevel() const { return mShaderLevel; }
-	
-	static LLDrawPool* createPool(const U32 type, LLViewerTexture *tex0 = NULL);
-	virtual LLViewerTexture* getTexture() = 0;
-	virtual BOOL isFacePool() { return FALSE; }
-	virtual void resetDrawOrders() = 0;
+    virtual BOOL verify() const { return TRUE; }        // Verify that all data in the draw pool is correct!
+    virtual S32 getShaderLevel() const { return mShaderLevel; }
+
+    static LLDrawPool* createPool(const U32 type, LLViewerTexture *tex0 = NULL);
+    virtual LLViewerTexture* getTexture() = 0;
+    virtual BOOL isFacePool() { return FALSE; }
+    virtual void resetDrawOrders() = 0;
     virtual void pushFaceGeometry() {}
 
-	S32 mShaderLevel;
-	S32	mId;
-	U32 mType;				// Type of draw pool
-	BOOL mSkipRender;
+    S32 mShaderLevel;
+    S32 mId;
+    U32 mType;              // Type of draw pool
+    BOOL mSkipRender;
 };
 
 class LLRenderPass : public LLDrawPool
@@ -132,77 +132,77 @@ public:
     // list of possible LLRenderPass types to assign a render batch to
     // NOTE: "rigged" variant MUST be non-rigged variant + 1
     // see LLVolumeGeometryManager::registerFace()
-	enum
-	{
-		PASS_SIMPLE = NUM_POOL_TYPES,
+    enum
+    {
+        PASS_SIMPLE = NUM_POOL_TYPES,
         PASS_SIMPLE_RIGGED,
-		PASS_GRASS,
-		PASS_FULLBRIGHT,
+        PASS_GRASS,
+        PASS_FULLBRIGHT,
         PASS_FULLBRIGHT_RIGGED,
-		PASS_INVISIBLE,
+        PASS_INVISIBLE,
         PASS_INVISIBLE_RIGGED,
-		PASS_INVISI_SHINY, 
+        PASS_INVISI_SHINY,
         PASS_INVISI_SHINY_RIGGED,
-		PASS_FULLBRIGHT_SHINY,
+        PASS_FULLBRIGHT_SHINY,
         PASS_FULLBRIGHT_SHINY_RIGGED,
-		PASS_SHINY,
+        PASS_SHINY,
         PASS_SHINY_RIGGED,
-		PASS_BUMP,
+        PASS_BUMP,
         PASS_BUMP_RIGGED,
-		PASS_POST_BUMP,
+        PASS_POST_BUMP,
         PASS_POST_BUMP_RIGGED,
-		PASS_MATERIAL,
+        PASS_MATERIAL,
         PASS_MATERIAL_RIGGED,
-		PASS_MATERIAL_ALPHA,
+        PASS_MATERIAL_ALPHA,
         PASS_MATERIAL_ALPHA_RIGGED,
-		PASS_MATERIAL_ALPHA_MASK,              // Diffuse texture used as alpha mask
+        PASS_MATERIAL_ALPHA_MASK,              // Diffuse texture used as alpha mask
         PASS_MATERIAL_ALPHA_MASK_RIGGED,
-		PASS_MATERIAL_ALPHA_EMISSIVE,
+        PASS_MATERIAL_ALPHA_EMISSIVE,
         PASS_MATERIAL_ALPHA_EMISSIVE_RIGGED,
-		PASS_SPECMAP,
+        PASS_SPECMAP,
         PASS_SPECMAP_RIGGED,
-		PASS_SPECMAP_BLEND,
+        PASS_SPECMAP_BLEND,
         PASS_SPECMAP_BLEND_RIGGED,
-		PASS_SPECMAP_MASK,                     // Diffuse texture used as alpha mask and specular texture(map)
+        PASS_SPECMAP_MASK,                     // Diffuse texture used as alpha mask and specular texture(map)
         PASS_SPECMAP_MASK_RIGGED,
-		PASS_SPECMAP_EMISSIVE,
+        PASS_SPECMAP_EMISSIVE,
         PASS_SPECMAP_EMISSIVE_RIGGED,
-		PASS_NORMMAP,
+        PASS_NORMMAP,
         PASS_NORMMAP_RIGGED,
-		PASS_NORMMAP_BLEND,
+        PASS_NORMMAP_BLEND,
         PASS_NORMMAP_BLEND_RIGGED,
-		PASS_NORMMAP_MASK,                     // Diffuse texture used as alpha mask and normal map
+        PASS_NORMMAP_MASK,                     // Diffuse texture used as alpha mask and normal map
         PASS_NORMMAP_MASK_RIGGED,
-		PASS_NORMMAP_EMISSIVE,
+        PASS_NORMMAP_EMISSIVE,
         PASS_NORMMAP_EMISSIVE_RIGGED,
-		PASS_NORMSPEC,
+        PASS_NORMSPEC,
         PASS_NORMSPEC_RIGGED,
-		PASS_NORMSPEC_BLEND, 
+        PASS_NORMSPEC_BLEND,
         PASS_NORMSPEC_BLEND_RIGGED,
-		PASS_NORMSPEC_MASK,                    // Diffuse texture used as alpha mask with normal and specular map
+        PASS_NORMSPEC_MASK,                    // Diffuse texture used as alpha mask with normal and specular map
         PASS_NORMSPEC_MASK_RIGGED,
-		PASS_NORMSPEC_EMISSIVE,
+        PASS_NORMSPEC_EMISSIVE,
         PASS_NORMSPEC_EMISSIVE_RIGGED,
-		PASS_GLOW,
+        PASS_GLOW,
         PASS_GLOW_RIGGED,
         PASS_GLTF_GLOW,
         PASS_GLTF_GLOW_RIGGED,
-		PASS_ALPHA,
+        PASS_ALPHA,
         PASS_ALPHA_RIGGED,
-		PASS_ALPHA_MASK,
+        PASS_ALPHA_MASK,
         PASS_ALPHA_MASK_RIGGED,
-		PASS_FULLBRIGHT_ALPHA_MASK,            // Diffuse texture used as alpha mask and fullbright
+        PASS_FULLBRIGHT_ALPHA_MASK,            // Diffuse texture used as alpha mask and fullbright
         PASS_FULLBRIGHT_ALPHA_MASK_RIGGED,
-		PASS_ALPHA_INVISIBLE,
+        PASS_ALPHA_INVISIBLE,
         PASS_ALPHA_INVISIBLE_RIGGED,
         PASS_GLTF_PBR,
         PASS_GLTF_PBR_RIGGED,
         PASS_GLTF_PBR_ALPHA_MASK,
         PASS_GLTF_PBR_ALPHA_MASK_RIGGED,
-		NUM_RENDER_TYPES,
-	};
+        NUM_RENDER_TYPES,
+    };
 
-	#ifdef LL_PROFILER_ENABLE_RENDER_DOC
+    #ifdef LL_PROFILER_ENABLE_RENDER_DOC
     static inline const char* lookupPassName(U32 pass)
     {
         switch (pass)
@@ -336,22 +336,22 @@ public:
             default:
                 return "Unknown pass";
         }
-	}
-	#else
+    }
+    #else
     static inline const char* lookupPass(U32 pass) { return ""; }
-	#endif
+    #endif
 
-	LLRenderPass(const U32 type);
-	virtual ~LLRenderPass();
-	/*virtual*/ LLViewerTexture* getDebugTexture() { return NULL; }
-	LLViewerTexture* getTexture() { return NULL; }
-	BOOL isDead() { return FALSE; }
-	void resetDrawOrders() { }
+    LLRenderPass(const U32 type);
+    virtual ~LLRenderPass();
+    /*virtual*/ LLViewerTexture* getDebugTexture() { return NULL; }
+    LLViewerTexture* getTexture() { return NULL; }
+    BOOL isDead() { return FALSE; }
+    void resetDrawOrders() { }
 
-	static void applyModelMatrix(const LLDrawInfo& params);
+    static void applyModelMatrix(const LLDrawInfo& params);
     // For rendering that doesn't use LLDrawInfo for some reason
-	static void applyModelMatrix(const LLMatrix4* model_matrix);
-	void pushBatches(U32 type, bool texture = true, bool batch_textures = false);
+    static void applyModelMatrix(const LLMatrix4* model_matrix);
+    void pushBatches(U32 type, bool texture = true, bool batch_textures = false);
     void pushUntexturedBatches(U32 type);
 
     void pushRiggedBatches(U32 type, bool texture = true, bool batch_textures = false);
@@ -379,104 +379,104 @@ public:
     static void pushUntexturedGLTFBatch(LLDrawInfo& params);
     static void pushUntexturedRiggedGLTFBatch(LLDrawInfo& params, LLVOAvatar*& lastAvatar, U64& lastMeshId);
 
-	void pushMaskBatches(U32 type, bool texture = true, bool batch_textures = false);
+    void pushMaskBatches(U32 type, bool texture = true, bool batch_textures = false);
     void pushRiggedMaskBatches(U32 type, bool texture = true, bool batch_textures = false);
-	void pushBatch(LLDrawInfo& params, bool texture, bool batch_textures = false);
+    void pushBatch(LLDrawInfo& params, bool texture, bool batch_textures = false);
     void pushUntexturedBatch(LLDrawInfo& params);
-	void pushBumpBatch(LLDrawInfo& params, bool texture, bool batch_textures = false);
+    void pushBumpBatch(LLDrawInfo& params, bool texture, bool batch_textures = false);
     static bool uploadMatrixPalette(LLDrawInfo& params);
     static bool uploadMatrixPalette(LLVOAvatar* avatar, LLMeshSkinInfo* skinInfo);
-	virtual void renderGroup(LLSpatialGroup* group, U32 type, bool texture = true);
+    virtual void renderGroup(LLSpatialGroup* group, U32 type, bool texture = true);
     virtual void renderRiggedGroup(LLSpatialGroup* group, U32 type, bool texture = true);
 };
 
 class LLFacePool : public LLDrawPool
 {
 public:
-	typedef std::vector<LLFace*> face_array_t;
-	
-	enum
-	{
-		SHADER_LEVEL_SCATTERING = 2
-	};
+    typedef std::vector<LLFace*> face_array_t;
+
+    enum
+    {
+        SHADER_LEVEL_SCATTERING = 2
+    };
 
 public:
-	LLFacePool(const U32 type);
-	virtual ~LLFacePool();
-	
-	BOOL isDead() { return mReferences.empty(); }
-	
-	virtual LLViewerTexture *getTexture();
-	virtual void dirtyTextures(const std::set<LLViewerFetchedTexture*>& textures);
+    LLFacePool(const U32 type);
+    virtual ~LLFacePool();
+
+    BOOL isDead() { return mReferences.empty(); }
+
+    virtual LLViewerTexture *getTexture();
+    virtual void dirtyTextures(const std::set<LLViewerFetchedTexture*>& textures);
+
+    virtual void enqueue(LLFace *face);
+    virtual BOOL addFace(LLFace *face);
+    virtual BOOL removeFace(LLFace *face);
 
-	virtual void enqueue(LLFace *face);
-	virtual BOOL addFace(LLFace *face);
-	virtual BOOL removeFace(LLFace *face);
+    virtual BOOL verify() const;        // Verify that all data in the draw pool is correct!
 
-	virtual BOOL verify() const;		// Verify that all data in the draw pool is correct!
-	
-	virtual void resetDrawOrders();
-	void resetAll();
+    virtual void resetDrawOrders();
+    void resetAll();
 
-	void destroy();
+    void destroy();
 
-	void buildEdges();
+    void buildEdges();
 
-	void addFaceReference(LLFace *facep);
-	void removeFaceReference(LLFace *facep);
+    void addFaceReference(LLFace *facep);
+    void removeFaceReference(LLFace *facep);
 
-	void printDebugInfo() const;
-	
-	BOOL isFacePool() { return TRUE; }
+    void printDebugInfo() const;
+
+    BOOL isFacePool() { return TRUE; }
 
     // call drawIndexed on every draw face
     void pushFaceGeometry();
 
-	friend class LLFace;
-	friend class LLPipeline;
+    friend class LLFace;
+    friend class LLPipeline;
 public:
-	face_array_t	mDrawFace;
-	face_array_t	mMoveFace;
-	face_array_t	mReferences;
+    face_array_t    mDrawFace;
+    face_array_t    mMoveFace;
+    face_array_t    mReferences;
 
 public:
-	class LLOverrideFaceColor
-	{
-	public:
-		LLOverrideFaceColor(LLDrawPool* pool)
-			: mOverride(sOverrideFaceColor), mPool(pool)
-		{
-			sOverrideFaceColor = TRUE;
-		}
-		LLOverrideFaceColor(LLDrawPool* pool, const LLColor4& color)
-			: mOverride(sOverrideFaceColor), mPool(pool)
-		{
-			sOverrideFaceColor = TRUE;
-			setColor(color);
-		}
-		LLOverrideFaceColor(LLDrawPool* pool, const LLColor4U& color)
-			: mOverride(sOverrideFaceColor), mPool(pool)
-		{
-			sOverrideFaceColor = TRUE;
-			setColor(color);
-		}
-		LLOverrideFaceColor(LLDrawPool* pool, F32 r, F32 g, F32 b, F32 a)
-			: mOverride(sOverrideFaceColor), mPool(pool)
-		{
-			sOverrideFaceColor = TRUE;
-			setColor(r, g, b, a);
-		}
-		~LLOverrideFaceColor()
-		{
-			sOverrideFaceColor = mOverride;
-		}
-		void setColor(const LLColor4& color);
-		void setColor(const LLColor4U& color);
-		void setColor(F32 r, F32 g, F32 b, F32 a);
-		BOOL mOverride;
-		LLDrawPool* mPool;
-		static BOOL sOverrideFaceColor;
-	};
+    class LLOverrideFaceColor
+    {
+    public:
+        LLOverrideFaceColor(LLDrawPool* pool)
+            : mOverride(sOverrideFaceColor), mPool(pool)
+        {
+            sOverrideFaceColor = TRUE;
+        }
+        LLOverrideFaceColor(LLDrawPool* pool, const LLColor4& color)
+            : mOverride(sOverrideFaceColor), mPool(pool)
+        {
+            sOverrideFaceColor = TRUE;
+            setColor(color);
+        }
+        LLOverrideFaceColor(LLDrawPool* pool, const LLColor4U& color)
+            : mOverride(sOverrideFaceColor), mPool(pool)
+        {
+            sOverrideFaceColor = TRUE;
+            setColor(color);
+        }
+        LLOverrideFaceColor(LLDrawPool* pool, F32 r, F32 g, F32 b, F32 a)
+            : mOverride(sOverrideFaceColor), mPool(pool)
+        {
+            sOverrideFaceColor = TRUE;
+            setColor(r, g, b, a);
+        }
+        ~LLOverrideFaceColor()
+        {
+            sOverrideFaceColor = mOverride;
+        }
+        void setColor(const LLColor4& color);
+        void setColor(const LLColor4U& color);
+        void setColor(F32 r, F32 g, F32 b, F32 a);
+        BOOL mOverride;
+        LLDrawPool* mPool;
+        static BOOL sOverrideFaceColor;
+    };
 };