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

diff --git a/indra/newview/llviewercamera.cpp b/indra/newview/llviewercamera.cpp
index a33e30f7ee..898f271edc 100644
--- a/indra/newview/llviewercamera.cpp
+++ b/indra/newview/llviewercamera.cpp
@@ -1,898 +1,898 @@
-/** 
- * @file llviewercamera.cpp
- * @brief LLViewerCamera class implementation
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#define LLVIEWERCAMERA_CPP
-#include "llviewercamera.h"
-
-// Viewer includes
-#include "llagent.h"
-#include "llagentcamera.h"
-#include "llmatrix4a.h"
-#include "llviewercontrol.h"
-#include "llviewerobjectlist.h"
-#include "llviewerregion.h"
-#include "llviewerwindow.h"
-#include "llvovolume.h"
-#include "llworld.h"
-#include "lltoolmgr.h"
-#include "llviewerjoystick.h"
-
-// Linden library includes
-#include "lldrawable.h"
-#include "llface.h"
-#include "llgl.h"
-#include "llglheaders.h"
-#include "llquaternion.h"
-#include "llwindow.h"			// getPixelAspectRatio()
-#include "lltracerecording.h"
-#include "llenvironment.h"
-
-// System includes
-#include <iomanip> // for setprecision
-
-LLTrace::CountStatHandle<> LLViewerCamera::sVelocityStat("camera_velocity");
-LLTrace::CountStatHandle<> LLViewerCamera::sAngularVelocityStat("camera_angular_velocity");
-
-LLViewerCamera::eCameraID LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD;
-
-//glu pick matrix implementation borrowed from Mesa3D
-glh::matrix4f gl_pick_matrix(GLfloat x, GLfloat y, GLfloat width, GLfloat height, GLint* viewport)
-{
-	GLfloat m[16];
-	GLfloat sx, sy;
-	GLfloat tx, ty;
-
-	sx = viewport[2] / width;
-	sy = viewport[3] / height;
-	tx = (viewport[2] + 2.f * (viewport[0] - x)) / width;
-	ty = (viewport[3] + 2.f * (viewport[1] - y)) / height;
-
-	#define M(row,col) m[col*4+row]
-	M(0,0) = sx; M(0,1) = 0.f; M(0,2) = 0.f; M(0,3) = tx;
-	M(1,0) = 0.f; M(1,1) = sy; M(1,2) = 0.f; M(1,3) = ty;
-	M(2,0) = 0.f; M(2,1) = 0.f; M(2,2) = 1.f; M(2,3) = 0.f;
-	M(3,0) = 0.f; M(3,1) = 0.f; M(3,2) = 0.f; M(3,3) = 1.f;
-	#undef M
-
-	return glh::matrix4f(m);
-}
-
-LLViewerCamera::LLViewerCamera() : LLCamera()
-{
-	calcProjection(getFar());
-	mCameraFOVDefault = DEFAULT_FIELD_OF_VIEW;
-	mPrevCameraFOVDefault = DEFAULT_FIELD_OF_VIEW;
-	mCosHalfCameraFOV = cosf(mCameraFOVDefault * 0.5f);
-	mPixelMeterRatio = 0.f;
-	mScreenPixelArea = 0;
-	mZoomFactor = 1.f;
-	mZoomSubregion = 1;
-	mAverageSpeed = 0.f;
-	mAverageAngularSpeed = 0.f;
-	gSavedSettings.getControl("CameraAngle")->getCommitSignal()->connect(boost::bind(&LLViewerCamera::updateCameraAngle, this, _2));
-}
-
-void LLViewerCamera::updateCameraLocation(const LLVector3 &center, const LLVector3 &up_direction, const LLVector3 &point_of_interest)
-{
-    // do not update if avatar didn't move
-    if (!LLViewerJoystick::getInstance()->getCameraNeedsUpdate())
-    {
-        return;
-    }
-
-    LLVector3 last_position;
-    LLVector3 last_axis;
-    last_position = getOrigin();
-    last_axis     = getAtAxis();
-
-    mLastPointOfInterest = point_of_interest;
-
-    LLViewerRegion* regp = LLWorld::instance().getRegionFromPosAgent(getOrigin());
-    if (!regp)
-    {
-        regp = gAgent.getRegion();
-    }
-
-    F32 water_height = (NULL != regp) ? regp->getWaterHeight() : 0.f;
-
-    LLVector3 origin = center;
-
-    {
-        if (origin.mV[2] > water_height)
-        {
-            origin.mV[2] = llmax(origin.mV[2], water_height + 0.20f);
-        }
-        else
-        {
-            origin.mV[2] = llmin(origin.mV[2], water_height - 0.20f);
-        }
-    }
-
-	setOriginAndLookAt(origin, up_direction, point_of_interest);
-
-	mVelocityDir = origin - last_position ; 
-	F32 dpos = mVelocityDir.normVec() ;
-	LLQuaternion rotation;
-	rotation.shortestArc(last_axis, getAtAxis());
-
-	F32 x, y, z;
-	F32 drot;
-	rotation.getAngleAxis(&drot, &x, &y, &z);
-
-	add(sVelocityStat, dpos);
-	add(sAngularVelocityStat, drot);
-	
-	mAverageSpeed = LLTrace::get_frame_recording().getPeriodMeanPerSec(sVelocityStat, 50);
-	mAverageAngularSpeed = LLTrace::get_frame_recording().getPeriodMeanPerSec(sAngularVelocityStat);
-	mCosHalfCameraFOV = cosf(0.5f * getView() * llmax(1.0f, getAspect()));
-
-	// update pixel meter ratio using default fov, not modified one
-	mPixelMeterRatio = getViewHeightInPixels()/ (2.f*tanf(mCameraFOVDefault*0.5));
-	// update screen pixel area
-	mScreenPixelArea =(S32)((F32)getViewHeightInPixels() * ((F32)getViewHeightInPixels() * getAspect()));
-}
-
-const LLMatrix4 &LLViewerCamera::getProjection() const
-{
-	calcProjection(getFar());
-	return mProjectionMatrix;
-
-}
-
-const LLMatrix4 &LLViewerCamera::getModelview() const
-{
-	LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
-	getMatrixToLocal(mModelviewMatrix);
-	mModelviewMatrix *= cfr;
-	return mModelviewMatrix;
-}
-
-void LLViewerCamera::calcProjection(const F32 far_distance) const
-{
-	F32 fov_y, z_far, z_near, aspect, f;
-	fov_y = getView();
-	z_far = far_distance;
-	z_near = getNear();
-	aspect = getAspect();
-
-	f = 1/tan(fov_y*0.5f);
-
-	mProjectionMatrix.setZero();
-	mProjectionMatrix.mMatrix[0][0] = f/aspect;
-	mProjectionMatrix.mMatrix[1][1] = f;
-	mProjectionMatrix.mMatrix[2][2] = (z_far + z_near)/(z_near - z_far);
-	mProjectionMatrix.mMatrix[3][2] = (2*z_far*z_near)/(z_near - z_far);
-	mProjectionMatrix.mMatrix[2][3] = -1;
-}
-
-// Sets up opengl state for 3D drawing.  If for selection, also
-// sets up a pick matrix.  x and y are ignored if for_selection is false.
-// The picking region is centered on x,y and has the specified width and
-// height.
-
-//static
-void LLViewerCamera::updateFrustumPlanes(LLCamera& camera, bool ortho, bool zflip, bool no_hacks)
-{
-	GLint* viewport = (GLint*) gGLViewport;
-	F64 model[16];
-	F64 proj[16];
-
-	for (U32 i = 0; i < 16; i++)
-	{
-		model[i] = (F64) gGLModelView[i];
-		proj[i] = (F64) gGLProjection[i];
-	}
-
-	GLdouble objX,objY,objZ;
-
-	LLVector3 frust[8];
-
-	if (no_hacks)
-	{
-		gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
-
-		gluUnProject(viewport[0],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
-		frust[4].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
-		frust[5].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
-		frust[6].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
-		frust[7].setVec((F32)objX,(F32)objY,(F32)objZ);
-	}
-	else if (zflip)
-	{
-		gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
-
-		gluUnProject(viewport[0],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
-		frust[4].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
-		frust[5].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
-		frust[6].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
-		frust[7].setVec((F32)objX,(F32)objY,(F32)objZ);
-
-		for (U32 i = 0; i < 4; i++)
-		{
-			frust[i+4] = frust[i+4]-frust[i];
-			frust[i+4].normVec();
-			frust[i+4] = frust[i] + frust[i+4]*camera.getFar();
-		}
-	}
-	else
-	{
-		gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
-		gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-		frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
-		
-		if (ortho)
-		{
-			LLVector3 far_shift = camera.getAtAxis()*camera.getFar()*2.f; 
-			for (U32 i = 0; i < 4; i++)
-			{
-				frust[i+4] = frust[i] + far_shift;
-			}
-		}
-		else
-		{
-			for (U32 i = 0; i < 4; i++)
-			{
-				LLVector3 vec = frust[i] - camera.getOrigin();
-				vec.normVec();
-				frust[i+4] = camera.getOrigin() + vec*camera.getFar();
-			}
-		}
-	}
-
-	camera.calcAgentFrustumPlanes(frust);
-}
-
-void LLViewerCamera::setPerspective(bool for_selection,
-									S32 x, S32 y_from_bot, S32 width, S32 height,
-									bool limit_select_distance,
-									F32 z_near, F32 z_far)
-{
-	F32 fov_y, aspect;
-	fov_y = RAD_TO_DEG * getView();
-	bool z_default_far = false;
-	if (z_far <= 0)
-	{
-		z_default_far = true;
-		z_far = getFar();
-	}
-	if (z_near <= 0)
-	{
-		z_near = getNear();
-	}
-	aspect = getAspect();
-
-	// Load camera view matrix
-	gGL.matrixMode(LLRender::MM_PROJECTION);
-	gGL.loadIdentity();
-
-	glh::matrix4f proj_mat;
-
-	if (for_selection)
-	{
-		// make a tiny little viewport
-		// anything drawn into this viewport will be "selected"
-
-		GLint viewport[4];
-		viewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft;
-		viewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom;
-		viewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth();
-		viewport[3] = gViewerWindow->getWorldViewRectRaw().getHeight();
-		
-		proj_mat = gl_pick_matrix(x+width/2.f, y_from_bot+height/2.f, (GLfloat) width, (GLfloat) height, viewport);
-
-		if (limit_select_distance)
-		{
-			// ...select distance from control
-			z_far = gSavedSettings.getF32("MaxSelectDistance");
-		}
-		else
-		{
-			z_far = gAgentCamera.mDrawDistance;
-		}
-	}
-	else
-	{
-		// Only override the far clip if it's not passed in explicitly.
-		if (z_default_far)
-		{
-			z_far = MAX_FAR_CLIP;
-		}
-		glViewport(x, y_from_bot, width, height);
-		gGLViewport[0] = x;
-		gGLViewport[1] = y_from_bot;
-		gGLViewport[2] = width;
-		gGLViewport[3] = height;
-	}
-	
-	if (mZoomFactor > 1.f)
-	{
-		float offset = mZoomFactor - 1.f;
-		int pos_y = mZoomSubregion / llceil(mZoomFactor);
-		int pos_x = mZoomSubregion - (pos_y*llceil(mZoomFactor));
-		glh::matrix4f translate;
-		translate.set_translate(glh::vec3f(offset - (F32)pos_x * 2.f, offset - (F32)pos_y * 2.f, 0.f));
-		glh::matrix4f scale;
-		scale.set_scale(glh::vec3f(mZoomFactor, mZoomFactor, 1.f));
-
-		proj_mat = scale*proj_mat;
-		proj_mat = translate*proj_mat;
-	}
-
-	calcProjection(z_far); // Update the projection matrix cache
-
-	proj_mat *= gl_perspective(fov_y,aspect,z_near,z_far);
-
-	gGL.loadMatrix(proj_mat.m);
-
-	for (U32 i = 0; i < 16; i++)
-	{
-		gGLProjection[i] = proj_mat.m[i];
-	}
-
-	gGL.matrixMode(LLRender::MM_MODELVIEW);
-
-	glh::matrix4f modelview((GLfloat*) OGL_TO_CFR_ROTATION);
-
-	GLfloat			ogl_matrix[16];
-
-	getOpenGLTransform(ogl_matrix);
-
-	modelview *= glh::matrix4f(ogl_matrix);
-	
-	gGL.loadMatrix(modelview.m);
-	
-	if (for_selection && (width > 1 || height > 1))
-	{
-		// NB: as of this writing, i believe the code below is broken (doesn't take into account the world view, assumes entire window)
-		// however, it is also unused (the GL matricies are used for selection, (see LLCamera::sphereInFrustum())) and so i'm not
-		// comfortable hacking on it.
-		calculateFrustumPlanesFromWindow((F32)(x - width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
-								(F32)(y_from_bot - height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f,
-								(F32)(x + width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
-								(F32)(y_from_bot + height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f);
-
-	}
-
-	// if not picking and not doing a snapshot, cache various GL matrices
-	if (!for_selection && mZoomFactor == 1.f)
-	{
-		// Save GL matrices for access elsewhere in code, especially project_world_to_screen
-		for (U32 i = 0; i < 16; i++)
-		{
-			gGLModelView[i] = modelview.m[i];
-		}
-	}
-
-	updateFrustumPlanes(*this);
-}
-
-
-// Uses the last GL matrices set in set_perspective to project a point from
-// screen coordinates to the agent's region.
-void LLViewerCamera::projectScreenToPosAgent(const S32 screen_x, const S32 screen_y, LLVector3* pos_agent) const
-{
-	GLdouble x, y, z;
-
-	F64 mdlv[16];
-	F64 proj[16];
-
-	for (U32 i = 0; i < 16; i++)
-	{
-		mdlv[i] = (F64) gGLModelView[i];
-		proj[i] = (F64) gGLProjection[i];
-	}
-
-	gluUnProject(
-		GLdouble(screen_x), GLdouble(screen_y), 0.0,
-		mdlv, proj, (GLint*)gGLViewport,
-		&x,
-		&y,
-		&z );
-	pos_agent->setVec( (F32)x, (F32)y, (F32)z );
-}
-
-// Uses the last GL matrices set in set_perspective to project a point from
-// the agent's region space to screen coordinates.  Returns true if point in within
-// the current window.
-bool LLViewerCamera::projectPosAgentToScreen(const LLVector3 &pos_agent, LLCoordGL &out_point, const bool clamp) const
-{
-	bool in_front = true;
-	GLdouble	x, y, z;			// object's window coords, GL-style
-
-	LLVector3 dir_to_point = pos_agent - getOrigin();
-	dir_to_point /= dir_to_point.magVec();
-
-	if (dir_to_point * getAtAxis() < 0.f)
-	{
-		if (clamp)
-		{
-			return false;
-		}
-		else
-		{
-			in_front = false;
-		}
-	}
-
-	LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();
-	S32	viewport[4];
-	viewport[0] = world_view_rect.mLeft;
-	viewport[1] = world_view_rect.mBottom;
-	viewport[2] = world_view_rect.getWidth();
-	viewport[3] = world_view_rect.getHeight();
-
-	F64 mdlv[16];
-	F64 proj[16];
-
-	for (U32 i = 0; i < 16; i++)
-	{
-		mdlv[i] = (F64) gGLModelView[i];
-		proj[i] = (F64) gGLProjection[i];
-	}
-
-	if (GL_TRUE == gluProject(pos_agent.mV[VX], pos_agent.mV[VY], pos_agent.mV[VZ],
-								mdlv, proj, (GLint*)viewport,
-								&x, &y, &z))
-	{
-		// convert screen coordinates to virtual UI coordinates
-		x /= gViewerWindow->getDisplayScale().mV[VX];
-		y /= gViewerWindow->getDisplayScale().mV[VY];
-
-		// should now have the x,y coords of grab_point in screen space
-		LLRect world_rect = gViewerWindow->getWorldViewRectScaled();
-
-		// convert to pixel coordinates
-		S32 int_x = lltrunc(x);
-		S32 int_y = lltrunc(y);
-
-		bool valid = true;
-
-		if (clamp)
-		{
-			if (int_x < world_rect.mLeft)
-			{
-				out_point.mX = world_rect.mLeft;
-				valid = false;
-			}
-			else if (int_x > world_rect.mRight)
-			{
-				out_point.mX = world_rect.mRight;
-				valid = false;
-			}
-			else
-			{
-				out_point.mX = int_x;
-			}
-
-			if (int_y < world_rect.mBottom)
-			{
-				out_point.mY = world_rect.mBottom;
-				valid = false;
-			}
-			else if (int_y > world_rect.mTop)
-			{
-				out_point.mY = world_rect.mTop;
-				valid = false;
-			}
-			else
-			{
-				out_point.mY = int_y;
-			}
-			return valid;
-		}
-		else
-		{
-			out_point.mX = int_x;
-			out_point.mY = int_y;
-
-			if (int_x < world_rect.mLeft)
-			{
-				valid = false;
-			}
-			else if (int_x > world_rect.mRight)
-			{
-				valid = false;
-			}
-			if (int_y < world_rect.mBottom)
-			{
-				valid = false;
-			}
-			else if (int_y > world_rect.mTop)
-			{
-				valid = false;
-			}
-
-			return in_front && valid;
-		}
-	}
-	else
-	{
-		return false;
-	}
-}
-
-// Uses the last GL matrices set in set_perspective to project a point from
-// the agent's region space to the nearest edge in screen coordinates.
-// Returns true if projection succeeds.
-bool LLViewerCamera::projectPosAgentToScreenEdge(const LLVector3 &pos_agent,
-												LLCoordGL &out_point) const
-{
-	LLVector3 dir_to_point = pos_agent - getOrigin();
-	dir_to_point /= dir_to_point.magVec();
-
-	bool in_front = true;
-	if (dir_to_point * getAtAxis() < 0.f)
-	{
-		in_front = false;
-	}
-
-	LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();
-	S32	viewport[4];
-	viewport[0] = world_view_rect.mLeft;
-	viewport[1] = world_view_rect.mBottom;
-	viewport[2] = world_view_rect.getWidth();
-	viewport[3] = world_view_rect.getHeight();
-	GLdouble	x, y, z;			// object's window coords, GL-style
-
-	F64 mdlv[16];
-	F64 proj[16];
-
-	for (U32 i = 0; i < 16; i++)
-	{
-		mdlv[i] = (F64) gGLModelView[i];
-		proj[i] = (F64) gGLProjection[i];
-	}
-
-	if (GL_TRUE == gluProject(pos_agent.mV[VX], pos_agent.mV[VY],
-							  pos_agent.mV[VZ], mdlv,
-							  proj, (GLint*)viewport,
-							  &x, &y, &z))
-	{
-		x /= gViewerWindow->getDisplayScale().mV[VX];
-		y /= gViewerWindow->getDisplayScale().mV[VY];
-		// should now have the x,y coords of grab_point in screen space
-		const LLRect& world_rect = gViewerWindow->getWorldViewRectScaled();
-
-		// ...sanity check
-		S32 int_x = lltrunc(x);
-		S32 int_y = lltrunc(y);
-
-		// find the center
-		GLdouble center_x = (GLdouble)world_rect.getCenterX();
-		GLdouble center_y = (GLdouble)world_rect.getCenterY();
-
-		if (x == center_x  &&  y == center_y)
-		{
-			// can't project to edge from exact center
-			return false;
-		}
-
-		// find the line from center to local
-		GLdouble line_x = x - center_x;
-		GLdouble line_y = y - center_y;
-
-		int_x = lltrunc(center_x);
-		int_y = lltrunc(center_y);
-
-
-		if (0.f == line_x)
-		{
-			// the slope of the line is undefined
-			if (line_y > 0.f)
-			{
-				int_y = world_rect.mTop;
-			}
-			else
-			{
-				int_y = world_rect.mBottom;
-			}
-		}
-		else if (0 == world_rect.getWidth())
-		{
-			// the diagonal slope of the view is undefined
-			if (y < world_rect.mBottom)
-			{
-				int_y = world_rect.mBottom;
-			}
-			else if ( y > world_rect.mTop)
-			{
-				int_y = world_rect.mTop;
-			}
-		}
-		else
-		{
-			F32 line_slope = (F32)(line_y / line_x);
-			F32 rect_slope = ((F32)world_rect.getHeight()) / ((F32)world_rect.getWidth());
-
-			if (fabs(line_slope) > rect_slope)
-			{
-				if (line_y < 0.f)
-				{
-					// bottom
-					int_y = world_rect.mBottom;
-				}
-				else
-				{
-					// top
-					int_y = world_rect.mTop;
-				}
-				int_x = lltrunc(((GLdouble)int_y - center_y) / line_slope + center_x);
-			}
-			else if (fabs(line_slope) < rect_slope)
-			{
-				if (line_x < 0.f)
-				{
-					// left
-					int_x = world_rect.mLeft;
-				}
-				else
-				{
-					// right
-					int_x = world_rect.mRight;
-				}
-				int_y = lltrunc(((GLdouble)int_x - center_x) * line_slope + center_y);
-			}
-			else
-			{
-				// exactly parallel ==> push to the corners
-				if (line_x > 0.f)
-				{
-					int_x = world_rect.mRight;
-				}
-				else
-				{
-					int_x = world_rect.mLeft;
-				}
-				if (line_y > 0.0f)
-				{
-					int_y = world_rect.mTop;
-				}
-				else
-				{
-					int_y = world_rect.mBottom;
-				}
-			}
-		}
-		if (!in_front)
-		{
-			int_x = world_rect.mLeft + world_rect.mRight - int_x;
-			int_y = world_rect.mBottom + world_rect.mTop - int_y;
-		}
-
-		out_point.mX = int_x + world_rect.mLeft;
-		out_point.mY = int_y + world_rect.mBottom;
-		return true;
-	}
-	return false;
-}
-
-
-void LLViewerCamera::getPixelVectors(const LLVector3 &pos_agent, LLVector3 &up, LLVector3 &right)
-{
-	LLVector3 to_vec = pos_agent - getOrigin();
-
-	F32 at_dist = to_vec * getAtAxis();
-
-	F32 height_meters = at_dist* (F32)tan(getView()/2.f);
-	F32 height_pixels = getViewHeightInPixels()/2.f;
-
-	F32 pixel_aspect = gViewerWindow->getWindow()->getPixelAspectRatio();
-
-	F32 meters_per_pixel = height_meters / height_pixels;
-	up = getUpAxis() * meters_per_pixel * gViewerWindow->getDisplayScale().mV[VY];
-	right = -1.f * pixel_aspect * meters_per_pixel * getLeftAxis() * gViewerWindow->getDisplayScale().mV[VX];
-}
-
-LLVector3 LLViewerCamera::roundToPixel(const LLVector3 &pos_agent)
-{
-	F32 dist = (pos_agent - getOrigin()).magVec();
-	// Convert to screen space and back, preserving the depth.
-	LLCoordGL screen_point;
-	if (!projectPosAgentToScreen(pos_agent, screen_point, false))
-	{
-		// Off the screen, just return the original position.
-		return pos_agent;
-	}
-
-	LLVector3 ray_dir;
-
-	projectScreenToPosAgent(screen_point.mX, screen_point.mY, &ray_dir);
-	ray_dir -= getOrigin();
-	ray_dir.normVec();
-
-	LLVector3 pos_agent_rounded = getOrigin() + ray_dir*dist;
-
-	/*
-	LLVector3 pixel_x, pixel_y;
-	getPixelVectors(pos_agent_rounded, pixel_y, pixel_x);
-	pos_agent_rounded += 0.5f*pixel_x, 0.5f*pixel_y;
-	*/
-	return pos_agent_rounded;
-}
-
-bool LLViewerCamera::cameraUnderWater() const
-{
-    LLViewerRegion* regionp = LLWorld::instance().getRegionFromPosAgent(getOrigin());
-
-    if (!regionp)
-    {
-        regionp = gAgent.getRegion();
-    }
-
-	if(!regionp)
-	{
-		return false ;
-	}
-
-	return getOrigin().mV[VZ] < regionp->getWaterHeight();
-}
-
-bool LLViewerCamera::areVertsVisible(LLViewerObject* volumep, bool all_verts)
-{
-	S32 i, num_faces;
-	LLDrawable* drawablep = volumep->mDrawable;
-
-	if (!drawablep)
-	{
-		return false;
-	}
-
-	LLVolume* volume = volumep->getVolume();
-	if (!volume)
-	{
-		return false;
-	}
-
-	LLVOVolume* vo_volume = (LLVOVolume*) volumep;
-
-	vo_volume->updateRelativeXform();
-	LLMatrix4 mat = vo_volume->getRelativeXform();
-	
-	LLMatrix4 render_mat(vo_volume->getRenderRotation(), LLVector4(vo_volume->getRenderPosition()));
-
-	LLMatrix4a render_mata;
-	render_mata.loadu(render_mat);
-	LLMatrix4a mata;
-	mata.loadu(mat);
-
-	num_faces = volume->getNumVolumeFaces();
-	for (i = 0; i < num_faces; i++)
-	{
-		const LLVolumeFace& face = volume->getVolumeFace(i);
-				
-		for (U32 v = 0; v < face.mNumVertices; v++)
-		{
-			const LLVector4a& src_vec = face.mPositions[v];
-			LLVector4a vec;
-			mata.affineTransform(src_vec, vec);
-
-			if (drawablep->isActive())
-			{
-				LLVector4a t = vec;
-				render_mata.affineTransform(t, vec);
-			}
-
-			bool in_frustum = pointInFrustum(LLVector3(vec.getF32ptr())) > 0;
-
-			if (( !in_frustum && all_verts) ||
-				 (in_frustum && !all_verts))
-			{
-				return !all_verts;
-			}
-		}
-	}
-	return all_verts;
-}
-
-extern bool gCubeSnapshot;
-
-// changes local camera and broadcasts change
-/* virtual */ void LLViewerCamera::setView(F32 vertical_fov_rads)
-{
-    llassert(!gCubeSnapshot);
-
-	F32 old_fov = LLViewerCamera::getInstance()->getView();
-
-	// cap the FoV
-	vertical_fov_rads = llclamp(vertical_fov_rads, getMinView(), getMaxView());
-
-	if (vertical_fov_rads == old_fov) return;
-
-	// send the new value to the simulator
-	LLMessageSystem* msg = gMessageSystem;
-	msg->newMessageFast(_PREHASH_AgentFOV);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-	msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-	msg->addU32Fast(_PREHASH_CircuitCode, gMessageSystem->mOurCircuitCode);
-
-	msg->nextBlockFast(_PREHASH_FOVBlock);
-	msg->addU32Fast(_PREHASH_GenCounter, 0);
-	msg->addF32Fast(_PREHASH_VerticalAngle, vertical_fov_rads);
-
-	gAgent.sendReliableMessage();
-
-	// sync the camera with the new value
-	LLCamera::setView(vertical_fov_rads); // call base implementation
-}
-
-void LLViewerCamera::setViewNoBroadcast(F32 vertical_fov_rads)
-{
-    LLCamera::setView(vertical_fov_rads);
-}
-
-void LLViewerCamera::setDefaultFOV(F32 vertical_fov_rads) 
-{
-	vertical_fov_rads = llclamp(vertical_fov_rads, getMinView(), getMaxView());
-	setView(vertical_fov_rads);
-	mCameraFOVDefault = vertical_fov_rads; 
-	mCosHalfCameraFOV = cosf(mCameraFOVDefault * 0.5f);
-}
-
-bool LLViewerCamera::isDefaultFOVChanged()
-{
-	if(mPrevCameraFOVDefault != mCameraFOVDefault)
-	{
-		mPrevCameraFOVDefault = mCameraFOVDefault;
-		return !gSavedSettings.getBOOL("IgnoreFOVZoomForLODs");
-	}
-	return false;
-}
-
-// static
-void LLViewerCamera::updateCameraAngle( void* user_data, const LLSD& value)
-{
-	LLViewerCamera* self=(LLViewerCamera*)user_data;
-	self->setDefaultFOV(value.asReal());	
-}
-
+/**

+ * @file llviewercamera.cpp

+ * @brief LLViewerCamera class implementation

+ *

+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$

+ * Second Life Viewer Source Code

+ * Copyright (C) 2010, Linden Research, Inc.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation;

+ * version 2.1 of the License only.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+ *

+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

+ * $/LicenseInfo$

+ */

