Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 581 insertions, 581 deletions

diff --git a/indra/newview/llvowlsky.cpp b/indra/newview/llvowlsky.cpp
index e0b312ec7c..4c36055038 100644
--- a/indra/newview/llvowlsky.cpp
+++ b/indra/newview/llvowlsky.cpp
@@ -1,581 +1,581 @@
-/** 
- * @file llvowlsky.cpp
- * @brief LLVOWLSky class implementation
- *
- * $LicenseInfo:firstyear=2007&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$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "pipeline.h"
-
-#include "llvowlsky.h"
-#include "llsky.h"
-#include "lldrawpoolwlsky.h"
-#include "llface.h"
-#include "llviewercontrol.h"
-#include "llenvironment.h"
-#include "llsettingssky.h"
-
-constexpr U32 MIN_SKY_DETAIL = 8;
-constexpr U32 MAX_SKY_DETAIL = 180;
-
-inline U32 LLVOWLSky::getNumStacks(void)
-{
-	return llmin(MAX_SKY_DETAIL, llmax(MIN_SKY_DETAIL, gSavedSettings.getU32("WLSkyDetail")));
-}
-
-inline U32 LLVOWLSky::getNumSlices(void)
-{
-	return 2 * llmin(MAX_SKY_DETAIL, llmax(MIN_SKY_DETAIL, gSavedSettings.getU32("WLSkyDetail")));
-}
-
-inline U32 LLVOWLSky::getStripsNumVerts(void)
-{
-	return (getNumStacks() - 1) * getNumSlices();
-}
-
-inline U32 LLVOWLSky::getStripsNumIndices(void)
-{
-	return 2 * ((getNumStacks() - 2) * (getNumSlices() + 1)) + 1 ; 
-}
-
-inline U32 LLVOWLSky::getStarsNumVerts(void)
-{
-	return 1000;
-}
-
-inline U32 LLVOWLSky::getStarsNumIndices(void)
-{
-	return 1000;
-}
-
-LLVOWLSky::LLVOWLSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
-	: LLStaticViewerObject(id, pcode, regionp, true)
-{
-	initStars();
-}
-
-void LLVOWLSky::idleUpdate(LLAgent &agent, const F64 &time)
-{
-	
-}
-
-bool LLVOWLSky::isActive(void) const
-{
-	return false;
-}
-
-LLDrawable * LLVOWLSky::createDrawable(LLPipeline * pipeline)
-{
-	pipeline->allocDrawable(this);
-
-	//LLDrawPoolWLSky *poolp = static_cast<LLDrawPoolWLSky *>(
-		gPipeline.getPool(LLDrawPool::POOL_WL_SKY);
-
-	mDrawable->setRenderType(LLPipeline::RENDER_TYPE_WL_SKY);
-
-	return mDrawable;
-}
-
-// a tiny helper function for controlling the sky dome tesselation.
-inline F32 calcPhi(const U32 &i, const F32 &reciprocal_num_stacks)
-{
-    // Calc: PI/8 * 1-((1-t^4)*(1-t^4))  { 0<t<1 }
-    // Demos: \pi/8*\left(1-((1-x^{4})*(1-x^{4}))\right)\ \left\{0<x\le1\right\}
-
-	// i should range from [0..SKY_STACKS] so t will range from [0.f .. 1.f]
-	F32 t = float(i) * reciprocal_num_stacks; //SL-16127: remove: / float(getNumStacks());
-
-	// ^4 the parameter of the tesselation to bias things toward 0 (the dome's apex)
-	t *= t;
-	t *= t;
-
-	// invert and square the parameter of the tesselation to bias things toward 1 (the horizon)
-	t = 1.f - t;
-	t = t*t;
-	t = 1.f - t;
-
-	return (F_PI / 8.f) * t;
-}
-
-void LLVOWLSky::resetVertexBuffers()
-{
-	mStripsVerts.clear();
-	mStarsVerts = nullptr;
-    mFsSkyVerts = nullptr;
-
-	gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL);
-}
-	
-void LLVOWLSky::cleanupGL()
-{
-	mStripsVerts.clear();
-	mStarsVerts = nullptr;
-    mFsSkyVerts = nullptr;
-
-	LLDrawPoolWLSky::cleanupGL();
-}
-
-void LLVOWLSky::restoreGL()
-{
-	LLDrawPoolWLSky::restoreGL();
-	gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL);
-}
-
-bool LLVOWLSky::updateGeometry(LLDrawable * drawable)
-{
-    LL_PROFILE_ZONE_SCOPED;
-	LLStrider<LLVector3>	vertices;
-	LLStrider<LLVector2>	texCoords;
-	LLStrider<U16>			indices;
-
-    if (mFsSkyVerts.isNull())
-    {
-        mFsSkyVerts = new LLVertexBuffer(LLDrawPoolWLSky::ADV_ATMO_SKY_VERTEX_DATA_MASK);
-
-        if (!mFsSkyVerts->allocateBuffer(4, 6))
-		{
-			LL_WARNS() << "Failed to allocate Vertex Buffer on full screen sky update" << LL_ENDL;
-		}
-
-		bool success = mFsSkyVerts->getVertexStrider(vertices)
-			        && mFsSkyVerts->getTexCoord0Strider(texCoords)
-			        && mFsSkyVerts->getIndexStrider(indices);
-
-		if(!success) 
-		{
-			LL_ERRS() << "Failed updating WindLight fullscreen sky geometry." << LL_ENDL;
-		}
-
-        *vertices++ = LLVector3(-1.0f, -1.0f, 0.0f);
-        *vertices++ = LLVector3( 1.0f, -1.0f, 0.0f);
-        *vertices++ = LLVector3(-1.0f,  1.0f, 0.0f);
-        *vertices++ = LLVector3( 1.0f,  1.0f, 0.0f);
-
-		*texCoords++ = LLVector2(0.0f, 0.0f);
-        *texCoords++ = LLVector2(1.0f, 0.0f);
-        *texCoords++ = LLVector2(0.0f, 1.0f);
-        *texCoords++ = LLVector2(1.0f, 1.0f);
-
-		*indices++ = 0;
-		*indices++ = 1;
-		*indices++ = 2;
-        *indices++ = 1;
-		*indices++ = 3;
-		*indices++ = 2;
-
-        mFsSkyVerts->unmapBuffer();
-    }
-
-	{
-        const F32 dome_radius = LLEnvironment::instance().getCurrentSky()->getDomeRadius();
-
-		const U32 max_buffer_bytes = gSavedSettings.getS32("RenderMaxVBOSize")*1024;
-		const U32 data_mask = LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK;
-		const U32 max_verts = max_buffer_bytes / LLVertexBuffer::calcVertexSize(data_mask);
-
-		const U32 total_stacks = getNumStacks();
-
-		const U32 verts_per_stack = getNumSlices();
-
-		// each seg has to have one more row of verts than it has stacks
-		// then round down
-		const U32 stacks_per_seg = (max_verts - verts_per_stack) / verts_per_stack;
-
-		// round up to a whole number of segments
-		const U32 strips_segments = (total_stacks+stacks_per_seg-1) / stacks_per_seg;
-
-		mStripsVerts.resize(strips_segments, NULL);
-
-#if RELEASE_SHOW_DEBUG
-		LL_INFOS() << "WL Skydome strips in " << strips_segments << " batches." << LL_ENDL;
-
-		LLTimer timer;
-		timer.start();
-#endif
-
-		for (U32 i = 0; i < strips_segments ;++i)
-		{
-			LLVertexBuffer * segment = new LLVertexBuffer(LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK);
-			mStripsVerts[i] = segment;
-
-			U32 num_stacks_this_seg = stacks_per_seg;
-			if ((i == strips_segments - 1) && (total_stacks % stacks_per_seg) != 0)
-			{
-				// for the last buffer only allocate what we'll use
-				num_stacks_this_seg = total_stacks % stacks_per_seg;
-			}
-
-			// figure out what range of the sky we're filling
-			const U32 begin_stack = i * stacks_per_seg;
-			const U32 end_stack = begin_stack + num_stacks_this_seg;
-			llassert(end_stack <= total_stacks);
-
-			const U32 num_verts_this_seg = verts_per_stack * (num_stacks_this_seg+1);
-			llassert(num_verts_this_seg <= max_verts);
-
-			const U32 num_indices_this_seg = 1+num_stacks_this_seg*(2+2*verts_per_stack);
-			llassert(num_indices_this_seg * sizeof(U16) <= max_buffer_bytes);
-
-			bool allocated = segment->allocateBuffer(num_verts_this_seg, num_indices_this_seg);
-#if RELEASE_SHOW_WARNS
-			if( !allocated )
-			{
-				LL_WARNS() << "Failed to allocate Vertex Buffer on update to "
-					<< num_verts_this_seg << " vertices and "
-					<< num_indices_this_seg << " indices" << LL_ENDL;
-			}
-#else
-			(void) allocated;
-#endif
-
-			// lock the buffer
-			bool success = segment->getVertexStrider(vertices)
-				&& segment->getTexCoord0Strider(texCoords)
-				&& segment->getIndexStrider(indices);
-
-#if RELEASE_SHOW_DEBUG
-			if(!success)
-			{
-				LL_ERRS() << "Failed updating WindLight sky geometry." << LL_ENDL;
-			}
-#else
-			(void) success;
-#endif
-
-			// fill it
-			buildStripsBuffer(begin_stack, end_stack, vertices, texCoords, indices, dome_radius, verts_per_stack, total_stacks);
-
-			// and unlock the buffer
-			segment->unmapBuffer();
-		}
-	
-#if RELEASE_SHOW_DEBUG
-		LL_INFOS() << "completed in " << llformat("%.2f", timer.getElapsedTimeF32().value()) << "seconds" << LL_ENDL;
-#endif
-	}
-
-	updateStarColors();
-	updateStarGeometry(drawable);
-
-	LLPipeline::sCompiles++;
-
-	return true;
-}
-
-void LLVOWLSky::drawStars(void)
-{
-	//  render the stars as a sphere centered at viewer camera 
-	if (mStarsVerts.notNull())
-	{
-		mStarsVerts->setBuffer();
-		mStarsVerts->drawArrays(LLRender::TRIANGLES, 0, getStarsNumVerts()*4);
-	}
-}
-
-void LLVOWLSky::drawFsSky(void)
-{
-    if (mFsSkyVerts.isNull())
-	{
-		updateGeometry(mDrawable);
-	}
-
-    LLGLDisable disable_blend(GL_BLEND);
-
-	mFsSkyVerts->setBuffer();
-	mFsSkyVerts->drawRange(LLRender::TRIANGLES, 0, mFsSkyVerts->getNumVerts() - 1, mFsSkyVerts->getNumIndices(), 0);
-	gPipeline.addTrianglesDrawn(mFsSkyVerts->getNumIndices());
-	LLVertexBuffer::unbind();
-}
-
-void LLVOWLSky::drawDome(void)
-{
-	if (mStripsVerts.empty())
-	{
-		updateGeometry(mDrawable);
-	}
-
-	LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
-
-	std::vector< LLPointer<LLVertexBuffer> >::const_iterator strips_vbo_iter, end_strips;
-	end_strips = mStripsVerts.end();
-	for(strips_vbo_iter = mStripsVerts.begin(); strips_vbo_iter != end_strips; ++strips_vbo_iter)
-	{
-		LLVertexBuffer * strips_segment = strips_vbo_iter->get();
-
-		strips_segment->setBuffer();
-
-		strips_segment->drawRange(
-			LLRender::TRIANGLE_STRIP, 
-			0, strips_segment->getNumVerts()-1, strips_segment->getNumIndices(), 
-			0);
-		gPipeline.addTrianglesDrawn(strips_segment->getNumIndices());
-	}
-
-	LLVertexBuffer::unbind();
-}
-
-void LLVOWLSky::initStars()
-{
-    const F32 DISTANCE_TO_STARS = LLEnvironment::instance().getCurrentSky()->getDomeRadius();
-
-	// Initialize star map
-	mStarVertices.resize(getStarsNumVerts());
-	mStarColors.resize(getStarsNumVerts());
-	mStarIntensities.resize(getStarsNumVerts());
-
-	std::vector<LLVector3>::iterator v_p = mStarVertices.begin();
-	std::vector<LLColor4>::iterator v_c = mStarColors.begin();
-	std::vector<F32>::iterator v_i = mStarIntensities.begin();
-
-	U32 i;
-
-	for (i = 0; i < getStarsNumVerts(); ++i)
-	{
-		v_p->mV[VX] = ll_frand() - 0.5f;
-		v_p->mV[VY] = ll_frand() - 0.5f;
-		
-		// we only want stars on the top half of the dome!
-
-		v_p->mV[VZ] = ll_frand()/2.f;
-
-		v_p->normVec();
-		*v_p *= DISTANCE_TO_STARS;
-		*v_i = llmin((F32)pow(ll_frand(),2.f) + 0.1f, 1.f);
-		v_c->mV[VRED]   = 0.75f + ll_frand() * 0.25f ;
-		v_c->mV[VGREEN] = 1.f ;
-		v_c->mV[VBLUE]  = 0.75f + ll_frand() * 0.25f ;
-		v_c->mV[VALPHA] = 1.f;
-		v_c->clamp();
-		v_p++;
-		v_c++;
-		v_i++;
-	}
-}
-
-void LLVOWLSky::buildStripsBuffer(U32 begin_stack,
-                                  U32 end_stack,
-                                  LLStrider<LLVector3> & vertices,
-                                  LLStrider<LLVector2> & texCoords,
-                                  LLStrider<U16> & indices,
-                                  const F32 dome_radius,
-                                  const U32& num_slices,
-                                  const U32& num_stacks)
-{
-	U32 i, j;
-	F32 phi0, theta, x0, y0, z0;
-	const F32 reciprocal_num_stacks = 1.f / num_stacks;
-
-	llassert(end_stack <= num_stacks);
-
-	// stacks are iterated one-indexed since phi(0) was handled by the fan above
-#if NEW_TESS
-	for(i = begin_stack; i <= end_stack; ++i) 
-#else
-    for(i = begin_stack + 1; i <= end_stack+1; ++i) 
-#endif
-	{
-		phi0 = calcPhi(i, reciprocal_num_stacks);
-
-		for(j = 0; j < num_slices; ++j)
-		{
-			theta = F_TWO_PI * (float(j) / float(num_slices));
-
-			// standard transformation from  spherical to
-			// rectangular coordinates
-			x0 = sin(phi0) * cos(theta);
-			y0 = cos(phi0);
-			z0 = sin(phi0) * sin(theta);
-
-#if NEW_TESS
-            *vertices++ = LLVector3(x0 * dome_radius, y0 * dome_radius, z0 * dome_radius);
-#else
-            if (i == num_stacks-2)
-			{
-				*vertices++ = LLVector3(x0*dome_radius, y0*dome_radius-1024.f*2.f, z0*dome_radius);
-			}
-			else if (i == num_stacks-1)
-			{
-				*vertices++ = LLVector3(0, y0*dome_radius-1024.f*2.f, 0);
-			}
-			else
-			{
-				*vertices++		= LLVector3(x0 * dome_radius, y0 * dome_radius, z0 * dome_radius);
-			}
-#endif
-
-			// generate planar uv coordinates
-			// note: x and z are transposed in order for things to animate
-			// correctly in the global coordinate system where +x is east and
-			// +y is north
-			*texCoords++	= LLVector2((-z0 + 1.f) / 2.f, (-x0 + 1.f) / 2.f);
-		}
-	}
-
-	//build triangle strip...
-	*indices++ = 0 ;
-
-	S32 k = 0 ;
-	for(i = 1; i <= end_stack - begin_stack; ++i) 
-	{
-		*indices++ = i * num_slices + k ;
-
-		k = (k+1) % num_slices ;
-		for(j = 0; j < num_slices ; ++j) 
-		{
-			*indices++ = (i-1) * num_slices + k ;
-			*indices++ = i * num_slices + k ;
-
-			k = (k+1) % num_slices ;
-		}
-
-		if((--k) < 0)
-		{
-			k = num_slices - 1 ;
-		}
-
-		*indices++ = i * num_slices + k ;
-	}
-}
-
-void LLVOWLSky::updateStarColors()
-{
-	std::vector<LLColor4>::iterator v_c = mStarColors.begin();
-	std::vector<F32>::iterator v_i = mStarIntensities.begin();
-	std::vector<LLVector3>::iterator v_p = mStarVertices.begin();
-
-	const F32 var = 0.15f;
-	const F32 min = 0.5f; //0.75f;
-	//const F32 sunclose_max = 0.6f;
-	//const F32 sunclose_range = 1 - sunclose_max;
-
-	//F32 below_horizon = - llmin(0.0f, gSky.mVOSkyp->getToSunLast().mV[2]);
-	//F32 brightness_factor = llmin(1.0f, below_horizon * 20);
-
-	static S32 swap = 0;
-	swap++;
-
-	if ((swap % 2) == 1)
-	{
-		F32 intensity;						//  max intensity of each star
-		U32 x;
-		for (x = 0; x < getStarsNumVerts(); ++x)
-		{
-			//F32 sundir_factor = 1;
-			LLVector3 tostar = *v_p;
-			tostar.normVec();
-			//const F32 how_close_to_sun = tostar * gSky.mVOSkyp->getToSunLast();
-			//if (how_close_to_sun > sunclose_max)
-			//{
-			//	sundir_factor = (1 - how_close_to_sun) / sunclose_range;
-			//}
-			intensity = *(v_i);
-			F32 alpha = v_c->mV[VALPHA] + (ll_frand() - 0.5f) * var * intensity;
-			if (alpha < min * intensity)
-			{
-				alpha = min * intensity;
-			}
-			if (alpha > intensity)
-			{
-				alpha = intensity;
-			}
-			//alpha *= brightness_factor * sundir_factor;
-
-			alpha = llclamp(alpha, 0.f, 1.f);
-			v_c->mV[VALPHA] = alpha;
-			v_c++;
-			v_i++;
-			v_p++;
-		}
-	}
-}
-
-bool LLVOWLSky::updateStarGeometry(LLDrawable *drawable)
-{
-	LLStrider<LLVector3> verticesp;
-	LLStrider<LLColor4U> colorsp;
-	LLStrider<LLVector2> texcoordsp;
-
-	if (mStarsVerts.isNull())
-	{
-		mStarsVerts = new LLVertexBuffer(LLDrawPoolWLSky::STAR_VERTEX_DATA_MASK);
-		if (!mStarsVerts->allocateBuffer(getStarsNumVerts()*6, 0))
-		{
-			LL_WARNS() << "Failed to allocate Vertex Buffer for Sky to " << getStarsNumVerts() * 6 << " vertices" << LL_ENDL;
-		}
-	}
- 
-	bool success = mStarsVerts->getVertexStrider(verticesp)
-		&& mStarsVerts->getColorStrider(colorsp)
-		&& mStarsVerts->getTexCoord0Strider(texcoordsp);
-
-	if(!success)
-	{
-		LL_ERRS() << "Failed updating star geometry." << LL_ENDL;
-	}
-
-	// *TODO: fix LLStrider with a real prefix increment operator so it can be
-	// used as a model of OutputIterator. -Brad
-	// std::copy(mStarVertices.begin(), mStarVertices.end(), verticesp);
-
-	if (mStarVertices.size() < getStarsNumVerts())
-	{
-		LL_ERRS() << "Star reference geometry insufficient." << LL_ENDL;
-	}
-
-	for (U32 vtx = 0; vtx < getStarsNumVerts(); ++vtx)
-	{
-		LLVector3 at = mStarVertices[vtx];
-		at.normVec();
-		LLVector3 left = at%LLVector3(0,0,1);
-		LLVector3 up = at%left;
-
-		F32 sc = 16.0f + (ll_frand() * 20.0f);
-		left *= sc;
-		up *= sc;
-
-		*(verticesp++)  = mStarVertices[vtx];
-		*(verticesp++) = mStarVertices[vtx]+up;
-		*(verticesp++) = mStarVertices[vtx]+left+up;
-		*(verticesp++)  = mStarVertices[vtx];
-		*(verticesp++) = mStarVertices[vtx]+left+up;
-		*(verticesp++) = mStarVertices[vtx]+left;
-
-		*(texcoordsp++) = LLVector2(1,0);
-		*(texcoordsp++) = LLVector2(1,1);
-		*(texcoordsp++) = LLVector2(0,1);
-		*(texcoordsp++) = LLVector2(1,0);
-		*(texcoordsp++) = LLVector2(0,1);
-		*(texcoordsp++) = LLVector2(0,0);
-
-		*(colorsp++)    = LLColor4U(mStarColors[vtx]);
-		*(colorsp++)    = LLColor4U(mStarColors[vtx]);
-		*(colorsp++)    = LLColor4U(mStarColors[vtx]);
-		*(colorsp++)    = LLColor4U(mStarColors[vtx]);
-		*(colorsp++)    = LLColor4U(mStarColors[vtx]);
-		*(colorsp++)    = LLColor4U(mStarColors[vtx]);
-	}
-
-	mStarsVerts->unmapBuffer();
-	return true;
-}
+/**

+ * @file llvowlsky.cpp

+ * @brief LLVOWLSky class implementation

+ *

+ * $LicenseInfo:firstyear=2007&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$

+ */

