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

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

游戏引擎

开发平台：

C++ Builder

llvosurfacepatch.cpp：源码内容
  1. /** 
  2.  * @file llvosurfacepatch.cpp
  3.  * @brief Viewer-object derived "surface patch", which is a piece of terrain
  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 "llvosurfacepatch.h"
  37. #include "lldrawpoolterrain.h"
  39. #include "lldrawable.h"
  40. #include "llface.h"
  41. #include "llprimitive.h"
  42. #include "llsky.h"
  43. #include "llsurfacepatch.h"
  44. #include "llsurface.h"
  45. #include "llviewerobjectlist.h"
  46. #include "llviewerregion.h"
  47. #include "llvlcomposition.h"
  48. #include "llvovolume.h"
  49. #include "pipeline.h"
  50. #include "llspatialpartition.h"
  52. F32 LLVOSurfacePatch::sLODFactor = 1.f;
  54. //============================================================================
  56. class LLVertexBufferTerrain : public LLVertexBuffer
  57. {
  58. public:
  59. LLVertexBufferTerrain() :
  60. LLVertexBuffer(MAP_VERTEX | MAP_NORMAL | MAP_TEXCOORD0 | MAP_TEXCOORD1 | MAP_COLOR, GL_DYNAMIC_DRAW_ARB)
  61. {
  62. //texture coordinates 2 and 3 exist, but use the same data as texture coordinate 1
  63. mOffsets[TYPE_TEXCOORD3] = mOffsets[TYPE_TEXCOORD2] = mOffsets[TYPE_TEXCOORD1];
  64. mTypeMask |= MAP_TEXCOORD2 | MAP_TEXCOORD3;
  65. };
  67. /*// virtual
  68. void setupVertexBuffer(U32 data_mask) const
  69. {
  70. if (LLDrawPoolTerrain::getDetailMode() == 0 || LLPipeline::sShadowRender)
  71. {
  72. LLVertexBuffer::setupVertexBuffer(data_mask);
  73. }
  74. else if (data_mask & LLVertexBuffer::MAP_TEXCOORD1)
  75. {
  76. LLVertexBuffer::setupVertexBuffer(data_mask);
  77. }
  78. else
  79. {
  80. LLVertexBuffer::setupVertexBuffer(data_mask);
  81. }
  82. llglassertok();
  83. }*/
  84. };
  86. //============================================================================
  88. LLVOSurfacePatch::LLVOSurfacePatch(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
  89. : LLStaticViewerObject(id, LL_VO_SURFACE_PATCH, regionp),
  90. mDirtiedPatch(FALSE),
  91. mPool(NULL),
  92. mBaseComp(0),
  93. mPatchp(NULL),
  94. mDirtyTexture(FALSE),
  95. mDirtyTerrain(FALSE),
  96. mLastNorthStride(0),
  97. mLastEastStride(0),
  98. mLastStride(0),
  99. mLastLength(0)
  100. {
  101. // Terrain must draw during selection passes so it can block objects behind it.
  102. mbCanSelect = TRUE;
  103. setScale(LLVector3(16.f, 16.f, 16.f)); // Hack for setting scale for bounding boxes/visibility.
  104. }
  107. LLVOSurfacePatch::~LLVOSurfacePatch()
  108. {
  109. mPatchp = NULL;
  110. }
  113. void LLVOSurfacePatch::markDead()
  114. {
  115. if (mPatchp)
  116. {
  117. mPatchp->clearVObj();
  118. mPatchp = NULL;
  119. }
  120. LLViewerObject::markDead();
  121. }
  124. BOOL LLVOSurfacePatch::isActive() const
  125. {
  126. return FALSE;
  127. }
  130. void LLVOSurfacePatch::setPixelAreaAndAngle(LLAgent &agent)
  131. {
  132. mAppAngle = 50;
  133. mPixelArea = 500*500;
  134. }
  137. void LLVOSurfacePatch::updateTextures()
  138. {
  139. }
  142. LLFacePool *LLVOSurfacePatch::getPool()
  143. {
  144. mPool = (LLDrawPoolTerrain*) gPipeline.getPool(LLDrawPool::POOL_TERRAIN, mPatchp->getSurface()->getSTexture());
  146. return mPool;
  147. }
  150. LLDrawable *LLVOSurfacePatch::createDrawable(LLPipeline *pipeline)
  151. {
  152. pipeline->allocDrawable(this);
  154. mDrawable->setRenderType(LLPipeline::RENDER_TYPE_TERRAIN);
  156. mBaseComp = llfloor(mPatchp->getMinComposition());
  157. S32 min_comp, max_comp, range;
  158. min_comp = llfloor(mPatchp->getMinComposition());
  159. max_comp = llceil(mPatchp->getMaxComposition());
  160. range = (max_comp - min_comp);
  161. range++;
  162. if (range > 3)
  163. {
  164. if ((mPatchp->getMinComposition() - min_comp) > (max_comp - mPatchp->getMaxComposition()))
  165. {
  166. // The top side runs over more
  167. mBaseComp++;
  168. }
  169. range = 3;
  170. }
  172. LLFacePool *poolp = getPool();
  174. mDrawable->addFace(poolp, NULL);
  176. return mDrawable;
  177. }
  179. static LLFastTimer::DeclareTimer FTM_UPDATE_TERRAIN("Update Terrain");
  181. void LLVOSurfacePatch::updateGL()
  182. {
  183. if (mPatchp)
  184. {
  185. mPatchp->updateGL();
  186. }
  187. }
  189. BOOL LLVOSurfacePatch::updateGeometry(LLDrawable *drawable)
  190. {
  191. LLFastTimer ftm(FTM_UPDATE_TERRAIN);
  193. dirtySpatialGroup(TRUE);
  195. S32 min_comp, max_comp, range;
  196. min_comp = lltrunc(mPatchp->getMinComposition());
  197. max_comp = lltrunc(ceil(mPatchp->getMaxComposition()));
  198. range = (max_comp - min_comp);
  199. range++;
  200. S32 new_base_comp = lltrunc(mPatchp->getMinComposition());
  201. if (range > 3)
  202. {
  203. if ((mPatchp->getMinComposition() - min_comp) > (max_comp - mPatchp->getMaxComposition()))
  204. {
  205. // The top side runs over more
  206. new_base_comp++;
  207. }
  208. range = 3;
  209. }
  211. // Pick the two closest detail textures for this patch...
  212. // Then create the draw pool for it.
  213. // Actually, should get the average composition instead of the center.
  214. mBaseComp = new_base_comp;
  216. //////////////////////////
  217. //
  218. // Figure out the strides
  219. //
  220. //
  222. U32 patch_width, render_stride, north_stride, east_stride, length;
  223. render_stride = mPatchp->getRenderStride();
  224. patch_width = mPatchp->getSurface()->getGridsPerPatchEdge();
  226. length = patch_width / render_stride;
  228. if (mPatchp->getNeighborPatch(NORTH))
  229. {
  230. north_stride = mPatchp->getNeighborPatch(NORTH)->getRenderStride();
  231. }
  232. else
  233. {
  234. north_stride = render_stride;
  235. }
  237. if (mPatchp->getNeighborPatch(EAST))
  238. {
  239. east_stride = mPatchp->getNeighborPatch(EAST)->getRenderStride();
  240. }
  241. else
  242. {
  243. east_stride = render_stride;
  244. }
  246. mLastLength = length;
  247. mLastStride = render_stride;
  248. mLastNorthStride = north_stride;
  249. mLastEastStride = east_stride;
  251. return TRUE;
  252. }
  254. void LLVOSurfacePatch::updateFaceSize(S32 idx)
  255. {
  256. if (idx != 0)
  257. {
  258. llwarns << "Terrain partition requested invalid face!!!" << llendl;
  259. return;
  260. }
  262. LLFace* facep = mDrawable->getFace(idx);
  264. S32 num_vertices = 0;
  265. S32 num_indices = 0;
  267. if (mLastStride)
  268. {
  269. getGeomSizesMain(mLastStride, num_vertices, num_indices);
  270. getGeomSizesNorth(mLastStride, mLastNorthStride, num_vertices, num_indices);
  271. getGeomSizesEast(mLastStride, mLastEastStride, num_vertices, num_indices);
  272. }
  274. facep->setSize(num_vertices, num_indices);
  275. }
  277. BOOL LLVOSurfacePatch::updateLOD()
  278. {
  279. return TRUE;
  280. }
  282. void LLVOSurfacePatch::getGeometry(LLStrider<LLVector3> &verticesp,
  283. LLStrider<LLVector3> &normalsp,
  284. LLStrider<LLColor4U> &colorsp,
  285. LLStrider<LLVector2> &texCoords0p,
  286. LLStrider<LLVector2> &texCoords1p,
  287. LLStrider<U16> &indicesp)
  288. {
  289. LLFace* facep = mDrawable->getFace(0);
  291. U32 index_offset = facep->getGeomIndex();
  293. updateMainGeometry(facep, 
  294. verticesp,
  295. normalsp,
  296. colorsp,
  297. texCoords0p,
  298. texCoords1p,
  299. indicesp,
  300. index_offset);
  301. updateNorthGeometry(facep, 
  302. verticesp,
  303. normalsp,
  304. colorsp,
  305. texCoords0p,
  306. texCoords1p,
  307. indicesp,
  308. index_offset);
  309. updateEastGeometry(facep, 
  310. verticesp,
  311. normalsp,
  312. colorsp,
  313. texCoords0p,
  314. texCoords1p,
  315. indicesp,
  316. index_offset);
  317. }
  319. void LLVOSurfacePatch::updateMainGeometry(LLFace *facep,
  320. LLStrider<LLVector3> &verticesp,
  321. LLStrider<LLVector3> &normalsp,
  322. LLStrider<LLColor4U> &colorsp,
  323. LLStrider<LLVector2> &texCoords0p,
  324. LLStrider<LLVector2> &texCoords1p,
  325. LLStrider<U16> &indicesp,
  326. U32 &index_offset)
  327. {
  328. S32 i, j, x, y;
  330. U32 patch_size, render_stride;
  331. S32 num_vertices, num_indices;
  332. U32 index;
  334. render_stride = mLastStride;
  335. patch_size = mPatchp->getSurface()->getGridsPerPatchEdge();
  336. S32 vert_size = patch_size / render_stride;
  338. ///////////////////////////
  339. //
  340. // Render the main patch
  341. //
  342. //
  344. num_vertices = 0;
  345. num_indices = 0;
  346. // First, figure out how many vertices we need...
  347. getGeomSizesMain(render_stride, num_vertices, num_indices);
  349. if (num_vertices > 0)
  350. {
  351. facep->mCenterAgent = mPatchp->getPointAgent(8, 8);
  353. // Generate patch points first
  354. for (j = 0; j < vert_size; j++)
  355. {
  356. for (i = 0; i < vert_size; i++)
  357. {
  358. x = i * render_stride;
  359. y = j * render_stride;
  360. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  361. *colorsp++ = LLColor4U::white;
  362. verticesp++;
  363. normalsp++;
  364. texCoords0p++;
  365. texCoords1p++;
  366. }
  367. }
  369. for (j = 0; j < (vert_size - 1); j++)
  370. {
  371. if (j % 2)
  372. {
  373. for (i = (vert_size - 1); i > 0; i--)
  374. {
  375. index = (i - 1)+ j*vert_size;
  376. *(indicesp++) = index_offset + index;
  378. index = i + (j+1)*vert_size;
  379. *(indicesp++) = index_offset + index;
  381. index = (i - 1) + (j+1)*vert_size;
  382. *(indicesp++) = index_offset + index;
  384. index = (i - 1) + j*vert_size;
  385. *(indicesp++) = index_offset + index;
  387. index = i + j*vert_size;
  388. *(indicesp++) = index_offset + index;
  390. index = i + (j+1)*vert_size;
  391. *(indicesp++) = index_offset + index;
  392. }
  393. }
  394. else
  395. {
  396. for (i = 0; i < (vert_size - 1); i++)
  397. {
  398. index = i + j*vert_size;
  399. *(indicesp++) = index_offset + index;
  401. index = (i + 1) + (j+1)*vert_size;
  402. *(indicesp++) = index_offset + index;
  404. index = i + (j+1)*vert_size;
  405. *(indicesp++) = index_offset + index;
  407. index = i + j*vert_size;
  408. *(indicesp++) = index_offset + index;
  410. index = (i + 1) + j*vert_size;
  411. *(indicesp++) = index_offset + index;
  413. index = (i + 1) + (j + 1)*vert_size;
  414. *(indicesp++) = index_offset + index;
  415. }
  416. }
  417. }
  418. }
  419. index_offset += num_vertices;
  420. }
  423. void LLVOSurfacePatch::updateNorthGeometry(LLFace *facep,
  424. LLStrider<LLVector3> &verticesp,
  425. LLStrider<LLVector3> &normalsp,
  426. LLStrider<LLColor4U> &colorsp,
  427. LLStrider<LLVector2> &texCoords0p,
  428. LLStrider<LLVector2> &texCoords1p,
  429. LLStrider<U16> &indicesp,
  430. U32 &index_offset)
  431. {
  432. S32 vertex_count = 0;
  433. S32 i, x, y;
  435. S32 num_vertices, num_indices;
  437. U32 render_stride = mLastStride;
  438. S32 patch_size = mPatchp->getSurface()->getGridsPerPatchEdge();
  439. S32 length = patch_size / render_stride;
  440. S32 half_length = length / 2;
  441. U32 north_stride = mLastNorthStride;
  443. ///////////////////////////
  444. //
  445. // Render the north strip
  446. //
  447. //
  449. // Stride lengths are the same
  450. if (north_stride == render_stride)
  451. {
  452. num_vertices = 2 * length + 1;
  453. num_indices = length * 6 - 3;
  455. facep->mCenterAgent = (mPatchp->getPointAgent(8, 15) + mPatchp->getPointAgent(8, 16))*0.5f;
  457. // Main patch
  458. for (i = 0; i < length; i++)
  459. {
  460. x = i * render_stride;
  461. y = 16 - render_stride;
  463. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  464. *colorsp++ = LLColor4U::white;
  465. verticesp++;
  466. normalsp++;
  467. texCoords0p++;
  468. texCoords1p++;
  469. vertex_count++;
  470. }
  472. // North patch
  473. for (i = 0; i <= length; i++)
  474. {
  475. x = i * render_stride;
  476. y = 16;
  477. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  478. verticesp++;
  479. normalsp++;
  480. *colorsp++ = LLColor4U::white;
  481. texCoords0p++;
  482. texCoords1p++;
  483. vertex_count++;
  484. }
  487. for (i = 0; i < length; i++)
  488. {
  489. // Generate indices
  490. *(indicesp++) = index_offset + i;
  491. *(indicesp++) = index_offset + length + i + 1;
  492. *(indicesp++) = index_offset + length + i;
  494. if (i != length - 1)
  495. {
  496. *(indicesp++) = index_offset + i;
  497. *(indicesp++) = index_offset + i + 1;
  498. *(indicesp++) = index_offset + length + i + 1;
  499. }
  500. }
  501. }
  502. else if (north_stride > render_stride)
  503. {
  504. // North stride is longer (has less vertices)
  505. num_vertices = length + length/2 + 1;
  506. num_indices = half_length*9 - 3;
  508. facep->mCenterAgent = (mPatchp->getPointAgent(7, 15) + mPatchp->getPointAgent(8, 16))*0.5f;
  510. // Iterate through this patch's points
  511. for (i = 0; i < length; i++)
  512. {
  513. x = i * render_stride;
  514. y = 16 - render_stride;
  516. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  517. verticesp++;
  518. normalsp++;
  519. *colorsp++ = LLColor4U::white;
  520. texCoords0p++;
  521. texCoords1p++;
  522. vertex_count++;
  523. }
  525. // Iterate through the north patch's points
  526. for (i = 0; i <= length; i+=2)
  527. {
  528. x = i * render_stride;
  529. y = 16;
  531. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  532. verticesp++;
  533. normalsp++;
  534. *colorsp++ = LLColor4U::white;
  535. texCoords0p++;
  536. texCoords1p++;
  537. vertex_count++;
  538. }
  541. for (i = 0; i < length; i++)
  542. {
  543. if (!(i % 2))
  544. {
  545. *(indicesp++) = index_offset + i;
  546. *(indicesp++) = index_offset + i + 1;
  547. *(indicesp++) = index_offset + length + (i/2);
  549. *(indicesp++) = index_offset + i + 1;
  550. *(indicesp++) = index_offset + length + (i/2) + 1;
  551. *(indicesp++) = index_offset + length + (i/2);
  552. }
  553. else if (i < (length - 1))
  554. {
  555. *(indicesp++) = index_offset + i;
  556. *(indicesp++) = index_offset + i + 1;
  557. *(indicesp++) = index_offset + length + (i/2) + 1;
  558. }
  559. }
  560. }
  561. else
  562. {
  563. // North stride is shorter (more vertices)
  564. length = patch_size / north_stride;
  565. half_length = length / 2;
  566. num_vertices = length + half_length + 1;
  567. num_indices = 9*half_length - 3;
  569. facep->mCenterAgent = (mPatchp->getPointAgent(15, 7) + mPatchp->getPointAgent(16, 8))*0.5f;
  571. // Iterate through this patch's points
  572. for (i = 0; i < length; i+=2)
  573. {
  574. x = i * north_stride;
  575. y = 16 - render_stride;
  577. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  578. *colorsp++ = LLColor4U::white;
  579. verticesp++;
  580. normalsp++;
  581. texCoords0p++;
  582. texCoords1p++;
  583. vertex_count++;
  584. }
  586. // Iterate through the north patch's points
  587. for (i = 0; i <= length; i++)
  588. {
  589. x = i * north_stride;
  590. y = 16;
  592. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  593. verticesp++;
  594. normalsp++;
  595. *colorsp++ = LLColor4U::white;
  596. texCoords0p++;
  597. texCoords1p++;
  598. vertex_count++;
  599. }
  601. for (i = 0; i < length; i++)
  602. {
  603. if (!(i%2))
  604. {
  605. *(indicesp++) = index_offset + half_length + i;
  606. *(indicesp++) = index_offset + i/2;
  607. *(indicesp++) = index_offset + half_length + i + 1;
  608. }
  609. else if (i < (length - 2))
  610. {
  611. *(indicesp++) = index_offset + half_length + i;
  612. *(indicesp++) = index_offset + i/2;
  613. *(indicesp++) = index_offset + i/2 + 1;
  615. *(indicesp++) = index_offset + half_length + i;
  616. *(indicesp++) = index_offset + i/2 + 1;
  617. *(indicesp++) = index_offset + half_length + i + 1;
  618. }
  619. else
  620. {
  621. *(indicesp++) = index_offset + half_length + i;
  622. *(indicesp++) = index_offset + i/2;
  623. *(indicesp++) = index_offset + half_length + i + 1;
  624. }
  625. }
  626. }
  627. index_offset += num_vertices;
  628. }
  630. void LLVOSurfacePatch::updateEastGeometry(LLFace *facep,
  631.   LLStrider<LLVector3> &verticesp,
  632.   LLStrider<LLVector3> &normalsp,
  633.   LLStrider<LLColor4U> &colorsp,
  634.   LLStrider<LLVector2> &texCoords0p,
  635.   LLStrider<LLVector2> &texCoords1p,
  636.   LLStrider<U16> &indicesp,
  637.   U32 &index_offset)
  638. {
  639. S32 i, x, y;
  641. S32 num_vertices, num_indices;
  643. U32 render_stride = mLastStride;
  644. S32 patch_size = mPatchp->getSurface()->getGridsPerPatchEdge();
  645. S32 length = patch_size / render_stride;
  646. S32 half_length = length / 2;
  648. U32 east_stride = mLastEastStride;
  650. // Stride lengths are the same
  651. if (east_stride == render_stride)
  652. {
  653. num_vertices = 2 * length + 1;
  654. num_indices = length * 6 - 3;
  656. facep->mCenterAgent = (mPatchp->getPointAgent(8, 15) + mPatchp->getPointAgent(8, 16))*0.5f;
  658. // Main patch
  659. for (i = 0; i < length; i++)
  660. {
  661. x = 16 - render_stride;
  662. y = i * render_stride;
  664. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  665. verticesp++;
  666. normalsp++;
  667. *colorsp++ = LLColor4U::white;
  668. texCoords0p++;
  669. texCoords1p++;
  670. }
  672. // East patch
  673. for (i = 0; i <= length; i++)
  674. {
  675. x = 16;
  676. y = i * render_stride;
  677. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  678. verticesp++;
  679. normalsp++;
  680. *colorsp++ = LLColor4U::white;
  681. texCoords0p++;
  682. texCoords1p++;
  683. }
  686. for (i = 0; i < length; i++)
  687. {
  688. // Generate indices
  689. *(indicesp++) = index_offset + i;
  690. *(indicesp++) = index_offset + length + i;
  691. *(indicesp++) = index_offset + length + i + 1;
  693. if (i != length - 1)
  694. {
  695. *(indicesp++) = index_offset + i;
  696. *(indicesp++) = index_offset + length + i + 1;
  697. *(indicesp++) = index_offset + i + 1;
  698. }
  699. }
  700. }
  701. else if (east_stride > render_stride)
  702. {
  703. // East stride is longer (has less vertices)
  704. num_vertices = length + half_length + 1;
  705. num_indices = half_length*9 - 3;
  707. facep->mCenterAgent = (mPatchp->getPointAgent(7, 15) + mPatchp->getPointAgent(8, 16))*0.5f;
  709. // Iterate through this patch's points
  710. for (i = 0; i < length; i++)
  711. {
  712. x = 16 - render_stride;
  713. y = i * render_stride;
  715. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  716. verticesp++;
  717. normalsp++;
  718. *colorsp++ = LLColor4U::white;
  719. texCoords0p++;
  720. texCoords1p++;
  721. }
  722. // Iterate through the east patch's points
  723. for (i = 0; i <= length; i+=2)
  724. {
  725. x = 16;
  726. y = i * render_stride;
  728. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  729. verticesp++;
  730. normalsp++;
  731. *colorsp++ = LLColor4U::white;
  732. texCoords0p++;
  733. texCoords1p++;
  734. }
  736. for (i = 0; i < length; i++)
  737. {
  738. if (!(i % 2))
  739. {
  740. *(indicesp++) = index_offset + i;
  741. *(indicesp++) = index_offset + length + (i/2);
  742. *(indicesp++) = index_offset + i + 1;
  744. *(indicesp++) = index_offset + i + 1;
  745. *(indicesp++) = index_offset + length + (i/2);
  746. *(indicesp++) = index_offset + length + (i/2) + 1;
  747. }
  748. else if (i < (length - 1))
  749. {
  750. *(indicesp++) = index_offset + i;
  751. *(indicesp++) = index_offset + length + (i/2) + 1;
  752. *(indicesp++) = index_offset + i + 1;
  753. }
  754. }
  755. }
  756. else
  757. {
  758. // East stride is shorter (more vertices)
  759. length = patch_size / east_stride;
  760. half_length = length / 2;
  761. num_vertices = length + length/2 + 1;
  762. num_indices = 9*(length/2) - 3;
  764. facep->mCenterAgent = (mPatchp->getPointAgent(15, 7) + mPatchp->getPointAgent(16, 8))*0.5f;
  766. // Iterate through this patch's points
  767. for (i = 0; i < length; i+=2)
  768. {
  769. x = 16 - render_stride;
  770. y = i * east_stride;
  772. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  773. verticesp++;
  774. normalsp++;
  775. *colorsp++ = LLColor4U::white;
  776. texCoords0p++;
  777. texCoords1p++;
  778. }
  779. // Iterate through the east patch's points
  780. for (i = 0; i <= length; i++)
  781. {
  782. x = 16;
  783. y = i * east_stride;
  785. mPatchp->eval(x, y, render_stride, verticesp.get(), normalsp.get(), texCoords0p.get(), texCoords1p.get());
  786. verticesp++;
  787. normalsp++;
  788. *colorsp++ = LLColor4U::white;
  789. texCoords0p++;
  790. texCoords1p++;
  791. }
  793. for (i = 0; i < length; i++)
  794. {
  795. if (!(i%2))
  796. {
  797. *(indicesp++) = index_offset + half_length + i;
  798. *(indicesp++) = index_offset + half_length + i + 1;
  799. *(indicesp++) = index_offset + i/2;
  800. }
  801. else if (i < (length - 2))
  802. {
  803. *(indicesp++) = index_offset + half_length + i;
  804. *(indicesp++) = index_offset + i/2 + 1;
  805. *(indicesp++) = index_offset + i/2;
  807. *(indicesp++) = index_offset + half_length + i;
  808. *(indicesp++) = index_offset + half_length + i + 1;
  809. *(indicesp++) = index_offset + i/2 + 1;
  810. }
  811. else
  812. {
  813. *(indicesp++) = index_offset + half_length + i;
  814. *(indicesp++) = index_offset + half_length + i + 1;
  815. *(indicesp++) = index_offset + i/2;
  816. }
  817. }
  818. }
  819. index_offset += num_vertices;
  820. }
  822. void LLVOSurfacePatch::setPatch(LLSurfacePatch *patchp)
  823. {
  824. mPatchp = patchp;
  826. dirtyPatch();
  827. };
  830. void LLVOSurfacePatch::dirtyPatch()
  831. {
  832. mDirtiedPatch = TRUE;
  833. dirtyGeom();
  834. mDirtyTerrain = TRUE;
  835. LLVector3 center = mPatchp->getCenterRegion();
  836. LLSurface *surfacep = mPatchp->getSurface();
  838. setPositionRegion(center);
  840. F32 scale_factor = surfacep->getGridsPerPatchEdge() * surfacep->getMetersPerGrid();
  841. setScale(LLVector3(scale_factor, scale_factor, mPatchp->getMaxZ() - mPatchp->getMinZ()));
  842. }
  844. void LLVOSurfacePatch::dirtyGeom()
  845. {
  846. if (mDrawable)
  847. {
  848. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  849. mDrawable->getFace(0)->mVertexBuffer = NULL;
  850. mDrawable->movePartition();
  851. }
  852. }
  854. void LLVOSurfacePatch::getGeomSizesMain(const S32 stride, S32 &num_vertices, S32 &num_indices)
  855. {
  856. S32 patch_size = mPatchp->getSurface()->getGridsPerPatchEdge();
  858. // First, figure out how many vertices we need...
  859. S32 vert_size = patch_size / stride;
  860. if (vert_size >= 2)
  861. {
  862. num_vertices += vert_size * vert_size;
  863. num_indices += 6 * (vert_size - 1)*(vert_size - 1);
  864. }
  865. }
  867. void LLVOSurfacePatch::getGeomSizesNorth(const S32 stride, const S32 north_stride,
  868.  S32 &num_vertices, S32 &num_indices)
  869. {
  870. S32 patch_size = mPatchp->getSurface()->getGridsPerPatchEdge();
  871. S32 length = patch_size / stride;
  872. // Stride lengths are the same
  873. if (north_stride == stride)
  874. {
  875. num_vertices += 2 * length + 1;
  876. num_indices += length * 6 - 3;
  877. }
  878. else if (north_stride > stride)
  879. {
  880. // North stride is longer (has less vertices)
  881. num_vertices += length + (length/2) + 1;
  882. num_indices += (length/2)*9 - 3;
  883. }
  884. else
  885. {
  886. // North stride is shorter (more vertices)
  887. length = patch_size / north_stride;
  888. num_vertices += length + (length/2) + 1;
  889. num_indices += 9*(length/2) - 3;
  890. }
  891. }
  893. void LLVOSurfacePatch::getGeomSizesEast(const S32 stride, const S32 east_stride,
  894. S32 &num_vertices, S32 &num_indices)
  895. {
  896. S32 patch_size = mPatchp->getSurface()->getGridsPerPatchEdge();
  897. S32 length = patch_size / stride;
  898. // Stride lengths are the same
  899. if (east_stride == stride)
  900. {
  901. num_vertices += 2 * length + 1;
  902. num_indices += length * 6 - 3;
  903. }
  904. else if (east_stride > stride)
  905. {
  906. // East stride is longer (has less vertices)
  907. num_vertices += length + (length/2) + 1;
  908. num_indices += (length/2)*9 - 3;
  909. }
  910. else
  911. {
  912. // East stride is shorter (more vertices)
  913. length = patch_size / east_stride;
  914. num_vertices += length + (length/2) + 1;
  915. num_indices += 9*(length/2) - 3;
  916. }
  917. }
  919. BOOL LLVOSurfacePatch::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, S32 face, BOOL pick_transparent, S32 *face_hitp,
  920.   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
  922. {
  924. if (!lineSegmentBoundingBox(start, end))
  925. {
  926. return FALSE;
  927. }
  929. LLVector3 delta = end-start;
  931. LLVector3 pdelta = delta;
  932. pdelta.mV[2] = 0;
  934. F32 plength = pdelta.length();
  936. F32 tdelta = 1.f/plength;
  938. LLVector3 origin = start - mRegionp->getOriginAgent();
  940. if (mRegionp->getLandHeightRegion(origin) > origin.mV[2])
  941. {
  942. //origin is under ground, treat as no intersection
  943. return FALSE;
  944. }
  946. //step one meter at a time until intersection point found
  948. const LLVector3* ext = mDrawable->getSpatialExtents();
  949. F32 rad = (delta*tdelta).magVecSquared();
  951. F32 t = 0.f;
  952. while ( t <= 1.f)
  953. {
  954. LLVector3 sample = origin + delta*t;
  956. if (AABBSphereIntersectR2(ext[0], ext[1], sample+mRegionp->getOriginAgent(), rad))
  957. {
  958. F32 height = mRegionp->getLandHeightRegion(sample);
  959. if (height > sample.mV[2])
  960. { //ray went below ground, positive intersection
  961. //quick and dirty binary search to get impact point
  962. tdelta = -tdelta*0.5f;
  963. F32 err_dist = 0.001f;
  964. F32 dist = fabsf(sample.mV[2] - height);
  966. while (dist > err_dist && tdelta*tdelta > 0.0f)
  967. {
  968. t += tdelta;
  969. sample = origin+delta*t;
  970. height = mRegionp->getLandHeightRegion(sample);
  971. if ((tdelta < 0 && height < sample.mV[2]) ||
  972. (height > sample.mV[2] && tdelta > 0))
  973. { //jumped over intersection point, go back
  974. tdelta = -tdelta;
  975. }
  976. tdelta *= 0.5f;
  977. dist = fabsf(sample.mV[2] - height);
  978. }
  980. if (intersection)
  981. {
  982. F32 height = mRegionp->getLandHeightRegion(sample);
  983. if (fabsf(sample.mV[2]-height) < delta.length()*tdelta)
  984. {
  985. sample.mV[2] = mRegionp->getLandHeightRegion(sample);
  986. }
  987. *intersection = sample + mRegionp->getOriginAgent();
  988. }
  990. if (normal)
  991. {
  992. *normal = mRegionp->getLand().resolveNormalGlobal(mRegionp->getPosGlobalFromRegion(sample));
  993. }
  995. return TRUE;
  996. }
  997. }
  999. t += tdelta;
  1000. if (t > 1 && t < 1.f+tdelta*0.99f)
  1001. { //make sure end point is checked (saves vertical lines coming up negative)
  1002. t = 1.f;
  1003. }
  1004. }
  1007. return FALSE;
  1008. }
  1010. void LLVOSurfacePatch::updateSpatialExtents(LLVector3& newMin, LLVector3 &newMax)
  1011. {
  1012. LLVector3 posAgent = getPositionAgent();
  1013. LLVector3 scale = getScale();
  1014. newMin = posAgent-scale*0.5f; // Changing to 2.f makes the culling a -little- better, but still wrong
  1015. newMax = posAgent+scale*0.5f;
  1016. mDrawable->setPositionGroup((newMin+newMax)*0.5f);
  1017. }
  1019. U32 LLVOSurfacePatch::getPartitionType() const
  1020. { 
  1021. return LLViewerRegion::PARTITION_TERRAIN; 
  1022. }
  1024. LLTerrainPartition::LLTerrainPartition()
  1025. : LLSpatialPartition(LLDrawPoolTerrain::VERTEX_DATA_MASK, FALSE, GL_DYNAMIC_DRAW_ARB)
  1026. {
  1027. mOcclusionEnabled = FALSE;
  1028. mInfiniteFarClip = TRUE;
  1029. mDrawableType = LLPipeline::RENDER_TYPE_TERRAIN;
  1030. mPartitionType = LLViewerRegion::PARTITION_TERRAIN;
  1031. }
  1033. LLVertexBuffer* LLTerrainPartition::createVertexBuffer(U32 type_mask, U32 usage)
  1034. {
  1035. return new LLVertexBufferTerrain();
  1036. }
  1038. static LLFastTimer::DeclareTimer FTM_REBUILD_TERRAIN_VB("Terrain VB");
  1039. void LLTerrainPartition::getGeometry(LLSpatialGroup* group)
  1040. {
  1041. LLFastTimer ftm(FTM_REBUILD_TERRAIN_VB);
  1043. LLVertexBuffer* buffer = group->mVertexBuffer;
  1045. //get vertex buffer striders
  1046. LLStrider<LLVector3> vertices;
  1047. LLStrider<LLVector3> normals;
  1048. LLStrider<LLVector2> texcoords2;
  1049. LLStrider<LLVector2> texcoords;
  1050. LLStrider<LLColor4U> colors;
  1051. LLStrider<U16> indices;
  1053. llassert_always(buffer->getVertexStrider(vertices));
  1054. llassert_always(buffer->getNormalStrider(normals));
  1055. llassert_always(buffer->getTexCoord0Strider(texcoords));
  1056. llassert_always(buffer->getTexCoord1Strider(texcoords2));
  1057. llassert_always(buffer->getColorStrider(colors));
  1058. llassert_always(buffer->getIndexStrider(indices));
  1060. U32 indices_index = 0;
  1061. U32 index_offset = 0;
  1063. for (std::vector<LLFace*>::iterator i = mFaceList.begin(); i != mFaceList.end(); ++i)
  1064. {
  1065. LLFace* facep = *i;
  1067. facep->setIndicesIndex(indices_index);
  1068. facep->setGeomIndex(index_offset);
  1069. facep->mVertexBuffer = buffer;
  1071. LLVOSurfacePatch* patchp = (LLVOSurfacePatch*) facep->getViewerObject();
  1072. patchp->getGeometry(vertices, normals, colors, texcoords, texcoords2, indices);
  1074. indices_index += facep->getIndicesCount();
  1075. index_offset += facep->getGeomCount();
  1076. }
  1078. buffer->setBuffer(0);
  1079. mFaceList.clear();
  1080. }