+

+#include "llviewerprecompiledheaders.h"

+

+#define LLVIEWERCAMERA_CPP

+#include "llviewercamera.h"

+

+// Viewer includes

+#include "llagent.h"

+#include "llagentcamera.h"

+#include "llmatrix4a.h"

+#include "llviewercontrol.h"

+#include "llviewerobjectlist.h"

+#include "llviewerregion.h"

+#include "llviewerwindow.h"

+#include "llvovolume.h"

+#include "llworld.h"

+#include "lltoolmgr.h"

+#include "llviewerjoystick.h"

+

+// Linden library includes

+#include "lldrawable.h"

+#include "llface.h"

+#include "llgl.h"

+#include "llglheaders.h"

+#include "llquaternion.h"

+#include "llwindow.h"           // getPixelAspectRatio()

+#include "lltracerecording.h"

+#include "llenvironment.h"

+

+// System includes

+#include <iomanip> // for setprecision

+

+LLTrace::CountStatHandle<> LLViewerCamera::sVelocityStat("camera_velocity");

+LLTrace::CountStatHandle<> LLViewerCamera::sAngularVelocityStat("camera_angular_velocity");

+

+LLViewerCamera::eCameraID LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD;

+

+//glu pick matrix implementation borrowed from Mesa3D

+glh::matrix4f gl_pick_matrix(GLfloat x, GLfloat y, GLfloat width, GLfloat height, GLint* viewport)