+

+#include "llviewerprecompiledheaders.h"

+

+#include "pipeline.h"

+

+#include "llvowlsky.h"

+#include "llsky.h"

+#include "lldrawpoolwlsky.h"

+#include "llface.h"

+#include "llviewercontrol.h"

+#include "llenvironment.h"

+#include "llsettingssky.h"

+

+constexpr U32 MIN_SKY_DETAIL = 8;

+constexpr U32 MAX_SKY_DETAIL = 180;

+

+inline U32 LLVOWLSky::getNumStacks(void)

+{

+    return llmin(MAX_SKY_DETAIL, llmax(MIN_SKY_DETAIL, gSavedSettings.getU32("WLSkyDetail")));

+}

+

+inline U32 LLVOWLSky::getNumSlices(void)

+{

+    return 2 * llmin(MAX_SKY_DETAIL, llmax(MIN_SKY_DETAIL, gSavedSettings.getU32("WLSkyDetail")));

+}

+

+inline U32 LLVOWLSky::getStripsNumVerts(void)

+{

+    return (getNumStacks() - 1) * getNumSlices();

+}

+

+inline U32 LLVOWLSky::getStripsNumIndices(void)

+{

+    return 2 * ((getNumStacks() - 2) * (getNumSlices() + 1)) + 1 ;

+}

