lltoolmgr.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:11k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file lltoolmgr.cpp
  3.  * @brief LLToolMgr class implementation
  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.  */
  32. #include "llviewerprecompiledheaders.h"
  33. #include "lltoolmgr.h"
  34. #include "lluictrl.h"
  35. #include "llmenugl.h"
  36. #include "llfloaterreg.h"
  37. //#include "llfirstuse.h"
  38. // tools and manipulators
  39. #include "lltool.h"
  40. #include "llmanipscale.h"
  41. #include "llselectmgr.h"
  42. #include "lltoolbrush.h"
  43. #include "lltoolcomp.h"
  44. #include "lltooldraganddrop.h"
  45. #include "lltoolface.h"
  46. #include "lltoolfocus.h"
  47. #include "lltoolgrab.h"
  48. #include "lltoolindividual.h"
  49. #include "lltoolmorph.h"
  50. #include "lltoolpie.h"
  51. #include "lltoolselectland.h"
  52. #include "lltoolobjpicker.h"
  53. #include "lltoolpipette.h"
  54. #include "llagent.h"
  55. #include "llviewercontrol.h"
  56. #include "llviewerjoystick.h"
  57. #include "llviewermenu.h"
  58. #include "llviewerparcelmgr.h"
  59. // Used when app not active to avoid processing hover.
  60. LLTool* gToolNull = NULL;
  61. LLToolset* gBasicToolset = NULL;
  62. LLToolset* gCameraToolset = NULL;
  63. //LLToolset* gLandToolset = NULL;
  64. LLToolset* gMouselookToolset = NULL;
  65. LLToolset* gFaceEditToolset = NULL;
  66. /////////////////////////////////////////////////////
  67. // LLToolMgr
  68. LLToolMgr::LLToolMgr()
  69. :
  70. mBaseTool(NULL), 
  71. mSavedTool(NULL),
  72. mTransientTool( NULL ),
  73. mOverrideTool( NULL ),
  74. mSelectedTool( NULL ),
  75. mCurrentToolset( NULL )
  76. {
  77. // Not a panel, register these callbacks globally.
  78. LLUICtrl::EnableCallbackRegistry::currentRegistrar().add("Build.Active", boost::bind(&LLToolMgr::inEdit, this));
  79. LLUICtrl::EnableCallbackRegistry::currentRegistrar().add("Build.Enabled", boost::bind(&LLToolMgr::canEdit, this));
  80. LLUICtrl::CommitCallbackRegistry::currentRegistrar().add("Build.Toggle", boost::bind(&LLToolMgr::toggleBuildMode, this));
  81. gToolNull = new LLTool(LLStringUtil::null);  // Does nothing
  82. setCurrentTool(gToolNull);
  83. gBasicToolset = new LLToolset();
  84. gCameraToolset = new LLToolset();
  85. // gLandToolset = new LLToolset();
  86. gMouselookToolset = new LLToolset();
  87. gFaceEditToolset = new LLToolset();
  88. }
  89. void LLToolMgr::initTools()
  90. {
  91. static BOOL initialized = FALSE;
  92. if(initialized)
  93. {
  94. return;
  95. }
  96. initialized = TRUE;
  97. gBasicToolset->addTool( LLToolPie::getInstance() );
  98. gBasicToolset->addTool( LLToolCamera::getInstance() );
  99. gCameraToolset->addTool( LLToolCamera::getInstance() );
  100. gBasicToolset->addTool( LLToolGrab::getInstance() );
  101. gBasicToolset->addTool( LLToolCompTranslate::getInstance() );
  102. gBasicToolset->addTool( LLToolCompCreate::getInstance() );
  103. gBasicToolset->addTool( LLToolBrushLand::getInstance() );
  104. gMouselookToolset->addTool( LLToolCompGun::getInstance() );
  105. gBasicToolset->addTool( LLToolCompInspect::getInstance() );
  106. gFaceEditToolset->addTool( LLToolCamera::getInstance() );
  107. // On startup, use "select" tool
  108. setCurrentToolset(gBasicToolset);
  109. gBasicToolset->selectTool( LLToolPie::getInstance() );
  110. }
  111. LLToolMgr::~LLToolMgr()
  112. {
  113. delete gBasicToolset;
  114. gBasicToolset = NULL;
  115. delete gMouselookToolset;
  116. gMouselookToolset = NULL;
  117. delete gFaceEditToolset;
  118. gFaceEditToolset = NULL;
  119. delete gCameraToolset;
  120. gCameraToolset = NULL;
  121. delete gToolNull;
  122. gToolNull = NULL;
  123. }
  124. BOOL LLToolMgr::usingTransientTool()
  125. {
  126. return mTransientTool ? TRUE : FALSE;
  127. }
  128. void LLToolMgr::setCurrentToolset(LLToolset* current)
  129. {
  130. if (!current) return;
  131. // switching toolsets?
  132. if (current != mCurrentToolset)
  133. {
  134. // deselect current tool
  135. if (mSelectedTool)
  136. {
  137. mSelectedTool->handleDeselect();
  138. }
  139. mCurrentToolset = current;
  140. // select first tool of new toolset only if toolset changed
  141. mCurrentToolset->selectFirstTool();
  142. }
  143. // update current tool based on new toolset
  144. setCurrentTool( mCurrentToolset->getSelectedTool() );
  145. }
  146. LLToolset* LLToolMgr::getCurrentToolset()
  147. {
  148. return mCurrentToolset;
  149. }
  150. void LLToolMgr::setCurrentTool( LLTool* tool )
  151. {
  152. if (mTransientTool)
  153. {
  154. mTransientTool = NULL;
  155. }
  156. mBaseTool = tool;
  157. updateToolStatus();
  158. mSavedTool = NULL;
  159. }
  160. LLTool* LLToolMgr::getCurrentTool()
  161. {
  162. MASK override_mask = gKeyboard ? gKeyboard->currentMask(TRUE) : 0;
  163. LLTool* cur_tool = NULL;
  164. // always use transient tools if available
  165. if (mTransientTool)
  166. {
  167. mOverrideTool = NULL;
  168. cur_tool = mTransientTool;
  169. }
  170. // tools currently grabbing mouse input will stay active
  171. else if (mSelectedTool && mSelectedTool->hasMouseCapture())
  172. {
  173. cur_tool = mSelectedTool;
  174. }
  175. else
  176. {
  177. mOverrideTool = mBaseTool ? mBaseTool->getOverrideTool(override_mask) : NULL;
  178. // use override tool if available otherwise drop back to base tool
  179. cur_tool = mOverrideTool ? mOverrideTool : mBaseTool;
  180. }
  181. LLTool* prev_tool = mSelectedTool;
  182. // Set the selected tool to avoid infinite recursion
  183. mSelectedTool = cur_tool;
  184. //update tool selection status
  185. if (prev_tool != cur_tool)
  186. {
  187. if (prev_tool)
  188. {
  189. prev_tool->handleDeselect();
  190. }
  191. if (cur_tool)
  192. {
  193. cur_tool->handleSelect();
  194. }
  195. }
  196. return mSelectedTool;
  197. }
  198. LLTool* LLToolMgr::getBaseTool()
  199. {
  200. return mBaseTool;
  201. }
  202. void LLToolMgr::updateToolStatus()
  203. {
  204. // call getcurrenttool() to calculate active tool and call handleSelect() and handleDeselect() immediately
  205. // when active tool changes
  206. getCurrentTool();
  207. }
  208. bool LLToolMgr::inEdit()
  209. {
  210. return mBaseTool != LLToolPie::getInstance() && mBaseTool != gToolNull;
  211. }
  212. bool LLToolMgr::canEdit()
  213. {
  214. return LLViewerParcelMgr::getInstance()->allowAgentBuild();
  215. }
  216. void LLToolMgr::toggleBuildMode()
  217. {
  218. if (inBuildMode())
  219. {
  220. if (gSavedSettings.getBOOL("EditCameraMovement"))
  221. {
  222. // just reset the view, will pull us out of edit mode
  223. handle_reset_view();
  224. }
  225. else
  226. {
  227. // manually disable edit mode, but do not affect the camera
  228. gAgent.resetView(false);
  229. LLFloaterReg::hideInstance("build");
  230. gViewerWindow->showCursor();
  231. }
  232. // avoid spurious avatar movements pulling out of edit mode
  233. LLViewerJoystick::getInstance()->setNeedsReset();
  234. }
  235. else
  236. {
  237. ECameraMode camMode = gAgent.getCameraMode();
  238. if (CAMERA_MODE_MOUSELOOK == camMode || CAMERA_MODE_CUSTOMIZE_AVATAR == camMode)
  239. {
  240. // pull the user out of mouselook or appearance mode when entering build mode
  241. handle_reset_view();
  242. }
  243. if (gSavedSettings.getBOOL("EditCameraMovement"))
  244. {
  245. // camera should be set
  246. if (LLViewerJoystick::getInstance()->getOverrideCamera())
  247. {
  248. handle_toggle_flycam();
  249. }
  250. if (gAgent.getFocusOnAvatar())
  251. {
  252. // zoom in if we're looking at the avatar
  253. gAgent.setFocusOnAvatar(FALSE, ANIMATE);
  254. gAgent.setFocusGlobal(gAgent.getPositionGlobal() + 2.0 * LLVector3d(gAgent.getAtAxis()));
  255. gAgent.cameraZoomIn(0.666f);
  256. gAgent.cameraOrbitOver( 30.f * DEG_TO_RAD );
  257. }
  258. }
  259. setCurrentToolset(gBasicToolset);
  260. getCurrentToolset()->selectTool( LLToolCompCreate::getInstance() );
  261. // Could be first use
  262. //LLFirstUse::useBuild();
  263. gAgent.resetView(false);
  264. // avoid spurious avatar movements
  265. LLViewerJoystick::getInstance()->setNeedsReset();
  266. }
  267. }
  268. bool LLToolMgr::inBuildMode()
  269. {
  270. // when entering mouselook inEdit() immediately returns true before 
  271. // cameraMouselook() actually starts returning true.  Also, appearance edit
  272. // sets build mode to true, so let's exclude that.
  273. bool b=(inEdit() 
  274. && !gAgent.cameraMouselook()
  275. && mCurrentToolset != gFaceEditToolset);
  276. return b;
  277. }
  278. void LLToolMgr::setTransientTool(LLTool* tool)
  279. {
  280. if (!tool)
  281. {
  282. clearTransientTool();
  283. }
  284. else
  285. {
  286. if (mTransientTool)
  287. {
  288. mTransientTool = NULL;
  289. }
  290. mTransientTool = tool;
  291. }
  292. updateToolStatus();
  293. }
  294. void LLToolMgr::clearTransientTool()
  295. {
  296. if (mTransientTool)
  297. {
  298. mTransientTool = NULL;
  299. if (!mBaseTool)
  300. {
  301. llwarns << "mBaseTool is NULL" << llendl;
  302. }
  303. }
  304. updateToolStatus();
  305. }
  306. void LLToolMgr::onAppFocusLost()
  307. {
  308. if (mSelectedTool)
  309. {
  310. mSelectedTool->handleDeselect();
  311. }
  312. updateToolStatus();
  313. }
  314. void LLToolMgr::onAppFocusGained()
  315. {
  316. if (mSelectedTool)
  317. {
  318. mSelectedTool->handleSelect();
  319. }
  320. updateToolStatus();
  321. }
  322. void LLToolMgr::clearSavedTool()
  323. {
  324. mSavedTool = NULL;
  325. }
  326. /////////////////////////////////////////////////////
  327. // LLToolset
  328. void LLToolset::addTool(LLTool* tool)
  329. {
  330. mToolList.push_back( tool );
  331. if( !mSelectedTool )
  332. {
  333. mSelectedTool = tool;
  334. }
  335. }
  336. void LLToolset::selectTool(LLTool* tool)
  337. {
  338. mSelectedTool = tool;
  339. LLToolMgr::getInstance()->setCurrentTool( mSelectedTool );
  340. }
  341. void LLToolset::selectToolByIndex( S32 index )
  342. {
  343. LLTool *tool = (index >= 0 && index < (S32)mToolList.size()) ? mToolList[index] : NULL;
  344. if (tool)
  345. {
  346. mSelectedTool = tool;
  347. LLToolMgr::getInstance()->setCurrentTool( tool );
  348. }
  349. }
  350. BOOL LLToolset::isToolSelected( S32 index )
  351. {
  352. LLTool *tool = (index >= 0 && index < (S32)mToolList.size()) ? mToolList[index] : NULL;
  353. return (tool == mSelectedTool);
  354. }
  355. void LLToolset::selectFirstTool()
  356. {
  357. mSelectedTool = (0 < mToolList.size()) ? mToolList[0] : NULL;
  358. LLToolMgr::getInstance()->setCurrentTool( mSelectedTool );
  359. }
  360. void LLToolset::selectNextTool()
  361. {
  362. LLTool* next = NULL;
  363. for( tool_list_t::iterator iter = mToolList.begin();
  364.  iter != mToolList.end(); )
  365. {
  366. LLTool* cur = *iter++;
  367. if( cur == mSelectedTool && iter != mToolList.end() )
  368. {
  369. next = *iter;
  370. break;
  371. }
  372. }
  373. if( next )
  374. {
  375. mSelectedTool = next;
  376. LLToolMgr::getInstance()->setCurrentTool( mSelectedTool );
  377. }
  378. else
  379. {
  380. selectFirstTool();
  381. }
  382. }
  383. void LLToolset::selectPrevTool()
  384. {
  385. LLTool* prev = NULL;
  386. for( tool_list_t::reverse_iterator iter = mToolList.rbegin();
  387.  iter != mToolList.rend(); )
  388. {
  389. LLTool* cur = *iter++;
  390. if( cur == mSelectedTool && iter != mToolList.rend() )
  391. {
  392. prev = *iter;
  393. break;
  394. }
  395. }
  396. if( prev )
  397. {
  398. mSelectedTool = prev;
  399. LLToolMgr::getInstance()->setCurrentTool( mSelectedTool );
  400. }
  401. else if (mToolList.size() > 0)
  402. {
  403. selectToolByIndex((S32)mToolList.size()-1);
  404. }
  405. }
  406. ////////////////////////////////////////////////////////////////////////////