+{

+    GLfloat m[16];

+    GLfloat sx, sy;

+    GLfloat tx, ty;

+

+    sx = viewport[2] / width;

+    sy = viewport[3] / height;

+    tx = (viewport[2] + 2.f * (viewport[0] - x)) / width;

+    ty = (viewport[3] + 2.f * (viewport[1] - y)) / height;

+

+    #define M(row,col) m[col*4+row]

+    M(0,0) = sx; M(0,1) = 0.f; M(0,2) = 0.f; M(0,3) = tx;

+    M(1,0) = 0.f; M(1,1) = sy; M(1,2) = 0.f; M(1,3) = ty;

+    M(2,0) = 0.f; M(2,1) = 0.f; M(2,2) = 1.f; M(2,3) = 0.f;

+    M(3,0) = 0.f; M(3,1) = 0.f; M(3,2) = 0.f; M(3,3) = 1.f;

+    #undef M

+

+    return glh::matrix4f(m);

+}

+

+LLViewerCamera::LLViewerCamera() : LLCamera()

+{

+    calcProjection(getFar());

+    mCameraFOVDefault = DEFAULT_FIELD_OF_VIEW;

+    mPrevCameraFOVDefault = DEFAULT_FIELD_OF_VIEW;

+    mCosHalfCameraFOV = cosf(mCameraFOVDefault * 0.5f);

+    mPixelMeterRatio = 0.f;

+    mScreenPixelArea = 0;

+    mZoomFactor = 1.f;

+    mZoomSubregion = 1;

+    mAverageSpeed = 0.f;

+    mAverageAngularSpeed = 0.f;

+    gSavedSettings.getControl("CameraAngle")->getCommitSignal()->connect(boost::bind(&LLViewerCamera::updateCameraAngle, this, _2));

+}