+

+inline U32 LLVOWLSky::getStarsNumVerts(void)

+{

+    return 1000;

+}

+

+inline U32 LLVOWLSky::getStarsNumIndices(void)

+{

+    return 1000;

+}

+

+LLVOWLSky::LLVOWLSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)

+    : LLStaticViewerObject(id, pcode, regionp, true)

+{

+    initStars();

+}

+

+void LLVOWLSky::idleUpdate(LLAgent &agent, const F64 &time)

+{

+

+}

+

+bool LLVOWLSky::isActive(void) const

+{

+    return false;

+}

+

+LLDrawable * LLVOWLSky::createDrawable(LLPipeline * pipeline)

+{

+    pipeline->allocDrawable(this);

+

+    //LLDrawPoolWLSky *poolp = static_cast<LLDrawPoolWLSky *>(

+        gPipeline.getPool(LLDrawPool::POOL_WL_SKY);

+

+    mDrawable->setRenderType(LLPipeline::RENDER_TYPE_WL_SKY);

+

+    return mDrawable;

+}

+

+// a tiny helper function for controlling the sky dome tesselation.

+inline F32 calcPhi(const U32 &i, const F32 &reciprocal_num_stacks)

+{

+    // Calc: PI/8 * 1-((1-t^4)*(1-t^4))  { 0<t<1 }

+    // Demos: \pi/8*\left(1-((1-x^{4})*(1-x^{4}))\right)\ \left\{0<x\le1\right\}

+

+    // i should range from [0..SKY_STACKS] so t will range from [0.f .. 1.f]

+    F32 t = float(i) * reciprocal_num_stacks; //SL-16127: remove: / float(getNumStacks());

+

+    // ^4 the parameter of the tesselation to bias things toward 0 (the dome's apex)

+    t *= t;

+    t *= t;

+

+    // invert and square the parameter of the tesselation to bias things toward 1 (the horizon)

+    t = 1.f - t;

+    t = t*t;

+    t = 1.f - t;

+

+    return (F_PI / 8.f) * t;

+}

