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

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

游戏引擎

开发平台：

C++ Builder

llface.cpp：源码内容
  1. /** 
  2.  * @file llface.cpp
  3.  * @brief LLFace class implementation
  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 "lldrawable.h" // lldrawable needs to be included before llface
  36. #include "llface.h"
  37. #include "llviewertextureanim.h"
  39. #include "llviewercontrol.h"
  40. #include "llvolume.h"
  41. #include "m3math.h"
  42. #include "v3color.h"
  44. #include "lldrawpoolbump.h"
  45. #include "llgl.h"
  46. #include "llrender.h"
  47. #include "lllightconstants.h"
  48. #include "llsky.h"
  49. #include "llviewercamera.h"
  50. #include "llviewertexturelist.h"
  51. #include "llvosky.h"
  52. #include "llvovolume.h"
  53. #include "pipeline.h"
  54. #include "llviewerregion.h"
  55. #include "llviewerwindow.h"
  57. #define LL_MAX_INDICES_COUNT 1000000
  59. BOOL LLFace::sSafeRenderSelect = TRUE; // FALSE
  61. #define DOTVEC(a,b) (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1] + a.mV[2]*b.mV[2])
  64. /*
  65. For each vertex, given:
  66. B - binormal
  67. T - tangent
  68. N - normal
  69. P - position
  71. The resulting texture coordinate <u,v> is:
  73. u = 2(B dot P)
  74. v = 2(T dot P)
  75. */
  76. void planarProjection(LLVector2 &tc, const LLVector3& normal,
  77.   const LLVector3 &mCenter, const LLVector3& vec)
  78. { //DONE!
  79. LLVector3 binormal;
  80. float d = normal * LLVector3(1,0,0);
  81. if (d >= 0.5f || d <= -0.5f)
  82. {
  83. binormal = LLVector3(0,1,0);
  84. if (normal.mV[0] < 0)
  85. {
  86. binormal = -binormal;
  87. }
  88. }
  89. else
  90. {
  91.         binormal = LLVector3(1,0,0);
  92. if (normal.mV[1] > 0)
  93. {
  94. binormal = -binormal;
  95. }
  96. }
  97. LLVector3 tangent = binormal % normal;
  99. tc.mV[1] = -((tangent*vec)*2 - 0.5f);
  100. tc.mV[0] = 1.0f+((binormal*vec)*2 - 0.5f);
  101. }
  103. void sphericalProjection(LLVector2 &tc, const LLVector3& normal,
  104.  const LLVector3 &mCenter, const LLVector3& vec)
  105. { //BROKEN
  106. /*tc.mV[0] = acosf(vd.mNormal * LLVector3(1,0,0))/3.14159f;
  108. tc.mV[1] = acosf(vd.mNormal * LLVector3(0,0,1))/6.284f;
  109. if (vd.mNormal.mV[1] > 0)
  110. {
  111. tc.mV[1] = 1.0f-tc.mV[1];
  112. }*/
  113. }
  115. void cylindricalProjection(LLVector2 &tc, const LLVector3& normal, const LLVector3 &mCenter, const LLVector3& vec)
  116. { //BROKEN
  117. /*LLVector3 binormal;
  118. float d = vd.mNormal * LLVector3(1,0,0);
  119. if (d >= 0.5f || d <= -0.5f)
  120. {
  121. binormal = LLVector3(0,1,0);
  122. }
  123. else{
  124. binormal = LLVector3(1,0,0);
  125. }
  126. LLVector3 tangent = binormal % vd.mNormal;
  128. tc.mV[1] = -((tangent*vec)*2 - 0.5f);
  130. tc.mV[0] = acosf(vd.mNormal * LLVector3(1,0,0))/6.284f;
  132. if (vd.mNormal.mV[1] < 0)
  133. {
  134. tc.mV[0] = 1.0f-tc.mV[0];
  135. }*/
  136. }
  138. ////////////////////
  139. //
  140. // LLFace implementation
  141. //
  143. void LLFace::init(LLDrawable* drawablep, LLViewerObject* objp)
  144. {
  145. mLastUpdateTime = gFrameTimeSeconds;
  146. mLastMoveTime = 0.f;
  147. mVSize = 0.f;
  148. mPixelArea = 16.f;
  149. mState      = GLOBAL;
  150. mDrawPoolp  = NULL;
  151. mPoolType = 0;
  152. mCenterLocal = objp->getPosition();
  153. mCenterAgent = drawablep->getPositionAgent();
  154. mDistance = 0.f;
  156. mGeomCount = 0;
  157. mGeomIndex = 0;
  158. mIndicesCount = 0;
  159. mIndicesIndex = 0;
  160. mIndexInTex = 0;
  161. mTexture = NULL;
  162. mTEOffset = -1;
  164. setDrawable(drawablep);
  165. mVObjp = objp;
  167. mReferenceIndex = -1;
  169. mTextureMatrix = NULL;
  170. mDrawInfo = NULL;
  172. mFaceColor = LLColor4(1,0,0,1);
  174. mLastVertexBuffer = mVertexBuffer;
  175. mLastGeomCount = mGeomCount;
  176. mLastGeomIndex = mGeomIndex;
  177. mLastIndicesCount = mIndicesCount;
  178. mLastIndicesIndex = mIndicesIndex;
  180. mImportanceToCamera = 0.f ;
  181. mBoundingSphereRadius = 0.0f ;
  183. mAtlasInfop = NULL ;
  184. mUsingAtlas  = FALSE ;
  185. mHasMedia = FALSE ;
  186. }
  189. void LLFace::destroy()
  190. {
  191. if(mTexture.notNull())
  192. {
  193. mTexture->removeFace(this) ;
  194. }
  196. if (mDrawPoolp)
  197. {
  198. mDrawPoolp->removeFace(this);
  199. mDrawPoolp = NULL;
  200. }
  202. if (mTextureMatrix)
  203. {
  204. delete mTextureMatrix;
  205. mTextureMatrix = NULL;
  207. if (mDrawablep.notNull())
  208. {
  209. LLSpatialGroup* group = mDrawablep->getSpatialGroup();
  210. if (group)
  211. {
  212. group->dirtyGeom();
  213. gPipeline.markRebuild(group, TRUE);
  214. }
  215. }
  216. }
  218. setDrawInfo(NULL);
  220. removeAtlas();
  221. mDrawablep = NULL;
  222. mVObjp = NULL;
  223. }
  226. // static
  227. void LLFace::initClass()
  228. {
  229. }
  231. void LLFace::setWorldMatrix(const LLMatrix4 &mat)
  232. {
  233. llerrs << "Faces on this drawable are not independently modifiablen" << llendl;
  234. }
  236. void LLFace::setPool(LLFacePool* new_pool, LLViewerTexture *texturep)
  237. {
  238. LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
  240. if (!new_pool)
  241. {
  242. llerrs << "Setting pool to null!" << llendl;
  243. }
  245. if (new_pool != mDrawPoolp)
  246. {
  247. // Remove from old pool
  248. if (mDrawPoolp)
  249. {
  250. mDrawPoolp->removeFace(this);
  252. if (mDrawablep)
  253. {
  254. gPipeline.markRebuild(mDrawablep, LLDrawable::REBUILD_ALL, TRUE);
  255. }
  256. }
  257. mGeomIndex = 0;
  259. // Add to new pool
  260. if (new_pool)
  261. {
  262. new_pool->addFace(this);
  263. }
  264. mDrawPoolp = new_pool;
  265. }
  267. setTexture(texturep) ;
  268. }
  270. void LLFace::setTexture(LLViewerTexture* tex) 
  271. {
  272. if(mTexture == tex)
  273. {
  274. return ;
  275. }
  277. if(mTexture.notNull())
  278. {
  279. mTexture->removeFace(this) ;
  280. removeAtlas() ;
  281. }
  283. if(tex)
  284. {
  285. tex->addFace(this) ;
  286. }
  288. mTexture = tex ;
  289. }
  291. void LLFace::dirtyTexture()
  292. {
  293. gPipeline.markTextured(getDrawable());
  294. }
  296. void LLFace::switchTexture(LLViewerTexture* new_texture)
  297. {
  298. if(mTexture == new_texture)
  299. {
  300. return ;
  301. }
  303. if(!new_texture)
  304. {
  305. llerrs << "Can not switch to a null texture." << llendl;
  306. return;
  307. }
  308. new_texture->addTextureStats(mTexture->getMaxVirtualSize()) ;
  310. getViewerObject()->changeTEImage(mTEOffset, new_texture) ;
  311. setTexture(new_texture) ;
  312. dirtyTexture();
  313. }
  315. void LLFace::setTEOffset(const S32 te_offset)
  316. {
  317. mTEOffset = te_offset;
  318. }
  321. void LLFace::setFaceColor(const LLColor4& color)
  322. {
  323. mFaceColor = color;
  324. setState(USE_FACE_COLOR);
  325. }
  327. void LLFace::unsetFaceColor()
  328. {
  329. clearState(USE_FACE_COLOR);
  330. }
  332. void LLFace::setDrawable(LLDrawable *drawable)
  333. {
  334. mDrawablep  = drawable;
  335. mXform      = &drawable->mXform;
  336. }
  338. void LLFace::setSize(const S32 num_vertices, const S32 num_indices)
  339. {
  340. if (mGeomCount != num_vertices ||
  341. mIndicesCount != num_indices)
  342. {
  343. mGeomCount    = num_vertices;
  344. mIndicesCount = num_indices;
  345. mVertexBuffer = NULL;
  346. mLastVertexBuffer = NULL;
  347. }
  348. }
  350. //============================================================================
  352. U16 LLFace::getGeometryAvatar(
  353. LLStrider<LLVector3> &vertices,
  354. LLStrider<LLVector3> &normals,
  355. LLStrider<LLVector2> &tex_coords,
  356. LLStrider<F32>  &vertex_weights,
  357. LLStrider<LLVector4> &clothing_weights)
  358. {
  359. LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
  361. if (mVertexBuffer.notNull())
  362. {
  363. mVertexBuffer->getVertexStrider      (vertices, mGeomIndex);
  364. mVertexBuffer->getNormalStrider      (normals, mGeomIndex);
  365. mVertexBuffer->getTexCoord0Strider    (tex_coords, mGeomIndex);
  366. mVertexBuffer->getWeightStrider(vertex_weights, mGeomIndex);
  367. mVertexBuffer->getClothWeightStrider(clothing_weights, mGeomIndex);
  368. }
  370. return mGeomIndex;
  371. }
  373. U16 LLFace::getGeometry(LLStrider<LLVector3> &vertices, LLStrider<LLVector3> &normals,
  374.     LLStrider<LLVector2> &tex_coords, LLStrider<U16> &indicesp)
  375. {
  376. LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
  378. if (mVertexBuffer.notNull())
  379. {
  380. mVertexBuffer->getVertexStrider(vertices,   mGeomIndex);
  381. if (mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_NORMAL))
  382. {
  383. mVertexBuffer->getNormalStrider(normals,    mGeomIndex);
  384. }
  385. if (mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_TEXCOORD0))
  386. {
  387. mVertexBuffer->getTexCoord0Strider(tex_coords, mGeomIndex);
  388. }
  390. mVertexBuffer->getIndexStrider(indicesp, mIndicesIndex);
  391. }
  393. return mGeomIndex;
  394. }
  396. void LLFace::updateCenterAgent()
  397. {
  398. if (mDrawablep->isActive())
  399. {
  400. mCenterAgent = mCenterLocal * getRenderMatrix();
  401. }
  402. else
  403. {
  404. mCenterAgent = mCenterLocal;
  405. }
  406. }
  408. void LLFace::renderForSelect(U32 data_mask)
  409. {
  410. if(mDrawablep.isNull() || mVertexBuffer.isNull())
  411. {
  412. return;
  413. }
  415. LLSpatialGroup* group = mDrawablep->getSpatialGroup();
  416. if (!group || group->isState(LLSpatialGroup::GEOM_DIRTY))
  417. {
  418. return;
  419. }
  421. if (mVObjp->mGLName)
  422. {
  423. S32 name = mVObjp->mGLName;
  425. LLColor4U color((U8)(name >> 16), (U8)(name >> 8), (U8)name);
  426. #if 0 // *FIX: Postponing this fix until we have texcoord pick info...
  427. if (mTEOffset != -1)
  428. {
  429. color.mV[VALPHA] = (U8)(getTextureEntry()->getColor().mV[VALPHA] * 255.f);
  430. }
  431. #endif
  432. glColor4ubv(color.mV);
  434. if (!getPool())
  435. {
  436. switch (getPoolType())
  437. {
  438. case LLDrawPool::POOL_ALPHA:
  439. gGL.getTexUnit(0)->bind(getTexture());
  440. break;
  441. default:
  442. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  443. break;
  444. }
  445. }
  447. mVertexBuffer->setBuffer(data_mask);
  448. #if !LL_RELEASE_FOR_DOWNLOAD
  449. LLGLState::checkClientArrays("", data_mask);
  450. #endif
  451. if (mTEOffset != -1)
  452. {
  453. // mask off high 4 bits (16 total possible faces)
  454. color.mV[0] &= 0x0f;
  455. color.mV[0] |= (mTEOffset & 0x0f) << 4;
  456. glColor4ubv(color.mV);
  457. }
  459. if (mIndicesCount)
  460. {
  461. if (isState(GLOBAL))
  462. {
  463. if (mDrawablep->getVOVolume())
  464. {
  465. glPushMatrix();
  466. glMultMatrixf((float*) mDrawablep->getRegion()->mRenderMatrix.mMatrix);
  467. mVertexBuffer->draw(LLRender::TRIANGLES, mIndicesCount, mIndicesIndex);
  468. glPopMatrix();
  469. }
  470. else
  471. {
  472. mVertexBuffer->draw(LLRender::TRIANGLES, mIndicesCount, mIndicesIndex);
  473. }
  474. }
  475. else
  476. {
  477. glPushMatrix();
  478. glMultMatrixf((float*)getRenderMatrix().mMatrix);
  479. mVertexBuffer->draw(LLRender::TRIANGLES, mIndicesCount, mIndicesIndex);
  480. glPopMatrix();
  481. }
  482. }
  483. }
  484. }
  486. void LLFace::renderSelected(LLViewerTexture *imagep, const LLColor4& color)
  487. {
  488. if (mDrawablep->getSpatialGroup() == NULL)
  489. {
  490. return;
  491. }
  493. mDrawablep->getSpatialGroup()->rebuildGeom();
  494. mDrawablep->getSpatialGroup()->rebuildMesh();
  496. if(mDrawablep.isNull() || mVertexBuffer.isNull())
  497. {
  498. return;
  499. }
  501. if (mGeomCount > 0 && mIndicesCount > 0)
  502. {
  503. gGL.getTexUnit(0)->bind(imagep);
  505. gGL.pushMatrix();
  506. if (mDrawablep->isActive())
  507. {
  508. glMultMatrixf((GLfloat*)mDrawablep->getRenderMatrix().mMatrix);
  509. }
  510. else
  511. {
  512. glMultMatrixf((GLfloat*)mDrawablep->getRegion()->mRenderMatrix.mMatrix);
  513. }
  515. glColor4fv(color.mV);
  516. mVertexBuffer->setBuffer(LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0);
  517. mVertexBuffer->draw(LLRender::TRIANGLES, mIndicesCount, mIndicesIndex);
  519. gGL.popMatrix();
  520. }
  521. }
  524. /* removed in lieu of raycast uv detection
  525. void LLFace::renderSelectedUV()
  526. {
  527. LLViewerTexture* red_blue_imagep = LLViewerTextureManager::getFetchedTextureFromFile("uv_test1.j2c", TRUE, LLViewerTexture::BOOST_UI);
  528. LLViewerTexture* green_imagep = LLViewerTextureManager::getFetchedTextureFromFile("uv_test2.tga", TRUE, LLViewerTexture::BOOST_UI);
  530. LLGLSUVSelect object_select;
  532. // use red/blue gradient to get coarse UV coordinates
  533. renderSelected(red_blue_imagep, LLColor4::white);
  535. static F32 bias = 0.f;
  536. static F32 factor = -10.f;
  537. glPolygonOffset(factor, bias);
  539. // add green dither pattern on top of red/blue gradient
  540. gGL.blendFunc(LLRender::BF_ONE, LLRender::BF_ONE);
  541. glMatrixMode(GL_TEXTURE);
  542. glPushMatrix();
  543. // make green pattern repeat once per texel in red/blue texture
  544. glScalef(256.f, 256.f, 1.f);
  545. glMatrixMode(GL_MODELVIEW);
  547. renderSelected(green_imagep, LLColor4::white);
  549. glMatrixMode(GL_TEXTURE);
  550. glPopMatrix();
  551. glMatrixMode(GL_MODELVIEW);
  552. gGL.blendFunc(LLRender::BF_SOURCE_ALPHA, LLRender::BF_ONE_MINUS_SOURCE_ALPHA);
  553. }
  554. */
  556. void LLFace::setDrawInfo(LLDrawInfo* draw_info)
  557. {
  558. if (draw_info)
  559. {
  560. if (draw_info->mFace)
  561. {
  562. draw_info->mFace->setDrawInfo(NULL);
  563. }
  564. draw_info->mFace = this;
  565. }
  567. if (mDrawInfo)
  568. {
  569. mDrawInfo->mFace = NULL;
  570. }
  572. mDrawInfo = draw_info;
  573. }
  575. void LLFace::printDebugInfo() const
  576. {
  577. LLFacePool *poolp = getPool();
  578. llinfos << "Object: " << getViewerObject()->mID << llendl;
  579. if (getDrawable())
  580. {
  581. llinfos << "Type: " << LLPrimitive::pCodeToString(getDrawable()->getVObj()->getPCode()) << llendl;
  582. }
  583. if (getTexture())
  584. {
  585. llinfos << "Texture: " << getTexture() << " Comps: " << (U32)getTexture()->getComponents() << llendl;
  586. }
  587. else
  588. {
  589. llinfos << "No texture: " << llendl;
  590. }
  592. llinfos << "Face: " << this << llendl;
  593. llinfos << "State: " << getState() << llendl;
  594. llinfos << "Geom Index Data:" << llendl;
  595. llinfos << "--------------------" << llendl;
  596. llinfos << "GI: " << mGeomIndex << " Count:" << mGeomCount << llendl;
  597. llinfos << "Face Index Data:" << llendl;
  598. llinfos << "--------------------" << llendl;
  599. llinfos << "II: " << mIndicesIndex << " Count:" << mIndicesCount << llendl;
  600. llinfos << llendl;
  602. poolp->printDebugInfo();
  604. S32 pool_references = 0;
  605. for (std::vector<LLFace*>::iterator iter = poolp->mReferences.begin();
  606.  iter != poolp->mReferences.end(); iter++)
  607. {
  608. LLFace *facep = *iter;
  609. if (facep == this)
  610. {
  611. llinfos << "Pool reference: " << pool_references << llendl;
  612. pool_references++;
  613. }
  614. }
  616. if (pool_references != 1)
  617. {
  618. llinfos << "Incorrect number of pool references!" << llendl;
  619. }
  621. #if 0
  622. llinfos << "Indices:" << llendl;
  623. llinfos << "--------------------" << llendl;
  625. const U32 *indicesp = getRawIndices();
  626. S32 indices_count = getIndicesCount();
  627. S32 geom_start = getGeomStart();
  629. for (S32 i = 0; i < indices_count; i++)
  630. {
  631. llinfos << i << ":" << indicesp[i] << ":" << (S32)(indicesp[i] - geom_start) << llendl;
  632. }
  633. llinfos << llendl;
  635. llinfos << "Vertices:" << llendl;
  636. llinfos << "--------------------" << llendl;
  637. for (S32 i = 0; i < mGeomCount; i++)
  638. {
  639. llinfos << mGeomIndex + i << ":" << poolp->getVertex(mGeomIndex + i) << llendl;
  640. }
  641. llinfos << llendl;
  642. #endif
  643. }
  645. // Transform the texture coordinates for this face.
  646. static void xform(LLVector2 &tex_coord, F32 cosAng, F32 sinAng, F32 offS, F32 offT, F32 magS, F32 magT)
  647. {
  648. // New, good way
  649. F32 s = tex_coord.mV[0];
  650. F32 t = tex_coord.mV[1];
  652. // Texture transforms are done about the center of the face.
  653. s -= 0.5; 
  654. t -= 0.5;
  656. // Handle rotation
  657. F32 temp = s;
  658. s  = s     * cosAng + t * sinAng;
  659. t  = -temp * sinAng + t * cosAng;
  661. // Then scale
  662. s *= magS;
  663. t *= magT;
  665. // Then offset
  666. s += offS + 0.5f; 
  667. t += offT + 0.5f;
  669. tex_coord.mV[0] = s;
  670. tex_coord.mV[1] = t;
  671. }
  674. BOOL LLFace::genVolumeBBoxes(const LLVolume &volume, S32 f,
  675. const LLMatrix4& mat_vert, const LLMatrix3& mat_normal, BOOL global_volume)
  676. {
  677. LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
  679. //get bounding box
  680. if (mDrawablep->isState(LLDrawable::REBUILD_VOLUME | LLDrawable::REBUILD_POSITION))
  681. {
  682. //if (mDrawablep->isState(LLDrawable::REBUILD_VOLUME))
  683. //{ //vertex buffer no longer valid
  684. // mVertexBuffer = NULL;
  685. // mLastVertexBuffer = NULL;
  686. //}
  688. LLVector3 min,max;
  690. if (f >= volume.getNumVolumeFaces())
  691. {
  692. min = LLVector3(-1,-1,-1);
  693. max = LLVector3(1,1,1);
  694. }
  695. else
  696. {
  697. const LLVolumeFace &face = volume.getVolumeFace(f);
  698. min = face.mExtents[0];
  699. max = face.mExtents[1];
  700. }
  702. //min, max are in volume space, convert to drawable render space
  703. LLVector3 center = ((min + max) * 0.5f)*mat_vert;
  704. LLVector3 size = ((max-min) * 0.5f);
  705. if (!global_volume)
  706. {
  707. size.scaleVec(mDrawablep->getVObj()->getScale());
  708. }
  710. LLMatrix3 mat = mat_normal;
  711. LLVector3 x = mat.getFwdRow();
  712. LLVector3 y = mat.getLeftRow();
  713. LLVector3 z = mat.getUpRow();
  714. x.normVec();
  715. y.normVec();
  716. z.normVec();
  718. mat.setRows(x,y,z);
  720. LLQuaternion rotation = LLQuaternion(mat);
  722. LLVector3 v[4];
  723. //get 4 corners of bounding box
  724. v[0] = (size * rotation);
  725. v[1] = (LLVector3(-size.mV[0], -size.mV[1], size.mV[2]) * rotation);
  726. v[2] = (LLVector3(size.mV[0], -size.mV[1], -size.mV[2]) * rotation);
  727. v[3] = (LLVector3(-size.mV[0], size.mV[1], -size.mV[2]) * rotation);
  729. LLVector3& newMin = mExtents[0];
  730. LLVector3& newMax = mExtents[1];
  732. newMin = newMax = center;
  734. for (U32 i = 0; i < 4; i++)
  735. {
  736. for (U32 j = 0; j < 3; j++)
  737. {
  738. F32 delta = fabsf(v[i].mV[j]);
  739. F32 min = center.mV[j] - delta;
  740. F32 max = center.mV[j] + delta;
  742. if (min < newMin.mV[j])
  743. {
  744. newMin.mV[j] = min;
  745. }
  747. if (max > newMax.mV[j])
  748. {
  749. newMax.mV[j] = max;
  750. }
  751. }
  752. }
  754. if (!mDrawablep->isActive())
  755. {
  756. LLVector3 offset = mDrawablep->getRegion()->getOriginAgent();
  757. newMin += offset;
  758. newMax += offset;
  759. }
  761. mCenterLocal = (newMin+newMax)*0.5f;
  762. LLVector3 tmp = (newMin - newMax) ;
  763. mBoundingSphereRadius = tmp.length() * 0.5f ;
  765. updateCenterAgent();
  766. }
  768. return TRUE;
  769. }
  773. // convert surface coordinates to texture coordinates, based on
  774. // the values in the texture entry.  probably should be
  775. // integrated with getGeometryVolume() for its texture coordinate
  776. // generation - but i'll leave that to someone more familiar
  777. // with the implications.
  778. LLVector2 LLFace::surfaceToTexture(LLVector2 surface_coord, LLVector3 position, LLVector3 normal)
  779. {
  780. LLVector2 tc = surface_coord;
  782. const LLTextureEntry *tep = getTextureEntry();
  784. if (tep == NULL)
  785. {
  786. // can't do much without the texture entry
  787. return surface_coord;
  788. }
  790. // see if we have a non-default mapping
  791.     U8 texgen = getTextureEntry()->getTexGen();
  792. if (texgen != LLTextureEntry::TEX_GEN_DEFAULT)
  793. {
  794. LLVector3 center = mDrawablep->getVOVolume()->getVolume()->getVolumeFace(mTEOffset).mCenter;
  796. LLVector3 scale  = (mDrawablep->getVOVolume()->isVolumeGlobal()) ? LLVector3(1,1,1) : mVObjp->getScale();
  797. LLVector3 volume_position = mDrawablep->getVOVolume()->agentPositionToVolume(position);
  798. volume_position.scaleVec(scale);
  800. LLVector3 volume_normal   = mDrawablep->getVOVolume()->agentDirectionToVolume(normal);
  801. volume_normal.normalize();
  803. switch (texgen)
  804. {
  805. case LLTextureEntry::TEX_GEN_PLANAR:
  806. planarProjection(tc, volume_normal, center, volume_position);
  807. break;
  808. case LLTextureEntry::TEX_GEN_SPHERICAL:
  809. sphericalProjection(tc, volume_normal, center, volume_position);
  810. break;
  811. case LLTextureEntry::TEX_GEN_CYLINDRICAL:
  812. cylindricalProjection(tc, volume_normal, center, volume_position);
  813. break;
  814. default:
  815. break;
  816. }
  817. }
  819. if (mTextureMatrix) // if we have a texture matrix, use it
  820. {
  821. LLVector3 tc3(tc);
  822. tc3 = tc3 * *mTextureMatrix;
  823. tc = LLVector2(tc3);
  824. }
  826. else // otherwise use the texture entry parameters
  827. {
  828. xform(tc, cos(tep->getRotation()), sin(tep->getRotation()),
  829.   tep->mOffsetS, tep->mOffsetT, tep->mScaleS, tep->mScaleT);
  830. }
  833. return tc;
  834. }
  836. void LLFace::updateRebuildFlags()
  837. {
  838. if (!mDrawablep->isState(LLDrawable::REBUILD_VOLUME))
  839. {
  840. BOOL moved = TRUE;
  841. if (mLastVertexBuffer == mVertexBuffer && 
  842. !mVertexBuffer->isEmpty())
  843. { //this face really doesn't need to be regenerated, try real hard not to do so
  844. if (mLastGeomCount == mGeomCount &&
  845. mLastGeomIndex == mGeomIndex &&
  846. mLastIndicesCount == mIndicesCount &&
  847. mLastIndicesIndex == mIndicesIndex)
  848. { //data is in same location in vertex buffer
  849. moved = FALSE;
  850. }
  851. }
  852. mLastMoveTime = gFrameTimeSeconds;
  854. if (moved)
  855. {
  856. mDrawablep->setState(LLDrawable::REBUILD_VOLUME);
  857. }
  858. }
  859. else
  860. {
  861. mLastUpdateTime = gFrameTimeSeconds;
  862. }
  863. }
  865. BOOL LLFace::getGeometryVolume(const LLVolume& volume,
  866.    const S32 &f,
  867. const LLMatrix4& mat_vert, const LLMatrix3& mat_normal,
  868. const U16 &index_offset)
  869. {
  870. llpushcallstacks ;
  871. const LLVolumeFace &vf = volume.getVolumeFace(f);
  872. S32 num_vertices = (S32)vf.mVertices.size();
  873. S32 num_indices = (S32)vf.mIndices.size();
  875. if (mVertexBuffer.notNull())
  876. {
  877. if (num_indices + (S32) mIndicesIndex > mVertexBuffer->getNumIndices())
  878. {
  879. llwarns << "Index buffer overflow!" << llendl;
  880. llwarns << "Indices Count: " << mIndicesCount
  881. << " VF Num Indices: " << num_indices
  882. << " Indices Index: " << mIndicesIndex
  883. << " VB Num Indices: " << mVertexBuffer->getNumIndices() << llendl;
  884. llwarns << "Last Indices Count: " << mLastIndicesCount
  885. << " Last Indices Index: " << mLastIndicesIndex
  886. << " Face Index: " << f
  887. << " Pool Type: " << mPoolType << llendl;
  888. return FALSE;
  889. }
  891. if (num_vertices + mGeomIndex > mVertexBuffer->getNumVerts())
  892. {
  893. llwarns << "Vertex buffer overflow!" << llendl;
  894. return FALSE;
  895. }
  896. }
  898. LLStrider<LLVector3> vertices;
  899. LLStrider<LLVector2> tex_coords;
  900. LLStrider<LLVector2> tex_coords2;
  901. LLStrider<LLVector3> normals;
  902. LLStrider<LLColor4U> colors;
  903. LLStrider<LLVector3> binormals;
  904. LLStrider<U16> indicesp;
  906. BOOL full_rebuild = mDrawablep->isState(LLDrawable::REBUILD_VOLUME);
  908. BOOL global_volume = mDrawablep->getVOVolume()->isVolumeGlobal();
  909. LLVector3 scale;
  910. if (global_volume)
  911. {
  912. scale.setVec(1,1,1);
  913. }
  914. else
  915. {
  916. scale = mVObjp->getScale();
  917. }
  919. BOOL rebuild_pos = full_rebuild || mDrawablep->isState(LLDrawable::REBUILD_POSITION);
  920. BOOL rebuild_color = full_rebuild || mDrawablep->isState(LLDrawable::REBUILD_COLOR);
  921. BOOL rebuild_tcoord = full_rebuild || mDrawablep->isState(LLDrawable::REBUILD_TCOORD);
  922. BOOL rebuild_normal = rebuild_pos && mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_NORMAL);
  923. BOOL rebuild_binormal = rebuild_pos && mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_BINORMAL);
  925. const LLTextureEntry *tep = mVObjp->getTE(f);
  926. U8  bump_code = tep ? tep->getBumpmap() : 0;
  928. if (rebuild_pos)
  929. {
  930. mVertexBuffer->getVertexStrider(vertices, mGeomIndex);
  931. }
  932. if (rebuild_normal)
  933. {
  934. mVertexBuffer->getNormalStrider(normals, mGeomIndex);
  935. }
  936. if (rebuild_binormal)
  937. {
  938. mVertexBuffer->getBinormalStrider(binormals, mGeomIndex);
  939. }
  941. F32 tcoord_xoffset = 0.f ;
  942. F32 tcoord_yoffset = 0.f ;
  943. F32 tcoord_xscale = 1.f ;
  944. F32 tcoord_yscale = 1.f ;
  945. BOOL in_atlas = FALSE ;
  947. if (rebuild_tcoord)
  948. {
  949. mVertexBuffer->getTexCoord0Strider(tex_coords, mGeomIndex);
  950. if (bump_code && mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_TEXCOORD1))
  951. {
  952. mVertexBuffer->getTexCoord1Strider(tex_coords2, mGeomIndex);
  953. }
  955. in_atlas = isAtlasInUse() ;
  956. if(in_atlas)
  957. {
  958. const LLVector2* tmp = getTexCoordOffset() ;
  959. tcoord_xoffset = tmp->mV[0] ; 
  960. tcoord_yoffset = tmp->mV[1] ;
  962. tmp = getTexCoordScale() ;
  963. tcoord_xscale = tmp->mV[0] ; 
  964. tcoord_yscale = tmp->mV[1] ;
  965. }
  966. }
  967. if (rebuild_color)
  968. {
  969. mVertexBuffer->getColorStrider(colors, mGeomIndex);
  970. }
  972. F32 r = 0, os = 0, ot = 0, ms = 0, mt = 0, cos_ang = 0, sin_ang = 0;
  974. BOOL is_static = mDrawablep->isStatic();
  975. BOOL is_global = is_static;
  977. LLVector3 center_sum(0.f, 0.f, 0.f);
  979. if (is_global)
  980. {
  981. setState(GLOBAL);
  982. }
  983. else
  984. {
  985. clearState(GLOBAL);
  986. }
  988. LLVector2 tmin, tmax;
  992. if (rebuild_tcoord)
  993. {
  994. if (tep)
  995. {
  996. r  = tep->getRotation();
  997. os = tep->mOffsetS;
  998. ot = tep->mOffsetT;
  999. ms = tep->mScaleS;
  1000. mt = tep->mScaleT;
  1001. cos_ang = cos(r);
  1002. sin_ang = sin(r);
  1003. }
  1004. else
  1005. {
  1006. cos_ang = 1.0f;
  1007. sin_ang = 0.0f;
  1008. os = 0.0f;
  1009. ot = 0.0f;
  1010. ms = 1.0f;
  1011. mt = 1.0f;
  1012. }
  1013. }
  1015. U8 tex_mode = 0;
  1017. if (isState(TEXTURE_ANIM))
  1018. {
  1019. LLVOVolume* vobj = (LLVOVolume*) (LLViewerObject*) mVObjp;
  1020. tex_mode = vobj->mTexAnimMode;
  1022. if (!tex_mode)
  1023. {
  1024. clearState(TEXTURE_ANIM);
  1025. }
  1026. else
  1027. {
  1028. os = ot = 0.f;
  1029. r = 0.f;
  1030. cos_ang = 1.f;
  1031. sin_ang = 0.f;
  1032. ms = mt = 1.f;
  1033. }
  1035. if (getVirtualSize() >= MIN_TEX_ANIM_SIZE)
  1036. { //don't override texture transform during tc bake
  1037. tex_mode = 0;
  1038. }
  1039. }
  1041. LLColor4U color = tep->getColor();
  1043. if (rebuild_color)
  1044. {
  1045. if (tep)
  1046. {
  1047. GLfloat alpha[4] =
  1048. {
  1049. 0.00f,
  1050. 0.25f,
  1051. 0.5f,
  1052. 0.75f
  1053. };
  1055. if (getPoolType() != LLDrawPool::POOL_ALPHA && (LLPipeline::sRenderDeferred || (LLPipeline::sRenderBump && tep->getShiny())))
  1056. {
  1057. color.mV[3] = U8 (alpha[tep->getShiny()] * 255);
  1058. }
  1059. }
  1060. }
  1062.     // INDICES
  1063. if (full_rebuild)
  1064. {
  1065. mVertexBuffer->getIndexStrider(indicesp, mIndicesIndex);
  1066. for (U16 i = 0; i < num_indices; i++)
  1067. {
  1068. *indicesp++ = vf.mIndices[i] + index_offset;
  1069. }
  1070. }
  1073. //bump setup
  1074. LLVector3 binormal_dir( -sin_ang, cos_ang, 0 );
  1075. LLVector3 bump_s_primary_light_ray;
  1076. LLVector3 bump_t_primary_light_ray;
  1078. LLQuaternion bump_quat;
  1079. if (mDrawablep->isActive())
  1080. {
  1081. bump_quat = LLQuaternion(mDrawablep->getRenderMatrix());
  1082. }
  1084. if (bump_code)
  1085. {
  1086. mVObjp->getVolume()->genBinormals(f);
  1087. F32 offset_multiple; 
  1088. switch( bump_code )
  1089. {
  1090. case BE_NO_BUMP:
  1091. offset_multiple = 0.f;
  1092. break;
  1093. case BE_BRIGHTNESS:
  1094. case BE_DARKNESS:
  1095. if( mTexture.notNull() && mTexture->hasGLTexture())
  1096. {
  1097. // Offset by approximately one texel
  1098. S32 cur_discard = mTexture->getDiscardLevel();
  1099. S32 max_size = llmax( mTexture->getWidth(), mTexture->getHeight() );
  1100. max_size <<= cur_discard;
  1101. const F32 ARTIFICIAL_OFFSET = 2.f;
  1102. offset_multiple = ARTIFICIAL_OFFSET / (F32)max_size;
  1103. }
  1104. else
  1105. {
  1106. offset_multiple = 1.f/256;
  1107. }
  1108. break;
  1110. default:  // Standard bumpmap textures.  Assumed to be 256x256
  1111. offset_multiple = 1.f / 256;
  1112. break;
  1113. }
  1115. F32 s_scale = 1.f;
  1116. F32 t_scale = 1.f;
  1117. if( tep )
  1118. {
  1119. tep->getScale( &s_scale, &t_scale );
  1120. }
  1121. // Use the nudged south when coming from above sun angle, such
  1122. // that emboss mapping always shows up on the upward faces of cubes when 
  1123. // it's noon (since a lot of builders build with the sun forced to noon).
  1124. LLVector3   sun_ray  = gSky.mVOSkyp->mBumpSunDir;
  1125. LLVector3   moon_ray = gSky.getMoonDirection();
  1126. LLVector3& primary_light_ray = (sun_ray.mV[VZ] > 0) ? sun_ray : moon_ray;
  1128. bump_s_primary_light_ray = offset_multiple * s_scale * primary_light_ray;
  1129. bump_t_primary_light_ray = offset_multiple * t_scale * primary_light_ray;
  1130. }
  1132. U8 texgen = getTextureEntry()->getTexGen();
  1133. if (rebuild_tcoord && texgen != LLTextureEntry::TEX_GEN_DEFAULT)
  1134. { //planar texgen needs binormals
  1135. mVObjp->getVolume()->genBinormals(f);
  1136. }
  1138. for (S32 i = 0; i < num_vertices; i++)
  1139. {
  1140. if (rebuild_tcoord)
  1141. {
  1142. LLVector2 tc = vf.mVertices[i].mTexCoord;
  1144. if (texgen != LLTextureEntry::TEX_GEN_DEFAULT)
  1145. {
  1146. LLVector3 vec = vf.mVertices[i].mPosition; 
  1148. vec.scaleVec(scale);
  1150. switch (texgen)
  1151. {
  1152. case LLTextureEntry::TEX_GEN_PLANAR:
  1153. planarProjection(tc, vf.mVertices[i].mNormal, vf.mCenter, vec);
  1154. break;
  1155. case LLTextureEntry::TEX_GEN_SPHERICAL:
  1156. sphericalProjection(tc, vf.mVertices[i].mNormal, vf.mCenter, vec);
  1157. break;
  1158. case LLTextureEntry::TEX_GEN_CYLINDRICAL:
  1159. cylindricalProjection(tc, vf.mVertices[i].mNormal, vf.mCenter, vec);
  1160. break;
  1161. default:
  1162. break;
  1163. }
  1164. }
  1166. if (tex_mode && mTextureMatrix)
  1167. {
  1168. LLVector3 tmp(tc.mV[0], tc.mV[1], 0.f);
  1169. tmp = tmp * *mTextureMatrix;
  1170. tc.mV[0] = tmp.mV[0];
  1171. tc.mV[1] = tmp.mV[1];
  1172. }
  1173. else
  1174. {
  1175. xform(tc, cos_ang, sin_ang, os, ot, ms, mt);
  1176. }
  1178. if(in_atlas)
  1179. {
  1180. //
  1181. //manually calculate tex-coord per vertex for varying address modes.
  1182. //should be removed if shader can handle this.
  1183. //
  1185. S32 int_part = 0 ;
  1186. switch(mTexture->getAddressMode())
  1187. {
  1188. case LLTexUnit::TAM_CLAMP:
  1189. if(tc.mV[0] < 0.f)
  1190. {
  1191. tc.mV[0] = 0.f ;
  1192. }
  1193. else if(tc.mV[0] > 1.f)
  1194. {
  1195. tc.mV[0] = 1.f;
  1196. }
  1198. if(tc.mV[1] < 0.f)
  1199. {
  1200. tc.mV[1] = 0.f ;
  1201. }
  1202. else if(tc.mV[1] > 1.f)
  1203. {
  1204. tc.mV[1] = 1.f;
  1205. }
  1206. break;
  1207. case LLTexUnit::TAM_MIRROR:
  1208. if(tc.mV[0] < 0.f)
  1209. {
  1210. tc.mV[0] = -tc.mV[0] ;
  1211. }
  1212. int_part = (S32)tc.mV[0] ;
  1213. if(int_part & 1) //odd number
  1214. {
  1215. tc.mV[0] = int_part + 1 - tc.mV[0] ;
  1216. }
  1217. else //even number
  1218. {
  1219. tc.mV[0] -= int_part ;
  1220. }
  1222. if(tc.mV[1] < 0.f)
  1223. {
  1224. tc.mV[1] = -tc.mV[1] ;
  1225. }
  1226. int_part = (S32)tc.mV[1] ;
  1227. if(int_part & 1) //odd number
  1228. {
  1229. tc.mV[1] = int_part + 1 - tc.mV[1] ;
  1230. }
  1231. else //even number
  1232. {
  1233. tc.mV[1] -= int_part ;
  1234. }
  1235. break;
  1236. case LLTexUnit::TAM_WRAP:
  1237. if(tc.mV[0] > 1.f)
  1238. tc.mV[0] -= (S32)(tc.mV[0] - 0.00001f) ;
  1239. else if(tc.mV[0] < -1.f)
  1240. tc.mV[0] -= (S32)(tc.mV[0] + 0.00001f) ;
  1242. if(tc.mV[1] > 1.f)
  1243. tc.mV[1] -= (S32)(tc.mV[1] - 0.00001f) ;
  1244. else if(tc.mV[1] < -1.f)
  1245. tc.mV[1] -= (S32)(tc.mV[1] + 0.00001f) ;
  1247. if(tc.mV[0] < 0.f)
  1248. {
  1249. tc.mV[0] = 1.0f + tc.mV[0] ;
  1250. }
  1251. if(tc.mV[1] < 0.f)
  1252. {
  1253. tc.mV[1] = 1.0f + tc.mV[1] ;
  1254. }
  1255. break;
  1256. default:
  1257. break;
  1258. }
  1260. tc.mV[0] = tcoord_xoffset + tcoord_xscale * tc.mV[0] ;
  1261. tc.mV[1] = tcoord_yoffset + tcoord_yscale * tc.mV[1] ;
  1262. }
  1265. *tex_coords++ = tc;
  1267. if (bump_code && mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_TEXCOORD1))
  1268. {
  1269. LLVector3 tangent = vf.mVertices[i].mBinormal % vf.mVertices[i].mNormal;
  1271. LLMatrix3 tangent_to_object;
  1272. tangent_to_object.setRows(tangent, vf.mVertices[i].mBinormal, vf.mVertices[i].mNormal);
  1273. LLVector3 binormal = binormal_dir * tangent_to_object;
  1274. binormal = binormal * mat_normal;
  1276. if (mDrawablep->isActive())
  1277. {
  1278. binormal *= bump_quat;
  1279. }
  1281. binormal.normVec();
  1282. tc += LLVector2( bump_s_primary_light_ray * tangent, bump_t_primary_light_ray * binormal );
  1284. *tex_coords2++ = tc;
  1285. }
  1286. }
  1288. if (rebuild_pos)
  1289. {
  1290. *vertices++ = vf.mVertices[i].mPosition * mat_vert;
  1291. }
  1293. if (rebuild_normal)
  1294. {
  1295. LLVector3 normal = vf.mVertices[i].mNormal * mat_normal;
  1296. normal.normVec();
  1298. *normals++ = normal;
  1299. }
  1301. if (rebuild_binormal)
  1302. {
  1303. LLVector3 binormal = vf.mVertices[i].mBinormal * mat_normal;
  1304. binormal.normVec();
  1305. *binormals++ = binormal;
  1306. }
  1308. if (rebuild_color)
  1309. {
  1310. *colors++ = color;
  1311. }
  1312. }
  1314. if (rebuild_tcoord)
  1315. {
  1316. mTexExtents[0].setVec(0,0);
  1317. mTexExtents[1].setVec(1,1);
  1318. xform(mTexExtents[0], cos_ang, sin_ang, os, ot, ms, mt);
  1319. xform(mTexExtents[1], cos_ang, sin_ang, os, ot, ms, mt);
  1320. }
  1322. mLastVertexBuffer = mVertexBuffer;
  1323. mLastGeomCount = mGeomCount;
  1324. mLastGeomIndex = mGeomIndex;
  1325. mLastIndicesCount = mIndicesCount;
  1326. mLastIndicesIndex = mIndicesIndex;
  1328. return TRUE;
  1329. }
  1331. //check if the face has a media
  1332. BOOL LLFace::hasMedia() const 
  1333. {
  1334. if(mHasMedia)
  1335. {
  1336. return TRUE ;
  1337. }
  1338. if(mTexture.notNull()) 
  1339. {
  1340. return mTexture->hasParcelMedia() ;  //if has a parcel media
  1341. }
  1343. return FALSE ; //no media.
  1344. }
  1346. const F32 LEAST_IMPORTANCE = 0.05f ;
  1347. const F32 LEAST_IMPORTANCE_FOR_LARGE_IMAGE = 0.3f ;
  1349. F32 LLFace::getTextureVirtualSize()
  1350. {
  1351. F32 radius;
  1352. F32 cos_angle_to_view_dir;
  1353. BOOL in_frustum = calcPixelArea(cos_angle_to_view_dir, radius);
  1355. if (mPixelArea < 0.0001f || !in_frustum)
  1356. {
  1357. setVirtualSize(0.f) ;
  1358. return 0.f;
  1359. }
  1361. //get area of circle in texture space
  1362. LLVector2 tdim = mTexExtents[1] - mTexExtents[0];
  1363. F32 texel_area = (tdim * 0.5f).lengthSquared()*3.14159f;
  1364. if (texel_area <= 0)
  1365. {
  1366. // Probably animated, use default
  1367. texel_area = 1.f;
  1368. }
  1370. //apply texel area to face area to get accurate ratio
  1371. //face_area /= llclamp(texel_area, 1.f/64.f, 16.f);
  1372. F32 face_area = mPixelArea / llclamp(texel_area, 0.015625f, 128.f);
  1374. if(face_area > LLViewerTexture::sMaxSmallImageSize)
  1375. {
  1376. if(mImportanceToCamera < LEAST_IMPORTANCE) //if the face is not important, do not load hi-res.
  1377. {
  1378. static const F32 MAX_LEAST_IMPORTANCE_IMAGE_SIZE = 128.0f * 128.0f ;
  1379. face_area = llmin(face_area * 0.5f, MAX_LEAST_IMPORTANCE_IMAGE_SIZE) ;
  1380. }
  1381. else if(face_area > LLViewerTexture::sMinLargeImageSize) //if is large image, shrink face_area by considering the partial overlapping.
  1382. {
  1383. if(mImportanceToCamera < LEAST_IMPORTANCE_FOR_LARGE_IMAGE)//if the face is not important, do not load hi-res.
  1384. {
  1385. face_area = LLViewerTexture::sMinLargeImageSize ;
  1386. }
  1387. else if(mTexture.notNull() && mTexture->isLargeImage())
  1388. {
  1389. face_area *= adjustPartialOverlapPixelArea(cos_angle_to_view_dir, radius );
  1390. }
  1391. }
  1392. }
  1394. setVirtualSize(face_area) ;
  1396. return face_area;
  1397. }
  1399. BOOL LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
  1400. {
  1401. //get area of circle around face
  1402. LLVector3 center = getPositionAgent();
  1403. LLVector3 size = (mExtents[1] - mExtents[0]) * 0.5f;
  1404. LLViewerCamera* camera = LLViewerCamera::getInstance();
  1406. F32 size_squared = size.lengthSquared() ;
  1407. LLVector3 lookAt = center - camera->getOrigin();
  1408. F32 dist = lookAt.normVec() ;
  1410. //get area of circle around node
  1411. F32 app_angle = atanf(fsqrtf(size_squared) / dist);
  1412. radius = app_angle*LLDrawable::sCurPixelAngle;
  1413. mPixelArea = radius*radius * 3.14159f;
  1414. cos_angle_to_view_dir = lookAt * camera->getXAxis() ;
  1416. //if has media, check if the face is out of the view frustum.
  1417. if(hasMedia())
  1418. {
  1419. if(!camera->AABBInFrustum(center, size)) 
  1420. {
  1421. mImportanceToCamera = 0.f ;
  1422. return false ;
  1423. }
  1424. if(cos_angle_to_view_dir > camera->getCosHalfFov()) //the center is within the view frustum
  1425. {
  1426. cos_angle_to_view_dir = 1.0f ;
  1427. }
  1428. else
  1429. {
  1430. if(dist * dist * (lookAt - camera->getXAxis()).lengthSquared() < size_squared)
  1431. {
  1432. cos_angle_to_view_dir = 1.0f ;
  1433. }
  1434. }
  1435. }
  1437. if(dist < mBoundingSphereRadius) //camera is very close
  1438. {
  1439. cos_angle_to_view_dir = 1.0f ;
  1440. mImportanceToCamera = 1.0f ;
  1441. }
  1442. else
  1443. {
  1444. mImportanceToCamera = LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist) ;
  1445. }
  1447. return true ;
  1448. }
  1450. //the projection of the face partially overlaps with the screen
  1451. F32 LLFace::adjustPartialOverlapPixelArea(F32 cos_angle_to_view_dir, F32 radius )
  1452. {
  1453. F32 screen_radius = (F32)llmax(gViewerWindow->getWindowWidthRaw(), gViewerWindow->getWindowHeightRaw()) ;
  1454. F32 center_angle = acosf(cos_angle_to_view_dir) ;
  1455. F32 d = center_angle * LLDrawable::sCurPixelAngle ;
  1457. if(d + radius > screen_radius + 5.f)
  1458. {
  1459. //----------------------------------------------
  1460. //calculate the intersection area of two circles
  1461. //F32 radius_square = radius * radius ;
  1462. //F32 d_square = d * d ;
  1463. //F32 screen_radius_square = screen_radius * screen_radius ;
  1464. //face_area = 
  1465. // radius_square * acosf((d_square + radius_square - screen_radius_square)/(2 * d * radius)) +
  1466. // screen_radius_square * acosf((d_square + screen_radius_square - radius_square)/(2 * d * screen_radius)) -
  1467. // 0.5f * sqrtf((-d + radius + screen_radius) * (d + radius - screen_radius) * (d - radius + screen_radius) * (d + radius + screen_radius)) ;
  1468. //----------------------------------------------
  1470. //the above calculation is too expensive
  1471. //the below is a good estimation: bounding box of the bounding sphere:
  1472. F32 alpha = 0.5f * (radius + screen_radius - d) / radius ;
  1473. alpha = llclamp(alpha, 0.f, 1.f) ;
  1474. return alpha * alpha ;
  1475. }
  1476. return 1.0f ;
  1477. }
  1479. const S8 FACE_IMPORTANCE_LEVEL = 4 ;
  1480. const F32 FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL][2] = //{distance, importance_weight}
  1481. {{16.1f, 1.0f}, {32.1f, 0.5f}, {48.1f, 0.2f}, {96.1f, 0.05f} } ;
  1482. const F32 FACE_IMPORTANCE_TO_CAMERA_OVER_ANGLE[FACE_IMPORTANCE_LEVEL][2] =    //{cos(angle), importance_weight}
  1483. {{0.985f /*cos(10 degrees)*/, 1.0f}, {0.94f /*cos(20 degrees)*/, 0.8f}, {0.866f /*cos(30 degrees)*/, 0.64f}, {0.0f, 0.36f}} ;
  1485. //static 
  1486. F32 LLFace::calcImportanceToCamera(F32 cos_angle_to_view_dir, F32 dist)
  1487. {
  1488. F32 importance = 0.f ;
  1490. if(cos_angle_to_view_dir > LLViewerCamera::getInstance()->getCosHalfFov() && 
  1491. dist < FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL - 1][0]) 
  1492. {
  1493. LLViewerCamera* camera = LLViewerCamera::getInstance();
  1494. F32 camera_moving_speed = camera->getAverageSpeed() ;
  1495. F32 camera_angular_speed = camera->getAverageAngularSpeed();
  1497. if(camera_moving_speed > 10.0f || camera_angular_speed > 1.0f)
  1498. {
  1499. //if camera moves or rotates too fast, ignore the importance factor
  1500. return 0.f ;
  1501. }
  1503. //F32 camera_relative_speed = camera_moving_speed * (lookAt * LLViewerCamera::getInstance()->getVelocityDir()) ;
  1505. S32 i = 0 ;
  1506. for(i = 0; i < FACE_IMPORTANCE_LEVEL && dist > FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[i][0]; ++i);
  1507. i = llmin(i, FACE_IMPORTANCE_LEVEL - 1) ;
  1508. F32 dist_factor = FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[i][1] ;
  1510. for(i = 0; i < FACE_IMPORTANCE_LEVEL && cos_angle_to_view_dir < FACE_IMPORTANCE_TO_CAMERA_OVER_ANGLE[i][0] ; ++i) ;
  1511. i = llmin(i, FACE_IMPORTANCE_LEVEL - 1) ;
  1512. importance = dist_factor * FACE_IMPORTANCE_TO_CAMERA_OVER_ANGLE[i][1] ;
  1513. }
  1515. return importance ;
  1516. }
  1518. BOOL LLFace::verify(const U32* indices_array) const
  1519. {
  1520. BOOL ok = TRUE;
  1522. if( mVertexBuffer.isNull() )
  1523. {
  1524. if( mGeomCount )
  1525. {
  1526. // This happens before teleports as faces are torn down.
  1527. // Stop the crash in DEV-31893 with a null pointer check,
  1528. // but present this info.
  1529. // To clean up the log, the geometry could be cleared, or the
  1530. // face could otherwise be marked for no ::verify.
  1531. llinfos << "Face with no vertex buffer and " << mGeomCount << " mGeomCount" << llendl;
  1532. }
  1533. return TRUE;
  1534. }
  1536. // First, check whether the face data fits within the pool's range.
  1537. if ((mGeomIndex + mGeomCount) > mVertexBuffer->getNumVerts())
  1538. {
  1539. ok = FALSE;
  1540. llinfos << "Face not within pool range!" << llendl;
  1541. }
  1543. S32 indices_count = (S32)getIndicesCount();
  1545. if (!indices_count)
  1546. {
  1547. return TRUE;
  1548. }
  1550. if (indices_count > LL_MAX_INDICES_COUNT)
  1551. {
  1552. ok = FALSE;
  1553. llinfos << "Face has bogus indices count" << llendl;
  1554. }
  1556. #if 0
  1557. S32 geom_start = getGeomStart();
  1558. S32 geom_count = mGeomCount;
  1560. const U32 *indicesp = indices_array ? indices_array + mIndicesIndex : getRawIndices();
  1562. for (S32 i = 0; i < indices_count; i++)
  1563. {
  1564. S32 delta = indicesp[i] - geom_start;
  1565. if (0 > delta)
  1566. {
  1567. llwarns << "Face index too low!" << llendl;
  1568. llinfos << "i:" << i << " Index:" << indicesp[i] << " GStart: " << geom_start << llendl;
  1569. ok = FALSE;
  1570. }
  1571. else if (delta >= geom_count)
  1572. {
  1573. llwarns << "Face index too high!" << llendl;
  1574. llinfos << "i:" << i << " Index:" << indicesp[i] << " GEnd: " << geom_start + geom_count << llendl;
  1575. ok = FALSE;
  1576. }
  1577. }
  1578. #endif
  1580. if (!ok)
  1581. {
  1582. printDebugInfo();
  1583. }
  1584. return ok;
  1585. }
  1588. void LLFace::setViewerObject(LLViewerObject* objp)
  1589. {
  1590. mVObjp = objp;
  1591. }
  1593. const LLColor4& LLFace::getRenderColor() const
  1594. {
  1595. if (isState(USE_FACE_COLOR))
  1596. {
  1597.   return mFaceColor; // Face Color
  1598. }
  1599. else
  1600. {
  1601. const LLTextureEntry* tep = getTextureEntry();
  1602. return (tep ? tep->getColor() : LLColor4::white);
  1603. }
  1604. }
  1606. void LLFace::renderSetColor() const
  1607. {
  1608. if (!LLFacePool::LLOverrideFaceColor::sOverrideFaceColor)
  1609. {
  1610. const LLColor4* color = &(getRenderColor());
  1612. glColor4fv(color->mV);
  1613. }
  1614. }
  1616. S32 LLFace::pushVertices(const U16* index_array) const
  1617. {
  1618. if (mIndicesCount)
  1619. {
  1620. mVertexBuffer->drawRange(LLRender::TRIANGLES, mGeomIndex, mGeomIndex+mGeomCount-1, mIndicesCount, mIndicesIndex);
  1621. gPipeline.addTrianglesDrawn(mIndicesCount/3);
  1622. }
  1624. return mIndicesCount;
  1625. }
  1627. const LLMatrix4& LLFace::getRenderMatrix() const
  1628. {
  1629. return mDrawablep->getRenderMatrix();
  1630. }
  1632. S32 LLFace::renderElements(const U16 *index_array) const
  1633. {
  1634. S32 ret = 0;
  1636. if (isState(GLOBAL))
  1637. {
  1638. ret = pushVertices(index_array);
  1639. }
  1640. else
  1641. {
  1642. glPushMatrix();
  1643. glMultMatrixf((float*)getRenderMatrix().mMatrix);
  1644. ret = pushVertices(index_array);
  1645. glPopMatrix();
  1646. }
  1648. return ret;
  1649. }
  1651. S32 LLFace::renderIndexed()
  1652. {
  1653. if(mDrawablep.isNull() || mDrawPoolp == NULL)
  1654. {
  1655. return 0;
  1656. }
  1658. return renderIndexed(mDrawPoolp->getVertexDataMask());
  1659. }
  1661. S32 LLFace::renderIndexed(U32 mask)
  1662. {
  1663. if (mVertexBuffer.isNull())
  1664. {
  1665. return 0;
  1666. }
  1668. mVertexBuffer->setBuffer(mask);
  1669. U16* index_array = (U16*) mVertexBuffer->getIndicesPointer();
  1670. return renderElements(index_array);
  1671. }
  1673. //============================================================================
  1674. // From llface.inl
  1676. S32 LLFace::getColors(LLStrider<LLColor4U> &colors)
  1677. {
  1678. if (!mGeomCount)
  1679. {
  1680. return -1;
  1681. }
  1683. // llassert(mGeomIndex >= 0);
  1684. mVertexBuffer->getColorStrider(colors, mGeomIndex);
  1685. return mGeomIndex;
  1686. }
  1688. S32 LLFace::getIndices(LLStrider<U16> &indicesp)
  1689. {
  1690. mVertexBuffer->getIndexStrider(indicesp, mIndicesIndex);
  1691. llassert(indicesp[0] != indicesp[1]);
  1692. return mIndicesIndex;
  1693. }
  1695. LLVector3 LLFace::getPositionAgent() const
  1696. {
  1697. if (mDrawablep->isStatic())
  1698. {
  1699. return mCenterAgent;
  1700. }
  1701. else
  1702. {
  1703. return mCenterLocal * getRenderMatrix();
  1704. }
  1705. }
  1707. //
  1708. //atlas
  1709. //
  1710. void LLFace::removeAtlas()
  1711. {
  1712. setAtlasInUse(FALSE) ;
  1713. mAtlasInfop = NULL ;
  1714. }
  1716. const LLTextureAtlas* LLFace::getAtlas()const 
  1717. {
  1718. if(mAtlasInfop)
  1719. {
  1720. return mAtlasInfop->getAtlas() ;
  1721. }
  1722. return NULL ;
  1723. }
  1725. const LLVector2* LLFace::getTexCoordOffset()const 
  1726. {
  1727. if(isAtlasInUse())
  1728. {
  1729. return mAtlasInfop->getTexCoordOffset() ;
  1730. }
  1731. return NULL ;
  1732. }
  1733. const LLVector2* LLFace::getTexCoordScale() const 
  1734. {
  1735. if(isAtlasInUse())
  1736. {
  1737. return mAtlasInfop->getTexCoordScale() ;
  1738. }
  1739. return NULL ;
  1740. }
  1742. BOOL LLFace::isAtlasInUse()const
  1743. {
  1744. return mUsingAtlas ;
  1745. }
  1747. BOOL LLFace::canUseAtlas()const
  1748. {
  1749. //no drawable or no spatial group, do not use atlas
  1750. if(!mDrawablep || !mDrawablep->getSpatialGroup())
  1751. {
  1752. return FALSE ;
  1753. }
  1755. //if bump face, do not use atlas
  1756. if(getTextureEntry() && getTextureEntry()->getBumpmap())
  1757. {
  1758. return FALSE ;
  1759. }
  1761. //if animated texture, do not use atlas
  1762. if(isState(TEXTURE_ANIM))
  1763. {
  1764. return FALSE ;
  1765. }
  1767. return TRUE ;
  1768. }
  1770. void LLFace::setAtlasInUse(BOOL flag)
  1771. {
  1772. //no valid atlas to use.
  1773. if(flag && (!mAtlasInfop || !mAtlasInfop->isValid()))
  1774. {
  1775. flag = FALSE ;
  1776. }
  1778. if(!flag && !mUsingAtlas)
  1779. {
  1780. return ;
  1781. }
  1783. //
  1784. //at this stage (flag || mUsingAtlas) is always true.
  1785. //
  1787. //rebuild the tex coords
  1788. if(mDrawablep)
  1789. {
  1790. gPipeline.markRebuild(mDrawablep, LLDrawable::REBUILD_TCOORD);
  1791. mUsingAtlas = flag ;
  1792. }
  1793. else
  1794. {
  1795. mUsingAtlas = FALSE ;
  1796. }
  1797. }
  1799. LLTextureAtlasSlot* LLFace::getAtlasInfo()
  1800. {
  1801. return mAtlasInfop ;
  1802. }
  1804. void LLFace::setAtlasInfo(LLTextureAtlasSlot* atlasp)
  1805. {
  1806. if(mAtlasInfop != atlasp)
  1807. {
  1808. if(mAtlasInfop)
  1809. {
  1810. //llerrs << "Atlas slot changed!" << llendl ;
  1811. }
  1812. mAtlasInfop = atlasp ;
  1813. }
  1814. }
  1816. LLViewerTexture* LLFace::getTexture() const
  1817. {
  1818. if(isAtlasInUse())
  1819. {
  1820. return (LLViewerTexture*)mAtlasInfop->getAtlas() ;
  1821. }
  1823. return mTexture ;
  1824. }
  1826. //switch to atlas or switch back to gl texture 
  1827. //return TRUE if using atlas.
  1828. BOOL LLFace::switchTexture()
  1829. {
  1830. //no valid atlas or texture
  1831. if(!mAtlasInfop || !mAtlasInfop->isValid() || !mTexture)
  1832. {
  1833. return FALSE ;
  1834. }
  1836. if(mTexture->getTexelsInAtlas() >= (U32)mVSize || 
  1837. mTexture->getTexelsInAtlas() >= mTexture->getTexelsInGLTexture())
  1838. {
  1839. //switch to use atlas
  1840. //atlas resolution is qualified, use it.
  1841. if(!mUsingAtlas)
  1842. {
  1843. setAtlasInUse(TRUE) ;
  1844. }
  1845. }
  1846. else //if atlas not qualified.
  1847. {
  1848. //switch back to GL texture
  1849. if(mUsingAtlas && mTexture->isGLTextureCreated() && 
  1850. mTexture->getDiscardLevel() < mTexture->getDiscardLevelInAtlas())
  1851. {
  1852. setAtlasInUse(FALSE) ;
  1853. }
  1854. }
  1856. return mUsingAtlas ;
  1857. }