+

+void LLViewerCamera::updateCameraLocation(const LLVector3 &center, const LLVector3 &up_direction, const LLVector3 &point_of_interest)

+{

+    // do not update if avatar didn't move

+    if (!LLViewerJoystick::getInstance()->getCameraNeedsUpdate())

+    {

+        return;

+    }

+

+    LLVector3 last_position;

+    LLVector3 last_axis;

+    last_position = getOrigin();

+    last_axis     = getAtAxis();

+

+    mLastPointOfInterest = point_of_interest;

+

+    LLViewerRegion* regp = LLWorld::instance().getRegionFromPosAgent(getOrigin());

+    if (!regp)

+    {

+        regp = gAgent.getRegion();

+    }

+

+    F32 water_height = (NULL != regp) ? regp->getWaterHeight() : 0.f;

+

+    LLVector3 origin = center;

+

+    {

+        if (origin.mV[2] > water_height)

+        {

+            origin.mV[2] = llmax(origin.mV[2], water_height + 0.20f);

+        }

+        else

+        {

+            origin.mV[2] = llmin(origin.mV[2], water_height - 0.20f);

+        }

+    }

+

+    setOriginAndLookAt(origin, up_direction, point_of_interest);

+

+    mVelocityDir = origin - last_position ;

+    F32 dpos = mVelocityDir.normVec() ;

+    LLQuaternion rotation;

+    rotation.shortestArc(last_axis, getAtAxis());

+

+    F32 x, y, z;

+    F32 drot;

+    rotation.getAngleAxis(&drot, &x, &y, &z);

+

+    add(sVelocityStat, dpos);

+    add(sAngularVelocityStat, drot);

+

+    mAverageSpeed = LLTrace::get_frame_recording().getPeriodMeanPerSec(sVelocityStat, 50);

+    mAverageAngularSpeed = LLTrace::get_frame_recording().getPeriodMeanPerSec(sAngularVelocityStat);

+    mCosHalfCameraFOV = cosf(0.5f * getView() * llmax(1.0f, getAspect()));

+

+    // update pixel meter ratio using default fov, not modified one

+    mPixelMeterRatio = getViewHeightInPixels()/ (2.f*tanf(mCameraFOVDefault*0.5));

+    // update screen pixel area

+    mScreenPixelArea =(S32)((F32)getViewHeightInPixels() * ((F32)getViewHeightInPixels() * getAspect()));

+}

