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

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

游戏引擎

开发平台：

C++ Builder

lltoolbrush.cpp：源码内容
  1. /** 
  2.  * @file lltoolbrush.cpp
  3.  * @brief Implementation of the toolbrushes
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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. #include "lltoolbrush.h"
  36. #include "lltoolselectland.h"
  38. // library headers
  39. #include "llgl.h"
  40. #include "llnotificationsutil.h"
  41. #include "llrender.h"
  42. #include "message.h"
  44. #include "llagent.h"
  45. #include "llcallbacklist.h"
  46. #include "llviewercontrol.h"
  47. #include "llfloatertools.h"
  48. #include "llregionposition.h"
  49. #include "llstatusbar.h"
  50. #include "llsurface.h"
  51. #include "llsurfacepatch.h"
  52. #include "lltoolmgr.h"
  53. #include "llui.h"
  54. #include "llviewerparcelmgr.h"
  55. #include "llviewerparceloverlay.h"
  56. #include "llviewerregion.h"
  57. #include "llviewerwindow.h"
  58. #include "llworld.h"
  59. #include "llappviewer.h"
  60. #include "llparcel.h"
  62. #include "llglheaders.h"
  64. const std::string REGION_BLOCKS_TERRAFORM_MSG = "This region does not allow terraforming.n"
  65. "You will need to buy land in another part of the world to terraform it.";
  68. ///============================================================================
  69. /// Local function declarations, constants, enums, and typedefs
  70. ///============================================================================
  72. const S32 LAND_BRUSH_SIZE_COUNT = 3;
  73. const F32 LAND_BRUSH_SIZE[LAND_BRUSH_SIZE_COUNT] = {1.0f, 2.0f, 4.0f};
  74. const S32 LAND_STEPS = 3;
  75. const F32 LAND_METERS_PER_SECOND = 1.0f;
  76. enum
  77. {
  78. E_LAND_LEVEL = 0,
  79. E_LAND_RAISE = 1,
  80. E_LAND_LOWER = 2,
  81. E_LAND_SMOOTH = 3,
  82. E_LAND_NOISE = 4,
  83. E_LAND_REVERT = 5,
  84. E_LAND_INVALID  = 6,
  85. };
  86. const LLColor4 OVERLAY_COLOR(1.0f, 1.0f, 1.0f, 1.0f);
  88. ///============================================================================
  89. /// Class LLToolBrushLand
  90. ///============================================================================
  92. // constructor
  93. LLToolBrushLand::LLToolBrushLand()
  94. : LLTool(std::string("Land")),
  95. mStartingZ( 0.0f ),
  96. mMouseX( 0 ),
  97. mMouseY(0),
  98. mGotHover(FALSE),
  99. mBrushSelected(FALSE)
  100. {
  101. mBrushSize = gSavedSettings.getF32("LandBrushSize");
  102. }
  105. U8 LLToolBrushLand::getBrushIndex()
  106. {
  107. // find the best index for desired size
  108. // (compatibility with old sims, brush_index is now depricated - DEV-8252)
  109. U8 index = 0;
  110. for (U8 i = 0; i < LAND_BRUSH_SIZE_COUNT; i++)
  111. {
  112. if (mBrushSize > LAND_BRUSH_SIZE[i])
  113. {
  114. index = i;
  115. }
  116. }
  118. return index;
  119. }
  121. void LLToolBrushLand::modifyLandAtPointGlobal(const LLVector3d &pos_global,
  122.   MASK mask)
  123. {
  124. S32 radioAction = gSavedSettings.getS32("RadioLandBrushAction");
  126. mLastAffectedRegions.clear();
  127. determineAffectedRegions(mLastAffectedRegions, pos_global);
  128. for(region_list_t::iterator iter = mLastAffectedRegions.begin();
  129. iter != mLastAffectedRegions.end(); ++iter)
  130. {
  131. LLViewerRegion* regionp = *iter;
  132. //BOOL is_changed = FALSE;
  133. LLVector3 pos_region = regionp->getPosRegionFromGlobal(pos_global);
  134. LLSurface &land = regionp->getLand();
  135. char action = E_LAND_LEVEL;
  136. switch (radioAction)
  137. {
  138. case 0:
  139. // // average toward mStartingZ
  140. action = E_LAND_LEVEL;
  141. break;
  142. case 1:
  143. action = E_LAND_RAISE;
  144. break;
  145. case 2:
  146. action = E_LAND_LOWER;
  147. break;
  148. case 3:
  149. action = E_LAND_SMOOTH;
  150. break;
  151. case 4:
  152. action = E_LAND_NOISE;
  153. break;
  154. case 5:
  155. action = E_LAND_REVERT;
  156. break;
  157. default:
  158. action = E_LAND_INVALID;
  159. break;
  160. }
  162. // Don't send a message to the region if nothing changed.
  163. //if(!is_changed) continue;
  165. // Now to update the patch information so it will redraw correctly.
  166. LLSurfacePatch *patchp= land.resolvePatchRegion(pos_region);
  167. if (patchp)
  168. {
  169. patchp->dirtyZ();
  170. }
  172. // Also force the property lines to update, normals to recompute, etc.
  173. regionp->forceUpdate();
  175. // tell the simulator what we've done
  176. F32 seconds = (1.0f / gFPSClamped) * gSavedSettings.getF32("LandBrushForce");
  177. F32 x_pos = (F32)pos_region.mV[VX];
  178. F32 y_pos = (F32)pos_region.mV[VY];
  179. LLMessageSystem* msg = gMessageSystem;
  180. msg->newMessageFast(_PREHASH_ModifyLand);
  181. msg->nextBlockFast(_PREHASH_AgentData);
  182. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  183. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  184. msg->nextBlockFast(_PREHASH_ModifyBlock);
  185. msg->addU8Fast(_PREHASH_Action, (U8)action);
  186. msg->addU8Fast(_PREHASH_BrushSize, getBrushIndex());
  187. msg->addF32Fast(_PREHASH_Seconds, seconds);
  188. msg->addF32Fast(_PREHASH_Height, mStartingZ);
  189. msg->nextBlockFast(_PREHASH_ParcelData);
  190. msg->addS32Fast(_PREHASH_LocalID, -1);
  191. msg->addF32Fast(_PREHASH_West, x_pos );
  192. msg->addF32Fast(_PREHASH_South, y_pos );
  193. msg->addF32Fast(_PREHASH_East, x_pos );
  194. msg->addF32Fast(_PREHASH_North, y_pos );
  195. msg->nextBlock("ModifyBlockExtended");
  196. msg->addF32("BrushSize", mBrushSize);
  197. msg->sendMessage(regionp->getHost());
  198. }
  199. }
  201. void LLToolBrushLand::modifyLandInSelectionGlobal()
  202. {
  203. if (LLViewerParcelMgr::getInstance()->selectionEmpty())
  204. {
  205. return;
  206. }
  208. if (LLToolMgr::getInstance()->getCurrentTool() == LLToolSelectLand::getInstance())
  209. {
  210. // selecting land, don't do anything
  211. return;
  212. }
  214. LLVector3d min;
  215. LLVector3d max;
  217. LLViewerParcelMgr::getInstance()->getSelection(min, max);
  219. S32 radioAction = gSavedSettings.getS32("RadioLandBrushAction");
  221. mLastAffectedRegions.clear();
  223. determineAffectedRegions(mLastAffectedRegions, LLVector3d(min.mdV[VX], min.mdV[VY], 0));
  224. determineAffectedRegions(mLastAffectedRegions, LLVector3d(min.mdV[VX], max.mdV[VY], 0));
  225. determineAffectedRegions(mLastAffectedRegions, LLVector3d(max.mdV[VX], min.mdV[VY], 0));
  226. determineAffectedRegions(mLastAffectedRegions, LLVector3d(max.mdV[VX], max.mdV[VY], 0));
  228. LLRegionPosition mid_point_region((min + max) * 0.5);
  229. LLViewerRegion* center_region = mid_point_region.getRegion();
  230. if (center_region)
  231. {
  232. LLVector3 pos_region = mid_point_region.getPositionRegion();
  233. U32 grids = center_region->getLand().mGridsPerEdge;
  234. S32 i = llclamp( (S32)pos_region.mV[VX], 0, (S32)grids );
  235. S32 j = llclamp( (S32)pos_region.mV[VY], 0, (S32)grids );
  236. mStartingZ = center_region->getLand().getZ(i+j*grids);
  237. }
  238. else
  239. {
  240. mStartingZ = 0.f;
  241. }
  243. // Stop if our selection include a no-terraform region
  244. for(region_list_t::iterator iter = mLastAffectedRegions.begin();
  245. iter != mLastAffectedRegions.end(); ++iter)
  246. {
  247. LLViewerRegion* regionp = *iter;
  248. if (!canTerraform(regionp))
  249. {
  250. alertNoTerraform(regionp);
  251. return;
  252. }
  253. }
  255. for(region_list_t::iterator iter = mLastAffectedRegions.begin();
  256. iter != mLastAffectedRegions.end(); ++iter)
  257. {
  258. LLViewerRegion* regionp = *iter;
  259. //BOOL is_changed = FALSE;
  260. LLVector3 min_region = regionp->getPosRegionFromGlobal(min);
  261. LLVector3 max_region = regionp->getPosRegionFromGlobal(max);
  263. min_region.clamp(0.f, regionp->getWidth());
  264. max_region.clamp(0.f, regionp->getWidth());
  265. F32 seconds = gSavedSettings.getF32("LandBrushForce");
  267. LLSurface &land = regionp->getLand();
  268. char action = E_LAND_LEVEL;
  269. switch (radioAction)
  270. {
  271. case 0:
  272. // // average toward mStartingZ
  273. action = E_LAND_LEVEL;
  274. seconds *= 0.25f;
  275. break;
  276. case 1:
  277. action = E_LAND_RAISE;
  278. seconds *= 0.25f;
  279. break;
  280. case 2:
  281. action = E_LAND_LOWER;
  282. seconds *= 0.25f;
  283. break;
  284. case 3:
  285. action = E_LAND_SMOOTH;
  286. seconds *= 5.0f;
  287. break;
  288. case 4:
  289. action = E_LAND_NOISE;
  290. seconds *= 0.5f;
  291. break;
  292. case 5:
  293. action = E_LAND_REVERT;
  294. seconds = 0.5f;
  295. break;
  296. default:
  297. //action = E_LAND_INVALID;
  298. //seconds = 0.0f;
  299. return;
  300. break;
  301. }
  303. // Don't send a message to the region if nothing changed.
  304. //if(!is_changed) continue;
  306. // Now to update the patch information so it will redraw correctly.
  307. LLSurfacePatch *patchp= land.resolvePatchRegion(min_region);
  308. if (patchp)
  309. {
  310. patchp->dirtyZ();
  311. }
  313. // Also force the property lines to update, normals to recompute, etc.
  314. regionp->forceUpdate();
  316. // tell the simulator what we've done
  317. LLMessageSystem* msg = gMessageSystem;
  318. msg->newMessageFast(_PREHASH_ModifyLand);
  319. msg->nextBlockFast(_PREHASH_AgentData);
  320. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  321. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  322. msg->nextBlockFast(_PREHASH_ModifyBlock);
  323. msg->addU8Fast(_PREHASH_Action, (U8)action);
  324. msg->addU8Fast(_PREHASH_BrushSize, getBrushIndex());
  325. msg->addF32Fast(_PREHASH_Seconds, seconds);
  326. msg->addF32Fast(_PREHASH_Height, mStartingZ);
  328. BOOL parcel_selected = LLViewerParcelMgr::getInstance()->getParcelSelection()->getWholeParcelSelected();
  329. LLParcel* selected_parcel = LLViewerParcelMgr::getInstance()->getParcelSelection()->getParcel();
  331. if (parcel_selected && selected_parcel)
  332. {
  333. msg->nextBlockFast(_PREHASH_ParcelData);
  334. msg->addS32Fast(_PREHASH_LocalID, selected_parcel->getLocalID());
  335. msg->addF32Fast(_PREHASH_West,  min_region.mV[VX] );
  336. msg->addF32Fast(_PREHASH_South, min_region.mV[VY] );
  337. msg->addF32Fast(_PREHASH_East,  max_region.mV[VX] );
  338. msg->addF32Fast(_PREHASH_North, max_region.mV[VY] );
  339. }
  340. else
  341. {
  342. msg->nextBlockFast(_PREHASH_ParcelData);
  343. msg->addS32Fast(_PREHASH_LocalID, -1);
  344. msg->addF32Fast(_PREHASH_West,  min_region.mV[VX] );
  345. msg->addF32Fast(_PREHASH_South, min_region.mV[VY] );
  346. msg->addF32Fast(_PREHASH_East,  max_region.mV[VX] );
  347. msg->addF32Fast(_PREHASH_North, max_region.mV[VY] );
  348. }
  350. msg->nextBlock("ModifyBlockExtended");
  351. msg->addF32("BrushSize", mBrushSize);
  353. msg->sendMessage(regionp->getHost());
  354. }
  355. }
  357. void LLToolBrushLand::brush( void )
  358. {
  359. LLVector3d spot;
  360. if( gViewerWindow->mousePointOnLandGlobal( mMouseX, mMouseY, &spot ) )
  361. {
  362. // Round to nearest X,Y grid
  363. spot.mdV[VX] = floor( spot.mdV[VX] + 0.5 );
  364. spot.mdV[VY] = floor( spot.mdV[VY] + 0.5 );
  366. modifyLandAtPointGlobal(spot, gKeyboard->currentMask(TRUE));
  367. }
  368. }
  370. BOOL LLToolBrushLand::handleMouseDown(S32 x, S32 y, MASK mask)
  371. {
  372. BOOL handled = FALSE;
  374. // Find the z value of the initial click. 
  375. LLVector3d spot;
  376. if( gViewerWindow->mousePointOnLandGlobal( x, y, &spot ) )
  377. {
  378. // Round to nearest X,Y grid
  379. spot.mdV[VX] = floor( spot.mdV[VX] + 0.5 );
  380. spot.mdV[VY] = floor( spot.mdV[VY] + 0.5 );
  382. LLRegionPosition region_position( spot );
  383. LLViewerRegion* regionp = region_position.getRegion();
  385. if (!canTerraform(regionp))
  386. {
  387. alertNoTerraform(regionp);
  388. return TRUE;
  389. }
  391. LLVector3 pos_region = region_position.getPositionRegion();
  392. U32 grids = regionp->getLand().mGridsPerEdge;
  393. S32 i = llclamp( (S32)pos_region.mV[VX], 0, (S32)grids );
  394. S32 j = llclamp( (S32)pos_region.mV[VY], 0, (S32)grids );
  395. mStartingZ = regionp->getLand().getZ(i+j*grids);
  396. mMouseX = x;
  397. mMouseY = y;
  398. gIdleCallbacks.addFunction( &LLToolBrushLand::onIdle, (void*)this );
  399. setMouseCapture( TRUE );
  401. LLViewerParcelMgr::getInstance()->setSelectionVisible(FALSE);
  402. handled = TRUE;
  403. }
  405. return handled;
  406. }
  408. BOOL LLToolBrushLand::handleHover( S32 x, S32 y, MASK mask )
  409. {
  410. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolBrushLand ("
  411. << (hasMouseCapture() ? "active":"inactive")
  412. << ")" << llendl;
  413. mMouseX = x;
  414. mMouseY = y;
  415. mGotHover = TRUE;
  416. gViewerWindow->setCursor(UI_CURSOR_TOOLLAND);
  417. return TRUE;
  418. }
  420. BOOL LLToolBrushLand::handleMouseUp(S32 x, S32 y, MASK mask)
  421. {
  422. BOOL handled = FALSE;
  423. mLastAffectedRegions.clear();
  424. if( hasMouseCapture() )
  425. {
  426. // Release the mouse
  427. setMouseCapture( FALSE );
  429. LLViewerParcelMgr::getInstance()->setSelectionVisible(TRUE);
  431. gIdleCallbacks.deleteFunction( &LLToolBrushLand::onIdle, (void*)this );
  432. handled = TRUE;
  433. }
  435. return handled;
  436. }
  438. void LLToolBrushLand::handleSelect()
  439. {
  440. gEditMenuHandler = this;
  442. gFloaterTools->setStatusText("modifyland");
  443. // if (!mBrushSelected)
  444. {
  445. mBrushSelected = TRUE;
  446. }
  447. }
  450. void LLToolBrushLand::handleDeselect()
  451. {
  452. if( gEditMenuHandler == this )
  453. {
  454. gEditMenuHandler = NULL;
  455. }
  456. LLViewerParcelMgr::getInstance()->setSelectionVisible(TRUE);
  457. mBrushSelected = FALSE;
  458. }
  460. // Draw the area that will be affected.
  461. void LLToolBrushLand::render()
  462. {
  463. if(mGotHover)
  464. {
  465. //llinfos << "LLToolBrushLand::render()" << llendl;
  466. LLVector3d spot;
  467. if(gViewerWindow->mousePointOnLandGlobal(mMouseX, mMouseY, &spot))
  468. {
  469. spot.mdV[VX] = floor( spot.mdV[VX] + 0.5 );
  470. spot.mdV[VY] = floor( spot.mdV[VY] + 0.5 );
  472. mBrushSize = gSavedSettings.getF32("LandBrushSize");
  474. region_list_t regions;
  475. determineAffectedRegions(regions, spot);
  477. // Now, for each region, render the overlay
  478. LLVector3 pos_world = gAgent.getRegion()->getPosRegionFromGlobal(spot);
  479. for(region_list_t::iterator iter = regions.begin();
  480. iter != regions.end(); ++iter)
  481. {
  482. LLViewerRegion* region = *iter;
  483. renderOverlay(region->getLand(), 
  484.   region->getPosRegionFromGlobal(spot),
  485.   pos_world);
  486. }
  487. }
  488. mGotHover = FALSE;
  489. }
  490. }
  492. /*
  493.  * Draw vertical lines from each vertex straight up in world space
  494.  * with lengths indicating the current "strength" slider.
  495.  * Decorate the tops and bottoms of the lines like this:
  496.  *
  497.  * Raise        Revert
  498.  * /|           ___
  499.  *  |             |
  500.  *  |             |
  501.  *
  502.  * Rough        Smooth
  503.  * /|           ___
  504.  *  |             |
  505.  *  |             |
  506.  * |/..........._|_
  507.  *
  508.  * Lower        Flatten
  509.  *  |             |
  510.  *  |             |
  511.  * |/..........._|_
  512.  */
  513. void LLToolBrushLand::renderOverlay(LLSurface& land, const LLVector3& pos_region,
  514. const LLVector3& pos_world)
  515. {
  516. glMatrixMode(GL_MODELVIEW);
  517. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  518. LLGLDepthTest mDepthTest(GL_TRUE);
  519. glPushMatrix();
  520. gGL.color4fv(OVERLAY_COLOR.mV);
  521. glTranslatef(0.0f, 0.0f, 1.0f);
  523. S32 i = (S32) pos_region.mV[VX];
  524. S32 j = (S32) pos_region.mV[VY];
  525. S32 half_edge = llfloor(mBrushSize);
  526. S32 radioAction = gSavedSettings.getS32("RadioLandBrushAction");
  527. F32 force = gSavedSettings.getF32("LandBrushForce"); // .1 to 100?
  529. gGL.begin(LLRender::LINES);
  530. for(S32 di = -half_edge; di <= half_edge; di++)
  531. {
  532. if((i+di) < 0 || (i+di) >= (S32)land.mGridsPerEdge) continue;
  533. for(S32 dj = -half_edge; dj <= half_edge; dj++)
  534. {
  535. if( (j+dj) < 0 || (j+dj) >= (S32)land.mGridsPerEdge ) continue;
  536. const F32 
  537. wx = pos_world.mV[VX] + di,
  538. wy = pos_world.mV[VY] + dj,
  539. wz = land.getZ((i+di)+(j+dj)*land.mGridsPerEdge),
  540. norm_dist = sqrt((float)di*di + dj*dj) / half_edge,
  541. force_scale = sqrt(2.f) - norm_dist, // 1 at center, 0 at corner
  542. wz2 = wz + .2 + (.2 + force/100) * force_scale, // top vertex
  543. tic = .075f; // arrowhead size
  544. // vertical line
  545. gGL.vertex3f(wx, wy, wz);
  546. gGL.vertex3f(wx, wy, wz2);
  547. if(radioAction == E_LAND_RAISE || radioAction == E_LAND_NOISE) // up arrow
  548. {
  549. gGL.vertex3f(wx, wy, wz2);
  550. gGL.vertex3f(wx+tic, wy, wz2-tic);
  551. gGL.vertex3f(wx, wy, wz2);
  552. gGL.vertex3f(wx-tic, wy, wz2-tic);
  553. }
  554. if(radioAction == E_LAND_LOWER || radioAction == E_LAND_NOISE) // down arrow
  555. {
  556. gGL.vertex3f(wx, wy, wz);
  557. gGL.vertex3f(wx+tic, wy, wz+tic);
  558. gGL.vertex3f(wx, wy, wz);
  559. gGL.vertex3f(wx-tic, wy, wz+tic);
  560. }
  561. if(radioAction == E_LAND_REVERT || radioAction == E_LAND_SMOOTH) // flat top
  562. {
  563. gGL.vertex3f(wx-tic, wy, wz2);
  564. gGL.vertex3f(wx+tic, wy, wz2);
  565. }
  566. if(radioAction == E_LAND_LEVEL || radioAction == E_LAND_SMOOTH) // flat bottom
  567. {
  568. gGL.vertex3f(wx-tic, wy, wz);
  569. gGL.vertex3f(wx+tic, wy, wz);
  570. }
  571. }
  572. }
  573. gGL.end();
  575. glPopMatrix();
  576. }
  578. void LLToolBrushLand::determineAffectedRegions(region_list_t& regions,
  579.    const LLVector3d& spot ) const
  580. {
  581. LLVector3d corner(spot);
  582. corner.mdV[VX] -= (mBrushSize / 2);
  583. corner.mdV[VY] -= (mBrushSize / 2);
  584. LLViewerRegion* region = NULL;
  585. region = LLWorld::getInstance()->getRegionFromPosGlobal(corner);
  586. if(region && regions.find(region) == regions.end())
  587. {
  588. regions.insert(region);
  589. }
  590. corner.mdV[VY] += mBrushSize;
  591. region = LLWorld::getInstance()->getRegionFromPosGlobal(corner);
  592. if(region && regions.find(region) == regions.end())
  593. {
  594. regions.insert(region);
  595. }
  596. corner.mdV[VX] += mBrushSize;
  597. region = LLWorld::getInstance()->getRegionFromPosGlobal(corner);
  598. if(region && regions.find(region) == regions.end())
  599. {
  600. regions.insert(region);
  601. }
  602. corner.mdV[VY] -= mBrushSize;
  603. region = LLWorld::getInstance()->getRegionFromPosGlobal(corner);
  604. if(region && regions.find(region) == regions.end())
  605. {
  606. regions.insert(region);
  607. }
  608. }
  610. // static
  611. void LLToolBrushLand::onIdle( void* brush_tool )
  612. {
  613. LLToolBrushLand* self = reinterpret_cast<LLToolBrushLand*>(brush_tool);
  615. if( LLToolMgr::getInstance()->getCurrentTool() == self )
  616. {
  617. self->brush();
  618. }
  619. else
  620. {
  621. gIdleCallbacks.deleteFunction( &LLToolBrushLand::onIdle, self );
  622. }
  623. }
  625. void LLToolBrushLand::onMouseCaptureLost()
  626. {
  627. gIdleCallbacks.deleteFunction(&LLToolBrushLand::onIdle, this);
  628. }
  630. // static
  631. void LLToolBrushLand::undo()
  632. {
  633. for(region_list_t::iterator iter = mLastAffectedRegions.begin();
  634. iter != mLastAffectedRegions.end(); ++iter)
  635. {
  636. LLViewerRegion* regionp = *iter;
  637. gMessageSystem->newMessageFast(_PREHASH_UndoLand);
  638. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  639. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  640. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  641. gMessageSystem->sendMessage(regionp->getHost());
  642. }
  643. }
  645. // static
  646. /*
  647. void LLToolBrushLand::redo()
  648. {
  649. for(region_list_t::iterator iter = mLastAffectedRegions.begin();
  650. iter != mLastAffectedRegions.end(); ++iter)
  651. {
  652. LLViewerRegion* regionp = *iter;
  653. gMessageSystem->newMessageFast(_PREHASH_RedoLand);
  654. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  655. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  656. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  657. gMessageSystem->sendMessage(regionp->getHost());
  658. }
  659. }*/
  661. // static
  662. bool LLToolBrushLand::canTerraform(LLViewerRegion* regionp) const
  663. {
  664. if (!regionp) return false;
  665. if (regionp->canManageEstate()) return true;
  666. return !(regionp->getRegionFlags() & REGION_FLAGS_BLOCK_TERRAFORM);
  667. }
  669. // static
  670. void LLToolBrushLand::alertNoTerraform(LLViewerRegion* regionp)
  671. {
  672. if (!regionp) return;
  674. LLSD args;
  675. args["REGION"] = regionp->getName();
  676. LLNotificationsUtil::add("RegionNoTerraforming", args);
  678. }
  680. ///============================================================================
  681. /// Local function definitions
  682. ///============================================================================