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

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

游戏引擎

开发平台：

C++ Builder

llviewerjoint.cpp：源码内容
  1. /** 
  2.  * @file llviewerjoint.cpp
  3.  * @brief Implementation of LLViewerJoint 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 "llviewerjoint.h"
  40. #include "llgl.h"
  41. #include "llrender.h"
  42. #include "llmath.h"
  43. #include "llglheaders.h"
  44. #include "llrendersphere.h"
  45. #include "llvoavatar.h"
  46. #include "pipeline.h"
  48. #define DEFAULT_LOD 0.0f
  50. const S32 MIN_PIXEL_AREA_3PASS_HAIR = 64*64;
  52. //-----------------------------------------------------------------------------
  53. // Static Data
  54. //-----------------------------------------------------------------------------
  55. BOOL LLViewerJoint::sDisableLOD = FALSE;
  57. //-----------------------------------------------------------------------------
  58. // LLViewerJoint()
  59. // Class Constructor
  60. //-----------------------------------------------------------------------------
  61. LLViewerJoint::LLViewerJoint()
  62. :       LLJoint()
  63. {
  64. init();
  65. }
  68. //-----------------------------------------------------------------------------
  69. // LLViewerJoint()
  70. // Class Constructor
  71. //-----------------------------------------------------------------------------
  72. LLViewerJoint::LLViewerJoint(const std::string &name, LLJoint *parent)
  73. : LLJoint(name, parent)
  74. {
  75. init();
  76. }
  79. void LLViewerJoint::init()
  80. {
  81. mValid = FALSE;
  82. mComponents = SC_JOINT | SC_BONE | SC_AXES;
  83. mMinPixelArea = DEFAULT_LOD;
  84. mPickName = PN_DEFAULT;
  85. mVisible = TRUE;
  86. mMeshID = 0;
  87. }
  90. //-----------------------------------------------------------------------------
  91. // ~LLViewerJoint()
  92. // Class Destructor
  93. //-----------------------------------------------------------------------------
  94. LLViewerJoint::~LLViewerJoint()
  95. {
  96. }
  99. //--------------------------------------------------------------------
  100. // setValid()
  101. //--------------------------------------------------------------------
  102. void LLViewerJoint::setValid( BOOL valid, BOOL recursive )
  103. {
  104. //----------------------------------------------------------------
  105. // set visibility for this joint
  106. //----------------------------------------------------------------
  107. mValid = valid;
  109. //----------------------------------------------------------------
  110. // set visibility for children
  111. //----------------------------------------------------------------
  112. if (recursive)
  113. {
  114. for (child_list_t::iterator iter = mChildren.begin();
  115.  iter != mChildren.end(); ++iter)
  116. {
  117. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  118. joint->setValid(valid, TRUE);
  119. }
  120. }
  122. }
  124. //--------------------------------------------------------------------
  125. // renderSkeleton()
  126. // DEBUG (UNUSED)
  127. //--------------------------------------------------------------------
  128. // void LLViewerJoint::renderSkeleton(BOOL recursive)
  129. // {
  130. //  F32 nc = 0.57735f;
  132. //  //----------------------------------------------------------------
  133. //  // push matrix stack
  134. //  //----------------------------------------------------------------
  135. //  glPushMatrix();
  137. //  //----------------------------------------------------------------
  138. //  // render the bone to my parent
  139. //  //----------------------------------------------------------------
  140. //  if (mComponents & SC_BONE)
  141. //  {
  142. //  drawBone();
  143. //  }
  145. //  //----------------------------------------------------------------
  146. //  // offset to joint position and 
  147. //  // rotate to our orientation
  148. //  //----------------------------------------------------------------
  149. //  glLoadIdentity();
  150. //  glMultMatrixf( &getWorldMatrix().mMatrix[0][0] );
  152. //  //----------------------------------------------------------------
  153. //  // render joint axes
  154. //  //----------------------------------------------------------------
  155. //  if (mComponents & SC_AXES)
  156. //  {
  157. //  gGL.begin(LLRender::LINES);
  158. //  gGL.color3f( 1.0f, 0.0f, 0.0f );
  159. //  gGL.vertex3f( 0.0f,            0.0f, 0.0f );
  160. //  gGL.vertex3f( 0.1f, 0.0f, 0.0f );
  162. //  gGL.color3f( 0.0f, 1.0f, 0.0f );
  163. //  gGL.vertex3f( 0.0f, 0.0f,            0.0f );
  164. //  gGL.vertex3f( 0.0f, 0.1f, 0.0f );
  166. //  gGL.color3f( 0.0f, 0.0f, 1.0f );
  167. //  gGL.vertex3f( 0.0f, 0.0f, 0.0f );
  168. //  gGL.vertex3f( 0.0f, 0.0f, 0.1f );
  169. //  gGL.end();
  170. //  }
  172. //  //----------------------------------------------------------------
  173. //  // render the joint graphic
  174. //  //----------------------------------------------------------------
  175. //  if (mComponents & SC_JOINT)
  176. //  {
  177. //  gGL.color3f( 1.0f, 1.0f, 0.0f );
  179. //  gGL.begin(LLRender::TRIANGLES);
  181. //  // joint top half
  182. //  glNormal3f(nc, nc, nc);
  183. //  gGL.vertex3f(0.0f,             0.0f, 0.05f);
  184. //  gGL.vertex3f(0.05f,       0.0f,       0.0f);
  185. //  gGL.vertex3f(0.0f,       0.05f,       0.0f);
  187. //  glNormal3f(-nc, nc, nc);
  188. //  gGL.vertex3f(0.0f,             0.0f, 0.05f);
  189. //  gGL.vertex3f(0.0f,       0.05f,       0.0f);
  190. //  gGL.vertex3f(-0.05f,      0.0f,       0.0f);
  192. //  glNormal3f(-nc, -nc, nc);
  193. //  gGL.vertex3f(0.0f,             0.0f, 0.05f);
  194. //  gGL.vertex3f(-0.05f,      0.0f,      0.0f);
  195. //  gGL.vertex3f(0.0f,      -0.05f,      0.0f);
  197. //  glNormal3f(nc, -nc, nc);
  198. //  gGL.vertex3f(0.0f,              0.0f, 0.05f);
  199. //  gGL.vertex3f(0.0f,       -0.05f,       0.0f);
  200. //  gGL.vertex3f(0.05f,        0.0f,       0.0f);
  202. //  // joint bottom half
  203. //  glNormal3f(nc, nc, -nc);
  204. //  gGL.vertex3f(0.0f,             0.0f, -0.05f);
  205. //  gGL.vertex3f(0.0f,       0.05f,        0.0f);
  206. //  gGL.vertex3f(0.05f,       0.0f,        0.0f);
  208. //  glNormal3f(-nc, nc, -nc);
  209. //  gGL.vertex3f(0.0f,             0.0f, -0.05f);
  210. //  gGL.vertex3f(-0.05f,      0.0f,        0.0f);
  211. //  gGL.vertex3f(0.0f,       0.05f,        0.0f);
  213. //  glNormal3f(-nc, -nc, -nc);
  214. //  gGL.vertex3f(0.0f,              0.0f, -0.05f);
  215. //  gGL.vertex3f(0.0f,       -0.05f,        0.0f);
  216. //  gGL.vertex3f(-0.05f,       0.0f,        0.0f);
  218. //  glNormal3f(nc, -nc, -nc);
  219. //  gGL.vertex3f(0.0f,             0.0f,  -0.05f);
  220. //  gGL.vertex3f(0.05f,       0.0f,         0.0f);
  221. //  gGL.vertex3f(0.0f,      -0.05f,         0.0f);
  223. //  gGL.end();
  224. //  }
  226. //  //----------------------------------------------------------------
  227. //  // render children
  228. //  //----------------------------------------------------------------
  229. //  if (recursive)
  230. //  {
  231. //  for (child_list_t::iterator iter = mChildren.begin();
  232. //   iter != mChildren.end(); ++iter)
  233. //  {
  234. //  LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  235. //  joint->renderSkeleton();
  236. //  }
  237. //  }
  239. //  //----------------------------------------------------------------
  240. //  // pop matrix stack
  241. //  //----------------------------------------------------------------
  242. //  glPopMatrix();
  243. // }
  246. //--------------------------------------------------------------------
  247. // render()
  248. //--------------------------------------------------------------------
  249. U32 LLViewerJoint::render( F32 pixelArea, BOOL first_pass, BOOL is_dummy )
  250. {
  251. stop_glerror();
  253. U32 triangle_count = 0;
  255. //----------------------------------------------------------------
  256. // ignore invisible objects
  257. //----------------------------------------------------------------
  258. if ( mValid )
  259. {
  262. //----------------------------------------------------------------
  263. // if object is transparent, defer it, otherwise
  264. // give the joint subclass a chance to draw itself
  265. //----------------------------------------------------------------
  266. if ( gRenderForSelect || is_dummy )
  267. {
  268. triangle_count += drawShape( pixelArea, first_pass, is_dummy );
  269. }
  270. else if (LLPipeline::sShadowRender)
  271. {
  272. triangle_count += drawShape(pixelArea, first_pass, is_dummy );
  273. }
  274. else if ( isTransparent() && !LLPipeline::sReflectionRender)
  275. {
  276. // Hair and Skirt
  277. if ((pixelArea > MIN_PIXEL_AREA_3PASS_HAIR))
  278. {
  279. // render all three passes
  280. LLGLDisable cull(GL_CULL_FACE);
  281. // first pass renders without writing to the z buffer
  282. {
  283. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  284. triangle_count += drawShape( pixelArea, first_pass, is_dummy );
  285. }
  286. // second pass writes to z buffer only
  287. gGL.setColorMask(false, false);
  288. {
  289. triangle_count += drawShape( pixelArea, FALSE, is_dummy  );
  290. }
  291. // third past respects z buffer and writes color
  292. gGL.setColorMask(true, false);
  293. {
  294. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  295. triangle_count += drawShape( pixelArea, FALSE, is_dummy  );
  296. }
  297. }
  298. else
  299. {
  300. // Render Inside (no Z buffer write)
  301. glCullFace(GL_FRONT);
  302. {
  303. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  304. triangle_count += drawShape( pixelArea, first_pass, is_dummy  );
  305. }
  306. // Render Outside (write to the Z buffer)
  307. glCullFace(GL_BACK);
  308. {
  309. triangle_count += drawShape( pixelArea, FALSE, is_dummy  );
  310. }
  311. }
  312. }
  313. else
  314. {
  315. // set up render state
  316. triangle_count += drawShape( pixelArea, first_pass );
  317. }
  318. }
  320. //----------------------------------------------------------------
  321. // render children
  322. //----------------------------------------------------------------
  323. for (child_list_t::iterator iter = mChildren.begin();
  324.  iter != mChildren.end(); ++iter)
  325. {
  326. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  327. F32 jointLOD = joint->getLOD();
  328. if (pixelArea >= jointLOD || sDisableLOD)
  329. {
  330. triangle_count += joint->render( pixelArea, TRUE, is_dummy );
  332. if (jointLOD != DEFAULT_LOD)
  333. {
  334. break;
  335. }
  336. }
  337. }
  339. return triangle_count;
  340. }
  343. //--------------------------------------------------------------------
  344. // drawBone()
  345. // DEBUG (UNUSED)
  346. //--------------------------------------------------------------------
  347. // void LLViewerJoint::drawBone()
  348. // {
  349. //  if ( mParent == NULL )
  350. //  return;
  352. //  F32 boneSize = 0.02f;
  354. //  // rotate to point to child (bone direction)
  355. //  glPushMatrix();
  357. //  LLVector3 boneX = getPosition();
  358. //  F32 length = boneX.normVec();
  360. //  LLVector3 boneZ(1.0f, 0.0f, 1.0f);
  362. //  LLVector3 boneY = boneZ % boneX;
  363. //  boneY.normVec();
  365. //  boneZ = boneX % boneY;
  367. //  LLMatrix4 rotateMat;
  368. //  rotateMat.setFwdRow( boneX );
  369. //  rotateMat.setLeftRow( boneY );
  370. //  rotateMat.setUpRow( boneZ );
  371. //  glMultMatrixf( &rotateMat.mMatrix[0][0] );
  373. //  // render the bone
  374. //  gGL.color3f( 0.5f, 0.5f, 0.0f );
  376. //  gGL.begin(LLRender::TRIANGLES);
  378. //  gGL.vertex3f( length,     0.0f,       0.0f);
  379. //  gGL.vertex3f( 0.0f,       boneSize,  0.0f);
  380. //  gGL.vertex3f( 0.0f,       0.0f,       boneSize);
  382. //  gGL.vertex3f( length,     0.0f,        0.0f);
  383. //  gGL.vertex3f( 0.0f,       0.0f,        -boneSize);
  384. //  gGL.vertex3f( 0.0f,       boneSize,   0.0f);
  386. //  gGL.vertex3f( length,     0.0f,        0.0f);
  387. //  gGL.vertex3f( 0.0f,       -boneSize,  0.0f);
  388. //  gGL.vertex3f( 0.0f,       0.0f,        -boneSize);
  390. //  gGL.vertex3f( length,     0.0f,        0.0f);
  391. //  gGL.vertex3f( 0.0f,       0.0f,        boneSize);
  392. //  gGL.vertex3f( 0.0f,       -boneSize,  0.0f);
  394. //  gGL.end();
  396. //  // restore matrix
  397. //  glPopMatrix();
  398. // }
  400. //--------------------------------------------------------------------
  401. // isTransparent()
  402. //--------------------------------------------------------------------
  403. BOOL LLViewerJoint::isTransparent()
  404. {
  405. return FALSE;
  406. }
  408. //--------------------------------------------------------------------
  409. // drawShape()
  410. //--------------------------------------------------------------------
  411. U32 LLViewerJoint::drawShape( F32 pixelArea, BOOL first_pass, BOOL is_dummy )
  412. {
  413. return 0;
  414. }
  416. //--------------------------------------------------------------------
  417. // setSkeletonComponents()
  418. //--------------------------------------------------------------------
  419. void LLViewerJoint::setSkeletonComponents( U32 comp, BOOL recursive )
  420. {
  421. mComponents = comp;
  422. if (recursive)
  423. {
  424. for (child_list_t::iterator iter = mChildren.begin();
  425.  iter != mChildren.end(); ++iter)
  426. {
  427. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  428. joint->setSkeletonComponents(comp, recursive);
  429. }
  430. }
  431. }
  433. void LLViewerJoint::updateFaceSizes(U32 &num_vertices, U32& num_indices, F32 pixel_area)
  434. {
  435. for (child_list_t::iterator iter = mChildren.begin();
  436.  iter != mChildren.end(); ++iter)
  437. {
  438. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  439. joint->updateFaceSizes(num_vertices, num_indices, pixel_area);
  440. }
  441. }
  443. void LLViewerJoint::updateFaceData(LLFace *face, F32 pixel_area, BOOL damp_wind)
  444. {
  445. for (child_list_t::iterator iter = mChildren.begin();
  446.  iter != mChildren.end(); ++iter)
  447. {
  448. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  449. joint->updateFaceData(face, pixel_area, damp_wind);
  450. }
  451. }
  453. void LLViewerJoint::updateJointGeometry()
  454. {
  455. for (child_list_t::iterator iter = mChildren.begin();
  456.  iter != mChildren.end(); ++iter)
  457. {
  458. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  459. joint->updateJointGeometry();
  460. }
  461. }
  464. BOOL LLViewerJoint::updateLOD(F32 pixel_area, BOOL activate)
  465. {
  466. BOOL lod_changed = FALSE;
  467. BOOL found_lod = FALSE;
  469. for (child_list_t::iterator iter = mChildren.begin();
  470.  iter != mChildren.end(); ++iter)
  471. {
  472. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  473. F32 jointLOD = joint->getLOD();
  475. if (found_lod || jointLOD == DEFAULT_LOD)
  476. {
  477. // we've already found a joint to enable, so enable the rest as alternatives
  478. lod_changed |= joint->updateLOD(pixel_area, TRUE);
  479. }
  480. else
  481. {
  482. if (pixel_area >= jointLOD || sDisableLOD)
  483. {
  484. lod_changed |= joint->updateLOD(pixel_area, TRUE);
  485. found_lod = TRUE;
  486. }
  487. else
  488. {
  489. lod_changed |= joint->updateLOD(pixel_area, FALSE);
  490. }
  491. }
  492. }
  493. return lod_changed;
  494. }
  496. void LLViewerJoint::dump()
  497. {
  498. for (child_list_t::iterator iter = mChildren.begin();
  499.  iter != mChildren.end(); ++iter)
  500. {
  501. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  502. joint->dump();
  503. }
  504. }
  506. void LLViewerJoint::setVisible(BOOL visible, BOOL recursive)
  507. {
  508. mVisible = visible;
  510. if (recursive)
  511. {
  512. for (child_list_t::iterator iter = mChildren.begin();
  513.  iter != mChildren.end(); ++iter)
  514. {
  515. LLViewerJoint* joint = (LLViewerJoint*)(*iter);
  516. joint->setVisible(visible, recursive);
  517. }
  518. }
  519. }
  522. void LLViewerJoint::setMeshesToChildren()
  523. {
  524. removeAllChildren();
  525. for (std::vector<LLViewerJointMesh*>::iterator iter = mMeshParts.begin();
  526. iter != mMeshParts.end(); iter++)
  527. {
  528. addChild((LLViewerJointMesh *) *iter);
  529. }
  530. }
  531. //-----------------------------------------------------------------------------
  532. // LLViewerJointCollisionVolume()
  533. //-----------------------------------------------------------------------------
  535. LLViewerJointCollisionVolume::LLViewerJointCollisionVolume()
  536. {
  537. mUpdateXform = FALSE;
  538. }
  540. LLViewerJointCollisionVolume::LLViewerJointCollisionVolume(const std::string &name, LLJoint *parent) : LLViewerJoint(name, parent)
  541. {
  543. }
  545. void LLViewerJointCollisionVolume::renderCollision()
  546. {
  547. updateWorldMatrix();
  549. gGL.pushMatrix();
  550. glMultMatrixf( &mXform.getWorldMatrix().mMatrix[0][0] );
  552. gGL.color3f( 0.f, 0.f, 1.f );
  554. gGL.begin(LLRender::LINES);
  556. LLVector3 v[] = 
  557. {
  558. LLVector3(1,0,0),
  559. LLVector3(-1,0,0),
  560. LLVector3(0,1,0),
  561. LLVector3(0,-1,0),
  563. LLVector3(0,0,-1),
  564. LLVector3(0,0,1),
  565. };
  567. //sides
  568. gGL.vertex3fv(v[0].mV); 
  569. gGL.vertex3fv(v[2].mV);
  571. gGL.vertex3fv(v[0].mV); 
  572. gGL.vertex3fv(v[3].mV);
  574. gGL.vertex3fv(v[1].mV); 
  575. gGL.vertex3fv(v[2].mV);
  577. gGL.vertex3fv(v[1].mV); 
  578. gGL.vertex3fv(v[3].mV);
  581. //top
  582. gGL.vertex3fv(v[0].mV); 
  583. gGL.vertex3fv(v[4].mV);
  585. gGL.vertex3fv(v[1].mV); 
  586. gGL.vertex3fv(v[4].mV);
  588. gGL.vertex3fv(v[2].mV); 
  589. gGL.vertex3fv(v[4].mV);
  591. gGL.vertex3fv(v[3].mV); 
  592. gGL.vertex3fv(v[4].mV);
  595. //bottom
  596. gGL.vertex3fv(v[0].mV); 
  597. gGL.vertex3fv(v[5].mV);
  599. gGL.vertex3fv(v[1].mV); 
  600. gGL.vertex3fv(v[5].mV);
  602. gGL.vertex3fv(v[2].mV); 
  603. gGL.vertex3fv(v[5].mV);
  605. gGL.vertex3fv(v[3].mV); 
  606. gGL.vertex3fv(v[5].mV);
  608. gGL.end();
  610. gGL.popMatrix();
  611. }
  613. LLVector3 LLViewerJointCollisionVolume::getVolumePos(LLVector3 &offset)
  614. {
  615. mUpdateXform = TRUE;
  617. LLVector3 result = offset;
  618. result.scaleVec(getScale());
  619. result.rotVec(getWorldRotation());
  620. result += getWorldPosition();
  622. return result;
  623. }
  625. // End