+

+void LLVOWLSky::resetVertexBuffers()

+{

+    mStripsVerts.clear();

+    mStarsVerts = nullptr;

+    mFsSkyVerts = nullptr;

+

+    gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL);

+}

+

+void LLVOWLSky::cleanupGL()

+{

+    mStripsVerts.clear();

+    mStarsVerts = nullptr;

+    mFsSkyVerts = nullptr;

+

+    LLDrawPoolWLSky::cleanupGL();

+}

+

+void LLVOWLSky::restoreGL()

+{

+    LLDrawPoolWLSky::restoreGL();

+    gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL);

+}

+

+bool LLVOWLSky::updateGeometry(LLDrawable * drawable)

+{

+    LL_PROFILE_ZONE_SCOPED;

+    LLStrider<LLVector3>    vertices;

+    LLStrider<LLVector2>    texCoords;

+    LLStrider<U16>          indices;

+

+    if (mFsSkyVerts.isNull())

+    {

+        mFsSkyVerts = new LLVertexBuffer(LLDrawPoolWLSky::ADV_ATMO_SKY_VERTEX_DATA_MASK);

+

+        if (!mFsSkyVerts->allocateBuffer(4, 6))

+        {

+            LL_WARNS() << "Failed to allocate Vertex Buffer on full screen sky update" << LL_ENDL;

+        }

+

+        bool success = mFsSkyVerts->getVertexStrider(vertices)

+                    && mFsSkyVerts->getTexCoord0Strider(texCoords)

+                    && mFsSkyVerts->getIndexStrider(indices);

+

+        if(!success)

+        {

+            LL_ERRS() << "Failed updating WindLight fullscreen sky geometry." << LL_ENDL;

+        }

+

+        *vertices++ = LLVector3(-1.0f, -1.0f, 0.0f);

+        *vertices++ = LLVector3( 1.0f, -1.0f, 0.0f);

+        *vertices++ = LLVector3(-1.0f,  1.0f, 0.0f);

+        *vertices++ = LLVector3( 1.0f,  1.0f, 0.0f);

+

+        *texCoords++ = LLVector2(0.0f, 0.0f);

+        *texCoords++ = LLVector2(1.0f, 0.0f);

+        *texCoords++ = LLVector2(0.0f, 1.0f);

+        *texCoords++ = LLVector2(1.0f, 1.0f);

+

+        *indices++ = 0;

+        *indices++ = 1;

+        *indices++ = 2;

+        *indices++ = 1;

+        *indices++ = 3;

+        *indices++ = 2;

+

+        mFsSkyVerts->unmapBuffer();

+    }

+

+    {

+        const F32 dome_radius = LLEnvironment::instance().getCurrentSky()->getDomeRadius();

+

+        const U32 max_buffer_bytes = gSavedSettings.getS32("RenderMaxVBOSize")*1024;

+        const U32 data_mask = LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK;

+        const U32 max_verts = max_buffer_bytes / LLVertexBuffer::calcVertexSize(data_mask);

+

+        const U32 total_stacks = getNumStacks();

+

+        const U32 verts_per_stack = getNumSlices();

+

+        // each seg has to have one more row of verts than it has stacks

+        // then round down

+        const U32 stacks_per_seg = (max_verts - verts_per_stack) / verts_per_stack;

+

+        // round up to a whole number of segments

+        const U32 strips_segments = (total_stacks+stacks_per_seg-1) / stacks_per_seg;

+

+        mStripsVerts.resize(strips_segments, NULL);

+

+#if RELEASE_SHOW_DEBUG

+        LL_INFOS() << "WL Skydome strips in " << strips_segments << " batches." << LL_ENDL;

+

+        LLTimer timer;

+        timer.start();

+#endif

+

+        for (U32 i = 0; i < strips_segments ;++i)

+        {

+            LLVertexBuffer * segment = new LLVertexBuffer(LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK);

+            mStripsVerts[i] = segment;

+

+            U32 num_stacks_this_seg = stacks_per_seg;

+            if ((i == strips_segments - 1) && (total_stacks % stacks_per_seg) != 0)

+            {

+                // for the last buffer only allocate what we'll use

+                num_stacks_this_seg = total_stacks % stacks_per_seg;

+            }

+

+            // figure out what range of the sky we're filling

+            const U32 begin_stack = i * stacks_per_seg;

+            const U32 end_stack = begin_stack + num_stacks_this_seg;

+            llassert(end_stack <= total_stacks);

+

+            const U32 num_verts_this_seg = verts_per_stack * (num_stacks_this_seg+1);

+            llassert(num_verts_this_seg <= max_verts);

+

+            const U32 num_indices_this_seg = 1+num_stacks_this_seg*(2+2*verts_per_stack);

+            llassert(num_indices_this_seg * sizeof(U16) <= max_buffer_bytes);

+

+            bool allocated = segment->allocateBuffer(num_verts_this_seg, num_indices_this_seg);

+#if RELEASE_SHOW_WARNS

+            if( !allocated )

+            {

+                LL_WARNS() << "Failed to allocate Vertex Buffer on update to "

+                    << num_verts_this_seg << " vertices and "

+                    << num_indices_this_seg << " indices" << LL_ENDL;

+            }

+#else

+            (void) allocated;

+#endif

+

+            // lock the buffer

+            bool success = segment->getVertexStrider(vertices)

+                && segment->getTexCoord0Strider(texCoords)

+                && segment->getIndexStrider(indices);

+

+#if RELEASE_SHOW_DEBUG

+            if(!success)

+            {

+                LL_ERRS() << "Failed updating WindLight sky geometry." << LL_ENDL;

+            }

+#else

+            (void) success;

+#endif

+

+            // fill it

+            buildStripsBuffer(begin_stack, end_stack, vertices, texCoords, indices, dome_radius, verts_per_stack, total_stacks);

+

+            // and unlock the buffer

+            segment->unmapBuffer();

+        }

+

+#if RELEASE_SHOW_DEBUG

+        LL_INFOS() << "completed in " << llformat("%.2f", timer.getElapsedTimeF32().value()) << "seconds" << LL_ENDL;

+#endif

+    }

+

+    updateStarColors();

+    updateStarGeometry(drawable);

+

+    LLPipeline::sCompiles++;

+

+    return true;

+}

