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

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

游戏引擎

开发平台：

C++ Builder

lldrawpoolbump.cpp：源码内容
  1. /** 
  2.  * @file lldrawpoolbump.cpp
  3.  * @brief LLDrawPoolBump class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2003-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 "lldrawpoolbump.h"
  37. #include "llstl.h"
  38. #include "llviewercontrol.h"
  39. #include "lldir.h"
  40. #include "m3math.h"
  41. #include "m4math.h"
  42. #include "v4math.h"
  43. #include "llglheaders.h"
  44. #include "llrender.h"
  46. #include "llcubemap.h"
  47. #include "lldrawable.h"
  48. #include "llface.h"
  49. #include "llsky.h"
  50. #include "lltextureentry.h"
  51. #include "llviewercamera.h"
  52. #include "llviewertexturelist.h"
  53. #include "pipeline.h"
  54. #include "llspatialpartition.h"
  55. #include "llviewershadermgr.h"
  57. //#include "llimagebmp.h"
  58. //#include "../tools/imdebug/imdebug.h"
  60. // static
  61. LLStandardBumpmap gStandardBumpmapList[TEM_BUMPMAP_COUNT]; 
  63. // static
  64. U32 LLStandardBumpmap::sStandardBumpmapCount = 0;
  66. // static
  67. LLBumpImageList gBumpImageList;
  69. const S32 STD_BUMP_LATEST_FILE_VERSION = 1;
  71. const U32 VERTEX_MASK_SHINY = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_COLOR;
  72. const U32 VERTEX_MASK_BUMP = LLVertexBuffer::MAP_VERTEX |LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_TEXCOORD1;
  74. U32 LLDrawPoolBump::sVertexMask = VERTEX_MASK_SHINY;
  77. static LLGLSLShader* shader = NULL;
  78. static S32 cube_channel = -1;
  79. static S32 diffuse_channel = -1;
  80. static S32 bump_channel = -1;
  82. // static 
  83. void LLStandardBumpmap::init()
  84. {
  85. LLStandardBumpmap::restoreGL();
  86. }
  88. // static 
  89. void LLStandardBumpmap::shutdown()
  90. {
  91. LLStandardBumpmap::destroyGL();
  92. }
  94. // static 
  95. void LLStandardBumpmap::restoreGL()
  96. {
  97. llassert( LLStandardBumpmap::sStandardBumpmapCount == 0 );
  98. gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount++] = LLStandardBumpmap("None"); // BE_NO_BUMP
  99. gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount++] = LLStandardBumpmap("Brightness"); // BE_BRIGHTNESS
  100. gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount++] = LLStandardBumpmap("Darkness"); // BE_DARKNESS
  102. std::string file_name = gDirUtilp->getExpandedFilename( LL_PATH_APP_SETTINGS, "std_bump.ini" );
  103. LLFILE* file = LLFile::fopen( file_name, "rt" );  /*Flawfinder: ignore*/
  104. if( !file )
  105. {
  106. llwarns << "Could not open std_bump <" << file_name << ">" << llendl;
  107. return;
  108. }
  110. S32 file_version = 0;
  112. S32 fields_read = fscanf( file, "LLStandardBumpmap version %d", &file_version );
  113. if( fields_read != 1 )
  114. {
  115. llwarns << "Bad LLStandardBumpmap header" << llendl;
  116. return;
  117. }
  119. if( file_version > STD_BUMP_LATEST_FILE_VERSION )
  120. {
  121. llwarns << "LLStandardBumpmap has newer version (" << file_version << ") than viewer (" << STD_BUMP_LATEST_FILE_VERSION << ")" << llendl;
  122. return;
  123. }
  125. while( !feof(file) && (LLStandardBumpmap::sStandardBumpmapCount < (U32)TEM_BUMPMAP_COUNT) )
  126. {
  127. // *NOTE: This buffer size is hard coded into scanf() below.
  128. char label[2048] = ""; /* Flawfinder: ignore */
  129. char bump_image_id[2048] = ""; /* Flawfinder: ignore */
  130. fields_read = fscanf( /* Flawfinder: ignore */
  131. file, "n%2047s %2047s", label, bump_image_id);
  132. if( EOF == fields_read )
  133. {
  134. break;
  135. }
  136. if( fields_read != 2 )
  137. {
  138. llwarns << "Bad LLStandardBumpmap entry" << llendl;
  139. return;
  140. }
  142. //  llinfos << "Loading bumpmap: " << bump_image_id << " from viewerart" << llendl;
  143. gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount].mLabel = label;
  144. gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount].mImage = 
  145. LLViewerTextureManager::getFetchedTexture(LLUUID(bump_image_id),
  146. TRUE, 
  147. LLViewerTexture::BOOST_NONE, 
  148. LLViewerTexture::LOD_TEXTURE,
  149. 0, 
  150. 0);
  151. gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount].mImage->setLoadedCallback(LLBumpImageList::onSourceStandardLoaded, 0, TRUE, FALSE, NULL );
  152. LLStandardBumpmap::sStandardBumpmapCount++;
  153. }
  155. fclose( file );
  156. }
  158. // static
  159. void LLStandardBumpmap::destroyGL()
  160. {
  161. for( U32 i = 0; i < LLStandardBumpmap::sStandardBumpmapCount; i++ )
  162. {
  163. gStandardBumpmapList[i].mLabel.assign("");
  164. gStandardBumpmapList[i].mImage = NULL;
  165. }
  166. sStandardBumpmapCount = 0;
  167. }
  171. ////////////////////////////////////////////////////////////////
  173. LLDrawPoolBump::LLDrawPoolBump() 
  174. :  LLRenderPass(LLDrawPool::POOL_BUMP)
  175. {
  176. mShiny = FALSE;
  177. }
  180. void LLDrawPoolBump::prerender()
  181. {
  182. mVertexShaderLevel = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
  183. }
  185. // static
  186. S32 LLDrawPoolBump::numBumpPasses()
  187. {
  188. if (gSavedSettings.getBOOL("RenderObjectBump"))
  189. {
  190. if (mVertexShaderLevel > 1)
  191. {
  192. if (LLPipeline::sImpostorRender)
  193. {
  194. return 2;
  195. }
  196. else
  197. {
  198. return 3;
  199. }
  200. }
  201. else if (LLPipeline::sImpostorRender)
  202. {
  203. return 1;
  204. }
  205. else
  206. {
  207. return 2;
  208. }
  209. }
  210.     else
  211. {
  212. return 0;
  213. }
  214. }
  216. S32 LLDrawPoolBump::getNumPasses()
  217. {
  218. return numBumpPasses();
  219. }
  221. void LLDrawPoolBump::beginRenderPass(S32 pass)
  222. {
  223. LLFastTimer t(FTM_RENDER_BUMP);
  224. switch( pass )
  225. {
  226. case 0:
  227. beginShiny();
  228. break;
  229. case 1:
  230. if (mVertexShaderLevel > 1)
  231. {
  232. beginFullbrightShiny();
  233. }
  234. else 
  235. {
  236. beginBump();
  237. }
  238. break;
  239. case 2:
  240. beginBump();
  241. break;
  242. default:
  243. llassert(0);
  244. break;
  245. }
  246. }
  248. void LLDrawPoolBump::render(S32 pass)
  249. {
  250. LLFastTimer t(FTM_RENDER_BUMP);
  252. if (!gPipeline.hasRenderType(LLDrawPool::POOL_SIMPLE))
  253. {
  254. return;
  255. }
  257. switch( pass )
  258. {
  259. case 0:
  260. renderShiny();
  261. break;
  262. case 1:
  263. if (mVertexShaderLevel > 1)
  264. {
  265. renderFullbrightShiny();
  266. }
  267. else 
  268. {
  269. renderBump(); 
  270. }
  271. break;
  272. case 2:
  273. renderBump();
  274. break;
  275. default:
  276. llassert(0);
  277. break;
  278. }
  279. }
  281. void LLDrawPoolBump::endRenderPass(S32 pass)
  282. {
  283. LLFastTimer t(FTM_RENDER_BUMP);
  284. switch( pass )
  285. {
  286. case 0:
  287. endShiny();
  288. break;
  289. case 1:
  290. if (mVertexShaderLevel > 1)
  291. {
  292. endFullbrightShiny();
  293. }
  294. else 
  295. {
  296. endBump();
  297. }
  298. break;
  299. case 2:
  300. endBump();
  301. break;
  302. default:
  303. llassert(0);
  304. break;
  305. }
  306. }
  308. //static
  309. void LLDrawPoolBump::beginShiny(bool invisible)
  310. {
  311. LLFastTimer t(FTM_RENDER_SHINY);
  312. if ((!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY))|| 
  313. (invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY)))
  314. {
  315. return;
  316. }
  318. mShiny = TRUE;
  319. sVertexMask = VERTEX_MASK_SHINY;
  320. // Second pass: environment map
  321. if (!invisible && mVertexShaderLevel > 1)
  322. {
  323. sVertexMask = VERTEX_MASK_SHINY | LLVertexBuffer::MAP_TEXCOORD0;
  324. }
  326. if (LLPipeline::sUnderWaterRender)
  327. {
  328. shader = &gObjectShinyWaterProgram;
  329. }
  330. else
  331. {
  332. shader = &gObjectShinyProgram;
  333. }
  335. LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;
  336. if( cube_map )
  337. {
  338. if (!invisible && LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT) > 0 )
  339. {
  340. LLMatrix4 mat;
  341. mat.initRows(LLVector4(gGLModelView+0),
  342.  LLVector4(gGLModelView+4),
  343.  LLVector4(gGLModelView+8),
  344.  LLVector4(gGLModelView+12));
  345. shader->bind();
  346. LLVector3 vec = LLVector3(gShinyOrigin) * mat;
  347. LLVector4 vec4(vec, gShinyOrigin.mV[3]);
  348. shader->uniform4fv(LLViewerShaderMgr::SHINY_ORIGIN, 1, vec4.mV);
  349. if (mVertexShaderLevel > 1)
  350. {
  351. cube_map->setMatrix(1);
  352. // Make sure that texture coord generation happens for tex unit 1, as that's the one we use for 
  353. // the cube map in the one pass shiny shaders
  354. cube_channel = shader->enableTexture(LLViewerShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
  355. cube_map->enableTexture(cube_channel);
  356. cube_map->enableTextureCoords(1);
  357. diffuse_channel = shader->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  358. }
  359. else
  360. {
  361. cube_channel = shader->enableTexture(LLViewerShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
  362. diffuse_channel = -1;
  363. cube_map->setMatrix(0);
  364. cube_map->enable(cube_channel);
  365. }
  366. gGL.getTexUnit(cube_channel)->bind(cube_map);
  367. gGL.getTexUnit(0)->activate();
  368. }
  369. else
  370. {
  371. cube_channel = 0;
  372. diffuse_channel = -1;
  373. gGL.getTexUnit(0)->disable();
  374. cube_map->enable(0);
  375. cube_map->setMatrix(0);
  376. gGL.getTexUnit(0)->bind(cube_map);
  378. gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_TEX_COLOR);
  379. gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_VERT_ALPHA);
  380. }
  381. }
  382. }
  384. void LLDrawPoolBump::renderShiny(bool invisible)
  385. {
  386. LLFastTimer t(FTM_RENDER_SHINY);
  387. if ((!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY))|| 
  388. (invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY)))
  389. {
  390. return;
  391. }
  393. if( gSky.mVOSkyp->getCubeMap() )
  394. {
  395. LLGLEnable blend_enable(GL_BLEND);
  396. if (!invisible && mVertexShaderLevel > 1)
  397. {
  398. LLRenderPass::renderTexture(LLRenderPass::PASS_SHINY, sVertexMask);
  399. }
  400. else if (!invisible)
  401. {
  402. renderGroups(LLRenderPass::PASS_SHINY, sVertexMask);
  403. }
  404. else // invisible
  405. {
  406. renderGroups(LLRenderPass::PASS_INVISI_SHINY, sVertexMask);
  407. }
  408. }
  409. }
  411. void LLDrawPoolBump::endShiny(bool invisible)
  412. {
  413. LLFastTimer t(FTM_RENDER_SHINY);
  414. if ((!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY))|| 
  415. (invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY)))
  416. {
  417. return;
  418. }
  420. LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;
  421. if( cube_map )
  422. {
  423. cube_map->disable();
  424. cube_map->restoreMatrix();
  426. if (!invisible && mVertexShaderLevel > 1)
  427. {
  428. shader->disableTexture(LLViewerShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
  430. if (LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT) > 0)
  431. {
  432. if (diffuse_channel != 0)
  433. {
  434. shader->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  435. }
  436. }
  437. shader->unbind();
  438. }
  439. }
  440. gGL.getTexUnit(diffuse_channel)->disable();
  441. gGL.getTexUnit(cube_channel)->disable();
  443. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  444. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  446. diffuse_channel = -1;
  447. cube_channel = 0;
  448. mShiny = FALSE;
  449. }
  451. void LLDrawPoolBump::beginFullbrightShiny()
  452. {
  453. LLFastTimer t(FTM_RENDER_SHINY);
  454. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_FULLBRIGHT_SHINY))
  455. {
  456. return;
  457. }
  459. sVertexMask = VERTEX_MASK_SHINY | LLVertexBuffer::MAP_TEXCOORD0;
  461. // Second pass: environment map
  463. if (LLPipeline::sUnderWaterRender)
  464. {
  465. shader = &gObjectShinyWaterProgram;
  466. }
  467. else
  468. {
  469. shader = &gObjectFullbrightShinyProgram;
  470. }
  472. LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;
  473. if( cube_map )
  474. {
  475. LLMatrix4 mat;
  476. mat.initRows(LLVector4(gGLModelView+0),
  477.  LLVector4(gGLModelView+4),
  478.  LLVector4(gGLModelView+8),
  479.  LLVector4(gGLModelView+12));
  480. shader->bind();
  481. LLVector3 vec = LLVector3(gShinyOrigin) * mat;
  482. LLVector4 vec4(vec, gShinyOrigin.mV[3]);
  483. shader->uniform4fv(LLViewerShaderMgr::SHINY_ORIGIN, 1, vec4.mV);
  485. cube_map->setMatrix(1);
  486. // Make sure that texture coord generation happens for tex unit 1, as that's the one we use for 
  487. // the cube map in the one pass shiny shaders
  488. gGL.getTexUnit(1)->disable();
  489. cube_channel = shader->enableTexture(LLViewerShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
  490. cube_map->enableTexture(cube_channel);
  491. cube_map->enableTextureCoords(1);
  492. diffuse_channel = shader->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  494. gGL.getTexUnit(cube_channel)->bind(cube_map);
  495. gGL.getTexUnit(0)->activate();
  496. }
  497. mShiny = TRUE;
  498. }
  500. void LLDrawPoolBump::renderFullbrightShiny()
  501. {
  502. LLFastTimer t(FTM_RENDER_SHINY);
  503. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_FULLBRIGHT_SHINY))
  504. {
  505. return;
  506. }
  508. if( gSky.mVOSkyp->getCubeMap() )
  509. {
  510. LLGLEnable blend_enable(GL_BLEND);
  511. LLRenderPass::renderTexture(LLRenderPass::PASS_FULLBRIGHT_SHINY, sVertexMask);
  512. }
  513. }
  515. void LLDrawPoolBump::endFullbrightShiny()
  516. {
  517. LLFastTimer t(FTM_RENDER_SHINY);
  518. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_FULLBRIGHT_SHINY))
  519. {
  520. return;
  521. }
  523. LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;
  524. if( cube_map )
  525. {
  526. cube_map->disable();
  527. cube_map->restoreMatrix();
  529. if (diffuse_channel != 0)
  530. {
  531. shader->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  532. }
  533. gGL.getTexUnit(0)->activate();
  534. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  536. shader->unbind();
  537. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  538. }
  540. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  541. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  543. diffuse_channel = -1;
  544. cube_channel = 0;
  545. mShiny = FALSE;
  546. }
  548. void LLDrawPoolBump::renderGroup(LLSpatialGroup* group, U32 type, U32 mask, BOOL texture = TRUE)
  549. {
  550. LLSpatialGroup::drawmap_elem_t& draw_info = group->mDrawMap[type];
  552. for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k) 
  553. {
  554. LLDrawInfo& params = **k;
  556. applyModelMatrix(params);
  558. if (params.mGroup)
  559. {
  560. params.mGroup->rebuildMesh();
  561. }
  562. params.mVertexBuffer->setBuffer(mask);
  563. params.mVertexBuffer->drawRange(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
  564. gPipeline.addTrianglesDrawn(params.mCount/3);
  565. }
  566. }
  569. // static
  570. BOOL LLDrawPoolBump::bindBumpMap(LLDrawInfo& params, S32 channel)
  571. {
  572. LLViewerTexture* bump = NULL;
  574. U8 bump_code = params.mBump;
  576. //Note: texture atlas does not support bump texture now.
  577. LLViewerFetchedTexture* tex = LLViewerTextureManager::staticCastToFetchedTexture(params.mTexture) ;
  578. if(!tex)
  579. {
  580. //if the texture is not a fetched texture
  581. return FALSE;
  582. }
  584. switch( bump_code )
  585. {
  586. case BE_NO_BUMP:
  587. break;
  588. case BE_BRIGHTNESS: 
  589. case BE_DARKNESS:
  590. bump = gBumpImageList.getBrightnessDarknessImage( tex, bump_code );
  591. break;
  593. default:
  594. if( bump_code < LLStandardBumpmap::sStandardBumpmapCount )
  595. {
  596. bump = gStandardBumpmapList[bump_code].mImage;
  597. gBumpImageList.addTextureStats(bump_code, tex->getID(), params.mVSize);
  598. }
  599. break;
  600. }
  602. if (bump)
  603. {
  604. if (channel == -2)
  605. {
  606. gGL.getTexUnit(1)->bind(bump);
  607. gGL.getTexUnit(0)->bind(bump);
  608. }
  609. else
  610. {
  611. gGL.getTexUnit(channel)->bind(bump);
  612. }
  614. return TRUE;
  615. }
  617. return FALSE;
  618. }
  620. //static
  621. void LLDrawPoolBump::beginBump()
  622. {
  623. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
  624. {
  625. return;
  626. }
  628. sVertexMask = VERTEX_MASK_BUMP;
  629. LLFastTimer t(FTM_RENDER_BUMP);
  630. // Optional second pass: emboss bump map
  631. stop_glerror();
  633. // TEXTURE UNIT 0
  634. // Output.rgb = texture at texture coord 0
  635. gGL.getTexUnit(0)->activate();
  637. gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_TEX_ALPHA);
  638. gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_TEX_ALPHA);
  640. // TEXTURE UNIT 1
  641. gGL.getTexUnit(1)->activate();
  642.  
  643. gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);
  645. gGL.getTexUnit(1)->setTextureColorBlend(LLTexUnit::TBO_ADD_SIGNED, LLTexUnit::TBS_PREV_COLOR, LLTexUnit::TBS_ONE_MINUS_TEX_ALPHA);
  646. gGL.getTexUnit(1)->setTextureAlphaBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_TEX_ALPHA);
  648. // src = tex0 + (1 - tex1) - 0.5
  649. // = (bump0/2 + 0.5) + (1 - (bump1/2 + 0.5)) - 0.5
  650. // = (1 + bump0 - bump1) / 2
  653. // Blend: src * dst + dst * src
  654. // = 2 * src * dst
  655. // = 2 * ((1 + bump0 - bump1) / 2) * dst   [0 - 2 * dst]
  656. // = (1 + bump0 - bump1) * dst.rgb
  657. // = dst.rgb + dst.rgb * (bump0 - bump1)
  658. gGL.setSceneBlendType(LLRender::BT_MULT_X2);
  659. gGL.getTexUnit(0)->activate();
  660. stop_glerror();
  662. gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
  663. }
  665. //static
  666. void LLDrawPoolBump::renderBump()
  667. {
  668. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
  669. {
  670. return;
  671. }
  673. LLFastTimer ftm(FTM_RENDER_BUMP);
  674. LLGLDisable fog(GL_FOG);
  675. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_LEQUAL);
  676. LLGLEnable blend(GL_BLEND);
  677. glColor4f(1,1,1,1);
  678. /// Get rid of z-fighting with non-bump pass.
  679. LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
  680. glPolygonOffset(-1.0f, -1.0f);
  681. renderBump(LLRenderPass::PASS_BUMP, sVertexMask);
  682. }
  684. //static
  685. void LLDrawPoolBump::endBump()
  686. {
  687. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
  688. {
  689. return;
  690. }
  692. // Disable texture unit 1
  693. gGL.getTexUnit(1)->activate();
  694. gGL.getTexUnit(1)->disable();
  695. gGL.getTexUnit(1)->setTextureBlendType(LLTexUnit::TB_MULT);
  697. // Disable texture unit 0
  698. gGL.getTexUnit(0)->activate();
  699. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  701. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  702. }
  704. void LLDrawPoolBump::beginDeferredPass(S32 pass)
  705. {
  706. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
  707. {
  708. return;
  709. }
  710. LLFastTimer ftm(FTM_RENDER_BUMP);
  711. mShiny = TRUE;
  712. gDeferredBumpProgram.bind();
  713. diffuse_channel = gDeferredBumpProgram.enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  714. bump_channel = gDeferredBumpProgram.enableTexture(LLViewerShaderMgr::BUMP_MAP);
  715. gGL.getTexUnit(diffuse_channel)->unbind(LLTexUnit::TT_TEXTURE);
  716. gGL.getTexUnit(bump_channel)->unbind(LLTexUnit::TT_TEXTURE);
  717. }
  719. void LLDrawPoolBump::endDeferredPass(S32 pass)
  720. {
  721. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
  722. {
  723. return;
  724. }
  725. LLFastTimer ftm(FTM_RENDER_BUMP);
  726. mShiny = FALSE;
  727. gDeferredBumpProgram.disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  728. gDeferredBumpProgram.disableTexture(LLViewerShaderMgr::BUMP_MAP);
  729. gDeferredBumpProgram.unbind();
  730. gGL.getTexUnit(0)->activate();
  731. }
  733. void LLDrawPoolBump::renderDeferred(S32 pass)
  734. {
  735. if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
  736. {
  737. return;
  738. }
  739. LLFastTimer ftm(FTM_RENDER_BUMP);
  741. U32 type = LLRenderPass::PASS_BUMP;
  742. LLCullResult::drawinfo_list_t::iterator begin = gPipeline.beginRenderMap(type);
  743. LLCullResult::drawinfo_list_t::iterator end = gPipeline.endRenderMap(type);
  745. U32 mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_BINORMAL | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_COLOR;
  747. for (LLCullResult::drawinfo_list_t::iterator i = begin; i != end; ++i)
  748. {
  749. LLDrawInfo& params = **i;
  751. LLDrawPoolBump::bindBumpMap(params, bump_channel);
  752. pushBatch(params, mask, TRUE);
  753. }
  754. }
  756. void LLDrawPoolBump::beginPostDeferredPass(S32 pass)
  757. {
  758. beginFullbrightShiny();
  759. }
  761. void LLDrawPoolBump::endPostDeferredPass(S32 pass)
  762. {
  763. endFullbrightShiny();
  764. }
  766. void LLDrawPoolBump::renderPostDeferred(S32 pass)
  767. {
  768. renderFullbrightShiny();
  769. }
  771. ////////////////////////////////////////////////////////////////
  772. // List of one-component bump-maps created from other texures.
  775. //const LLUUID TEST_BUMP_ID("3d33eaf2-459c-6f97-fd76-5fce3fc29447");
  777. void LLBumpImageList::init()
  778. {
  779. llassert( mBrightnessEntries.size() == 0 );
  780. llassert( mDarknessEntries.size() == 0 );
  782. LLStandardBumpmap::init();
  783. }
  785. void LLBumpImageList::shutdown()
  786. {
  787. mBrightnessEntries.clear();
  788. mDarknessEntries.clear();
  789. LLStandardBumpmap::shutdown();
  790. }
  792. void LLBumpImageList::destroyGL()
  793. {
  794. mBrightnessEntries.clear();
  795. mDarknessEntries.clear();
  796. LLStandardBumpmap::destroyGL();
  797. }
  799. void LLBumpImageList::restoreGL()
  800. {
  801. // Images will be recreated as they are needed.
  802. LLStandardBumpmap::restoreGL();
  803. }
  806. LLBumpImageList::~LLBumpImageList()
  807. {
  808. // Shutdown should have already been called.
  809. llassert( mBrightnessEntries.size() == 0 );
  810. llassert( mDarknessEntries.size() == 0 );
  811. }
  814. // Note: Does nothing for entries in gStandardBumpmapList that are not actually standard bump images (e.g. none, brightness, and darkness)
  815. void LLBumpImageList::addTextureStats(U8 bump, const LLUUID& base_image_id, F32 virtual_size)
  816. {
  817. bump &= TEM_BUMP_MASK;
  818. LLViewerFetchedTexture* bump_image = gStandardBumpmapList[bump].mImage;
  819. if( bump_image )
  820. {
  821. bump_image->addTextureStats(virtual_size);
  822. }
  823. }
  826. void LLBumpImageList::updateImages()
  827. {
  828. llpushcallstacks ;
  829. for (bump_image_map_t::iterator iter = mBrightnessEntries.begin(); iter != mBrightnessEntries.end(); )
  830. {
  831. bump_image_map_t::iterator curiter = iter++;
  832. LLViewerTexture* image = curiter->second;
  833. if( image )
  834. {
  835. BOOL destroy = TRUE;
  836. if( image->hasGLTexture())
  837. {
  838. if( image->getBoundRecently() )
  839. {
  840. destroy = FALSE;
  841. }
  842. else
  843. {
  844. image->destroyGLTexture();
  845. }
  846. }
  848. if( destroy )
  849. {
  850. //llinfos << "*** Destroying bright " << (void*)image << llendl;
  851. mBrightnessEntries.erase(curiter);   // deletes the image thanks to reference counting
  852. }
  853. }
  854. }
  855. llpushcallstacks ;
  856. for (bump_image_map_t::iterator iter = mDarknessEntries.begin(); iter != mDarknessEntries.end(); )
  857. {
  858. bump_image_map_t::iterator curiter = iter++;
  859. LLViewerTexture* image = curiter->second;
  860. if( image )
  861. {
  862. BOOL destroy = TRUE;
  863. if( image->hasGLTexture())
  864. {
  865. if( image->getBoundRecently() )
  866. {
  867. destroy = FALSE;
  868. }
  869. else
  870. {
  871. image->destroyGLTexture();
  872. }
  873. }
  875. if( destroy )
  876. {
  877. //llinfos << "*** Destroying dark " << (void*)image << llendl;;
  878. mDarknessEntries.erase(curiter);  // deletes the image thanks to reference counting
  879. }
  880. }
  881. }
  882. llpushcallstacks ;
  883. }
  886. // Note: the caller SHOULD NOT keep the pointer that this function returns.  It may be updated as more data arrives.
  887. LLViewerTexture* LLBumpImageList::getBrightnessDarknessImage(LLViewerFetchedTexture* src_image, U8 bump_code )
  888. {
  889. llassert( (bump_code == BE_BRIGHTNESS) || (bump_code == BE_DARKNESS) );
  891. LLViewerTexture* bump = NULL;
  892. const F32 BRIGHTNESS_DARKNESS_PIXEL_AREA_THRESHOLD = 1000;
  893. if( src_image->getMaxVirtualSize() > BRIGHTNESS_DARKNESS_PIXEL_AREA_THRESHOLD )
  894. {
  895. bump_image_map_t* entries_list = NULL;
  896. void (*callback_func)( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata ) = NULL;
  898. switch( bump_code )
  899. {
  900. case BE_BRIGHTNESS:
  901. entries_list = &mBrightnessEntries;
  902. callback_func = LLBumpImageList::onSourceBrightnessLoaded;
  903. break;
  904. case BE_DARKNESS:
  905. entries_list = &mDarknessEntries;
  906. callback_func = LLBumpImageList::onSourceDarknessLoaded;
  907. break;
  908. default:
  909. llassert(0);
  910. return NULL;
  911. }
  913. bump_image_map_t::iterator iter = entries_list->find(src_image->getID());
  914. if (iter != entries_list->end())
  915. {
  916. bump = iter->second;
  917. }
  918. else
  919. {
  920. LLPointer<LLImageRaw> raw = new LLImageRaw(1,1,1);
  921. raw->clear(0x77, 0x77, 0x77, 0xFF);
  923. (*entries_list)[src_image->getID()] = LLViewerTextureManager::getLocalTexture( raw.get(), TRUE);
  924. (*entries_list)[src_image->getID()]->setExplicitFormat(GL_ALPHA8, GL_ALPHA);
  926. // Note: this may create an LLImageGL immediately
  927. src_image->setLoadedCallback( callback_func, 0, TRUE, FALSE, new LLUUID(src_image->getID()) );
  928. bump = (*entries_list)[src_image->getID()]; // In case callback was called immediately and replaced the image
  930. // bump_total++;
  931. // llinfos << "*** Creating " << (void*)bump << " " << bump_total << llendl;
  932. }
  933. }
  935. return bump;
  936. }
  939. // static
  940. void LLBumpImageList::onSourceBrightnessLoaded( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata )
  941. {
  942. LLUUID* source_asset_id = (LLUUID*)userdata;
  943. LLBumpImageList::onSourceLoaded( success, src_vi, src, *source_asset_id, BE_BRIGHTNESS );
  944. if( final )
  945. {
  946. delete source_asset_id;
  947. }
  948. }
  950. // static
  951. void LLBumpImageList::onSourceDarknessLoaded( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata )
  952. {
  953. LLUUID* source_asset_id = (LLUUID*)userdata;
  954. LLBumpImageList::onSourceLoaded( success, src_vi, src, *source_asset_id, BE_DARKNESS );
  955. if( final )
  956. {
  957. delete source_asset_id;
  958. }
  959. }
  961. void LLBumpImageList::onSourceStandardLoaded( BOOL success, LLViewerFetchedTexture* src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata)
  962. {
  963. if (success && LLPipeline::sRenderDeferred)
  964. {
  965. LLPointer<LLImageRaw> nrm_image = new LLImageRaw(src->getWidth(), src->getHeight(), 4);
  966. generateNormalMapFromAlpha(src, nrm_image);
  967. src_vi->setExplicitFormat(GL_RGBA, GL_RGBA);
  968. src_vi->createGLTexture(src_vi->getDiscardLevel(), nrm_image);
  969. }
  970. }
  972. void LLBumpImageList::generateNormalMapFromAlpha(LLImageRaw* src, LLImageRaw* nrm_image)
  973. {
  974. U8* nrm_data = nrm_image->getData();
  975. S32 resX = src->getWidth();
  976. S32 resY = src->getHeight();
  978. U8* src_data = src->getData();
  980. S32 src_cmp = src->getComponents();
  982. F32 norm_scale = gSavedSettings.getF32("RenderNormalMapScale");
  984. U32 idx = 0;
  985. //generate normal map from pseudo-heightfield
  986. for (S32 j = 0; j < resY; ++j)
  987. {
  988. for (S32 i = 0; i < resX; ++i)
  989. {
  990. S32 rX = (i+1)%resX;
  991. S32 rY = (j+1)%resY;
  992. S32 lX = (i-1)%resX;
  993. S32 lY = (j-1)%resY;
  995. if (lX < 0)
  996. {
  997. lX += resX;
  998. }
  999. if (lY < 0)
  1000. {
  1001. lY += resY;
  1002. }
  1004. F32 cH = (F32) src_data[(j*resX+i)*src_cmp+src_cmp-1];
  1006. LLVector3 right = LLVector3(norm_scale, 0, (F32) src_data[(j*resX+rX)*src_cmp+src_cmp-1]-cH);
  1007. LLVector3 left = LLVector3(-norm_scale, 0, (F32) src_data[(j*resX+lX)*src_cmp+src_cmp-1]-cH);
  1008. LLVector3 up = LLVector3(0, -norm_scale, (F32) src_data[(rY*resX+i)*src_cmp+src_cmp-1]-cH);
  1009. LLVector3 down = LLVector3(0, norm_scale, (F32) src_data[(lY*resX+i)*src_cmp+src_cmp-1]-cH);
  1011. LLVector3 norm = right%down + down%left + left%up + up%right;
  1013. norm.normVec();
  1015. norm *= 0.5f;
  1016. norm += LLVector3(0.5f,0.5f,0.5f);
  1018. idx = (j*resX+i)*4;
  1019. nrm_data[idx+0]= (U8) (norm.mV[0]*255);
  1020. nrm_data[idx+1]= (U8) (norm.mV[1]*255);
  1021. nrm_data[idx+2]= (U8) (norm.mV[2]*255);
  1022. nrm_data[idx+3]= src_data[(j*resX+i)*src_cmp+src_cmp-1];
  1023. }
  1024. }
  1025. }
  1027. // static
  1028. void LLBumpImageList::onSourceLoaded( BOOL success, LLViewerTexture *src_vi, LLImageRaw* src, LLUUID& source_asset_id, EBumpEffect bump_code )
  1029. {
  1030. if( success )
  1031. {
  1032. bump_image_map_t& entries_list(bump_code == BE_BRIGHTNESS ? gBumpImageList.mBrightnessEntries : gBumpImageList.mDarknessEntries );
  1033. bump_image_map_t::iterator iter = entries_list.find(source_asset_id);
  1034. if (iter != entries_list.end())
  1035. {
  1036. LLPointer<LLImageRaw> dst_image = new LLImageRaw(src->getWidth(), src->getHeight(), 1);
  1037. U8* dst_data = dst_image->getData();
  1038. S32 dst_data_size = dst_image->getDataSize();
  1040. U8* src_data = src->getData();
  1041. S32 src_data_size = src->getDataSize();
  1043. S32 src_components = src->getComponents();
  1045. // Convert to luminance and then scale and bias that to get ready for
  1046. // embossed bump mapping.  (0-255 maps to 127-255)
  1048. // Convert to fixed point so we don't have to worry about precision/clamping.
  1049. const S32 FIXED_PT = 8;
  1050. const S32 R_WEIGHT = S32(0.2995f * (1<<FIXED_PT));
  1051. const S32 G_WEIGHT = S32(0.5875f * (1<<FIXED_PT));
  1052. const S32 B_WEIGHT = S32(0.1145f * (1<<FIXED_PT));
  1054. S32 minimum = 255;
  1055. S32 maximum = 0;
  1057. switch( src_components )
  1058. {
  1059. case 1:
  1060. case 2:
  1061. if( src_data_size == dst_data_size * src_components )
  1062. {
  1063. for( S32 i = 0, j=0; i < dst_data_size; i++, j+= src_components )
  1064. {
  1065. dst_data[i] = src_data[j];
  1066. if( dst_data[i] < minimum )
  1067. {
  1068. minimum = dst_data[i];
  1069. }
  1070. if( dst_data[i] > maximum )
  1071. {
  1072. maximum = dst_data[i];
  1073. }
  1074. }
  1075. }
  1076. else
  1077. {
  1078. llassert(0);
  1079. dst_image->clear();
  1080. }
  1081. break;
  1082. case 3:
  1083. case 4:
  1084. if( src_data_size == dst_data_size * src_components )
  1085. {
  1086. for( S32 i = 0, j=0; i < dst_data_size; i++, j+= src_components )
  1087. {
  1088. // RGB to luminance
  1089. dst_data[i] = (R_WEIGHT * src_data[j] + G_WEIGHT * src_data[j+1] + B_WEIGHT * src_data[j+2]) >> FIXED_PT;
  1090. //llassert( dst_data[i] <= 255 );true because it's 8bit
  1091. if( dst_data[i] < minimum )
  1092. {
  1093. minimum = dst_data[i];
  1094. }
  1095. if( dst_data[i] > maximum )
  1096. {
  1097. maximum = dst_data[i];
  1098. }
  1099. }
  1100. }
  1101. else
  1102. {
  1103. llassert(0);
  1104. dst_image->clear();
  1105. }
  1106. break;
  1107. default:
  1108. llassert(0);
  1109. dst_image->clear();
  1110. break;
  1111. }
  1113. if( maximum > minimum )
  1114. {
  1115. U8 bias_and_scale_lut[256];
  1116. F32 twice_one_over_range = 2.f / (maximum - minimum);
  1117. S32 i;
  1119. const F32 ARTIFICIAL_SCALE = 2.f;  // Advantage: exagerates the effect in midrange.  Disadvantage: clamps at the extremes.
  1120. if( BE_DARKNESS == bump_code )
  1121. {
  1122. for( i = minimum; i <= maximum; i++ )
  1123. {
  1124. F32 minus_one_to_one = F32(maximum - i) * twice_one_over_range - 1.f;
  1125. bias_and_scale_lut[i] = llclampb(llround(127 * minus_one_to_one * ARTIFICIAL_SCALE + 128));
  1126. }
  1127. }
  1128. else
  1129. {
  1130. // BE_LIGHTNESS
  1131. for( i = minimum; i <= maximum; i++ )
  1132. {
  1133. F32 minus_one_to_one = F32(i - minimum) * twice_one_over_range - 1.f;
  1134. bias_and_scale_lut[i] = llclampb(llround(127 * minus_one_to_one * ARTIFICIAL_SCALE + 128));
  1135. }
  1136. }
  1138. for( i = 0; i < dst_data_size; i++ )
  1139. {
  1140. dst_data[i] = bias_and_scale_lut[dst_data[i]];
  1141. }
  1142. }
  1144. //---------------------------------------------------
  1145. //immediately assign bump to a global smart pointer in case some local smart pointer
  1146. //accidently releases it.
  1147. LLPointer<LLViewerTexture> bump = LLViewerTextureManager::getLocalTexture( TRUE);
  1149. if (!LLPipeline::sRenderDeferred)
  1150. {
  1151. bump->setExplicitFormat(GL_ALPHA8, GL_ALPHA);
  1152. bump->createGLTexture(0, dst_image);
  1153. }
  1154. else
  1155. {
  1156. LLPointer<LLImageRaw> nrm_image = new LLImageRaw(src->getWidth(), src->getHeight(), 4);
  1157. generateNormalMapFromAlpha(src, nrm_image);
  1158. bump->setExplicitFormat(GL_RGBA, GL_RGBA);
  1159. bump->createGLTexture(0, nrm_image);
  1160. }
  1163. iter->second = bump; // derefs (and deletes) old image
  1164. //---------------------------------------------------
  1165. }
  1166. else
  1167. {
  1168. // entry should have been added in LLBumpImageList::getImage().
  1170. // Not a legit assertion - the bump texture could have been flushed by the bump image manager
  1171. //llassert(0);
  1172. }
  1173. }
  1174. }
  1176. void LLDrawPoolBump::renderBump(U32 type, U32 mask)
  1177. {
  1178. LLCullResult::drawinfo_list_t::iterator begin = gPipeline.beginRenderMap(type);
  1179. LLCullResult::drawinfo_list_t::iterator end = gPipeline.endRenderMap(type);
  1181. for (LLCullResult::drawinfo_list_t::iterator i = begin; i != end; ++i)
  1182. {
  1183. LLDrawInfo& params = **i;
  1185. if (LLDrawPoolBump::bindBumpMap(params))
  1186. {
  1187. pushBatch(params, mask, FALSE);
  1188. }
  1189. }
  1190. }
  1192. void LLDrawPoolBump::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture)
  1193. {
  1194. applyModelMatrix(params);
  1196. if (params.mTextureMatrix)
  1197. {
  1198. if (mShiny)
  1199. {
  1200. gGL.getTexUnit(0)->activate();
  1201. glMatrixMode(GL_TEXTURE);
  1202. }
  1203. else
  1204. {
  1205. gGL.getTexUnit(1)->activate();
  1206. glMatrixMode(GL_TEXTURE);
  1207. glLoadMatrixf((GLfloat*) params.mTextureMatrix->mMatrix);
  1208. gPipeline.mTextureMatrixOps++;
  1209. gGL.getTexUnit(0)->activate();
  1210. }
  1212. glLoadMatrixf((GLfloat*) params.mTextureMatrix->mMatrix);
  1213. gPipeline.mTextureMatrixOps++;
  1214. }
  1216. if (mShiny && mVertexShaderLevel > 1 && texture)
  1217. {
  1218. if (params.mTexture.notNull())
  1219. {
  1220. gGL.getTexUnit(diffuse_channel)->bind(params.mTexture) ;
  1221. params.mTexture->addTextureStats(params.mVSize);
  1222. }
  1223. else
  1224. {
  1225. gGL.getTexUnit(diffuse_channel)->unbind(LLTexUnit::TT_TEXTURE);
  1226. }
  1227. }
  1229. if (params.mGroup)
  1230. {
  1231. params.mGroup->rebuildMesh();
  1232. }
  1233. params.mVertexBuffer->setBuffer(mask);
  1234. params.mVertexBuffer->drawRange(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
  1235. gPipeline.addTrianglesDrawn(params.mCount/3);
  1236. if (params.mTextureMatrix)
  1237. {
  1238. if (mShiny)
  1239. {
  1240. gGL.getTexUnit(0)->activate();
  1241. }
  1242. else
  1243. {
  1244. gGL.getTexUnit(1)->activate();
  1245. glLoadIdentity();
  1246. gGL.getTexUnit(0)->activate();
  1247. }
  1248. glLoadIdentity();
  1249. glMatrixMode(GL_MODELVIEW);
  1250. }
  1251. }
  1253. void LLDrawPoolInvisible::render(S32 pass)
  1254. { //render invisiprims
  1255. LLFastTimer t(FTM_RENDER_INVISIBLE);
  1256.   
  1257. U32 invisi_mask = LLVertexBuffer::MAP_VERTEX;
  1258. glStencilMask(0);
  1259. gGL.setColorMask(false, false);
  1260. pushBatches(LLRenderPass::PASS_INVISIBLE, invisi_mask, FALSE);
  1261. gGL.setColorMask(true, false);
  1262. glStencilMask(0xFFFFFFFF);
  1264. if (gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
  1265. {
  1266. beginShiny(true);
  1267. renderShiny(true);
  1268. endShiny(true);
  1269. }
  1270. }
  1272. void LLDrawPoolInvisible::beginDeferredPass(S32 pass)
  1273. {
  1274. beginRenderPass(pass);
  1275. }
  1277. void LLDrawPoolInvisible::endDeferredPass( S32 pass )
  1278. {
  1279. endRenderPass(pass);
  1280. }
  1282. void LLDrawPoolInvisible::renderDeferred( S32 pass )
  1283. { //render invisiprims; this doesn't work becaue it also blocks all the post-deferred stuff
  1284. LLFastTimer t(FTM_RENDER_INVISIBLE);
  1285.   
  1286. U32 invisi_mask = LLVertexBuffer::MAP_VERTEX;
  1287. glStencilMask(0);
  1288. glStencilOp(GL_ZERO, GL_KEEP, GL_REPLACE);
  1289. gGL.setColorMask(false, false);
  1290. pushBatches(LLRenderPass::PASS_INVISIBLE, invisi_mask, FALSE);
  1291. gGL.setColorMask(true, true);
  1292. glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
  1293. glStencilMask(0xFFFFFFFF);
  1295. if (gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
  1296. {
  1297. beginShiny(true);
  1298. renderShiny(true);
  1299. endShiny(true);
  1300. }
  1301. }