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, 757 insertions, 757 deletions

diff --git a/indra/newview/llscenemonitor.cpp b/indra/newview/llscenemonitor.cpp
index 1c1577a7e5..5f7adfec90 100644
--- a/indra/newview/llscenemonitor.cpp
+++ b/indra/newview/llscenemonitor.cpp
@@ -1,757 +1,757 @@
-/** 
- * @file llscenemonitor.cpp
- * @brief monitor the scene loading process.
- *
- * $LicenseInfo:firstyear=2003&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 "llrendertarget.h"
-#include "llscenemonitor.h"
-#include "llviewerwindow.h"
-#include "llviewerdisplay.h"
-#include "llviewercontrol.h"
-#include "llviewershadermgr.h"
-#include "llui.h"
-#include "llstartup.h"
-#include "llappviewer.h"
-#include "llwindow.h"
-#include "llpointer.h"
-#include "llspatialpartition.h"
-#include "llagent.h"
-#include "pipeline.h"
-#include "llviewerparcelmgr.h"
-#include "llviewerpartsim.h"
-
-LLSceneMonitorView* gSceneMonitorView = NULL;
-
-//
-//The procedures of monitoring when the scene finishes loading visually, 
-//i.e., no pixel differences among frames, are:
-//1, freeze all dynamic objects and avatars;
-//2, (?) disable all sky and water;
-//3, capture frames periodically, by calling "capture()";
-//4, compute pixel differences between two latest captured frames, by calling "compare()", results are stored at mDiff;
-//5, compute the number of pixels in mDiff above some tolerance threshold in GPU, by calling "calcDiffAggregate()";
-//6, use gl occlusion query to fetch the result from GPU, by calling "fetchQueryResult()";
-//END.
-//
-
-LLSceneMonitor::LLSceneMonitor() : 
-	mEnabled(false), 
-	mDiff(NULL),
-	mDiffResult(0.f),
-	mDiffTolerance(0.1f),
-	mDiffState(WAITING_FOR_NEXT_DIFF),
-	mDebugViewerVisible(false),
-	mQueryObject(0),
-	mDiffPixelRatio(0.5f)
-{
-	mFrames[0] = NULL;
-	mFrames[1] = NULL;
-}
-
-LLSceneMonitor::~LLSceneMonitor()
-{
-	mDiffState = VIEWER_QUITTING;
-	reset();
-
-	mDitheringTexture = NULL;
-}
-
-void LLSceneMonitor::reset()
-{
-	delete mFrames[0];
-	delete mFrames[1];
-	delete mDiff;
-
-	mFrames[0] = NULL;
-	mFrames[1] = NULL;
-	mDiff = NULL;
-
-	mMonitorRecording.reset();
-	mSceneLoadRecording.reset();
-	mRecordingTimer.reset();
-
-	unfreezeScene();
-
-	if(mQueryObject > 0)
-	{
-		LLOcclusionCullingGroup::releaseOcclusionQueryObjectName(mQueryObject);
-		mQueryObject = 0;
-	}
-}
-
-void LLSceneMonitor::generateDitheringTexture(S32 width, S32 height)
-{
-#if 1
-	//4 * 4 matrix
-	mDitherMatrixWidth = 4;	
-	S32 dither_matrix[4][4] = 
-	{
-		{1, 9, 3, 11}, 
-		{13, 5, 15, 7}, 
-		{4, 12, 2, 10}, 
-		{16, 8, 14, 6}
-	};
-	
-	mDitherScale = 255.f / 17;
-#else
-	//8 * 8 matrix
-	mDitherMatrixWidth = 16;	
-	S32 dither_matrix[16][16] = 
-	{
-		{1, 49, 13, 61, 4, 52, 16, 64, 1, 49, 13, 61, 4, 52, 16, 64}, 
-		{33, 17, 45, 29, 36, 20, 48, 32, 33, 17, 45, 29, 36, 20, 48, 32}, 
-		{9, 57, 5, 53, 12, 60, 8, 56, 9, 57, 5, 53, 12, 60, 8, 56}, 
-		{41, 25, 37, 21, 44, 28, 40, 24, 41, 25, 37, 21, 44, 28, 40, 24},
-		{3, 51, 15, 63, 2, 50, 14, 62, 3, 51, 15, 63, 2, 50, 14, 62},
-		{35, 19, 47, 31, 34, 18, 46, 30, 35, 19, 47, 31, 34, 18, 46, 30},
-		{11, 59, 7, 55, 10, 58, 6, 54, 11, 59, 7, 55, 10, 58, 6, 54},
-		{43, 27, 39, 23, 42, 26, 38, 22, 43, 27, 39, 23, 42, 26, 38, 22},
-		{1, 49, 13, 61, 4, 52, 16, 64, 1, 49, 13, 61, 4, 52, 16, 64}, 
-		{33, 17, 45, 29, 36, 20, 48, 32, 33, 17, 45, 29, 36, 20, 48, 32}, 
-		{9, 57, 5, 53, 12, 60, 8, 56, 9, 57, 5, 53, 12, 60, 8, 56}, 
-		{41, 25, 37, 21, 44, 28, 40, 24, 41, 25, 37, 21, 44, 28, 40, 24},
-		{3, 51, 15, 63, 2, 50, 14, 62, 3, 51, 15, 63, 2, 50, 14, 62},
-		{35, 19, 47, 31, 34, 18, 46, 30, 35, 19, 47, 31, 34, 18, 46, 30},
-		{11, 59, 7, 55, 10, 58, 6, 54, 11, 59, 7, 55, 10, 58, 6, 54},
-		{43, 27, 39, 23, 42, 26, 38, 22, 43, 27, 39, 23, 42, 26, 38, 22}
-	};
-
-	mDitherScale = 255.f / 65;
-#endif
-
-	LLPointer<LLImageRaw> image_raw = new LLImageRaw(mDitherMatrixWidth, mDitherMatrixWidth, 3);
-	U8* data = image_raw->getData();
-	for (S32 i = 0; i < mDitherMatrixWidth; i++)
-	{
-		for (S32 j = 0; j < mDitherMatrixWidth; j++)
-		{
-			U8 val = dither_matrix[i][j];
-			*data++ = val;
-			*data++ = val;
-			*data++ = val;
-		}
-	}
-
-	mDitheringTexture = LLViewerTextureManager::getLocalTexture(image_raw.get(), false) ;
-	mDitheringTexture->setAddressMode(LLTexUnit::TAM_WRAP);
-	mDitheringTexture->setFilteringOption(LLTexUnit::TFO_POINT);
-	
-	mDitherScaleS = (F32)width / mDitherMatrixWidth;
-	mDitherScaleT = (F32)height / mDitherMatrixWidth;
-}
-
-void LLSceneMonitor::setDebugViewerVisible(bool visible) 
-{
-	mDebugViewerVisible = visible;
-}
-
-LLRenderTarget& LLSceneMonitor::getCaptureTarget()
-{
-	LLRenderTarget* cur_target = NULL;
-
-	S32 width = gViewerWindow->getWorldViewWidthRaw();
-	S32 height = gViewerWindow->getWorldViewHeightRaw();
-	
-	if(!mFrames[0])
-	{
-		mFrames[0] = new LLRenderTarget();
-		mFrames[0]->allocate(width, height, GL_RGB);
-		gGL.getTexUnit(0)->bind(mFrames[0]);
-		gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
-		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
-		cur_target = mFrames[0];
-	}
-	else if(!mFrames[1])
-	{
-		mFrames[1] = new LLRenderTarget();
-		mFrames[1]->allocate(width, height, GL_RGB);
-		gGL.getTexUnit(0)->bind(mFrames[1]);
-		gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
-		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
-		cur_target = mFrames[1];
-	}
-	else //swap
-	{
-		cur_target = mFrames[0];
-		mFrames[0] = mFrames[1];
-		mFrames[1] = cur_target;
-	}
-	
-	if(cur_target->getWidth() != width || cur_target->getHeight() != height) //size changed
-	{
-		cur_target->resize(width, height);
-	}
-
-	// we're promising the target exists
-	return *cur_target;
-}
-
-void LLSceneMonitor::freezeAvatar(LLCharacter* avatarp)
-{
-	if(mEnabled)
-	{
-		mAvatarPauseHandles.push_back(avatarp->requestPause());
-	}
-}
-
-void LLSceneMonitor::freezeScene()
-{
-	if(!mEnabled)
-	{
-		return;
-	}
-
-	//freeze all avatars
-	for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
-		iter != LLCharacter::sInstances.end(); ++iter)
-	{
-		freezeAvatar((LLCharacter*)(*iter));
-	}
-
-	// freeze everything else
-	gSavedSettings.setBOOL("FreezeTime", true);
-
-	//disable sky, water and clouds
-	gPipeline.clearRenderTypeMask(LLPipeline::RENDER_TYPE_SKY, LLPipeline::RENDER_TYPE_WL_SKY, 
-		LLPipeline::RENDER_TYPE_WATER, LLPipeline::RENDER_TYPE_CLOUDS, LLPipeline::END_RENDER_TYPES);
-
-	//disable particle system
-	LLViewerPartSim::getInstance()->enable(false);
-}
-
-void LLSceneMonitor::unfreezeScene()
-{
-	//thaw all avatars
-	mAvatarPauseHandles.clear();
-
-	if(mDiffState == VIEWER_QUITTING)
-	{
-		return;
-	}
-
-	// thaw everything else
-	gSavedSettings.setBOOL("FreezeTime", false);
-
-	//enable sky, water and clouds
-	gPipeline.setRenderTypeMask(LLPipeline::RENDER_TYPE_SKY, LLPipeline::RENDER_TYPE_WL_SKY, 
-		LLPipeline::RENDER_TYPE_WATER, LLPipeline::RENDER_TYPE_CLOUDS, LLPipeline::END_RENDER_TYPES);
-
-	//enable particle system
-	LLViewerPartSim::getInstance()->enable(true);
-}
-
-void LLSceneMonitor::capture()
-{
-	static U32 last_capture_frame = 0;
-	static LLCachedControl<bool> monitor_enabled(gSavedSettings, "SceneLoadingMonitorEnabled");
-	static LLCachedControl<F32>  scene_load_sample_time(gSavedSettings, "SceneLoadingMonitorSampleTime");
-	static bool force_capture = true;
-
-	bool enabled = monitor_enabled || mDebugViewerVisible;
-	if(mEnabled != enabled)
-	{
-		if(mEnabled)
-		{			
-			mEnabled = enabled;
-			unfreezeScene();
-			reset();
-			force_capture = true;
-		}
-		else
-		{
-			mEnabled = enabled;
-			reset();
-			freezeScene();
-		}
-	}
-
-	if (mEnabled 
-		&& (mMonitorRecording.getSum(*LLViewerCamera::getVelocityStat()) > 0.1f
-			|| mMonitorRecording.getSum(*LLViewerCamera::getAngularVelocityStat()) > 0.05f))
-	{
-		reset();
-		freezeScene();
-		force_capture = true;
-	}
-
-	if(mEnabled
-		&& (mRecordingTimer.getElapsedTimeF32() > scene_load_sample_time() 
-			|| force_capture)
-		&& last_capture_frame != gFrameCount)
-	{
-		force_capture = false;
-
-		mSceneLoadRecording.resume();
-		mMonitorRecording.resume();
-
-		last_capture_frame = gFrameCount;
-
-		LLRenderTarget& cur_target = getCaptureTarget();
-
-		U32 old_FBO = LLRenderTarget::sCurFBO;
-
-		gGL.getTexUnit(0)->bind(&cur_target);
-		glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); //point to the main frame buffer.
-		
-		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, cur_target.getWidth(), cur_target.getHeight()); //copy the content
-	
-		glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
-		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);		
-		glBindFramebuffer(GL_FRAMEBUFFER, old_FBO);
-
-		mDiffState = NEED_DIFF;
-	}
-}
-
-bool LLSceneMonitor::needsUpdate() const
-{
-	return mDiffState == NEED_DIFF;
-}
-
-static LLStaticHashedString sDitherScale("dither_scale");
-static LLStaticHashedString sDitherScaleS("dither_scale_s");
-static LLStaticHashedString sDitherScaleT("dither_scale_t");
-
-void LLSceneMonitor::compare()
-{
-#ifdef LL_WINDOWS
-	if(mDiffState != NEED_DIFF)
-	{
-		return;
-	}
-
-	if(!mFrames[0] || !mFrames[1])
-	{
-		return;
-	}
-	if(mFrames[0]->getWidth() != mFrames[1]->getWidth() || mFrames[0]->getHeight() != mFrames[1]->getHeight())
-	{	//size does not match
-		return; 
-	}
-
-	mDiffState = EXECUTE_DIFF;
-
-	S32 width = gViewerWindow->getWindowWidthRaw();
-	S32 height = gViewerWindow->getWindowHeightRaw();
-	if(!mDiff)
-	{
-		mDiff = new LLRenderTarget();
-		mDiff->allocate(width, height, GL_RGBA);
-
-		generateDitheringTexture(width, height);
-	}
-	else if(mDiff->getWidth() != width || mDiff->getHeight() != height)
-	{
-		mDiff->resize(width, height);
-		generateDitheringTexture(width, height);
-	}
-
-	mDiff->bindTarget();
-	mDiff->clear();
-	
-	gTwoTextureCompareProgram.bind();
-	
-	gTwoTextureCompareProgram.uniform1f(sDitherScale, mDitherScale);
-	gTwoTextureCompareProgram.uniform1f(sDitherScaleS, mDitherScaleS);
-	gTwoTextureCompareProgram.uniform1f(sDitherScaleT, mDitherScaleT);
-
-	gGL.getTexUnit(0)->activate();
-	gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(0)->bind(mFrames[0]);
-	gGL.getTexUnit(0)->activate();
-
-	gGL.getTexUnit(1)->activate();
-	gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(1)->bind(mFrames[1]);
-	gGL.getTexUnit(1)->activate();	
-	
-	gGL.getTexUnit(2)->activate();
-	gGL.getTexUnit(2)->enable(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(2)->bind(mDitheringTexture);
-	gGL.getTexUnit(2)->activate();	
-
-	gl_rect_2d_simple_tex(width, height);
-	
-	mDiff->flush();	
-
-	gTwoTextureCompareProgram.unbind();
-
-	gGL.getTexUnit(0)->disable();
-	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(1)->disable();
-	gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(2)->disable();
-	gGL.getTexUnit(2)->unbind(LLTexUnit::TT_TEXTURE);
-
-	if (!mDebugViewerVisible)
-	{
-		calcDiffAggregate();
-	}
-#endif
-}
-
-static LLStaticHashedString sTolerance("tolerance");
-
-//calculate Diff aggregate information in GPU, and enable gl occlusion query to capture it.
-void LLSceneMonitor::calcDiffAggregate()
-{
-#ifdef LL_WINDOWS
-
-	if(mDiffState != EXECUTE_DIFF && !mDebugViewerVisible)
-	{
-		return;
-	}	
-
-	if(!mQueryObject)
-	{
-		mQueryObject = LLOcclusionCullingGroup::getNewOcclusionQueryObjectName();
-	}
-
-	LLGLDepthTest depth(true, false, GL_ALWAYS);
-	if(!mDebugViewerVisible)
-	{
-		glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-	}
-
-	LLGLSLShader* cur_shader = NULL;
-	
-	cur_shader = LLGLSLShader::sCurBoundShaderPtr;
-	gOneTextureFilterProgram.bind();
-	gOneTextureFilterProgram.uniform1f(sTolerance, mDiffTolerance);
-
-	if(mDiffState == EXECUTE_DIFF)
-	{
-		glBeginQuery(GL_SAMPLES_PASSED, mQueryObject);
-	}
-
-	gl_draw_scaled_target(0, 0, S32(mDiff->getWidth() * mDiffPixelRatio), S32(mDiff->getHeight() * mDiffPixelRatio), mDiff);
-
-	if(mDiffState == EXECUTE_DIFF)
-	{
-		glEndQuery(GL_SAMPLES_PASSED);
-		mDiffState = WAIT_ON_RESULT;
-	}
-		
-	gOneTextureFilterProgram.unbind();
-	
-	if(cur_shader != NULL)
-	{
-		cur_shader->bind();
-	}
-	
-	if(!mDebugViewerVisible)
-	{
-		glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-	}
-#endif
-}
-
-static LLTrace::EventStatHandle<> sFramePixelDiff("FramePixelDifference");
-void LLSceneMonitor::fetchQueryResult()
-{
-	// also throttle timing here, to avoid going below sample time due to phasing with frame capture
-	static LLCachedControl<F32>  scene_load_sample_time_control(gSavedSettings, "SceneLoadingMonitorSampleTime");
-	F32Seconds scene_load_sample_time = (F32Seconds)scene_load_sample_time_control();
-
-	if(mDiffState == WAIT_ON_RESULT 
-		&& !LLAppViewer::instance()->quitRequested())
-	{
-		mDiffState = WAITING_FOR_NEXT_DIFF;
-
-		GLuint available = 0;
-		glGetQueryObjectuiv(mQueryObject, GL_QUERY_RESULT_AVAILABLE, &available);
-		if(available)
-		{
-			GLuint count = 0;
-			glGetQueryObjectuiv(mQueryObject, GL_QUERY_RESULT, &count);
-	
-			mDiffResult = sqrtf(count * 0.5f / (mDiff->getWidth() * mDiff->getHeight() * mDiffPixelRatio * mDiffPixelRatio)); //0.5 -> (front face + back face)
-
-			LL_DEBUGS("SceneMonitor") << "Frame difference: " << mDiffResult << LL_ENDL;
-			record(sFramePixelDiff, mDiffResult);
-
-			static LLCachedControl<F32> diff_threshold(gSavedSettings,"SceneLoadingMonitorPixelDiffThreshold");
-			F32Seconds elapsed_time = mRecordingTimer.getElapsedTimeF32();
-
-			if (elapsed_time > scene_load_sample_time)
-			{
-				if(mDiffResult > diff_threshold())
-				{
-					mSceneLoadRecording.extend();
-					llassert_always(mSceneLoadRecording.getResults().getLastRecording().getDuration() > scene_load_sample_time);
-				}
-				else
-				{
-					mSceneLoadRecording.nextPeriod();
-				}
-				mRecordingTimer.reset();
-			}
-		}
-	}
-}
-
-//dump results to a file _scene_xmonitor_results.csv
-void LLSceneMonitor::dumpToFile(const std::string &file_name)
-{
-	if (!hasResults()) return;
-
-	LL_INFOS("SceneMonitor") << "Saving scene load stats to " << file_name << LL_ENDL; 
-	try
-	{
-		llofstream os(file_name.c_str());
-
-		os << std::setprecision(10);
-
-		LLTrace::PeriodicRecording& scene_load_recording = mSceneLoadRecording.getResults();
-		const U32 frame_count = scene_load_recording.getNumRecordedPeriods();
-
-		F64Seconds frame_time;
-
-		os << "Stat";
-		for (S32 frame = 1; frame <= frame_count; frame++)
-		{
-			frame_time += scene_load_recording.getPrevRecording(frame_count - frame).getDuration();
-			os << ", " << frame_time.value();
-		}
-		os << '\n';
-
-		os << "Sample period(s)";
-		for (S32 frame = 1; frame <= frame_count; frame++)
-		{
-			frame_time = scene_load_recording.getPrevRecording(frame_count - frame).getDuration();
-			os << ", " << frame_time.value();
-		}
-		os << '\n';
-
-
-		typedef LLTrace::StatType<LLTrace::CountAccumulator> trace_count;
-		for (auto& it : trace_count::instance_snapshot())
-		{
-			std::ostringstream row;
-			row << std::setprecision(10);
-
-			row << it.getName();
-
-			const char* unit_label = it.getUnitLabel();
-			if (unit_label[0])
-			{
-				row << "(" << unit_label << ")";
-			}
-
-			S32 samples = 0;
-
-			for (S32 frame = 1; frame <= frame_count; frame++)
-			{
-				LLTrace::Recording& recording = scene_load_recording.getPrevRecording(frame_count - frame);
-				samples += recording.getSampleCount(it);
-				row << ", " << recording.getSum(it);
-			}
-
-			row << '\n';
-
-			if (samples > 0)
-			{
-				os << row.str();
-			}
-		}
-
-		typedef LLTrace::StatType<LLTrace::EventAccumulator> trace_event;
-
-		for (auto& it : trace_event::instance_snapshot())
-		{
-			std::ostringstream row;
-			row << std::setprecision(10);
-			row << it.getName();
-
-			const char* unit_label = it.getUnitLabel();
-			if (unit_label[0])
-			{
-				row << "(" << unit_label << ")";
-			}
-
-			S32 samples = 0;
-
-			for (S32 frame = 1; frame <= frame_count; frame++)
-			{
-				LLTrace::Recording& recording = scene_load_recording.getPrevRecording(frame_count - frame);
-				samples += recording.getSampleCount(it);
-				F64 mean = recording.getMean(it);
-				if (llisnan(mean))
-				{
-					row << ", n/a";
-				}
-				else
-				{
-					row << ", " << mean;
-				}
-			}
-
-			row << '\n';
-
-			if (samples > 0)
-			{
-				os << row.str();
-			}
-		}
-
-		typedef LLTrace::StatType<LLTrace::SampleAccumulator> trace_sample;
-
-		for (auto& it : trace_sample::instance_snapshot())
-		{
-			std::ostringstream row;
-			row << std::setprecision(10);
-			row << it.getName();
-
-			const char* unit_label = it.getUnitLabel();
-			if (unit_label[0])
-			{
-				row << "(" << unit_label << ")";
-			}
-
-			S32 samples = 0;
-
-			for (S32 frame = 1; frame <= frame_count; frame++)
-			{
-				LLTrace::Recording& recording = scene_load_recording.getPrevRecording(frame_count - frame);
-				samples += recording.getSampleCount(it);
-				F64 mean = recording.getMean(it);
-				if (llisnan(mean))
-				{
-					row << ", n/a";
-				}
-				else
-				{
-					row << ", " << mean;
-				}
-			}
-
-			row << '\n';
-
-			if (samples > 0)
-			{
-				os << row.str();
-			}
-		}
-
-		os.flush();
-		os.close();
-	}
-	catch (const std::ios_base::failure &e)
-	{
-		LL_WARNS() << "Unable to dump scene monitor results: " << e.what() << LL_ENDL;
-	}
-}
-
-//-------------------------------------------------------------------------------------------------------------
-//definition of class LLSceneMonitorView
-//-------------------------------------------------------------------------------------------------------------
-LLSceneMonitorView::LLSceneMonitorView(const LLRect& rect)
-	:	LLFloater(LLSD())
-{
-	setRect(rect);
-	setVisible(false);
-	
-	setCanMinimize(false);
-	setCanClose(true);
-
-	sTeleportFinishConnection = LLViewerParcelMgr::getInstance()->setTeleportFinishedCallback(boost::bind(&LLSceneMonitorView::onTeleportFinished, this));
-}
-
-LLSceneMonitorView::~LLSceneMonitorView()
-{
-	sTeleportFinishConnection.disconnect();
-}
-
-void LLSceneMonitorView::onClose(bool app_quitting)
-{
-	setVisible(false);	
-}
-
-void LLSceneMonitorView::onClickCloseBtn(bool app_quitting)
-{
-	setVisible(false);
-}
-
-void LLSceneMonitorView::onTeleportFinished()
-{
-	if(isInVisibleChain())
-	{
-		LLSceneMonitor::getInstance()->reset();
-	}
-}
-
-void LLSceneMonitorView::onVisibilityChange(bool visible)
-{
-	LLSceneMonitor::getInstance()->setDebugViewerVisible(visible);
-}
-
-void LLSceneMonitorView::draw()
-{
-	const LLRenderTarget* target = LLSceneMonitor::getInstance()->getDiffTarget();
-	if(!target)
-	{
-		return;
-	}
-
-	F32 ratio = LLSceneMonitor::getInstance()->getDiffPixelRatio();
-	S32 height = (S32)(target->getHeight() * ratio);
-	S32 width = (S32)(target->getWidth() * ratio);
-	
-	LLRect new_rect;
-	new_rect.setLeftTopAndSize(getRect().mLeft, getRect().mTop, width, height);
-	setRect(new_rect);
-
-	//draw background
-	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-	gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0, LLColor4(0.f, 0.f, 0.f, 0.25f));
-	
-	LLSceneMonitor::getInstance()->calcDiffAggregate();
-
-	//show some texts
-	LLColor4 color = LLColor4::white;
-	S32 line_height = LLFontGL::getFontMonospace()->getLineHeight();
-
-	S32 lines = 0;
-	std::string num_str = llformat("Frame difference: %.6f", LLSceneMonitor::getInstance()->getDiffResult());
-	LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, 5, getRect().getHeight() - line_height * lines, color, LLFontGL::LEFT, LLFontGL::TOP);
-	lines++;
-
-	num_str = llformat("Pixel tolerance: (R+G+B) < %.4f", LLSceneMonitor::getInstance()->getDiffTolerance());
-	LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, 5, getRect().getHeight() - line_height * lines, color, LLFontGL::LEFT, LLFontGL::TOP);
-	lines++;
-
-	num_str = llformat("Sampling time: %.3f seconds", gSavedSettings.getF32("SceneLoadingMonitorSampleTime"));
-	LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, 5, getRect().getHeight() - line_height * lines, color, LLFontGL::LEFT, LLFontGL::TOP);
-	lines++;
-
-	num_str = llformat("Scene Loading time: %.3f seconds", (F32)LLSceneMonitor::getInstance()->getRecording()->getResults().getDuration().value());
-	LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, 5, getRect().getHeight() - line_height * lines, color, LLFontGL::LEFT, LLFontGL::TOP);
-	lines++;
-
-	LLView::draw();
-}
-
+/**

+ * @file llscenemonitor.cpp

+ * @brief monitor the scene loading process.

+ *

+ * $LicenseInfo:firstyear=2003&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 "llrendertarget.h"

+#include "llscenemonitor.h"

+#include "llviewerwindow.h"

+#include "llviewerdisplay.h"

+#include "llviewercontrol.h"

+#include "llviewershadermgr.h"

+#include "llui.h"

+#include "llstartup.h"

+#include "llappviewer.h"

+#include "llwindow.h"

+#include "llpointer.h"

+#include "llspatialpartition.h"

+#include "llagent.h"

+#include "pipeline.h"

+#include "llviewerparcelmgr.h"

+#include "llviewerpartsim.h"

+

+LLSceneMonitorView* gSceneMonitorView = NULL;

+

+//

+//The procedures of monitoring when the scene finishes loading visually,

+//i.e., no pixel differences among frames, are:

+//1, freeze all dynamic objects and avatars;

+//2, (?) disable all sky and water;

+//3, capture frames periodically, by calling "capture()";

+//4, compute pixel differences between two latest captured frames, by calling "compare()", results are stored at mDiff;

+//5, compute the number of pixels in mDiff above some tolerance threshold in GPU, by calling "calcDiffAggregate()";

+//6, use gl occlusion query to fetch the result from GPU, by calling "fetchQueryResult()";

+//END.

+//

+

+LLSceneMonitor::LLSceneMonitor() :

+    mEnabled(false),

+    mDiff(NULL),

+    mDiffResult(0.f),

+    mDiffTolerance(0.1f),

+    mDiffState(WAITING_FOR_NEXT_DIFF),

+    mDebugViewerVisible(false),

+    mQueryObject(0),

+    mDiffPixelRatio(0.5f)

+{

+    mFrames[0] = NULL;

+    mFrames[1] = NULL;

+}

+

+LLSceneMonitor::~LLSceneMonitor()

+{

+    mDiffState = VIEWER_QUITTING;

+    reset();

+

+    mDitheringTexture = NULL;

+}

+

+void LLSceneMonitor::reset()

+{

+    delete mFrames[0];

+    delete mFrames[1];

+    delete mDiff;

+

+    mFrames[0] = NULL;

+    mFrames[1] = NULL;

+    mDiff = NULL;

+

+    mMonitorRecording.reset();

+    mSceneLoadRecording.reset();

+    mRecordingTimer.reset();

+

+    unfreezeScene();

+

+    if(mQueryObject > 0)

+    {

+        LLOcclusionCullingGroup::releaseOcclusionQueryObjectName(mQueryObject);

+        mQueryObject = 0;

+    }

+}

+

+void LLSceneMonitor::generateDitheringTexture(S32 width, S32 height)

+{

+#if 1

+    //4 * 4 matrix

+    mDitherMatrixWidth = 4;

+    S32 dither_matrix[4][4] =

+    {

+        {1, 9, 3, 11},

+        {13, 5, 15, 7},

+        {4, 12, 2, 10},

+        {16, 8, 14, 6}

+    };

+

+    mDitherScale = 255.f / 17;

+#else

+    //8 * 8 matrix

+    mDitherMatrixWidth = 16;

+    S32 dither_matrix[16][16] =

+    {

+        {1, 49, 13, 61, 4, 52, 16, 64, 1, 49, 13, 61, 4, 52, 16, 64},

+        {33, 17, 45, 29, 36, 20, 48, 32, 33, 17, 45, 29, 36, 20, 48, 32},

+        {9, 57, 5, 53, 12, 60, 8, 56, 9, 57, 5, 53, 12, 60, 8, 56},

+        {41, 25, 37, 21, 44, 28, 40, 24, 41, 25, 37, 21, 44, 28, 40, 24},

+        {3, 51, 15, 63, 2, 50, 14, 62, 3, 51, 15, 63, 2, 50, 14, 62},

+        {35, 19, 47, 31, 34, 18, 46, 30, 35, 19, 47, 31, 34, 18, 46, 30},

+        {11, 59, 7, 55, 10, 58, 6, 54, 11, 59, 7, 55, 10, 58, 6, 54},

+        {43, 27, 39, 23, 42, 26, 38, 22, 43, 27, 39, 23, 42, 26, 38, 22},

+        {1, 49, 13, 61, 4, 52, 16, 64, 1, 49, 13, 61, 4, 52, 16, 64},

+        {33, 17, 45, 29, 36, 20, 48, 32, 33, 17, 45, 29, 36, 20, 48, 32},

+        {9, 57, 5, 53, 12, 60, 8, 56, 9, 57, 5, 53, 12, 60, 8, 56},

+        {41, 25, 37, 21, 44, 28, 40, 24, 41, 25, 37, 21, 44, 28, 40, 24},

+        {3, 51, 15, 63, 2, 50, 14, 62, 3, 51, 15, 63, 2, 50, 14, 62},

+        {35, 19, 47, 31, 34, 18, 46, 30, 35, 19, 47, 31, 34, 18, 46, 30},

+        {11, 59, 7, 55, 10, 58, 6, 54, 11, 59, 7, 55, 10, 58, 6, 54},

+        {43, 27, 39, 23, 42, 26, 38, 22, 43, 27, 39, 23, 42, 26, 38, 22}

+    };

+

+    mDitherScale = 255.f / 65;

+#endif

+

+    LLPointer<LLImageRaw> image_raw = new LLImageRaw(mDitherMatrixWidth, mDitherMatrixWidth, 3);

+    U8* data = image_raw->getData();

+    for (S32 i = 0; i < mDitherMatrixWidth; i++)

+    {

+        for (S32 j = 0; j < mDitherMatrixWidth; j++)

+        {

+            U8 val = dither_matrix[i][j];

+            *data++ = val;

+            *data++ = val;

+            *data++ = val;

+        }

+    }

+

+    mDitheringTexture = LLViewerTextureManager::getLocalTexture(image_raw.get(), false) ;

+    mDitheringTexture->setAddressMode(LLTexUnit::TAM_WRAP);

+    mDitheringTexture->setFilteringOption(LLTexUnit::TFO_POINT);

+

+    mDitherScaleS = (F32)width / mDitherMatrixWidth;

+    mDitherScaleT = (F32)height / mDitherMatrixWidth;

+}

+

+void LLSceneMonitor::setDebugViewerVisible(bool visible)

+{

+    mDebugViewerVisible = visible;

+}

+

+LLRenderTarget& LLSceneMonitor::getCaptureTarget()

+{

+    LLRenderTarget* cur_target = NULL;

+

+    S32 width = gViewerWindow->getWorldViewWidthRaw();

+    S32 height = gViewerWindow->getWorldViewHeightRaw();

+

+    if(!mFrames[0])

+    {

+        mFrames[0] = new LLRenderTarget();

+        mFrames[0]->allocate(width, height, GL_RGB);

+        gGL.getTexUnit(0)->bind(mFrames[0]);

+        gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);

+        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+

+        cur_target = mFrames[0];

+    }

+    else if(!mFrames[1])

+    {

+        mFrames[1] = new LLRenderTarget();

+        mFrames[1]->allocate(width, height, GL_RGB);

+        gGL.getTexUnit(0)->bind(mFrames[1]);

+        gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);

+        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+

+        cur_target = mFrames[1];

+    }

+    else //swap

+    {

+        cur_target = mFrames[0];

+        mFrames[0] = mFrames[1];

+        mFrames[1] = cur_target;

+    }

+

+    if(cur_target->getWidth() != width || cur_target->getHeight() != height) //size changed

+    {

+        cur_target->resize(width, height);

+    }

+

+    // we're promising the target exists

+    return *cur_target;

+}

+

+void LLSceneMonitor::freezeAvatar(LLCharacter* avatarp)

+{

+    if(mEnabled)

+    {

+        mAvatarPauseHandles.push_back(avatarp->requestPause());

+    }

+}

+

+void LLSceneMonitor::freezeScene()

+{

+    if(!mEnabled)

+    {

+        return;

+    }

+

+    //freeze all avatars

+    for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();

+        iter != LLCharacter::sInstances.end(); ++iter)

+    {

+        freezeAvatar((LLCharacter*)(*iter));

+    }

+

+    // freeze everything else

+    gSavedSettings.setBOOL("FreezeTime", true);

+

+    //disable sky, water and clouds

+    gPipeline.clearRenderTypeMask(LLPipeline::RENDER_TYPE_SKY, LLPipeline::RENDER_TYPE_WL_SKY,

+        LLPipeline::RENDER_TYPE_WATER, LLPipeline::RENDER_TYPE_CLOUDS, LLPipeline::END_RENDER_TYPES);

+

+    //disable particle system

+    LLViewerPartSim::getInstance()->enable(false);

+}

+

+void LLSceneMonitor::unfreezeScene()

+{

+    //thaw all avatars

+    mAvatarPauseHandles.clear();

+

+    if(mDiffState == VIEWER_QUITTING)

+    {

+        return;

+    }

+

+    // thaw everything else

+    gSavedSettings.setBOOL("FreezeTime", false);

+

+    //enable sky, water and clouds

+    gPipeline.setRenderTypeMask(LLPipeline::RENDER_TYPE_SKY, LLPipeline::RENDER_TYPE_WL_SKY,

+        LLPipeline::RENDER_TYPE_WATER, LLPipeline::RENDER_TYPE_CLOUDS, LLPipeline::END_RENDER_TYPES);

+

+    //enable particle system

+    LLViewerPartSim::getInstance()->enable(true);

+}

+

+void LLSceneMonitor::capture()

+{

+    static U32 last_capture_frame = 0;

+    static LLCachedControl<bool> monitor_enabled(gSavedSettings, "SceneLoadingMonitorEnabled");

+    static LLCachedControl<F32>  scene_load_sample_time(gSavedSettings, "SceneLoadingMonitorSampleTime");

+    static bool force_capture = true;

+

+    bool enabled = monitor_enabled || mDebugViewerVisible;

+    if(mEnabled != enabled)

+    {

+        if(mEnabled)

+        {

+            mEnabled = enabled;

+            unfreezeScene();

+            reset();

+            force_capture = true;

+        }

+        else

+        {

+            mEnabled = enabled;

+            reset();

+            freezeScene();

+        }

+    }

+

+    if (mEnabled

+        && (mMonitorRecording.getSum(*LLViewerCamera::getVelocityStat()) > 0.1f

+            || mMonitorRecording.getSum(*LLViewerCamera::getAngularVelocityStat()) > 0.05f))

+    {

+        reset();

+        freezeScene();

+        force_capture = true;

+    }

+

+    if(mEnabled

+        && (mRecordingTimer.getElapsedTimeF32() > scene_load_sample_time()

+            || force_capture)

+        && last_capture_frame != gFrameCount)

+    {

+        force_capture = false;

+

+        mSceneLoadRecording.resume();

+        mMonitorRecording.resume();

+

+        last_capture_frame = gFrameCount;

+

+        LLRenderTarget& cur_target = getCaptureTarget();

+

+        U32 old_FBO = LLRenderTarget::sCurFBO;

+

+        gGL.getTexUnit(0)->bind(&cur_target);

+        glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); //point to the main frame buffer.

+

+        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, cur_target.getWidth(), cur_target.getHeight()); //copy the content

+

+        glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);

+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);

+        glBindFramebuffer(GL_FRAMEBUFFER, old_FBO);

+

+        mDiffState = NEED_DIFF;

+    }

+}

+

+bool LLSceneMonitor::needsUpdate() const

+{

+    return mDiffState == NEED_DIFF;

+}

+

+static LLStaticHashedString sDitherScale("dither_scale");

+static LLStaticHashedString sDitherScaleS("dither_scale_s");

+static LLStaticHashedString sDitherScaleT("dither_scale_t");

+

+void LLSceneMonitor::compare()

+{

+#ifdef LL_WINDOWS

+    if(mDiffState != NEED_DIFF)

+    {

+        return;

+    }

+

+    if(!mFrames[0] || !mFrames[1])

+    {

+        return;

+    }

+    if(mFrames[0]->getWidth() != mFrames[1]->getWidth() || mFrames[0]->getHeight() != mFrames[1]->getHeight())

+    {   //size does not match

+        return;

+    }

+

+    mDiffState = EXECUTE_DIFF;

+

+    S32 width = gViewerWindow->getWindowWidthRaw();

+    S32 height = gViewerWindow->getWindowHeightRaw();

+    if(!mDiff)

+    {

+        mDiff = new LLRenderTarget();

+        mDiff->allocate(width, height, GL_RGBA);

+

+        generateDitheringTexture(width, height);

+    }

+    else if(mDiff->getWidth() != width || mDiff->getHeight() != height)

+    {

+        mDiff->resize(width, height);

+        generateDitheringTexture(width, height);

+    }

+

+    mDiff->bindTarget();

+    mDiff->clear();

+

+    gTwoTextureCompareProgram.bind();

+

+    gTwoTextureCompareProgram.uniform1f(sDitherScale, mDitherScale);

+    gTwoTextureCompareProgram.uniform1f(sDitherScaleS, mDitherScaleS);

+    gTwoTextureCompareProgram.uniform1f(sDitherScaleT, mDitherScaleT);

+

+    gGL.getTexUnit(0)->activate();

+    gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);

+    gGL.getTexUnit(0)->bind(mFrames[0]);

+    gGL.getTexUnit(0)->activate();

+

+    gGL.getTexUnit(1)->activate();

+    gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);

+    gGL.getTexUnit(1)->bind(mFrames[1]);

+    gGL.getTexUnit(1)->activate();

+

+    gGL.getTexUnit(2)->activate();

+    gGL.getTexUnit(2)->enable(LLTexUnit::TT_TEXTURE);

+    gGL.getTexUnit(2)->bind(mDitheringTexture);

+    gGL.getTexUnit(2)->activate();

+

+    gl_rect_2d_simple_tex(width, height);

+

+    mDiff->flush();

+

+    gTwoTextureCompareProgram.unbind();

+

+    gGL.getTexUnit(0)->disable();

+    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+    gGL.getTexUnit(1)->disable();

+    gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);

+    gGL.getTexUnit(2)->disable();

+    gGL.getTexUnit(2)->unbind(LLTexUnit::TT_TEXTURE);

+

+    if (!mDebugViewerVisible)

+    {

+        calcDiffAggregate();

+    }

+#endif

+}

+

+static LLStaticHashedString sTolerance("tolerance");

+

+//calculate Diff aggregate information in GPU, and enable gl occlusion query to capture it.

+void LLSceneMonitor::calcDiffAggregate()

+{

+#ifdef LL_WINDOWS

+

+    if(mDiffState != EXECUTE_DIFF && !mDebugViewerVisible)

+    {

+        return;

+    }

+

+    if(!mQueryObject)

+    {

+        mQueryObject = LLOcclusionCullingGroup::getNewOcclusionQueryObjectName();

+    }

+

+    LLGLDepthTest depth(true, false, GL_ALWAYS);

+    if(!mDebugViewerVisible)

+    {

+        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

+    }

+

+    LLGLSLShader* cur_shader = NULL;

+

+    cur_shader = LLGLSLShader::sCurBoundShaderPtr;

+    gOneTextureFilterProgram.bind();

+    gOneTextureFilterProgram.uniform1f(sTolerance, mDiffTolerance);

+

+    if(mDiffState == EXECUTE_DIFF)

+    {

+        glBeginQuery(GL_SAMPLES_PASSED, mQueryObject);

+    }

+

+    gl_draw_scaled_target(0, 0, S32(mDiff->getWidth() * mDiffPixelRatio), S32(mDiff->getHeight() * mDiffPixelRatio), mDiff);

+

+    if(mDiffState == EXECUTE_DIFF)

+    {

+        glEndQuery(GL_SAMPLES_PASSED);

+        mDiffState = WAIT_ON_RESULT;

+    }

+

+    gOneTextureFilterProgram.unbind();

+

+    if(cur_shader != NULL)

+    {

+        cur_shader->bind();

+    }

+

+    if(!mDebugViewerVisible)

+    {

+        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

+    }

+#endif

+}

+

+static LLTrace::EventStatHandle<> sFramePixelDiff("FramePixelDifference");

+void LLSceneMonitor::fetchQueryResult()

+{

+    // also throttle timing here, to avoid going below sample time due to phasing with frame capture

+    static LLCachedControl<F32>  scene_load_sample_time_control(gSavedSettings, "SceneLoadingMonitorSampleTime");

+    F32Seconds scene_load_sample_time = (F32Seconds)scene_load_sample_time_control();

+

+    if(mDiffState == WAIT_ON_RESULT

+        && !LLAppViewer::instance()->quitRequested())

+    {

+        mDiffState = WAITING_FOR_NEXT_DIFF;

+

+        GLuint available = 0;

+        glGetQueryObjectuiv(mQueryObject, GL_QUERY_RESULT_AVAILABLE, &available);

+        if(available)

+        {

+            GLuint count = 0;

+            glGetQueryObjectuiv(mQueryObject, GL_QUERY_RESULT, &count);

+

+            mDiffResult = sqrtf(count * 0.5f / (mDiff->getWidth() * mDiff->getHeight() * mDiffPixelRatio * mDiffPixelRatio)); //0.5 -> (front face + back face)

+

+            LL_DEBUGS("SceneMonitor") << "Frame difference: " << mDiffResult << LL_ENDL;

+            record(sFramePixelDiff, mDiffResult);

+

+            static LLCachedControl<F32> diff_threshold(gSavedSettings,"SceneLoadingMonitorPixelDiffThreshold");

+            F32Seconds elapsed_time = mRecordingTimer.getElapsedTimeF32();

+

+            if (elapsed_time > scene_load_sample_time)

+            {

+                if(mDiffResult > diff_threshold())

+                {

+                    mSceneLoadRecording.extend();

+                    llassert_always(mSceneLoadRecording.getResults().getLastRecording().getDuration() > scene_load_sample_time);

+                }

+                else

+                {

+                    mSceneLoadRecording.nextPeriod();

+                }

+                mRecordingTimer.reset();

+            }

+        }

+    }

+}

+

+//dump results to a file _scene_xmonitor_results.csv

+void LLSceneMonitor::dumpToFile(const std::string &file_name)

+{

+    if (!hasResults()) return;

+

+    LL_INFOS("SceneMonitor") << "Saving scene load stats to " << file_name << LL_ENDL;

+    try

+    {

+        llofstream os(file_name.c_str());

+

+        os << std::setprecision(10);

+

+        LLTrace::PeriodicRecording& scene_load_recording = mSceneLoadRecording.getResults();

+        const U32 frame_count = scene_load_recording.getNumRecordedPeriods();

+

+        F64Seconds frame_time;

+

+        os << "Stat";

+        for (S32 frame = 1; frame <= frame_count; frame++)

+        {

+            frame_time += scene_load_recording.getPrevRecording(frame_count - frame).getDuration();

+            os << ", " << frame_time.value();

+        }

+        os << '\n';

+

+        os << "Sample period(s)";

+        for (S32 frame = 1; frame <= frame_count; frame++)

+        {

+            frame_time = scene_load_recording.getPrevRecording(frame_count - frame).getDuration();

+            os << ", " << frame_time.value();

+        }

+        os << '\n';

+

+

+        typedef LLTrace::StatType<LLTrace::CountAccumulator> trace_count;

+        for (auto& it : trace_count::instance_snapshot())

+        {

+            std::ostringstream row;

+            row << std::setprecision(10);

+

+            row << it.getName();

+

+            const char* unit_label = it.getUnitLabel();

+            if (unit_label[0])

+            {

+                row << "(" << unit_label << ")";

+            }

+

+            S32 samples = 0;

+

+            for (S32 frame = 1; frame <= frame_count; frame++)

+            {

+                LLTrace::Recording& recording = scene_load_recording.getPrevRecording(frame_count - frame);

+                samples += recording.getSampleCount(it);

+                row << ", " << recording.getSum(it);

+            }

+

+            row << '\n';

+

+            if (samples > 0)

+            {

+                os << row.str();

+            }

+        }

+

+        typedef LLTrace::StatType<LLTrace::EventAccumulator> trace_event;

+

+        for (auto& it : trace_event::instance_snapshot())

+        {

+            std::ostringstream row;

+            row << std::setprecision(10);

+            row << it.getName();

+

+            const char* unit_label = it.getUnitLabel();

+            if (unit_label[0])

+            {

+                row << "(" << unit_label << ")";

+            }

+

+            S32 samples = 0;

+

+            for (S32 frame = 1; frame <= frame_count; frame++)

+            {

+                LLTrace::Recording& recording = scene_load_recording.getPrevRecording(frame_count - frame);

+                samples += recording.getSampleCount(it);

+                F64 mean = recording.getMean(it);

+                if (llisnan(mean))

+                {

+                    row << ", n/a";

+                }

+                else

+                {

+                    row << ", " << mean;

+                }

+            }

+

+            row << '\n';

+

+            if (samples > 0)

+            {

+                os << row.str();

+            }

+        }

+

+        typedef LLTrace::StatType<LLTrace::SampleAccumulator> trace_sample;

+

+        for (auto& it : trace_sample::instance_snapshot())

+        {

+            std::ostringstream row;

+            row << std::setprecision(10);

+            row << it.getName();

+

+            const char* unit_label = it.getUnitLabel();

+            if (unit_label[0])

+            {

+                row << "(" << unit_label << ")";

+            }

+

+            S32 samples = 0;

+

+            for (S32 frame = 1; frame <= frame_count; frame++)

+            {

+                LLTrace::Recording& recording = scene_load_recording.getPrevRecording(frame_count - frame);

+                samples += recording.getSampleCount(it);

+                F64 mean = recording.getMean(it);

+                if (llisnan(mean))

+                {

+                    row << ", n/a";

+                }

+                else

+                {

+                    row << ", " << mean;

+                }

+            }

+

+            row << '\n';

+

+            if (samples > 0)

+            {

+                os << row.str();

+            }

+        }

+

+        os.flush();

+        os.close();

+    }

+    catch (const std::ios_base::failure &e)

+    {

+        LL_WARNS() << "Unable to dump scene monitor results: " << e.what() << LL_ENDL;

+    }

+}

+

+//-------------------------------------------------------------------------------------------------------------

+//definition of class LLSceneMonitorView

+//-------------------------------------------------------------------------------------------------------------

+LLSceneMonitorView::LLSceneMonitorView(const LLRect& rect)

+    :   LLFloater(LLSD())

+{

+    setRect(rect);

+    setVisible(false);

+

+    setCanMinimize(false);

+    setCanClose(true);

+

+    sTeleportFinishConnection = LLViewerParcelMgr::getInstance()->setTeleportFinishedCallback(boost::bind(&LLSceneMonitorView::onTeleportFinished, this));

+}

+

+LLSceneMonitorView::~LLSceneMonitorView()

+{

+    sTeleportFinishConnection.disconnect();

+}

+

+void LLSceneMonitorView::onClose(bool app_quitting)

+{

+    setVisible(false);

+}

+

+void LLSceneMonitorView::onClickCloseBtn(bool app_quitting)

+{

+    setVisible(false);

+}

+

+void LLSceneMonitorView::onTeleportFinished()

+{

+    if(isInVisibleChain())

+    {

+        LLSceneMonitor::getInstance()->reset();

+    }

+}

+

+void LLSceneMonitorView::onVisibilityChange(bool visible)

+{

+    LLSceneMonitor::getInstance()->setDebugViewerVisible(visible);

+}

+

+void LLSceneMonitorView::draw()

+{

+    const LLRenderTarget* target = LLSceneMonitor::getInstance()->getDiffTarget();

+    if(!target)

+    {

+        return;

+    }

+

+    F32 ratio = LLSceneMonitor::getInstance()->getDiffPixelRatio();

+    S32 height = (S32)(target->getHeight() * ratio);

+    S32 width = (S32)(target->getWidth() * ratio);

+

+    LLRect new_rect;

+    new_rect.setLeftTopAndSize(getRect().mLeft, getRect().mTop, width, height);

+    setRect(new_rect);

+

+    //draw background

+    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+    gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0, LLColor4(0.f, 0.f, 0.f, 0.25f));

+

+    LLSceneMonitor::getInstance()->calcDiffAggregate();

+

+    //show some texts

+    LLColor4 color = LLColor4::white;

+    S32 line_height = LLFontGL::getFontMonospace()->getLineHeight();

+

+    S32 lines = 0;

+    std::string num_str = llformat("Frame difference: %.6f", LLSceneMonitor::getInstance()->getDiffResult());

+    LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, 5, getRect().getHeight() - line_height * lines, color, LLFontGL::LEFT, LLFontGL::TOP);

+    lines++;

+

+    num_str = llformat("Pixel tolerance: (R+G+B) < %.4f", LLSceneMonitor::getInstance()->getDiffTolerance());

+    LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, 5, getRect().getHeight() - line_height * lines, color, LLFontGL::LEFT, LLFontGL::TOP);

+    lines++;

+

+    num_str = llformat("Sampling time: %.3f seconds", gSavedSettings.getF32("SceneLoadingMonitorSampleTime"));

+    LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, 5, getRect().getHeight() - line_height * lines, color, LLFontGL::LEFT, LLFontGL::TOP);

+    lines++;

+

+    num_str = llformat("Scene Loading time: %.3f seconds", (F32)LLSceneMonitor::getInstance()->getRecording()->getResults().getDuration().value());

+    LLFontGL::getFontMonospace()->renderUTF8(num_str, 0, 5, getRect().getHeight() - line_height * lines, color, LLFontGL::LEFT, LLFontGL::TOP);

+    lines++;

+

+    LLView::draw();

+}

+