#824 Process source files in bulk: replace tabs with spaces, convert CRLF to LF, and trim trailing whitespaces as needed

1 files changed, 133 insertions, 133 deletions

diff --git a/indra/newview/llsky.cpp b/indra/newview/llsky.cpp
index 4926b86b14..dc784662e9 100644
--- a/indra/newview/llsky.cpp
+++ b/indra/newview/llsky.cpp
@@ -1,35 +1,35 @@
-/** 
+/**
  * @file llsky.cpp
- * @brief IndraWorld sky class 
+ * @brief IndraWorld sky class
  *
  * $LicenseInfo:firstyear=2000&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$
  */
 
-//	Ideas:
-//		-haze should be controlled by global query from sims
-//		-need secondary optical effects on sun (flare)
-//		-stars should be brought down from sims
-//		-star intensity should be driven by global ambient level from sims,
-//		 so that eclipses, etc can be easily done.
+//  Ideas:
+//      -haze should be controlled by global query from sims
+//      -need secondary optical effects on sun (flare)
+//      -stars should be brought down from sims
+//      -star intensity should be driven by global ambient level from sims,
+//       so that eclipses, etc can be easily done.
 //
 
 #include "llviewerprecompiledheaders.h"
@@ -67,13 +67,13 @@ LLSky gSky;
 
 LLSky::LLSky()
 {
-	// Set initial clear color to black
-	// Set fog color 
-	mFogColor.mV[VRED] = mFogColor.mV[VGREEN] = mFogColor.mV[VBLUE] = 0.5f;
-	mFogColor.mV[VALPHA] = 0.0f;
+    // Set initial clear color to black
+    // Set fog color
+    mFogColor.mV[VRED] = mFogColor.mV[VGREEN] = mFogColor.mV[VBLUE] = 0.5f;
+    mFogColor.mV[VALPHA] = 0.0f;
 
-	mLightingGeneration = 0;
-	mUpdatedThisFrame = TRUE;
+    mLightingGeneration = 0;
+    mUpdatedThisFrame = TRUE;
 }
 
 
@@ -83,47 +83,47 @@ LLSky::~LLSky()
 
 void LLSky::cleanup()
 {
-	mVOSkyp = NULL;
-	mVOWLSkyp = NULL;
+    mVOSkyp = NULL;
+    mVOWLSkyp = NULL;
 }
 
 void LLSky::destroyGL()
 {
-	if (!mVOSkyp.isNull() && mVOSkyp->getCubeMap())
-	{
-		mVOSkyp->cleanupGL();
-	}
-	if (mVOWLSkyp.notNull())
-	{
-		mVOWLSkyp->cleanupGL();
-	}
+    if (!mVOSkyp.isNull() && mVOSkyp->getCubeMap())
+    {
+        mVOSkyp->cleanupGL();
+    }
+    if (mVOWLSkyp.notNull())
+    {
+        mVOWLSkyp->cleanupGL();
+    }
 }
 
 void LLSky::restoreGL()
 {
-	if (mVOSkyp)
-	{
-		mVOSkyp->restoreGL();
-	}
-	if (mVOWLSkyp)
-	{
-		mVOWLSkyp->restoreGL();
-	}
+    if (mVOSkyp)
+    {
+        mVOSkyp->restoreGL();
+    }
+    if (mVOWLSkyp)
+    {
+        mVOWLSkyp->restoreGL();
+    }
 }
 
 void LLSky::resetVertexBuffers()
 {
-	if (gSky.mVOSkyp.notNull())
-	{
-		gPipeline.resetVertexBuffers(gSky.mVOSkyp->mDrawable);
-		gPipeline.markRebuild(gSky.mVOSkyp->mDrawable, LLDrawable::REBUILD_ALL);
-	}
-	if (gSky.mVOWLSkyp.notNull())
-	{
-		gSky.mVOWLSkyp->resetVertexBuffers();
-		gPipeline.resetVertexBuffers(gSky.mVOWLSkyp->mDrawable);
-		gPipeline.markRebuild(gSky.mVOWLSkyp->mDrawable, LLDrawable::REBUILD_ALL);
-	}
+    if (gSky.mVOSkyp.notNull())
+    {
+        gPipeline.resetVertexBuffers(gSky.mVOSkyp->mDrawable);
+        gPipeline.markRebuild(gSky.mVOSkyp->mDrawable, LLDrawable::REBUILD_ALL);
+    }
+    if (gSky.mVOWLSkyp.notNull())
+    {
+        gSky.mVOWLSkyp->resetVertexBuffers();
+        gPipeline.resetVertexBuffers(gSky.mVOWLSkyp->mDrawable);
+        gPipeline.markRebuild(gSky.mVOWLSkyp->mDrawable, LLDrawable::REBUILD_ALL);
+    }
 }
 
 void LLSky::setSunScale(F32 sun_scale)