+

+const LLMatrix4 &LLViewerCamera::getProjection() const

+{

+    calcProjection(getFar());

+    return mProjectionMatrix;

+

+}

+

+const LLMatrix4 &LLViewerCamera::getModelview() const

+{

+    LLMatrix4 cfr(OGL_TO_CFR_ROTATION);

+    getMatrixToLocal(mModelviewMatrix);

+    mModelviewMatrix *= cfr;

+    return mModelviewMatrix;

+}

+

+void LLViewerCamera::calcProjection(const F32 far_distance) const

+{

+    F32 fov_y, z_far, z_near, aspect, f;

+    fov_y = getView();

+    z_far = far_distance;

+    z_near = getNear();

+    aspect = getAspect();

+

+    f = 1/tan(fov_y*0.5f);

+

+    mProjectionMatrix.setZero();

+    mProjectionMatrix.mMatrix[0][0] = f/aspect;

+    mProjectionMatrix.mMatrix[1][1] = f;

+    mProjectionMatrix.mMatrix[2][2] = (z_far + z_near)/(z_near - z_far);

+    mProjectionMatrix.mMatrix[3][2] = (2*z_far*z_near)/(z_near - z_far);

+    mProjectionMatrix.mMatrix[2][3] = -1;

+}

+

+// Sets up opengl state for 3D drawing.  If for selection, also

