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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file lltoolplacer.cpp
  3.  * @brief Tool for placing new objects into the world
  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. // self header
  34. #include "lltoolplacer.h"
  35. // viewer headers
  36. #include "llbutton.h"
  37. #include "llviewercontrol.h"
  38. //#include "llfirstuse.h"
  39. #include "llfloatertools.h"
  40. #include "llselectmgr.h"
  41. #include "llstatusbar.h"
  42. #include "lltoolcomp.h"
  43. #include "lltoolmgr.h"
  44. #include "llviewerobject.h"
  45. #include "llviewerregion.h"
  46. #include "llviewerwindow.h"
  47. #include "llworld.h"
  48. #include "llui.h"
  49. //Headers added for functions moved from viewer.cpp
  50. #include "llvograss.h"
  51. #include "llvotree.h"
  52. #include "llvolumemessage.h"
  53. #include "llhudmanager.h"
  54. #include "llagent.h"
  55. #include "llaudioengine.h"
  56. #include "llhudeffecttrail.h"
  57. #include "llviewerobjectlist.h"
  58. #include "llviewercamera.h"
  59. #include "llviewerstats.h"
  60. // linden library headers
  61. #include "llprimitive.h"
  62. #include "llwindow.h" // incBusyCount()
  63. #include "material_codes.h"
  64. const LLVector3 DEFAULT_OBJECT_SCALE(0.5f, 0.5f, 0.5f);
  65. //static 
  66. LLPCode LLToolPlacer::sObjectType = LL_PCODE_CUBE;
  67. LLToolPlacer::LLToolPlacer()
  68. : LLTool( "Create" )
  69. {
  70. }
  71. BOOL LLToolPlacer::raycastForNewObjPos( S32 x, S32 y, LLViewerObject** hit_obj, S32* hit_face, 
  72.  BOOL* b_hit_land, LLVector3* ray_start_region, LLVector3* ray_end_region, LLViewerRegion** region )
  73. {
  74. F32 max_dist_from_camera = gSavedSettings.getF32( "MaxSelectDistance" ) - 1.f;
  75. // Viewer-side pick to find the right sim to create the object on.  
  76. // First find the surface the object will be created on.
  77. LLPickInfo pick = gViewerWindow->pickImmediate(x, y, FALSE);
  78. // Note: use the frontmost non-flora version because (a) plants usually have lots of alpha and (b) pants' Havok
  79. // representations (if any) are NOT the same as their viewer representation.
  80. if (pick.mPickType == LLPickInfo::PICK_FLORA)
  81. {
  82. *hit_obj = NULL;
  83. *hit_face = -1;
  84. }
  85. else
  86. {
  87. *hit_obj = pick.getObject();
  88. *hit_face = pick.mObjectFace;
  89. }
  90. *b_hit_land = !(*hit_obj) && !pick.mPosGlobal.isExactlyZero();
  91. LLVector3d land_pos_global = pick.mPosGlobal;
  92. // Make sure there's a surface to place the new object on.
  93. BOOL bypass_sim_raycast = FALSE;
  94. LLVector3d surface_pos_global;
  95. if (*b_hit_land)
  96. {
  97. surface_pos_global = land_pos_global; 
  98. bypass_sim_raycast = TRUE;
  99. }
  100. else 
  101. if (*hit_obj)
  102. {
  103. surface_pos_global = (*hit_obj)->getPositionGlobal();
  104. }
  105. else
  106. {
  107. return FALSE;
  108. }
  109. // Make sure the surface isn't too far away.
  110. LLVector3d ray_start_global = gAgent.getCameraPositionGlobal();
  111. F32 dist_to_surface_sq = (F32)((surface_pos_global - ray_start_global).magVecSquared());
  112. if( dist_to_surface_sq > (max_dist_from_camera * max_dist_from_camera) )
  113. {
  114. return FALSE;
  115. }
  116. // Find the sim where the surface lives.
  117. LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromPosGlobal(surface_pos_global);
  118. if (!regionp)
  119. {
  120. llwarns << "Trying to add object outside of all known regions!" << llendl;
  121. return FALSE;
  122. }
  123. // Find the simulator-side ray that will be used to place the object accurately
  124. LLVector3d mouse_direction;
  125. mouse_direction.setVec( gViewerWindow->mouseDirectionGlobal( x, y ) );
  126. *region = regionp;
  127. *ray_start_region = regionp->getPosRegionFromGlobal( ray_start_global );
  128. F32 near_clip = LLViewerCamera::getInstance()->getNear() + 0.01f;  // Include an epsilon to avoid rounding issues.
  129. *ray_start_region += LLViewerCamera::getInstance()->getAtAxis() * near_clip;
  130. if( bypass_sim_raycast )
  131. {
  132. // Hack to work around Havok's inability to ray cast onto height fields
  133. *ray_end_region = regionp->getPosRegionFromGlobal( surface_pos_global );  // ray end is the viewer's intersection point
  134. }
  135. else
  136. {
  137. LLVector3d ray_end_global = ray_start_global + (1.f + max_dist_from_camera) * mouse_direction;  // add an epsilon to the sim version of the ray to avoid rounding problems.
  138. *ray_end_region = regionp->getPosRegionFromGlobal( ray_end_global );
  139. }
  140. return TRUE;
  141. }
  142. BOOL LLToolPlacer::addObject( LLPCode pcode, S32 x, S32 y, U8 use_physics )
  143. {
  144. LLVector3 ray_start_region;
  145. LLVector3 ray_end_region;
  146. LLViewerRegion* regionp = NULL;
  147. BOOL b_hit_land = FALSE;
  148. S32 hit_face = -1;
  149. LLViewerObject* hit_obj = NULL;
  150. U8 state = 0;
  151. BOOL success = raycastForNewObjPos( x, y, &hit_obj, &hit_face, &b_hit_land, &ray_start_region, &ray_end_region, &regionp );
  152. if( !success )
  153. {
  154. return FALSE;
  155. }
  156. if( hit_obj && (hit_obj->isAvatar() || hit_obj->isAttachment()) )
  157. {
  158. // Can't create objects on avatars or attachments
  159. return FALSE;
  160. }
  161. if (NULL == regionp)
  162. {
  163. llwarns << "regionp was NULL; aborting function." << llendl;
  164. return FALSE;
  165. }
  166. if (regionp->getRegionFlags() & REGION_FLAGS_SANDBOX)
  167. {
  168. //LLFirstUse::useSandbox();
  169. }
  170. // Set params for new object based on its PCode.
  171. LLQuaternion rotation;
  172. LLVector3 scale = DEFAULT_OBJECT_SCALE;
  173. U8 material = LL_MCODE_WOOD;
  174. BOOL create_selected = FALSE;
  175. LLVolumeParams volume_params;
  176. switch (pcode) 
  177. {
  178. case LL_PCODE_LEGACY_GRASS:
  179. //  Randomize size of grass patch 
  180. scale.setVec(10.f + ll_frand(20.f), 10.f + ll_frand(20.f),  1.f + ll_frand(2.f));
  181. state = rand() % LLVOGrass::sMaxGrassSpecies;
  182. break;
  183. case LL_PCODE_LEGACY_TREE:
  184. case LL_PCODE_TREE_NEW:
  185. state = rand() % LLVOTree::sMaxTreeSpecies;
  186. break;
  187. case LL_PCODE_SPHERE:
  188. case LL_PCODE_CONE:
  189. case LL_PCODE_CUBE:
  190. case LL_PCODE_CYLINDER:
  191. case LL_PCODE_TORUS:
  192. case LLViewerObject::LL_VO_SQUARE_TORUS:
  193. case LLViewerObject::LL_VO_TRIANGLE_TORUS:
  194. default:
  195. create_selected = TRUE;
  196. break;
  197. }
  198. // Play creation sound
  199. if (gAudiop)
  200. {
  201. gAudiop->triggerSound( LLUUID(gSavedSettings.getString("UISndObjectCreate")),
  202.    gAgent.getID(), 1.0f, LLAudioEngine::AUDIO_TYPE_UI);
  203. }
  204. gMessageSystem->newMessageFast(_PREHASH_ObjectAdd);
  205. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  206. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  207. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  208. gMessageSystem->addUUIDFast(_PREHASH_GroupID, gAgent.getGroupID());
  209. gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
  210. gMessageSystem->addU8Fast(_PREHASH_Material, material);
  211. U32 flags = 0; // not selected
  212. if (use_physics)
  213. {
  214. flags |= FLAGS_USE_PHYSICS;
  215. }
  216. if (create_selected)
  217. {
  218. flags |= FLAGS_CREATE_SELECTED;
  219. }
  220. gMessageSystem->addU32Fast(_PREHASH_AddFlags, flags );
  221. LLPCode volume_pcode; // ...PCODE_VOLUME, or the original on error
  222. switch (pcode)
  223. {
  224. case LL_PCODE_SPHERE:
  225. rotation.setQuat(90.f * DEG_TO_RAD, LLVector3::y_axis);
  226. volume_params.setType( LL_PCODE_PROFILE_CIRCLE_HALF, LL_PCODE_PATH_CIRCLE );
  227. volume_params.setBeginAndEndS( 0.f, 1.f );
  228. volume_params.setBeginAndEndT( 0.f, 1.f );
  229. volume_params.setRatio ( 1, 1 );
  230. volume_params.setShear ( 0, 0 );
  231. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  232. volume_pcode = LL_PCODE_VOLUME;
  233. break;
  234. case LL_PCODE_TORUS:
  235. rotation.setQuat(90.f * DEG_TO_RAD, LLVector3::y_axis);
  236. volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_CIRCLE );
  237. volume_params.setBeginAndEndS( 0.f, 1.f );
  238. volume_params.setBeginAndEndT( 0.f, 1.f );
  239. volume_params.setRatio ( 1.f, 0.25f ); // "top size"
  240. volume_params.setShear ( 0, 0 );
  241. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  242. volume_pcode = LL_PCODE_VOLUME;
  243. break;
  244. case LLViewerObject::LL_VO_SQUARE_TORUS:
  245. rotation.setQuat(90.f * DEG_TO_RAD, LLVector3::y_axis);
  246. volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_CIRCLE );
  247. volume_params.setBeginAndEndS( 0.f, 1.f );
  248. volume_params.setBeginAndEndT( 0.f, 1.f );
  249. volume_params.setRatio ( 1.f, 0.25f ); // "top size"
  250. volume_params.setShear ( 0, 0 );
  251. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  252. volume_pcode = LL_PCODE_VOLUME;
  253. break;
  254. case LLViewerObject::LL_VO_TRIANGLE_TORUS:
  255. rotation.setQuat(90.f * DEG_TO_RAD, LLVector3::y_axis);
  256. volume_params.setType( LL_PCODE_PROFILE_EQUALTRI, LL_PCODE_PATH_CIRCLE );
  257. volume_params.setBeginAndEndS( 0.f, 1.f );
  258. volume_params.setBeginAndEndT( 0.f, 1.f );
  259. volume_params.setRatio ( 1.f, 0.25f ); // "top size"
  260. volume_params.setShear ( 0, 0 );
  261. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  262. volume_pcode = LL_PCODE_VOLUME;
  263. break;
  264. case LL_PCODE_SPHERE_HEMI:
  265. volume_params.setType( LL_PCODE_PROFILE_CIRCLE_HALF, LL_PCODE_PATH_CIRCLE );
  266. //volume_params.setBeginAndEndS( 0.5f, 1.f );
  267. volume_params.setBeginAndEndT( 0.f, 0.5f );
  268. volume_params.setRatio ( 1, 1 );
  269. volume_params.setShear ( 0, 0 );
  270. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  271. volume_pcode = LL_PCODE_VOLUME;
  272. break;
  273. case LL_PCODE_CUBE:
  274. volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE );
  275. volume_params.setBeginAndEndS( 0.f, 1.f );
  276. volume_params.setBeginAndEndT( 0.f, 1.f );
  277. volume_params.setRatio ( 1, 1 );
  278. volume_params.setShear ( 0, 0 );
  279. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  280. volume_pcode = LL_PCODE_VOLUME;
  281. break;
  282. case LL_PCODE_PRISM:
  283. volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE );
  284. volume_params.setBeginAndEndS( 0.f, 1.f );
  285. volume_params.setBeginAndEndT( 0.f, 1.f );
  286. volume_params.setRatio ( 0, 1 );
  287. volume_params.setShear ( -0.5f, 0 );
  288. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  289. volume_pcode = LL_PCODE_VOLUME;
  290. break;
  291. case LL_PCODE_PYRAMID:
  292. volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE );
  293. volume_params.setBeginAndEndS( 0.f, 1.f );
  294. volume_params.setBeginAndEndT( 0.f, 1.f );
  295. volume_params.setRatio ( 0, 0 );
  296. volume_params.setShear ( 0, 0 );
  297. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  298. volume_pcode = LL_PCODE_VOLUME;
  299. break;
  300. case LL_PCODE_TETRAHEDRON:
  301. volume_params.setType( LL_PCODE_PROFILE_EQUALTRI, LL_PCODE_PATH_LINE );
  302. volume_params.setBeginAndEndS( 0.f, 1.f );
  303. volume_params.setBeginAndEndT( 0.f, 1.f );
  304. volume_params.setRatio ( 0, 0 );
  305. volume_params.setShear ( 0, 0 );
  306. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  307. volume_pcode = LL_PCODE_VOLUME;
  308. break;
  309. case LL_PCODE_CYLINDER:
  310. volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
  311. volume_params.setBeginAndEndS( 0.f, 1.f );
  312. volume_params.setBeginAndEndT( 0.f, 1.f );
  313. volume_params.setRatio ( 1, 1 );
  314. volume_params.setShear ( 0, 0 );
  315. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  316. volume_pcode = LL_PCODE_VOLUME;
  317. break;
  318. case LL_PCODE_CYLINDER_HEMI:
  319. volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
  320. volume_params.setBeginAndEndS( 0.25f, 0.75f );
  321. volume_params.setBeginAndEndT( 0.f, 1.f );
  322. volume_params.setRatio ( 1, 1 );
  323. volume_params.setShear ( 0, 0 );
  324. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  325. volume_pcode = LL_PCODE_VOLUME;
  326. break;
  327. case LL_PCODE_CONE:
  328. volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
  329. volume_params.setBeginAndEndS( 0.f, 1.f );
  330. volume_params.setBeginAndEndT( 0.f, 1.f );
  331. volume_params.setRatio ( 0, 0 );
  332. volume_params.setShear ( 0, 0 );
  333. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  334. volume_pcode = LL_PCODE_VOLUME;
  335. break;
  336. case LL_PCODE_CONE_HEMI:
  337. volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
  338. volume_params.setBeginAndEndS( 0.25f, 0.75f );
  339. volume_params.setBeginAndEndT( 0.f, 1.f );
  340. volume_params.setRatio ( 0, 0 );
  341. volume_params.setShear ( 0, 0 );
  342. LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
  343. volume_pcode = LL_PCODE_VOLUME;
  344. break;
  345. default:
  346. LLVolumeMessage::packVolumeParams(0, gMessageSystem);
  347. volume_pcode = pcode;
  348. break;
  349. }
  350. gMessageSystem->addU8Fast(_PREHASH_PCode, volume_pcode);
  351. gMessageSystem->addVector3Fast(_PREHASH_Scale, scale );
  352. gMessageSystem->addQuatFast(_PREHASH_Rotation, rotation );
  353. gMessageSystem->addVector3Fast(_PREHASH_RayStart, ray_start_region );
  354. gMessageSystem->addVector3Fast(_PREHASH_RayEnd, ray_end_region );
  355. gMessageSystem->addU8Fast(_PREHASH_BypassRaycast, (U8)b_hit_land );
  356. gMessageSystem->addU8Fast(_PREHASH_RayEndIsIntersection, (U8)FALSE );
  357. gMessageSystem->addU8Fast(_PREHASH_State, state);
  358. // Limit raycast to a single object.  
  359. // Speeds up server raycast + avoid problems with server ray hitting objects
  360. // that were clipped by the near plane or culled on the viewer.
  361. LLUUID ray_target_id;
  362. if( hit_obj )
  363. {
  364. ray_target_id = hit_obj->getID();
  365. }
  366. else
  367. {
  368. ray_target_id.setNull();
  369. }
  370. gMessageSystem->addUUIDFast(_PREHASH_RayTargetID, ray_target_id );
  371. // Pack in name value pairs
  372. gMessageSystem->sendReliable(regionp->getHost());
  373. // Spawns a message, so must be after above send
  374. if (create_selected)
  375. {
  376. LLSelectMgr::getInstance()->deselectAll();
  377. gViewerWindow->getWindow()->incBusyCount();
  378. }
  379. // VEFFECT: AddObject
  380. LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_BEAM, TRUE);
  381. effectp->setSourceObject((LLViewerObject*)gAgent.getAvatarObject());
  382. effectp->setPositionGlobal(regionp->getPosGlobalFromRegion(ray_end_region));
  383. effectp->setDuration(LL_HUD_DUR_SHORT);
  384. effectp->setColor(LLColor4U(gAgent.getEffectColor()));
  385. LLViewerStats::getInstance()->incStat(LLViewerStats::ST_CREATE_COUNT);
  386. return TRUE;
  387. }
  388. // Used by the placer tool to add copies of the current selection.
  389. // Inspired by add_object().  JC
  390. BOOL LLToolPlacer::addDuplicate(S32 x, S32 y)
  391. {
  392. LLVector3 ray_start_region;
  393. LLVector3 ray_end_region;
  394. LLViewerRegion* regionp = NULL;
  395. BOOL b_hit_land = FALSE;
  396. S32 hit_face = -1;
  397. LLViewerObject* hit_obj = NULL;
  398. BOOL success = raycastForNewObjPos( x, y, &hit_obj, &hit_face, &b_hit_land, &ray_start_region, &ray_end_region, &regionp );
  399. if( !success )
  400. {
  401. make_ui_sound("UISndInvalidOp");
  402. return FALSE;
  403. }
  404. if( hit_obj && (hit_obj->isAvatar() || hit_obj->isAttachment()) )
  405. {
  406. // Can't create objects on avatars or attachments
  407. make_ui_sound("UISndInvalidOp");
  408. return FALSE;
  409. }
  410. // Limit raycast to a single object.  
  411. // Speeds up server raycast + avoid problems with server ray hitting objects
  412. // that were clipped by the near plane or culled on the viewer.
  413. LLUUID ray_target_id;
  414. if( hit_obj )
  415. {
  416. ray_target_id = hit_obj->getID();
  417. }
  418. else
  419. {
  420. ray_target_id.setNull();
  421. }
  422. LLSelectMgr::getInstance()->selectDuplicateOnRay(ray_start_region,
  423. ray_end_region,
  424. b_hit_land, // suppress raycast
  425. FALSE, // intersection
  426. ray_target_id,
  427. gSavedSettings.getBOOL("CreateToolCopyCenters"),
  428. gSavedSettings.getBOOL("CreateToolCopyRotates"),
  429. FALSE); // select copy
  430. if (regionp
  431. && (regionp->getRegionFlags() & REGION_FLAGS_SANDBOX))
  432. {
  433. //LLFirstUse::useSandbox();
  434. }
  435. return TRUE;
  436. }
  437. BOOL LLToolPlacer::placeObject(S32 x, S32 y, MASK mask)
  438. {
  439. BOOL added = TRUE;
  440. if (gSavedSettings.getBOOL("CreateToolCopySelection"))
  441. {
  442. added = addDuplicate(x, y);
  443. }
  444. else
  445. {
  446. added = addObject( sObjectType, x, y, FALSE );
  447. }
  448. // ...and go back to the default tool
  449. if (added && !gSavedSettings.getBOOL("CreateToolKeepSelected"))
  450. {
  451. LLToolMgr::getInstance()->getCurrentToolset()->selectTool( LLToolCompTranslate::getInstance() );
  452. }
  453. return added;
  454. }
  455. BOOL LLToolPlacer::handleHover(S32 x, S32 y, MASK mask)
  456. {
  457. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPlacer" << llendl;
  458. gViewerWindow->setCursor(UI_CURSOR_TOOLCREATE);
  459. return TRUE;
  460. }
  461. void LLToolPlacer::handleSelect()
  462. {
  463. gFloaterTools->setStatusText("place");
  464. }
  465. void LLToolPlacer::handleDeselect()
  466. {
  467. }