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

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

游戏引擎

开发平台：

C++ Builder

llglsandbox.cpp：源码内容
  1. /** 
  2.  * @file llglsandbox.cpp
  3.  * @brief GL functionality access
  4.  *
  5.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2003-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. /** 
  34.  * Contains ALL methods which directly access GL functionality 
  35.  * except for core rendering engine functionality.
  36.  */
  38. #include "llviewerprecompiledheaders.h"
  40. #include "llviewercontrol.h"
  42. #include "llgl.h"
  43. #include "llrender.h"
  44. #include "llglheaders.h"
  45. #include "llparcel.h"
  46. #include "llui.h"
  48. #include "lldrawable.h"
  49. #include "lltextureentry.h"
  50. #include "llviewercamera.h"
  52. #include "llvoavatarself.h"
  53. #include "llagent.h"
  54. #include "lltoolmgr.h"
  55. #include "llselectmgr.h"
  56. #include "llhudmanager.h"
  57. #include "llrendersphere.h"
  58. #include "llviewerobjectlist.h"
  59. #include "lltoolselectrect.h"
  60. #include "llviewerwindow.h"
  61. #include "llsurface.h"
  62. #include "llwind.h"
  63. #include "llworld.h"
  64. #include "llviewerparcelmgr.h"
  65. #include "llviewerregion.h"
  66. #include "llpreviewtexture.h"
  67. #include "llresmgr.h"
  68. #include "pipeline.h"
  69. #include "llspatialpartition.h"
  71. // Height of the yellow selection highlight posts for land
  72. const F32 PARCEL_POST_HEIGHT = 0.666f;
  74. BOOL LLAgent::setLookAt(ELookAtType target_type, LLViewerObject *object, LLVector3 position)
  75. {
  76. if(object && object->isAttachment())
  77. {
  78. LLViewerObject* parent = object;
  79. while(parent)
  80. {
  81. if (parent == mAvatarObject)
  82. {
  83. // looking at an attachment on ourselves, which we don't want to do
  84. object = mAvatarObject;
  85. position.clearVec();
  86. }
  87. parent = (LLViewerObject*)parent->getParent();
  88. }
  89. }
  90. if(!mLookAt || mLookAt->isDead())
  91. {
  92. mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
  93. mLookAt->setSourceObject(mAvatarObject);
  94. }
  96. return mLookAt->setLookAt(target_type, object, position);
  97. }
  99. BOOL LLAgent::setPointAt(EPointAtType target_type, LLViewerObject *object, LLVector3 position)
  100. {
  101. // disallow pointing at attachments and avatars
  102. if (object && (object->isAttachment() || object->isAvatar()))
  103. {
  104. return FALSE;
  105. }
  107. if(!mPointAt || mPointAt->isDead())
  108. {
  109. mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
  110. mPointAt->setSourceObject(mAvatarObject);
  111. }
  113. return mPointAt->setPointAt(target_type, object, position);
  114. }
  116. ELookAtType LLAgent::getLookAtType()
  117. { 
  118. if (mLookAt) 
  119. {
  120. return mLookAt->getLookAtType();
  121. }
  123. return LOOKAT_TARGET_NONE;
  124. }
  126. EPointAtType LLAgent::getPointAtType()
  127. { 
  128. if (mPointAt) 
  129. {
  130. return mPointAt->getPointAtType();
  131. }
  133. return POINTAT_TARGET_NONE;
  134. }
  136. // Draw a representation of current autopilot target
  137. void LLAgent::renderAutoPilotTarget()
  138. {
  139. if (mAutoPilot)
  140. {
  141. F32 height_meters;
  142. LLVector3d target_global;
  144. glMatrixMode(GL_MODELVIEW);
  145. gGL.pushMatrix();
  147. // not textured
  148. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  150. // lovely green
  151. glColor4f(0.f, 1.f, 1.f, 1.f);
  153. target_global = mAutoPilotTargetGlobal;
  155. gGL.translatef((F32)(target_global.mdV[VX]), (F32)(target_global.mdV[VY]), (F32)(target_global.mdV[VZ]));
  157. height_meters = 1.f;
  159. glScalef(height_meters, height_meters, height_meters);
  161. gSphere.render(1500.f);
  163. gGL.popMatrix();
  164. }
  165. }
  167. // Returns true if you got at least one object
  168. void LLToolSelectRect::handleRectangleSelection(S32 x, S32 y, MASK mask)
  169. {
  170. LLVector3 av_pos = gAgent.getPositionAgent();
  171. F32 select_dist_squared = gSavedSettings.getF32("MaxSelectDistance");
  172. select_dist_squared = select_dist_squared * select_dist_squared;
  174. BOOL deselect = (mask == MASK_CONTROL);
  175. S32 left = llmin(x, mDragStartX);
  176. S32 right = llmax(x, mDragStartX);
  177. S32 top = llmax(y, mDragStartY);
  178. S32 bottom =llmin(y, mDragStartY);
  180. left = llround((F32) left * LLUI::sGLScaleFactor.mV[VX]);
  181. right = llround((F32) right * LLUI::sGLScaleFactor.mV[VX]);
  182. top = llround((F32) top * LLUI::sGLScaleFactor.mV[VY]);
  183. bottom = llround((F32) bottom * LLUI::sGLScaleFactor.mV[VY]);
  185. F32 old_far_plane = LLViewerCamera::getInstance()->getFar();
  186. F32 old_near_plane = LLViewerCamera::getInstance()->getNear();
  188. S32 width = right - left + 1;
  189. S32 height = top - bottom + 1;
  191. BOOL grow_selection = FALSE;
  192. BOOL shrink_selection = FALSE;
  194. if (height > mDragLastHeight || width > mDragLastWidth)
  195. {
  196. grow_selection = TRUE;
  197. }
  198. if (height < mDragLastHeight || width < mDragLastWidth)
  199. {
  200. shrink_selection = TRUE;
  201. }
  203. if (!grow_selection && !shrink_selection)
  204. {
  205. // nothing to do
  206. return;
  207. }
  209. mDragLastHeight = height;
  210. mDragLastWidth = width;
  212. S32 center_x = (left + right) / 2;
  213. S32 center_y = (top + bottom) / 2;
  215. // save drawing mode
  216. glMatrixMode(GL_PROJECTION);
  217. gGL.pushMatrix();
  219. BOOL limit_select_distance = gSavedSettings.getBOOL("LimitSelectDistance");
  220. if (limit_select_distance)
  221. {
  222. // ...select distance from control
  223. LLVector3 relative_av_pos = av_pos;
  224. relative_av_pos -= LLViewerCamera::getInstance()->getOrigin();
  226. F32 new_far = relative_av_pos * LLViewerCamera::getInstance()->getAtAxis() + gSavedSettings.getF32("MaxSelectDistance");
  227. F32 new_near = relative_av_pos * LLViewerCamera::getInstance()->getAtAxis() - gSavedSettings.getF32("MaxSelectDistance");
  229. new_near = llmax(new_near, 0.1f);
  231. LLViewerCamera::getInstance()->setFar(new_far);
  232. LLViewerCamera::getInstance()->setNear(new_near);
  233. }
  234. LLViewerCamera::getInstance()->setPerspective(FOR_SELECTION, 
  235. center_x-width/2, center_y-height/2, width, height, 
  236. limit_select_distance);
  238. if (shrink_selection)
  239. {
  240. struct f : public LLSelectedObjectFunctor
  241. {
  242. virtual bool apply(LLViewerObject* vobjp)
  243. {
  244. LLDrawable* drawable = vobjp->mDrawable;
  245. if (!drawable || vobjp->getPCode() != LL_PCODE_VOLUME || vobjp->isAttachment())
  246. {
  247. return true;
  248. }
  249. S32 result = LLViewerCamera::getInstance()->sphereInFrustum(drawable->getPositionAgent(), drawable->getRadius());
  250. switch (result)
  251. {
  252.   case 0:
  253. LLSelectMgr::getInstance()->unhighlightObjectOnly(vobjp);
  254. break;
  255.   case 1:
  256. // check vertices
  257. if (!LLViewerCamera::getInstance()->areVertsVisible(vobjp, LLSelectMgr::sRectSelectInclusive))
  258. {
  259. LLSelectMgr::getInstance()->unhighlightObjectOnly(vobjp);
  260. }
  261. break;
  262.   default:
  263. break;
  264. }
  265. return true;
  266. }
  267. } func;
  268. LLSelectMgr::getInstance()->getHighlightedObjects()->applyToObjects(&func);
  269. }
  271. if (grow_selection)
  272. {
  273. std::vector<LLDrawable*> potentials;
  275. for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin(); 
  276. iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
  277. {
  278. LLViewerRegion* region = *iter;
  279. for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
  280. {
  281. LLSpatialPartition* part = region->getSpatialPartition(i);
  282. if (part)
  283. {
  284. part->cull(*LLViewerCamera::getInstance(), &potentials, TRUE);
  285. }
  286. }
  287. }
  289. for (std::vector<LLDrawable*>::iterator iter = potentials.begin();
  290.  iter != potentials.end(); iter++)
  291. {
  292. LLDrawable* drawable = *iter;
  293. LLViewerObject* vobjp = drawable->getVObj();
  295. if (!drawable || !vobjp ||
  296. vobjp->getPCode() != LL_PCODE_VOLUME || 
  297. vobjp->isAttachment() ||
  298. (deselect && !vobjp->isSelected()))
  299. {
  300. continue;
  301. }
  303. if (limit_select_distance && dist_vec_squared(drawable->getWorldPosition(), av_pos) > select_dist_squared)
  304. {
  305. continue;
  306. }
  308. S32 result = LLViewerCamera::getInstance()->sphereInFrustum(drawable->getPositionAgent(), drawable->getRadius());
  309. if (result)
  310. {
  311. switch (result)
  312. {
  313. case 1:
  314. // check vertices
  315. if (LLViewerCamera::getInstance()->areVertsVisible(vobjp, LLSelectMgr::sRectSelectInclusive))
  316. {
  317. LLSelectMgr::getInstance()->highlightObjectOnly(vobjp);
  318. }
  319. break;
  320. case 2:
  321. LLSelectMgr::getInstance()->highlightObjectOnly(vobjp);
  322. break;
  323. default:
  324. break;
  325. }
  326. }
  327. }
  328. }
  330. // restore drawing mode
  331. glMatrixMode(GL_PROJECTION);
  332. gGL.popMatrix();
  333. glMatrixMode(GL_MODELVIEW);
  335. // restore camera
  336. LLViewerCamera::getInstance()->setFar(old_far_plane);
  337. LLViewerCamera::getInstance()->setNear(old_near_plane);
  338. gViewerWindow->setup3DRender();
  339. }
  341. const F32 WIND_ALTITUDE = 180.f;
  343. void LLWind::renderVectors()
  344. {
  345. // Renders the wind as vectors (used for debug)
  346. S32 i,j;
  347. F32 x,y;
  349. F32 region_width_meters = LLWorld::getInstance()->getRegionWidthInMeters();
  351. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  352. gGL.pushMatrix();
  353. LLVector3 origin_agent;
  354. origin_agent = gAgent.getPosAgentFromGlobal(mOriginGlobal);
  355. gGL.translatef(origin_agent.mV[VX], origin_agent.mV[VY], WIND_ALTITUDE);
  356. for (j = 0; j < mSize; j++)
  357. {
  358. for (i = 0; i < mSize; i++)
  359. {
  360. x = mCloudVelX[i + j*mSize] * WIND_SCALE_HACK;
  361. y = mCloudVelY[i + j*mSize] * WIND_SCALE_HACK;
  362. gGL.pushMatrix();
  363. gGL.translatef((F32)i * region_width_meters/mSize, (F32)j * region_width_meters/mSize, 0.0);
  364. gGL.color3f(0,1,0);
  365. gGL.begin(LLRender::POINTS);
  366. gGL.vertex3f(0,0,0);
  367. gGL.end();
  368. gGL.color3f(1,0,0);
  369. gGL.begin(LLRender::LINES);
  370. gGL.vertex3f(x * 0.1f, y * 0.1f ,0.f);
  371. gGL.vertex3f(x, y, 0.f);
  372. gGL.end();
  373. gGL.popMatrix();
  374. }
  375. }
  376. gGL.popMatrix();
  377. }
  382. // Used by lltoolselectland
  383. void LLViewerParcelMgr::renderRect(const LLVector3d &west_south_bottom_global, 
  384.    const LLVector3d &east_north_top_global )
  385. {
  386. LLGLSUIDefault gls_ui;
  387. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  388. LLGLDepthTest gls_depth(GL_TRUE);
  390. LLVector3 west_south_bottom_agent = gAgent.getPosAgentFromGlobal(west_south_bottom_global);
  391. F32 west = west_south_bottom_agent.mV[VX];
  392. F32 south = west_south_bottom_agent.mV[VY];
  393. // F32 bottom = west_south_bottom_agent.mV[VZ] - 1.f;
  395. LLVector3 east_north_top_agent = gAgent.getPosAgentFromGlobal(east_north_top_global);
  396. F32 east = east_north_top_agent.mV[VX];
  397. F32 north = east_north_top_agent.mV[VY];
  398. // F32 top = east_north_top_agent.mV[VZ] + 1.f;
  400. // HACK: At edge of last region of world, we need to make sure the region
  401. // resolves correctly so we can get a height value.
  402. const F32 FUDGE = 0.01f;
  404. F32 sw_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( west, south, 0.f ) );
  405. F32 se_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( east-FUDGE, south, 0.f ) );
  406. F32 ne_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( east-FUDGE, north-FUDGE, 0.f ) );
  407. F32 nw_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( west, north-FUDGE, 0.f ) );
  409. F32 sw_top = sw_bottom + PARCEL_POST_HEIGHT;
  410. F32 se_top = se_bottom + PARCEL_POST_HEIGHT;
  411. F32 ne_top = ne_bottom + PARCEL_POST_HEIGHT;
  412. F32 nw_top = nw_bottom + PARCEL_POST_HEIGHT;
  414. LLUI::setLineWidth(2.f);
  415. gGL.color4f(1.f, 1.f, 0.f, 1.f);
  417. // Cheat and give this the same pick-name as land
  418. gGL.begin(LLRender::LINES);
  420. gGL.vertex3f(west, north, nw_bottom);
  421. gGL.vertex3f(west, north, nw_top);
  423. gGL.vertex3f(east, north, ne_bottom);
  424. gGL.vertex3f(east, north, ne_top);
  426. gGL.vertex3f(east, south, se_bottom);
  427. gGL.vertex3f(east, south, se_top);
  429. gGL.vertex3f(west, south, sw_bottom);
  430. gGL.vertex3f(west, south, sw_top);
  432. gGL.end();
  434. gGL.color4f(1.f, 1.f, 0.f, 0.2f);
  435. gGL.begin(LLRender::QUADS);
  437. gGL.vertex3f(west, north, nw_bottom);
  438. gGL.vertex3f(west, north, nw_top);
  439. gGL.vertex3f(east, north, ne_top);
  440. gGL.vertex3f(east, north, ne_bottom);
  442. gGL.vertex3f(east, north, ne_bottom);
  443. gGL.vertex3f(east, north, ne_top);
  444. gGL.vertex3f(east, south, se_top);
  445. gGL.vertex3f(east, south, se_bottom);
  447. gGL.vertex3f(east, south, se_bottom);
  448. gGL.vertex3f(east, south, se_top);
  449. gGL.vertex3f(west, south, sw_top);
  450. gGL.vertex3f(west, south, sw_bottom);
  452. gGL.vertex3f(west, south, sw_bottom);
  453. gGL.vertex3f(west, south, sw_top);
  454. gGL.vertex3f(west, north, nw_top);
  455. gGL.vertex3f(west, north, nw_bottom);
  457. gGL.end();
  459. LLUI::setLineWidth(1.f);
  460. }
  462. /*
  463. void LLViewerParcelMgr::renderParcel(LLParcel* parcel )
  464. {
  465. S32 i;
  466. S32 count = parcel->getBoxCount();
  467. for (i = 0; i < count; i++)
  468. {
  469. const LLParcelBox& box = parcel->getBox(i);
  471. F32 west = box.mMin.mV[VX];
  472. F32 south = box.mMin.mV[VY];
  474. F32 east = box.mMax.mV[VX];
  475. F32 north = box.mMax.mV[VY];
  477. // HACK: At edge of last region of world, we need to make sure the region
  478. // resolves correctly so we can get a height value.
  479. const F32 FUDGE = 0.01f;
  481. F32 sw_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( west, south, 0.f ) );
  482. F32 se_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( east-FUDGE, south, 0.f ) );
  483. F32 ne_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( east-FUDGE, north-FUDGE, 0.f ) );
  484. F32 nw_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( west, north-FUDGE, 0.f ) );
  486. // little hack to make nearby lines not Z-fight
  487. east -= 0.1f;
  488. north -= 0.1f;
  490. F32 sw_top = sw_bottom + POST_HEIGHT;
  491. F32 se_top = se_bottom + POST_HEIGHT;
  492. F32 ne_top = ne_bottom + POST_HEIGHT;
  493. F32 nw_top = nw_bottom + POST_HEIGHT;
  495. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  496. LLGLDepthTest gls_depth(GL_TRUE);
  498. LLUI::setLineWidth(2.f);
  499. gGL.color4f(0.f, 1.f, 1.f, 1.f);
  501. // Cheat and give this the same pick-name as land
  502. gGL.begin(LLRender::LINES);
  504. gGL.vertex3f(west, north, nw_bottom);
  505. gGL.vertex3f(west, north, nw_top);
  507. gGL.vertex3f(east, north, ne_bottom);
  508. gGL.vertex3f(east, north, ne_top);
  510. gGL.vertex3f(east, south, se_bottom);
  511. gGL.vertex3f(east, south, se_top);
  513. gGL.vertex3f(west, south, sw_bottom);
  514. gGL.vertex3f(west, south, sw_top);
  516. gGL.end();
  518. gGL.color4f(0.f, 1.f, 1.f, 0.2f);
  519. gGL.begin(LLRender::QUADS);
  521. gGL.vertex3f(west, north, nw_bottom);
  522. gGL.vertex3f(west, north, nw_top);
  523. gGL.vertex3f(east, north, ne_top);
  524. gGL.vertex3f(east, north, ne_bottom);
  526. gGL.vertex3f(east, north, ne_bottom);
  527. gGL.vertex3f(east, north, ne_top);
  528. gGL.vertex3f(east, south, se_top);
  529. gGL.vertex3f(east, south, se_bottom);
  531. gGL.vertex3f(east, south, se_bottom);
  532. gGL.vertex3f(east, south, se_top);
  533. gGL.vertex3f(west, south, sw_top);
  534. gGL.vertex3f(west, south, sw_bottom);
  536. gGL.vertex3f(west, south, sw_bottom);
  537. gGL.vertex3f(west, south, sw_top);
  538. gGL.vertex3f(west, north, nw_top);
  539. gGL.vertex3f(west, north, nw_bottom);
  541. gGL.end();
  543. LLUI::setLineWidth(1.f);
  544. }
  545. }
  546. */
  549. // north = a wall going north/south.  Need that info to set up texture
  550. // coordinates correctly.
  551. void LLViewerParcelMgr::renderOneSegment(F32 x1, F32 y1, F32 x2, F32 y2, F32 height, U8 direction, LLViewerRegion* regionp)
  552. {
  553. // HACK: At edge of last region of world, we need to make sure the region
  554. // resolves correctly so we can get a height value.
  555. const F32 BORDER = REGION_WIDTH_METERS - 0.1f;
  557. F32 clamped_x1 = x1;
  558. F32 clamped_y1 = y1;
  559. F32 clamped_x2 = x2;
  560. F32 clamped_y2 = y2;
  562. if (clamped_x1 > BORDER) clamped_x1 = BORDER;
  563. if (clamped_y1 > BORDER) clamped_y1 = BORDER;
  564. if (clamped_x2 > BORDER) clamped_x2 = BORDER;
  565. if (clamped_y2 > BORDER) clamped_y2 = BORDER;
  567. F32 z;
  568. F32 z1;
  569. F32 z2;
  571. z1 = regionp->getLand().resolveHeightRegion( LLVector3( clamped_x1, clamped_y1, 0.f ) );
  572. z2 = regionp->getLand().resolveHeightRegion( LLVector3( clamped_x2, clamped_y2, 0.f ) );
  574. // Convert x1 and x2 from region-local to agent coords.
  575. LLVector3 origin = regionp->getOriginAgent();
  576. x1 += origin.mV[VX];
  577. x2 += origin.mV[VX];
  578. y1 += origin.mV[VY];
  579. y2 += origin.mV[VY];
  581. if (height < 1.f)
  582. {
  583. z = z1+height;
  584. gGL.vertex3f(x1, y1, z);
  586. gGL.vertex3f(x1, y1, z1);
  588. gGL.vertex3f(x2, y2, z2);
  590. z = z2+height;
  591. gGL.vertex3f(x2, y2, z);
  592. }
  593. else
  594. {
  595. F32 tex_coord1;
  596. F32 tex_coord2;
  598. if (WEST_MASK == direction)
  599. {
  600. tex_coord1 = y1;
  601. tex_coord2 = y2;
  602. }
  603. else if (SOUTH_MASK == direction)
  604. {
  605. tex_coord1 = x1;
  606. tex_coord2 = x2;
  607. }
  608. else if (EAST_MASK == direction)
  609. {
  610. tex_coord1 = y2;
  611. tex_coord2 = y1;
  612. }
  613. else /* (NORTH_MASK == direction) */
  614. {
  615. tex_coord1 = x2;
  616. tex_coord2 = x1;
  617. }
  620. gGL.texCoord2f(tex_coord1*0.5f+0.5f, z1*0.5f);
  621. gGL.vertex3f(x1, y1, z1);
  623. gGL.texCoord2f(tex_coord2*0.5f+0.5f, z2*0.5f);
  624. gGL.vertex3f(x2, y2, z2);
  626. // top edge stairsteps
  627. z = llmax(z2+height, z1+height);
  628. gGL.texCoord2f(tex_coord2*0.5f+0.5f, z*0.5f);
  629. gGL.vertex3f(x2, y2, z);
  631. gGL.texCoord2f(tex_coord1*0.5f+0.5f, z*0.5f);
  632. gGL.vertex3f(x1, y1, z);
  633. }
  634. }
  637. void LLViewerParcelMgr::renderHighlightSegments(const U8* segments, LLViewerRegion* regionp)
  638. {
  639. S32 x, y;
  640. F32 x1, y1; // start point
  641. F32 x2, y2; // end point
  642. bool has_segments = false;
  644. LLGLSUIDefault gls_ui;
  645. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  646. LLGLDepthTest gls_depth(GL_TRUE);
  648. gGL.color4f(1.f, 1.f, 0.f, 0.2f);
  650. const S32 STRIDE = (mParcelsPerEdge+1);
  652. // Cheat and give this the same pick-name as land
  655. for (y = 0; y < STRIDE; y++)
  656. {
  657. for (x = 0; x < STRIDE; x++)
  658. {
  659. U8 segment_mask = segments[x + y*STRIDE];
  661. if (segment_mask & SOUTH_MASK)
  662. {
  663. x1 = x * PARCEL_GRID_STEP_METERS;
  664. y1 = y * PARCEL_GRID_STEP_METERS;
  666. x2 = x1 + PARCEL_GRID_STEP_METERS;
  667. y2 = y1;
  669. if (!has_segments)
  670. {
  671. has_segments = true;
  672. gGL.begin(LLRender::QUADS);
  673. }
  674. renderOneSegment(x1, y1, x2, y2, PARCEL_POST_HEIGHT, SOUTH_MASK, regionp);
  675. }
  677. if (segment_mask & WEST_MASK)
  678. {
  679. x1 = x * PARCEL_GRID_STEP_METERS;
  680. y1 = y * PARCEL_GRID_STEP_METERS;
  682. x2 = x1;
  683. y2 = y1 + PARCEL_GRID_STEP_METERS;
  685. if (!has_segments)
  686. {
  687. has_segments = true;
  688. gGL.begin(LLRender::QUADS);
  689. }
  690. renderOneSegment(x1, y1, x2, y2, PARCEL_POST_HEIGHT, WEST_MASK, regionp);
  691. }
  692. }
  693. }
  695. if (has_segments)
  696. {
  697. gGL.end();
  698. }
  699. }
  702. void LLViewerParcelMgr::renderCollisionSegments(U8* segments, BOOL use_pass, LLViewerRegion* regionp)
  703. {
  705. S32 x, y;
  706. F32 x1, y1; // start point
  707. F32 x2, y2; // end point
  708. F32 alpha = 0;
  709. F32 dist = 0;
  710. F32 dx, dy;
  711. F32 collision_height;
  713. const S32 STRIDE = (mParcelsPerEdge+1);
  715. LLVector3 pos = gAgent.getPositionAgent();
  717. F32 pos_x = pos.mV[VX];
  718. F32 pos_y = pos.mV[VY];
  720. LLGLSUIDefault gls_ui;
  721. LLGLDepthTest gls_depth(GL_TRUE);
  722. LLGLDisable cull(GL_CULL_FACE);
  724. if (mCollisionBanned == BA_BANNED)
  725. {
  726. collision_height = BAN_HEIGHT;
  727. }
  728. else
  729. {
  730. collision_height = PARCEL_HEIGHT;
  731. }
  734. if (use_pass && (mCollisionBanned == BA_NOT_ON_LIST))
  735. {
  736. gGL.getTexUnit(0)->bind(mPassImage);
  737. }
  738. else
  739. {
  740. gGL.getTexUnit(0)->bind(mBlockedImage);
  741. }
  743. gGL.begin(LLRender::QUADS);
  745. for (y = 0; y < STRIDE; y++)
  746. {
  747. for (x = 0; x < STRIDE; x++)
  748. {
  749. U8 segment_mask = segments[x + y*STRIDE];
  750. U8 direction;
  751. const F32 MAX_ALPHA = 0.95f;
  752. const S32 DIST_OFFSET = 5;
  753. const S32 MIN_DIST_SQ = DIST_OFFSET*DIST_OFFSET;
  754. const S32 MAX_DIST_SQ = 169;
  756. if (segment_mask & SOUTH_MASK)
  757. {
  758. x1 = x * PARCEL_GRID_STEP_METERS;
  759. y1 = y * PARCEL_GRID_STEP_METERS;
  761. x2 = x1 + PARCEL_GRID_STEP_METERS;
  762. y2 = y1;
  764. if (gRenderForSelect)
  765. {
  766. LLColor4U color((U8)(GL_NAME_PARCEL_WALL >> 16), (U8)(GL_NAME_PARCEL_WALL >> 8), (U8)GL_NAME_PARCEL_WALL);
  767. gGL.color4ubv(color.mV);
  768. }
  769. else
  770. {
  771. dy = (pos_y - y1) + DIST_OFFSET;
  773. if (pos_x < x1)
  774. dx = pos_x - x1;
  775. else if (pos_x > x2)
  776. dx = pos_x - x2;
  777. else 
  778. dx = 0;
  780. dist = dx*dx+dy*dy;
  782. if (dist < MIN_DIST_SQ)
  783. alpha = MAX_ALPHA;
  784. else if (dist > MAX_DIST_SQ)
  785. alpha = 0.0f;
  786. else
  787. alpha = 30/dist;
  789. alpha = llclamp(alpha, 0.0f, MAX_ALPHA);
  791. gGL.color4f(1.f, 1.f, 1.f, alpha);
  792. }
  794. if ((pos_y - y1) < 0) direction = SOUTH_MASK;
  795. else  direction = NORTH_MASK;
  797. // avoid Z fighting
  798. renderOneSegment(x1+0.1f, y1+0.1f, x2+0.1f, y2+0.1f, collision_height, direction, regionp);
  800. }
  802. if (segment_mask & WEST_MASK)
  803. {
  804. x1 = x * PARCEL_GRID_STEP_METERS;
  805. y1 = y * PARCEL_GRID_STEP_METERS;
  807. x2 = x1;
  808. y2 = y1 + PARCEL_GRID_STEP_METERS;
  810. if (gRenderForSelect)
  811. {
  812. LLColor4U color((U8)(GL_NAME_PARCEL_WALL >> 16), (U8)(GL_NAME_PARCEL_WALL >> 8), (U8)GL_NAME_PARCEL_WALL);
  813. gGL.color4ubv(color.mV);
  814. }
  815. else
  816. {
  817. dx = (pos_x - x1) + DIST_OFFSET;
  819. if (pos_y < y1) 
  820. dy = pos_y - y1;
  821. else if (pos_y > y2)
  822. dy = pos_y - y2;
  823. else 
  824. dy = 0;
  826. dist = dx*dx+dy*dy;
  828. if (dist < MIN_DIST_SQ) 
  829. alpha = MAX_ALPHA;
  830. else if (dist > MAX_DIST_SQ)
  831. alpha = 0.0f;
  832. else
  833. alpha = 30/dist;
  835. alpha = llclamp(alpha, 0.0f, MAX_ALPHA);
  837. gGL.color4f(1.f, 1.f, 1.f, alpha);
  838. }
  840. if ((pos_x - x1) > 0) direction = WEST_MASK;
  841. else  direction = EAST_MASK;
  843. // avoid Z fighting
  844. renderOneSegment(x1+0.1f, y1+0.1f, x2+0.1f, y2+0.1f, collision_height, direction, regionp);
  846. }
  847. }
  848. }
  850. gGL.end();
  851. }
  853. void draw_line_cube(F32 width, const LLVector3& center)
  854. {
  855. width = 0.5f * width;
  856. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] + width);
  857. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] + width);
  858. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] + width);
  859. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] + width);
  860. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] + width);
  861. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] + width);
  862. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] + width);
  863. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] + width);
  865. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] - width);
  866. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] - width);
  867. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] - width);
  868. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] - width);
  869. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] - width);
  870. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] - width);
  871. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] - width);
  872. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] - width);
  874. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] + width);
  875. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] - width);
  876. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] + width);
  877. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] - width);
  878. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] + width);
  879. gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] - width);
  880. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] + width);
  881. gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] - width);
  882. }
  885. void LLViewerObjectList::renderObjectBeacons()
  886. {
  887. if (mDebugBeacons.empty())
  888. {
  889. return;
  890. }
  892. LLGLSUIDefault gls_ui;
  894. {
  895. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  897. S32 last_line_width = -1;
  898. // gGL.begin(LLRender::LINES); // Always happens in (line_width != last_line_width)
  900. for (S32 i = 0; i < mDebugBeacons.count(); i++)
  901. {
  902. const LLDebugBeacon &debug_beacon = mDebugBeacons[i];
  903. LLColor4 color = debug_beacon.mColor;
  904. color.mV[3] *= 0.25f;
  905. S32 line_width = debug_beacon.mLineWidth;
  906. if (line_width != last_line_width)
  907. {
  908. if (i > 0)
  909. {
  910. gGL.end();
  911. gGL.flush();
  912. }
  913. glLineWidth( (F32)line_width );
  914. last_line_width = line_width;
  915. gGL.begin(LLRender::LINES);
  916. }
  918. const LLVector3 &thisline = debug_beacon.mPositionAgent;
  919. gGL.color4fv(color.mV);
  920. gGL.vertex3f(thisline.mV[VX],thisline.mV[VY],thisline.mV[VZ] - 50.f);
  921. gGL.vertex3f(thisline.mV[VX],thisline.mV[VY],thisline.mV[VZ] + 50.f);
  922. gGL.vertex3f(thisline.mV[VX] - 2.f,thisline.mV[VY],thisline.mV[VZ]);
  923. gGL.vertex3f(thisline.mV[VX] + 2.f,thisline.mV[VY],thisline.mV[VZ]);
  924. gGL.vertex3f(thisline.mV[VX],thisline.mV[VY] - 2.f,thisline.mV[VZ]);
  925. gGL.vertex3f(thisline.mV[VX],thisline.mV[VY] + 2.f,thisline.mV[VZ]);
  927. draw_line_cube(0.10f, thisline);
  928. }
  929. gGL.end();
  930. }
  932. {
  933. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  934. LLGLDepthTest gls_depth(GL_TRUE);
  936. S32 last_line_width = -1;
  937. // gGL.begin(LLRender::LINES); // Always happens in (line_width != last_line_width)
  939. for (S32 i = 0; i < mDebugBeacons.count(); i++)
  940. {
  941. const LLDebugBeacon &debug_beacon = mDebugBeacons[i];
  943. S32 line_width = debug_beacon.mLineWidth;
  944. if (line_width != last_line_width)
  945. {
  946. if (i > 0)
  947. {
  948. gGL.end();
  949. gGL.flush();
  950. }
  951. glLineWidth( (F32)line_width );
  952. last_line_width = line_width;
  953. gGL.begin(LLRender::LINES);
  954. }
  956. const LLVector3 &thisline = debug_beacon.mPositionAgent;
  957. gGL.color4fv(debug_beacon.mColor.mV);
  958. gGL.vertex3f(thisline.mV[VX],thisline.mV[VY],thisline.mV[VZ] - 0.5f);
  959. gGL.vertex3f(thisline.mV[VX],thisline.mV[VY],thisline.mV[VZ] + 0.5f);
  960. gGL.vertex3f(thisline.mV[VX] - 0.5f,thisline.mV[VY],thisline.mV[VZ]);
  961. gGL.vertex3f(thisline.mV[VX] + 0.5f,thisline.mV[VY],thisline.mV[VZ]);
  962. gGL.vertex3f(thisline.mV[VX],thisline.mV[VY] - 0.5f,thisline.mV[VZ]);
  963. gGL.vertex3f(thisline.mV[VX],thisline.mV[VY] + 0.5f,thisline.mV[VZ]);
  965. draw_line_cube(0.10f, thisline);
  966. }
  968. gGL.end();
  969. gGL.flush();
  970. glLineWidth(1.f);
  972. for (S32 i = 0; i < mDebugBeacons.count(); i++)
  973. {
  974. LLDebugBeacon &debug_beacon = mDebugBeacons[i];
  975. if (debug_beacon.mString == "")
  976. {
  977. continue;
  978. }
  979. LLHUDText *hud_textp = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);
  981. hud_textp->setZCompare(FALSE);
  982. LLColor4 color;
  983. color = debug_beacon.mTextColor;
  984. color.mV[3] *= 1.f;
  986. hud_textp->setString(utf8str_to_wstring(debug_beacon.mString));
  987. hud_textp->setColor(color);
  988. hud_textp->setPositionAgent(debug_beacon.mPositionAgent);
  989. debug_beacon.mHUDObject = hud_textp;
  990. }
  991. }
  992. }