+

+void LLVOWLSky::drawStars(void)

+{

+    //  render the stars as a sphere centered at viewer camera

+    if (mStarsVerts.notNull())

+    {

+        mStarsVerts->setBuffer();

+        mStarsVerts->drawArrays(LLRender::TRIANGLES, 0, getStarsNumVerts()*4);

+    }

+}

+

+void LLVOWLSky::drawFsSky(void)

+{

+    if (mFsSkyVerts.isNull())

+    {

+        updateGeometry(mDrawable);

+    }

+

+    LLGLDisable disable_blend(GL_BLEND);

+

+    mFsSkyVerts->setBuffer();

+    mFsSkyVerts->drawRange(LLRender::TRIANGLES, 0, mFsSkyVerts->getNumVerts() - 1, mFsSkyVerts->getNumIndices(), 0);

+    gPipeline.addTrianglesDrawn(mFsSkyVerts->getNumIndices());

+    LLVertexBuffer::unbind();

+}

+

+void LLVOWLSky::drawDome(void)

+{

+    if (mStripsVerts.empty())

+    {

+        updateGeometry(mDrawable);

+    }

+

+    LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);

+

+    std::vector< LLPointer<LLVertexBuffer> >::const_iterator strips_vbo_iter, end_strips;

+    end_strips = mStripsVerts.end();