+// sets up a pick matrix.  x and y are ignored if for_selection is false.

+// The picking region is centered on x,y and has the specified width and

+// height.

+

+//static

+void LLViewerCamera::updateFrustumPlanes(LLCamera& camera, bool ortho, bool zflip, bool no_hacks)

+{

+    GLint* viewport = (GLint*) gGLViewport;

+    F64 model[16];

+    F64 proj[16];

+

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

+    {

+        model[i] = (F64) gGLModelView[i];

+        proj[i] = (F64) gGLProjection[i];

+    }

+

+    GLdouble objX,objY,objZ;

+

+    LLVector3 frust[8];

+

+    if (no_hacks)

+    {

+        gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);

+

+        gluUnProject(viewport[0],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);

+        frust[4].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);

+        frust[5].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);

+        frust[6].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);

+        frust[7].setVec((F32)objX,(F32)objY,(F32)objZ);

+    }

+    else if (zflip)

+    {

+        gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);

+

+        gluUnProject(viewport[0],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);

+        frust[4].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);

+        frust[5].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);

+        frust[6].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);

+        frust[7].setVec((F32)objX,(F32)objY,(F32)objZ);

+

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

+        {

+            frust[i+4] = frust[i+4]-frust[i];

+            frust[i+4].normVec();

+            frust[i+4] = frust[i] + frust[i+4]*camera.getFar();

+        }

+    }

+    else

+    {

+        gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);

+        gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);

+        frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);

+

+        if (ortho)

+        {

+            LLVector3 far_shift = camera.getAtAxis()*camera.getFar()*2.f;

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

+            {

+                frust[i+4] = frust[i] + far_shift;

+            }

+        }

+        else

+        {

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

+            {

+                LLVector3 vec = frust[i] - camera.getOrigin();

+                vec.normVec();

+                frust[i+4] = camera.getOrigin() + vec*camera.getFar();

+            }

+        }

+    }

+

+    camera.calcAgentFrustumPlanes(frust);

+}

+

+void LLViewerCamera::setPerspective(bool for_selection,

+                                    S32 x, S32 y_from_bot, S32 width, S32 height,

+                                    bool limit_select_distance,

+                                    F32 z_near, F32 z_far)

