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

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

游戏引擎

开发平台：

C++ Builder

llvotree.cpp：源码内容
  1. /** 
  2.  * @file llvotree.cpp
  3.  * @brief LLVOTree class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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 "llvotree.h"
  37. #include "lldrawpooltree.h"
  39. #include "llviewercontrol.h"
  40. #include "lldir.h"
  41. #include "llprimitive.h"
  42. #include "lltree_common.h"
  43. #include "llxmltree.h"
  44. #include "material_codes.h"
  45. #include "object_flags.h"
  47. #include "llagent.h"
  48. #include "lldrawable.h"
  49. #include "llface.h"
  50. #include "llviewercamera.h"
  51. #include "llviewertexturelist.h"
  52. #include "llviewerobjectlist.h"
  53. #include "llviewerregion.h"
  54. #include "llworld.h"
  55. #include "noise.h"
  56. #include "pipeline.h"
  57. #include "llspatialpartition.h"
  58. #include "llnotificationsutil.h"
  60. extern LLPipeline gPipeline;
  62. const S32 MAX_SLICES = 32;
  63. const F32 LEAF_LEFT = 0.52f;
  64. const F32 LEAF_RIGHT = 0.98f;
  65. const F32 LEAF_TOP = 1.0f;
  66. const F32 LEAF_BOTTOM = 0.52f;
  67. const F32 LEAF_WIDTH = 1.f;
  69. S32 LLVOTree::sLODVertexOffset[4];
  70. S32 LLVOTree::sLODVertexCount[4];
  71. S32 LLVOTree::sLODIndexOffset[4];
  72. S32 LLVOTree::sLODIndexCount[4];
  73. S32 LLVOTree::sLODSlices[4] = {10, 5, 4, 3};
  74. F32 LLVOTree::sLODAngles[4] = {30.f, 20.f, 15.f, 0.f};
  76. F32 LLVOTree::sTreeFactor = 1.f;
  78. LLVOTree::SpeciesMap LLVOTree::sSpeciesTable;
  79. S32 LLVOTree::sMaxTreeSpecies = 0;
  81. // Tree variables and functions
  83. LLVOTree::LLVOTree(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp):
  84. LLViewerObject(id, pcode, regionp)
  85. {
  86. mSpecies = 0;
  87. mFrameCount = 0;
  88. mWind = mRegionp->mWind.getVelocity(getPositionRegion());
  89. mTrunkLOD = 0;
  90. }
  93. LLVOTree::~LLVOTree()
  94. {
  95. if (mData)
  96. {
  97. delete[] mData;
  98. mData = NULL;
  99. }
  100. }
  102. // static
  103. void LLVOTree::initClass()
  104. {
  105. std::string xml_filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"trees.xml");
  107. LLXmlTree tree_def_tree;
  109. if (!tree_def_tree.parseFile(xml_filename))
  110. {
  111. llerrs << "Failed to parse tree file." << llendl;
  112. }
  114. LLXmlTreeNode* rootp = tree_def_tree.getRoot();
  116. for (LLXmlTreeNode* tree_def = rootp->getFirstChild();
  117. tree_def;
  118. tree_def = rootp->getNextChild())
  119. {
  120. if (!tree_def->hasName("tree"))
  121. {
  122. llwarns << "Invalid tree definition node " << tree_def->getName() << llendl;
  123. continue;
  124. }
  125. F32 F32_val;
  126. LLUUID id;
  127. S32 S32_val;
  129. BOOL success = TRUE;
  133. S32 species;
  134. static LLStdStringHandle species_id_string = LLXmlTree::addAttributeString("species_id");
  135. if (!tree_def->getFastAttributeS32(species_id_string, species))
  136. {
  137. llwarns << "No species id defined" << llendl;
  138. continue;
  139. }
  141. if (species < 0)
  142. {
  143. llwarns << "Invalid species id " << species << llendl;
  144. continue;
  145. }
  147. if (sSpeciesTable.count(species))
  148. {
  149. llwarns << "Tree species " << species << " already defined! Duplicate discarded." << llendl;
  150. continue;
  151. }
  153. TreeSpeciesData* newTree = new TreeSpeciesData();
  155. static LLStdStringHandle texture_id_string = LLXmlTree::addAttributeString("texture_id");
  156. success &= tree_def->getFastAttributeUUID(texture_id_string, id);
  157. newTree->mTextureID = id;
  159. static LLStdStringHandle droop_string = LLXmlTree::addAttributeString("droop");
  160. success &= tree_def->getFastAttributeF32(droop_string, F32_val);
  161. newTree->mDroop = F32_val;
  163. static LLStdStringHandle twist_string = LLXmlTree::addAttributeString("twist");
  164. success &= tree_def->getFastAttributeF32(twist_string, F32_val);
  165. newTree->mTwist = F32_val;
  167. static LLStdStringHandle branches_string = LLXmlTree::addAttributeString("branches");
  168. success &= tree_def->getFastAttributeF32(branches_string, F32_val);
  169. newTree->mBranches = F32_val;
  171. static LLStdStringHandle depth_string = LLXmlTree::addAttributeString("depth");
  172. success &= tree_def->getFastAttributeS32(depth_string, S32_val);
  173. newTree->mDepth = S32_val;
  175. static LLStdStringHandle scale_step_string = LLXmlTree::addAttributeString("scale_step");
  176. success &= tree_def->getFastAttributeF32(scale_step_string, F32_val);
  177. newTree->mScaleStep = F32_val;
  179. static LLStdStringHandle trunk_depth_string = LLXmlTree::addAttributeString("trunk_depth");
  180. success &= tree_def->getFastAttributeS32(trunk_depth_string, S32_val);
  181. newTree->mTrunkDepth = S32_val;
  183. static LLStdStringHandle branch_length_string = LLXmlTree::addAttributeString("branch_length");
  184. success &= tree_def->getFastAttributeF32(branch_length_string, F32_val);
  185. newTree->mBranchLength = F32_val;
  187. static LLStdStringHandle trunk_length_string = LLXmlTree::addAttributeString("trunk_length");
  188. success &= tree_def->getFastAttributeF32(trunk_length_string, F32_val);
  189. newTree->mTrunkLength = F32_val;
  191. static LLStdStringHandle leaf_scale_string = LLXmlTree::addAttributeString("leaf_scale");
  192. success &= tree_def->getFastAttributeF32(leaf_scale_string, F32_val);
  193. newTree->mLeafScale = F32_val;
  195. static LLStdStringHandle billboard_scale_string = LLXmlTree::addAttributeString("billboard_scale");
  196. success &= tree_def->getFastAttributeF32(billboard_scale_string, F32_val);
  197. newTree->mBillboardScale = F32_val;
  199. static LLStdStringHandle billboard_ratio_string = LLXmlTree::addAttributeString("billboard_ratio");
  200. success &= tree_def->getFastAttributeF32(billboard_ratio_string, F32_val);
  201. newTree->mBillboardRatio = F32_val;
  203. static LLStdStringHandle trunk_aspect_string = LLXmlTree::addAttributeString("trunk_aspect");
  204. success &= tree_def->getFastAttributeF32(trunk_aspect_string, F32_val);
  205. newTree->mTrunkAspect = F32_val;
  207. static LLStdStringHandle branch_aspect_string = LLXmlTree::addAttributeString("branch_aspect");
  208. success &= tree_def->getFastAttributeF32(branch_aspect_string, F32_val);
  209. newTree->mBranchAspect = F32_val;
  211. static LLStdStringHandle leaf_rotate_string = LLXmlTree::addAttributeString("leaf_rotate");
  212. success &= tree_def->getFastAttributeF32(leaf_rotate_string, F32_val);
  213. newTree->mRandomLeafRotate = F32_val;
  215. static LLStdStringHandle noise_mag_string = LLXmlTree::addAttributeString("noise_mag");
  216. success &= tree_def->getFastAttributeF32(noise_mag_string, F32_val);
  217. newTree->mNoiseMag = F32_val;
  219. static LLStdStringHandle noise_scale_string = LLXmlTree::addAttributeString("noise_scale");
  220. success &= tree_def->getFastAttributeF32(noise_scale_string, F32_val);
  221. newTree->mNoiseScale = F32_val;
  223. static LLStdStringHandle taper_string = LLXmlTree::addAttributeString("taper");
  224. success &= tree_def->getFastAttributeF32(taper_string, F32_val);
  225. newTree->mTaper = F32_val;
  227. static LLStdStringHandle repeat_z_string = LLXmlTree::addAttributeString("repeat_z");
  228. success &= tree_def->getFastAttributeF32(repeat_z_string, F32_val);
  229. newTree->mRepeatTrunkZ = F32_val;
  231. sSpeciesTable[species] = newTree;
  233. if (species >= sMaxTreeSpecies) sMaxTreeSpecies = species + 1;
  235. if (!success)
  236. {
  237. std::string name;
  238. static LLStdStringHandle name_string = LLXmlTree::addAttributeString("name");
  239. tree_def->getFastAttributeString(name_string, name);
  240. llwarns << "Incomplete definition of tree " << name << llendl;
  241. }
  242. }
  244. BOOL have_all_trees = TRUE;
  245. std::string err;
  247. for (S32 i=0;i<sMaxTreeSpecies;++i)
  248. {
  249. if (!sSpeciesTable.count(i))
  250. {
  251. err.append(llformat(" %d",i));
  252. have_all_trees = FALSE;
  253. }
  254. }
  256. if (!have_all_trees) 
  257. {
  258. LLSD args;
  259. args["SPECIES"] = err;
  260. LLNotificationsUtil::add("ErrorUndefinedTrees", args);
  261. }
  262. };
  264. //static
  265. void LLVOTree::cleanupClass()
  266. {
  267. std::for_each(sSpeciesTable.begin(), sSpeciesTable.end(), DeletePairedPointer());
  268. }
  270. U32 LLVOTree::processUpdateMessage(LLMessageSystem *mesgsys,
  271.   void **user_data,
  272.   U32 block_num, EObjectUpdateType update_type,
  273.   LLDataPacker *dp)
  274. {
  275. // Do base class updates...
  276. U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
  278. if (  (getVelocity().lengthSquared() > 0.f)
  279. ||(getAcceleration().lengthSquared() > 0.f)
  280. ||(getAngularVelocity().lengthSquared() > 0.f))
  281. {
  282. llinfos << "ACK! Moving tree!" << llendl;
  283. setVelocity(LLVector3::zero);
  284. setAcceleration(LLVector3::zero);
  285. setAngularVelocity(LLVector3::zero);
  286. }
  288. if (update_type == OUT_TERSE_IMPROVED)
  289. {
  290. // Nothing else needs to be done for the terse message.
  291. return retval;
  292. }
  294. // 
  295. //  Load Instance-Specific data 
  296. //
  297. if (mData)
  298. {
  299. mSpecies = ((U8 *)mData)[0];
  300. }
  302. if (!sSpeciesTable.count(mSpecies))
  303. {
  304. if (sSpeciesTable.size())
  305. {
  306. SpeciesMap::const_iterator it = sSpeciesTable.begin();
  307. mSpecies = (*it).first;
  308. }
  309. }
  311. //
  312. //  Load Species-Specific data 
  313. //
  314. mTreeImagep = LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
  315. mBranchLength = sSpeciesTable[mSpecies]->mBranchLength;
  316. mTrunkLength = sSpeciesTable[mSpecies]->mTrunkLength;
  317. mLeafScale = sSpeciesTable[mSpecies]->mLeafScale;
  318. mDroop = sSpeciesTable[mSpecies]->mDroop;
  319. mTwist = sSpeciesTable[mSpecies]->mTwist;
  320. mBranches = sSpeciesTable[mSpecies]->mBranches;
  321. mDepth = sSpeciesTable[mSpecies]->mDepth;
  322. mScaleStep = sSpeciesTable[mSpecies]->mScaleStep;
  323. mTrunkDepth = sSpeciesTable[mSpecies]->mTrunkDepth;
  324. mBillboardScale = sSpeciesTable[mSpecies]->mBillboardScale;
  325. mBillboardRatio = sSpeciesTable[mSpecies]->mBillboardRatio;
  326. mTrunkAspect = sSpeciesTable[mSpecies]->mTrunkAspect;
  327. mBranchAspect = sSpeciesTable[mSpecies]->mBranchAspect;
  329. // position change not caused by us, etc.  make sure to rebuild.
  330. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL);
  332. return retval;
  333. }
  335. BOOL LLVOTree::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
  336. {
  337. const U16 FRAMES_PER_WIND_UPDATE = 20; //  How many frames between wind update per tree
  338. const F32 TREE_WIND_SENSITIVITY = 0.005f;
  339. const F32 TREE_TRUNK_STIFFNESS = 0.1f;
  341.   if (mDead || !(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_TREE)))
  342. {
  343. return TRUE;
  344. }
  346. if (gSavedSettings.getBOOL("RenderAnimateTrees"))
  347. {
  348. F32 mass_inv; 
  350. //  For all tree objects, update the trunk bending with the current wind 
  351. //  Walk sprite list in order away from viewer 
  352. if (!(mFrameCount % FRAMES_PER_WIND_UPDATE)) 
  353. {
  354. //  If needed, Get latest wind for this tree
  355. mWind = mRegionp->mWind.getVelocity(getPositionRegion());
  356. }
  357. mFrameCount++;
  359. mass_inv = 1.f/(5.f + mDepth*mBranches*0.2f);
  360. mTrunkVel += (mWind * mass_inv * TREE_WIND_SENSITIVITY); //  Pull in direction of wind
  361. mTrunkVel -= (mTrunkBend * mass_inv * TREE_TRUNK_STIFFNESS); //  Restoring force in direction of trunk 
  362. mTrunkBend += mTrunkVel;
  363. mTrunkVel *= 0.99f; //  Add damping
  365. if (mTrunkBend.length() > 1.f)
  366. {
  367. mTrunkBend.normalize();
  368. }
  370. if (mTrunkVel.length() > 1.f)
  371. {
  372. mTrunkVel.normalize();
  373. }
  374. }
  376. S32 trunk_LOD = 0;
  377. F32 app_angle = getAppAngle()*LLVOTree::sTreeFactor;
  379. for (S32 j = 0; j < 4; j++)
  380. {
  382. if (app_angle > LLVOTree::sLODAngles[j])
  383. {
  384. trunk_LOD = j;
  385. break;
  386. }
  387. } 
  389. if (!gSavedSettings.getBOOL("RenderAnimateTrees"))
  390. {
  391. if (mReferenceBuffer.isNull())
  392. {
  393. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  394. }
  395. else if (trunk_LOD != mTrunkLOD)
  396. {
  397. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, FALSE);
  398. }
  399. else
  400. {
  401. // we're not animating but we may *still* need to
  402. // regenerate the mesh if we moved, since position
  403. // and rotation are baked into the mesh.
  404. // *TODO: I don't know what's so special about trees
  405. // that they don't get REBUILD_POSITION automatically
  406. // at a higher level.
  407. const LLVector3 &this_position = getPositionAgent();
  408. if (this_position != mLastPosition)
  409. {
  410. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_POSITION);
  411. mLastPosition = this_position;
  412. }
  413. else
  414. {
  415. const LLQuaternion &this_rotation = getRotation();
  417. if (this_rotation != mLastRotation)
  418. {
  419. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_POSITION);
  420. mLastRotation = this_rotation;
  421. }
  422. }
  423. }
  424. }
  426. mTrunkLOD = trunk_LOD;
  428. return TRUE;
  429. }
  431. const F32 TREE_BLEND_MIN = 1.f;
  432. const F32 TREE_BLEND_RANGE = 1.f;
  434. void LLVOTree::render(LLAgent &agent)
  435. {
  436. }
  439. void LLVOTree::setPixelAreaAndAngle(LLAgent &agent)
  440. {
  441. // First calculate values as for any other object (for mAppAngle)
  442. LLViewerObject::setPixelAreaAndAngle(agent);
  444. // Re-calculate mPixelArea accurately
  446. // This should be the camera's center, as soon as we move to all region-local.
  447. LLVector3 relative_position = getPositionAgent() - agent.getCameraPositionAgent();
  448. F32 range = relative_position.length(); // ugh, square root
  450. F32 max_scale = mBillboardScale * getMaxScale();
  451. F32 area = max_scale * (max_scale*mBillboardRatio);
  453. // Compute pixels per meter at the given range
  454. F32 pixels_per_meter = LLViewerCamera::getInstance()->getViewHeightInPixels() / 
  455.    (tan(LLViewerCamera::getInstance()->getView()) * range);
  457. mPixelArea = (pixels_per_meter) * (pixels_per_meter) * area;
  458. #if 0
  459. // mAppAngle is a bit of voodoo;
  460. // use the one calculated LLViewerObject::setPixelAreaAndAngle above
  461. // to avoid LOD miscalculations
  462. mAppAngle = (F32) atan2( max_scale, range) * RAD_TO_DEG;
  463. #endif
  464. }
  466. void LLVOTree::updateTextures()
  467. {
  468. if (mTreeImagep)
  469. {
  470. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
  471. {
  472. setDebugText(llformat("%4.0f", fsqrtf(mPixelArea)));
  473. }
  474. mTreeImagep->addTextureStats(mPixelArea);
  475. }
  477. }
  480. LLDrawable* LLVOTree::createDrawable(LLPipeline *pipeline)
  481. {
  482. pipeline->allocDrawable(this);
  483. mDrawable->setLit(FALSE);
  485. mDrawable->setRenderType(LLPipeline::RENDER_TYPE_TREE);
  487. LLDrawPoolTree *poolp = (LLDrawPoolTree*) gPipeline.getPool(LLDrawPool::POOL_TREE, mTreeImagep);
  489. // Just a placeholder for an actual object...
  490. LLFace *facep = mDrawable->addFace(poolp, mTreeImagep);
  491. facep->setSize(1, 3);
  493. updateRadius();
  495. return mDrawable;
  496. }
  499. // Yes, I know this is bad.  I'll clean this up soon. - djs 04/02/02
  500. const S32 LEAF_INDICES = 24;
  501. const S32 LEAF_VERTICES = 16;
  503. static LLFastTimer::DeclareTimer FTM_UPDATE_TREE("Update Tree");
  505. BOOL LLVOTree::updateGeometry(LLDrawable *drawable)
  506. {
  507. LLFastTimer ftm(FTM_UPDATE_TREE);
  509. if (mReferenceBuffer.isNull() || mDrawable->getFace(0)->mVertexBuffer.isNull())
  510. {
  511. const F32 SRR3 = 0.577350269f; // sqrt(1/3)
  512. const F32 SRR2 = 0.707106781f; // sqrt(1/2)
  513. U32 i, j;
  515. U32 slices = MAX_SLICES;
  517. S32 max_indices = LEAF_INDICES;
  518. S32 max_vertices = LEAF_VERTICES;
  519. S32 lod;
  521. LLFace *face = drawable->getFace(0);
  523. face->mCenterAgent = getPositionAgent();
  524. face->mCenterLocal = face->mCenterAgent;
  526. for (lod = 0; lod < 4; lod++)
  527. {
  528. slices = sLODSlices[lod];
  529. sLODVertexOffset[lod] = max_vertices;
  530. sLODVertexCount[lod] = slices*slices;
  531. sLODIndexOffset[lod] = max_indices;
  532. sLODIndexCount[lod] = (slices-1)*(slices-1)*6;
  533. max_indices += sLODIndexCount[lod];
  534. max_vertices += sLODVertexCount[lod];
  535. }
  537. mReferenceBuffer = new LLVertexBuffer(LLDrawPoolTree::VERTEX_DATA_MASK, gSavedSettings.getBOOL("RenderAnimateTrees") ? GL_STATIC_DRAW_ARB : 0);
  538. mReferenceBuffer->allocateBuffer(max_vertices, max_indices, TRUE);
  540. LLStrider<LLVector3> vertices;
  541. LLStrider<LLVector3> normals;
  542. LLStrider<LLVector2> tex_coords;
  543. LLStrider<U16> indicesp;
  545. mReferenceBuffer->getVertexStrider(vertices);
  546. mReferenceBuffer->getNormalStrider(normals);
  547. mReferenceBuffer->getTexCoord0Strider(tex_coords);
  548. mReferenceBuffer->getIndexStrider(indicesp);
  550. S32 vertex_count = 0;
  551. S32 index_count = 0;
  553. // First leaf
  554. *(normals++) = LLVector3(-SRR2, -SRR2, 0.f);
  555. *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
  556. *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 0.f);
  557. vertex_count++;
  559. *(normals++) = LLVector3(SRR3, -SRR3, SRR3);
  560. *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
  561. *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 1.f);
  562. vertex_count++;
  564. *(normals++) = LLVector3(-SRR3, -SRR3, SRR3);
  565. *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
  566. *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 1.f);
  567. vertex_count++;
  569. *(normals++) = LLVector3(SRR2, -SRR2, 0.f);
  570. *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
  571. *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 0.f);
  572. vertex_count++;
  575. *(indicesp++) = 0;
  576. index_count++;
  577. *(indicesp++) = 1;
  578. index_count++;
  579. *(indicesp++) = 2;
  580. index_count++;
  582. *(indicesp++) = 0;
  583. index_count++;
  584. *(indicesp++) = 3;
  585. index_count++;
  586. *(indicesp++) = 1;
  587. index_count++;
  589. // Same leaf, inverse winding/normals
  590. *(normals++) = LLVector3(-SRR2, SRR2, 0.f);
  591. *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
  592. *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 0.f);
  593. vertex_count++;
  595. *(normals++) = LLVector3(SRR3, SRR3, SRR3);
  596. *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
  597. *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 1.f);
  598. vertex_count++;
  600. *(normals++) = LLVector3(-SRR3, SRR3, SRR3);
  601. *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
  602. *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 1.f);
  603. vertex_count++;
  605. *(normals++) = LLVector3(SRR2, SRR2, 0.f);
  606. *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
  607. *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 0.f);
  608. vertex_count++;
  610. *(indicesp++) = 4;
  611. index_count++;
  612. *(indicesp++) = 6;
  613. index_count++;
  614. *(indicesp++) = 5;
  615. index_count++;
  617. *(indicesp++) = 4;
  618. index_count++;
  619. *(indicesp++) = 5;
  620. index_count++;
  621. *(indicesp++) = 7;
  622. index_count++;
  625. // next leaf
  626. *(normals++) = LLVector3(SRR2, -SRR2, 0.f);
  627. *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
  628. *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 0.f);
  629. vertex_count++;
  631. *(normals++) = LLVector3(SRR3, SRR3, SRR3);
  632. *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
  633. *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 1.f);
  634. vertex_count++;
  636. *(normals++) = LLVector3(SRR3, -SRR3, SRR3);
  637. *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
  638. *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 1.f);
  639. vertex_count++;
  641. *(normals++) = LLVector3(SRR2, SRR2, 0.f);
  642. *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
  643. *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 0.f);
  644. vertex_count++;
  646. *(indicesp++) = 8;
  647. index_count++;
  648. *(indicesp++) = 9;
  649. index_count++;
  650. *(indicesp++) = 10;
  651. index_count++;
  653. *(indicesp++) = 8;
  654. index_count++;
  655. *(indicesp++) = 11;
  656. index_count++;
  657. *(indicesp++) = 9;
  658. index_count++;
  661. // other side of same leaf
  662. *(normals++) = LLVector3(-SRR2, -SRR2, 0.f);
  663. *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
  664. *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 0.f);
  665. vertex_count++;
  667. *(normals++) = LLVector3(-SRR3, SRR3, SRR3);
  668. *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
  669. *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 1.f);
  670. vertex_count++;
  672. *(normals++) = LLVector3(-SRR3, -SRR3, SRR3);
  673. *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
  674. *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 1.f);
  675. vertex_count++;
  677. *(normals++) = LLVector3(-SRR2, SRR2, 0.f);
  678. *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
  679. *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 0.f);
  680. vertex_count++;
  682. *(indicesp++) = 12;
  683. index_count++;
  684. *(indicesp++) = 14;
  685. index_count++;
  686. *(indicesp++) = 13;
  687. index_count++;
  689. *(indicesp++) = 12;
  690. index_count++;
  691. *(indicesp++) = 13;
  692. index_count++;
  693. *(indicesp++) = 15;
  694. index_count++;
  696. // Generate geometry for the cylinders
  698. // Different LOD's
  700. // Generate the vertices
  701. // Generate the indices
  703. for (lod = 0; lod < 4; lod++)
  704. {
  705. slices = sLODSlices[lod];
  706. F32 base_radius = 0.65f;
  707. F32 top_radius = base_radius * sSpeciesTable[mSpecies]->mTaper;
  708. //llinfos << "Species " << ((U32) mSpecies) << ", taper = " << sSpeciesTable[mSpecies].mTaper << llendl;
  709. //llinfos << "Droop " << mDroop << ", branchlength: " << mBranchLength << llendl;
  710. F32 angle = 0;
  711. F32 angle_inc = 360.f/(slices-1);
  712. F32 z = 0.f;
  713. F32 z_inc = 1.f;
  714. if (slices > 3)
  715. {
  716. z_inc = 1.f/(slices - 3);
  717. }
  718. F32 radius = base_radius;
  720. F32 x1,y1;
  721. F32 noise_scale = sSpeciesTable[mSpecies]->mNoiseMag;
  722. LLVector3 nvec;
  724. const F32 cap_nudge = 0.1f; // Height to 'peak' the caps on top/bottom of branch
  726. const S32 fractal_depth = 5;
  727. F32 nvec_scale = 1.f * sSpeciesTable[mSpecies]->mNoiseScale;
  728. F32 nvec_scalez = 4.f * sSpeciesTable[mSpecies]->mNoiseScale;
  730. F32 tex_z_repeat = sSpeciesTable[mSpecies]->mRepeatTrunkZ;
  732. F32 start_radius;
  733. F32 nangle = 0;
  734. F32 height = 1.f;
  735. F32 r0;
  737. for (i = 0; i < slices; i++)
  738. {
  739. if (i == 0) 
  740. {
  741. z = - cap_nudge;
  742. r0 = 0.0;
  743. }
  744. else if (i == (slices - 1))
  745. {
  746. z = 1.f + cap_nudge;//((i - 2) * z_inc) + cap_nudge;
  747. r0 = 0.0;
  748. }
  749. else  
  750. {
  751. z = (i - 1) * z_inc;
  752. r0 = base_radius + (top_radius - base_radius)*z;
  753. }
  755. for (j = 0; j < slices; j++)
  756. {
  757. if (slices - 1 == j)
  758. {
  759. angle = 0.f;
  760. }
  761. else
  762. {
  763. angle =  j*angle_inc;
  764. }
  766. nangle = angle;
  768. x1 = cos(angle * DEG_TO_RAD);
  769. y1 = sin(angle * DEG_TO_RAD);
  770. LLVector2 tc;
  771. // This isn't totally accurate.  Should compute based on slope as well.
  772. start_radius = r0 * (1.f + 1.2f*fabs(z - 0.66f*height)/height);
  773. nvec.set( cos(nangle * DEG_TO_RAD)*start_radius*nvec_scale, 
  774. sin(nangle * DEG_TO_RAD)*start_radius*nvec_scale, 
  775. z*nvec_scalez); 
  776. // First and last slice at 0 radius (to bring in top/bottom of structure)
  777. radius = start_radius + turbulence3((F32*)&nvec.mV, (F32)fractal_depth)*noise_scale;
  779. if (slices - 1 == j)
  780. {
  781. // Not 0.5 for slight slop factor to avoid edges on leaves
  782. tc = LLVector2(0.490f, (1.f - z/2.f)*tex_z_repeat);
  783. }
  784. else
  785. {
  786. tc = LLVector2((angle/360.f)*0.5f, (1.f - z/2.f)*tex_z_repeat);
  787. }
  789. *(vertices++) = LLVector3(x1*radius, y1*radius, z);
  790. *(normals++) = LLVector3(x1, y1, 0.f);
  791. *(tex_coords++) = tc;
  792. vertex_count++;
  793. }
  794. }
  796. for (i = 0; i < (slices - 1); i++)
  797. {
  798. for (j = 0; j < (slices - 1); j++)
  799. {
  800. S32 x1_offset = j+1;
  801. if ((j+1) == slices)
  802. {
  803. x1_offset = 0;
  804. }
  805. // Generate the matching quads
  806. *(indicesp) = j + (i*slices) + sLODVertexOffset[lod];
  807. llassert(*(indicesp) < (U32)max_vertices);
  808. indicesp++;
  809. index_count++;
  810. *(indicesp) = x1_offset + ((i+1)*slices) + sLODVertexOffset[lod];
  811. llassert(*(indicesp) < (U32)max_vertices);
  812. indicesp++;
  813. index_count++;
  814. *(indicesp) = j + ((i+1)*slices) + sLODVertexOffset[lod];
  815. llassert(*(indicesp) < (U32)max_vertices);
  816. indicesp++;
  817. index_count++;
  819. *(indicesp) = j + (i*slices) + sLODVertexOffset[lod];
  820. llassert(*(indicesp) < (U32)max_vertices);
  821. indicesp++;
  822. index_count++;
  823. *(indicesp) = x1_offset + (i*slices) + sLODVertexOffset[lod];
  824. llassert(*(indicesp) < (U32)max_vertices);
  825. indicesp++;
  826. index_count++;
  827. *(indicesp) = x1_offset + ((i+1)*slices) + sLODVertexOffset[lod];
  828. llassert(*(indicesp) < (U32)max_vertices);
  829. indicesp++;
  830. index_count++;
  831. }
  832. }
  833. slices /= 2; 
  834. }
  836. mReferenceBuffer->setBuffer(0);
  837. llassert(vertex_count == max_vertices);
  838. llassert(index_count == max_indices);
  839. }
  841. if (gSavedSettings.getBOOL("RenderAnimateTrees"))
  842. {
  843. mDrawable->getFace(0)->mVertexBuffer = mReferenceBuffer;
  844. }
  845. else
  846. {
  847. //generate tree mesh
  848. updateMesh();
  849. }
  851. return TRUE;
  852. }
  854. void LLVOTree::updateMesh()
  855. {
  856. LLMatrix4 matrix;
  858. // Translate to tree base  HACK - adjustment in Z plants tree underground
  859. const LLVector3 &pos_agent = getPositionAgent();
  860. //glTranslatef(pos_agent.mV[VX], pos_agent.mV[VY], pos_agent.mV[VZ] - 0.1f);
  861. LLMatrix4 trans_mat;
  862. trans_mat.setTranslation(pos_agent.mV[VX], pos_agent.mV[VY], pos_agent.mV[VZ] - 0.1f);
  863. trans_mat *= matrix;
  865. // Rotate to tree position and bend for current trunk/wind
  866. // Note that trunk stiffness controls the amount of bend at the trunk as 
  867. // opposed to the crown of the tree
  868. // 
  869. const F32 TRUNK_STIFF = 22.f;
  871. LLQuaternion rot = 
  872. LLQuaternion(mTrunkBend.magVec()*TRUNK_STIFF*DEG_TO_RAD, LLVector4(mTrunkBend.mV[VX], mTrunkBend.mV[VY], 0)) *
  873. LLQuaternion(90.f*DEG_TO_RAD, LLVector4(0,0,1)) *
  874. getRotation();
  876. LLMatrix4 rot_mat(rot);
  877. rot_mat *= trans_mat;
  879. F32 radius = getScale().magVec()*0.05f;
  880. LLMatrix4 scale_mat;
  881. scale_mat.mMatrix[0][0] = 
  882. scale_mat.mMatrix[1][1] =
  883. scale_mat.mMatrix[2][2] = radius;
  885. scale_mat *= rot_mat;
  887. // const F32 THRESH_ANGLE_FOR_BILLBOARD = 15.f;
  888. // const F32 BLEND_RANGE_FOR_BILLBOARD = 3.f;
  890. F32 droop = mDroop + 25.f*(1.f - mTrunkBend.magVec());
  892. S32 stop_depth = 0;
  893. F32 alpha = 1.0;
  896. U32 vert_count = 0;
  897. U32 index_count = 0;
  899. calcNumVerts(vert_count, index_count, mTrunkLOD, stop_depth, mDepth, mTrunkDepth, mBranches);
  901. LLFace* facep = mDrawable->getFace(0);
  902. facep->mVertexBuffer = new LLVertexBuffer(LLDrawPoolTree::VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
  903. facep->mVertexBuffer->allocateBuffer(vert_count, index_count, TRUE);
  905. LLStrider<LLVector3> vertices;
  906. LLStrider<LLVector3> normals;
  907. LLStrider<LLVector2> tex_coords;
  908. LLStrider<U16> indices;
  909. U16 idx_offset = 0;
  911. facep->mVertexBuffer->getVertexStrider(vertices);
  912. facep->mVertexBuffer->getNormalStrider(normals);
  913. facep->mVertexBuffer->getTexCoord0Strider(tex_coords);
  914. facep->mVertexBuffer->getIndexStrider(indices);
  916. genBranchPipeline(vertices, normals, tex_coords, indices, idx_offset, scale_mat, mTrunkLOD, stop_depth, mDepth, mTrunkDepth, 1.0, mTwist, droop, mBranches, alpha);
  918. mReferenceBuffer->setBuffer(0);
  919. facep->mVertexBuffer->setBuffer(0);
  921. }
  923. void LLVOTree::appendMesh(LLStrider<LLVector3>& vertices, 
  924.  LLStrider<LLVector3>& normals, 
  925.  LLStrider<LLVector2>& tex_coords, 
  926.  LLStrider<U16>& indices,
  927.  U16& cur_idx,
  928.  LLMatrix4& matrix,
  929.  LLMatrix4& norm_mat,
  930.  S32 vert_start,
  931.  S32 vert_count,
  932.  S32 index_count,
  933.  S32 index_offset)
  934. {
  935. LLStrider<LLVector3> v;
  936. LLStrider<LLVector3> n;
  937. LLStrider<LLVector2> t;
  938. LLStrider<U16> idx;
  940. mReferenceBuffer->getVertexStrider(v);
  941. mReferenceBuffer->getNormalStrider(n);
  942. mReferenceBuffer->getTexCoord0Strider(t);
  943. mReferenceBuffer->getIndexStrider(idx);
  945. //copy/transform vertices into mesh - check
  946. for (S32 i = 0; i < vert_count; i++)
  947. { 
  948. U16 index = vert_start + i;
  949. *vertices++ = v[index] * matrix;
  950. LLVector3 norm = n[index] * norm_mat;
  951. norm.normalize();
  952. *normals++ = norm;
  953. *tex_coords++ = t[index];
  954. }
  956. //copy offset indices into mesh - check
  957. for (S32 i = 0; i < index_count; i++)
  958. {
  959. U16 index = index_offset + i;
  960. if (idx[index] >= vert_start + vert_count ||
  961. idx[index] < vert_start)
  962. {
  963. llerrs << "WTF?" << llendl;
  964. }
  965. *indices++ = idx[index]-vert_start+cur_idx;
  966. }
  968. //increment index offset - check
  969. cur_idx += vert_count;
  970. }
  971.  
  973. void LLVOTree::genBranchPipeline(LLStrider<LLVector3>& vertices, 
  974.  LLStrider<LLVector3>& normals, 
  975.  LLStrider<LLVector2>& tex_coords, 
  976.  LLStrider<U16>& indices,
  977.  U16& index_offset,
  978.  LLMatrix4& matrix, 
  979.  S32 trunk_LOD, 
  980.  S32 stop_level, 
  981.  U16 depth, 
  982.  U16 trunk_depth,  
  983.  F32 scale, 
  984.  F32 twist, 
  985.  F32 droop,  
  986.  F32 branches, 
  987.  F32 alpha)
  988. {
  989. //
  990. //  Generates a tree mesh by recursing, generating branches and then a 'leaf' texture.
  992. static F32 constant_twist;
  993. static F32 width = 0;
  995. F32 length = ((trunk_depth || (scale == 1.f))? mTrunkLength:mBranchLength);
  996. F32 aspect = ((trunk_depth || (scale == 1.f))? mTrunkAspect:mBranchAspect);
  998. constant_twist = 360.f/branches;
  1000. if (stop_level >= 0)
  1001. {
  1002. if (depth > stop_level)
  1003. {
  1004. {
  1005. llassert(sLODIndexCount[trunk_LOD] > 0);
  1006. width = scale * length * aspect;
  1007. LLMatrix4 scale_mat;
  1008. scale_mat.mMatrix[0][0] = width;
  1009. scale_mat.mMatrix[1][1] = width;
  1010. scale_mat.mMatrix[2][2] = scale*length;
  1011. scale_mat *= matrix;
  1013. glh::matrix4f norm((F32*) scale_mat.mMatrix);
  1014. LLMatrix4 norm_mat = LLMatrix4(norm.inverse().transpose().m);
  1016. norm_mat.invert();
  1017. appendMesh(vertices, normals, tex_coords, indices, index_offset, scale_mat, norm_mat, 
  1018. sLODVertexOffset[trunk_LOD], sLODVertexCount[trunk_LOD], sLODIndexCount[trunk_LOD], sLODIndexOffset[trunk_LOD]);
  1019. }
  1021. // Recurse to create more branches
  1022. for (S32 i=0; i < (S32)branches; i++) 
  1023. {
  1024. LLMatrix4 trans_mat;
  1025. trans_mat.setTranslation(0,0,scale*length);
  1026. trans_mat *= matrix;
  1028. LLQuaternion rot = 
  1029. LLQuaternion(20.f*DEG_TO_RAD, LLVector4(0.f, 0.f, 1.f)) *
  1030. LLQuaternion(droop*DEG_TO_RAD, LLVector4(0.f, 1.f, 0.f)) *
  1031. LLQuaternion(((constant_twist + ((i%2==0)?twist:-twist))*i)*DEG_TO_RAD, LLVector4(0.f, 0.f, 1.f));
  1033. LLMatrix4 rot_mat(rot);
  1034. rot_mat *= trans_mat;
  1036. genBranchPipeline(vertices, normals, tex_coords, indices, index_offset, rot_mat, trunk_LOD, stop_level, depth - 1, 0, scale*mScaleStep, twist, droop, branches, alpha);
  1037. }
  1038. //  Recurse to continue trunk
  1039. if (trunk_depth)
  1040. {
  1041. LLMatrix4 trans_mat;
  1042. trans_mat.setTranslation(0,0,scale*length);
  1043. trans_mat *= matrix;
  1045. LLMatrix4 rot_mat(70.5f*DEG_TO_RAD, LLVector4(0,0,1));
  1046. rot_mat *= trans_mat; // rotate a bit around Z when ascending 
  1047. genBranchPipeline(vertices, normals, tex_coords, indices, index_offset, rot_mat, trunk_LOD, stop_level, depth, trunk_depth-1, scale*mScaleStep, twist, droop, branches, alpha);
  1048. }
  1049. }
  1050. else
  1051. {
  1052. //
  1053. //  Append leaves as two 90 deg crossed quads with leaf textures
  1054. //
  1055. {
  1056. LLMatrix4 scale_mat;
  1057. scale_mat.mMatrix[0][0] = 
  1058. scale_mat.mMatrix[1][1] =
  1059. scale_mat.mMatrix[2][2] = scale*mLeafScale;
  1061. scale_mat *= matrix;
  1063. glh::matrix4f norm((F32*) scale_mat.mMatrix);
  1064. LLMatrix4 norm_mat = LLMatrix4(norm.inverse().transpose().m);
  1066. appendMesh(vertices, normals, tex_coords, indices, index_offset, scale_mat, norm_mat, 0, LEAF_VERTICES, LEAF_INDICES, 0);
  1067. }
  1068. }
  1069. }
  1070. }
  1074. void LLVOTree::calcNumVerts(U32& vert_count, U32& index_count, S32 trunk_LOD, S32 stop_level, U16 depth, U16 trunk_depth, F32 branches)
  1075. {
  1076. if (stop_level >= 0)
  1077. {
  1078. if (depth > stop_level)
  1079. {
  1080. index_count += sLODIndexCount[trunk_LOD];
  1081. vert_count += sLODVertexCount[trunk_LOD];
  1083. // Recurse to create more branches
  1084. for (S32 i=0; i < (S32)branches; i++) 
  1085. {
  1086. calcNumVerts(vert_count, index_count, trunk_LOD, stop_level, depth - 1, 0, branches);
  1087. }
  1089. //  Recurse to continue trunk
  1090. if (trunk_depth)
  1091. {
  1092. calcNumVerts(vert_count, index_count, trunk_LOD, stop_level, depth, trunk_depth-1, branches);
  1093. }
  1094. }
  1095. else
  1096. {
  1097. index_count += LEAF_INDICES;
  1098. vert_count += LEAF_VERTICES;
  1099. }
  1100. }
  1101. else
  1102. {
  1103. index_count += LEAF_INDICES;
  1104. vert_count += LEAF_VERTICES;
  1105. }
  1106. }
  1108. U32 LLVOTree::drawBranchPipeline(LLMatrix4& matrix, U16* indicesp, S32 trunk_LOD, S32 stop_level, U16 depth, U16 trunk_depth,  F32 scale, F32 twist, F32 droop,  F32 branches, F32 alpha)
  1109. {
  1110. U32 ret = 0;
  1111. //
  1112. //  Draws a tree by recursing, drawing branches and then a 'leaf' texture.
  1113. //  If stop_level = -1, simply draws the whole tree as a billboarded texture
  1114. //
  1116. static F32 constant_twist;
  1117. static F32 width = 0;
  1119. //F32 length = ((scale == 1.f)? mTrunkLength:mBranchLength);
  1120. //F32 aspect = ((scale == 1.f)? mTrunkAspect:mBranchAspect);
  1121. F32 length = ((trunk_depth || (scale == 1.f))? mTrunkLength:mBranchLength);
  1122. F32 aspect = ((trunk_depth || (scale == 1.f))? mTrunkAspect:mBranchAspect);
  1124. constant_twist = 360.f/branches;
  1126. if (!LLPipeline::sReflectionRender && stop_level >= 0)
  1127. {
  1128. //
  1129. //  Draw the tree using recursion
  1130. //
  1131. if (depth > stop_level)
  1132. {
  1133. {
  1134. llassert(sLODIndexCount[trunk_LOD] > 0);
  1135. width = scale * length * aspect;
  1136. LLMatrix4 scale_mat;
  1137. scale_mat.mMatrix[0][0] = width;
  1138. scale_mat.mMatrix[1][1] = width;
  1139. scale_mat.mMatrix[2][2] = scale*length;
  1140. scale_mat *= matrix;
  1142. glLoadMatrixf((F32*) scale_mat.mMatrix);
  1143.   glDrawElements(GL_TRIANGLES, sLODIndexCount[trunk_LOD], GL_UNSIGNED_SHORT, indicesp + sLODIndexOffset[trunk_LOD]);
  1144. gPipeline.addTrianglesDrawn(LEAF_INDICES/3);
  1145. stop_glerror();
  1146. ret += sLODIndexCount[trunk_LOD];
  1147. }
  1149. // Recurse to create more branches
  1150. for (S32 i=0; i < (S32)branches; i++) 
  1151. {
  1152. LLMatrix4 trans_mat;
  1153. trans_mat.setTranslation(0,0,scale*length);
  1154. trans_mat *= matrix;
  1156. LLQuaternion rot = 
  1157. LLQuaternion(20.f*DEG_TO_RAD, LLVector4(0.f, 0.f, 1.f)) *
  1158. LLQuaternion(droop*DEG_TO_RAD, LLVector4(0.f, 1.f, 0.f)) *
  1159. LLQuaternion(((constant_twist + ((i%2==0)?twist:-twist))*i)*DEG_TO_RAD, LLVector4(0.f, 0.f, 1.f));
  1161. LLMatrix4 rot_mat(rot);
  1162. rot_mat *= trans_mat;
  1164. ret += drawBranchPipeline(rot_mat, indicesp, trunk_LOD, stop_level, depth - 1, 0, scale*mScaleStep, twist, droop, branches, alpha);
  1165. }
  1166. //  Recurse to continue trunk
  1167. if (trunk_depth)
  1168. {
  1169. LLMatrix4 trans_mat;
  1170. trans_mat.setTranslation(0,0,scale*length);
  1171. trans_mat *= matrix;
  1173. LLMatrix4 rot_mat(70.5f*DEG_TO_RAD, LLVector4(0,0,1));
  1174. rot_mat *= trans_mat; // rotate a bit around Z when ascending 
  1175. ret += drawBranchPipeline(rot_mat, indicesp, trunk_LOD, stop_level, depth, trunk_depth-1, scale*mScaleStep, twist, droop, branches, alpha);
  1176. }
  1177. }
  1178. else
  1179. {
  1180. //
  1181. //  Draw leaves as two 90 deg crossed quads with leaf textures
  1182. //
  1183. {
  1184. LLMatrix4 scale_mat;
  1185. scale_mat.mMatrix[0][0] = 
  1186. scale_mat.mMatrix[1][1] =
  1187. scale_mat.mMatrix[2][2] = scale*mLeafScale;
  1189. scale_mat *= matrix;
  1192. glLoadMatrixf((F32*) scale_mat.mMatrix);
  1193. glDrawElements(GL_TRIANGLES, LEAF_INDICES, GL_UNSIGNED_SHORT, indicesp);
  1194. gPipeline.addTrianglesDrawn(LEAF_INDICES/3);
  1195. stop_glerror();
  1196. ret += LEAF_INDICES;
  1197. }
  1198. }
  1199. }
  1200. else
  1201. {
  1202. //
  1203. //  Draw the tree as a single billboard texture 
  1204. //
  1206. LLMatrix4 scale_mat;
  1207. scale_mat.mMatrix[0][0] = 
  1208. scale_mat.mMatrix[1][1] =
  1209. scale_mat.mMatrix[2][2] = mBillboardScale*mBillboardRatio;
  1211. scale_mat *= matrix;
  1213. glMatrixMode(GL_TEXTURE);
  1214. glTranslatef(0.0, -0.5, 0.0);
  1215. glMatrixMode(GL_MODELVIEW);
  1217. glLoadMatrixf((F32*) scale_mat.mMatrix);
  1218. glDrawElements(GL_TRIANGLES, LEAF_INDICES, GL_UNSIGNED_SHORT, indicesp);
  1219. gPipeline.addTrianglesDrawn(LEAF_INDICES/3);
  1220. stop_glerror();
  1221. ret += LEAF_INDICES;
  1223. glMatrixMode(GL_TEXTURE);
  1224. glLoadIdentity();
  1225. glMatrixMode(GL_MODELVIEW);
  1226. }
  1228. return ret;
  1229. }
  1231. void LLVOTree::updateRadius()
  1232. {
  1233. if (mDrawable.isNull())
  1234. {
  1235. return;
  1236. }
  1238. mDrawable->setRadius(32.0f);
  1239. }
  1241. void LLVOTree::updateSpatialExtents(LLVector3& newMin, LLVector3& newMax)
  1242. {
  1243. F32 radius = getScale().length()*0.05f;
  1244. LLVector3 center = getRenderPosition();
  1246. F32 sz = mBillboardScale*mBillboardRatio*radius*0.5f; 
  1247. LLVector3 size(sz,sz,sz);
  1249. center += LLVector3(0, 0, size.mV[2]) * getRotation();
  1251. newMin.set(center-size);
  1252. newMax.set(center+size);
  1253. mDrawable->setPositionGroup(center);
  1254. }
  1256. BOOL LLVOTree::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, S32 face, BOOL pick_transparent, S32 *face_hitp,
  1257.   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
  1259. {
  1261. if (!lineSegmentBoundingBox(start, end))
  1262. {
  1263. return FALSE;
  1264. }
  1266. const LLVector3* ext = mDrawable->getSpatialExtents();
  1268. LLVector3 center = (ext[1]+ext[0])*0.5f;
  1269. LLVector3 size = (ext[1]-ext[0]);
  1271. LLQuaternion quat = getRotation();
  1273. center -= LLVector3(0,0,size.magVec() * 0.25f)*quat;
  1275. size.scaleVec(LLVector3(0.25f, 0.25f, 1.f));
  1276. size.mV[0] = llmin(size.mV[0], 1.f);
  1277. size.mV[1] = llmin(size.mV[1], 1.f);
  1279. LLVector3 pos, norm;
  1281. if (linesegment_tetrahedron(start, end, center, size, quat, pos, norm))
  1282. {
  1283. if (intersection)
  1284. {
  1285. *intersection = pos;
  1286. }
  1288. if (normal)
  1289. {
  1290. *normal = norm;
  1291. }
  1292. return TRUE;
  1293. }
  1295. return FALSE;
  1296. }
  1298. U32 LLVOTree::getPartitionType() const
  1299. { 
  1300. return LLViewerRegion::PARTITION_TREE; 
  1301. }
  1303. LLTreePartition::LLTreePartition()
  1304. : LLSpatialPartition(0, FALSE, 0)
  1305. {
  1306. mDrawableType = LLPipeline::RENDER_TYPE_TREE;
  1307. mPartitionType = LLViewerRegion::PARTITION_TREE;
  1308. mSlopRatio = 0.f;
  1309. mLODPeriod = 1;
  1310. }