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

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

游戏引擎

开发平台：

C++ Builder

llviewerjointmesh.cpp：源码内容
  1. /** 
  2.  * @file llviewerjointmesh.cpp
  3.  * @brief Implementation of LLViewerJointMesh class
  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. //-----------------------------------------------------------------------------
  34. // Header Files
  35. //-----------------------------------------------------------------------------
  36. #include "llviewerprecompiledheaders.h"
  38. #include "imageids.h"
  39. #include "llfasttimer.h"
  40. #include "llrender.h"
  42. #include "llapr.h"
  43. #include "llbox.h"
  44. #include "lldrawable.h"
  45. #include "lldrawpoolavatar.h"
  46. #include "lldrawpoolbump.h"
  47. #include "lldynamictexture.h"
  48. #include "llface.h"
  49. #include "llgldbg.h"
  50. #include "llglheaders.h"
  51. #include "lltexlayer.h"
  52. #include "llviewercamera.h"
  53. #include "llviewercontrol.h"
  54. #include "llviewertexturelist.h"
  55. #include "llviewerjointmesh.h"
  56. #include "llvoavatar.h"
  57. #include "llsky.h"
  58. #include "pipeline.h"
  59. #include "llviewershadermgr.h"
  60. #include "llmath.h"
  61. #include "v4math.h"
  62. #include "m3math.h"
  63. #include "m4math.h"
  65. #if !LL_DARWIN && !LL_LINUX && !LL_SOLARIS
  66. extern PFNGLWEIGHTPOINTERARBPROC glWeightPointerARB;
  67. extern PFNGLWEIGHTFVARBPROC glWeightfvARB;
  68. extern PFNGLVERTEXBLENDARBPROC glVertexBlendARB;
  69. #endif
  70. extern BOOL gRenderForSelect;
  72. static LLPointer<LLVertexBuffer> sRenderBuffer = NULL;
  73. static const U32 sRenderMask = LLVertexBuffer::MAP_VERTEX |
  74.    LLVertexBuffer::MAP_NORMAL |
  75.    LLVertexBuffer::MAP_TEXCOORD0;
  78. //-----------------------------------------------------------------------------
  79. //-----------------------------------------------------------------------------
  80. // LLViewerJointMesh::LLSkinJoint
  81. //-----------------------------------------------------------------------------
  82. //-----------------------------------------------------------------------------
  84. //-----------------------------------------------------------------------------
  85. // LLSkinJoint
  86. //-----------------------------------------------------------------------------
  87. LLSkinJoint::LLSkinJoint()
  88. {
  89. mJoint       = NULL;
  90. }
  92. //-----------------------------------------------------------------------------
  93. // ~LLSkinJoint
  94. //-----------------------------------------------------------------------------
  95. LLSkinJoint::~LLSkinJoint()
  96. {
  97. mJoint = NULL;
  98. }
  101. //-----------------------------------------------------------------------------
  102. // LLSkinJoint::setupSkinJoint()
  103. //-----------------------------------------------------------------------------
  104. BOOL LLSkinJoint::setupSkinJoint( LLViewerJoint *joint)
  105. {
  106. // find the named joint
  107. mJoint = joint;
  108. if ( !mJoint )
  109. {
  110. llinfos << "Can't find joint" << llendl;
  111. }
  113. // compute the inverse root skin matrix
  114. mRootToJointSkinOffset.clearVec();
  116. LLVector3 rootSkinOffset;
  117. while (joint)
  118. {
  119. rootSkinOffset += joint->getSkinOffset();
  120. joint = (LLViewerJoint*)joint->getParent();
  121. }
  123. mRootToJointSkinOffset = -rootSkinOffset;
  124. mRootToParentJointSkinOffset = mRootToJointSkinOffset;
  125. mRootToParentJointSkinOffset += mJoint->getSkinOffset();
  127. return TRUE;
  128. }
  131. //-----------------------------------------------------------------------------
  132. //-----------------------------------------------------------------------------
  133. // LLViewerJointMesh
  134. //-----------------------------------------------------------------------------
  135. //-----------------------------------------------------------------------------
  137. BOOL LLViewerJointMesh::sPipelineRender = FALSE;
  138. EAvatarRenderPass LLViewerJointMesh::sRenderPass = AVATAR_RENDER_PASS_SINGLE;
  139. U32 LLViewerJointMesh::sClothingMaskImageName = 0;
  140. LLColor4 LLViewerJointMesh::sClothingInnerColor;
  142. //-----------------------------------------------------------------------------
  143. // LLViewerJointMesh()
  144. //-----------------------------------------------------------------------------
  145. LLViewerJointMesh::LLViewerJointMesh()
  146. :
  147. mTexture( NULL ),
  148. mLayerSet( NULL ),
  149. mTestImageName( 0 ),
  150. mFaceIndexCount(0),
  151. mIsTransparent(FALSE)
  152. {
  154. mColor[0] = 1.0f;
  155. mColor[1] = 1.0f;
  156. mColor[2] = 1.0f;
  157. mColor[3] = 1.0f;
  158. mShiny = 0.0f;
  159. mCullBackFaces = TRUE;
  161. mMesh = NULL;
  163. mNumSkinJoints = 0;
  164. mSkinJoints = NULL;
  166. mFace = NULL;
  168. mMeshID = 0;
  169. mUpdateXform = FALSE;
  171. mValid = FALSE;
  172. }
  175. //-----------------------------------------------------------------------------
  176. // ~LLViewerJointMesh()
  177. // Class Destructor
  178. //-----------------------------------------------------------------------------
  179. LLViewerJointMesh::~LLViewerJointMesh()
  180. {
  181. mMesh = NULL;
  182. mTexture = NULL;
  183. freeSkinData();
  184. }
  187. //-----------------------------------------------------------------------------
  188. // LLViewerJointMesh::allocateSkinData()
  189. //-----------------------------------------------------------------------------
  190. BOOL LLViewerJointMesh::allocateSkinData( U32 numSkinJoints )
  191. {
  192. mSkinJoints = new LLSkinJoint[ numSkinJoints ];
  193. mNumSkinJoints = numSkinJoints;
  194. return TRUE;
  195. }
  197. //-----------------------------------------------------------------------------
  198. // LLViewerJointMesh::freeSkinData()
  199. //-----------------------------------------------------------------------------
  200. void LLViewerJointMesh::freeSkinData()
  201. {
  202. mNumSkinJoints = 0;
  203. delete [] mSkinJoints;
  204. mSkinJoints = NULL;
  205. }
  207. //--------------------------------------------------------------------
  208. // LLViewerJointMesh::getColor()
  209. //--------------------------------------------------------------------
  210. void LLViewerJointMesh::getColor( F32 *red, F32 *green, F32 *blue, F32 *alpha )
  211. {
  212. *red   = mColor[0];
  213. *green = mColor[1];
  214. *blue  = mColor[2];
  215. *alpha = mColor[3];
  216. }
  218. //--------------------------------------------------------------------
  219. // LLViewerJointMesh::setColor()
  220. //--------------------------------------------------------------------
  221. void LLViewerJointMesh::setColor( F32 red, F32 green, F32 blue, F32 alpha )
  222. {
  223. mColor[0] = red;
  224. mColor[1] = green;
  225. mColor[2] = blue;
  226. mColor[3] = alpha;
  227. }
  230. //--------------------------------------------------------------------
  231. // LLViewerJointMesh::getTexture()
  232. //--------------------------------------------------------------------
  233. //LLViewerTexture *LLViewerJointMesh::getTexture()
  234. //{
  235. // return mTexture;
  236. //}
  238. //--------------------------------------------------------------------
  239. // LLViewerJointMesh::setTexture()
  240. //--------------------------------------------------------------------
  241. void LLViewerJointMesh::setTexture( LLViewerTexture *texture )
  242. {
  243. mTexture = texture;
  245. // texture and dynamic_texture are mutually exclusive
  246. if( texture )
  247. {
  248. mLayerSet = NULL;
  249. //texture->bindTexture(0);
  250. //texture->setClamp(TRUE, TRUE);
  251. }
  252. }
  254. //--------------------------------------------------------------------
  255. // LLViewerJointMesh::setLayerSet()
  256. // Sets the shape texture (takes precedence over normal texture)
  257. //--------------------------------------------------------------------
  258. void LLViewerJointMesh::setLayerSet( LLTexLayerSet* layer_set )
  259. {
  260. mLayerSet = layer_set;
  262. // texture and dynamic_texture are mutually exclusive
  263. if( layer_set )
  264. {
  265. mTexture = NULL;
  266. }
  267. }
  271. //--------------------------------------------------------------------
  272. // LLViewerJointMesh::getMesh()
  273. //--------------------------------------------------------------------
  274. LLPolyMesh *LLViewerJointMesh::getMesh()
  275. {
  276. return mMesh;
  277. }
  279. //-----------------------------------------------------------------------------
  280. // LLViewerJointMesh::setMesh()
  281. //-----------------------------------------------------------------------------
  282. void LLViewerJointMesh::setMesh( LLPolyMesh *mesh )
  283. {
  284. // set the mesh pointer
  285. mMesh = mesh;
  287. // release any existing skin joints
  288. freeSkinData();
  290. if ( mMesh == NULL )
  291. {
  292. return;
  293. }
  295. // acquire the transform from the mesh object
  296. setPosition( mMesh->getPosition() );
  297. setRotation( mMesh->getRotation() );
  298. setScale( mMesh->getScale() );
  300. // create skin joints if necessary
  301. if ( mMesh->hasWeights() && !mMesh->isLOD())
  302. {
  303. U32 numJointNames = mMesh->getNumJointNames();
  305. allocateSkinData( numJointNames );
  306. std::string *jointNames = mMesh->getJointNames();
  308. U32 jn;
  309. for (jn = 0; jn < numJointNames; jn++)
  310. {
  311. //llinfos << "Setting up joint " << jointNames[jn] << llendl;
  312. LLViewerJoint* joint = (LLViewerJoint*)(getRoot()->findJoint(jointNames[jn]) );
  313. mSkinJoints[jn].setupSkinJoint( joint );
  314. }
  315. }
  317. // setup joint array
  318. if (!mMesh->isLOD())
  319. {
  320. setupJoint((LLViewerJoint*)getRoot());
  321. }
  323. // llinfos << "joint render entries: " << mMesh->mJointRenderData.count() << llendl;
  324. }
  326. //-----------------------------------------------------------------------------
  327. // setupJoint()
  328. //-----------------------------------------------------------------------------
  329. void LLViewerJointMesh::setupJoint(LLViewerJoint* current_joint)
  330. {
  331. // llinfos << "Mesh: " << getName() << llendl;
  333. // S32 joint_count = 0;
  334. U32 sj;
  335. for (sj=0; sj<mNumSkinJoints; sj++)
  336. {
  337. LLSkinJoint &js = mSkinJoints[sj];
  339. if (js.mJoint != current_joint)
  340. {
  341. continue;
  342. }
  344. // we've found a skinjoint for this joint..
  346. // is the last joint in the array our parent?
  347. if(mMesh->mJointRenderData.count() && mMesh->mJointRenderData[mMesh->mJointRenderData.count() - 1]->mWorldMatrix == &current_joint->getParent()->getWorldMatrix())
  348. {
  349. // ...then just add ourselves
  350. LLViewerJoint* jointp = js.mJoint;
  351. mMesh->mJointRenderData.put(new LLJointRenderData(&jointp->getWorldMatrix(), &js));
  352. // llinfos << "joint " << joint_count << js.mJoint->getName() << llendl;
  353. // joint_count++;
  354. }
  355. // otherwise add our parent and ourselves
  356. else
  357. {
  358. mMesh->mJointRenderData.put(new LLJointRenderData(&current_joint->getParent()->getWorldMatrix(), NULL));
  359. // llinfos << "joint " << joint_count << current_joint->getParent()->getName() << llendl;
  360. // joint_count++;
  361. mMesh->mJointRenderData.put(new LLJointRenderData(&current_joint->getWorldMatrix(), &js));
  362. // llinfos << "joint " << joint_count << current_joint->getName() << llendl;
  363. // joint_count++;
  364. }
  365. }
  367. // depth-first traversal
  368. for (LLJoint::child_list_t::iterator iter = current_joint->mChildren.begin();
  369.  iter != current_joint->mChildren.end(); ++iter)
  370. {
  371. LLViewerJoint* child_joint = (LLViewerJoint*)(*iter);
  372. setupJoint(child_joint);
  373. }
  374. }
  376. const S32 NUM_AXES = 3;
  378. // register layoud
  379. // rotation X 0-n
  380. // rotation Y 0-n
  381. // rotation Z 0-n
  382. // pivot parent 0-n -- child = n+1
  384. static LLMatrix4 gJointMatUnaligned[32];
  385. static LLMatrix3 gJointRotUnaligned[32];
  386. static LLVector4 gJointPivot[32];
  388. //-----------------------------------------------------------------------------
  389. // uploadJointMatrices()
  390. //-----------------------------------------------------------------------------
  391. void LLViewerJointMesh::uploadJointMatrices()
  392. {
  393. S32 joint_num;
  394. LLPolyMesh *reference_mesh = mMesh->getReferenceMesh();
  395. LLDrawPool *poolp = mFace ? mFace->getPool() : NULL;
  396. BOOL hardware_skinning = (poolp && poolp->getVertexShaderLevel() > 0) ? TRUE : FALSE;
  398. //calculate joint matrices
  399. for (joint_num = 0; joint_num < reference_mesh->mJointRenderData.count(); joint_num++)
  400. {
  401. LLMatrix4 joint_mat = *reference_mesh->mJointRenderData[joint_num]->mWorldMatrix;
  403. if (hardware_skinning)
  404. {
  405. joint_mat *= LLDrawPoolAvatar::getModelView();
  406. }
  407. gJointMatUnaligned[joint_num] = joint_mat;
  408. gJointRotUnaligned[joint_num] = joint_mat.getMat3();
  409. }
  411. BOOL last_pivot_uploaded = FALSE;
  412. S32 j = 0;
  414. //upload joint pivots
  415. for (joint_num = 0; joint_num < reference_mesh->mJointRenderData.count(); joint_num++)
  416. {
  417. LLSkinJoint *sj = reference_mesh->mJointRenderData[joint_num]->mSkinJoint;
  418. if (sj)
  419. {
  420. if (!last_pivot_uploaded)
  421. {
  422. LLVector4 parent_pivot(sj->mRootToParentJointSkinOffset);
  423. parent_pivot.mV[VW] = 0.f;
  424. gJointPivot[j++] = parent_pivot;
  425. }
  427. LLVector4 child_pivot(sj->mRootToJointSkinOffset);
  428. child_pivot.mV[VW] = 0.f;
  430. gJointPivot[j++] = child_pivot;
  432. last_pivot_uploaded = TRUE;
  433. }
  434. else
  435. {
  436. last_pivot_uploaded = FALSE;
  437. }
  438. }
  440. //add pivot point into transform
  441. for (S32 i = 0; i < j; i++)
  442. {
  443. LLVector3 pivot;
  444. pivot = LLVector3(gJointPivot[i]);
  445. pivot = pivot * gJointRotUnaligned[i];
  446. gJointMatUnaligned[i].translate(pivot);
  447. }
  449. // upload matrices
  450. if (hardware_skinning)
  451. {
  452. GLfloat mat[45*4];
  453. memset(mat, 0, sizeof(GLfloat)*45*4);
  455. for (joint_num = 0; joint_num < reference_mesh->mJointRenderData.count(); joint_num++)
  456. {
  457. gJointMatUnaligned[joint_num].transpose();
  459. for (S32 axis = 0; axis < NUM_AXES; axis++)
  460. {
  461. F32* vector = gJointMatUnaligned[joint_num].mMatrix[axis];
  462. U32 offset = LL_CHARACTER_MAX_JOINTS_PER_MESH*axis+joint_num;
  463. memcpy(mat+offset*4, vector, sizeof(GLfloat)*4);
  464. }
  465. }
  466. stop_glerror();
  467. glUniform4fvARB(gAvatarMatrixParam, 45, mat);
  468. stop_glerror();
  469. }
  470. }
  472. //--------------------------------------------------------------------
  473. // LLViewerJointMesh::drawBone()
  474. //--------------------------------------------------------------------
  475. void LLViewerJointMesh::drawBone()
  476. {
  477. }
  479. //--------------------------------------------------------------------
  480. // LLViewerJointMesh::isTransparent()
  481. //--------------------------------------------------------------------
  482. BOOL LLViewerJointMesh::isTransparent()
  483. {
  484. return mIsTransparent;
  485. }
  487. //--------------------------------------------------------------------
  488. // DrawElementsBLEND and utility code
  489. //--------------------------------------------------------------------
  491. // compate_int is used by the qsort function to sort the index array
  492. int compare_int(const void *a, const void *b)
  493. {
  494. if (*(U32*)a < *(U32*)b)
  495. {
  496. return -1;
  497. }
  498. else if (*(U32*)a > *(U32*)b)
  499. {
  500. return 1;
  501. }
  502. else return 0;
  503. }
  505. //--------------------------------------------------------------------
  506. // LLViewerJointMesh::drawShape()
  507. //--------------------------------------------------------------------
  508. U32 LLViewerJointMesh::drawShape( F32 pixelArea, BOOL first_pass, BOOL is_dummy)
  509. {
  510. if (!mValid || !mMesh || !mFace || !mVisible || 
  511. mFace->mVertexBuffer.isNull() ||
  512. mMesh->getNumFaces() == 0) 
  513. {
  514. return 0;
  515. }
  517. U32 triangle_count = 0;
  519. stop_glerror();
  521. //----------------------------------------------------------------
  522. // setup current color
  523. //----------------------------------------------------------------
  524. if (!gRenderForSelect)
  525. {
  526. if (is_dummy)
  527. glColor4fv(LLVOAvatar::getDummyColor().mV);
  528. else
  529. glColor4fv(mColor.mV);
  530. }
  532. stop_glerror();
  534. LLGLSSpecular specular(LLColor4(1.f,1.f,1.f,1.f), gRenderForSelect ? 0.0f : mShiny && !(mFace->getPool()->getVertexShaderLevel() > 0));
  536. //----------------------------------------------------------------
  537. // setup current texture
  538. //----------------------------------------------------------------
  539. llassert( !(mTexture.notNull() && mLayerSet) );  // mutually exclusive
  541. LLTexUnit::eTextureAddressMode old_mode = LLTexUnit::TAM_WRAP;
  542. if (mTestImageName)
  543. {
  544. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, mTestImageName);
  546. if (mIsTransparent)
  547. {
  548. glColor4f(1.f, 1.f, 1.f, 1.f);
  549. }
  550. else
  551. {
  552. glColor4f(0.7f, 0.6f, 0.3f, 1.f);
  553. gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_LERP_TEX_ALPHA, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_PREV_COLOR);
  554. }
  555. }
  556. else if( !is_dummy && mLayerSet )
  557. {
  558. if( mLayerSet->hasComposite() )
  559. {
  560. gGL.getTexUnit(0)->bind(mLayerSet->getComposite());
  561. }
  562. else
  563. {
  564. // This warning will always trigger if you've hacked the avatar to show as incomplete.
  565. // Ignore the warning if that's the case.
  566. if (!gSavedSettings.getBOOL("RenderUnloadedAvatar"))
  567. {
  568. //llwarns << "Layerset without composite" << llendl;
  569. }
  570. gGL.getTexUnit(0)->bind(LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT));
  571. }
  572. }
  573. else
  574. if ( !is_dummy && mTexture.notNull() )
  575. {
  576. if(mTexture->hasGLTexture())
  577. {
  578. old_mode = mTexture->getAddressMode();
  579. }
  580. gGL.getTexUnit(0)->bind(mTexture.get());
  581. gGL.getTexUnit(0)->bind(mTexture);
  582. gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
  583. }
  584. else
  585. {
  586. gGL.getTexUnit(0)->bind(LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT));
  587. }
  589. if (gRenderForSelect)
  590. {
  591. if (isTransparent())
  592. {
  593. gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_COLOR);
  594. gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_ALPHA, LLTexUnit::TBS_CONST_ALPHA);
  595. }
  596. else
  597. {
  598. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  599. }
  600. }
  602. mFace->mVertexBuffer->setBuffer(sRenderMask);
  604. U32 start = mMesh->mFaceVertexOffset;
  605. U32 end = start + mMesh->mFaceVertexCount - 1;
  606. U32 count = mMesh->mFaceIndexCount;
  607. U32 offset = mMesh->mFaceIndexOffset;
  609. if (mMesh->hasWeights())
  610. {
  611. if ((mFace->getPool()->getVertexShaderLevel() > 0))
  612. {
  613. if (first_pass)
  614. {
  615. uploadJointMatrices();
  616. }
  617. }
  619. mFace->mVertexBuffer->drawRange(LLRender::TRIANGLES, start, end, count, offset);
  620. }
  621. else
  622. {
  623. glPushMatrix();
  624. LLMatrix4 jointToWorld = getWorldMatrix();
  625. glMultMatrixf((GLfloat*)jointToWorld.mMatrix);
  626. mFace->mVertexBuffer->drawRange(LLRender::TRIANGLES, start, end, count, offset);
  627. glPopMatrix();
  628. }
  629. gPipeline.addTrianglesDrawn(count/3);
  631. triangle_count += count;
  633. if (mTestImageName)
  634. {
  635. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  636. }
  638. if (mTexture.notNull() && !is_dummy)
  639. {
  640. gGL.getTexUnit(0)->bind(mTexture);
  641. gGL.getTexUnit(0)->setTextureAddressMode(old_mode);
  642. }
  644. return triangle_count;
  645. }
  647. //-----------------------------------------------------------------------------
  648. // updateFaceSizes()
  649. //-----------------------------------------------------------------------------
  650. void LLViewerJointMesh::updateFaceSizes(U32 &num_vertices, U32& num_indices, F32 pixel_area)
  651. {
  652. // Do a pre-alloc pass to determine sizes of data.
  653. if (mMesh && mValid)
  654. {
  655. mMesh->mFaceVertexOffset = num_vertices;
  656. mMesh->mFaceVertexCount = mMesh->getNumVertices();
  657. mMesh->mFaceIndexOffset = num_indices;
  658. mMesh->mFaceIndexCount = mMesh->getSharedData()->mNumTriangleIndices;
  660. mMesh->getReferenceMesh()->mCurVertexCount = mMesh->mFaceVertexCount;
  662. num_vertices += mMesh->getNumVertices();
  663. num_indices += mMesh->mFaceIndexCount;
  664. }
  665. }
  667. //-----------------------------------------------------------------------------
  668. // updateFaceData()
  669. //-----------------------------------------------------------------------------
  670. void LLViewerJointMesh::updateFaceData(LLFace *face, F32 pixel_area, BOOL damp_wind)
  671. {
  672. mFace = face;
  674. if (mFace->mVertexBuffer.isNull())
  675. {
  676. return;
  677. }
  679. LLStrider<LLVector3> verticesp;
  680. LLStrider<LLVector3> normalsp;
  681. LLStrider<LLVector2> tex_coordsp;
  682. LLStrider<F32>  vertex_weightsp;
  683. LLStrider<LLVector4> clothing_weightsp;
  684. LLStrider<U16> indicesp;
  686. // Copy data into the faces from the polymesh data.
  687. if (mMesh && mValid)
  688. {
  689. if (mMesh->getNumVertices())
  690. {
  691. stop_glerror();
  692. face->getGeometryAvatar(verticesp, normalsp, tex_coordsp, vertex_weightsp, clothing_weightsp);
  693. stop_glerror();
  694. face->mVertexBuffer->getIndexStrider(indicesp);
  695. stop_glerror();
  697. for (U16 i = 0; i < mMesh->getNumVertices(); i++)
  698. {
  699. verticesp[mMesh->mFaceVertexOffset + i] = *(mMesh->getCoords() + i);
  700. tex_coordsp[mMesh->mFaceVertexOffset + i] = *(mMesh->getTexCoords() + i);
  701. normalsp[mMesh->mFaceVertexOffset + i] = *(mMesh->getNormals() + i);
  702. vertex_weightsp[mMesh->mFaceVertexOffset + i] = *(mMesh->getWeights() + i);
  703. if (damp_wind)
  704. {
  705. clothing_weightsp[mMesh->mFaceVertexOffset + i] = LLVector4(0,0,0,0);
  706. }
  707. else
  708. {
  709. clothing_weightsp[mMesh->mFaceVertexOffset + i] = (*(mMesh->getClothingWeights() + i));
  710. }
  711. }
  713. for (S32 i = 0; i < mMesh->getNumFaces(); i++)
  714. {
  715. for (U32 j = 0; j < 3; j++)
  716. {
  717. U32 k = i*3+j+mMesh->mFaceIndexOffset;
  718. indicesp[k] = mMesh->getFaces()[i][j] + mMesh->mFaceVertexOffset;
  719. }
  720. }
  721. }
  722. }
  723. }
  725. //-----------------------------------------------------------------------------
  726. // updateLOD()
  727. //-----------------------------------------------------------------------------
  728. BOOL LLViewerJointMesh::updateLOD(F32 pixel_area, BOOL activate)
  729. {
  730. BOOL valid = mValid;
  731. setValid(activate, TRUE);
  732. return (valid != activate);
  733. }
  735. // static
  736. void LLViewerJointMesh::updateGeometryOriginal(LLFace *mFace, LLPolyMesh *mMesh)
  737. {
  738. LLStrider<LLVector3> o_vertices;
  739. LLStrider<LLVector3> o_normals;
  741. //get vertex and normal striders
  742. LLVertexBuffer *buffer = mFace->mVertexBuffer;
  743. buffer->getVertexStrider(o_vertices,  0);
  744. buffer->getNormalStrider(o_normals,   0);
  746. F32 last_weight = F32_MAX;
  747. LLMatrix4 gBlendMat;
  748. LLMatrix3 gBlendRotMat;
  750. const F32* weights = mMesh->getWeights();
  751. const LLVector3* coords = mMesh->getCoords();
  752. const LLVector3* normals = mMesh->getNormals();
  753. for (U32 index = 0; index < mMesh->getNumVertices(); index++)
  754. {
  755. U32 bidx = index + mMesh->mFaceVertexOffset;
  757. // blend by first matrix
  758. F32 w = weights[index]; 
  760. // Maybe we don't have to change gBlendMat.
  761. // Profiles of a single-avatar scene on a Mac show this to be a very
  762. // common case.  JC
  763. if (w == last_weight)
  764. {
  765. o_vertices[bidx] = coords[index] * gBlendMat;
  766. o_normals[bidx] = normals[index] * gBlendRotMat;
  767. continue;
  768. }
  770. last_weight = w;
  772. S32 joint = llfloor(w);
  773. w -= joint;
  775. // No lerp required in this case.
  776. if (w == 1.0f)
  777. {
  778. gBlendMat = gJointMatUnaligned[joint+1];
  779. o_vertices[bidx] = coords[index] * gBlendMat;
  780. gBlendRotMat = gJointRotUnaligned[joint+1];
  781. o_normals[bidx] = normals[index] * gBlendRotMat;
  782. continue;
  783. }
  785. // Try to keep all the accesses to the matrix data as close
  786. // together as possible.  This function is a hot spot on the
  787. // Mac. JC
  788. LLMatrix4 &m0 = gJointMatUnaligned[joint+1];
  789. LLMatrix4 &m1 = gJointMatUnaligned[joint+0];
  791. gBlendMat.mMatrix[VX][VX] = lerp(m1.mMatrix[VX][VX], m0.mMatrix[VX][VX], w);
  792. gBlendMat.mMatrix[VX][VY] = lerp(m1.mMatrix[VX][VY], m0.mMatrix[VX][VY], w);
  793. gBlendMat.mMatrix[VX][VZ] = lerp(m1.mMatrix[VX][VZ], m0.mMatrix[VX][VZ], w);
  795. gBlendMat.mMatrix[VY][VX] = lerp(m1.mMatrix[VY][VX], m0.mMatrix[VY][VX], w);
  796. gBlendMat.mMatrix[VY][VY] = lerp(m1.mMatrix[VY][VY], m0.mMatrix[VY][VY], w);
  797. gBlendMat.mMatrix[VY][VZ] = lerp(m1.mMatrix[VY][VZ], m0.mMatrix[VY][VZ], w);
  799. gBlendMat.mMatrix[VZ][VX] = lerp(m1.mMatrix[VZ][VX], m0.mMatrix[VZ][VX], w);
  800. gBlendMat.mMatrix[VZ][VY] = lerp(m1.mMatrix[VZ][VY], m0.mMatrix[VZ][VY], w);
  801. gBlendMat.mMatrix[VZ][VZ] = lerp(m1.mMatrix[VZ][VZ], m0.mMatrix[VZ][VZ], w);
  803. gBlendMat.mMatrix[VW][VX] = lerp(m1.mMatrix[VW][VX], m0.mMatrix[VW][VX], w);
  804. gBlendMat.mMatrix[VW][VY] = lerp(m1.mMatrix[VW][VY], m0.mMatrix[VW][VY], w);
  805. gBlendMat.mMatrix[VW][VZ] = lerp(m1.mMatrix[VW][VZ], m0.mMatrix[VW][VZ], w);
  807. o_vertices[bidx] = coords[index] * gBlendMat;
  809. LLMatrix3 &n0 = gJointRotUnaligned[joint+1];
  810. LLMatrix3 &n1 = gJointRotUnaligned[joint+0];
  812. gBlendRotMat.mMatrix[VX][VX] = lerp(n1.mMatrix[VX][VX], n0.mMatrix[VX][VX], w);
  813. gBlendRotMat.mMatrix[VX][VY] = lerp(n1.mMatrix[VX][VY], n0.mMatrix[VX][VY], w);
  814. gBlendRotMat.mMatrix[VX][VZ] = lerp(n1.mMatrix[VX][VZ], n0.mMatrix[VX][VZ], w);
  816. gBlendRotMat.mMatrix[VY][VX] = lerp(n1.mMatrix[VY][VX], n0.mMatrix[VY][VX], w);
  817. gBlendRotMat.mMatrix[VY][VY] = lerp(n1.mMatrix[VY][VY], n0.mMatrix[VY][VY], w);
  818. gBlendRotMat.mMatrix[VY][VZ] = lerp(n1.mMatrix[VY][VZ], n0.mMatrix[VY][VZ], w);
  820. gBlendRotMat.mMatrix[VZ][VX] = lerp(n1.mMatrix[VZ][VX], n0.mMatrix[VZ][VX], w);
  821. gBlendRotMat.mMatrix[VZ][VY] = lerp(n1.mMatrix[VZ][VY], n0.mMatrix[VZ][VY], w);
  822. gBlendRotMat.mMatrix[VZ][VZ] = lerp(n1.mMatrix[VZ][VZ], n0.mMatrix[VZ][VZ], w);
  824. o_normals[bidx] = normals[index] * gBlendRotMat;
  825. }
  827. buffer->setBuffer(0);
  828. }
  830. const U32 UPDATE_GEOMETRY_CALL_MASK = 0x1FFF; // 8K samples before overflow
  831. const U32 UPDATE_GEOMETRY_CALL_OVERFLOW = ~UPDATE_GEOMETRY_CALL_MASK;
  832. static bool sUpdateGeometryCallPointer = false;
  833. static F64 sUpdateGeometryGlobalTime = 0.0 ;
  834. static F64 sUpdateGeometryElapsedTime = 0.0 ;
  835. static F64 sUpdateGeometryElapsedTimeOff = 0.0 ;
  836. static F64 sUpdateGeometryElapsedTimeOn = 0.0 ;
  837. static F64 sUpdateGeometryRunAvgOff[10];
  838. static F64 sUpdateGeometryRunAvgOn[10];
  839. static U32 sUpdateGeometryRunCount = 0 ;
  840. static U32 sUpdateGeometryCalls = 0 ;
  841. static U32 sUpdateGeometryLastProcessor = 0 ;
  842. static BOOL sVectorizePerfTest  = FALSE;
  843. static U32 sVectorizeProcessor  = 0;
  845. //static
  846. void (*LLViewerJointMesh::sUpdateGeometryFunc)(LLFace* face, LLPolyMesh* mesh);
  848. //static
  849. void LLViewerJointMesh::updateVectorize()
  850. {
  851. sVectorizePerfTest = gSavedSettings.getBOOL("VectorizePerfTest");
  852. sVectorizeProcessor = gSavedSettings.getU32("VectorizeProcessor");
  853. BOOL vectorizeEnable = gSavedSettings.getBOOL("VectorizeEnable");
  854. BOOL vectorizeSkin = gSavedSettings.getBOOL("VectorizeSkin");
  856. std::string vp;
  857. switch(sVectorizeProcessor)
  858. {
  859. case 2: vp = "SSE2"; break; // *TODO: replace the magic #s
  860. case 1: vp = "SSE"; break;
  861. default: vp = "COMPILER DEFAULT"; break;
  862. }
  863. LL_INFOS("AppInit") << "Vectorization         : " << ( vectorizeEnable ? "ENABLED" : "DISABLED" ) << LL_ENDL ;
  864. LL_INFOS("AppInit") << "Vector Processor      : " << vp << LL_ENDL ;
  865. LL_INFOS("AppInit") << "Vectorized Skinning   : " << ( vectorizeSkin ? "ENABLED" : "DISABLED" ) << LL_ENDL ;
  866. if(vectorizeEnable && vectorizeSkin)
  867. {
  868. switch(sVectorizeProcessor)
  869. {
  870. case 2:
  871. sUpdateGeometryFunc = &updateGeometrySSE2;
  872. break;
  873. case 1:
  874. sUpdateGeometryFunc = &updateGeometrySSE;
  875. break;
  876. default:
  877. sUpdateGeometryFunc = &updateGeometryVectorized;
  878. break;
  879. }
  880. }
  881. else
  882. {
  883. sUpdateGeometryFunc = &updateGeometryOriginal;
  884. }
  885. }
  887. void LLViewerJointMesh::updateJointGeometry()
  888. {
  889. if (!(mValid
  890.   && mMesh
  891.   && mFace
  892.   && mMesh->hasWeights()
  893.   && mFace->mVertexBuffer.notNull()
  894.   && LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_AVATAR) == 0))
  895. {
  896. return;
  897. }
  899. if (!sVectorizePerfTest)
  900. {
  901. // Once we've measured performance, just run the specified
  902. // code version.
  903. if(sUpdateGeometryFunc == updateGeometryOriginal)
  904. uploadJointMatrices();
  905. sUpdateGeometryFunc(mFace, mMesh);
  906. }
  907. else
  908. {
  909. // At startup, measure the amount of time in skinning and choose
  910. // the fastest one.
  911. LLTimer ug_timer ;
  913. if (sUpdateGeometryCallPointer)
  914. {
  915. if(sUpdateGeometryFunc == updateGeometryOriginal)
  916. uploadJointMatrices();
  917. // call accelerated version for this processor
  918. sUpdateGeometryFunc(mFace, mMesh);
  919. }
  920. else
  921. {
  922. uploadJointMatrices();
  923. updateGeometryOriginal(mFace, mMesh);
  924. }
  926. sUpdateGeometryElapsedTime += ug_timer.getElapsedTimeF64();
  927. ++sUpdateGeometryCalls;
  928. if(0 != (sUpdateGeometryCalls & UPDATE_GEOMETRY_CALL_OVERFLOW))
  929. {
  930. F64 time_since_app_start = ug_timer.getElapsedSeconds();
  931. if(sUpdateGeometryGlobalTime == 0.0 
  932. || sUpdateGeometryLastProcessor != sVectorizeProcessor)
  933. {
  934. sUpdateGeometryGlobalTime = time_since_app_start;
  935. sUpdateGeometryElapsedTime = 0;
  936. sUpdateGeometryCalls = 0;
  937. sUpdateGeometryRunCount = 0;
  938. sUpdateGeometryLastProcessor = sVectorizeProcessor;
  939. sUpdateGeometryCallPointer = false;
  940. return;
  941. }
  942. F64 percent_time_in_function = 
  943. ( sUpdateGeometryElapsedTime * 100.0 ) / ( time_since_app_start - sUpdateGeometryGlobalTime ) ;
  944. sUpdateGeometryGlobalTime = time_since_app_start;
  945. if (!sUpdateGeometryCallPointer)
  946. {
  947. // First set of run data is with vectorization off.
  948. sUpdateGeometryCallPointer = true;
  949. llinfos << "profile (avg of " << sUpdateGeometryCalls << " samples) = "
  950. << "vectorize off " << percent_time_in_function
  951. << "% of time with "
  952. << (sUpdateGeometryElapsedTime / (F64)sUpdateGeometryCalls)
  953. << " seconds per call "
  954. << llendl;
  955. sUpdateGeometryRunAvgOff[sUpdateGeometryRunCount] = percent_time_in_function;
  956. sUpdateGeometryElapsedTimeOff += sUpdateGeometryElapsedTime;
  957. sUpdateGeometryCalls = 0;
  958. }
  959. else
  960. {
  961. // Second set of run data is with vectorization on.
  962. sUpdateGeometryCallPointer = false;
  963. llinfos << "profile (avg of " << sUpdateGeometryCalls << " samples) = "
  964. << "VEC on " << percent_time_in_function
  965. << "% of time with "
  966. << (sUpdateGeometryElapsedTime / (F64)sUpdateGeometryCalls)
  967. << " seconds per call "
  968. << llendl;
  969. sUpdateGeometryRunAvgOn[sUpdateGeometryRunCount] = percent_time_in_function ;
  970. sUpdateGeometryElapsedTimeOn += sUpdateGeometryElapsedTime;
  972. sUpdateGeometryCalls = 0;
  973. sUpdateGeometryRunCount++;
  974. F64 a = 0.0, b = 0.0;
  975. for(U32 i = 0; i<sUpdateGeometryRunCount; i++)
  976. {
  977. a += sUpdateGeometryRunAvgOff[i];
  978. b += sUpdateGeometryRunAvgOn[i];
  979. }
  980. a /= sUpdateGeometryRunCount;
  981. b /= sUpdateGeometryRunCount;
  982. F64 perf_boost = ( sUpdateGeometryElapsedTimeOff - sUpdateGeometryElapsedTimeOn ) / sUpdateGeometryElapsedTimeOn;
  983. llinfos << "run averages (" << (F64)sUpdateGeometryRunCount
  984. << "/10) vectorize off " << a
  985. << "% : vectorize type " << sVectorizeProcessor
  986. << " " << b
  987. << "% : performance boost " 
  988. << perf_boost * 100.0
  989. << "%"
  990. << llendl ;
  991. if(sUpdateGeometryRunCount == 10)
  992. {
  993. // In case user runs test again, force reset of data on
  994. // next run.
  995. sUpdateGeometryGlobalTime = 0.0;
  997. // We have data now on which version is faster.  Switch to that
  998. // code and save the data for next run.
  999. gSavedSettings.setBOOL("VectorizePerfTest", FALSE);
  1001. if (perf_boost > 0.0)
  1002. {
  1003. llinfos << "Vectorization improves avatar skinning performance, "
  1004. << "keeping on for future runs."
  1005. << llendl;
  1006. gSavedSettings.setBOOL("VectorizeSkin", TRUE);
  1007. }
  1008. else
  1009. {
  1010. // SIMD decreases performance, fall back to original code
  1011. llinfos << "Vectorization decreases avatar skinning performance, "
  1012. << "switching back to original code."
  1013. << llendl;
  1015. gSavedSettings.setBOOL("VectorizeSkin", FALSE);
  1016. }
  1017. }
  1018. }
  1019. sUpdateGeometryElapsedTime = 0.0f;
  1020. }
  1021. }
  1022. }
  1024. void LLViewerJointMesh::dump()
  1025. {
  1026. if (mValid)
  1027. {
  1028. llinfos << "Usable LOD " << mName << llendl;
  1029. }
  1030. }
  1032. // End