+{

+    F32 fov_y, aspect;

+    fov_y = RAD_TO_DEG * getView();

+    bool z_default_far = false;

+    if (z_far <= 0)

+    {

+        z_default_far = true;

+        z_far = getFar();

+    }

+    if (z_near <= 0)

+    {

+        z_near = getNear();

+    }

+    aspect = getAspect();

+

+    // Load camera view matrix

+    gGL.matrixMode(LLRender::MM_PROJECTION);

+    gGL.loadIdentity();

+

+    glh::matrix4f proj_mat;

+

+    if (for_selection)

+    {

+        // make a tiny little viewport

+        // anything drawn into this viewport will be "selected"

+

+        GLint viewport[4];

+        viewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft;

+        viewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom;

+        viewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth();

+        viewport[3] = gViewerWindow->getWorldViewRectRaw().getHeight();

+

+        proj_mat = gl_pick_matrix(x+width/2.f, y_from_bot+height/2.f, (GLfloat) width, (GLfloat) height, viewport);

+

+        if (limit_select_distance)

+        {

+            // ...select distance from control

+            z_far = gSavedSettings.getF32("MaxSelectDistance");

+        }

+        else

+        {

+            z_far = gAgentCamera.mDrawDistance;

+        }

+    }

+    else

+    {

+        // Only override the far clip if it's not passed in explicitly.

+        if (z_default_far)

+        {

+            z_far = MAX_FAR_CLIP;

+        }

+        glViewport(x, y_from_bot, width, height);

+        gGLViewport[0] = x;

+        gGLViewport[1] = y_from_bot;

+        gGLViewport[2] = width;

+        gGLViewport[3] = height;

+    }

+

+    if (mZoomFactor > 1.f)

+    {

+        float offset = mZoomFactor - 1.f;

+        int pos_y = mZoomSubregion / llceil(mZoomFactor);

+        int pos_x = mZoomSubregion - (pos_y*llceil(mZoomFactor));

+        glh::matrix4f translate;

+        translate.set_translate(glh::vec3f(offset - (F32)pos_x * 2.f, offset - (F32)pos_y * 2.f, 0.f));

+        glh::matrix4f scale;

+        scale.set_scale(glh::vec3f(mZoomFactor, mZoomFactor, 1.f));

+

+        proj_mat = scale*proj_mat;

+        proj_mat = translate*proj_mat;

+    }

+

+    calcProjection(z_far); // Update the projection matrix cache

+

+    proj_mat *= gl_perspective(fov_y,aspect,z_near,z_far);

+

+    gGL.loadMatrix(proj_mat.m);

+

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

+    {

+        gGLProjection[i] = proj_mat.m[i];

+    }

+

+    gGL.matrixMode(LLRender::MM_MODELVIEW);

+

+    glh::matrix4f modelview((GLfloat*) OGL_TO_CFR_ROTATION);

+

+    GLfloat         ogl_matrix[16];

+

+    getOpenGLTransform(ogl_matrix);

+

+    modelview *= glh::matrix4f(ogl_matrix);

+

+    gGL.loadMatrix(modelview.m);

+

+    if (for_selection && (width > 1 || height > 1))

+    {

+        // NB: as of this writing, i believe the code below is broken (doesn't take into account the world view, assumes entire window)

+        // however, it is also unused (the GL matricies are used for selection, (see LLCamera::sphereInFrustum())) and so i'm not

+        // comfortable hacking on it.

+        calculateFrustumPlanesFromWindow((F32)(x - width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,

+                                (F32)(y_from_bot - height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f,

+                                (F32)(x + width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,

+                                (F32)(y_from_bot + height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f);

+

+    }

+

+    // if not picking and not doing a snapshot, cache various GL matrices

+    if (!for_selection && mZoomFactor == 1.f)

+    {

+        // Save GL matrices for access elsewhere in code, especially project_world_to_screen

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

+        {

+            gGLModelView[i] = modelview.m[i];

+        }

+    }

+

+    updateFrustumPlanes(*this);

+}

+

+

+// Uses the last GL matrices set in set_perspective to project a point from

+// screen coordinates to the agent's region.

+void LLViewerCamera::projectScreenToPosAgent(const S32 screen_x, const S32 screen_y, LLVector3* pos_agent) const

+{

+    GLdouble x, y, z;

+

+    F64 mdlv[16];

+    F64 proj[16];

+

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

+    {

+        mdlv[i] = (F64) gGLModelView[i];

+        proj[i] = (F64) gGLProjection[i];

+    }

+

+    gluUnProject(

+        GLdouble(screen_x), GLdouble(screen_y), 0.0,

+        mdlv, proj, (GLint*)gGLViewport,

+        &x,

+        &y,

+        &z );

+    pos_agent->setVec( (F32)x, (F32)y, (F32)z );

+}

+

+// Uses the last GL matrices set in set_perspective to project a point from

+// the agent's region space to screen coordinates.  Returns true if point in within

+// the current window.

+bool LLViewerCamera::projectPosAgentToScreen(const LLVector3 &pos_agent, LLCoordGL &out_point, const bool clamp) const

+{

+    bool in_front = true;

+    GLdouble    x, y, z;            // object's window coords, GL-style

+

+    LLVector3 dir_to_point = pos_agent - getOrigin();

+    dir_to_point /= dir_to_point.magVec();

+

+    if (dir_to_point * getAtAxis() < 0.f)

+    {

+        if (clamp)

+        {

+            return false;

+        }

+        else

+        {

+            in_front = false;

+        }

+    }

+

+    LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();

+    S32 viewport[4];

+    viewport[0] = world_view_rect.mLeft;

+    viewport[1] = world_view_rect.mBottom;

+    viewport[2] = world_view_rect.getWidth();

+    viewport[3] = world_view_rect.getHeight();

+

+    F64 mdlv[16];

+    F64 proj[16];

+

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

+    {

+        mdlv[i] = (F64) gGLModelView[i];

+        proj[i] = (F64) gGLProjection[i];

+    }

+

+    if (GL_TRUE == gluProject(pos_agent.mV[VX], pos_agent.mV[VY], pos_agent.mV[VZ],

+                                mdlv, proj, (GLint*)viewport,

+                                &x, &y, &z))

+    {

+        // convert screen coordinates to virtual UI coordinates

+        x /= gViewerWindow->getDisplayScale().mV[VX];

+        y /= gViewerWindow->getDisplayScale().mV[VY];

+

+        // should now have the x,y coords of grab_point in screen space

+        LLRect world_rect = gViewerWindow->getWorldViewRectScaled();

+

+        // convert to pixel coordinates

+        S32 int_x = lltrunc(x);

+        S32 int_y = lltrunc(y);

+

+        bool valid = true;

+

+        if (clamp)

+        {

+            if (int_x < world_rect.mLeft)

+            {

+                out_point.mX = world_rect.mLeft;

+                valid = false;

+            }

+            else if (int_x > world_rect.mRight)

+            {

+                out_point.mX = world_rect.mRight;

+                valid = false;

+            }

+            else

+            {

+                out_point.mX = int_x;

+            }

+

+            if (int_y < world_rect.mBottom)

+            {

+                out_point.mY = world_rect.mBottom;

+                valid = false;

+            }

+            else if (int_y > world_rect.mTop)

+            {

+                out_point.mY = world_rect.mTop;

+                valid = false;

+            }

+            else

+            {

+                out_point.mY = int_y;

+            }

+            return valid;

+        }

+        else

+        {

+            out_point.mX = int_x;

+            out_point.mY = int_y;

+

+            if (int_x < world_rect.mLeft)

+            {

+                valid = false;

+            }

+            else if (int_x > world_rect.mRight)

+            {

+                valid = false;

+            }

+            if (int_y < world_rect.mBottom)

+            {

+                valid = false;

+            }

+            else if (int_y > world_rect.mTop)

+            {

+                valid = false;

+            }

+

+            return in_front && valid;

+        }

+    }

+    else

+    {

+        return false;

+    }

+}

+

+// Uses the last GL matrices set in set_perspective to project a point from

+// the agent's region space to the nearest edge in screen coordinates.

+// Returns true if projection succeeds.

+bool LLViewerCamera::projectPosAgentToScreenEdge(const LLVector3 &pos_agent,

+                                                LLCoordGL &out_point) const

+{

+    LLVector3 dir_to_point = pos_agent - getOrigin();

+    dir_to_point /= dir_to_point.magVec();

+

+    bool in_front = true;

+    if (dir_to_point * getAtAxis() < 0.f)

+    {

+        in_front = false;

+    }

+

+    LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();

+    S32 viewport[4];

+    viewport[0] = world_view_rect.mLeft;

+    viewport[1] = world_view_rect.mBottom;

+    viewport[2] = world_view_rect.getWidth();

+    viewport[3] = world_view_rect.getHeight();

+    GLdouble    x, y, z;            // object's window coords, GL-style

+

+    F64 mdlv[16];

+    F64 proj[16];

+

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

+    {

+        mdlv[i] = (F64) gGLModelView[i];

+        proj[i] = (F64) gGLProjection[i];

+    }

+

+    if (GL_TRUE == gluProject(pos_agent.mV[VX], pos_agent.mV[VY],

+                              pos_agent.mV[VZ], mdlv,

+                              proj, (GLint*)viewport,

+                              &x, &y, &z))

+    {

+        x /= gViewerWindow->getDisplayScale().mV[VX];

+        y /= gViewerWindow->getDisplayScale().mV[VY];

+        // should now have the x,y coords of grab_point in screen space

+        const LLRect& world_rect = gViewerWindow->getWorldViewRectScaled();

+

+        // ...sanity check

+        S32 int_x = lltrunc(x);

+        S32 int_y = lltrunc(y);

+

+        // find the center

+        GLdouble center_x = (GLdouble)world_rect.getCenterX();

+        GLdouble center_y = (GLdouble)world_rect.getCenterY();

+

+        if (x == center_x  &&  y == center_y)

+        {

+            // can't project to edge from exact center

+            return false;

+        }

+

+        // find the line from center to local

+        GLdouble line_x = x - center_x;

+        GLdouble line_y = y - center_y;

+

+        int_x = lltrunc(center_x);

+        int_y = lltrunc(center_y);

+

+

+        if (0.f == line_x)

+        {

+            // the slope of the line is undefined

+            if (line_y > 0.f)

+            {

+                int_y = world_rect.mTop;

+            }

+            else

+            {

+                int_y = world_rect.mBottom;

+            }

+        }

+        else if (0 == world_rect.getWidth())

+        {

+            // the diagonal slope of the view is undefined

+            if (y < world_rect.mBottom)

+            {

+                int_y = world_rect.mBottom;

+            }

+            else if ( y > world_rect.mTop)

+            {

+                int_y = world_rect.mTop;

+            }

+        }

+        else

+        {

+            F32 line_slope = (F32)(line_y / line_x);

+            F32 rect_slope = ((F32)world_rect.getHeight()) / ((F32)world_rect.getWidth());

+

+            if (fabs(line_slope) > rect_slope)

+            {

+                if (line_y < 0.f)

+                {

+                    // bottom

+                    int_y = world_rect.mBottom;

+                }

+                else

+                {

+                    // top

+                    int_y = world_rect.mTop;

+                }

+                int_x = lltrunc(((GLdouble)int_y - center_y) / line_slope + center_x);

+            }

+            else if (fabs(line_slope) < rect_slope)

+            {

+                if (line_x < 0.f)

+                {

+                    // left

+                    int_x = world_rect.mLeft;

+                }

+                else

+                {

+                    // right

+                    int_x = world_rect.mRight;

+                }

+                int_y = lltrunc(((GLdouble)int_x - center_x) * line_slope + center_y);

+            }

+            else

+            {

+                // exactly parallel ==> push to the corners

+                if (line_x > 0.f)

+                {

+                    int_x = world_rect.mRight;

+                }

+                else

+                {

+                    int_x = world_rect.mLeft;

+                }

+                if (line_y > 0.0f)

+                {

+                    int_y = world_rect.mTop;

+                }

+                else

+                {

+                    int_y = world_rect.mBottom;

+                }

+            }

+        }

+        if (!in_front)

+        {

+            int_x = world_rect.mLeft + world_rect.mRight - int_x;

+            int_y = world_rect.mBottom + world_rect.mTop - int_y;

+        }

+

+        out_point.mX = int_x + world_rect.mLeft;

+        out_point.mY = int_y + world_rect.mBottom;

+        return true;

+    }

+    return false;

+}

+

+

+void LLViewerCamera::getPixelVectors(const LLVector3 &pos_agent, LLVector3 &up, LLVector3 &right)

+{

+    LLVector3 to_vec = pos_agent - getOrigin();

+

+    F32 at_dist = to_vec * getAtAxis();

+

+    F32 height_meters = at_dist* (F32)tan(getView()/2.f);

+    F32 height_pixels = getViewHeightInPixels()/2.f;

+

+    F32 pixel_aspect = gViewerWindow->getWindow()->getPixelAspectRatio();

+

+    F32 meters_per_pixel = height_meters / height_pixels;

+    up = getUpAxis() * meters_per_pixel * gViewerWindow->getDisplayScale().mV[VY];

+    right = -1.f * pixel_aspect * meters_per_pixel * getLeftAxis() * gViewerWindow->getDisplayScale().mV[VX];

+}

+

+LLVector3 LLViewerCamera::roundToPixel(const LLVector3 &pos_agent)

+{

+    F32 dist = (pos_agent - getOrigin()).magVec();

+    // Convert to screen space and back, preserving the depth.

+    LLCoordGL screen_point;

+    if (!projectPosAgentToScreen(pos_agent, screen_point, false))

+    {

+        // Off the screen, just return the original position.

+        return pos_agent;

+    }

+

+    LLVector3 ray_dir;

+

+    projectScreenToPosAgent(screen_point.mX, screen_point.mY, &ray_dir);

+    ray_dir -= getOrigin();

+    ray_dir.normVec();

+

+    LLVector3 pos_agent_rounded = getOrigin() + ray_dir*dist;

+

+    /*

+    LLVector3 pixel_x, pixel_y;

+    getPixelVectors(pos_agent_rounded, pixel_y, pixel_x);

+    pos_agent_rounded += 0.5f*pixel_x, 0.5f*pixel_y;

+    */

+    return pos_agent_rounded;

+}

+

+bool LLViewerCamera::cameraUnderWater() const

+{

+    LLViewerRegion* regionp = LLWorld::instance().getRegionFromPosAgent(getOrigin());

+

+    if (!regionp)

+    {

+        regionp = gAgent.getRegion();

+    }

+

+    if(!regionp)

+    {

+        return false ;

+    }

+

+    return getOrigin().mV[VZ] < regionp->getWaterHeight();

+}

+

+bool LLViewerCamera::areVertsVisible(LLViewerObject* volumep, bool all_verts)

+{

+    S32 i, num_faces;

+    LLDrawable* drawablep = volumep->mDrawable;

+

+    if (!drawablep)

+    {

+        return false;

+    }

+

+    LLVolume* volume = volumep->getVolume();

+    if (!volume)

+    {

+        return false;

+    }

+

+    LLVOVolume* vo_volume = (LLVOVolume*) volumep;

+

+    vo_volume->updateRelativeXform();

+    LLMatrix4 mat = vo_volume->getRelativeXform();

+

+    LLMatrix4 render_mat(vo_volume->getRenderRotation(), LLVector4(vo_volume->getRenderPosition()));

+

+    LLMatrix4a render_mata;

+    render_mata.loadu(render_mat);

+    LLMatrix4a mata;

+    mata.loadu(mat);

+

+    num_faces = volume->getNumVolumeFaces();

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

+    {

+        const LLVolumeFace& face = volume->getVolumeFace(i);

+

+        for (U32 v = 0; v < face.mNumVertices; v++)

+        {

+            const LLVector4a& src_vec = face.mPositions[v];

+            LLVector4a vec;

+            mata.affineTransform(src_vec, vec);

+

+            if (drawablep->isActive())

+            {

+                LLVector4a t = vec;

+                render_mata.affineTransform(t, vec);

+            }

+

+            bool in_frustum = pointInFrustum(LLVector3(vec.getF32ptr())) > 0;

+

+            if (( !in_frustum && all_verts) ||

+                 (in_frustum && !all_verts))

+            {

+                return !all_verts;

+            }

+        }

+    }

+    return all_verts;

+}

+

+extern bool gCubeSnapshot;

+

+// changes local camera and broadcasts change

+/* virtual */ void LLViewerCamera::setView(F32 vertical_fov_rads)

+{

+    llassert(!gCubeSnapshot);

+

+    F32 old_fov = LLViewerCamera::getInstance()->getView();

+

+    // cap the FoV

+    vertical_fov_rads = llclamp(vertical_fov_rads, getMinView(), getMaxView());

+

+    if (vertical_fov_rads == old_fov) return;

+

+    // send the new value to the simulator

+    LLMessageSystem* msg = gMessageSystem;

+    msg->newMessageFast(_PREHASH_AgentFOV);

+    msg->nextBlockFast(_PREHASH_AgentData);

+    msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());

+    msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());

+    msg->addU32Fast(_PREHASH_CircuitCode, gMessageSystem->mOurCircuitCode);

+

+    msg->nextBlockFast(_PREHASH_FOVBlock);

+    msg->addU32Fast(_PREHASH_GenCounter, 0);

+    msg->addF32Fast(_PREHASH_VerticalAngle, vertical_fov_rads);

+

+    gAgent.sendReliableMessage();

+

+    // sync the camera with the new value

+    LLCamera::setView(vertical_fov_rads); // call base implementation

+}

+

+void LLViewerCamera::setViewNoBroadcast(F32 vertical_fov_rads)

+{

+    LLCamera::setView(vertical_fov_rads);

+}

+

+void LLViewerCamera::setDefaultFOV(F32 vertical_fov_rads)

+{

+    vertical_fov_rads = llclamp(vertical_fov_rads, getMinView(), getMaxView());

+    setView(vertical_fov_rads);

+    mCameraFOVDefault = vertical_fov_rads;

+    mCosHalfCameraFOV = cosf(mCameraFOVDefault * 0.5f);

+}

+

+bool LLViewerCamera::isDefaultFOVChanged()

+{

+    if(mPrevCameraFOVDefault != mCameraFOVDefault)

+    {

+        mPrevCameraFOVDefault = mCameraFOVDefault;

+        return !gSavedSettings.getBOOL("IgnoreFOVZoomForLODs");

+    }

+    return false;

+}

+

+// static

+void LLViewerCamera::updateCameraAngle( void* user_data, const LLSD& value)

+{

+    LLViewerCamera* self=(LLViewerCamera*)user_data;

+    self->setDefaultFOV(value.asReal());

+}

+