forestBrushTool.cpp 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696
  1. //-----------------------------------------------------------------------------
  2. // Copyright (c) 2012 GarageGames, LLC
  3. //
  4. // Permission is hereby granted, free of charge, to any person obtaining a copy
  5. // of this software and associated documentation files (the "Software"), to
  6. // deal in the Software without restriction, including without limitation the
  7. // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  8. // sell copies of the Software, and to permit persons to whom the Software is
  9. // furnished to do so, subject to the following conditions:
  10. //
  11. // The above copyright notice and this permission notice shall be included in
  12. // all copies or substantial portions of the Software.
  13. //
  14. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15. // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16. // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17. // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18. // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  20. // IN THE SOFTWARE.
  21. //-----------------------------------------------------------------------------
  22. #include "platform/platform.h"
  23. #include "forest/editor/forestBrushTool.h"
  24. #include "forest/forest.h"
  25. #include "forest/editor/forestUndo.h"
  26. #include "forest/editor/forestBrushElement.h"
  27. #include "forest/editor/forestEditorCtrl.h"
  28. #include "gui/worldEditor/editTSCtrl.h"
  29. #include "console/consoleTypes.h"
  30. #include "console/engineAPI.h"
  31. #include "core/util/tVector.h"
  32. #include "gfx/gfxDrawUtil.h"
  33. #include "gui/core/guiCanvas.h"
  34. #include "gfx/primBuilder.h"
  35. #include "gui/controls/guiTreeViewCtrl.h"
  36. #include "core/strings/stringUnit.h"
  37. #include "math/mRandomDeck.h"
  38. #include "math/mRandomSet.h"
  39. #include "scene/sceneContainer.h"
  40. bool ForestBrushTool::protectedSetSize( void *object, const char *index, const char *data )
  41. {
  42. ForestBrushTool *tool = static_cast<ForestBrushTool*>( object );
  43. F32 val = dAtof(data);
  44. tool->setSize( val );
  45. return false;
  46. }
  47. bool ForestBrushTool::protectedSetPressure( void *object, const char *index, const char *data )
  48. {
  49. ForestBrushTool *tool = static_cast<ForestBrushTool*>( object );
  50. F32 val = dAtof(data);
  51. tool->setPressure( val );
  52. return false;
  53. }
  54. bool ForestBrushTool::protectedSetHardness( void *object, const char *index, const char *data )
  55. {
  56. ForestBrushTool *tool = static_cast<ForestBrushTool*>( object );
  57. F32 val = dAtof(data);
  58. tool->setHardness( val );
  59. return false;
  60. }
  61. ImplementEnumType( ForestBrushMode,
  62. "Active brush mode type.\n"
  63. "@internal\n\n")
  64. { ForestBrushTool::Paint, "Paint", "Creates Items based on the Elements you have selected.\n" },
  65. { ForestBrushTool::Erase, "Erase", "Erases Items of any Mesh type.\n" },
  66. { ForestBrushTool::EraseSelected, "EraseSelected", "Erases items of a specific type.\n" },
  67. EndImplementEnumType;
  68. ForestBrushTool::ForestBrushTool()
  69. : mRandom( Platform::getRealMilliseconds() + 1 ),
  70. mSize( 5.0f ),
  71. mPressure( 0.1f ),
  72. mHardness( 1.0f ),
  73. mMode( Paint ),
  74. mColor( ColorI::WHITE ),
  75. mBrushDown( false ),
  76. mDrawBrush( false ),
  77. mStrokeEvent( 0 ),
  78. mCurrAction( NULL )
  79. {
  80. }
  81. ForestBrushTool::~ForestBrushTool()
  82. {
  83. }
  84. IMPLEMENT_CONOBJECT( ForestBrushTool );
  85. ConsoleDocClass( ForestBrushTool,
  86. "@brief Defines the brush properties when painting trees in Forest Editor\n\n"
  87. "Editor use only.\n\n"
  88. "@internal"
  89. );
  90. void ForestBrushTool::initPersistFields()
  91. {
  92. docsURL;
  93. addGroup( "ForestBrushTool" );
  94. addField( "mode", TYPEID< BrushMode >(), Offset( mMode, ForestBrushTool) );
  95. addProtectedField( "size", TypeF32, Offset( mSize, ForestBrushTool ),
  96. &protectedSetSize, &defaultProtectedGetFn, "Brush Size" );
  97. addProtectedField( "pressure", TypeF32, Offset( mPressure, ForestBrushTool ),
  98. &protectedSetPressure, &defaultProtectedGetFn, "Brush Pressure" );
  99. addProtectedField( "hardness", TypeF32, Offset( mHardness, ForestBrushTool ),
  100. &protectedSetHardness, &defaultProtectedGetFn, "Brush Hardness" );
  101. endGroup( "ForestBrushTool" );
  102. Parent::initPersistFields();
  103. }
  104. bool ForestBrushTool::onAdd()
  105. {
  106. if ( !Parent::onAdd() )
  107. return false;
  108. return true;
  109. }
  110. void ForestBrushTool::onRemove()
  111. {
  112. Parent::onRemove();
  113. }
  114. void ForestBrushTool::on3DMouseDown( const Gui3DMouseEvent &evt )
  115. {
  116. Con::executef( this, "onMouseDown" );
  117. if ( !_updateBrushPoint( evt ) || !mForest )
  118. return;
  119. mBrushDown = true;
  120. mEditor->getRoot()->showCursor( false );
  121. _collectElements();
  122. _onStroke();
  123. return;
  124. }
  125. void ForestBrushTool::on3DMouseUp( const Gui3DMouseEvent &evt )
  126. {
  127. _updateBrushPoint( evt );
  128. Sim::cancelEvent( mStrokeEvent );
  129. mBrushDown = false;
  130. mEditor->getRoot()->showCursor( true );
  131. if ( mCurrAction )
  132. {
  133. _submitUndo( mCurrAction );
  134. mCurrAction = NULL;
  135. }
  136. //mElements.clear();
  137. }
  138. void ForestBrushTool::on3DMouseMove( const Gui3DMouseEvent &evt )
  139. {
  140. _updateBrushPoint( evt );
  141. }
  142. void ForestBrushTool::on3DMouseDragged( const Gui3DMouseEvent &evt )
  143. {
  144. _updateBrushPoint( evt );
  145. if ( mBrushDown && !Sim::isEventPending( mStrokeEvent ) )
  146. mStrokeEvent = Sim::postEvent( this, new ForestBrushToolEvent(), Sim::getCurrentTime() + 250 );
  147. }
  148. bool ForestBrushTool::onMouseWheel( const GuiEvent &evt )
  149. {
  150. if ( evt.modifier & SI_PRIMARY_CTRL )
  151. setPressure( mPressure + evt.fval * ( 0.05f / 120.0f ) );
  152. else if ( evt.modifier & SI_SHIFT )
  153. setHardness( mHardness + evt.fval * ( 0.05f / 120.0f ) );
  154. else
  155. setSize( mSize + evt.fval * ( 1.0f / 120.0f ) );
  156. return true;
  157. }
  158. void ForestBrushTool::onRender3D( )
  159. {
  160. }
  161. void ForestBrushTool::onRender2D()
  162. {
  163. if ( !mDrawBrush )
  164. return;
  165. if ( !mEditor->getRoot()->isCursorON() && !mBrushDown )
  166. return;
  167. RayInfo ri;
  168. Point3F start( 0, 0, mLastBrushPoint.z + mSize );
  169. Point3F end( 0, 0, mLastBrushPoint.z - mSize );
  170. Vector<Point3F> pointList;
  171. const U32 steps = 32;
  172. if ( mForest )
  173. mForest->disableCollision();
  174. for ( S32 i = 0; i < steps; i++ )
  175. {
  176. F32 radians = (F32)i / (F32)(steps-1) * M_2PI_F;
  177. VectorF vec(0,1,0);
  178. MathUtils::vectorRotateZAxis( vec, radians );
  179. end.x = start.x = mLastBrushPoint.x + vec.x * mSize;
  180. end.y = start.y = mLastBrushPoint.y + vec.y * mSize;
  181. bool hit = gServerContainer.castRay( start, end, TerrainObjectType | StaticShapeObjectType, &ri );
  182. if ( hit )
  183. pointList.push_back( ri.point );
  184. }
  185. if ( mForest )
  186. mForest->enableCollision();
  187. if ( pointList.empty() )
  188. return;
  189. ColorI brushColor( ColorI::WHITE );
  190. if ( mMode == Paint )
  191. brushColor = ColorI::BLUE;
  192. else if ( mMode == Erase )
  193. brushColor = ColorI::RED;
  194. else if ( mMode == EraseSelected )
  195. brushColor.set( 150, 0, 0 );
  196. if ( mMode == Paint || mMode == EraseSelected )
  197. {
  198. if ( mElements.empty() )
  199. {
  200. brushColor.set( 140, 140, 140 );
  201. }
  202. }
  203. mEditor->drawLineList( pointList, brushColor, 1.5f );
  204. }
  205. void ForestBrushTool::onActivated( const Gui3DMouseEvent &lastEvent )
  206. {
  207. _updateBrushPoint( lastEvent );
  208. Con::executef( this, "onActivated" );
  209. }
  210. void ForestBrushTool::onDeactivated()
  211. {
  212. Con::executef( this, "onDeactivated" );
  213. }
  214. bool ForestBrushTool::updateGuiInfo()
  215. {
  216. GuiTextCtrl *statusbar;
  217. Sim::findObject( "EWorldEditorStatusBarInfo", statusbar );
  218. GuiTextCtrl *selectionBar;
  219. Sim::findObject( "EWorldEditorStatusBarSelection", selectionBar );
  220. String text;
  221. if ( mMode == Paint )
  222. text = "Forest Editor ( Paint Tool ) - This brush creates Items based on the Elements you have selected.";
  223. else if ( mMode == Erase )
  224. text = "Forest Editor ( Erase Tool ) - This brush erases Items of any Mesh type.";
  225. else if ( mMode == EraseSelected )
  226. text = "Forest Editor ( Erase Selected ) - This brush erases Items based on the Elements you have selected.";
  227. if ( statusbar )
  228. statusbar->setText( text );
  229. if ( mMode == Paint || mMode == EraseSelected )
  230. text = String::ToString( "%i elements selected", mElements.size() );
  231. else
  232. text = "";
  233. if ( selectionBar )
  234. selectionBar->setText( text );
  235. return true;
  236. }
  237. void ForestBrushTool::setSize( F32 val )
  238. {
  239. mSize = mClampF( val, 0.0f, 150.0f );
  240. Con::executef( this, "syncBrushToolbar" );
  241. }
  242. void ForestBrushTool::setPressure( F32 val )
  243. {
  244. mPressure = mClampF( val, 0.0f, 1.0f );
  245. Con::executef( this, "syncBrushToolbar" );
  246. }
  247. void ForestBrushTool::setHardness( F32 val )
  248. {
  249. mHardness = mClampF( val, 0.0f, 1.0f );
  250. Con::executef( this, "syncBrushToolbar" );
  251. }
  252. void ForestBrushTool::_onStroke()
  253. {
  254. if ( !mForest || !mBrushDown )
  255. return;
  256. _action( mLastBrushPoint );
  257. }
  258. void ForestBrushTool::_action( const Point3F &point )
  259. {
  260. if ( mMode == Paint )
  261. _paint( point );
  262. else if ( mMode == Erase || mMode == EraseSelected )
  263. _erase( point );
  264. }
  265. inline F32 mCircleArea( F32 radius )
  266. {
  267. return radius * radius * M_PI_F;
  268. }
  269. void ForestBrushTool::_paint( const Point3F &point )
  270. {
  271. AssertFatal( mForest, "ForestBrushTool::_paint() - Can't paint without a Forest!" );
  272. if ( mElements.empty() )
  273. return;
  274. // Iterators, pointers, and temporaries.
  275. ForestBrushElement *pElement;
  276. ForestItemData *pData;
  277. F32 radius, area;
  278. // How much area do we have to fill with trees ( within the brush ).
  279. F32 fillArea = mCircleArea( mSize );
  280. // Scale that down by pressure, this is how much area we want to fill.
  281. fillArea *= mPressure;
  282. // Create an MRandomSet we can get items we are painting out of with
  283. // the desired distribution.
  284. // Also grab the smallest and largest radius elements while we are looping.
  285. ForestBrushElement *smallestElement, *largestElement;
  286. smallestElement = largestElement = mElements[0];
  287. MRandomSet<ForestBrushElement*> randElementSet(&mRandom);
  288. for ( S32 i = 0; i < mElements.size(); i++ )
  289. {
  290. pElement = mElements[i];
  291. if ( pElement->mData->mRadius > largestElement->mData->mRadius )
  292. largestElement = pElement;
  293. if ( pElement->mData->mRadius < smallestElement->mData->mRadius )
  294. smallestElement = pElement;
  295. randElementSet.add( pElement, pElement->mProbability );
  296. }
  297. // Pull elements from the random set until we would theoretically fill
  298. // the desired area.
  299. F32 areaLeft = fillArea;
  300. F32 scaleFactor, sink, randRot, worldCoordZ, slope;
  301. Point2F worldCoords;
  302. Point3F normalVector, right;
  303. Point2F temp;
  304. const S32 MaxTries = 5;
  305. while ( areaLeft > 0.0f )
  306. {
  307. pElement = randElementSet.get();
  308. pData = pElement->mData;
  309. scaleFactor = mLerp( pElement->mScaleMin, pElement->mScaleMax, mClampF( mPow( mRandom.randF(), pElement->mScaleExponent ), 0.0f, 1.0f ) );
  310. radius = getMax( pData->mRadius * scaleFactor, 0.1f );
  311. area = mCircleArea( radius );
  312. areaLeft -= area * 5.0f; // fudge value
  313. // No room left we are done.
  314. //if ( areaLeft < 0.0f )
  315. // break;
  316. // We have area left to fill...
  317. const F32 rotRange = mDegToRad( pElement->mRotationRange );
  318. // Get a random sink value.
  319. sink = mRandom.randF( pElement->mSinkMin, pElement->mSinkMax ) * scaleFactor;
  320. // Get a random rotation.
  321. randRot = mRandom.randF( 0.0f, rotRange );
  322. // Look for a place within the brush area to place this item.
  323. // We may have to try several times or give and go onto the next.
  324. S32 i = 0;
  325. for ( ; i < MaxTries; i++ )
  326. {
  327. // Pick some randoms for placement.
  328. worldCoords = MathUtils::randomPointInCircle( mSize ) + point.asPoint2F();
  329. // Look for the ground at this position.
  330. if ( !getGroundAt( Point3F( worldCoords.x, worldCoords.y , point.z ),
  331. &worldCoordZ,
  332. &normalVector ) )
  333. {
  334. continue;
  335. }
  336. // Does this pass our slope and elevation limits.
  337. right.set( normalVector.x, normalVector.y, 0 );
  338. right.normalizeSafe();
  339. slope = mRadToDeg( mDot( right, normalVector ) );
  340. if ( worldCoordZ < pElement->mElevationMin ||
  341. worldCoordZ > pElement->mElevationMax ||
  342. slope < pElement->mSlopeMin ||
  343. slope > pElement->mSlopeMax )
  344. {
  345. continue;
  346. }
  347. // Are we up against another tree?
  348. if ( mForest->getData()->getItems( worldCoords, radius, NULL ) > 0 )
  349. continue;
  350. // If the trunk radius is set then we need to sink
  351. // the tree into the ground a bit to hide the bottom.
  352. if ( pElement->mSinkRadius > 0.0f )
  353. {
  354. // Items that are not aligned to the ground surface
  355. // get sunken down to hide the bottom of their trunks.
  356. // sunk down a bit to hide their bottoms on slopes.
  357. normalVector.z = 0;
  358. normalVector.normalizeSafe();
  359. normalVector *= sink;
  360. temp = worldCoords + normalVector.asPoint2F();
  361. getGroundAt( Point3F( temp.x, temp.y, point.z ),
  362. &worldCoordZ,
  363. NULL );
  364. }
  365. worldCoordZ -= sink;
  366. // Create a new undo action if this is a new stroke.
  367. ForestCreateUndoAction *action = dynamic_cast<ForestCreateUndoAction*>( mCurrAction );
  368. if ( !action )
  369. {
  370. action = new ForestCreateUndoAction( mForest->getData(), mEditor );
  371. mCurrAction = action;
  372. }
  373. //Con::printf( "worldCoords = %g, %g, %g", worldCoords.x, worldCoords.y, worldCoordZ );
  374. // Let the action manage adding it to the forest.
  375. action->addItem( pData,
  376. Point3F( worldCoords.x, worldCoords.y, worldCoordZ ),
  377. randRot,
  378. scaleFactor );
  379. break;
  380. }
  381. }
  382. }
  383. void ForestBrushTool::_erase( const Point3F &point )
  384. {
  385. AssertFatal( mForest, "ForestBrushTool::_erase() - Can't erase without a Forest!" );
  386. // First grab all the forest items around the point.
  387. ForestItemVector trees;
  388. if ( mForest->getData()->getItems( point.asPoint2F(), mSize, &trees ) == 0 )
  389. return;
  390. if ( mMode == EraseSelected )
  391. {
  392. for ( U32 i = 0; i < trees.size(); i++ )
  393. {
  394. const ForestItem &tree = trees[i];
  395. if ( !mDatablocks.contains( tree.getData() ) )
  396. {
  397. trees.erase_fast( i );
  398. i--;
  399. }
  400. }
  401. }
  402. if ( trees.empty() )
  403. return;
  404. // Number of trees to erase depending on pressure.
  405. S32 eraseCount = getMax( (S32)mCeil( (F32)trees.size() * mPressure ), 0 );
  406. // Initialize an MRandomDeck with trees under the brush.
  407. MRandomDeck<ForestItem> deck(&mRandom);
  408. deck.addToPile( trees );
  409. deck.shuffle();
  410. ForestItem currentTree;
  411. // Draw eraseCount number of trees from MRandomDeck, adding them to our erase action.
  412. for ( U32 i = 0; i < eraseCount; i++ )
  413. {
  414. deck.draw(&currentTree);
  415. // Create a new undo action if this is a new stroke.
  416. ForestDeleteUndoAction *action = dynamic_cast<ForestDeleteUndoAction*>( mCurrAction );
  417. if ( !action )
  418. {
  419. action = new ForestDeleteUndoAction( mForest->getData(), mEditor );
  420. mCurrAction = action;
  421. }
  422. action->removeItem( currentTree );
  423. }
  424. }
  425. bool ForestBrushTool::_updateBrushPoint( const Gui3DMouseEvent &event_ )
  426. {
  427. // Do a raycast for terrain... thats the placement center.
  428. const U32 mask = TerrainObjectType | StaticShapeObjectType; // TODO: Make an option!
  429. Point3F start( event_.pos );
  430. Point3F end( event_.pos + ( event_.vec * 10000.0f ) );
  431. if ( mForest )
  432. mForest->disableCollision();
  433. RayInfo rinfo;
  434. mDrawBrush = gServerContainer.castRay( start, end, mask, &rinfo );
  435. if ( mForest )
  436. mForest->enableCollision();
  437. if ( mDrawBrush )
  438. {
  439. mLastBrushPoint = rinfo.point;
  440. mLastBrushNormal = rinfo.normal;
  441. }
  442. return mDrawBrush;
  443. }
  444. bool findSelectedElements( ForestBrushElement *obj )
  445. {
  446. if ( obj->isSelectedRecursive() )
  447. return true;
  448. return false;
  449. }
  450. void ForestBrushTool::_collectElements()
  451. {
  452. mElements.clear();
  453. // Get the selected objects from the tree view.
  454. // These can be a combination of ForestBrush(s) and ForestBrushElement(s).
  455. GuiTreeViewCtrl *brushTree;
  456. if ( !Sim::findObject( "ForestEditBrushTree", brushTree ) )
  457. return;
  458. ConsoleValue cValue = Con::executef( brushTree, "getSelectedObjectList" );
  459. const char* objectIdList = cValue.getString();
  460. // Collect those objects in a vector and mark them as selected.
  461. Vector<SimObject*> objectList;
  462. SimObject *simobj;
  463. S32 wordCount = StringUnit::getUnitCount( objectIdList, " " );
  464. for ( S32 i = 0; i < wordCount; i++ )
  465. {
  466. const char* word = StringUnit::getUnit( objectIdList, i, " " );
  467. if ( Sim::findObject( word, simobj ) )
  468. {
  469. objectList.push_back( simobj );
  470. simobj->setSelected(true);
  471. }
  472. }
  473. // Find all ForestBrushElements that are directly or indirectly selected.
  474. SimSet* brushSet;
  475. if (!Sim::findObject("ForestBrushSet", brushSet))
  476. {
  477. Con::errorf("ForestBrushTool::_collectElements() - could not find ForestBrushSet!");
  478. return;
  479. }
  480. brushSet->findObjectByCallback( findSelectedElements, mElements );
  481. // We just needed to flag these objects as selected for the benefit of our
  482. // findSelectedElements callback, we can now mark them un-selected again.
  483. for ( S32 i = 0; i < objectList.size(); i++ )
  484. objectList[i]->setSelected(false);
  485. // If we are in Paint or EraseSelected mode we filter out elements with
  486. // a non-positive probability.
  487. if ( mMode == Paint || mMode == EraseSelected )
  488. {
  489. for ( S32 i = 0; i < mElements.size(); i++ )
  490. {
  491. if ( mElements[i]->mProbability <= 0.0f )
  492. {
  493. mElements.erase_fast(i);
  494. i--;
  495. }
  496. }
  497. }
  498. // Filter out elements with NULL datablocks and collect all unique datablocks
  499. // in a vector.
  500. mDatablocks.clear();
  501. for ( S32 i = 0; i < mElements.size(); i++ )
  502. {
  503. if ( mElements[i]->mData == NULL )
  504. {
  505. mElements.erase_fast(i);
  506. i--;
  507. continue;
  508. }
  509. mDatablocks.push_back_unique( mElements[i]->mData );
  510. }
  511. }
  512. bool ForestBrushTool::getGroundAt( const Point3F &worldPt, F32 *zValueOut, VectorF *normalOut )
  513. {
  514. const U32 mask = TerrainObjectType | StaticShapeObjectType;
  515. Point3F start( worldPt.x, worldPt.y, worldPt.z + mSize );
  516. Point3F end( worldPt.x, worldPt.y, worldPt.z - mSize );
  517. if ( mForest )
  518. mForest->disableCollision();
  519. // Do a cast ray at this point from the top to
  520. // the bottom of our brush radius.
  521. RayInfo rinfo;
  522. bool hit = gServerContainer.castRay( start, end, mask, &rinfo );
  523. if ( mForest )
  524. mForest->enableCollision();
  525. if ( !hit )
  526. return false;
  527. if (zValueOut)
  528. *zValueOut = rinfo.point.z;
  529. if (normalOut)
  530. *normalOut = rinfo.normal;
  531. return true;
  532. }
  533. DefineEngineMethod( ForestBrushTool, collectElements, void, (), , "" )
  534. {
  535. object->collectElements();
  536. }