+    for(strips_vbo_iter = mStripsVerts.begin(); strips_vbo_iter != end_strips; ++strips_vbo_iter)

+    {

+        LLVertexBuffer * strips_segment = strips_vbo_iter->get();

+

+        strips_segment->setBuffer();

+

+        strips_segment->drawRange(

+            LLRender::TRIANGLE_STRIP,

+            0, strips_segment->getNumVerts()-1, strips_segment->getNumIndices(),

+            0);

+        gPipeline.addTrianglesDrawn(strips_segment->getNumIndices());

+    }

+

+    LLVertexBuffer::unbind();

+}

+

+void LLVOWLSky::initStars()

+{

+    const F32 DISTANCE_TO_STARS = LLEnvironment::instance().getCurrentSky()->getDomeRadius();

+

+    // Initialize star map

+    mStarVertices.resize(getStarsNumVerts());

+    mStarColors.resize(getStarsNumVerts());

+    mStarIntensities.resize(getStarsNumVerts());

+

+    std::vector<LLVector3>::iterator v_p = mStarVertices.begin();

+    std::vector<LLColor4>::iterator v_c = mStarColors.begin();

+    std::vector<F32>::iterator v_i = mStarIntensities.begin();

+

+    U32 i;

+

+    for (i = 0; i < getStarsNumVerts(); ++i)

+    {

+        v_p->mV[VX] = ll_frand() - 0.5f;

+        v_p->mV[VY] = ll_frand() - 0.5f;

+

+        // we only want stars on the top half of the dome!

+

+        v_p->mV[VZ] = ll_frand()/2.f;

+

+        v_p->normVec();

+        *v_p *= DISTANCE_TO_STARS;

+        *v_i = llmin((F32)pow(ll_frand(),2.f) + 0.1f, 1.f);

+        v_c->mV[VRED]   = 0.75f + ll_frand() * 0.25f ;

+        v_c->mV[VGREEN] = 1.f ;

+        v_c->mV[VBLUE]  = 0.75f + ll_frand() * 0.25f ;

+        v_c->mV[VALPHA] = 1.f;

+        v_c->clamp();

+        v_p++;

+        v_c++;

+        v_i++;

+    }

+}