@@ -131,7 +131,7 @@ void LLSky::setSunScale(F32 sun_scale)
     if(mVOSkyp.notNull())
     {
         mVOSkyp->setSunScale(sun_scale);
-	}
+    }
 }
 
 void LLSky::setMoonScale(F32 moon_scale)
@@ -139,56 +139,56 @@ void LLSky::setMoonScale(F32 moon_scale)
     if(mVOSkyp.notNull())
     {
         mVOSkyp->setMoonScale(moon_scale);
-	}
+    }
 }
 
 void LLSky::setSunTextures(const LLUUID& sun_texture, const LLUUID& sun_texture_next)
 {
     if(mVOSkyp.notNull()) {
         mVOSkyp->setSunTextures(sun_texture, sun_texture_next);
-	}
+    }
 }
 
 void LLSky::setMoonTextures(const LLUUID& moon_texture, const LLUUID& moon_texture_next)
 {
     if(mVOSkyp.notNull()) {
         mVOSkyp->setMoonTextures(moon_texture, moon_texture_next);
-	}
+    }
 }
 
 void LLSky::setCloudNoiseTextures(const LLUUID& cloud_noise_texture, const LLUUID& cloud_noise_texture_next)
 {
     if(mVOSkyp.notNull()) {
         mVOSkyp->setCloudNoiseTextures(cloud_noise_texture, cloud_noise_texture_next);
-	}
+    }
 }
 
 void LLSky::setBloomTextures(const LLUUID& bloom_texture, const LLUUID& bloom_texture_next)
 {
     if(mVOSkyp.notNull()) {
         mVOSkyp->setBloomTextures(bloom_texture, bloom_texture_next);
-	}
+    }
 }
 
 void LLSky::setSunAndMoonDirectionsCFR(const LLVector3 &sun_direction, const LLVector3 &moon_direction)
 {
     if(mVOSkyp.notNull()) {
         mVOSkyp->setSunAndMoonDirectionsCFR(sun_direction, moon_direction);
-	}
+    }
 }
 
 void LLSky::setSunDirectionCFR(const LLVector3 &sun_direction)
 {
     if(mVOSkyp.notNull()) {
         mVOSkyp->setSunDirectionCFR(sun_direction);
-	}
+    }
 }
 
 void LLSky::setMoonDirectionCFR(const LLVector3 &moon_direction)
 {
     if(mVOSkyp.notNull()) {
         mVOSkyp->setMoonDirectionCFR(moon_direction);
-	}
+    }
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -197,52 +197,52 @@ void LLSky::setMoonDirectionCFR(const LLVector3 &moon_direction)
 
 void LLSky::init()
 {
-	mVOWLSkyp = static_cast<LLVOWLSky*>(gObjectList.createObjectViewer(LLViewerObject::LL_VO_WL_SKY, NULL));
+    mVOWLSkyp = static_cast<LLVOWLSky*>(gObjectList.createObjectViewer(LLViewerObject::LL_VO_WL_SKY, NULL));
     mVOWLSkyp->init();
-	gPipeline.createObject(mVOWLSkyp.get());
+    gPipeline.createObject(mVOWLSkyp.get());
 
-	mVOSkyp = (LLVOSky *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_SKY, NULL);
+    mVOSkyp = (LLVOSky *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_SKY, NULL);
     mVOSkyp->init();
-	gPipeline.createObject(mVOSkyp.get());
+    gPipeline.createObject(mVOSkyp.get());
 
-	gSky.setFogRatio(gSavedSettings.getF32("RenderFogRatio"));
+    gSky.setFogRatio(gSavedSettings.getF32("RenderFogRatio"));
 
-	mUpdatedThisFrame = TRUE;
+    mUpdatedThisFrame = TRUE;
 }
 
 
 void LLSky::setCloudDensityAtAgent(F32 cloud_density)
 {
-	if (mVOSkyp)
-	{
-		mVOSkyp->setCloudDensity(cloud_density);
-	}
+    if (mVOSkyp)
+    {
+        mVOSkyp->setCloudDensity(cloud_density);
+    }
 }
 
 
 void LLSky::setWind(const LLVector3& average_wind)
 {
-	if (mVOSkyp)
-	{
-		mVOSkyp->setWind(average_wind);
-	}
+    if (mVOSkyp)
+    {
+        mVOSkyp->setWind(average_wind);
+    }
 }
 
 void LLSky::addSunMoonBeacons()
