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

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

游戏引擎

开发平台：

C++ Builder

lldrawpoolavatar.cpp：源码内容
  1. /** 
  2.  * @file lldrawpoolavatar.cpp
  3.  * @brief LLDrawPoolAvatar class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "lldrawpoolavatar.h"
  36. #include "llrender.h"
  38. #include "llvoavatar.h"
  39. #include "m3math.h"
  41. #include "lldrawable.h"
  42. #include "llface.h"
  43. #include "llsky.h"
  44. #include "llviewercamera.h"
  45. #include "llviewerregion.h"
  46. #include "noise.h"
  47. #include "pipeline.h"
  48. #include "llviewershadermgr.h"
  49. #include "llappviewer.h"
  50. #include "llrendersphere.h"
  51. #include "llviewerpartsim.h"
  53. static U32 sDataMask = LLDrawPoolAvatar::VERTEX_DATA_MASK;
  54. static U32 sBufferUsage = GL_STREAM_DRAW_ARB;
  55. static U32 sShaderLevel = 0;
  56. static LLGLSLShader* sVertexProgram = NULL;
  58. BOOL LLDrawPoolAvatar::sSkipOpaque = FALSE;
  59. BOOL LLDrawPoolAvatar::sSkipTransparent = FALSE;
  61. extern BOOL gUseGLPick;
  63. F32 CLOTHING_GRAVITY_EFFECT = 0.7f;
  64. F32 CLOTHING_ACCEL_FORCE_FACTOR = 0.2f;
  65. const S32 NUM_TEST_AVATARS = 30;
  66. const S32 MIN_PIXEL_AREA_2_PASS_SKINNING = 500000000;
  68. // Format for gAGPVertices
  69. // vertex format for bumpmapping:
  70. //  vertices   12
  71. //  pad     4
  72. //  normals    12
  73. //  pad     4
  74. //  texcoords0  8
  75. //  texcoords1  8
  76. // total       48
  77. //
  78. // for no bumpmapping
  79. //  vertices    12
  80. //  texcoords 8
  81. //  normals    12
  82. // total    32
  83. //
  85. S32 AVATAR_OFFSET_POS = 0;
  86. S32 AVATAR_OFFSET_NORMAL = 16;
  87. S32 AVATAR_OFFSET_TEX0 = 32;
  88. S32 AVATAR_OFFSET_TEX1 = 40;
  89. S32 AVATAR_VERTEX_BYTES = 48;
  91. BOOL gAvatarEmbossBumpMap = FALSE;
  92. static BOOL sRenderingSkinned = FALSE;
  93. S32 normal_channel = -1;
  94. S32 specular_channel = -1;
  95. S32 diffuse_channel = -1;
  97. static LLFastTimer::DeclareTimer FTM_SHADOW_AVATAR("Avatar Shadow");
  99. LLDrawPoolAvatar::LLDrawPoolAvatar() : 
  100. LLFacePool(POOL_AVATAR)
  101. {
  102. }
  104. //-----------------------------------------------------------------------------
  105. // instancePool()
  106. //-----------------------------------------------------------------------------
  107. LLDrawPool *LLDrawPoolAvatar::instancePool()
  108. {
  109. return new LLDrawPoolAvatar();
  110. }
  113. S32 LLDrawPoolAvatar::getVertexShaderLevel() const
  114. {
  115. return (S32) LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_AVATAR);
  116. }
  118. void LLDrawPoolAvatar::prerender()
  119. {
  120. mVertexShaderLevel = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_AVATAR);
  122. sShaderLevel = mVertexShaderLevel;
  124. if (sShaderLevel > 0)
  125. {
  126. sBufferUsage = GL_STATIC_DRAW_ARB;
  127. }
  128. else
  129. {
  130. sBufferUsage = GL_STREAM_DRAW_ARB;
  131. }
  132. }
  134. LLMatrix4& LLDrawPoolAvatar::getModelView()
  135. {
  136. static LLMatrix4 ret;
  138. ret.initRows(LLVector4(gGLModelView+0),
  139.  LLVector4(gGLModelView+4),
  140.  LLVector4(gGLModelView+8),
  141.  LLVector4(gGLModelView+12));
  143. return ret;
  144. }
  146. //-----------------------------------------------------------------------------
  147. // render()
  148. //-----------------------------------------------------------------------------
  151. S32 LLDrawPoolAvatar::getNumDeferredPasses()
  152. {
  153. return getNumPasses();
  154. }
  156. void LLDrawPoolAvatar::beginDeferredPass(S32 pass)
  157. {
  158. LLFastTimer t(FTM_RENDER_CHARACTERS);
  160. if (LLPipeline::sImpostorRender)
  161. {
  162. beginDeferredSkinned();
  163. return;
  164. }
  166. switch (pass)
  167. {
  168. case 0:
  169. beginDeferredImpostor();
  170. break;
  171. case 1:
  172. beginDeferredRigid();
  173. break;
  174. case 2:
  175. beginDeferredSkinned();
  176. break;
  177. }
  178. }
  180. void LLDrawPoolAvatar::endDeferredPass(S32 pass)
  181. {
  182. LLFastTimer t(FTM_RENDER_CHARACTERS);
  184. if (LLPipeline::sImpostorRender)
  185. {
  186. endDeferredSkinned();
  187. return;
  188. }
  190. switch (pass)
  191. {
  192. case 0:
  193. endDeferredImpostor();
  194. break;
  195. case 1:
  196. endDeferredRigid();
  197. break;
  198. case 2:
  199. endDeferredSkinned();
  200. break;
  201. }
  202. }
  204. void LLDrawPoolAvatar::renderDeferred(S32 pass)
  205. {
  206. render(pass);
  207. }
  209. S32 LLDrawPoolAvatar::getNumPostDeferredPasses()
  210. {
  211. return 1;
  212. }
  214. void LLDrawPoolAvatar::beginPostDeferredPass(S32 pass)
  215. {
  216. sSkipOpaque = TRUE;
  217. sShaderLevel = mVertexShaderLevel;
  218. sVertexProgram = &gDeferredAvatarAlphaProgram;
  220. sRenderingSkinned = TRUE;
  222. gPipeline.bindDeferredShader(*sVertexProgram);
  224. enable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  225. }
  227. void LLDrawPoolAvatar::endPostDeferredPass(S32 pass)
  228. {
  229. // if we're in software-blending, remember to set the fence _after_ we draw so we wait till this rendering is done
  230. sRenderingSkinned = FALSE;
  231. sSkipOpaque = FALSE;
  232. disable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  234. gPipeline.unbindDeferredShader(*sVertexProgram);
  236. sShaderLevel = mVertexShaderLevel;
  237. }
  239. void LLDrawPoolAvatar::renderPostDeferred(S32 pass)
  240. {
  241. render(2); //pass 2 = skinned
  242. }
  245. S32 LLDrawPoolAvatar::getNumShadowPasses()
  246. {
  247. return 1;
  248. }
  250. void LLDrawPoolAvatar::beginShadowPass(S32 pass)
  251. {
  252. LLFastTimer t(FTM_SHADOW_AVATAR);
  254. sVertexProgram = &gDeferredAvatarShadowProgram;
  255. if (sShaderLevel > 0)
  256. {
  257. gAvatarMatrixParam = sVertexProgram->mUniform[LLViewerShaderMgr::AVATAR_MATRIX];
  258. }
  259. gGL.setAlphaRejectSettings(LLRender::CF_GREATER_EQUAL, 0.2f);
  261. glColor4f(1,1,1,1);
  263. if ((sShaderLevel > 0))  // for hardware blending
  264. {
  265. sRenderingSkinned = TRUE;
  266. sVertexProgram->bind();
  267. enable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  268. }
  270. }
  272. void LLDrawPoolAvatar::endShadowPass(S32 pass)
  273. {
  274. LLFastTimer t(FTM_SHADOW_AVATAR);
  276. if (sShaderLevel > 0)
  277. {
  278. sRenderingSkinned = FALSE;
  279. sVertexProgram->unbind();
  280. disable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  281. }
  283. gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
  284. }
  286. void LLDrawPoolAvatar::renderShadow(S32 pass)
  287. {
  288. LLFastTimer t(FTM_SHADOW_AVATAR);
  290. if (mDrawFace.empty())
  291. {
  292. return;
  293. }
  295. const LLFace *facep = mDrawFace[0];
  296. if (!facep->getDrawable())
  297. {
  298. return;
  299. }
  300. LLVOAvatar *avatarp = (LLVOAvatar *)facep->getDrawable()->getVObj().get();
  302. if (avatarp->isDead() || avatarp->mIsDummy || avatarp->mDrawable.isNull())
  303. {
  304. return;
  305. }
  307. BOOL impostor = avatarp->isImpostor();
  308. if (impostor)
  309. {
  310. return;
  311. }
  313. avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
  315. }
  317. S32 LLDrawPoolAvatar::getNumPasses()
  318. {
  319. return LLPipeline::sImpostorRender ? 1 : 3;
  320. }
  322. void LLDrawPoolAvatar::render(S32 pass)
  323. {
  324. LLFastTimer t(FTM_RENDER_CHARACTERS);
  325. if (LLPipeline::sImpostorRender)
  326. {
  327. renderAvatars(NULL, 2);
  328. return;
  329. }
  331. renderAvatars(NULL, pass); // render all avatars
  332. }
  334. void LLDrawPoolAvatar::beginRenderPass(S32 pass)
  335. {
  336. LLFastTimer t(FTM_RENDER_CHARACTERS);
  337. //reset vertex buffer mappings
  338. LLVertexBuffer::unbind();
  340. if (LLPipeline::sImpostorRender)
  341. {
  342. beginSkinned();
  343. return;
  344. }
  346. switch (pass)
  347. {
  348. case 0:
  349. beginFootShadow();
  350. break;
  351. case 1:
  352. beginRigid();
  353. break;
  354. case 2:
  355. beginSkinned();
  356. break;
  357. }
  358. }
  360. void LLDrawPoolAvatar::endRenderPass(S32 pass)
  361. {
  362. LLFastTimer t(FTM_RENDER_CHARACTERS);
  364. if (LLPipeline::sImpostorRender)
  365. {
  366. endSkinned();
  367. return;
  368. }
  370. switch (pass)
  371. {
  372. case 0:
  373. endFootShadow();
  374. break;
  375. case 1:
  376. endRigid();
  377. break;
  378. case 2:
  379. endSkinned();
  380. }
  381. }
  383. void LLDrawPoolAvatar::beginFootShadow()
  384. {
  385. if (!LLPipeline::sReflectionRender)
  386. {
  387. LLVOAvatar::sRenderDistance = llclamp(LLVOAvatar::sRenderDistance, 16.f, 256.f);
  388. LLVOAvatar::sNumVisibleAvatars = 0;
  389. }
  391. gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
  392. diffuse_channel = 0;
  393. }
  395. void LLDrawPoolAvatar::endFootShadow()
  396. {
  397. gPipeline.enableLightsDynamic();
  398. }
  400. void LLDrawPoolAvatar::beginRigid()
  401. {
  402. if (gPipeline.canUseVertexShaders())
  403. {
  404. if (LLPipeline::sUnderWaterRender)
  405. {
  406. sVertexProgram = &gObjectSimpleWaterProgram;
  407. }
  408. else
  409. {
  410. sVertexProgram = &gObjectSimpleProgram;
  411. }
  413. if (sVertexProgram != NULL)
  414. { //eyeballs render with the specular shader
  415. sVertexProgram->bind();
  416. }
  417. }
  418. else
  419. {
  420. sVertexProgram = NULL;
  421. }
  422. }
  424. void LLDrawPoolAvatar::endRigid()
  425. {
  426. sShaderLevel = mVertexShaderLevel;
  427. if (sVertexProgram != NULL)
  428. {
  429. sVertexProgram->unbind();
  430. }
  431. }
  433. void LLDrawPoolAvatar::beginDeferredImpostor()
  434. {
  435. if (!LLPipeline::sReflectionRender)
  436. {
  437. LLVOAvatar::sRenderDistance = llclamp(LLVOAvatar::sRenderDistance, 16.f, 256.f);
  438. LLVOAvatar::sNumVisibleAvatars = 0;
  439. }
  441. sVertexProgram = &gDeferredImpostorProgram;
  443. normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::DEFERRED_NORMAL);
  444. specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
  445. diffuse_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  447. sVertexProgram->bind();
  448. }
  450. void LLDrawPoolAvatar::endDeferredImpostor()
  451. {
  452. sShaderLevel = mVertexShaderLevel;
  453. sVertexProgram->disableTexture(LLViewerShaderMgr::DEFERRED_NORMAL);
  454. sVertexProgram->disableTexture(LLViewerShaderMgr::SPECULAR_MAP);
  455. sVertexProgram->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  456. sVertexProgram->unbind();
  457. gGL.getTexUnit(0)->activate();
  458. }
  460. void LLDrawPoolAvatar::beginDeferredRigid()
  461. {
  462. sVertexProgram = &gDeferredDiffuseProgram;
  464. sVertexProgram->bind();
  465. }
  467. void LLDrawPoolAvatar::endDeferredRigid()
  468. {
  469. sShaderLevel = mVertexShaderLevel;
  470. sVertexProgram->unbind();
  471. gGL.getTexUnit(0)->activate();
  472. }
  475. void LLDrawPoolAvatar::beginSkinned()
  476. {
  477. if (sShaderLevel > 0)
  478. {
  479. if (LLPipeline::sUnderWaterRender)
  480. {
  481. sVertexProgram = &gAvatarWaterProgram;
  482. sShaderLevel = llmin((U32) 1, sShaderLevel);
  483. }
  484. else
  485. {
  486. sVertexProgram = &gAvatarProgram;
  487. }
  488. }
  489. else
  490. {
  491. if (LLPipeline::sUnderWaterRender)
  492. {
  493. sVertexProgram = &gObjectSimpleWaterProgram;
  494. }
  495. else
  496. {
  497. sVertexProgram = &gObjectSimpleProgram;
  498. }
  499. }
  501. if (sShaderLevel > 0)  // for hardware blending
  502. {
  503. sRenderingSkinned = TRUE;
  505. sVertexProgram->bind();
  506. if (sShaderLevel >= SHADER_LEVEL_CLOTH)
  507. {
  508. enable_cloth_weights(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_CLOTHING]);
  509. }
  510. enable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  512. if (sShaderLevel >= SHADER_LEVEL_BUMP)
  513. {
  514. enable_binormals(sVertexProgram->mAttribute[LLViewerShaderMgr::BINORMAL]);
  515. }
  517. sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
  518. gGL.getTexUnit(0)->activate();
  519. }
  520. else
  521. {
  522. if(gPipeline.canUseVertexShaders())
  523. {
  524. // software skinning, use a basic shader for windlight.
  525. // TODO: find a better fallback method for software skinning.
  526. sVertexProgram->bind();
  527. }
  528. }
  529. }
  531. void LLDrawPoolAvatar::endSkinned()
  532. {
  533. // if we're in software-blending, remember to set the fence _after_ we draw so we wait till this rendering is done
  534. if (sShaderLevel > 0)
  535. {
  536. sRenderingSkinned = FALSE;
  537. sVertexProgram->disableTexture(LLViewerShaderMgr::BUMP_MAP);
  538. gGL.getTexUnit(0)->activate();
  539. disable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  540. if (sShaderLevel >= SHADER_LEVEL_BUMP)
  541. {
  542. disable_binormals(sVertexProgram->mAttribute[LLViewerShaderMgr::BINORMAL]);
  543. }
  544. if ((sShaderLevel >= SHADER_LEVEL_CLOTH))
  545. {
  546. disable_cloth_weights(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_CLOTHING]);
  547. }
  549. sVertexProgram->unbind();
  550. sShaderLevel = mVertexShaderLevel;
  551. }
  552. else
  553. {
  554. if(gPipeline.canUseVertexShaders())
  555. {
  556. // software skinning, use a basic shader for windlight.
  557. // TODO: find a better fallback method for software skinning.
  558. sVertexProgram->unbind();
  559. }
  560. }
  562. gGL.getTexUnit(0)->activate();
  563. }
  565. void LLDrawPoolAvatar::beginDeferredSkinned()
  566. {
  567. sSkipTransparent = TRUE;
  568. sShaderLevel = mVertexShaderLevel;
  569. sVertexProgram = &gDeferredAvatarProgram;
  571. sRenderingSkinned = TRUE;
  573. sVertexProgram->bind();
  575. enable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  577. gGL.getTexUnit(0)->activate();
  578. }
  580. void LLDrawPoolAvatar::endDeferredSkinned()
  581. {
  582. sSkipTransparent = FALSE;
  583. // if we're in software-blending, remember to set the fence _after_ we draw so we wait till this rendering is done
  584. sRenderingSkinned = FALSE;
  585. disable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  586. sVertexProgram->unbind();
  588. sShaderLevel = mVertexShaderLevel;
  590. gGL.getTexUnit(0)->activate();
  591. }
  594. void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
  595. {
  596. if (pass == -1)
  597. {
  598. for (S32 i = 1; i < getNumPasses(); i++)
  599. { //skip foot shadows
  600. prerender();
  601. beginRenderPass(i);
  602. renderAvatars(single_avatar, i);
  603. endRenderPass(i);
  604. }
  606. return;
  607. }
  609. if (mDrawFace.empty() && !single_avatar)
  610. {
  611. return;
  612. }
  614. LLVOAvatar *avatarp;
  616. if (single_avatar)
  617. {
  618. avatarp = single_avatar;
  619. }
  620. else
  621. {
  622. const LLFace *facep = mDrawFace[0];
  623. if (!facep->getDrawable())
  624. {
  625. return;
  626. }
  627. avatarp = (LLVOAvatar *)facep->getDrawable()->getVObj().get();
  628. }
  630.     if (avatarp->isDead() || avatarp->mDrawable.isNull())
  631. {
  632. return;
  633. }
  635. if (!single_avatar && !avatarp->isFullyLoaded() )
  636. {
  637. if (pass==1 && (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES) || LLViewerPartSim::getMaxPartCount() <= 0))
  638. {
  639. // debug code to draw a sphere in place of avatar
  640. gGL.getTexUnit(0)->bind(LLViewerFetchedTexture::sWhiteImagep);
  641. gGL.setColorMask(true, true);
  642. LLVector3 pos = avatarp->getPositionAgent();
  643. gGL.color4f(1.0f, 1.0f, 1.0f, 0.7f);
  645. gGL.pushMatrix();  
  646. gGL.translatef((F32)(pos.mV[VX]),  
  647.    (F32)(pos.mV[VY]),  
  648. (F32)(pos.mV[VZ]));  
  649.  gGL.scalef(0.15f, 0.15f, 0.3f);  
  650.  gSphere.render();  
  651.  gGL.popMatrix();
  652.  gGL.setColorMask(true, false);
  653. }
  654. // don't render please
  655. return;
  656. }
  658. BOOL impostor = avatarp->isImpostor() && !single_avatar;
  660. if (impostor && pass != 0)
  661. { //don't draw anything but the impostor for impostored avatars
  662. return;
  663. }
  665. if (pass == 0 && !impostor && LLPipeline::sUnderWaterRender)
  666. { //don't draw foot shadows under water
  667. return;
  668. }
  670.     LLOverrideFaceColor color(this, 1.0f, 1.0f, 1.0f, 1.0f);
  672. if (pass == 0)
  673. {
  674. if (!LLPipeline::sReflectionRender)
  675. {
  676. LLVOAvatar::sNumVisibleAvatars++;
  677. }
  679. if (impostor)
  680. {
  681. if (LLPipeline::sRenderDeferred && avatarp->mImpostor.isComplete()) 
  682. {
  683. if (normal_channel > -1)
  684. {
  685. avatarp->mImpostor.bindTexture(2, normal_channel);
  686. }
  687. if (specular_channel > -1)
  688. {
  689. avatarp->mImpostor.bindTexture(1, specular_channel);
  690. }
  691. }
  692. avatarp->renderImpostor(LLColor4U(255,255,255,255), diffuse_channel);
  693. }
  694. else if (gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_FOOT_SHADOWS) && !LLPipeline::sRenderDeferred)
  695. {
  696. avatarp->renderFootShadows();
  697. }
  698. return;
  699. }
  701. if (single_avatar && avatarp->mSpecialRenderMode >= 1) // 1=anim preview, 2=image preview,  3=morph view
  702. {
  703. gPipeline.enableLightsAvatarEdit(LLColor4(.5f, .5f, .5f, 1.f));
  704. }
  706. if (pass == 1)
  707. {
  708. // render rigid meshes (eyeballs) first
  709. avatarp->renderRigid();
  710. return;
  711. }
  713. if (sShaderLevel > 0)
  714. {
  715. gAvatarMatrixParam = sVertexProgram->mUniform[LLViewerShaderMgr::AVATAR_MATRIX];
  716. }
  717.     
  718. if ((sShaderLevel >= SHADER_LEVEL_CLOTH))
  719. {
  720. LLMatrix4 rot_mat;
  721. LLViewerCamera::getInstance()->getMatrixToLocal(rot_mat);
  722. LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
  723. rot_mat *= cfr;
  725. LLVector4 wind;
  726. wind.setVec(avatarp->mWindVec);
  727. wind.mV[VW] = 0;
  728. wind = wind * rot_mat;
  729. wind.mV[VW] = avatarp->mWindVec.mV[VW];
  731. sVertexProgram->vertexAttrib4fv(LLViewerShaderMgr::AVATAR_WIND, wind.mV);
  732. F32 phase = -1.f * (avatarp->mRipplePhase);
  734. F32 freq = 7.f + (noise1(avatarp->mRipplePhase) * 2.f);
  735. LLVector4 sin_params(freq, freq, freq, phase);
  736. sVertexProgram->vertexAttrib4fv(LLViewerShaderMgr::AVATAR_SINWAVE, sin_params.mV);
  738. LLVector4 gravity(0.f, 0.f, -CLOTHING_GRAVITY_EFFECT, 0.f);
  739. gravity = gravity * rot_mat;
  740. sVertexProgram->vertexAttrib4fv(LLViewerShaderMgr::AVATAR_GRAVITY, gravity.mV);
  741. }
  743. if( !single_avatar || (avatarp == single_avatar) )
  744. {
  745. avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
  746. }
  747. }
  749. //-----------------------------------------------------------------------------
  750. // renderForSelect()
  751. //-----------------------------------------------------------------------------
  752. void LLDrawPoolAvatar::renderForSelect()
  753. {
  756. if (mDrawFace.empty())
  757. {
  758. return;
  759. }
  761. const LLFace *facep = mDrawFace[0];
  762. if (!facep->getDrawable())
  763. {
  764. return;
  765. }
  766. LLVOAvatar *avatarp = (LLVOAvatar *)facep->getDrawable()->getVObj().get();
  768. if (avatarp->isDead() || avatarp->mIsDummy || avatarp->mDrawable.isNull())
  769. {
  770. return;
  771. }
  773. S32 curr_shader_level = getVertexShaderLevel();
  774. S32 name = avatarp->mDrawable->getVObj()->mGLName;
  775. LLColor4U color((U8)(name >> 16), (U8)(name >> 8), (U8)name);
  777. BOOL impostor = avatarp->isImpostor();
  778. if (impostor)
  779. {
  780. gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_VERT_COLOR);
  781. gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_ALPHA, LLTexUnit::TBS_VERT_ALPHA);
  783. avatarp->renderImpostor(color);
  785. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  786. return;
  787. }
  789. sVertexProgram = &gAvatarPickProgram;
  790. if (curr_shader_level > 0)
  791. {
  792. gAvatarMatrixParam = sVertexProgram->mUniform[LLViewerShaderMgr::AVATAR_MATRIX];
  793. }
  794. gGL.setAlphaRejectSettings(LLRender::CF_GREATER_EQUAL, 0.2f);
  795. gGL.setSceneBlendType(LLRender::BT_REPLACE);
  797. glColor4ubv(color.mV);
  799. if (curr_shader_level > 0)  // for hardware blending
  800. {
  801. sRenderingSkinned = TRUE;
  802. sVertexProgram->bind();
  803. enable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  804. }
  806. avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
  808. // if we're in software-blending, remember to set the fence _after_ we draw so we wait till this rendering is done
  809. if (curr_shader_level > 0)
  810. {
  811. sRenderingSkinned = FALSE;
  812. sVertexProgram->unbind();
  813. disable_vertex_weighting(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT]);
  814. }
  816. gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
  817. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  819. // restore texture mode
  820. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  821. }
  823. //-----------------------------------------------------------------------------
  824. // getDebugTexture()
  825. //-----------------------------------------------------------------------------
  826. LLViewerTexture *LLDrawPoolAvatar::getDebugTexture()
  827. {
  828. if (mReferences.empty())
  829. {
  830. return NULL;
  831. }
  832. LLFace *face = mReferences[0];
  833. if (!face->getDrawable())
  834. {
  835. return NULL;
  836. }
  837. const LLViewerObject *objectp = face->getDrawable()->getVObj();
  839. // Avatar should always have at least 1 (maybe 3?) TE's.
  840. return objectp->getTEImage(0);
  841. }
  844. LLColor3 LLDrawPoolAvatar::getDebugColor() const
  845. {
  846. return LLColor3(0.f, 1.f, 0.f);
  847. }
  849. LLVertexBufferAvatar::LLVertexBufferAvatar()
  850. : LLVertexBuffer(sDataMask, 
  851. LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_AVATAR) > 0 ?
  852. GL_DYNAMIC_DRAW_ARB : 
  853. GL_STREAM_DRAW_ARB)
  854. {
  856. }
  859. void LLVertexBufferAvatar::setupVertexBuffer(U32 data_mask) const
  860. {
  861. if (sRenderingSkinned)
  862. {
  863. U8* base = useVBOs() ? NULL : mMappedData;
  865. glVertexPointer(3,GL_FLOAT, mStride, (void*)(base + 0));
  866. glNormalPointer(GL_FLOAT, mStride, (void*)(base + mOffsets[TYPE_NORMAL]));
  867. glTexCoordPointer(2,GL_FLOAT, mStride, (void*)(base + mOffsets[TYPE_TEXCOORD0]));
  869. set_vertex_weights(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_WEIGHT], mStride, (F32*)(base + mOffsets[TYPE_WEIGHT]));
  871. if (sShaderLevel >= LLDrawPoolAvatar::SHADER_LEVEL_BUMP)
  872. {
  873. set_binormals(sVertexProgram->mAttribute[LLViewerShaderMgr::BINORMAL], mStride, (LLVector3*)(base + mOffsets[TYPE_BINORMAL]));
  874. }
  876. if (sShaderLevel >= LLDrawPoolAvatar::SHADER_LEVEL_CLOTH)
  877. {
  878. set_vertex_clothing_weights(sVertexProgram->mAttribute[LLViewerShaderMgr::AVATAR_CLOTHING], mStride, (LLVector4*)(base + mOffsets[TYPE_CLOTHWEIGHT]));
  879. }
  880. }
  881. else
  882. {
  883. LLVertexBuffer::setupVertexBuffer(data_mask);
  884. }
  885. }