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

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

游戏引擎

开发平台：

C++ Builder

llviewershadermgr.cpp：源码内容
  1. /** 
  2.  * @file llviewershadermgr.cpp
  3.  * @brief Viewer shader manager implementation.
  4.  *
  5.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2005-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.  */
  34. #include "llviewerprecompiledheaders.h"
  36. #include "llfeaturemanager.h"
  37. #include "llviewershadermgr.h"
  39. #include "llfile.h"
  40. #include "llviewerwindow.h"
  41. #include "llviewercontrol.h"
  42. #include "pipeline.h"
  43. #include "llworld.h"
  44. #include "llwlparammanager.h"
  45. #include "llwaterparammanager.h"
  46. #include "llsky.h"
  47. #include "llvosky.h"
  48. #include "llrender.h"
  50. #if LL_DARWIN
  51. #include "OpenGL/OpenGL.h"
  52. #endif
  54. #ifdef LL_RELEASE_FOR_DOWNLOAD
  55. #define UNIFORM_ERRS LL_WARNS_ONCE("Shader")
  56. #else
  57. #define UNIFORM_ERRS LL_ERRS("Shader")
  58. #endif
  60. // Lots of STL stuff in here, using namespace std to keep things more readable
  61. using std::vector;
  62. using std::pair;
  63. using std::make_pair;
  64. using std::string;
  66. BOOL LLViewerShaderMgr::sInitialized = FALSE;
  68. LLVector4 gShinyOrigin;
  70. //object shaders
  71. LLGLSLShader gObjectSimpleProgram;
  72. LLGLSLShader gObjectSimpleWaterProgram;
  73. LLGLSLShader gObjectFullbrightProgram;
  74. LLGLSLShader gObjectFullbrightWaterProgram;
  76. LLGLSLShader gObjectFullbrightShinyProgram;
  77. LLGLSLShader gObjectShinyProgram;
  78. LLGLSLShader gObjectShinyWaterProgram;
  80. //environment shaders
  81. LLGLSLShader gTerrainProgram;
  82. LLGLSLShader gTerrainWaterProgram;
  83. LLGLSLShader gWaterProgram;
  84. LLGLSLShader gUnderWaterProgram;
  86. //interface shaders
  87. LLGLSLShader gHighlightProgram;
  89. //avatar shader handles
  90. LLGLSLShader gAvatarProgram;
  91. LLGLSLShader gAvatarWaterProgram;
  92. LLGLSLShader gAvatarEyeballProgram;
  93. LLGLSLShader gAvatarPickProgram;
  95. // WindLight shader handles
  96. LLGLSLShader gWLSkyProgram;
  97. LLGLSLShader gWLCloudProgram;
  99. // Effects Shaders
  100. LLGLSLShader gGlowProgram;
  101. LLGLSLShader gGlowExtractProgram;
  102. LLGLSLShader gPostColorFilterProgram;
  103. LLGLSLShader gPostNightVisionProgram;
  105. // Deferred rendering shaders
  106. LLGLSLShader gDeferredImpostorProgram;
  107. LLGLSLShader gDeferredEdgeProgram;
  108. LLGLSLShader gDeferredWaterProgram;
  109. LLGLSLShader gDeferredDiffuseProgram;
  110. LLGLSLShader gDeferredBumpProgram;
  111. LLGLSLShader gDeferredTerrainProgram;
  112. LLGLSLShader gDeferredTreeProgram;
  113. LLGLSLShader gDeferredAvatarProgram;
  114. LLGLSLShader gDeferredAvatarAlphaProgram;
  115. LLGLSLShader gDeferredLightProgram;
  116. LLGLSLShader gDeferredMultiLightProgram;
  117. LLGLSLShader gDeferredSpotLightProgram;
  118. LLGLSLShader gDeferredMultiSpotLightProgram;
  119. LLGLSLShader gDeferredSunProgram;
  120. LLGLSLShader gDeferredBlurLightProgram;
  121. LLGLSLShader gDeferredSoftenProgram;
  122. LLGLSLShader gDeferredShadowProgram;
  123. LLGLSLShader gDeferredAvatarShadowProgram;
  124. LLGLSLShader gDeferredAlphaProgram;
  125. LLGLSLShader gDeferredFullbrightProgram;
  126. LLGLSLShader gDeferredGIProgram;
  127. LLGLSLShader gDeferredGIFinalProgram;
  128. LLGLSLShader gDeferredPostGIProgram;
  129. LLGLSLShader gDeferredPostProgram;
  131. LLGLSLShader gLuminanceGatherProgram;
  134. //current avatar shader parameter pointer
  135. GLint gAvatarMatrixParam;
  137. LLViewerShaderMgr::LLViewerShaderMgr() :
  138. mVertexShaderLevel(SHADER_COUNT, 0),
  139. mMaxAvatarShaderLevel(0)
  140. {
  141. /// Make sure WL Sky is the first program
  142. mShaderList.push_back(&gWLSkyProgram);
  143. mShaderList.push_back(&gWLCloudProgram);
  144. mShaderList.push_back(&gAvatarProgram);
  145. mShaderList.push_back(&gObjectShinyProgram);
  146. mShaderList.push_back(&gWaterProgram);
  147. mShaderList.push_back(&gAvatarEyeballProgram); 
  148. mShaderList.push_back(&gObjectSimpleProgram);
  149. mShaderList.push_back(&gObjectFullbrightProgram);
  150. mShaderList.push_back(&gObjectFullbrightShinyProgram);
  151. mShaderList.push_back(&gTerrainProgram);
  152. mShaderList.push_back(&gTerrainWaterProgram);
  153. mShaderList.push_back(&gObjectSimpleWaterProgram);
  154. mShaderList.push_back(&gObjectFullbrightWaterProgram);
  155. mShaderList.push_back(&gAvatarWaterProgram);
  156. mShaderList.push_back(&gObjectShinyWaterProgram);
  157. mShaderList.push_back(&gUnderWaterProgram);
  158. mShaderList.push_back(&gDeferredSunProgram);
  159. mShaderList.push_back(&gDeferredBlurLightProgram);
  160. mShaderList.push_back(&gDeferredSoftenProgram);
  161. mShaderList.push_back(&gDeferredLightProgram);
  162. mShaderList.push_back(&gDeferredMultiLightProgram);
  163. mShaderList.push_back(&gDeferredAlphaProgram);
  164. mShaderList.push_back(&gDeferredFullbrightProgram);
  165. mShaderList.push_back(&gDeferredPostGIProgram);
  166. mShaderList.push_back(&gDeferredEdgeProgram);
  167. mShaderList.push_back(&gDeferredPostProgram);
  168. mShaderList.push_back(&gDeferredGIProgram);
  169. mShaderList.push_back(&gDeferredGIFinalProgram);
  170. mShaderList.push_back(&gDeferredWaterProgram);
  171. mShaderList.push_back(&gDeferredAvatarAlphaProgram);
  172. }
  174. LLViewerShaderMgr::~LLViewerShaderMgr()
  175. {
  176. mVertexShaderLevel.clear();
  177. mShaderList.clear();
  178. }
  180. // static
  181. LLViewerShaderMgr * LLViewerShaderMgr::instance()
  182. {
  183. if(NULL == sInstance)
  184. {
  185. sInstance = new LLViewerShaderMgr();
  186. }
  188. return static_cast<LLViewerShaderMgr*>(sInstance);
  189. }
  191. void LLViewerShaderMgr::initAttribsAndUniforms(void)
  192. {
  193. if (mReservedAttribs.empty())
  194. {
  195. mReservedAttribs.push_back("materialColor");
  196. mReservedAttribs.push_back("specularColor");
  197. mReservedAttribs.push_back("binormal");
  199. mAvatarAttribs.reserve(5);
  200. mAvatarAttribs.push_back("weight");
  201. mAvatarAttribs.push_back("clothing");
  202. mAvatarAttribs.push_back("gWindDir");
  203. mAvatarAttribs.push_back("gSinWaveParams");
  204. mAvatarAttribs.push_back("gGravity");
  206. mAvatarUniforms.push_back("matrixPalette");
  208. mReservedUniforms.reserve(24);
  209. mReservedUniforms.push_back("diffuseMap");
  210. mReservedUniforms.push_back("specularMap");
  211. mReservedUniforms.push_back("bumpMap");
  212. mReservedUniforms.push_back("environmentMap");
  213. mReservedUniforms.push_back("cloude_noise_texture");
  214. mReservedUniforms.push_back("fullbright");
  215. mReservedUniforms.push_back("lightnorm");
  216. mReservedUniforms.push_back("sunlight_color");
  217. mReservedUniforms.push_back("ambient");
  218. mReservedUniforms.push_back("blue_horizon");
  219. mReservedUniforms.push_back("blue_density");
  220. mReservedUniforms.push_back("haze_horizon");
  221. mReservedUniforms.push_back("haze_density");
  222. mReservedUniforms.push_back("cloud_shadow");
  223. mReservedUniforms.push_back("density_multiplier");
  224. mReservedUniforms.push_back("distance_multiplier");
  225. mReservedUniforms.push_back("max_y");
  226. mReservedUniforms.push_back("glow");
  227. mReservedUniforms.push_back("cloud_color");
  228. mReservedUniforms.push_back("cloud_pos_density1");
  229. mReservedUniforms.push_back("cloud_pos_density2");
  230. mReservedUniforms.push_back("cloud_scale");
  231. mReservedUniforms.push_back("gamma");
  232. mReservedUniforms.push_back("scene_light_strength");
  234. mReservedUniforms.push_back("depthMap");
  235. mReservedUniforms.push_back("shadowMap0");
  236. mReservedUniforms.push_back("shadowMap1");
  237. mReservedUniforms.push_back("shadowMap2");
  238. mReservedUniforms.push_back("shadowMap3");
  239. mReservedUniforms.push_back("shadowMap4");
  240. mReservedUniforms.push_back("shadowMap5");
  242. mReservedUniforms.push_back("normalMap");
  243. mReservedUniforms.push_back("positionMap");
  244. mReservedUniforms.push_back("diffuseRect");
  245. mReservedUniforms.push_back("specularRect");
  246. mReservedUniforms.push_back("noiseMap");
  247. mReservedUniforms.push_back("lightFunc");
  248. mReservedUniforms.push_back("lightMap");
  249. mReservedUniforms.push_back("luminanceMap");
  250. mReservedUniforms.push_back("giLightMap");
  251. mReservedUniforms.push_back("giMip");
  252. mReservedUniforms.push_back("edgeMap");
  253. mReservedUniforms.push_back("bloomMap");
  254. mReservedUniforms.push_back("sunLightMap");
  255. mReservedUniforms.push_back("localLightMap");
  256. mReservedUniforms.push_back("projectionMap");
  257. mReservedUniforms.push_back("diffuseGIMap");
  258. mReservedUniforms.push_back("specularGIMap");
  259. mReservedUniforms.push_back("normalGIMap");
  260. mReservedUniforms.push_back("minpGIMap");
  261. mReservedUniforms.push_back("maxpGIMap");
  262. mReservedUniforms.push_back("depthGIMap");
  263. mReservedUniforms.push_back("lastDiffuseGIMap");
  264. mReservedUniforms.push_back("lastNormalGIMap");
  265. mReservedUniforms.push_back("lastMinpGIMap");
  266. mReservedUniforms.push_back("lastMaxpGIMap");
  268. mWLUniforms.push_back("camPosLocal");
  270. mTerrainUniforms.reserve(5);
  271. mTerrainUniforms.push_back("detail_0");
  272. mTerrainUniforms.push_back("detail_1");
  273. mTerrainUniforms.push_back("detail_2");
  274. mTerrainUniforms.push_back("detail_3");
  275. mTerrainUniforms.push_back("alpha_ramp");
  277. mGlowUniforms.push_back("glowDelta");
  278. mGlowUniforms.push_back("glowStrength");
  280. mGlowExtractUniforms.push_back("minLuminance");
  281. mGlowExtractUniforms.push_back("maxExtractAlpha");
  282. mGlowExtractUniforms.push_back("lumWeights");
  283. mGlowExtractUniforms.push_back("warmthWeights");
  284. mGlowExtractUniforms.push_back("warmthAmount");
  286. mShinyUniforms.push_back("origin");
  288. mWaterUniforms.reserve(12);
  289. mWaterUniforms.push_back("screenTex");
  290. mWaterUniforms.push_back("screenDepth");
  291. mWaterUniforms.push_back("refTex");
  292. mWaterUniforms.push_back("eyeVec");
  293. mWaterUniforms.push_back("time");
  294. mWaterUniforms.push_back("d1");
  295. mWaterUniforms.push_back("d2");
  296. mWaterUniforms.push_back("lightDir");
  297. mWaterUniforms.push_back("specular");
  298. mWaterUniforms.push_back("lightExp");
  299. mWaterUniforms.push_back("fogCol");
  300. mWaterUniforms.push_back("kd");
  301. mWaterUniforms.push_back("refScale");
  302. mWaterUniforms.push_back("waterHeight");
  303. }
  304. }
  307. //============================================================================
  308. // Set Levels
  310. S32 LLViewerShaderMgr::getVertexShaderLevel(S32 type)
  311. {
  312. return LLPipeline::sDisableShaders ? 0 : mVertexShaderLevel[type];
  313. }
  315. //============================================================================
  316. // Shader Management
  318. void LLViewerShaderMgr::setShaders()
  319. {
  320. if (!gPipeline.mInitialized || !sInitialized)
  321. {
  322. return;
  323. }
  324. // Make sure the compiled shader map is cleared before we recompile shaders.
  325. mShaderObjects.clear();
  327. initAttribsAndUniforms();
  328. gPipeline.releaseGLBuffers();
  330. if (gSavedSettings.getBOOL("VertexShaderEnable"))
  331. {
  332. LLPipeline::sWaterReflections = gGLManager.mHasCubeMap;
  333. LLPipeline::sRenderGlow = gSavedSettings.getBOOL("RenderGlow"); 
  334. LLPipeline::updateRenderDeferred();
  335. }
  336. else
  337. {
  338. LLPipeline::sRenderGlow = 
  339. LLPipeline::sWaterReflections = FALSE;
  340. }
  342. //hack to reset buffers that change behavior with shaders
  343. gPipeline.resetVertexBuffers();
  345. if (gViewerWindow)
  346. {
  347. gViewerWindow->setCursor(UI_CURSOR_WAIT);
  348. }
  350. // Lighting
  351. gPipeline.setLightingDetail(-1);
  353. // Shaders
  354. LL_INFOS("ShaderLoading") << "n~~~~~~~~~~~~~~~~~~n Loading Shaders:n~~~~~~~~~~~~~~~~~~" << LL_ENDL;
  355. for (S32 i = 0; i < SHADER_COUNT; i++)
  356. {
  357. mVertexShaderLevel[i] = 0;
  358. }
  359. mMaxAvatarShaderLevel = 0;
  361. if (LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable") 
  362. && gSavedSettings.getBOOL("VertexShaderEnable"))
  363. {
  364. S32 light_class = 2;
  365. S32 env_class = 2;
  366. S32 obj_class = 2;
  367. S32 effect_class = 2;
  368. S32 wl_class = 2;
  369. S32 water_class = 2;
  370. S32 deferred_class = 0;
  371. if (!(LLFeatureManager::getInstance()->isFeatureAvailable("WindLightUseAtmosShaders")
  372.   && gSavedSettings.getBOOL("WindLightUseAtmosShaders")))
  373. {
  374. // user has disabled WindLight in their settings, downgrade
  375. // windlight shaders to stub versions.
  376. wl_class = 1;
  377. }
  379. if (LLPipeline::sRenderDeferred)
  380. {
  381. if (gSavedSettings.getBOOL("RenderDeferredShadow"))
  382. {
  383. if (gSavedSettings.getBOOL("RenderDeferredGI"))
  384. { //shadows + gi
  385. deferred_class = 3;
  386. }
  387. else
  388. { //shadows
  389. deferred_class = 2;
  390. }
  391. }
  392. else
  393. { //no shadows
  394. deferred_class = 1;
  395. }
  396. }
  398. if(!gSavedSettings.getBOOL("EnableRippleWater"))
  399. {
  400. water_class = 0;
  401. }
  403. // Trigger a full rebuild of the fallback skybox / cubemap if we've toggled windlight shaders
  404. if (mVertexShaderLevel[SHADER_WINDLIGHT] != wl_class && gSky.mVOSkyp.notNull())
  405. {
  406. gSky.mVOSkyp->forceSkyUpdate();
  407. }
  409. // Load lighting shaders
  410. mVertexShaderLevel[SHADER_LIGHTING] = light_class;
  411. mVertexShaderLevel[SHADER_INTERFACE] = light_class;
  412. mVertexShaderLevel[SHADER_ENVIRONMENT] = env_class;
  413. mVertexShaderLevel[SHADER_WATER] = water_class;
  414. mVertexShaderLevel[SHADER_OBJECT] = obj_class;
  415. mVertexShaderLevel[SHADER_EFFECT] = effect_class;
  416. mVertexShaderLevel[SHADER_WINDLIGHT] = wl_class;
  417. mVertexShaderLevel[SHADER_DEFERRED] = deferred_class;
  419. BOOL loaded = loadBasicShaders();
  421. if (loaded)
  422. {
  423. gPipeline.mVertexShadersEnabled = TRUE;
  424. gPipeline.mVertexShadersLoaded = 1;
  426. // Load all shaders to set max levels
  427. loadShadersEnvironment();
  428. loadShadersWater();
  429. loadShadersObject();
  430. loadShadersWindLight();
  431. loadShadersEffects();
  432. loadShadersInterface();
  434. // Load max avatar shaders to set the max level
  435. mVertexShaderLevel[SHADER_AVATAR] = 3;
  436. mMaxAvatarShaderLevel = 3;
  437. loadShadersAvatar();
  439. #if 0 && LL_DARWIN // force avatar shaders off for mac
  440. mVertexShaderLevel[SHADER_AVATAR] = 0;
  441. sMaxAvatarShaderLevel = 0;
  442. #else
  443. if (gSavedSettings.getBOOL("RenderAvatarVP"))
  444. {
  445. BOOL avatar_cloth = gSavedSettings.getBOOL("RenderAvatarCloth");
  446. S32 avatar_class = 1;
  448. // cloth is a class3 shader
  449. if(avatar_cloth)
  450. {
  451. avatar_class = 3;
  452. }
  454. // Set the actual level
  455. mVertexShaderLevel[SHADER_AVATAR] = avatar_class;
  456. loadShadersAvatar();
  457. if (mVertexShaderLevel[SHADER_AVATAR] != avatar_class)
  458. {
  459. if (mVertexShaderLevel[SHADER_AVATAR] == 0)
  460. {
  461. gSavedSettings.setBOOL("RenderAvatarVP", FALSE);
  462. }
  463. if(llmax(mVertexShaderLevel[SHADER_AVATAR]-1,0) >= 3)
  464. {
  465. avatar_cloth = true;
  466. }
  467. else
  468. {
  469. avatar_cloth = false;
  470. }
  471. gSavedSettings.setBOOL("RenderAvatarCloth", avatar_cloth);
  472. }
  473. }
  474. else
  475. {
  476. mVertexShaderLevel[SHADER_AVATAR] = 0;
  477. gSavedSettings.setBOOL("RenderAvatarCloth", FALSE);
  478. loadShadersAvatar(); // unloads
  479. }
  481. if (!loadShadersDeferred())
  482. {
  483. gSavedSettings.setBOOL("RenderDeferred", FALSE);
  484. }
  485. #endif
  486. }
  487. else
  488. {
  489. gPipeline.mVertexShadersEnabled = FALSE;
  490. gPipeline.mVertexShadersLoaded = 0;
  491. mVertexShaderLevel[SHADER_LIGHTING] = 0;
  492. mVertexShaderLevel[SHADER_INTERFACE] = 0;
  493. mVertexShaderLevel[SHADER_ENVIRONMENT] = 0;
  494. mVertexShaderLevel[SHADER_WATER] = 0;
  495. mVertexShaderLevel[SHADER_OBJECT] = 0;
  496. mVertexShaderLevel[SHADER_EFFECT] = 0;
  497. mVertexShaderLevel[SHADER_WINDLIGHT] = 0;
  498. mVertexShaderLevel[SHADER_AVATAR] = 0;
  499. }
  500. }
  501. else
  502. {
  503. gPipeline.mVertexShadersEnabled = FALSE;
  504. gPipeline.mVertexShadersLoaded = 0;
  505. mVertexShaderLevel[SHADER_LIGHTING] = 0;
  506. mVertexShaderLevel[SHADER_INTERFACE] = 0;
  507. mVertexShaderLevel[SHADER_ENVIRONMENT] = 0;
  508. mVertexShaderLevel[SHADER_WATER] = 0;
  509. mVertexShaderLevel[SHADER_OBJECT] = 0;
  510. mVertexShaderLevel[SHADER_EFFECT] = 0;
  511. mVertexShaderLevel[SHADER_WINDLIGHT] = 0;
  512. mVertexShaderLevel[SHADER_AVATAR] = 0;
  513. }
  515. if (gViewerWindow)
  516. {
  517. gViewerWindow->setCursor(UI_CURSOR_ARROW);
  518. }
  519. gPipeline.createGLBuffers();
  520. }
  522. void LLViewerShaderMgr::unloadShaders()
  523. {
  524. gObjectSimpleProgram.unload();
  525. gObjectSimpleWaterProgram.unload();
  526. gObjectFullbrightProgram.unload();
  527. gObjectFullbrightWaterProgram.unload();
  529. gObjectShinyProgram.unload();
  530. gObjectFullbrightShinyProgram.unload();
  531. gObjectShinyWaterProgram.unload();
  532. gWaterProgram.unload();
  533. gUnderWaterProgram.unload();
  534. gTerrainProgram.unload();
  535. gTerrainWaterProgram.unload();
  536. gGlowProgram.unload();
  537. gGlowExtractProgram.unload();
  538. gAvatarProgram.unload();
  539. gAvatarWaterProgram.unload();
  540. gAvatarEyeballProgram.unload();
  541. gAvatarPickProgram.unload();
  542. gHighlightProgram.unload();
  544. gWLSkyProgram.unload();
  545. gWLCloudProgram.unload();
  547. gPostColorFilterProgram.unload();
  548. gPostNightVisionProgram.unload();
  550. gDeferredDiffuseProgram.unload();
  552. mVertexShaderLevel[SHADER_LIGHTING] = 0;
  553. mVertexShaderLevel[SHADER_OBJECT] = 0;
  554. mVertexShaderLevel[SHADER_AVATAR] = 0;
  555. mVertexShaderLevel[SHADER_ENVIRONMENT] = 0;
  556. mVertexShaderLevel[SHADER_WATER] = 0;
  557. mVertexShaderLevel[SHADER_INTERFACE] = 0;
  558. mVertexShaderLevel[SHADER_EFFECT] = 0;
  559. mVertexShaderLevel[SHADER_WINDLIGHT] = 0;
  561. gPipeline.mVertexShadersLoaded = 0;
  562. }
  564. BOOL LLViewerShaderMgr::loadBasicShaders()
  565. {
  566. // Load basic dependency shaders first
  567. // All of these have to load for any shaders to function
  569. #if LL_DARWIN // Mac can't currently handle all 8 lights, 
  570. S32 sum_lights_class = 2;
  571. #else 
  572. S32 sum_lights_class = 3;
  574. // class one cards will get the lower sum lights
  575. // class zero we're not going to think about
  576. // since a class zero card COULD be a ridiculous new card
  577. // and old cards should have the features masked
  578. if(LLFeatureManager::getInstance()->getGPUClass() == GPU_CLASS_1)
  579. {
  580. sum_lights_class = 2;
  581. }
  582. #endif
  584. // If we have sun and moon only checked, then only sum those lights.
  585. if (gPipeline.getLightingDetail() == 0)
  586. {
  587. sum_lights_class = 1;
  588. }
  590. // Use the feature table to mask out the max light level to use.  Also make sure it's at least 1.
  591. S32 max_light_class = gSavedSettings.getS32("RenderShaderLightingMaxLevel");
  592. sum_lights_class = llclamp(sum_lights_class, 1, max_light_class);
  594. // Load the Basic Vertex Shaders at the appropriate level. 
  595. // (in order of shader function call depth for reference purposes, deepest level first)
  597. vector< pair<string, S32> > shaders;
  598. shaders.reserve(10);
  599. shaders.push_back( make_pair( "windlight/atmosphericsVarsV.glsl", mVertexShaderLevel[SHADER_WINDLIGHT] ) );
  600. shaders.push_back( make_pair( "windlight/atmosphericsHelpersV.glsl", mVertexShaderLevel[SHADER_WINDLIGHT] ) );
  601. shaders.push_back( make_pair( "lighting/lightFuncV.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  602. shaders.push_back( make_pair( "lighting/sumLightsV.glsl", sum_lights_class ) );
  603. shaders.push_back( make_pair( "lighting/lightV.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  604. shaders.push_back( make_pair( "lighting/lightFuncSpecularV.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  605. shaders.push_back( make_pair( "lighting/sumLightsSpecularV.glsl", sum_lights_class ) );
  606. shaders.push_back( make_pair( "lighting/lightSpecularV.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  607. shaders.push_back( make_pair( "windlight/atmosphericsV.glsl", mVertexShaderLevel[SHADER_WINDLIGHT] ) );
  608. shaders.push_back( make_pair( "avatar/avatarSkinV.glsl", 1 ) );
  610. // We no longer have to bind the shaders to global glhandles, they are automatically added to a map now.
  611. for (U32 i = 0; i < shaders.size(); i++)
  612. {
  613. // Note usage of GL_VERTEX_SHADER_ARB
  614. if (loadShaderFile(shaders[i].first, shaders[i].second, GL_VERTEX_SHADER_ARB) == 0)
  615. {
  616. return FALSE;
  617. }
  618. }
  620. // Load the Basic Fragment Shaders at the appropriate level. 
  621. // (in order of shader function call depth for reference purposes, deepest level first)
  623. shaders.clear();
  624. shaders.reserve(12);
  625. shaders.push_back( make_pair( "windlight/atmosphericsVarsF.glsl", mVertexShaderLevel[SHADER_WINDLIGHT] ) );
  626. shaders.push_back( make_pair( "windlight/gammaF.glsl", mVertexShaderLevel[SHADER_WINDLIGHT]) );
  627. shaders.push_back( make_pair( "windlight/atmosphericsF.glsl", mVertexShaderLevel[SHADER_WINDLIGHT] ) );
  628. shaders.push_back( make_pair( "windlight/transportF.glsl", mVertexShaderLevel[SHADER_WINDLIGHT] ) );
  629. shaders.push_back( make_pair( "environment/waterFogF.glsl", mVertexShaderLevel[SHADER_WATER] ) );
  630. shaders.push_back( make_pair( "lighting/lightF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  631. shaders.push_back( make_pair( "lighting/lightFullbrightF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  632. shaders.push_back( make_pair( "lighting/lightWaterF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  633. shaders.push_back( make_pair( "lighting/lightFullbrightWaterF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  634. shaders.push_back( make_pair( "lighting/lightShinyF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  635. shaders.push_back( make_pair( "lighting/lightFullbrightShinyF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  636. shaders.push_back( make_pair( "lighting/lightShinyWaterF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
  638. for (U32 i = 0; i < shaders.size(); i++)
  639. {
  640. // Note usage of GL_FRAGMENT_SHADER_ARB
  641. if (loadShaderFile(shaders[i].first, shaders[i].second, GL_FRAGMENT_SHADER_ARB) == 0)
  642. {
  643. return FALSE;
  644. }
  645. }
  647. return TRUE;
  648. }
  650. BOOL LLViewerShaderMgr::loadShadersEnvironment()
  651. {
  652. BOOL success = TRUE;
  654. if (mVertexShaderLevel[SHADER_ENVIRONMENT] == 0)
  655. {
  656. gTerrainProgram.unload();
  657. return FALSE;
  658. }
  660. if (success)
  661. {
  662. gTerrainProgram.mName = "Terrain Shader";
  663. gTerrainProgram.mFeatures.calculatesLighting = true;
  664. gTerrainProgram.mFeatures.calculatesAtmospherics = true;
  665. gTerrainProgram.mFeatures.hasAtmospherics = true;
  666. gTerrainProgram.mFeatures.hasGamma = true;
  667. gTerrainProgram.mShaderFiles.clear();
  668. gTerrainProgram.mShaderFiles.push_back(make_pair("environment/terrainV.glsl", GL_VERTEX_SHADER_ARB));
  669. gTerrainProgram.mShaderFiles.push_back(make_pair("environment/terrainF.glsl", GL_FRAGMENT_SHADER_ARB));
  670. gTerrainProgram.mShaderLevel = mVertexShaderLevel[SHADER_ENVIRONMENT];
  671. success = gTerrainProgram.createShader(NULL, &mTerrainUniforms);
  672. }
  674. if (!success)
  675. {
  676. mVertexShaderLevel[SHADER_ENVIRONMENT] = 0;
  677. return FALSE;
  678. }
  680. LLWorld::getInstance()->updateWaterObjects();
  682. return TRUE;
  683. }
  685. BOOL LLViewerShaderMgr::loadShadersWater()
  686. {
  687. BOOL success = TRUE;
  688. BOOL terrainWaterSuccess = TRUE;
  690. if (mVertexShaderLevel[SHADER_WATER] == 0)
  691. {
  692. gWaterProgram.unload();
  693. gUnderWaterProgram.unload();
  694. gTerrainWaterProgram.unload();
  695. return FALSE;
  696. }
  698. if (success)
  699. {
  700. // load water shader
  701. gWaterProgram.mName = "Water Shader";
  702. gWaterProgram.mFeatures.calculatesAtmospherics = true;
  703. gWaterProgram.mFeatures.hasGamma = true;
  704. gWaterProgram.mFeatures.hasTransport = true;
  705. gWaterProgram.mShaderFiles.clear();
  706. gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER_ARB));
  707. gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER_ARB));
  708. gWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_WATER];
  709. success = gWaterProgram.createShader(NULL, &mWaterUniforms);
  710. }
  712. if (success)
  713. {
  714. //load under water vertex shader
  715. gUnderWaterProgram.mName = "Underwater Shader";
  716. gUnderWaterProgram.mFeatures.calculatesAtmospherics = true;
  717. gUnderWaterProgram.mShaderFiles.clear();
  718. gUnderWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER_ARB));
  719. gUnderWaterProgram.mShaderFiles.push_back(make_pair("environment/underWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
  720. gUnderWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_WATER];
  721. gUnderWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
  723. success = gUnderWaterProgram.createShader(NULL, &mWaterUniforms);
  724. }
  726. if (success)
  727. {
  728. //load terrain water shader
  729. gTerrainWaterProgram.mName = "Terrain Water Shader";
  730. gTerrainWaterProgram.mFeatures.calculatesLighting = true;
  731. gTerrainWaterProgram.mFeatures.calculatesAtmospherics = true;
  732. gTerrainWaterProgram.mFeatures.hasAtmospherics = true;
  733. gTerrainWaterProgram.mFeatures.hasWaterFog = true;
  734. gTerrainWaterProgram.mShaderFiles.clear();
  735. gTerrainWaterProgram.mShaderFiles.push_back(make_pair("environment/terrainV.glsl", GL_VERTEX_SHADER_ARB));
  736. gTerrainWaterProgram.mShaderFiles.push_back(make_pair("environment/terrainWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
  737. gTerrainWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_ENVIRONMENT];
  738. gTerrainWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
  739. terrainWaterSuccess = gTerrainWaterProgram.createShader(NULL, &mTerrainUniforms);
  740. }
  742. /// Keep track of water shader levels
  743. if (gWaterProgram.mShaderLevel != mVertexShaderLevel[SHADER_WATER]
  744. || gUnderWaterProgram.mShaderLevel != mVertexShaderLevel[SHADER_WATER])
  745. {
  746. mVertexShaderLevel[SHADER_WATER] = llmin(gWaterProgram.mShaderLevel, gUnderWaterProgram.mShaderLevel);
  747. }
  749. if (!success)
  750. {
  751. mVertexShaderLevel[SHADER_WATER] = 0;
  752. return FALSE;
  753. }
  755. // if we failed to load the terrain water shaders and we need them (using class2 water),
  756. // then drop down to class1 water.
  757. if (mVertexShaderLevel[SHADER_WATER] > 1 && !terrainWaterSuccess)
  758. {
  759. mVertexShaderLevel[SHADER_WATER]--;
  760. return loadShadersWater();
  761. }
  763. LLWorld::getInstance()->updateWaterObjects();
  765. return TRUE;
  766. }
  768. BOOL LLViewerShaderMgr::loadShadersEffects()
  769. {
  770. BOOL success = TRUE;
  772. if (mVertexShaderLevel[SHADER_EFFECT] == 0)
  773. {
  774. gGlowProgram.unload();
  775. gGlowExtractProgram.unload();
  776. gPostColorFilterProgram.unload();
  777. gPostNightVisionProgram.unload();
  778. return FALSE;
  779. }
  781. if (success)
  782. {
  783. gGlowProgram.mName = "Glow Shader (Post)";
  784. gGlowProgram.mShaderFiles.clear();
  785. gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowV.glsl", GL_VERTEX_SHADER_ARB));
  786. gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowF.glsl", GL_FRAGMENT_SHADER_ARB));
  787. gGlowProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
  788. success = gGlowProgram.createShader(NULL, &mGlowUniforms);
  789. if (!success)
  790. {
  791. LLPipeline::sRenderGlow = FALSE;
  792. }
  793. }
  795. if (success)
  796. {
  797. gGlowExtractProgram.mName = "Glow Extract Shader (Post)";
  798. gGlowExtractProgram.mShaderFiles.clear();
  799. gGlowExtractProgram.mShaderFiles.push_back(make_pair("effects/glowExtractV.glsl", GL_VERTEX_SHADER_ARB));
  800. gGlowExtractProgram.mShaderFiles.push_back(make_pair("effects/glowExtractF.glsl", GL_FRAGMENT_SHADER_ARB));
  801. gGlowExtractProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
  802. success = gGlowExtractProgram.createShader(NULL, &mGlowExtractUniforms);
  803. if (!success)
  804. {
  805. LLPipeline::sRenderGlow = FALSE;
  806. }
  807. }
  809. #if 0
  810. // disabling loading of postprocess shaders until we fix
  811. // ATI sampler2DRect compatibility.
  813. //load Color Filter Shader
  814. if (success)
  815. {
  816. vector<string> shaderUniforms;
  817. shaderUniforms.reserve(7);
  818. shaderUniforms.push_back("RenderTexture");
  819. shaderUniforms.push_back("gamma");
  820. shaderUniforms.push_back("brightness");
  821. shaderUniforms.push_back("contrast");
  822. shaderUniforms.push_back("contrastBase");
  823. shaderUniforms.push_back("saturation");
  824. shaderUniforms.push_back("lumWeights");
  826. gPostColorFilterProgram.mName = "Color Filter Shader (Post)";
  827. gPostColorFilterProgram.mShaderFiles.clear();
  828. gPostColorFilterProgram.mShaderFiles.push_back(make_pair("effects/colorFilterF.glsl", GL_FRAGMENT_SHADER_ARB));
  829. gPostColorFilterProgram.mShaderFiles.push_back(make_pair("effects/drawQuadV.glsl", GL_VERTEX_SHADER_ARB));
  830. gPostColorFilterProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
  831. success = gPostColorFilterProgram.createShader(NULL, &shaderUniforms);
  832. }
  834. //load Night Vision Shader
  835. if (success)
  836. {
  837. vector<string> shaderUniforms;
  838. shaderUniforms.reserve(5);
  839. shaderUniforms.push_back("RenderTexture");
  840. shaderUniforms.push_back("NoiseTexture");
  841. shaderUniforms.push_back("brightMult");
  842. shaderUniforms.push_back("noiseStrength");
  843. shaderUniforms.push_back("lumWeights");
  845. gPostNightVisionProgram.mName = "Night Vision Shader (Post)";
  846. gPostNightVisionProgram.mShaderFiles.clear();
  847. gPostNightVisionProgram.mShaderFiles.push_back(make_pair("effects/nightVisionF.glsl", GL_FRAGMENT_SHADER_ARB));
  848. gPostNightVisionProgram.mShaderFiles.push_back(make_pair("effects/drawQuadV.glsl", GL_VERTEX_SHADER_ARB));
  849. gPostNightVisionProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
  850. success = gPostNightVisionProgram.createShader(NULL, &shaderUniforms);
  851. }
  852. #endif
  854. return success;
  856. }
  858. BOOL LLViewerShaderMgr::loadShadersDeferred()
  859. {
  860. if (mVertexShaderLevel[SHADER_DEFERRED] == 0)
  861. {
  862. gDeferredTreeProgram.unload();
  863. gDeferredDiffuseProgram.unload();
  864. gDeferredBumpProgram.unload();
  865. gDeferredImpostorProgram.unload();
  866. gDeferredTerrainProgram.unload();
  867. gDeferredLightProgram.unload();
  868. gDeferredMultiLightProgram.unload();
  869. gDeferredSpotLightProgram.unload();
  870. gDeferredMultiSpotLightProgram.unload();
  871. gDeferredSunProgram.unload();
  872. gDeferredBlurLightProgram.unload();
  873. gDeferredSoftenProgram.unload();
  874. gDeferredShadowProgram.unload();
  875. gDeferredAvatarShadowProgram.unload();
  876. gDeferredAvatarProgram.unload();
  877. gDeferredAvatarAlphaProgram.unload();
  878. gDeferredAlphaProgram.unload();
  879. gDeferredFullbrightProgram.unload();
  880. gDeferredPostGIProgram.unload();
  881. gDeferredEdgeProgram.unload();
  882. gDeferredPostProgram.unload();
  883. gLuminanceGatherProgram.unload();
  884. gDeferredGIProgram.unload();
  885. gDeferredGIFinalProgram.unload();
  886. gDeferredWaterProgram.unload();
  887. return FALSE;
  888. }
  890. mVertexShaderLevel[SHADER_AVATAR] = 1;
  892. BOOL success = TRUE;
  894. if (success)
  895. {
  896. gDeferredDiffuseProgram.mName = "Deferred Diffuse Shader";
  897. gDeferredDiffuseProgram.mShaderFiles.clear();
  898. gDeferredDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER_ARB));
  899. gDeferredDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER_ARB));
  900. gDeferredDiffuseProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  901. success = gDeferredDiffuseProgram.createShader(NULL, NULL);
  902. }
  904. if (success)
  905. {
  906. gDeferredBumpProgram.mName = "Deferred Bump Shader";
  907. gDeferredBumpProgram.mShaderFiles.clear();
  908. gDeferredBumpProgram.mShaderFiles.push_back(make_pair("deferred/bumpV.glsl", GL_VERTEX_SHADER_ARB));
  909. gDeferredBumpProgram.mShaderFiles.push_back(make_pair("deferred/bumpF.glsl", GL_FRAGMENT_SHADER_ARB));
  910. gDeferredBumpProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  911. success = gDeferredBumpProgram.createShader(NULL, NULL);
  912. }
  914. if (success)
  915. {
  916. gDeferredTreeProgram.mName = "Deferred Tree Shader";
  917. gDeferredTreeProgram.mShaderFiles.clear();
  918. gDeferredTreeProgram.mShaderFiles.push_back(make_pair("deferred/treeV.glsl", GL_VERTEX_SHADER_ARB));
  919. gDeferredTreeProgram.mShaderFiles.push_back(make_pair("deferred/treeF.glsl", GL_FRAGMENT_SHADER_ARB));
  920. gDeferredTreeProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  921. success = gDeferredTreeProgram.createShader(NULL, NULL);
  922. }
  924. if (success)
  925. {
  926. gDeferredImpostorProgram.mName = "Deferred Impostor Shader";
  927. gDeferredImpostorProgram.mShaderFiles.clear();
  928. gDeferredImpostorProgram.mShaderFiles.push_back(make_pair("deferred/impostorV.glsl", GL_VERTEX_SHADER_ARB));
  929. gDeferredImpostorProgram.mShaderFiles.push_back(make_pair("deferred/impostorF.glsl", GL_FRAGMENT_SHADER_ARB));
  930. gDeferredImpostorProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  931. success = gDeferredImpostorProgram.createShader(NULL, NULL);
  932. }
  934. if (success)
  935. {
  936. gDeferredLightProgram.mName = "Deferred Light Shader";
  937. gDeferredLightProgram.mShaderFiles.clear();
  938. gDeferredLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER_ARB));
  939. gDeferredLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightF.glsl", GL_FRAGMENT_SHADER_ARB));
  940. gDeferredLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  941. success = gDeferredLightProgram.createShader(NULL, NULL);
  942. }
  944. if (success)
  945. {
  946. gDeferredMultiLightProgram.mName = "Deferred MultiLight Shader";
  947. gDeferredMultiLightProgram.mShaderFiles.clear();
  948. gDeferredMultiLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER_ARB));
  949. gDeferredMultiLightProgram.mShaderFiles.push_back(make_pair("deferred/multiPointLightF.glsl", GL_FRAGMENT_SHADER_ARB));
  950. gDeferredMultiLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  951. success = gDeferredMultiLightProgram.createShader(NULL, NULL);
  952. }
  954. if (success)
  955. {
  956. gDeferredSpotLightProgram.mName = "Deferred SpotLight Shader";
  957. gDeferredSpotLightProgram.mShaderFiles.clear();
  958. gDeferredSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER_ARB));
  959. gDeferredSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/multiSpotLightF.glsl", GL_FRAGMENT_SHADER_ARB));
  960. gDeferredSpotLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  961. success = gDeferredSpotLightProgram.createShader(NULL, NULL);
  962. }
  964. if (success)
  965. {
  966. gDeferredMultiSpotLightProgram.mName = "Deferred MultiSpotLight Shader";
  967. gDeferredMultiSpotLightProgram.mShaderFiles.clear();
  968. gDeferredMultiSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER_ARB));
  969. gDeferredMultiSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/multiSpotLightF.glsl", GL_FRAGMENT_SHADER_ARB));
  970. gDeferredMultiSpotLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  971. success = gDeferredMultiSpotLightProgram.createShader(NULL, NULL);
  972. }
  974. if (success)
  975. {
  976. gDeferredSunProgram.mName = "Deferred Sun Shader";
  977. gDeferredSunProgram.mShaderFiles.clear();
  978. gDeferredSunProgram.mShaderFiles.push_back(make_pair("deferred/sunLightV.glsl", GL_VERTEX_SHADER_ARB));
  979. gDeferredSunProgram.mShaderFiles.push_back(make_pair("deferred/sunLightF.glsl", GL_FRAGMENT_SHADER_ARB));
  980. gDeferredSunProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  981. success = gDeferredSunProgram.createShader(NULL, NULL);
  982. }
  984. if (success)
  985. {
  986. gDeferredBlurLightProgram.mName = "Deferred Blur Light Shader";
  987. gDeferredBlurLightProgram.mShaderFiles.clear();
  988. gDeferredBlurLightProgram.mShaderFiles.push_back(make_pair("deferred/blurLightV.glsl", GL_VERTEX_SHADER_ARB));
  989. gDeferredBlurLightProgram.mShaderFiles.push_back(make_pair("deferred/blurLightF.glsl", GL_FRAGMENT_SHADER_ARB));
  990. gDeferredBlurLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  991. success = gDeferredBlurLightProgram.createShader(NULL, NULL);
  992. }
  994. if (success)
  995. {
  996. gDeferredAlphaProgram.mName = "Deferred Alpha Shader";
  997. gDeferredAlphaProgram.mFeatures.calculatesLighting = true;
  998. gDeferredAlphaProgram.mFeatures.calculatesAtmospherics = true;
  999. gDeferredAlphaProgram.mFeatures.hasGamma = true;
  1000. gDeferredAlphaProgram.mFeatures.hasAtmospherics = true;
  1001. gDeferredAlphaProgram.mFeatures.hasLighting = true;
  1002. gDeferredAlphaProgram.mShaderFiles.clear();
  1003. gDeferredAlphaProgram.mShaderFiles.push_back(make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER_ARB));
  1004. gDeferredAlphaProgram.mShaderFiles.push_back(make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER_ARB));
  1005. gDeferredAlphaProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1006. success = gDeferredAlphaProgram.createShader(NULL, NULL);
  1007. }
  1009. if (success)
  1010. {
  1011. gDeferredFullbrightProgram.mName = "Deferred Fullbright Shader";
  1012. gDeferredFullbrightProgram.mFeatures.calculatesAtmospherics = true;
  1013. gDeferredFullbrightProgram.mFeatures.hasGamma = true;
  1014. gDeferredFullbrightProgram.mFeatures.hasTransport = true;
  1015. gDeferredFullbrightProgram.mFeatures.isFullbright = true;
  1016. gDeferredFullbrightProgram.mShaderFiles.clear();
  1017. gDeferredFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
  1018. gDeferredFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
  1019. gDeferredFullbrightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1020. success = gDeferredFullbrightProgram.createShader(NULL, NULL);
  1021. }
  1023. if (success)
  1024. {
  1025. // load water shader
  1026. gDeferredWaterProgram.mName = "Deferred Water Shader";
  1027. gDeferredWaterProgram.mFeatures.calculatesAtmospherics = true;
  1028. gDeferredWaterProgram.mFeatures.hasGamma = true;
  1029. gDeferredWaterProgram.mFeatures.hasTransport = true;
  1030. gDeferredWaterProgram.mShaderFiles.clear();
  1031. gDeferredWaterProgram.mShaderFiles.push_back(make_pair("deferred/waterV.glsl", GL_VERTEX_SHADER_ARB));
  1032. gDeferredWaterProgram.mShaderFiles.push_back(make_pair("deferred/waterF.glsl", GL_FRAGMENT_SHADER_ARB));
  1033. gDeferredWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1034. success = gDeferredWaterProgram.createShader(NULL, &mWaterUniforms);
  1035. }
  1037. if (success)
  1038. {
  1039. gDeferredSoftenProgram.mName = "Deferred Soften Shader";
  1040. gDeferredSoftenProgram.mShaderFiles.clear();
  1041. gDeferredSoftenProgram.mShaderFiles.push_back(make_pair("deferred/softenLightV.glsl", GL_VERTEX_SHADER_ARB));
  1042. gDeferredSoftenProgram.mShaderFiles.push_back(make_pair("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER_ARB));
  1043. gDeferredSoftenProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1044. success = gDeferredSoftenProgram.createShader(NULL, NULL);
  1045. }
  1047. if (success)
  1048. {
  1049. gDeferredShadowProgram.mName = "Deferred Shadow Shader";
  1050. gDeferredShadowProgram.mShaderFiles.clear();
  1051. gDeferredShadowProgram.mShaderFiles.push_back(make_pair("deferred/shadowV.glsl", GL_VERTEX_SHADER_ARB));
  1052. gDeferredShadowProgram.mShaderFiles.push_back(make_pair("deferred/shadowF.glsl", GL_FRAGMENT_SHADER_ARB));
  1053. gDeferredShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1054. success = gDeferredShadowProgram.createShader(NULL, NULL);
  1055. }
  1057. if (success)
  1058. {
  1059. gDeferredAvatarShadowProgram.mName = "Deferred Avatar Shadow Shader";
  1060. gDeferredAvatarShadowProgram.mFeatures.hasSkinning = true;
  1061. gDeferredAvatarShadowProgram.mShaderFiles.clear();
  1062. gDeferredAvatarShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarShadowV.glsl", GL_VERTEX_SHADER_ARB));
  1063. gDeferredAvatarShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarShadowF.glsl", GL_FRAGMENT_SHADER_ARB));
  1064. gDeferredAvatarShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1065. success = gDeferredAvatarShadowProgram.createShader(&mAvatarAttribs, &mAvatarUniforms);
  1066. }
  1068. if (success)
  1069. {
  1070. gTerrainProgram.mName = "Deferred Terrain Shader";
  1071. gDeferredTerrainProgram.mShaderFiles.clear();
  1072. gDeferredTerrainProgram.mShaderFiles.push_back(make_pair("deferred/terrainV.glsl", GL_VERTEX_SHADER_ARB));
  1073. gDeferredTerrainProgram.mShaderFiles.push_back(make_pair("deferred/terrainF.glsl", GL_FRAGMENT_SHADER_ARB));
  1074. gDeferredTerrainProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1075. success = gDeferredTerrainProgram.createShader(NULL, &mTerrainUniforms);
  1076. }
  1078. if (success)
  1079. {
  1080. gDeferredAvatarProgram.mName = "Avatar Shader";
  1081. gDeferredAvatarProgram.mFeatures.hasSkinning = true;
  1082. gDeferredAvatarProgram.mShaderFiles.clear();
  1083. gDeferredAvatarProgram.mShaderFiles.push_back(make_pair("deferred/avatarV.glsl", GL_VERTEX_SHADER_ARB));
  1084. gDeferredAvatarProgram.mShaderFiles.push_back(make_pair("deferred/avatarF.glsl", GL_FRAGMENT_SHADER_ARB));
  1085. gDeferredAvatarProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1086. success = gDeferredAvatarProgram.createShader(&mAvatarAttribs, &mAvatarUniforms);
  1087. }
  1089. if (success)
  1090. {
  1091. gDeferredAvatarAlphaProgram.mName = "Avatar Alpha Shader";
  1092. gDeferredAvatarAlphaProgram.mFeatures.hasSkinning = true;
  1093. gDeferredAvatarAlphaProgram.mFeatures.calculatesLighting = true;
  1094. gDeferredAvatarAlphaProgram.mFeatures.calculatesAtmospherics = true;
  1095. gDeferredAvatarAlphaProgram.mFeatures.hasGamma = true;
  1096. gDeferredAvatarAlphaProgram.mFeatures.hasAtmospherics = true;
  1097. gDeferredAvatarAlphaProgram.mFeatures.hasLighting = true;
  1098. gDeferredAvatarAlphaProgram.mShaderFiles.clear();
  1099. gDeferredAvatarAlphaProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaV.glsl", GL_VERTEX_SHADER_ARB));
  1100. gDeferredAvatarAlphaProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaF.glsl", GL_FRAGMENT_SHADER_ARB));
  1101. gDeferredAvatarAlphaProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1102. success = gDeferredAvatarAlphaProgram.createShader(&mAvatarAttribs, &mAvatarUniforms);
  1103. }
  1105. if (mVertexShaderLevel[SHADER_DEFERRED] > 1)
  1106. {
  1107. if (success)
  1108. {
  1109. gDeferredEdgeProgram.mName = "Deferred Edge Shader";
  1110. gDeferredEdgeProgram.mShaderFiles.clear();
  1111. gDeferredEdgeProgram.mShaderFiles.push_back(make_pair("deferred/edgeV.glsl", GL_VERTEX_SHADER_ARB));
  1112. gDeferredEdgeProgram.mShaderFiles.push_back(make_pair("deferred/edgeF.glsl", GL_FRAGMENT_SHADER_ARB));
  1113. gDeferredEdgeProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1114. success = gDeferredEdgeProgram.createShader(NULL, NULL);
  1115. }
  1116. }
  1118. if (mVertexShaderLevel[SHADER_DEFERRED] > 2)
  1119. {
  1120. if (success)
  1121. {
  1122. gDeferredPostProgram.mName = "Deferred Post Shader";
  1123. gDeferredPostProgram.mShaderFiles.clear();
  1124. gDeferredPostProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredV.glsl", GL_VERTEX_SHADER_ARB));
  1125. gDeferredPostProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredF.glsl", GL_FRAGMENT_SHADER_ARB));
  1126. gDeferredPostProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1127. success = gDeferredPostProgram.createShader(NULL, NULL);
  1128. }
  1130. if (success)
  1131. {
  1132. gDeferredPostGIProgram.mName = "Deferred Post GI Shader";
  1133. gDeferredPostGIProgram.mShaderFiles.clear();
  1134. gDeferredPostGIProgram.mShaderFiles.push_back(make_pair("deferred/postgiV.glsl", GL_VERTEX_SHADER_ARB));
  1135. gDeferredPostGIProgram.mShaderFiles.push_back(make_pair("deferred/postgiF.glsl", GL_FRAGMENT_SHADER_ARB));
  1136. gDeferredPostGIProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1137. success = gDeferredPostGIProgram.createShader(NULL, NULL);
  1138. }
  1140. if (success)
  1141. {
  1142. gDeferredGIProgram.mName = "Deferred GI Shader";
  1143. gDeferredGIProgram.mShaderFiles.clear();
  1144. gDeferredGIProgram.mShaderFiles.push_back(make_pair("deferred/giV.glsl", GL_VERTEX_SHADER_ARB));
  1145. gDeferredGIProgram.mShaderFiles.push_back(make_pair("deferred/giF.glsl", GL_FRAGMENT_SHADER_ARB));
  1146. gDeferredGIProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1147. success = gDeferredGIProgram.createShader(NULL, NULL);
  1148. }
  1150. if (success)
  1151. {
  1152. gDeferredGIFinalProgram.mName = "Deferred GI Final Shader";
  1153. gDeferredGIFinalProgram.mShaderFiles.clear();
  1154. gDeferredGIFinalProgram.mShaderFiles.push_back(make_pair("deferred/giFinalV.glsl", GL_VERTEX_SHADER_ARB));
  1155. gDeferredGIFinalProgram.mShaderFiles.push_back(make_pair("deferred/giFinalF.glsl", GL_FRAGMENT_SHADER_ARB));
  1156. gDeferredGIFinalProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1157. success = gDeferredGIFinalProgram.createShader(NULL, NULL);
  1158. }
  1160. if (success)
  1161. {
  1162. gLuminanceGatherProgram.mName = "Luminance Gather Shader";
  1163. gLuminanceGatherProgram.mShaderFiles.clear();
  1164. gLuminanceGatherProgram.mShaderFiles.push_back(make_pair("deferred/luminanceV.glsl", GL_VERTEX_SHADER_ARB));
  1165. gLuminanceGatherProgram.mShaderFiles.push_back(make_pair("deferred/luminanceF.glsl", GL_FRAGMENT_SHADER_ARB));
  1166. gLuminanceGatherProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
  1167. success = gLuminanceGatherProgram.createShader(NULL, NULL);
  1168. }
  1169. }
  1171. return success;
  1172. }
  1174. BOOL LLViewerShaderMgr::loadShadersObject()
  1175. {
  1176. BOOL success = TRUE;
  1178. if (mVertexShaderLevel[SHADER_OBJECT] == 0)
  1179. {
  1180. gObjectShinyProgram.unload();
  1181. gObjectFullbrightShinyProgram.unload();
  1182. gObjectShinyWaterProgram.unload();
  1183. gObjectSimpleProgram.unload();
  1184. gObjectSimpleWaterProgram.unload();
  1185. gObjectFullbrightProgram.unload();
  1186. gObjectFullbrightWaterProgram.unload();
  1187. return FALSE;
  1188. }
  1190. if (success)
  1191. {
  1192. gObjectSimpleProgram.mName = "Simple Shader";
  1193. gObjectSimpleProgram.mFeatures.calculatesLighting = true;
  1194. gObjectSimpleProgram.mFeatures.calculatesAtmospherics = true;
  1195. gObjectSimpleProgram.mFeatures.hasGamma = true;
  1196. gObjectSimpleProgram.mFeatures.hasAtmospherics = true;
  1197. gObjectSimpleProgram.mFeatures.hasLighting = true;
  1198. gObjectSimpleProgram.mShaderFiles.clear();
  1199. gObjectSimpleProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
  1200. gObjectSimpleProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB));
  1201. gObjectSimpleProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
  1202. success = gObjectSimpleProgram.createShader(NULL, NULL);
  1203. }
  1205. if (success)
  1206. {
  1207. gObjectSimpleWaterProgram.mName = "Simple Water Shader";
  1208. gObjectSimpleWaterProgram.mFeatures.calculatesLighting = true;
  1209. gObjectSimpleWaterProgram.mFeatures.calculatesAtmospherics = true;
  1210. gObjectSimpleWaterProgram.mFeatures.hasWaterFog = true;
  1211. gObjectSimpleWaterProgram.mFeatures.hasAtmospherics = true;
  1212. gObjectSimpleWaterProgram.mFeatures.hasLighting = true;
  1213. gObjectSimpleWaterProgram.mShaderFiles.clear();
  1214. gObjectSimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
  1215. gObjectSimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
  1216. gObjectSimpleWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
  1217. gObjectSimpleWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
  1218. success = gObjectSimpleWaterProgram.createShader(NULL, NULL);
  1219. }
  1221. if (success)
  1222. {
  1223. gObjectFullbrightProgram.mName = "Fullbright Shader";
  1224. gObjectFullbrightProgram.mFeatures.calculatesAtmospherics = true;
  1225. gObjectFullbrightProgram.mFeatures.hasGamma = true;
  1226. gObjectFullbrightProgram.mFeatures.hasTransport = true;
  1227. gObjectFullbrightProgram.mFeatures.isFullbright = true;
  1228. gObjectFullbrightProgram.mShaderFiles.clear();
  1229. gObjectFullbrightProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
  1230. gObjectFullbrightProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
  1231. gObjectFullbrightProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
  1232. success = gObjectFullbrightProgram.createShader(NULL, NULL);
  1233. }
  1235. if (success)
  1236. {
  1237. gObjectFullbrightWaterProgram.mName = "Fullbright Water Shader";
  1238. gObjectFullbrightWaterProgram.mFeatures.calculatesAtmospherics = true;
  1239. gObjectFullbrightWaterProgram.mFeatures.isFullbright = true;
  1240. gObjectFullbrightWaterProgram.mFeatures.hasWaterFog = true;
  1241. gObjectFullbrightWaterProgram.mFeatures.hasTransport = true;
  1242. gObjectFullbrightWaterProgram.mShaderFiles.clear();
  1243. gObjectFullbrightWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
  1244. gObjectFullbrightWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
  1245. gObjectFullbrightWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
  1246. gObjectFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
  1247. success = gObjectFullbrightWaterProgram.createShader(NULL, NULL);
  1248. }
  1250. if (success)
  1251. {
  1252. gObjectShinyProgram.mName = "Shiny Shader";
  1253. gObjectShinyProgram.mFeatures.calculatesAtmospherics = true;
  1254. gObjectShinyProgram.mFeatures.calculatesLighting = true;
  1255. gObjectShinyProgram.mFeatures.hasGamma = true;
  1256. gObjectShinyProgram.mFeatures.hasAtmospherics = true;
  1257. gObjectShinyProgram.mFeatures.isShiny = true;
  1258. gObjectShinyProgram.mShaderFiles.clear();
  1259. gObjectShinyProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
  1260. gObjectShinyProgram.mShaderFiles.push_back(make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER_ARB));
  1261. gObjectShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
  1262. success = gObjectShinyProgram.createShader(NULL, &mShinyUniforms);
  1263. }
  1265. if (success)
  1266. {
  1267. gObjectShinyWaterProgram.mName = "Shiny Water Shader";
  1268. gObjectShinyWaterProgram.mFeatures.calculatesAtmospherics = true;
  1269. gObjectShinyWaterProgram.mFeatures.calculatesLighting = true;
  1270. gObjectShinyWaterProgram.mFeatures.isShiny = true;
  1271. gObjectShinyWaterProgram.mFeatures.hasWaterFog = true;
  1272. gObjectShinyWaterProgram.mFeatures.hasAtmospherics = true;
  1273. gObjectShinyWaterProgram.mShaderFiles.clear();
  1274. gObjectShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
  1275. gObjectShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
  1276. gObjectShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
  1277. gObjectShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
  1278. success = gObjectShinyWaterProgram.createShader(NULL, &mShinyUniforms);
  1279. }
  1281. if (success)
  1282. {
  1283. gObjectFullbrightShinyProgram.mName = "Fullbright Shiny Shader";
  1284. gObjectFullbrightShinyProgram.mFeatures.calculatesAtmospherics = true;
  1285. gObjectFullbrightShinyProgram.mFeatures.isFullbright = true;
  1286. gObjectFullbrightShinyProgram.mFeatures.isShiny = true;
  1287. gObjectFullbrightShinyProgram.mFeatures.hasGamma = true;
  1288. gObjectFullbrightShinyProgram.mFeatures.hasTransport = true;
  1289. gObjectFullbrightShinyProgram.mShaderFiles.clear();
  1290. gObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER_ARB));
  1291. gObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER_ARB));
  1292. gObjectFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
  1293. success = gObjectFullbrightShinyProgram.createShader(NULL, &mShinyUniforms);
  1294. }
  1297. if( !success )
  1298. {
  1299. mVertexShaderLevel[SHADER_OBJECT] = 0;
  1300. return FALSE;
  1301. }
  1303. return TRUE;
  1304. }
  1306. BOOL LLViewerShaderMgr::loadShadersAvatar()
  1307. {
  1308. BOOL success = TRUE;
  1310. if (mVertexShaderLevel[SHADER_AVATAR] == 0)
  1311. {
  1312. gAvatarProgram.unload();
  1313. gAvatarWaterProgram.unload();
  1314. gAvatarEyeballProgram.unload();
  1315. gAvatarPickProgram.unload();
  1316. return FALSE;
  1317. }
  1319. if (success)
  1320. {
  1321. gAvatarProgram.mName = "Avatar Shader";
  1322. gAvatarProgram.mFeatures.hasSkinning = true;
  1323. gAvatarProgram.mFeatures.calculatesAtmospherics = true;
  1324. gAvatarProgram.mFeatures.calculatesLighting = true;
  1325. gAvatarProgram.mFeatures.hasGamma = true;
  1326. gAvatarProgram.mFeatures.hasAtmospherics = true;
  1327. gAvatarProgram.mFeatures.hasLighting = true;
  1328. gAvatarProgram.mShaderFiles.clear();
  1329. gAvatarProgram.mShaderFiles.push_back(make_pair("avatar/avatarV.glsl", GL_VERTEX_SHADER_ARB));
  1330. gAvatarProgram.mShaderFiles.push_back(make_pair("avatar/avatarF.glsl", GL_FRAGMENT_SHADER_ARB));
  1331. gAvatarProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
  1332. success = gAvatarProgram.createShader(&mAvatarAttribs, &mAvatarUniforms);
  1334. if (success)
  1335. {
  1336. gAvatarWaterProgram.mName = "Avatar Water Shader";
  1337. gAvatarWaterProgram.mFeatures.hasSkinning = true;
  1338. gAvatarWaterProgram.mFeatures.calculatesAtmospherics = true;
  1339. gAvatarWaterProgram.mFeatures.calculatesLighting = true;
  1340. gAvatarWaterProgram.mFeatures.hasWaterFog = true;
  1341. gAvatarWaterProgram.mFeatures.hasAtmospherics = true;
  1342. gAvatarWaterProgram.mFeatures.hasLighting = true;
  1343. gAvatarWaterProgram.mShaderFiles.clear();
  1344. gAvatarWaterProgram.mShaderFiles.push_back(make_pair("avatar/avatarV.glsl", GL_VERTEX_SHADER_ARB));
  1345. gAvatarWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
  1346. // Note: no cloth under water:
  1347. gAvatarWaterProgram.mShaderLevel = llmin(mVertexShaderLevel[SHADER_AVATAR], 1);
  1348. gAvatarWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
  1349. success = gAvatarWaterProgram.createShader(&mAvatarAttribs, &mAvatarUniforms);
  1350. }
  1352. /// Keep track of avatar levels
  1353. if (gAvatarProgram.mShaderLevel != mVertexShaderLevel[SHADER_AVATAR])
  1354. {
  1355. mMaxAvatarShaderLevel = mVertexShaderLevel[SHADER_AVATAR] = gAvatarProgram.mShaderLevel;
  1356. }
  1357. }
  1359. if (success)
  1360. {
  1361. gAvatarPickProgram.mName = "Avatar Pick Shader";
  1362. gAvatarPickProgram.mFeatures.hasSkinning = true;
  1363. gAvatarPickProgram.mShaderFiles.clear();
  1364. gAvatarPickProgram.mShaderFiles.push_back(make_pair("avatar/pickAvatarV.glsl", GL_VERTEX_SHADER_ARB));
  1365. gAvatarPickProgram.mShaderFiles.push_back(make_pair("avatar/pickAvatarF.glsl", GL_FRAGMENT_SHADER_ARB));
  1366. gAvatarPickProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
  1367. success = gAvatarPickProgram.createShader(&mAvatarAttribs, &mAvatarUniforms);
  1368. }
  1370. if (success)
  1371. {
  1372. gAvatarEyeballProgram.mName = "Avatar Eyeball Program";
  1373. gAvatarEyeballProgram.mFeatures.calculatesLighting = true;
  1374. gAvatarEyeballProgram.mFeatures.isSpecular = true;
  1375. gAvatarEyeballProgram.mFeatures.calculatesAtmospherics = true;
  1376. gAvatarEyeballProgram.mFeatures.hasGamma = true;
  1377. gAvatarEyeballProgram.mFeatures.hasAtmospherics = true;
  1378. gAvatarEyeballProgram.mFeatures.hasLighting = true;
  1379. gAvatarEyeballProgram.mShaderFiles.clear();
  1380. gAvatarEyeballProgram.mShaderFiles.push_back(make_pair("avatar/eyeballV.glsl", GL_VERTEX_SHADER_ARB));
  1381. gAvatarEyeballProgram.mShaderFiles.push_back(make_pair("avatar/eyeballF.glsl", GL_FRAGMENT_SHADER_ARB));
  1382. gAvatarEyeballProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
  1383. success = gAvatarEyeballProgram.createShader(NULL, NULL);
  1384. }
  1386. if( !success )
  1387. {
  1388. mVertexShaderLevel[SHADER_AVATAR] = 0;
  1389. mMaxAvatarShaderLevel = 0;
  1390. return FALSE;
  1391. }
  1393. return TRUE;
  1394. }
  1396. BOOL LLViewerShaderMgr::loadShadersInterface()
  1397. {
  1398. BOOL success = TRUE;
  1400. if (mVertexShaderLevel[SHADER_INTERFACE] == 0)
  1401. {
  1402. gHighlightProgram.unload();
  1403. return FALSE;
  1404. }
  1406. if (success)
  1407. {
  1408. gHighlightProgram.mName = "Highlight Shader";
  1409. gHighlightProgram.mShaderFiles.clear();
  1410. gHighlightProgram.mShaderFiles.push_back(make_pair("interface/highlightV.glsl", GL_VERTEX_SHADER_ARB));
  1411. gHighlightProgram.mShaderFiles.push_back(make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER_ARB));
  1412. gHighlightProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
  1413. success = gHighlightProgram.createShader(NULL, NULL);
  1414. }
  1416. if( !success )
  1417. {
  1418. mVertexShaderLevel[SHADER_INTERFACE] = 0;
  1419. return FALSE;
  1420. }
  1422. return TRUE;
  1423. }
  1425. BOOL LLViewerShaderMgr::loadShadersWindLight()
  1426. {
  1427. BOOL success = TRUE;
  1429. if (mVertexShaderLevel[SHADER_WINDLIGHT] < 2)
  1430. {
  1431. gWLSkyProgram.unload();
  1432. gWLCloudProgram.unload();
  1433. return FALSE;
  1434. }
  1436. if (success)
  1437. {
  1438. gWLSkyProgram.mName = "Windlight Sky Shader";
  1439. //gWLSkyProgram.mFeatures.hasGamma = true;
  1440. gWLSkyProgram.mShaderFiles.clear();
  1441. gWLSkyProgram.mShaderFiles.push_back(make_pair("windlight/skyV.glsl", GL_VERTEX_SHADER_ARB));
  1442. gWLSkyProgram.mShaderFiles.push_back(make_pair("windlight/skyF.glsl", GL_FRAGMENT_SHADER_ARB));
  1443. gWLSkyProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
  1444. gWLSkyProgram.mShaderGroup = LLGLSLShader::SG_SKY;
  1445. success = gWLSkyProgram.createShader(NULL, &mWLUniforms);
  1446. }
  1448. if (success)
  1449. {
  1450. gWLCloudProgram.mName = "Windlight Cloud Program";
  1451. //gWLCloudProgram.mFeatures.hasGamma = true;
  1452. gWLCloudProgram.mShaderFiles.clear();
  1453. gWLCloudProgram.mShaderFiles.push_back(make_pair("windlight/cloudsV.glsl", GL_VERTEX_SHADER_ARB));
  1454. gWLCloudProgram.mShaderFiles.push_back(make_pair("windlight/cloudsF.glsl", GL_FRAGMENT_SHADER_ARB));
  1455. gWLCloudProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
  1456. gWLCloudProgram.mShaderGroup = LLGLSLShader::SG_SKY;
  1457. success = gWLCloudProgram.createShader(NULL, &mWLUniforms);
  1458. }
  1460. return success;
  1461. }
  1463. std::string LLViewerShaderMgr::getShaderDirPrefix(void)
  1464. {
  1465. return gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "shaders/class");
  1466. }
  1468. void LLViewerShaderMgr::updateShaderUniforms(LLGLSLShader * shader)
  1469. {
  1470. LLWLParamManager::instance()->updateShaderUniforms(shader);
  1471. LLWaterParamManager::instance()->updateShaderUniforms(shader);
  1472. }