+

+void LLVOWLSky::buildStripsBuffer(U32 begin_stack,

+                                  U32 end_stack,

+                                  LLStrider<LLVector3> & vertices,

+                                  LLStrider<LLVector2> & texCoords,

+                                  LLStrider<U16> & indices,

+                                  const F32 dome_radius,

+                                  const U32& num_slices,

+                                  const U32& num_stacks)

+{

+    U32 i, j;

+    F32 phi0, theta, x0, y0, z0;

+    const F32 reciprocal_num_stacks = 1.f / num_stacks;

+

+    llassert(end_stack <= num_stacks);

+

+    // stacks are iterated one-indexed since phi(0) was handled by the fan above

+#if NEW_TESS

+    for(i = begin_stack; i <= end_stack; ++i)

+#else

+    for(i = begin_stack + 1; i <= end_stack+1; ++i)

+#endif

+    {

+        phi0 = calcPhi(i, reciprocal_num_stacks);

+

+        for(j = 0; j < num_slices; ++j)

+        {

+            theta = F_TWO_PI * (float(j) / float(num_slices));

+

+            // standard transformation from  spherical to

+            // rectangular coordinates

+            x0 = sin(phi0) * cos(theta);

+            y0 = cos(phi0);

+            z0 = sin(phi0) * sin(theta);

+

+#if NEW_TESS

+            *vertices++ = LLVector3(x0 * dome_radius, y0 * dome_radius, z0 * dome_radius);

+#else

+            if (i == num_stacks-2)

+            {

+                *vertices++ = LLVector3(x0*dome_radius, y0*dome_radius-1024.f*2.f, z0*dome_radius);

+            }

+            else if (i == num_stacks-1)

+            {

+                *vertices++ = LLVector3(0, y0*dome_radius-1024.f*2.f, 0);

+            }

+            else

+            {

+                *vertices++     = LLVector3(x0 * dome_radius, y0 * dome_radius, z0 * dome_radius);

+            }

+#endif

+

+            // generate planar uv coordinates

+            // note: x and z are transposed in order for things to animate

+            // correctly in the global coordinate system where +x is east and

+            // +y is north

+            *texCoords++    = LLVector2((-z0 + 1.f) / 2.f, (-x0 + 1.f) / 2.f);

+        }

+    }

+

+    //build triangle strip...

+    *indices++ = 0 ;

+

+    S32 k = 0 ;

+    for(i = 1; i <= end_stack - begin_stack; ++i)

+    {

+        *indices++ = i * num_slices + k ;

+

+        k = (k+1) % num_slices ;

+        for(j = 0; j < num_slices ; ++j)

+        {

+            *indices++ = (i-1) * num_slices + k ;

+            *indices++ = i * num_slices + k ;

+

+            k = (k+1) % num_slices ;

+        }

+

+        if((--k) < 0)

+        {

+            k = num_slices - 1 ;

+        }

+

+        *indices++ = i * num_slices + k ;

+    }

+}