-{	
-	if (!gAgentAvatarp || !mVOSkyp) return;
-
-	static LLUICachedControl<bool> show_sun_beacon("sunbeacon", false);
-	static LLUICachedControl<bool> show_moon_beacon("moonbeacon", false);
-
-	if (show_sun_beacon)
-	{
-		renderSunMoonBeacons(gAgentAvatarp->getPositionAgent(), mVOSkyp->getSun().getDirection(), LLColor4(1.f, 0.5f, 0.f, 0.5f));
-	}
-	if (show_moon_beacon)
-	{
-		renderSunMoonBeacons(gAgentAvatarp->getPositionAgent(), mVOSkyp->getMoon().getDirection(), LLColor4(1.f, 0.f, 0.8f, 0.5f));
-	}
+{
+    if (!gAgentAvatarp || !mVOSkyp) return;
+
+    static LLUICachedControl<bool> show_sun_beacon("sunbeacon", false);
+    static LLUICachedControl<bool> show_moon_beacon("moonbeacon", false);
+
+    if (show_sun_beacon)
+    {
+        renderSunMoonBeacons(gAgentAvatarp->getPositionAgent(), mVOSkyp->getSun().getDirection(), LLColor4(1.f, 0.5f, 0.f, 0.5f));
+    }
+    if (show_moon_beacon)
+    {
+        renderSunMoonBeacons(gAgentAvatarp->getPositionAgent(), mVOSkyp->getMoon().getDirection(), LLColor4(1.f, 0.f, 0.8f, 0.5f));
+    }
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -252,82 +252,82 @@ void LLSky::addSunMoonBeacons()
 
 LLColor4 LLSky::getSkyFogColor() const
 {
-	if (mVOSkyp)
-	{
-		return mVOSkyp->getSkyFogColor();
-	}
+    if (mVOSkyp)
+    {
+        return mVOSkyp->getSkyFogColor();
+    }
 
-	return LLColor4(1.f, 1.f, 1.f, 1.f);
+    return LLColor4(1.f, 1.f, 1.f, 1.f);
 }
 
 void LLSky::updateFog(const F32 distance)
 {
-	if (mVOSkyp)
-	{
-		mVOSkyp->updateFog(distance);
-	}
+    if (mVOSkyp)
+    {
+        mVOSkyp->updateFog(distance);
+    }
 }
 
 void LLSky::updateCull()
 {
-	// *TODO: do culling for wl sky properly -Brad
+    // *TODO: do culling for wl sky properly -Brad
 }
 
 void LLSky::updateSky()
 {
-	if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
-	{
-		return;
-	}
-	if (mVOSkyp)
-	{
-		mVOSkyp->updateSky();
-	}
+    if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
+    {
+        return;
+    }
+    if (mVOSkyp)
+    {
+        mVOSkyp->updateSky();
+    }
 }
 
 
 void LLSky::setFogRatio(const F32 fog_ratio)
 {
-	if (mVOSkyp)
-	{
-		mVOSkyp->setFogRatio(fog_ratio);
-	}
+    if (mVOSkyp)
+    {
+        mVOSkyp->setFogRatio(fog_ratio);
+    }
 }
 
 
 F32 LLSky::getFogRatio() const
 {
-	if (mVOSkyp)
-	{
-		return mVOSkyp->getFogRatio();
-	}
-	else
-	{
-		return 0.f;
-	}
+    if (mVOSkyp)
+    {
+        return mVOSkyp->getFogRatio();
+    }
+    else
+    {
+        return 0.f;
+    }
 }
 
 
-// Returns angle (DEGREES) between the horizontal plane and "v", 
+// Returns angle (DEGREES) between the horizontal plane and "v",
 // where the angle is negative when v.mV[VZ] < 0.0f
 F32 elevation_from_vector(const LLVector3 &v)
 {
-	F32 elevation = 0.0f;
-	F32 xy_component = (F32) sqrt(v.mV[VX] * v.mV[VX] + v.mV[VY] * v.mV[VY]);
-	if (xy_component != 0.0f)
-	{
-		elevation = RAD_TO_DEG * (F32) atan(v.mV[VZ]/xy_component);
-	}
-	else
-	{
-		if (v.mV[VZ] > 0.f)
-		{
-			elevation = 90.f;
-		}
-		else
-		{
-			elevation = -90.f;
-		}
-	}
-	return elevation;
+    F32 elevation = 0.0f;
+    F32 xy_component = (F32) sqrt(v.mV[VX] * v.mV[VX] + v.mV[VY] * v.mV[VY]);
+    if (xy_component != 0.0f)
+    {
+        elevation = RAD_TO_DEG * (F32) atan(v.mV[VZ]/xy_component);
+    }
+    else
+    {
+        if (v.mV[VZ] > 0.f)
+        {
+            elevation = 90.f;
+        }
+        else
+        {
+            elevation = -90.f;
+        }
+    }
+    return elevation;
 }