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

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

游戏引擎

开发平台：

C++ Builder

llpolymorph.cpp：源码内容
  1. /** 
  2.  * @file llpolymorph.cpp
  3.  * @brief Implementation of LLPolyMesh 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 "llpolymorph.h"
  39. #include "llvoavatar.h"
  40. #include "llwearable.h"
  41. #include "llxmltree.h"
  42. #include "llendianswizzle.h"
  44. //#include "../tools/imdebug/imdebug.h"
  46. const F32 NORMAL_SOFTEN_FACTOR = 0.65f;
  48. //-----------------------------------------------------------------------------
  49. // LLPolyMorphData()
  50. //-----------------------------------------------------------------------------
  51. LLPolyMorphData::LLPolyMorphData(const std::string& morph_name)
  52. : mName(morph_name)
  53. {
  54. mNumIndices = 0;
  55. mCurrentIndex = 0;
  56. mTotalDistortion = 0.f;
  57. mAvgDistortion.zeroVec();
  58. mMaxDistortion = 0.f;
  59. mVertexIndices = NULL;
  60. mCoords = NULL;
  61. mNormals = NULL;
  62. mBinormals = NULL;
  63. mTexCoords = NULL;
  65. mMesh = NULL;
  66. }
  68. //-----------------------------------------------------------------------------
  69. // ~LLPolyMorphData()
  70. //-----------------------------------------------------------------------------
  71. LLPolyMorphData::~LLPolyMorphData()
  72. {
  73. delete [] mVertexIndices;
  74. delete [] mCoords;
  75. delete [] mNormals;
  76. delete [] mBinormals;
  77. delete [] mTexCoords;
  78. }
  80. //-----------------------------------------------------------------------------
  81. // loadBinary()
  82. //-----------------------------------------------------------------------------
  83. BOOL LLPolyMorphData::loadBinary(LLFILE *fp, LLPolyMeshSharedData *mesh)
  84. {
  85. S32 numVertices;
  86. S32 numRead;
  88. numRead = fread(&numVertices, sizeof(S32), 1, fp);
  89. llendianswizzle(&numVertices, sizeof(S32), 1);
  90. if (numRead != 1)
  91. {
  92. llwarns << "Can't read number of morph target vertices" << llendl;
  93. return FALSE;
  94. }
  96. //-------------------------------------------------------------------------
  97. // allocate vertices
  98. //-------------------------------------------------------------------------
  99. mCoords = new LLVector3[numVertices];
  100. mNormals = new LLVector3[numVertices];
  101. mBinormals = new LLVector3[numVertices];
  102. mTexCoords = new LLVector2[numVertices];
  103. // Actually, we are allocating more space than we need for the skiplist
  104. mVertexIndices = new U32[numVertices];
  105. mNumIndices = 0;
  106. mTotalDistortion = 0.f;
  107. mMaxDistortion = 0.f;
  108. mAvgDistortion.zeroVec();
  109. mMesh = mesh;
  111. //-------------------------------------------------------------------------
  112. // read vertices
  113. //-------------------------------------------------------------------------
  114. for(S32 v = 0; v < numVertices; v++)
  115. {
  116. numRead = fread(&mVertexIndices[v], sizeof(U32), 1, fp);
  117. llendianswizzle(&mVertexIndices[v], sizeof(U32), 1);
  118. if (numRead != 1)
  119. {
  120. llwarns << "Can't read morph target vertex number" << llendl;
  121. return FALSE;
  122. }
  124. if (mVertexIndices[v] > 10000)
  125. {
  126. llerrs << "Bad morph index: " << mVertexIndices[v] << llendl;
  127. }
  130. numRead = fread(&mCoords[v].mV, sizeof(F32), 3, fp);
  131. llendianswizzle(&mCoords[v].mV, sizeof(F32), 3);
  132. if (numRead != 3)
  133. {
  134. llwarns << "Can't read morph target vertex coordinates" << llendl;
  135. return FALSE;
  136. }
  138. F32 magnitude = mCoords[v].magVec();
  140. mTotalDistortion += magnitude;
  141. mAvgDistortion.mV[VX] += fabs(mCoords[v].mV[VX]);
  142. mAvgDistortion.mV[VY] += fabs(mCoords[v].mV[VY]);
  143. mAvgDistortion.mV[VZ] += fabs(mCoords[v].mV[VZ]);
  145. if (magnitude > mMaxDistortion)
  146. {
  147. mMaxDistortion = magnitude;
  148. }
  150. numRead = fread(&mNormals[v].mV, sizeof(F32), 3, fp);
  151. llendianswizzle(&mNormals[v].mV, sizeof(F32), 3);
  152. if (numRead != 3)
  153. {
  154. llwarns << "Can't read morph target normal" << llendl;
  155. return FALSE;
  156. }
  158. numRead = fread(&mBinormals[v].mV, sizeof(F32), 3, fp);
  159. llendianswizzle(&mBinormals[v].mV, sizeof(F32), 3);
  160. if (numRead != 3)
  161. {
  162. llwarns << "Can't read morph target binormal" << llendl;
  163. return FALSE;
  164. }
  167. numRead = fread(&mTexCoords[v].mV, sizeof(F32), 2, fp);
  168. llendianswizzle(&mTexCoords[v].mV, sizeof(F32), 2);
  169. if (numRead != 2)
  170. {
  171. llwarns << "Can't read morph target uv" << llendl;
  172. return FALSE;
  173. }
  175. mNumIndices++;
  176. }
  178. mAvgDistortion = mAvgDistortion * (1.f/(F32)mNumIndices);
  179. mAvgDistortion.normVec();
  181. return TRUE;
  182. }
  184. //-----------------------------------------------------------------------------
  185. // LLPolyMorphTargetInfo()
  186. //-----------------------------------------------------------------------------
  187. LLPolyMorphTargetInfo::LLPolyMorphTargetInfo()
  188. : mIsClothingMorph(FALSE)
  189. {
  190. }
  192. BOOL LLPolyMorphTargetInfo::parseXml(LLXmlTreeNode* node)
  193. {
  194. llassert( node->hasName( "param" ) && node->getChildByName( "param_morph" ) );
  196. if (!LLViewerVisualParamInfo::parseXml(node))
  197. return FALSE;
  199. // Get mixed-case name
  200. static LLStdStringHandle name_string = LLXmlTree::addAttributeString("name");
  201. if( !node->getFastAttributeString( name_string, mMorphName ) )
  202. {
  203. llwarns << "Avatar file: <param> is missing name attribute" << llendl;
  204. return FALSE;  // Continue, ignoring this tag
  205. }
  207. static LLStdStringHandle clothing_morph_string = LLXmlTree::addAttributeString("clothing_morph");
  208. node->getFastAttributeBOOL(clothing_morph_string, mIsClothingMorph);
  210. LLXmlTreeNode *paramNode = node->getChildByName("param_morph");
  212.         if (NULL == paramNode)
  213.         {
  214.                 llwarns << "Failed to getChildByName("param_morph")"
  215.                         << llendl;
  216.                 return FALSE;
  217.         }
  219. for (LLXmlTreeNode* child_node = paramNode->getFirstChild();
  220.  child_node;
  221.  child_node = paramNode->getNextChild())
  222. {
  223. static LLStdStringHandle name_string = LLXmlTree::addAttributeString("name");
  224. if (child_node->hasName("volume_morph"))
  225. {
  226. std::string volume_name;
  227. if (child_node->getFastAttributeString(name_string, volume_name))
  228. {
  229. LLVector3 scale;
  230. static LLStdStringHandle scale_string = LLXmlTree::addAttributeString("scale");
  231. child_node->getFastAttributeVector3(scale_string, scale);
  233. LLVector3 pos;
  234. static LLStdStringHandle pos_string = LLXmlTree::addAttributeString("pos");
  235. child_node->getFastAttributeVector3(pos_string, pos);
  237. mVolumeInfoList.push_back(LLPolyVolumeMorphInfo(volume_name,scale,pos));
  238. }
  239. }
  240. }
  242. return TRUE;
  243. }
  245. //-----------------------------------------------------------------------------
  246. // LLPolyMorphTarget()
  247. //-----------------------------------------------------------------------------
  248. LLPolyMorphTarget::LLPolyMorphTarget(LLPolyMesh *poly_mesh)
  249. : mMorphData(NULL), mMesh(poly_mesh),
  250.   mVertMask(NULL),
  251.   mLastSex(SEX_FEMALE),
  252.   mNumMorphMasksPending(0)
  253. {
  254. }
  256. //-----------------------------------------------------------------------------
  257. // ~LLPolyMorphTarget()
  258. //-----------------------------------------------------------------------------
  259. LLPolyMorphTarget::~LLPolyMorphTarget()
  260. {
  261. if (mVertMask)
  262. {
  263. delete mVertMask;
  264. }
  265. }
  267. //-----------------------------------------------------------------------------
  268. // setInfo()
  269. //-----------------------------------------------------------------------------
  270. BOOL LLPolyMorphTarget::setInfo(LLPolyMorphTargetInfo* info)
  271. {
  272. llassert(mInfo == NULL);
  273. if (info->mID < 0)
  274. return FALSE;
  275. mInfo = info;
  276. mID = info->mID;
  277. setWeight(getDefaultWeight(), FALSE );
  279. LLVOAvatar* avatarp = mMesh->getAvatar();
  280. LLPolyMorphTargetInfo::volume_info_list_t::iterator iter;
  281. for (iter = getInfo()->mVolumeInfoList.begin(); iter != getInfo()->mVolumeInfoList.end(); iter++)
  282. {
  283. LLPolyVolumeMorphInfo *volume_info = &(*iter);
  284. for (S32 i = 0; i < avatarp->mNumCollisionVolumes; i++)
  285. {
  286. if (avatarp->mCollisionVolumes[i].getName() == volume_info->mName)
  287. {
  288. mVolumeMorphs.push_back(LLPolyVolumeMorph(&avatarp->mCollisionVolumes[i],
  289.   volume_info->mScale,
  290.   volume_info->mPos));
  291. break;
  292. }
  293. }
  294. }
  296. mMorphData = mMesh->getMorphData(getInfo()->mMorphName);
  297. if (!mMorphData)
  298. {
  299. llwarns << "No morph target named " << getInfo()->mMorphName << " found in mesh." << llendl;
  300. return FALSE;  // Continue, ignoring this tag
  301. }
  302. return TRUE;
  303. }
  305. /*virtual*/ LLViewerVisualParam* LLPolyMorphTarget::cloneParam(LLWearable* wearable) const
  306. {
  307. LLPolyMorphTarget *new_param = new LLPolyMorphTarget(mMesh);
  308. *new_param = *this;
  309. return new_param;
  310. }
  312. #if 0 // obsolete
  313. //-----------------------------------------------------------------------------
  314. // parseData()
  315. //-----------------------------------------------------------------------------
  316. BOOL LLPolyMorphTarget::parseData(LLXmlTreeNode* node)
  317. {
  318. LLPolyMorphTargetInfo* info = new LLPolyMorphTargetInfo;
  320. info->parseXml(node);
  321. if (!setInfo(info))
  322. {
  323. delete info;
  324. return FALSE;
  325. }
  326. return TRUE;
  327. }
  328. #endif
  330. //-----------------------------------------------------------------------------
  331. // getVertexDistortion()
  332. //-----------------------------------------------------------------------------
  333. LLVector3 LLPolyMorphTarget::getVertexDistortion(S32 requested_index, LLPolyMesh *mesh)
  334. {
  335. if (!mMorphData || mMesh != mesh) return LLVector3::zero;
  337. for(U32 index = 0; index < mMorphData->mNumIndices; index++)
  338. {
  339. if (mMorphData->mVertexIndices[index] == (U32)requested_index)
  340. {
  341. return mMorphData->mCoords[index];
  342. }
  343. }
  345. return LLVector3::zero;
  346. }
  348. //-----------------------------------------------------------------------------
  349. // getFirstDistortion()
  350. //-----------------------------------------------------------------------------
  351. const LLVector3 *LLPolyMorphTarget::getFirstDistortion(U32 *index, LLPolyMesh **poly_mesh)
  352. {
  353. if (!mMorphData) return &LLVector3::zero;
  355. LLVector3* resultVec;
  356. mMorphData->mCurrentIndex = 0;
  357. if (mMorphData->mNumIndices)
  358. {
  359. resultVec = &mMorphData->mCoords[mMorphData->mCurrentIndex];
  360. if (index != NULL)
  361. {
  362. *index = mMorphData->mVertexIndices[mMorphData->mCurrentIndex];
  363. }
  364. if (poly_mesh != NULL)
  365. {
  366. *poly_mesh = mMesh;
  367. }
  369. return resultVec;
  370. }
  371. return NULL;
  372. }
  374. //-----------------------------------------------------------------------------
  375. // getNextDistortion()
  376. //-----------------------------------------------------------------------------
  377. const LLVector3 *LLPolyMorphTarget::getNextDistortion(U32 *index, LLPolyMesh **poly_mesh)
  378. {
  379. if (!mMorphData) return &LLVector3::zero;
  381. LLVector3* resultVec;
  382. mMorphData->mCurrentIndex++;
  383. if (mMorphData->mCurrentIndex < mMorphData->mNumIndices)
  384. {
  385. resultVec = &mMorphData->mCoords[mMorphData->mCurrentIndex];
  386. if (index != NULL)
  387. {
  388. *index = mMorphData->mVertexIndices[mMorphData->mCurrentIndex];
  389. }
  390. if (poly_mesh != NULL)
  391. {
  392. *poly_mesh = mMesh;
  393. }
  394. return resultVec;
  395. }
  396. return NULL;
  397. }
  399. //-----------------------------------------------------------------------------
  400. // getTotalDistortion()
  401. //-----------------------------------------------------------------------------
  402. F32 LLPolyMorphTarget::getTotalDistortion() 
  403. { 
  404. if (mMorphData) 
  405. {
  406. return mMorphData->mTotalDistortion; 
  407. }
  408. else 
  409. {
  410. return 0.f;
  411. }
  412. }
  414. //-----------------------------------------------------------------------------
  415. // getAvgDistortion()
  416. //-----------------------------------------------------------------------------
  417. const LLVector3& LLPolyMorphTarget::getAvgDistortion()
  418. {
  419. if (mMorphData) 
  420. {
  421. return mMorphData->mAvgDistortion; 
  422. }
  423. else 
  424. {
  425. return LLVector3::zero;
  426. }
  427. }
  429. //-----------------------------------------------------------------------------
  430. // getMaxDistortion()
  431. //-----------------------------------------------------------------------------
  432. F32 LLPolyMorphTarget::getMaxDistortion() 
  433. {
  434. if (mMorphData) 
  435. {
  436. return mMorphData->mMaxDistortion; 
  437. }
  438. else
  439. {
  440. return 0.f;
  441. }
  442. }
  444. //-----------------------------------------------------------------------------
  445. // apply()
  446. //-----------------------------------------------------------------------------
  447. void LLPolyMorphTarget::apply( ESex avatar_sex )
  448. {
  449. if (!mMorphData || mNumMorphMasksPending > 0)
  450. {
  451. return;
  452. }
  454. mLastSex = avatar_sex;
  456. // perform differential update of morph
  457. F32 delta_weight = ( getSex() & avatar_sex ) ? (mCurWeight - mLastWeight) : (getDefaultWeight() - mLastWeight);
  458. // store last weight
  459. mLastWeight += delta_weight;
  461. if (delta_weight != 0.f)
  462. {
  463. llassert(!mMesh->isLOD());
  464. LLVector3 *coords = mMesh->getWritableCoords();
  466. LLVector3 *scaled_normals = mMesh->getScaledNormals();
  467. LLVector3 *normals = mMesh->getWritableNormals();
  469. LLVector3 *scaled_binormals = mMesh->getScaledBinormals();
  470. LLVector3 *binormals = mMesh->getWritableBinormals();
  472. LLVector4 *clothing_weights = mMesh->getWritableClothingWeights();
  473. LLVector2 *tex_coords = mMesh->getWritableTexCoords();
  475. F32 *maskWeightArray = (mVertMask) ? mVertMask->getMorphMaskWeights() : NULL;
  477. for(U32 vert_index_morph = 0; vert_index_morph < mMorphData->mNumIndices; vert_index_morph++)
  478. {
  479. S32 vert_index_mesh = mMorphData->mVertexIndices[vert_index_morph];
  481. F32 maskWeight = 1.f;
  482. if (maskWeightArray)
  483. {
  484. maskWeight = maskWeightArray[vert_index_morph];
  485. }
  487. coords[vert_index_mesh] += mMorphData->mCoords[vert_index_morph] * delta_weight * maskWeight;
  488. if (getInfo()->mIsClothingMorph && clothing_weights)
  489. {
  490. LLVector3 clothing_offset = mMorphData->mCoords[vert_index_morph] * delta_weight * maskWeight;
  491. LLVector4* clothing_weight = &clothing_weights[vert_index_mesh];
  492. clothing_weight->mV[VX] += clothing_offset.mV[VX];
  493. clothing_weight->mV[VY] += clothing_offset.mV[VY];
  494. clothing_weight->mV[VZ] += clothing_offset.mV[VZ];
  495. clothing_weight->mV[VW] = maskWeight;
  496. }
  498. // calculate new normals based on half angles
  499. scaled_normals[vert_index_mesh] += mMorphData->mNormals[vert_index_morph] * delta_weight * maskWeight * NORMAL_SOFTEN_FACTOR;
  500. LLVector3 normalized_normal = scaled_normals[vert_index_mesh];
  501. normalized_normal.normVec();
  502. normals[vert_index_mesh] = normalized_normal;
  504. // calculate new binormals
  505. scaled_binormals[vert_index_mesh] += mMorphData->mBinormals[vert_index_morph] * delta_weight * maskWeight * NORMAL_SOFTEN_FACTOR;
  506. LLVector3 tangent = scaled_binormals[vert_index_mesh] % normalized_normal;
  507. LLVector3 normalized_binormal = normalized_normal % tangent; 
  508. normalized_binormal.normVec();
  509. binormals[vert_index_mesh] = normalized_binormal;
  511. tex_coords[vert_index_mesh] += mMorphData->mTexCoords[vert_index_morph] * delta_weight * maskWeight;
  512. }
  514. // now apply volume changes
  515. for( volume_list_t::iterator iter = mVolumeMorphs.begin(); iter != mVolumeMorphs.end(); iter++ )
  516. {
  517. LLPolyVolumeMorph* volume_morph = &(*iter);
  518. LLVector3 scale_delta = volume_morph->mScale * delta_weight;
  519. LLVector3 pos_delta = volume_morph->mPos * delta_weight;
  521. volume_morph->mVolume->setScale(volume_morph->mVolume->getScale() + scale_delta);
  522. volume_morph->mVolume->setPosition(volume_morph->mVolume->getPosition() + pos_delta);
  523. }
  524. }
  526. if (mNext)
  527. {
  528. mNext->apply(avatar_sex);
  529. }
  530. }
  532. //-----------------------------------------------------------------------------
  533. // applyMask()
  534. //-----------------------------------------------------------------------------
  535. void LLPolyMorphTarget::applyMask(U8 *maskTextureData, S32 width, S32 height, S32 num_components, BOOL invert)
  536. {
  537. LLVector4 *clothing_weights = getInfo()->mIsClothingMorph ? mMesh->getWritableClothingWeights() : NULL;
  539. if (!mVertMask)
  540. {
  541. mVertMask = new LLPolyVertexMask(mMorphData);
  542. mNumMorphMasksPending--;
  543. }
  544. else
  545. {
  546. // remove effect of previous mask
  547. F32 *maskWeights = (mVertMask) ? mVertMask->getMorphMaskWeights() : NULL;
  549. if (maskWeights)
  550. {
  551. LLVector3 *coords = mMesh->getWritableCoords();
  552. LLVector3 *scaled_normals = mMesh->getScaledNormals();
  553. LLVector3 *scaled_binormals = mMesh->getScaledBinormals();
  554. LLVector2 *tex_coords = mMesh->getWritableTexCoords();
  556. for(U32 vert = 0; vert < mMorphData->mNumIndices; vert++)
  557. {
  558. F32 lastMaskWeight = mLastWeight * maskWeights[vert];
  559. S32 out_vert = mMorphData->mVertexIndices[vert];
  561. // remove effect of existing masked morph
  562. coords[out_vert] -= mMorphData->mCoords[vert] * lastMaskWeight;
  563. scaled_normals[out_vert] -= mMorphData->mNormals[vert] * lastMaskWeight * NORMAL_SOFTEN_FACTOR;
  564. scaled_binormals[out_vert] -= mMorphData->mBinormals[vert] * lastMaskWeight * NORMAL_SOFTEN_FACTOR;
  565. tex_coords[out_vert] -= mMorphData->mTexCoords[vert] * lastMaskWeight;
  567. if (clothing_weights)
  568. {
  569. LLVector3 clothing_offset = mMorphData->mCoords[vert] * lastMaskWeight;
  570. LLVector4* clothing_weight = &clothing_weights[out_vert];
  571. clothing_weight->mV[VX] -= clothing_offset.mV[VX];
  572. clothing_weight->mV[VY] -= clothing_offset.mV[VY];
  573. clothing_weight->mV[VZ] -= clothing_offset.mV[VZ];
  574. }
  575. }
  576. }
  577. }
  579. // set last weight to 0, since we've removed the effect of this morph
  580. mLastWeight = 0.f;
  582. mVertMask->generateMask(maskTextureData, width, height, num_components, invert, clothing_weights);
  584. apply(mLastSex);
  585. }
  588. //-----------------------------------------------------------------------------
  589. // LLPolyVertexMask()
  590. //-----------------------------------------------------------------------------
  591. LLPolyVertexMask::LLPolyVertexMask(LLPolyMorphData* morph_data)
  592. {
  593. mWeights = new F32[morph_data->mNumIndices];
  594. mMorphData = morph_data;
  595. mWeightsGenerated = FALSE;
  596. }
  598. //-----------------------------------------------------------------------------
  599. // ~LLPolyVertexMask()
  600. //-----------------------------------------------------------------------------
  601. LLPolyVertexMask::~LLPolyVertexMask()
  602. {
  603. delete[] mWeights;
  604. }
  606. //-----------------------------------------------------------------------------
  607. // generateMask()
  608. //-----------------------------------------------------------------------------
  609. void LLPolyVertexMask::generateMask(U8 *maskTextureData, S32 width, S32 height, S32 num_components, BOOL invert, LLVector4 *clothing_weights)
  610. {
  611. // RN debug output that uses Image Debugger (http://www.cs.unc.edu/~baxter/projects/imdebug/)
  612. // BOOL debugImg = FALSE; 
  613. // if (debugImg)
  614. // {
  615. // if (invert)
  616. // {
  617. // imdebug("lum rbga=rgba b=8 w=%d h=%d *-1 %p", width, height, maskTextureData);
  618. // }
  619. // else
  620. // {
  621. // imdebug("lum rbga=rgba b=8 w=%d h=%d %p", width, height, maskTextureData);
  622. // }
  623. // }
  624. for (U32 index = 0; index < mMorphData->mNumIndices; index++)
  625. {
  626. S32 vertIndex = mMorphData->mVertexIndices[index];
  627. const S32 *sharedVertIndex = mMorphData->mMesh->getSharedVert(vertIndex);
  628. LLVector2 uvCoords;
  630. if (sharedVertIndex)
  631. {
  632. uvCoords = mMorphData->mMesh->getUVs(*sharedVertIndex);
  633. }
  634. else
  635. {
  636. uvCoords = mMorphData->mMesh->getUVs(vertIndex);
  637. }
  638. U32 s = llclamp((U32)(uvCoords.mV[VX] * (F32)(width - 1)), (U32)0, (U32)width - 1);
  639. U32 t = llclamp((U32)(uvCoords.mV[VY] * (F32)(height - 1)), (U32)0, (U32)height - 1);
  641. mWeights[index] = ((F32) maskTextureData[((t * width + s) * num_components) + (num_components - 1)]) / 255.f;
  643. if (invert) 
  644. {
  645. mWeights[index] = 1.f - mWeights[index];
  646. }
  648. // now apply step function
  649. // mWeights[index] = mWeights[index] > 0.95f ? 1.f : 0.f;
  651. if (clothing_weights)
  652. {
  653. clothing_weights[vertIndex].mV[VW] = mWeights[index];
  654. }
  655. }
  656. mWeightsGenerated = TRUE;
  657. }
  659. //-----------------------------------------------------------------------------
  660. // getMaskForMorphIndex()
  661. //-----------------------------------------------------------------------------
  662. F32* LLPolyVertexMask::getMorphMaskWeights()
  663. {
  664. if (!mWeightsGenerated)
  665. {
  666. return NULL;
  667. }
  669. return mWeights;
  670. }