开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llviewercamera.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：23k
源码类别：

游戏引擎

开发平台：

C++ Builder

llviewercamera.cpp：源码内容
  1. /** 
  2.  * @file llviewercamera.cpp
  3.  * @brief LLViewerCamera class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #define LLVIEWERCAMERA_CPP
  36. #include "llviewercamera.h"
  38. // Viewer includes
  39. #include "llagent.h"
  40. #include "llviewercontrol.h"
  41. #include "llviewerobjectlist.h"
  42. #include "llviewerregion.h"
  43. #include "llviewerwindow.h"
  44. #include "llvovolume.h"
  45. #include "llworld.h"
  46. #include "lltoolmgr.h"
  47. #include "llviewerjoystick.h"
  49. // Linden library includes
  50. #include "lldrawable.h"
  51. #include "llface.h"
  52. #include "llgl.h"
  53. #include "llglheaders.h"
  54. #include "llquaternion.h"
  55. #include "llwindow.h" // getPixelAspectRatio()
  57. // System includes
  58. #include <iomanip> // for setprecision
  60. U32 LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD;
  62. //glu pick matrix implementation borrowed from Mesa3D
  63. glh::matrix4f gl_pick_matrix(GLfloat x, GLfloat y, GLfloat width, GLfloat height, GLint* viewport)
  64. {
  65. GLfloat m[16];
  66. GLfloat sx, sy;
  67. GLfloat tx, ty;
  69. sx = viewport[2] / width;
  70. sy = viewport[3] / height;
  71. tx = (viewport[2] + 2.f * (viewport[0] - x)) / width;
  72. ty = (viewport[3] + 2.f * (viewport[1] - y)) / height;
  74. #define M(row,col) m[col*4+row]
  75. M(0,0) = sx; M(0,1) = 0.f; M(0,2) = 0.f; M(0,3) = tx;
  76. M(1,0) = 0.f; M(1,1) = sy; M(1,2) = 0.f; M(1,3) = ty;
  77. M(2,0) = 0.f; M(2,1) = 0.f; M(2,2) = 1.f; M(2,3) = 0.f;
  78. M(3,0) = 0.f; M(3,1) = 0.f; M(3,2) = 0.f; M(3,3) = 1.f;
  79. #undef M
  81. return glh::matrix4f(m);
  82. }
  84. glh::matrix4f gl_perspective(GLfloat fovy, GLfloat aspect, GLfloat zNear, GLfloat zFar)
  85. {
  86. GLfloat f = 1.f/tanf(DEG_TO_RAD*fovy/2.f);
  88. return glh::matrix4f(f/aspect, 0, 0, 0,
  89.  0, f, 0, 0,
  90.  0, 0, (zFar+zNear)/(zNear-zFar), (2.f*zFar*zNear)/(zNear-zFar),
  91.  0, 0, -1.f, 0);
  92. }
  94. glh::matrix4f gl_lookat(LLVector3 eye, LLVector3 center, LLVector3 up)
  95. {
  96. LLVector3 f = center-eye;
  97. f.normVec();
  98. up.normVec();
  99. LLVector3 s = f % up;
  100. LLVector3 u = s % f;
  102. return glh::matrix4f(s[0], s[1], s[2], 0,
  103.   u[0], u[1], u[2], 0,
  104.   -f[0], -f[1], -f[2], 0,
  105.   0, 0, 0, 1);
  107. }
  109. // Build time optimization, generate this once in .cpp file
  110. template class LLViewerCamera* LLSingleton<class LLViewerCamera>::getInstance();
  112. LLViewerCamera::LLViewerCamera() : LLCamera()
  113. {
  114. calcProjection(getFar());
  115. mCameraFOVDefault = DEFAULT_FIELD_OF_VIEW;
  116. mCosHalfCameraFOV = cosf(mCameraFOVDefault * 0.5f);
  117. mPixelMeterRatio = 0.f;
  118. mScreenPixelArea = 0;
  119. mZoomFactor = 1.f;
  120. mZoomSubregion = 1;
  121. mAverageSpeed = 0.f;
  122. mAverageAngularSpeed = 0.f;
  123. gSavedSettings.getControl("CameraAngle")->getCommitSignal()->connect(boost::bind(&LLViewerCamera::updateCameraAngle, this, _2));
  124. }
  126. void LLViewerCamera::updateCameraLocation(const LLVector3 &center,
  127. const LLVector3 &up_direction,
  128. const LLVector3 &point_of_interest)
  129. {
  130. // do not update if avatar didn't move
  131. if (!LLViewerJoystick::getInstance()->getCameraNeedsUpdate())
  132. {
  133. return;
  134. }
  136. LLVector3 last_position;
  137. LLVector3 last_axis;
  138. last_position = getOrigin();
  139. last_axis = getAtAxis();
  141. mLastPointOfInterest = point_of_interest;
  143. // constrain to max distance from avatar
  144. LLVector3 camera_offset = center - gAgent.getPositionAgent();
  146. LLViewerRegion * regp = gAgent.getRegion();
  147. F32 water_height = (NULL != regp) ? regp->getWaterHeight() : 0.f;
  149. LLVector3 origin = center;
  150. if (origin.mV[2] > water_height)
  151. {
  152. origin.mV[2] = llmax(origin.mV[2], water_height+0.20f);
  153. }
  154. else
  155. {
  156. origin.mV[2] = llmin(origin.mV[2], water_height-0.20f);
  157. }
  159. setOriginAndLookAt(origin, up_direction, point_of_interest);
  161. mVelocityDir = center - last_position ; 
  162. F32 dpos = mVelocityDir.normVec() ;
  163. LLQuaternion rotation;
  164. rotation.shortestArc(last_axis, getAtAxis());
  166. F32 x, y, z;
  167. F32 drot;
  168. rotation.getAngleAxis(&drot, &x, &y, &z);
  170. mVelocityStat.addValue(dpos);
  171. mAngularVelocityStat.addValue(drot);
  173. mAverageSpeed = mVelocityStat.getMeanPerSec() ;
  174. mAverageAngularSpeed = mAngularVelocityStat.getMeanPerSec() ;
  175. mCosHalfCameraFOV = cosf(0.5f * getView() * llmax(1.0f, getAspect()));
  177. // update pixel meter ratio using default fov, not modified one
  178. mPixelMeterRatio = getViewHeightInPixels()/ (2.f*tanf(mCameraFOVDefault*0.5));
  179. // update screen pixel area
  180. mScreenPixelArea =(S32)((F32)getViewHeightInPixels() * ((F32)getViewHeightInPixels() * getAspect()));
  181. }
  183. const LLMatrix4 &LLViewerCamera::getProjection() const
  184. {
  185. calcProjection(getFar());
  186. return mProjectionMatrix;
  188. }
  190. const LLMatrix4 &LLViewerCamera::getModelview() const
  191. {
  192. LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
  193. getMatrixToLocal(mModelviewMatrix);
  194. mModelviewMatrix *= cfr;
  195. return mModelviewMatrix;
  196. }
  198. void LLViewerCamera::calcProjection(const F32 far_distance) const
  199. {
  200. F32 fov_y, z_far, z_near, aspect, f;
  201. fov_y = getView();
  202. z_far = far_distance;
  203. z_near = getNear();
  204. aspect = getAspect();
  206. f = 1/tan(fov_y*0.5f);
  208. mProjectionMatrix.setZero();
  209. mProjectionMatrix.mMatrix[0][0] = f/aspect;
  210. mProjectionMatrix.mMatrix[1][1] = f;
  211. mProjectionMatrix.mMatrix[2][2] = (z_far + z_near)/(z_near - z_far);
  212. mProjectionMatrix.mMatrix[3][2] = (2*z_far*z_near)/(z_near - z_far);
  213. mProjectionMatrix.mMatrix[2][3] = -1;
  214. }
  216. // Sets up opengl state for 3D drawing.  If for selection, also
  217. // sets up a pick matrix.  x and y are ignored if for_selection is false.
  218. // The picking region is centered on x,y and has the specified width and
  219. // height.
  221. //static
  222. void LLViewerCamera::updateFrustumPlanes(LLCamera& camera, BOOL ortho, BOOL zflip, BOOL no_hacks)
  223. {
  224. GLint* viewport = (GLint*) gGLViewport;
  225. GLdouble* model = gGLModelView;
  226. GLdouble* proj = gGLProjection;
  227. GLdouble objX,objY,objZ;
  229. LLVector3 frust[8];
  231. if (no_hacks)
  232. {
  233. gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
  234. frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
  235. gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
  236. frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
  237. gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
  238. frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
  239. gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
  240. frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
  242. gluUnProject(viewport[0],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
  243. frust[4].setVec((F32)objX,(F32)objY,(F32)objZ);
  244. gluUnProject(viewport[0]+viewport[2],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
  245. frust[5].setVec((F32)objX,(F32)objY,(F32)objZ);
  246. gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
  247. frust[6].setVec((F32)objX,(F32)objY,(F32)objZ);
  248. gluUnProject(viewport[0],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
  249. frust[7].setVec((F32)objX,(F32)objY,(F32)objZ);
  250. }
  251. else if (zflip)
  252. {
  253. gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
  254. frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
  255. gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
  256. frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
  257. gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
  258. frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
  259. gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
  260. frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
  262. gluUnProject(viewport[0],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
  263. frust[4].setVec((F32)objX,(F32)objY,(F32)objZ);
  264. gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
  265. frust[5].setVec((F32)objX,(F32)objY,(F32)objZ);
  266. gluUnProject(viewport[0]+viewport[2],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
  267. frust[6].setVec((F32)objX,(F32)objY,(F32)objZ);
  268. gluUnProject(viewport[0],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
  269. frust[7].setVec((F32)objX,(F32)objY,(F32)objZ);
  271. for (U32 i = 0; i < 4; i++)
  272. {
  273. frust[i+4] = frust[i+4]-frust[i];
  274. frust[i+4].normVec();
  275. frust[i+4] = frust[i] + frust[i+4]*camera.getFar();
  276. }
  277. }
  278. else
  279. {
  280. gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
  281. frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
  282. gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
  283. frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
  284. gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
  285. frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
  286. gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
  287. frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
  289. if (ortho)
  290. {
  291. LLVector3 far_shift = camera.getAtAxis()*camera.getFar()*2.f; 
  292. for (U32 i = 0; i < 4; i++)
  293. {
  294. frust[i+4] = frust[i] + far_shift;
  295. }
  296. }
  297. else
  298. {
  299. for (U32 i = 0; i < 4; i++)
  300. {
  301. LLVector3 vec = frust[i] - camera.getOrigin();
  302. vec.normVec();
  303. frust[i+4] = camera.getOrigin() + vec*camera.getFar();
  304. }
  305. }
  306. }
  308. camera.calcAgentFrustumPlanes(frust);
  309. }
  311. void LLViewerCamera::setPerspective(BOOL for_selection,
  312. S32 x, S32 y_from_bot, S32 width, S32 height,
  313. BOOL limit_select_distance,
  314. F32 z_near, F32 z_far)
  315. {
  316. F32 fov_y, aspect;
  317. fov_y = RAD_TO_DEG * getView();
  318. BOOL z_default_near, z_default_far = FALSE;
  319. if (z_far <= 0)
  320. {
  321. z_default_far = TRUE;
  322. z_far = getFar();
  323. }
  324. if (z_near <= 0)
  325. {
  326. z_default_near = TRUE;
  327. z_near = getNear();
  328. }
  329. aspect = getAspect();
  331. // Load camera view matrix
  332. glMatrixMode( GL_PROJECTION );
  333. glLoadIdentity();
  335. glh::matrix4f proj_mat;
  337. if (for_selection)
  338. {
  339. // make a tiny little viewport
  340. // anything drawn into this viewport will be "selected"
  341. GLint* viewport = (GLint*) gGLViewport;
  343. proj_mat = gl_pick_matrix(x+width/2.f, y_from_bot+height/2.f, (GLfloat) width, (GLfloat) height, viewport);
  345. if (limit_select_distance)
  346. {
  347. // ...select distance from control
  348. z_far = gSavedSettings.getF32("MaxSelectDistance");
  349. }
  350. else
  351. {
  352. z_far = gAgent.mDrawDistance;
  353. }
  354. }
  355. else
  356. {
  357. // Only override the far clip if it's not passed in explicitly.
  358. if (z_default_far)
  359. {
  360. z_far = MAX_FAR_CLIP;
  361. }
  362. glViewport(x, y_from_bot, width, height);
  363. gGLViewport[0] = x;
  364. gGLViewport[1] = y_from_bot;
  365. gGLViewport[2] = width;
  366. gGLViewport[3] = height;
  367. }
  369. if (mZoomFactor > 1.f)
  370. {
  371. float offset = mZoomFactor - 1.f;
  372. int pos_y = mZoomSubregion / llceil(mZoomFactor);
  373. int pos_x = mZoomSubregion - (pos_y*llceil(mZoomFactor));
  374. glh::matrix4f translate;
  375. translate.set_translate(glh::vec3f(offset - (F32)pos_x * 2.f, offset - (F32)pos_y * 2.f, 0.f));
  376. glh::matrix4f scale;
  377. scale.set_scale(glh::vec3f(mZoomFactor, mZoomFactor, 1.f));
  379. proj_mat = scale*proj_mat;
  380. proj_mat = translate*proj_mat;
  381. }
  383. calcProjection(z_far); // Update the projection matrix cache
  385. proj_mat *= gl_perspective(fov_y,aspect,z_near,z_far);
  387. glLoadMatrixf(proj_mat.m);
  389. for (U32 i = 0; i < 16; i++)
  390. {
  391. gGLProjection[i] = proj_mat.m[i];
  392. }
  394. glMatrixMode( GL_MODELVIEW );
  396. glh::matrix4f modelview((GLfloat*) OGL_TO_CFR_ROTATION);
  398. GLfloat ogl_matrix[16];
  400. getOpenGLTransform(ogl_matrix);
  402. modelview *= glh::matrix4f(ogl_matrix);
  404. glLoadMatrixf(modelview.m);
  406. if (for_selection && (width > 1 || height > 1))
  407. {
  408. calculateFrustumPlanesFromWindow((F32)(x - width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
  409. (F32)(y_from_bot - height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f,
  410. (F32)(x + width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
  411. (F32)(y_from_bot + height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f);
  413. }
  415. // if not picking and not doing a snapshot, cache various GL matrices
  416. if (!for_selection && mZoomFactor == 1.f)
  417. {
  418. // Save GL matrices for access elsewhere in code, especially project_world_to_screen
  419. //glGetDoublev(GL_MODELVIEW_MATRIX, gGLModelView);
  420. for (U32 i = 0; i < 16; i++)
  421. {
  422. gGLModelView[i] = modelview.m[i];
  423. }
  424. }
  426. updateFrustumPlanes(*this);
  428. /*if (gSavedSettings.getBOOL("CameraOffset"))
  429. {
  430. glMatrixMode(GL_PROJECTION);
  431. glTranslatef(0,0,-50);
  432. glRotatef(20.0,1,0,0);
  433. glMatrixMode(GL_MODELVIEW);
  434. }*/
  435. }
  438. // Uses the last GL matrices set in set_perspective to project a point from
  439. // screen coordinates to the agent's region.
  440. void LLViewerCamera::projectScreenToPosAgent(const S32 screen_x, const S32 screen_y, LLVector3* pos_agent) const
  441. {
  443. GLdouble x, y, z;
  444. gluUnProject(
  445. GLdouble(screen_x), GLdouble(screen_y), 0.0,
  446. gGLModelView, gGLProjection, (GLint*)gGLViewport,
  447. &x,
  448. &y,
  449. &z );
  450. pos_agent->setVec( (F32)x, (F32)y, (F32)z );
  451. }
  453. // Uses the last GL matrices set in set_perspective to project a point from
  454. // the agent's region space to screen coordinates.  Returns TRUE if point in within
  455. // the current window.
  456. BOOL LLViewerCamera::projectPosAgentToScreen(const LLVector3 &pos_agent, LLCoordGL &out_point, const BOOL clamp) const
  457. {
  458. BOOL in_front = TRUE;
  459. GLdouble x, y, z; // object's window coords, GL-style
  461. LLVector3 dir_to_point = pos_agent - getOrigin();
  462. dir_to_point /= dir_to_point.magVec();
  464. if (dir_to_point * getAtAxis() < 0.f)
  465. {
  466. if (clamp)
  467. {
  468. return FALSE;
  469. }
  470. else
  471. {
  472. in_front = FALSE;
  473. }
  474. }
  476. LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();
  477. S32 viewport[4];
  478. viewport[0] = world_view_rect.mLeft;
  479. viewport[1] = world_view_rect.mBottom;
  480. viewport[2] = world_view_rect.getWidth();
  481. viewport[3] = world_view_rect.getHeight();
  483. if (GL_TRUE == gluProject(pos_agent.mV[VX], pos_agent.mV[VY], pos_agent.mV[VZ],
  484. gGLModelView, gGLProjection, (GLint*)viewport,
  485. &x, &y, &z))
  486. {
  487. // convert screen coordinates to virtual UI coordinates
  488. x /= gViewerWindow->getDisplayScale().mV[VX];
  489. y /= gViewerWindow->getDisplayScale().mV[VY];
  491. // should now have the x,y coords of grab_point in screen space
  492. LLRect world_rect = gViewerWindow->getWorldViewRectScaled();
  494. // convert to pixel coordinates
  495. S32 int_x = lltrunc(x);
  496. S32 int_y = lltrunc(y);
  498. BOOL valid = TRUE;
  500. if (clamp)
  501. {
  502. if (int_x < world_rect.mLeft)
  503. {
  504. out_point.mX = world_rect.mLeft;
  505. valid = FALSE;
  506. }
  507. else if (int_x > world_rect.mRight)
  508. {
  509. out_point.mX = world_rect.mRight;
  510. valid = FALSE;
  511. }
  512. else
  513. {
  514. out_point.mX = int_x;
  515. }
  517. if (int_y < world_rect.mBottom)
  518. {
  519. out_point.mY = world_rect.mBottom;
  520. valid = FALSE;
  521. }
  522. else if (int_y > world_rect.mTop)
  523. {
  524. out_point.mY = world_rect.mTop;
  525. valid = FALSE;
  526. }
  527. else
  528. {
  529. out_point.mY = int_y;
  530. }
  531. return valid;
  532. }
  533. else
  534. {
  535. out_point.mX = int_x;
  536. out_point.mY = int_y;
  538. if (int_x < world_rect.mLeft)
  539. {
  540. valid = FALSE;
  541. }
  542. else if (int_x > world_rect.mRight)
  543. {
  544. valid = FALSE;
  545. }
  546. if (int_y < world_rect.mBottom)
  547. {
  548. valid = FALSE;
  549. }
  550. else if (int_y > world_rect.mTop)
  551. {
  552. valid = FALSE;
  553. }
  555. return in_front && valid;
  556. }
  557. }
  558. else
  559. {
  560. return FALSE;
  561. }
  562. }
  564. // Uses the last GL matrices set in set_perspective to project a point from
  565. // the agent's region space to the nearest edge in screen coordinates.
  566. // Returns TRUE if projection succeeds.
  567. BOOL LLViewerCamera::projectPosAgentToScreenEdge(const LLVector3 &pos_agent,
  568. LLCoordGL &out_point) const
  569. {
  570. LLVector3 dir_to_point = pos_agent - getOrigin();
  571. dir_to_point /= dir_to_point.magVec();
  573. BOOL in_front = TRUE;
  574. if (dir_to_point * getAtAxis() < 0.f)
  575. {
  576. in_front = FALSE;
  577. }
  579. LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();
  580. S32 viewport[4];
  581. viewport[0] = world_view_rect.mLeft;
  582. viewport[1] = world_view_rect.mBottom;
  583. viewport[2] = world_view_rect.getWidth();
  584. viewport[3] = world_view_rect.getHeight();
  585. GLdouble x, y, z; // object's window coords, GL-style
  586. if (GL_TRUE == gluProject(pos_agent.mV[VX], pos_agent.mV[VY],
  587.   pos_agent.mV[VZ], gGLModelView,
  588.   gGLProjection, (GLint*)viewport,
  589.   &x, &y, &z))
  590. {
  591. x /= gViewerWindow->getDisplayScale().mV[VX];
  592. y /= gViewerWindow->getDisplayScale().mV[VY];
  593. // should now have the x,y coords of grab_point in screen space
  594. const LLRect& world_rect = gViewerWindow->getWorldViewRectScaled();
  596. // ...sanity check
  597. S32 int_x = lltrunc(x);
  598. S32 int_y = lltrunc(y);
  600. // find the center
  601. GLdouble center_x = (GLdouble)world_rect.getCenterX();
  602. GLdouble center_y = (GLdouble)world_rect.getCenterY();
  604. if (x == center_x  &&  y == center_y)
  605. {
  606. // can't project to edge from exact center
  607. return FALSE;
  608. }
  610. // find the line from center to local
  611. GLdouble line_x = x - center_x;
  612. GLdouble line_y = y - center_y;
  614. int_x = lltrunc(center_x);
  615. int_y = lltrunc(center_y);
  618. if (0.f == line_x)
  619. {
  620. // the slope of the line is undefined
  621. if (line_y > 0.f)
  622. {
  623. int_y = world_rect.mTop;
  624. }
  625. else
  626. {
  627. int_y = world_rect.mBottom;
  628. }
  629. }
  630. else if (0 == world_rect.getWidth())
  631. {
  632. // the diagonal slope of the view is undefined
  633. if (y < world_rect.mBottom)
  634. {
  635. int_y = world_rect.mBottom;
  636. }
  637. else if ( y > world_rect.mTop)
  638. {
  639. int_y = world_rect.mTop;
  640. }
  641. }
  642. else
  643. {
  644. F32 line_slope = (F32)(line_y / line_x);
  645. F32 rect_slope = ((F32)world_rect.getHeight()) / ((F32)world_rect.getWidth());
  647. if (fabs(line_slope) > rect_slope)
  648. {
  649. if (line_y < 0.f)
  650. {
  651. // bottom
  652. int_y = world_rect.mBottom;
  653. }
  654. else
  655. {
  656. // top
  657. int_y = world_rect.mTop;
  658. }
  659. int_x = lltrunc(((GLdouble)int_y - center_y) / line_slope + center_x);
  660. }
  661. else if (fabs(line_slope) < rect_slope)
  662. {
  663. if (line_x < 0.f)
  664. {
  665. // left
  666. int_x = world_rect.mLeft;
  667. }
  668. else
  669. {
  670. // right
  671. int_x = world_rect.mRight;
  672. }
  673. int_y = lltrunc(((GLdouble)int_x - center_x) * line_slope + center_y);
  674. }
  675. else
  676. {
  677. // exactly parallel ==> push to the corners
  678. if (line_x > 0.f)
  679. {
  680. int_x = world_rect.mRight;
  681. }
  682. else
  683. {
  684. int_x = world_rect.mLeft;
  685. }
  686. if (line_y > 0.0f)
  687. {
  688. int_y = world_rect.mTop;
  689. }
  690. else
  691. {
  692. int_y = world_rect.mBottom;
  693. }
  694. }
  695. }
  696. if (!in_front)
  697. {
  698. int_x = world_rect.mLeft + world_rect.mRight - int_x;
  699. int_y = world_rect.mBottom + world_rect.mTop - int_y;
  700. }
  702. out_point.mX = int_x + world_rect.mLeft;
  703. out_point.mY = int_y + world_rect.mBottom;
  704. return TRUE;
  705. }
  706. return FALSE;
  707. }
  710. void LLViewerCamera::getPixelVectors(const LLVector3 &pos_agent, LLVector3 &up, LLVector3 &right)
  711. {
  712. LLVector3 to_vec = pos_agent - getOrigin();
  714. F32 at_dist = to_vec * getAtAxis();
  716. F32 height_meters = at_dist* (F32)tan(getView()/2.f);
  717. F32 height_pixels = getViewHeightInPixels()/2.f;
  719. F32 pixel_aspect = gViewerWindow->getWindow()->getPixelAspectRatio();
  721. F32 meters_per_pixel = height_meters / height_pixels;
  722. up = getUpAxis() * meters_per_pixel * gViewerWindow->getDisplayScale().mV[VY];
  723. right = -1.f * pixel_aspect * meters_per_pixel * getLeftAxis() * gViewerWindow->getDisplayScale().mV[VX];
  724. }
  726. LLVector3 LLViewerCamera::roundToPixel(const LLVector3 &pos_agent)
  727. {
  728. F32 dist = (pos_agent - getOrigin()).magVec();
  729. // Convert to screen space and back, preserving the depth.
  730. LLCoordGL screen_point;
  731. if (!projectPosAgentToScreen(pos_agent, screen_point, FALSE))
  732. {
  733. // Off the screen, just return the original position.
  734. return pos_agent;
  735. }
  737. LLVector3 ray_dir;
  739. projectScreenToPosAgent(screen_point.mX, screen_point.mY, &ray_dir);
  740. ray_dir -= getOrigin();
  741. ray_dir.normVec();
  743. LLVector3 pos_agent_rounded = getOrigin() + ray_dir*dist;
  745. /*
  746. LLVector3 pixel_x, pixel_y;
  747. getPixelVectors(pos_agent_rounded, pixel_y, pixel_x);
  748. pos_agent_rounded += 0.5f*pixel_x, 0.5f*pixel_y;
  749. */
  750. return pos_agent_rounded;
  751. }
  753. BOOL LLViewerCamera::cameraUnderWater() const
  754. {
  755. return getOrigin().mV[VZ] < gAgent.getRegion()->getWaterHeight();
  756. }
  758. BOOL LLViewerCamera::areVertsVisible(LLViewerObject* volumep, BOOL all_verts)
  759. {
  760. S32 i, num_faces;
  761. LLDrawable* drawablep = volumep->mDrawable;
  763. if (!drawablep)
  764. {
  765. return FALSE;
  766. }
  768. LLVolume* volume = volumep->getVolume();
  769. if (!volume)
  770. {
  771. return FALSE;
  772. }
  774. LLVOVolume* vo_volume = (LLVOVolume*) volumep;
  776. vo_volume->updateRelativeXform();
  777. LLMatrix4 mat = vo_volume->getRelativeXform();
  779. LLMatrix4 render_mat(vo_volume->getRenderRotation(), LLVector4(vo_volume->getRenderPosition()));
  781. num_faces = volume->getNumVolumeFaces();
  782. for (i = 0; i < num_faces; i++)
  783. {
  784. const LLVolumeFace& face = volume->getVolumeFace(i);
  786. for (U32 v = 0; v < face.mVertices.size(); v++)
  787. {
  788. LLVector4 vec = LLVector4(face.mVertices[v].mPosition) * mat;
  790. if (drawablep->isActive())
  791. {
  792. vec = vec * render_mat;
  793. }
  795. BOOL in_frustum = pointInFrustum(LLVector3(vec)) > 0;
  797. if (( !in_frustum && all_verts) ||
  798.  (in_frustum && !all_verts))
  799. {
  800. return !all_verts;
  801. }
  802. }
  803. }
  804. return all_verts;
  805. }
  807. // changes local camera and broadcasts change
  808. /* virtual */ void LLViewerCamera::setView(F32 vertical_fov_rads)
  809. {
  810. F32 old_fov = LLViewerCamera::getInstance()->getView();
  812. // cap the FoV
  813. vertical_fov_rads = llclamp(vertical_fov_rads, getMinView(), getMaxView());
  815. if (vertical_fov_rads == old_fov) return;
  817. // send the new value to the simulator
  818. LLMessageSystem* msg = gMessageSystem;
  819. msg->newMessageFast(_PREHASH_AgentFOV);
  820. msg->nextBlockFast(_PREHASH_AgentData);
  821. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  822. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  823. msg->addU32Fast(_PREHASH_CircuitCode, gMessageSystem->mOurCircuitCode);
  825. msg->nextBlockFast(_PREHASH_FOVBlock);
  826. msg->addU32Fast(_PREHASH_GenCounter, 0);
  827. msg->addF32Fast(_PREHASH_VerticalAngle, vertical_fov_rads);
  829. gAgent.sendReliableMessage();
  831. // sync the camera with the new value
  832. LLCamera::setView(vertical_fov_rads); // call base implementation
  833. }
  835. void LLViewerCamera::setDefaultFOV(F32 vertical_fov_rads) 
  836. {
  837. vertical_fov_rads = llclamp(vertical_fov_rads, getMinView(), getMaxView());
  838. setView(vertical_fov_rads);
  839. mCameraFOVDefault = vertical_fov_rads; 
  840. mCosHalfCameraFOV = cosf(mCameraFOVDefault * 0.5f);
  841. }
  844. // static
  845. void LLViewerCamera::updateCameraAngle( void* user_data, const LLSD& value)
  846. {
  847. LLViewerCamera* self=(LLViewerCamera*)user_data;
  848. self->setDefaultFOV(value.asReal());
  849. }