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

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

游戏引擎

开发平台：

C++ Builder

llvograss.cpp：源码内容
  1. /** 
  2.  * @file llvograss.cpp
  3.  * @brief Not a blade, but a clump of grass
  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 "llvograss.h"
  37. #include "imageids.h"
  38. #include "llviewercontrol.h"
  40. #include "llagent.h"
  41. #include "llnotificationsutil.h"
  42. #include "lldrawable.h"
  43. #include "llface.h"
  44. #include "llsky.h"
  45. #include "llsurface.h"
  46. #include "llsurfacepatch.h"
  47. #include "llvosky.h"
  48. #include "llviewercamera.h"
  49. #include "llviewertexturelist.h"
  50. #include "llviewerregion.h"
  51. #include "pipeline.h"
  52. #include "llspatialpartition.h"
  53. #include "llworld.h"
  54. #include "lldir.h"
  55. #include "llxmltree.h"
  57. const S32 GRASS_MAX_BLADES = 32;
  58. const F32 GRASS_BLADE_BASE = 0.25f; //  Width of grass at base
  59. const F32 GRASS_BLADE_TOP = 0.25f; //  Width of grass at top
  60. const F32 GRASS_BLADE_HEIGHT = 0.5f; // meters
  61. const F32 GRASS_DISTRIBUTION_SD = 0.15f; // empirically defined
  63. F32 exp_x[GRASS_MAX_BLADES];
  64. F32 exp_y[GRASS_MAX_BLADES];
  65. F32 rot_x[GRASS_MAX_BLADES];
  66. F32 rot_y[GRASS_MAX_BLADES];
  67. F32 dz_x [GRASS_MAX_BLADES];
  68. F32 dz_y [GRASS_MAX_BLADES];
  70. F32 w_mod[GRASS_MAX_BLADES]; //  Factor to modulate wind movement by to randomize appearance
  72. LLVOGrass::SpeciesMap LLVOGrass::sSpeciesTable;
  73. S32 LLVOGrass::sMaxGrassSpecies = 0;
  76. LLVOGrass::LLVOGrass(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
  77. : LLAlphaObject(id, pcode, regionp)
  78. {
  79. mPatch               = NULL;
  80. mLastPatchUpdateTime = 0;
  81. mGrassVel.clearVec();
  82. mGrassBend.clearVec();
  83. mbCanSelect          = TRUE;
  85. mBladeWindAngle      = 35.f;
  86. mBWAOverlap          = 2.f;
  88. setNumTEs(1);
  90. setTEColor(0, LLColor4(1.0f, 1.0f, 1.0f, 1.f));
  91. mNumBlades = GRASS_MAX_BLADES;
  92. }
  94. LLVOGrass::~LLVOGrass()
  95. {
  96. }
  99. void LLVOGrass::updateSpecies()
  100. {
  101. mSpecies = mState;
  103. if (!sSpeciesTable.count(mSpecies))
  104. {
  105. llinfos << "Unknown grass type, substituting grass type." << llendl;
  106. SpeciesMap::const_iterator it = sSpeciesTable.begin();
  107. mSpecies = (*it).first;
  108. }
  109. setTEImage(0, LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE));
  110. }
  113. void LLVOGrass::initClass()
  114. {
  115. LLVector3 pos(0.0f, 0.0f, 0.0f);
  116. //  Create nifty list of exponential distribution 0-1
  117. F32 x = 0.f;
  118. F32 y = 0.f;
  119. F32 rot;
  121. std::string xml_filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"grass.xml");
  123. LLXmlTree grass_def_grass;
  125. if (!grass_def_grass.parseFile(xml_filename))
  126. {
  127. llerrs << "Failed to parse grass file." << llendl;
  128. return;
  129. }
  131. LLXmlTreeNode* rootp = grass_def_grass.getRoot();
  133. for (LLXmlTreeNode* grass_def = rootp->getFirstChild();
  134. grass_def;
  135. grass_def = rootp->getNextChild())
  136. {
  137. if (!grass_def->hasName("grass"))
  138. {
  139. llwarns << "Invalid grass definition node " << grass_def->getName() << llendl;
  140. continue;
  141. }
  142. F32 F32_val;
  143. LLUUID id;
  145. BOOL success = TRUE;
  147. S32 species;
  148. static LLStdStringHandle species_id_string = LLXmlTree::addAttributeString("species_id");
  149. if (!grass_def->getFastAttributeS32(species_id_string, species))
  150. {
  151. llwarns << "No species id defined" << llendl;
  152. continue;
  153. }
  155. if (species < 0)
  156. {
  157. llwarns << "Invalid species id " << species << llendl;
  158. continue;
  159. }
  161. GrassSpeciesData* newGrass = new GrassSpeciesData();
  164. static LLStdStringHandle texture_id_string = LLXmlTree::addAttributeString("texture_id");
  165. grass_def->getFastAttributeUUID(texture_id_string, id);
  166. newGrass->mTextureID = id;
  168. static LLStdStringHandle blade_sizex_string = LLXmlTree::addAttributeString("blade_size_x");
  169. success &= grass_def->getFastAttributeF32(blade_sizex_string, F32_val);
  170. newGrass->mBladeSizeX = F32_val;
  172. static LLStdStringHandle blade_sizey_string = LLXmlTree::addAttributeString("blade_size_y");
  173. success &= grass_def->getFastAttributeF32(blade_sizey_string, F32_val);
  174. newGrass->mBladeSizeY = F32_val;
  176. if (sSpeciesTable.count(species))
  177. {
  178. llinfos << "Grass species " << species << " already defined! Duplicate discarded." << llendl;
  179. delete newGrass;
  180. continue;
  181. }
  182. else
  183. {
  184. sSpeciesTable[species] = newGrass;
  185. }
  187. if (species >= sMaxGrassSpecies) sMaxGrassSpecies = species + 1;
  189. if (!success)
  190. {
  191. std::string name;
  192. static LLStdStringHandle name_string = LLXmlTree::addAttributeString("name");
  193. grass_def->getFastAttributeString(name_string, name);
  194. llwarns << "Incomplete definition of grass " << name << llendl;
  195. }
  196. }
  198. BOOL have_all_grass = TRUE;
  199. std::string err;
  201. for (S32 i=0;i<sMaxGrassSpecies;++i)
  202. {
  203. if (!sSpeciesTable.count(i))
  204. {
  205. err.append(llformat(" %d",i));
  206. have_all_grass = FALSE;
  207. }
  208. }
  210. if (!have_all_grass) 
  211. {
  212. LLSD args;
  213. args["SPECIES"] = err;
  214. LLNotificationsUtil::add("ErrorUndefinedGrasses", args);
  215. }
  217. for (S32 i = 0; i < GRASS_MAX_BLADES; ++i)
  218. {
  219. if (1)   //(i%2 == 0) Uncomment for X blading
  220. {
  221. F32 u = sqrt(-2.0f * log(ll_frand()));
  222. F32 v = 2.0f * F_PI * ll_frand();
  224. x = u * sin(v) * GRASS_DISTRIBUTION_SD;
  225. y = u * cos(v) * GRASS_DISTRIBUTION_SD;
  227. rot = ll_frand(F_PI);
  228. }
  229. else
  230. {
  231. rot += (F_PI*0.4f + ll_frand(0.2f*F_PI));
  232. }
  234. exp_x[i] = x;
  235. exp_y[i] = y;
  236. rot_x[i] = sin(rot);
  237. rot_y[i] = cos(rot);
  238. dz_x[i] = ll_frand(GRASS_BLADE_BASE * 0.25f);
  239. dz_y[i] = ll_frand(GRASS_BLADE_BASE * 0.25f);
  240. w_mod[i] = 0.5f + ll_frand(); //  Degree to which blade is moved by wind
  242. }
  243. }
  245. void LLVOGrass::cleanupClass()
  246. {
  247. for_each(sSpeciesTable.begin(), sSpeciesTable.end(), DeletePairedPointer());
  248. }
  250. U32 LLVOGrass::processUpdateMessage(LLMessageSystem *mesgsys,
  251.   void **user_data,
  252.   U32 block_num,
  253.   const EObjectUpdateType update_type,
  254.   LLDataPacker *dp)
  255. {
  256. // Do base class updates...
  257. U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
  259. updateSpecies();
  261. if (  (getVelocity().lengthSquared() > 0.f)
  262. ||(getAcceleration().lengthSquared() > 0.f)
  263. ||(getAngularVelocity().lengthSquared() > 0.f))
  264. {
  265. llinfos << "ACK! Moving grass!" << llendl;
  266. setVelocity(LLVector3::zero);
  267. setAcceleration(LLVector3::zero);
  268. setAngularVelocity(LLVector3::zero);
  269. }
  271. if (mDrawable)
  272. {
  273. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
  274. }
  276. return retval;
  277. }
  279. BOOL LLVOGrass::isActive() const
  280. {
  281. return TRUE;
  282. }
  284. BOOL LLVOGrass::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
  285. {
  286.   if (mDead || !(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_GRASS)))
  287. {
  288. return TRUE;
  289. }
  291. if (!mDrawable)
  292. {
  293. // So drones work.
  294. return TRUE;
  295. }
  297. if (mPatch && (mLastPatchUpdateTime != mPatch->getLastUpdateTime()))
  298. {
  299. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
  300. }
  302. return TRUE;
  303. }
  306. void LLVOGrass::setPixelAreaAndAngle(LLAgent &agent)
  307. {
  308. // This should be the camera's center, as soon as we move to all region-local.
  309. LLVector3 relative_position = getPositionAgent() - agent.getCameraPositionAgent();
  310. F32 range = relative_position.length();
  312. F32 max_scale = getMaxScale();
  314. mAppAngle = (F32) atan2( max_scale, range) * RAD_TO_DEG;
  316. // Compute pixels per meter at the given range
  317. F32 pixels_per_meter = LLViewerCamera::getInstance()->getViewHeightInPixels() / (tan(LLViewerCamera::getInstance()->getView()) * range);
  319. // Assume grass texture is a 5 meter by 5 meter sprite at the grass object's center
  320. mPixelArea = (pixels_per_meter) * (pixels_per_meter) * 25.f;
  321. }
  324. // BUG could speed this up by caching the relative_position and range calculations
  325. void LLVOGrass::updateTextures()
  326. {
  327. if (getTEImage(0))
  328. {
  329. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
  330. {
  331. setDebugText(llformat("%4.0f", fsqrtf(mPixelArea)));
  332. }
  333. getTEImage(0)->addTextureStats(mPixelArea);
  334. }
  335. }
  337. BOOL LLVOGrass::updateLOD()
  338. {
  339. if (mDrawable->getNumFaces() <= 0)
  340. {
  341. return FALSE;
  342. }
  344. LLFace* face = mDrawable->getFace(0);
  346. F32 tan_angle = 0.f;
  347. S32 num_blades = 0;
  349. tan_angle = (mScale.mV[0]*mScale.mV[1])/mDrawable->mDistanceWRTCamera;
  350. num_blades = llmin(GRASS_MAX_BLADES, lltrunc(tan_angle * 5));
  351. num_blades = llmax(1, num_blades);
  352. if (num_blades >= (mNumBlades << 1))
  353. {
  354. while (mNumBlades < num_blades)
  355. {
  356. mNumBlades <<= 1;
  357. }
  359. face->setSize(mNumBlades*8, mNumBlades*12);
  360. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  361. }
  362. else if (num_blades <= (mNumBlades >> 1))
  363. {
  364. while (mNumBlades > num_blades)
  365. {
  366. mNumBlades >>=1;
  367. }
  369. face->setSize(mNumBlades*8, mNumBlades*12);
  370. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  371. return TRUE;
  372. }
  374. return FALSE;
  375. }
  377. LLDrawable* LLVOGrass::createDrawable(LLPipeline *pipeline)
  378. {
  379. pipeline->allocDrawable(this);
  380. mDrawable->setRenderType(LLPipeline::RENDER_TYPE_GRASS);
  382. return mDrawable;
  383. }
  385. static LLFastTimer::DeclareTimer FTM_UPDATE_GRASS("Update Grass");
  387. BOOL LLVOGrass::updateGeometry(LLDrawable *drawable)
  388. {
  389. LLFastTimer ftm(FTM_UPDATE_GRASS);
  390. dirtySpatialGroup();
  391. plantBlades();
  392. return TRUE;
  393. }
  395. void LLVOGrass::plantBlades()
  396. {
  397. // It is possible that the species of a grass is not defined
  398. // This is bad, but not the end of the world.
  399. if (!sSpeciesTable.count(mSpecies))
  400. {
  401. llinfos << "Unknown grass species " << mSpecies << llendl;
  402. return;
  403. }
  405. if (mDrawable->getNumFaces() < 1)
  406. {
  407. mDrawable->setNumFaces(1, NULL, getTEImage(0));
  408. }
  410. LLFace *face = mDrawable->getFace(0);
  412. face->setTexture(getTEImage(0));
  413. face->setState(LLFace::GLOBAL);
  414. face->setSize(mNumBlades * 8, mNumBlades * 12);
  415. face->mVertexBuffer = NULL;
  416. face->setTEOffset(0);
  417. face->mCenterLocal = mPosition + mRegionp->getOriginAgent();
  419. mDepth = (face->mCenterLocal - LLViewerCamera::getInstance()->getOrigin())*LLViewerCamera::getInstance()->getAtAxis();
  420. mDrawable->setPosition(face->mCenterLocal);
  421. mDrawable->movePartition();
  422. LLPipeline::sCompiles++;
  423. }
  425. void LLVOGrass::getGeometry(S32 idx,
  426. LLStrider<LLVector3>& verticesp,
  427. LLStrider<LLVector3>& normalsp, 
  428. LLStrider<LLVector2>& texcoordsp,
  429. LLStrider<LLColor4U>& colorsp, 
  430. LLStrider<U16>& indicesp)
  431. {
  432. mPatch = mRegionp->getLand().resolvePatchRegion(getPositionRegion());
  433. if (mPatch)
  434. mLastPatchUpdateTime = mPatch->getLastUpdateTime();
  436. LLVector3 position;
  437. // Create random blades of grass with gaussian distribution
  438. F32 x,y,xf,yf,dzx,dzy;
  440. LLColor4U color(255,255,255,255);
  442. LLFace *face = mDrawable->getFace(idx);
  444. F32 width  = sSpeciesTable[mSpecies]->mBladeSizeX;
  445. F32 height = sSpeciesTable[mSpecies]->mBladeSizeY;
  447. U32 index_offset = face->getGeomIndex();
  449. for (S32 i = 0;  i < mNumBlades; i++)
  450. {
  451. x   = exp_x[i] * mScale.mV[VX];
  452. y   = exp_y[i] * mScale.mV[VY];
  453. xf  = rot_x[i] * GRASS_BLADE_BASE * width * w_mod[i];
  454. yf  = rot_y[i] * GRASS_BLADE_BASE * width * w_mod[i];
  455. dzx = dz_x [i];
  456. dzy = dz_y [i];
  458. LLVector3 v1,v2,v3;
  459. F32 blade_height= GRASS_BLADE_HEIGHT * height * w_mod[i];
  461. *texcoordsp++   = LLVector2(0, 0);
  462. *texcoordsp++   = LLVector2(0, 0);
  463. *texcoordsp++   = LLVector2(0, 0.98f);
  464. *texcoordsp++   = LLVector2(0, 0.98f);
  465. *texcoordsp++   = LLVector2(1, 0);
  466. *texcoordsp++   = LLVector2(1, 0);
  467. *texcoordsp++   = LLVector2(1, 0.98f);
  468. *texcoordsp++   = LLVector2(1, 0.98f);
  470. position.mV[0]  = mPosition.mV[VX] + x + xf;
  471. position.mV[1]  = mPosition.mV[VY] + y + yf;
  472. position.mV[2]  = mRegionp->getLand().resolveHeightRegion(position);
  473. *verticesp++    = v1 = position + mRegionp->getOriginAgent();
  474. *verticesp++    = v1;
  477. position.mV[0] += dzx;
  478. position.mV[1] += dzy;
  479. position.mV[2] += blade_height;
  480. *verticesp++    = v2 = position + mRegionp->getOriginAgent();
  481. *verticesp++    = v2;
  483. position.mV[0]  = mPosition.mV[VX] + x - xf;
  484. position.mV[1]  = mPosition.mV[VY] + y - xf;
  485. position.mV[2]  = mRegionp->getLand().resolveHeightRegion(position);
  486. *verticesp++    = v3 = position + mRegionp->getOriginAgent();
  487. *verticesp++    = v3;
  489. LLVector3 normal1 = (v1-v2) % (v2-v3);
  490. normal1.mV[VZ] = 0.75f;
  491. normal1.normalize();
  492. LLVector3 normal2 = -normal1;
  493. normal2.mV[VZ] = -normal2.mV[VZ];
  495. position.mV[0] += dzx;
  496. position.mV[1] += dzy;
  497. position.mV[2] += blade_height;
  498. *verticesp++    = v1 = position + mRegionp->getOriginAgent();
  499. *verticesp++    = v1;
  501. *(normalsp++)   = normal1;
  502. *(normalsp++)   = normal2;
  503. *(normalsp++)   = normal1;
  504. *(normalsp++)   = normal2;
  506. *(normalsp++)   = normal1;
  507. *(normalsp++)   = normal2;
  508. *(normalsp++)   = normal1;
  509. *(normalsp++)   = normal2;
  511. *(colorsp++)   = color;
  512. *(colorsp++)   = color;
  513. *(colorsp++)   = color;
  514. *(colorsp++)   = color;
  515. *(colorsp++)   = color;
  516. *(colorsp++)   = color;
  517. *(colorsp++)   = color;
  518. *(colorsp++)   = color;
  520. *indicesp++     = index_offset + 0;
  521. *indicesp++     = index_offset + 2;
  522. *indicesp++     = index_offset + 4;
  524. *indicesp++     = index_offset + 2;
  525. *indicesp++     = index_offset + 6;
  526. *indicesp++     = index_offset + 4;
  528. *indicesp++     = index_offset + 1;
  529. *indicesp++     = index_offset + 5;
  530. *indicesp++     = index_offset + 3;
  532. *indicesp++     = index_offset + 3;
  533. *indicesp++     = index_offset + 5;
  534. *indicesp++     = index_offset + 7;
  535. index_offset   += 8;
  536. }
  538. LLPipeline::sCompiles++;
  539. }
  541. U32 LLVOGrass::getPartitionType() const
  542. {
  543. return LLViewerRegion::PARTITION_GRASS;
  544. }
  546. LLGrassPartition::LLGrassPartition()
  547. {
  548. mDrawableType = LLPipeline::RENDER_TYPE_GRASS;
  549. mPartitionType = LLViewerRegion::PARTITION_GRASS;
  550. mLODPeriod = 16;
  551. mDepthMask = TRUE;
  552. mSlopRatio = 0.1f;
  553. mRenderPass = LLRenderPass::PASS_GRASS;
  554. mBufferUsage = GL_DYNAMIC_DRAW_ARB;
  555. }
  557. // virtual
  558. void LLVOGrass::updateDrawable(BOOL force_damped)
  559. {
  560. // Force an immediate rebuild on any update
  561. if (mDrawable.notNull())
  562. {
  563. mDrawable->updateXform(TRUE);
  564. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  565. }
  566. clearChanged(SHIFTED);
  567. }
  569. // virtual 
  570. BOOL LLVOGrass::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, S32 face, BOOL pick_transparent, S32 *face_hitp,
  571.   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
  573. {
  574. BOOL ret = FALSE;
  575. if (!mbCanSelect ||
  576. mDrawable->isDead() || 
  577. !gPipeline.hasRenderType(mDrawable->getRenderType()))
  578. {
  579. return FALSE;
  580. }
  582. LLVector3 dir = end-start;
  584. mPatch = mRegionp->getLand().resolvePatchRegion(getPositionRegion());
  586. LLVector3 position;
  587. // Create random blades of grass with gaussian distribution
  588. F32 x,y,xf,yf,dzx,dzy;
  590. LLColor4U color(255,255,255,255);
  592. F32 width  = sSpeciesTable[mSpecies]->mBladeSizeX;
  593. F32 height = sSpeciesTable[mSpecies]->mBladeSizeY;
  595. LLVector2 tc[4];
  596. LLVector3 v[4];
  597. // LLVector3 n[4]; // unused!
  599. F32 closest_t = 1.f;
  601. for (S32 i = 0;  i < mNumBlades; i++)
  602. {
  603. x   = exp_x[i] * mScale.mV[VX];
  604. y   = exp_y[i] * mScale.mV[VY];
  605. xf  = rot_x[i] * GRASS_BLADE_BASE * width * w_mod[i];
  606. yf  = rot_y[i] * GRASS_BLADE_BASE * width * w_mod[i];
  607. dzx = dz_x [i];
  608. dzy = dz_y [i];
  610. LLVector3 v1,v2,v3;
  611. F32 blade_height= GRASS_BLADE_HEIGHT * height * w_mod[i];
  613. tc[0]   = LLVector2(0, 0);
  614. tc[1]   = LLVector2(0, 0.98f);
  615. tc[2]   = LLVector2(1, 0);
  616. tc[3]   = LLVector2(1, 0.98f);
  618. position.mV[0]  = mPosition.mV[VX] + x + xf;
  619. position.mV[1]  = mPosition.mV[VY] + y + yf;
  620. position.mV[2]  = mRegionp->getLand().resolveHeightRegion(position);
  621. v[0]    = v1 = position + mRegionp->getOriginAgent();
  625. position.mV[0] += dzx;
  626. position.mV[1] += dzy;
  627. position.mV[2] += blade_height;
  628. v[1]    = v2 = position + mRegionp->getOriginAgent();
  630. position.mV[0]  = mPosition.mV[VX] + x - xf;
  631. position.mV[1]  = mPosition.mV[VY] + y - xf;
  632. position.mV[2]  = mRegionp->getLand().resolveHeightRegion(position);
  633. v[2]    = v3 = position + mRegionp->getOriginAgent();
  635. LLVector3 normal1 = (v1-v2) % (v2-v3);
  636. normal1.normalize();
  638. position.mV[0] += dzx;
  639. position.mV[1] += dzy;
  640. position.mV[2] += blade_height;
  641. v[3]    = v1 = position + mRegionp->getOriginAgent();
  644. F32 a,b,t;
  646. BOOL hit = FALSE;
  649. U32 idx0 = 0,idx1 = 0,idx2 = 0;
  651. if (LLTriangleRayIntersect(v[0], v[1], v[2], start, dir, &a, &b, &t, FALSE))
  652. {
  653. hit = TRUE;
  654. idx0 = 0; idx1 = 1; idx2 = 2;
  655. }
  656. else if (LLTriangleRayIntersect(v[1], v[3], v[2], start, dir, &a, &b, &t, FALSE))
  657. {
  658. hit = TRUE;
  659. idx0 = 1; idx1 = 3; idx2 = 2;
  660. }
  661. else if (LLTriangleRayIntersect(v[2], v[1], v[0], start, dir, &a, &b, &t, FALSE))
  662. {
  663. normal1 = -normal1;
  664. hit = TRUE;
  665. idx0 = 2; idx1 = 1; idx2 = 0;
  666. }
  667. else if (LLTriangleRayIntersect(v[2], v[3], v[1], start, dir, &a, &b, &t, FALSE))
  668. {
  669. normal1 = -normal1;
  670. hit = TRUE;
  671. idx0 = 2; idx1 = 3; idx2 = 1;
  672. }
  674. if (hit)
  675. {
  676. if (t >= 0.f &&
  677. t <= 1.f &&
  678. t < closest_t)
  679. {
  681. LLVector2 hit_tc = ((1.f - a - b)  * tc[idx0] +
  682.   a              * tc[idx1] +
  683.   b              * tc[idx2]);
  684. if (pick_transparent ||
  685. getTEImage(0)->getMask(hit_tc))
  686. {
  687. closest_t = t;
  688. if (intersection != NULL)
  689. {
  690. *intersection = start+dir*closest_t;
  691. }
  693. if (tex_coord != NULL)
  694. {
  695. *tex_coord = hit_tc;
  696. }
  698. if (normal != NULL)
  699. {
  700. *normal    = normal1;
  701. }
  702. ret = TRUE;
  703. }
  704. }
  705. }
  706. }
  708. return ret;
  709. }