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

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

游戏引擎

开发平台：

C++ Builder

llpolymesh.cpp：源码内容
  1. /** 
  2.  * @file llpolymesh.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 "llpolymesh.h"
  40. #include "llviewercontrol.h"
  41. #include "llxmltree.h"
  42. #include "llvoavatar.h"
  43. #include "llwearable.h"
  44. #include "lldir.h"
  45. #include "llvolume.h"
  46. #include "llendianswizzle.h"
  48. #include "llfasttimer.h"
  50. #define HEADER_ASCII "Linden Mesh 1.0"
  51. #define HEADER_BINARY "Linden Binary Mesh 1.0"
  53. extern LLControlGroup gSavedSettings; // read only
  55. //-----------------------------------------------------------------------------
  56. // Global table of loaded LLPolyMeshes
  57. //-----------------------------------------------------------------------------
  58. LLPolyMesh::LLPolyMeshSharedDataTable LLPolyMesh::sGlobalSharedMeshList;
  60. //-----------------------------------------------------------------------------
  61. // LLPolyMeshSharedData()
  62. //-----------------------------------------------------------------------------
  63. LLPolyMeshSharedData::LLPolyMeshSharedData()
  64. {
  65. mNumVertices = 0;
  66. mBaseCoords = NULL;
  67. mBaseNormals = NULL;
  68. mBaseBinormals = NULL;
  69. mTexCoords = NULL;
  70. mDetailTexCoords = NULL;
  71. mWeights = NULL;
  72. mHasWeights = FALSE;
  73. mHasDetailTexCoords = FALSE;
  75. mNumFaces = 0;
  76. mFaces = NULL;
  78. mNumJointNames = 0;
  79. mJointNames = NULL;
  81. mTriangleIndices = NULL;
  82. mNumTriangleIndices = 0;
  84. mReferenceData = NULL;
  86. mLastIndexOffset = -1;
  87. }
  89. //-----------------------------------------------------------------------------
  90. // ~LLPolyMeshSharedData()
  91. //-----------------------------------------------------------------------------
  92. LLPolyMeshSharedData::~LLPolyMeshSharedData()
  93. {
  94. freeMeshData();
  95. for_each(mMorphData.begin(), mMorphData.end(), DeletePointer());
  96. mMorphData.clear();
  97. }
  99. //-----------------------------------------------------------------------------
  100. // setupLOD()
  101. //-----------------------------------------------------------------------------
  102. void LLPolyMeshSharedData::setupLOD(LLPolyMeshSharedData* reference_data)
  103. {
  104. mReferenceData = reference_data;
  106. if (reference_data)
  107. {
  108. mBaseCoords = reference_data->mBaseCoords;
  109. mBaseNormals = reference_data->mBaseNormals;
  110. mBaseBinormals = reference_data->mBaseBinormals;
  111. mTexCoords = reference_data->mTexCoords;
  112. mDetailTexCoords = reference_data->mDetailTexCoords;
  113. mWeights = reference_data->mWeights;
  114. mHasWeights = reference_data->mHasWeights;
  115. mHasDetailTexCoords = reference_data->mHasDetailTexCoords;
  116. }
  117. }
  119. //-----------------------------------------------------------------------------
  120. // LLPolyMeshSharedData::freeMeshData()
  121. //-----------------------------------------------------------------------------
  122. void LLPolyMeshSharedData::freeMeshData()
  123. {
  124. if (!mReferenceData)
  125. {
  126. mNumVertices = 0;
  128. delete [] mBaseCoords;
  129. mBaseCoords = NULL;
  131. delete [] mBaseNormals;
  132. mBaseNormals = NULL;
  134. delete [] mBaseBinormals;
  135. mBaseBinormals = NULL;
  137. delete [] mTexCoords;
  138. mTexCoords = NULL;
  140. delete [] mDetailTexCoords;
  141. mDetailTexCoords = NULL;
  143. delete [] mWeights;
  144. mWeights = NULL;
  145. }
  147. mNumFaces = 0;
  148. delete [] mFaces;
  149. mFaces = NULL;
  151. mNumJointNames = 0;
  152. delete [] mJointNames;
  153. mJointNames = NULL;
  155. delete [] mTriangleIndices;
  156. mTriangleIndices = NULL;
  158. // mVertFaceMap.deleteAllData();
  159. }
  161. // compate_int is used by the qsort function to sort the index array
  162. int compare_int(const void *a, const void *b);
  164. //-----------------------------------------------------------------------------
  165. // genIndices()
  166. //-----------------------------------------------------------------------------
  167. void LLPolyMeshSharedData::genIndices(S32 index_offset)
  168. {
  169. if (index_offset == mLastIndexOffset)
  170. {
  171. return;
  172. }
  174. delete []mTriangleIndices;
  175. mTriangleIndices = new U32[mNumTriangleIndices];
  177. S32 cur_index = 0;
  178. for (S32 i = 0; i < mNumFaces; i++)
  179. {
  180. mTriangleIndices[cur_index] = mFaces[i][0] + index_offset;
  181. cur_index++;
  182. mTriangleIndices[cur_index] = mFaces[i][1] + index_offset;
  183. cur_index++;
  184. mTriangleIndices[cur_index] = mFaces[i][2] + index_offset;
  185. cur_index++;
  186. }
  188. mLastIndexOffset = index_offset;
  189. }
  191. //--------------------------------------------------------------------
  192. // LLPolyMeshSharedData::getNumKB()
  193. //--------------------------------------------------------------------
  194. U32 LLPolyMeshSharedData::getNumKB()
  195. {
  196. U32 num_kb = sizeof(LLPolyMesh);
  198. if (!isLOD())
  199. {
  200. num_kb += mNumVertices *
  201. ( sizeof(LLVector3) + // coords
  202. sizeof(LLVector3) + // normals
  203. sizeof(LLVector2) ); // texCoords
  204. }
  206. if (mHasDetailTexCoords && !isLOD())
  207. {
  208. num_kb += mNumVertices * sizeof(LLVector2); // detailTexCoords
  209. }
  211. if (mHasWeights && !isLOD())
  212. {
  213. num_kb += mNumVertices * sizeof(float); // weights
  214. }
  216. num_kb += mNumFaces * sizeof(LLPolyFace); // faces
  218. num_kb /= 1024;
  219. return num_kb;
  220. }
  222. //-----------------------------------------------------------------------------
  223. // LLPolyMeshSharedData::allocateVertexData()
  224. //-----------------------------------------------------------------------------
  225. BOOL LLPolyMeshSharedData::allocateVertexData( U32 numVertices )
  226. {
  227. U32 i;
  228. mBaseCoords = new LLVector3[ numVertices ];
  229. mBaseNormals = new LLVector3[ numVertices ];
  230. mBaseBinormals = new LLVector3[ numVertices ];
  231. mTexCoords = new LLVector2[ numVertices ];
  232. mDetailTexCoords = new LLVector2[ numVertices ];
  233. mWeights = new F32[ numVertices ];
  234. for (i = 0; i < numVertices; i++)
  235. {
  236. mWeights[i] = 0.f;
  237. }
  238. mNumVertices = numVertices;
  239. return TRUE;
  240. }
  242. //-----------------------------------------------------------------------------
  243. // LLPolyMeshSharedData::allocateFaceData()
  244. //-----------------------------------------------------------------------------
  245. BOOL LLPolyMeshSharedData::allocateFaceData( U32 numFaces )
  246. {
  247. mFaces = new LLPolyFace[ numFaces ];
  248. mNumFaces = numFaces;
  249. mNumTriangleIndices = mNumFaces * 3;
  250. return TRUE;
  251. }
  253. //-----------------------------------------------------------------------------
  254. // LLPolyMeshSharedData::allocateJointNames()
  255. //-----------------------------------------------------------------------------
  256. BOOL LLPolyMeshSharedData::allocateJointNames( U32 numJointNames )
  257. {
  258. mJointNames = new std::string[ numJointNames ];
  259. mNumJointNames = numJointNames;
  260. return TRUE;
  261. }
  263. //--------------------------------------------------------------------
  264. // LLPolyMeshSharedData::loadMesh()
  265. //--------------------------------------------------------------------
  266. BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
  267. {
  268. //-------------------------------------------------------------------------
  269. // Open the file
  270. //-------------------------------------------------------------------------
  271. if(fileName.empty())
  272. {
  273. llerrs << "Filename is Empty!" << llendl;
  274. return FALSE;
  275. }
  276. LLFILE* fp = LLFile::fopen(fileName, "rb"); /*Flawfinder: ignore*/
  277. if (!fp)
  278. {
  279. llerrs << "can't open: " << fileName << llendl;
  280. return FALSE;
  281. }
  283. //-------------------------------------------------------------------------
  284. // Read a chunk
  285. //-------------------------------------------------------------------------
  286. char header[128]; /*Flawfinder: ignore*/
  287. if (fread(header, sizeof(char), 128, fp) != 128)
  288. {
  289. llwarns << "Short read" << llendl;
  290. }
  292. //-------------------------------------------------------------------------
  293. // Check for proper binary header
  294. //-------------------------------------------------------------------------
  295. BOOL status = FALSE;
  296. if ( strncmp(header, HEADER_BINARY, strlen(HEADER_BINARY)) == 0 ) /*Flawfinder: ignore*/
  297. {
  298. lldebugs << "Loading " << fileName << llendl;
  300. //----------------------------------------------------------------
  301. // File Header (seek past it)
  302. //----------------------------------------------------------------
  303. fseek(fp, 24, SEEK_SET);
  305. //----------------------------------------------------------------
  306. // HasWeights
  307. //----------------------------------------------------------------
  308. U8 hasWeights;
  309. size_t numRead = fread(&hasWeights, sizeof(U8), 1, fp);
  310. if (numRead != 1)
  311. {
  312. llerrs << "can't read HasWeights flag from " << fileName << llendl;
  313. return FALSE;
  314. }
  315. if (!isLOD())
  316. {
  317. mHasWeights = (hasWeights==0) ? FALSE : TRUE;
  318. }
  320. //----------------------------------------------------------------
  321. // HasDetailTexCoords
  322. //----------------------------------------------------------------
  323. U8 hasDetailTexCoords;
  324. numRead = fread(&hasDetailTexCoords, sizeof(U8), 1, fp);
  325. if (numRead != 1)
  326. {
  327. llerrs << "can't read HasDetailTexCoords flag from " << fileName << llendl;
  328. return FALSE;
  329. }
  331. //----------------------------------------------------------------
  332. // Position
  333. //----------------------------------------------------------------
  334. LLVector3 position;
  335. numRead = fread(position.mV, sizeof(float), 3, fp);
  336. llendianswizzle(position.mV, sizeof(float), 3);
  337. if (numRead != 3)
  338. {
  339. llerrs << "can't read Position from " << fileName << llendl;
  340. return FALSE;
  341. }
  342. setPosition( position );
  344. //----------------------------------------------------------------
  345. // Rotation
  346. //----------------------------------------------------------------
  347. LLVector3 rotationAngles;
  348. numRead = fread(rotationAngles.mV, sizeof(float), 3, fp);
  349. llendianswizzle(rotationAngles.mV, sizeof(float), 3);
  350. if (numRead != 3)
  351. {
  352. llerrs << "can't read RotationAngles from " << fileName << llendl;
  353. return FALSE;
  354. }
  356. U8 rotationOrder;
  357. numRead = fread(&rotationOrder, sizeof(U8), 1, fp);
  359. if (numRead != 1)
  360. {
  361. llerrs << "can't read RotationOrder from " << fileName << llendl;
  362. return FALSE;
  363. }
  365. rotationOrder = 0;
  367. setRotation( mayaQ( rotationAngles.mV[0],
  368. rotationAngles.mV[1],
  369. rotationAngles.mV[2],
  370. (LLQuaternion::Order)rotationOrder ) );
  372. //----------------------------------------------------------------
  373. // Scale
  374. //----------------------------------------------------------------
  375. LLVector3 scale;
  376. numRead = fread(scale.mV, sizeof(float), 3, fp);
  377. llendianswizzle(scale.mV, sizeof(float), 3);
  378. if (numRead != 3)
  379. {
  380. llerrs << "can't read Scale from " << fileName << llendl;
  381. return FALSE;
  382. }
  383. setScale( scale );
  385. //-------------------------------------------------------------------------
  386. // Release any existing mesh geometry
  387. //-------------------------------------------------------------------------
  388. freeMeshData();
  390. U16 numVertices = 0;
  392. //----------------------------------------------------------------
  393. // NumVertices
  394. //----------------------------------------------------------------
  395. if (!isLOD())
  396. {
  397. numRead = fread(&numVertices, sizeof(U16), 1, fp);
  398. llendianswizzle(&numVertices, sizeof(U16), 1);
  399. if (numRead != 1)
  400. {
  401. llerrs << "can't read NumVertices from " << fileName << llendl;
  402. return FALSE;
  403. }
  405. allocateVertexData( numVertices );
  407. //----------------------------------------------------------------
  408. // Coords
  409. //----------------------------------------------------------------
  410. numRead = fread(mBaseCoords, 3*sizeof(float), numVertices, fp);
  411. llendianswizzle(mBaseCoords, sizeof(float), 3*numVertices);
  412. if (numRead != numVertices)
  413. {
  414. llerrs << "can't read Coordinates from " << fileName << llendl;
  415. return FALSE;
  416. }
  418. //----------------------------------------------------------------
  419. // Normals
  420. //----------------------------------------------------------------
  421. numRead = fread(mBaseNormals, 3*sizeof(float), numVertices, fp);
  422. llendianswizzle(mBaseNormals, sizeof(float), 3*numVertices);
  423. if (numRead != numVertices)
  424. {
  425. llerrs << " can't read Normals from " << fileName << llendl;
  426. return FALSE;
  427. }
  429. //----------------------------------------------------------------
  430. // Binormals
  431. //----------------------------------------------------------------
  432. numRead = fread(mBaseBinormals, 3*sizeof(float), numVertices, fp);
  433. llendianswizzle(mBaseBinormals, sizeof(float), 3*numVertices);
  434. if (numRead != numVertices)
  435. {
  436. llerrs << " can't read Binormals from " << fileName << llendl;
  437. return FALSE;
  438. }
  441. //----------------------------------------------------------------
  442. // TexCoords
  443. //----------------------------------------------------------------
  444. numRead = fread(mTexCoords, 2*sizeof(float), numVertices, fp);
  445. llendianswizzle(mTexCoords, sizeof(float), 2*numVertices);
  446. if (numRead != numVertices)
  447. {
  448. llerrs << "can't read TexCoords from " << fileName << llendl;
  449. return FALSE;
  450. }
  452. //----------------------------------------------------------------
  453. // DetailTexCoords
  454. //----------------------------------------------------------------
  455. if (mHasDetailTexCoords)
  456. {
  457. numRead = fread(mDetailTexCoords, 2*sizeof(float), numVertices, fp);
  458. llendianswizzle(mDetailTexCoords, sizeof(float), 2*numVertices);
  459. if (numRead != numVertices)
  460. {
  461. llerrs << "can't read DetailTexCoords from " << fileName << llendl;
  462. return FALSE;
  463. }
  464. }
  466. //----------------------------------------------------------------
  467. // Weights
  468. //----------------------------------------------------------------
  469. if (mHasWeights)
  470. {
  471. numRead = fread(mWeights, sizeof(float), numVertices, fp);
  472. llendianswizzle(mWeights, sizeof(float), numVertices);
  473. if (numRead != numVertices)
  474. {
  475. llerrs << "can't read Weights from " << fileName << llendl;
  476. return FALSE;
  477. }
  478. }
  479. }
  481. //----------------------------------------------------------------
  482. // NumFaces
  483. //----------------------------------------------------------------
  484. U16 numFaces;
  485. numRead = fread(&numFaces, sizeof(U16), 1, fp);
  486. llendianswizzle(&numFaces, sizeof(U16), 1);
  487. if (numRead != 1)
  488. {
  489. llerrs << "can't read NumFaces from " << fileName << llendl;
  490. return FALSE;
  491. }
  492. allocateFaceData( numFaces );
  495. //----------------------------------------------------------------
  496. // Faces
  497. //----------------------------------------------------------------
  498. U32 i;
  499. U32 numTris = 0;
  500. for (i = 0; i < numFaces; i++)
  501. {
  502. S16 face[3];
  503. numRead = fread(face, sizeof(U16), 3, fp);
  504. llendianswizzle(face, sizeof(U16), 3);
  505. if (numRead != 3)
  506. {
  507. llerrs << "can't read Face[" << i << "] from " << fileName << llendl;
  508. return FALSE;
  509. }
  510. if (mReferenceData)
  511. {
  512. llassert(face[0] < mReferenceData->mNumVertices);
  513. llassert(face[1] < mReferenceData->mNumVertices);
  514. llassert(face[2] < mReferenceData->mNumVertices);
  515. }
  517. if (isLOD())
  518. {
  519. // store largest index in case of LODs
  520. for (S32 j = 0; j < 3; j++)
  521. {
  522. if (face[j] > mNumVertices - 1)
  523. {
  524. mNumVertices = face[j] + 1;
  525. }
  526. }
  527. }
  528. mFaces[i][0] = face[0];
  529. mFaces[i][1] = face[1];
  530. mFaces[i][2] = face[2];
  532. // S32 j;
  533. // for(j = 0; j < 3; j++)
  534. // {
  535. // LLDynamicArray<S32> *face_list = mVertFaceMap.getIfThere(face[j]);
  536. // if (!face_list)
  537. // {
  538. // face_list = new LLDynamicArray<S32>;
  539. // mVertFaceMap.addData(face[j], face_list);
  540. // }
  541. // face_list->put(i);
  542. // }
  544. numTris++;
  545. }
  547. lldebugs << "verts: " << numVertices 
  548. << ", faces: "   << numFaces
  549. << ", tris: "    << numTris
  550. << llendl;
  552. //----------------------------------------------------------------
  553. // NumSkinJoints
  554. //----------------------------------------------------------------
  555. if (!isLOD())
  556. {
  557. U16 numSkinJoints = 0;
  558. if ( mHasWeights )
  559. {
  560. numRead = fread(&numSkinJoints, sizeof(U16), 1, fp);
  561. llendianswizzle(&numSkinJoints, sizeof(U16), 1);
  562. if (numRead != 1)
  563. {
  564. llerrs << "can't read NumSkinJoints from " << fileName << llendl;
  565. return FALSE;
  566. }
  567. allocateJointNames( numSkinJoints );
  568. }
  570. //----------------------------------------------------------------
  571. // SkinJoints
  572. //----------------------------------------------------------------
  573. for (i=0; i < numSkinJoints; i++)
  574. {
  575. char jointName[64+1];
  576. numRead = fread(jointName, sizeof(jointName)-1, 1, fp);
  577. jointName[sizeof(jointName)-1] = ''; // ensure nul-termination
  578. if (numRead != 1)
  579. {
  580. llerrs << "can't read Skin[" << i << "].Name from " << fileName << llendl;
  581. return FALSE;
  582. }
  584. std::string *jn = &mJointNames[i];
  585. *jn = jointName;
  586. }
  588. //-------------------------------------------------------------------------
  589. // look for morph section
  590. //-------------------------------------------------------------------------
  591. char morphName[64+1];
  592. morphName[sizeof(morphName)-1] = ''; // ensure nul-termination
  593. while(fread(&morphName, sizeof(char), 64, fp) == 64)
  594. {
  595. if (!strcmp(morphName, "End Morphs"))
  596. {
  597. // we reached the end of the morphs
  598. break;
  599. }
  600. LLPolyMorphData* morph_data = new LLPolyMorphData(std::string(morphName));
  602. BOOL result = morph_data->loadBinary(fp, this);
  604. if (!result)
  605. {
  606. delete morph_data;
  607. continue;
  608. }
  610. mMorphData.insert(morph_data);
  611. }
  613. S32 numRemaps;
  614. if (fread(&numRemaps, sizeof(S32), 1, fp) == 1)
  615. {
  616. llendianswizzle(&numRemaps, sizeof(S32), 1);
  617. for (S32 i = 0; i < numRemaps; i++)
  618. {
  619. S32 remapSrc;
  620. S32 remapDst;
  621. if (fread(&remapSrc, sizeof(S32), 1, fp) != 1)
  622. {
  623. llerrs << "can't read source vertex in vertex remap data" << llendl;
  624. break;
  625. }
  626. if (fread(&remapDst, sizeof(S32), 1, fp) != 1)
  627. {
  628. llerrs << "can't read destination vertex in vertex remap data" << llendl;
  629. break;
  630. }
  631. llendianswizzle(&remapSrc, sizeof(S32), 1);
  632. llendianswizzle(&remapDst, sizeof(S32), 1);
  634. mSharedVerts[remapSrc] = remapDst;
  635. }
  636. }
  637. }
  639. status = TRUE;
  640. }
  641. else
  642. {
  643. llerrs << "invalid mesh file header: " << fileName << llendl;
  644. status = FALSE;
  645. }
  647. if (0 == mNumJointNames)
  648. {
  649. allocateJointNames(1);
  650. }
  652. fclose( fp );
  654. return status;
  655. }
  657. //-----------------------------------------------------------------------------
  658. // getSharedVert()
  659. //-----------------------------------------------------------------------------
  660. const S32 *LLPolyMeshSharedData::getSharedVert(S32 vert)
  661. {
  662. if (mSharedVerts.count(vert) > 0)
  663. {
  664. return &mSharedVerts[vert];
  665. }
  666. return NULL;
  667. }
  669. //-----------------------------------------------------------------------------
  670. // getUV()
  671. //-----------------------------------------------------------------------------
  672. const LLVector2 &LLPolyMeshSharedData::getUVs(U32 index)
  673. {
  674. // TODO: convert all index variables to S32
  675. llassert((S32)index < mNumVertices);
  677. return mTexCoords[index];
  678. }
  680. //-----------------------------------------------------------------------------
  681. // LLPolyMesh()
  682. //-----------------------------------------------------------------------------
  683. LLPolyMesh::LLPolyMesh(LLPolyMeshSharedData *shared_data, LLPolyMesh *reference_mesh)
  684. {
  685. LLMemType mt(LLMemType::MTYPE_AVATAR_MESH);
  687. llassert(shared_data);
  689. mSharedData = shared_data;
  690. mReferenceMesh = reference_mesh;
  691. mAvatarp = NULL;
  692. mVertexData = NULL;
  694. mCurVertexCount = 0;
  695. mFaceIndexCount = 0;
  696. mFaceIndexOffset = 0;
  697. mFaceVertexCount = 0;
  698. mFaceVertexOffset = 0;
  700. if (shared_data->isLOD() && reference_mesh)
  701. {
  702. mCoords = reference_mesh->mCoords;
  703. mNormals = reference_mesh->mNormals;
  704. mScaledNormals = reference_mesh->mScaledNormals;
  705. mBinormals = reference_mesh->mBinormals;
  706. mScaledBinormals = reference_mesh->mScaledBinormals;
  707. mTexCoords = reference_mesh->mTexCoords;
  708. mClothingWeights = reference_mesh->mClothingWeights;
  709. }
  710. else
  711. {
  712. #if 1 // Allocate memory without initializing every vector
  713. // NOTE: This makes asusmptions about the size of LLVector[234]
  714. int nverts = mSharedData->mNumVertices;
  715. int nfloats = nverts * (3*5 + 2 + 4);
  716. mVertexData = new F32[nfloats];
  717. int offset = 0;
  718. mCoords =  (LLVector3*)(mVertexData + offset); offset += 3*nverts;
  719. mNormals =  (LLVector3*)(mVertexData + offset); offset += 3*nverts;
  720. mScaledNormals =  (LLVector3*)(mVertexData + offset); offset += 3*nverts;
  721. mBinormals =  (LLVector3*)(mVertexData + offset); offset += 3*nverts;
  722. mScaledBinormals =  (LLVector3*)(mVertexData + offset); offset += 3*nverts;
  723. mTexCoords =  (LLVector2*)(mVertexData + offset); offset += 2*nverts;
  724. mClothingWeights =  (LLVector4*)(mVertexData + offset); offset += 4*nverts;
  725. #else
  726. mCoords = new LLVector3[mSharedData->mNumVertices];
  727. mNormals = new LLVector3[mSharedData->mNumVertices];
  728. mScaledNormals = new LLVector3[mSharedData->mNumVertices];
  729. mBinormals = new LLVector3[mSharedData->mNumVertices];
  730. mScaledBinormals = new LLVector3[mSharedData->mNumVertices];
  731. mTexCoords = new LLVector2[mSharedData->mNumVertices];
  732. mClothingWeights = new LLVector4[mSharedData->mNumVertices];
  733. memset(mClothingWeights, 0, sizeof(LLVector4) * mSharedData->mNumVertices);
  734. #endif
  735. initializeForMorph();
  736. }
  737. }
  740. //-----------------------------------------------------------------------------
  741. // ~LLPolyMesh()
  742. //-----------------------------------------------------------------------------
  743. LLPolyMesh::~LLPolyMesh()
  744. {
  745. S32 i;
  746. for (i = 0; i < mJointRenderData.count(); i++)
  747. {
  748. delete mJointRenderData[i];
  749. mJointRenderData[i] = NULL;
  750. }
  751. #if 0 // These are now allocated as one big uninitialized chunk
  752. delete [] mCoords;
  753. delete [] mNormals;
  754. delete [] mScaledNormals;
  755. delete [] mBinormals;
  756. delete [] mScaledBinormals;
  757. delete [] mClothingWeights;
  758. delete [] mTexCoords;
  759. #else
  760. delete [] mVertexData;
  761. #endif
  762. }
  765. //-----------------------------------------------------------------------------
  766. // LLPolyMesh::getMesh()
  767. //-----------------------------------------------------------------------------
  768. LLPolyMesh *LLPolyMesh::getMesh(const std::string &name, LLPolyMesh* reference_mesh)
  769. {
  770. //-------------------------------------------------------------------------
  771. // search for an existing mesh by this name
  772. //-------------------------------------------------------------------------
  773. LLPolyMeshSharedData* meshSharedData = get_if_there(sGlobalSharedMeshList, name, (LLPolyMeshSharedData*)NULL);
  774. if (meshSharedData)
  775. {
  776. // llinfos << "Polymesh " << name << " found in global mesh table." << llendl;
  777. LLPolyMesh *poly_mesh = new LLPolyMesh(meshSharedData, reference_mesh);
  778. return poly_mesh;
  779. }
  781. //-------------------------------------------------------------------------
  782. // if not found, create a new one, add it to the list
  783. //-------------------------------------------------------------------------
  784. std::string full_path;
  785. full_path = gDirUtilp->getExpandedFilename(LL_PATH_CHARACTER,name);
  787. LLPolyMeshSharedData *mesh_data = new LLPolyMeshSharedData();
  788. if (reference_mesh)
  789. {
  790. mesh_data->setupLOD(reference_mesh->getSharedData());
  791. }
  792. if ( ! mesh_data->loadMesh( full_path ) )
  793. {
  794. delete mesh_data;
  795. return NULL;
  796. }
  798. LLPolyMesh *poly_mesh = new LLPolyMesh(mesh_data, reference_mesh);
  800. // llinfos << "Polymesh " << name << " added to global mesh table." << llendl;
  801. sGlobalSharedMeshList[name] = poly_mesh->mSharedData;
  803. return poly_mesh;
  804. }
  806. //-----------------------------------------------------------------------------
  807. // LLPolyMesh::freeAllMeshes()
  808. //-----------------------------------------------------------------------------
  809. void LLPolyMesh::freeAllMeshes()
  810. {
  811. // delete each item in the global lists
  812. for_each(sGlobalSharedMeshList.begin(), sGlobalSharedMeshList.end(), DeletePairedPointer());
  813. sGlobalSharedMeshList.clear();
  814. }
  816. LLPolyMeshSharedData *LLPolyMesh::getSharedData() const
  817. {
  818. return mSharedData;
  819. }
  822. //--------------------------------------------------------------------
  823. // LLPolyMesh::dumpDiagInfo()
  824. //--------------------------------------------------------------------
  825. void LLPolyMesh::dumpDiagInfo()
  826. {
  827. // keep track of totals
  828. U32 total_verts = 0;
  829. U32 total_faces = 0;
  830. U32 total_kb = 0;
  832. std::string buf;
  834. llinfos << "-----------------------------------------------------" << llendl;
  835. llinfos << "       Global PolyMesh Table (DEBUG only)" << llendl;
  836. llinfos << "   Verts    Faces  Mem(KB) Name" << llendl;
  837. llinfos << "-----------------------------------------------------" << llendl;
  839. // print each loaded mesh, and it's memory usage
  840. for(LLPolyMeshSharedDataTable::iterator iter = sGlobalSharedMeshList.begin();
  841. iter != sGlobalSharedMeshList.end(); ++iter)
  842. {
  843. const std::string& mesh_name = iter->first;
  844. LLPolyMeshSharedData* mesh = iter->second;
  846. S32 num_verts = mesh->mNumVertices;
  847. S32 num_faces = mesh->mNumFaces;
  848. U32 num_kb = mesh->getNumKB();
  850. buf = llformat("%8d %8d %8d %s", num_verts, num_faces, num_kb, mesh_name.c_str());
  851. llinfos << buf << llendl;
  853. total_verts += num_verts;
  854. total_faces += num_faces;
  855. total_kb += num_kb;
  856. }
  858. llinfos << "-----------------------------------------------------" << llendl;
  859. buf = llformat("%8d %8d %8d TOTAL", total_verts, total_faces, total_kb );
  860. llinfos << buf << llendl;
  861. llinfos << "-----------------------------------------------------" << llendl;
  862. }
  864. //-----------------------------------------------------------------------------
  865. // getWritableCoords()
  866. //-----------------------------------------------------------------------------
  867. LLVector3 *LLPolyMesh::getWritableCoords()
  868. {
  869. return mCoords;
  870. }
  872. //-----------------------------------------------------------------------------
  873. // getWritableNormals()
  874. //-----------------------------------------------------------------------------
  875. LLVector3 *LLPolyMesh::getWritableNormals()
  876. {
  877. return mNormals;
  878. }
  880. //-----------------------------------------------------------------------------
  881. // getWritableBinormals()
  882. //-----------------------------------------------------------------------------
  883. LLVector3 *LLPolyMesh::getWritableBinormals()
  884. {
  885. return mBinormals;
  886. }
  889. //-----------------------------------------------------------------------------
  890. // getWritableClothingWeights()
  891. //-----------------------------------------------------------------------------
  892. LLVector4 *LLPolyMesh::getWritableClothingWeights()
  893. {
  894. return mClothingWeights;
  895. }
  897. //-----------------------------------------------------------------------------
  898. // getWritableTexCoords()
  899. //-----------------------------------------------------------------------------
  900. LLVector2 *LLPolyMesh::getWritableTexCoords()
  901. {
  902. return mTexCoords;
  903. }
  905. //-----------------------------------------------------------------------------
  906. // getScaledNormals()
  907. //-----------------------------------------------------------------------------
  908. LLVector3 *LLPolyMesh::getScaledNormals()
  909. {
  910. return mScaledNormals;
  911. }
  913. //-----------------------------------------------------------------------------
  914. // getScaledBinormals()
  915. //-----------------------------------------------------------------------------
  916. LLVector3 *LLPolyMesh::getScaledBinormals()
  917. {
  918. return mScaledBinormals;
  919. }
  922. //-----------------------------------------------------------------------------
  923. // initializeForMorph()
  924. //-----------------------------------------------------------------------------
  925. void LLPolyMesh::initializeForMorph()
  926. {
  927. if (!mSharedData)
  928. return;
  930. memcpy(mCoords, mSharedData->mBaseCoords, sizeof(LLVector3) * mSharedData->mNumVertices); /*Flawfinder: ignore*/
  931. memcpy(mNormals, mSharedData->mBaseNormals, sizeof(LLVector3) * mSharedData->mNumVertices); /*Flawfinder: ignore*/
  932. memcpy(mScaledNormals, mSharedData->mBaseNormals, sizeof(LLVector3) * mSharedData->mNumVertices); /*Flawfinder: ignore*/
  933. memcpy(mBinormals, mSharedData->mBaseBinormals, sizeof(LLVector3) * mSharedData->mNumVertices); /*Flawfinder: ignore*/
  934. memcpy(mScaledBinormals, mSharedData->mBaseBinormals, sizeof(LLVector3) * mSharedData->mNumVertices); /*Flawfinder: ignore*/
  935. memcpy(mTexCoords, mSharedData->mTexCoords, sizeof(LLVector2) * mSharedData->mNumVertices); /*Flawfinder: ignore*/
  936. memset(mClothingWeights, 0, sizeof(LLVector4) * mSharedData->mNumVertices);
  937. }
  939. //-----------------------------------------------------------------------------
  940. // getMorphData()
  941. //-----------------------------------------------------------------------------
  942. LLPolyMorphData* LLPolyMesh::getMorphData(const std::string& morph_name)
  943. {
  944. if (!mSharedData)
  945. return NULL;
  946. for (LLPolyMeshSharedData::morphdata_list_t::iterator iter = mSharedData->mMorphData.begin();
  947.  iter != mSharedData->mMorphData.end(); ++iter)
  948. {
  949. LLPolyMorphData *morph_data = *iter;
  950. if (morph_data->getName() == morph_name)
  951. {
  952. return morph_data;
  953. }
  954. }
  955. return NULL;
  956. }
  958. //-----------------------------------------------------------------------------
  959. // removeMorphData()
  960. //-----------------------------------------------------------------------------
  961. // // erasing but not deleting seems bad, but fortunately we don't actually use this...
  962. // void LLPolyMesh::removeMorphData(LLPolyMorphData *morph_target)
  963. // {
  964. //  if (!mSharedData)
  965. //  return;
  966. //  mSharedData->mMorphData.erase(morph_target);
  967. // }
  969. //-----------------------------------------------------------------------------
  970. // deleteAllMorphData()
  971. //-----------------------------------------------------------------------------
  972. // void LLPolyMesh::deleteAllMorphData()
  973. // {
  974. //  if (!mSharedData)
  975. //  return;
  977. //  for_each(mSharedData->mMorphData.begin(), mSharedData->mMorphData.end(), DeletePointer());
  978. //  mSharedData->mMorphData.clear();
  979. // }
  981. //-----------------------------------------------------------------------------
  982. // getWritableWeights()
  983. //-----------------------------------------------------------------------------
  984. F32* LLPolyMesh::getWritableWeights() const
  985. {
  986. return mSharedData->mWeights;
  987. }
  989. //-----------------------------------------------------------------------------
  990. // LLPolySkeletalDistortionInfo()
  991. //-----------------------------------------------------------------------------
  992. LLPolySkeletalDistortionInfo::LLPolySkeletalDistortionInfo()
  993. {
  994. }
  996. BOOL LLPolySkeletalDistortionInfo::parseXml(LLXmlTreeNode* node)
  997. {
  998. llassert( node->hasName( "param" ) && node->getChildByName( "param_skeleton" ) );
  1000. if (!LLViewerVisualParamInfo::parseXml(node))
  1001. return FALSE;
  1003. LLXmlTreeNode* skeletalParam = node->getChildByName("param_skeleton");
  1005. if (NULL == skeletalParam)
  1006. {
  1007. llwarns << "Failed to getChildByName("param_skeleton")"
  1008. << llendl;
  1009. return FALSE;
  1010. }
  1012. for( LLXmlTreeNode* bone = skeletalParam->getFirstChild(); bone; bone = skeletalParam->getNextChild() )
  1013. {
  1014. if (bone->hasName("bone"))
  1015. {
  1016. std::string name;
  1017. LLVector3 scale;
  1018. LLVector3 pos;
  1019. BOOL haspos = FALSE;
  1021. static LLStdStringHandle name_string = LLXmlTree::addAttributeString("name");
  1022. if (!bone->getFastAttributeString(name_string, name))
  1023. {
  1024. llwarns << "No bone name specified for skeletal param." << llendl;
  1025. continue;
  1026. }
  1028. static LLStdStringHandle scale_string = LLXmlTree::addAttributeString("scale");
  1029. if (!bone->getFastAttributeVector3(scale_string, scale))
  1030. {
  1031. llwarns << "No scale specified for bone " << name << "." << llendl;
  1032. continue;
  1033. }
  1035. // optional offset deformation (translation)
  1036. static LLStdStringHandle offset_string = LLXmlTree::addAttributeString("offset");
  1037. if (bone->getFastAttributeVector3(offset_string, pos))
  1038. {
  1039. haspos = TRUE;
  1040. }
  1041. mBoneInfoList.push_back(LLPolySkeletalBoneInfo(name, scale, pos, haspos));
  1042. }
  1043. else
  1044. {
  1045. llwarns << "Unrecognized element " << bone->getName() << " in skeletal distortion" << llendl;
  1046. continue;
  1047. }
  1048. }
  1049. return TRUE;
  1050. }
  1052. //-----------------------------------------------------------------------------
  1053. // LLPolySkeletalDistortion()
  1054. //-----------------------------------------------------------------------------
  1055. LLPolySkeletalDistortion::LLPolySkeletalDistortion(LLVOAvatar *avatarp)
  1056. {
  1057. mAvatar = avatarp;
  1058. mDefaultVec.setVec(0.001f, 0.001f, 0.001f);
  1059. }
  1061. //-----------------------------------------------------------------------------
  1062. // ~LLPolySkeletalDistortion()
  1063. //-----------------------------------------------------------------------------
  1064. LLPolySkeletalDistortion::~LLPolySkeletalDistortion()
  1065. {
  1066. }
  1068. BOOL LLPolySkeletalDistortion::setInfo(LLPolySkeletalDistortionInfo *info)
  1069. {
  1070. llassert(mInfo == NULL);
  1071. if (info->mID < 0)
  1072. return FALSE;
  1073. mInfo = info;
  1074. mID = info->mID;
  1075. setWeight(getDefaultWeight(), FALSE );
  1077. LLPolySkeletalDistortionInfo::bone_info_list_t::iterator iter;
  1078. for (iter = getInfo()->mBoneInfoList.begin(); iter != getInfo()->mBoneInfoList.end(); iter++)
  1079. {
  1080. LLPolySkeletalBoneInfo *bone_info = &(*iter);
  1081. LLJoint* joint = mAvatar->getJoint(bone_info->mBoneName);
  1082. if (!joint)
  1083. {
  1084. llwarns << "Joint " << bone_info->mBoneName << " not found." << llendl;
  1085. continue;
  1086. }
  1088. if (mJointScales.find(joint) != mJointScales.end())
  1089. {
  1090. llwarns << "Scale deformation already supplied for joint " << joint->getName() << "." << llendl;
  1091. }
  1093. // store it
  1094. mJointScales[joint] = bone_info->mScaleDeformation;
  1096. // apply to children that need to inherit it
  1097. for (LLJoint::child_list_t::iterator iter = joint->mChildren.begin();
  1098.  iter != joint->mChildren.end(); ++iter)
  1099. {
  1100. LLViewerJoint* child_joint = (LLViewerJoint*)(*iter);
  1101. if (child_joint->inheritScale())
  1102. {
  1103. LLVector3 childDeformation = LLVector3(child_joint->getScale());
  1104. childDeformation.scaleVec(bone_info->mScaleDeformation);
  1105. mJointScales[child_joint] = childDeformation;
  1106. }
  1107. }
  1109. if (bone_info->mHasPositionDeformation)
  1110. {
  1111. if (mJointOffsets.find(joint) != mJointOffsets.end())
  1112. {
  1113. llwarns << "Offset deformation already supplied for joint " << joint->getName() << "." << llendl;
  1114. }
  1115. mJointOffsets[joint] = bone_info->mPositionDeformation;
  1116. }
  1117. }
  1118. return TRUE;
  1119. }
  1121. /*virtual*/ LLViewerVisualParam* LLPolySkeletalDistortion::cloneParam(LLWearable* wearable) const
  1122. {
  1123. LLPolySkeletalDistortion *new_param = new LLPolySkeletalDistortion(mAvatar);
  1124. *new_param = *this;
  1125. return new_param;
  1126. }
  1128. //-----------------------------------------------------------------------------
  1129. // apply()
  1130. //-----------------------------------------------------------------------------
  1131. void LLPolySkeletalDistortion::apply( ESex avatar_sex )
  1132. {
  1133. F32 effective_weight = ( getSex() & avatar_sex ) ? mCurWeight : getDefaultWeight();
  1135. LLJoint* joint;
  1136. joint_vec_map_t::iterator iter;
  1138. for (iter = mJointScales.begin();
  1139.  iter != mJointScales.end();
  1140.  iter++)
  1141. {
  1142. joint = iter->first;
  1143. LLVector3 newScale = joint->getScale();
  1144. LLVector3 scaleDelta = iter->second;
  1145. newScale = newScale + (effective_weight * scaleDelta) - (mLastWeight * scaleDelta);
  1146. joint->setScale(newScale);
  1147. }
  1149. for (iter = mJointOffsets.begin();
  1150.  iter != mJointOffsets.end();
  1151.  iter++)
  1152. {
  1153. joint = iter->first;
  1154. LLVector3 newPosition = joint->getPosition();
  1155. LLVector3 positionDelta = iter->second;
  1156. newPosition = newPosition + (effective_weight * positionDelta) - (mLastWeight * positionDelta);
  1157. joint->setPosition(newPosition);
  1158. }
  1160. if (mLastWeight != mCurWeight && !mIsAnimating)
  1161. {
  1162. mAvatar->setSkeletonSerialNum(mAvatar->getSkeletonSerialNum() + 1);
  1163. }
  1164. mLastWeight = mCurWeight;
  1165. }
  1167. // End