+

+void LLVOWLSky::updateStarColors()

+{

+    std::vector<LLColor4>::iterator v_c = mStarColors.begin();

+    std::vector<F32>::iterator v_i = mStarIntensities.begin();

+    std::vector<LLVector3>::iterator v_p = mStarVertices.begin();

+

+    const F32 var = 0.15f;

+    const F32 min = 0.5f; //0.75f;

+    //const F32 sunclose_max = 0.6f;

+    //const F32 sunclose_range = 1 - sunclose_max;

+

+    //F32 below_horizon = - llmin(0.0f, gSky.mVOSkyp->getToSunLast().mV[2]);

+    //F32 brightness_factor = llmin(1.0f, below_horizon * 20);

+

+    static S32 swap = 0;

+    swap++;

+

+    if ((swap % 2) == 1)

+    {

+        F32 intensity;                      //  max intensity of each star

+        U32 x;

+        for (x = 0; x < getStarsNumVerts(); ++x)

+        {

+            //F32 sundir_factor = 1;

+            LLVector3 tostar = *v_p;

+            tostar.normVec();

+            //const F32 how_close_to_sun = tostar * gSky.mVOSkyp->getToSunLast();

+            //if (how_close_to_sun > sunclose_max)

+            //{

+            //  sundir_factor = (1 - how_close_to_sun) / sunclose_range;

+            //}

+            intensity = *(v_i);

+            F32 alpha = v_c->mV[VALPHA] + (ll_frand() - 0.5f) * var * intensity;

+            if (alpha < min * intensity)

+            {

+                alpha = min * intensity;

+            }

+            if (alpha > intensity)

+            {

+                alpha = intensity;

+            }

+            //alpha *= brightness_factor * sundir_factor;

+

+            alpha = llclamp(alpha, 0.f, 1.f);

+            v_c->mV[VALPHA] = alpha;

+            v_c++;

+            v_i++;

+            v_p++;

+        }

+    }

+}

+

+bool LLVOWLSky::updateStarGeometry(LLDrawable *drawable)

+{

+    LLStrider<LLVector3> verticesp;

+    LLStrider<LLColor4U> colorsp;

+    LLStrider<LLVector2> texcoordsp;

+

+    if (mStarsVerts.isNull())

+    {

+        mStarsVerts = new LLVertexBuffer(LLDrawPoolWLSky::STAR_VERTEX_DATA_MASK);

+        if (!mStarsVerts->allocateBuffer(getStarsNumVerts()*6, 0))

+        {

+            LL_WARNS() << "Failed to allocate Vertex Buffer for Sky to " << getStarsNumVerts() * 6 << " vertices" << LL_ENDL;

+        }

+    }

+

+    bool success = mStarsVerts->getVertexStrider(verticesp)

+        && mStarsVerts->getColorStrider(colorsp)

+        && mStarsVerts->getTexCoord0Strider(texcoordsp);

+

+    if(!success)

+    {

+        LL_ERRS() << "Failed updating star geometry." << LL_ENDL;

+    }

+

+    // *TODO: fix LLStrider with a real prefix increment operator so it can be

+    // used as a model of OutputIterator. -Brad

+    // std::copy(mStarVertices.begin(), mStarVertices.end(), verticesp);

+

+    if (mStarVertices.size() < getStarsNumVerts())

+    {

+        LL_ERRS() << "Star reference geometry insufficient." << LL_ENDL;

+    }

+

+    for (U32 vtx = 0; vtx < getStarsNumVerts(); ++vtx)

+    {

+        LLVector3 at = mStarVertices[vtx];

+        at.normVec();

+        LLVector3 left = at%LLVector3(0,0,1);

+        LLVector3 up = at%left;

+

+        F32 sc = 16.0f + (ll_frand() * 20.0f);

+        left *= sc;

+        up *= sc;

+

+        *(verticesp++)  = mStarVertices[vtx];

+        *(verticesp++) = mStarVertices[vtx]+up;

+        *(verticesp++) = mStarVertices[vtx]+left+up;

+        *(verticesp++)  = mStarVertices[vtx];

+        *(verticesp++) = mStarVertices[vtx]+left+up;

+        *(verticesp++) = mStarVertices[vtx]+left;

+

+        *(texcoordsp++) = LLVector2(1,0);

+        *(texcoordsp++) = LLVector2(1,1);

+        *(texcoordsp++) = LLVector2(0,1);

+        *(texcoordsp++) = LLVector2(1,0);

+        *(texcoordsp++) = LLVector2(0,1);

+        *(texcoordsp++) = LLVector2(0,0);

+

+        *(colorsp++)    = LLColor4U(mStarColors[vtx]);

+        *(colorsp++)    = LLColor4U(mStarColors[vtx]);

+        *(colorsp++)    = LLColor4U(mStarColors[vtx]);

+        *(colorsp++)    = LLColor4U(mStarColors[vtx]);

+        *(colorsp++)    = LLColor4U(mStarColors[vtx]);

+        *(colorsp++)    = LLColor4U(mStarColors[vtx]);

+    }

+

+    mStarsVerts->unmapBuffer();

+    return true;

+}