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

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

游戏引擎

开发平台：

C++ Builder

llglslshader.cpp：源码内容
  1. /** 
  2.  * @file llglslshader.cpp
  3.  * @brief GLSL helper functions and state.
  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.  */
  33. #include "linden_common.h"
  35. #include "llglslshader.h"
  37. #include "llshadermgr.h"
  38. #include "llfile.h"
  39. #include "llrender.h"
  41. #if LL_DARWIN
  42. #include "OpenGL/OpenGL.h"
  43. #endif
  45. #ifdef LL_RELEASE_FOR_DOWNLOAD
  46. #define UNIFORM_ERRS LL_WARNS_ONCE("Shader")
  47. #else
  48. #define UNIFORM_ERRS LL_ERRS("Shader")
  49. #endif
  51. // Lots of STL stuff in here, using namespace std to keep things more readable
  52. using std::vector;
  53. using std::pair;
  54. using std::make_pair;
  55. using std::string;
  57. BOOL shouldChange(const LLVector4& v1, const LLVector4& v2)
  58. {
  59. return v1 != v2;
  60. }
  62. LLShaderFeatures::LLShaderFeatures()
  63. : calculatesLighting(false), isShiny(false), isFullbright(false), hasWaterFog(false),
  64. hasTransport(false), hasSkinning(false), hasAtmospherics(false), isSpecular(false),
  65. hasGamma(false), hasLighting(false), calculatesAtmospherics(false)
  66. {
  67. }
  69. //===============================
  70. // LLGLSL Shader implementation
  71. //===============================
  72. LLGLSLShader::LLGLSLShader()
  73. : mProgramObject(0), mActiveTextureChannels(0), mShaderLevel(0), mShaderGroup(SG_DEFAULT), mUniformsDirty(FALSE)
  74. {
  75. }
  77. void LLGLSLShader::unload()
  78. {
  79. stop_glerror();
  80. mAttribute.clear();
  81. mTexture.clear();
  82. mUniform.clear();
  83. mShaderFiles.clear();
  85. if (mProgramObject)
  86. {
  87. GLhandleARB obj[1024];
  88. GLsizei count;
  90. glGetAttachedObjectsARB(mProgramObject, 1024, &count, obj);
  91. for (GLsizei i = 0; i < count; i++)
  92. {
  93. glDeleteObjectARB(obj[i]);
  94. }
  96. glDeleteObjectARB(mProgramObject);
  98. mProgramObject = 0;
  99. }
  101. //hack to make apple not complain
  102. glGetError();
  104. stop_glerror();
  105. }
  107. BOOL LLGLSLShader::createShader(vector<string> * attributes,
  108. vector<string> * uniforms)
  109. {
  110. llassert_always(!mShaderFiles.empty());
  111. BOOL success = TRUE;
  113. // Create program
  114. mProgramObject = glCreateProgramObjectARB();
  116. // Attach existing objects
  117. if (!LLShaderMgr::instance()->attachShaderFeatures(this))
  118. {
  119. return FALSE;
  120. }
  122. vector< pair<string,GLenum> >::iterator fileIter = mShaderFiles.begin();
  123. for ( ; fileIter != mShaderFiles.end(); fileIter++ )
  124. {
  125. GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second);
  126. LL_DEBUGS("ShaderLoading") << "SHADER FILE: " << (*fileIter).first << " mShaderLevel=" << mShaderLevel << LL_ENDL;
  127. if (mShaderLevel > 0)
  128. {
  129. attachObject(shaderhandle);
  130. }
  131. else
  132. {
  133. success = FALSE;
  134. }
  135. }
  137. // Map attributes and uniforms
  138. if (success)
  139. {
  140. success = mapAttributes(attributes);
  141. }
  142. if (success)
  143. {
  144. success = mapUniforms(uniforms);
  145. }
  146. if( !success )
  147. {
  148. LL_WARNS("ShaderLoading") << "Failed to link shader: " << mName << LL_ENDL;
  150. // Try again using a lower shader level;
  151. if (mShaderLevel > 0)
  152. {
  153. LL_WARNS("ShaderLoading") << "Failed to link using shader level " << mShaderLevel << " trying again using shader level " << (mShaderLevel - 1) << LL_ENDL;
  154. mShaderLevel--;
  155. return createShader(attributes,uniforms);
  156. }
  157. }
  158. return success;
  159. }
  161. BOOL LLGLSLShader::attachObject(std::string object)
  162. {
  163. if (LLShaderMgr::instance()->mShaderObjects.count(object) > 0)
  164. {
  165. stop_glerror();
  166. glAttachObjectARB(mProgramObject, LLShaderMgr::instance()->mShaderObjects[object]);
  167. stop_glerror();
  168. return TRUE;
  169. }
  170. else
  171. {
  172. LL_WARNS("ShaderLoading") << "Attempting to attach shader object that hasn't been compiled: " << object << LL_ENDL;
  173. return FALSE;
  174. }
  175. }
  177. void LLGLSLShader::attachObject(GLhandleARB object)
  178. {
  179. if (object != 0)
  180. {
  181. stop_glerror();
  182. glAttachObjectARB(mProgramObject, object);
  183. stop_glerror();
  184. }
  185. else
  186. {
  187. LL_WARNS("ShaderLoading") << "Attempting to attach non existing shader object. " << LL_ENDL;
  188. }
  189. }
  191. void LLGLSLShader::attachObjects(GLhandleARB* objects, S32 count)
  192. {
  193. for (S32 i = 0; i < count; i++)
  194. {
  195. attachObject(objects[i]);
  196. }
  197. }
  199. BOOL LLGLSLShader::mapAttributes(const vector<string> * attributes)
  200. {
  201. //link the program
  202. BOOL res = link();
  204. mAttribute.clear();
  205. U32 numAttributes = (attributes == NULL) ? 0 : attributes->size();
  206. mAttribute.resize(LLShaderMgr::instance()->mReservedAttribs.size() + numAttributes, -1);
  208. if (res)
  209. { //read back channel locations
  211. //read back reserved channels first
  212. for (U32 i = 0; i < LLShaderMgr::instance()->mReservedAttribs.size(); i++)
  213. {
  214. const char* name = LLShaderMgr::instance()->mReservedAttribs[i].c_str();
  215. S32 index = glGetAttribLocationARB(mProgramObject, (const GLcharARB *)name);
  216. if (index != -1)
  217. {
  218. mAttribute[i] = index;
  219. LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
  220. }
  221. }
  222. if (attributes != NULL)
  223. {
  224. for (U32 i = 0; i < numAttributes; i++)
  225. {
  226. const char* name = (*attributes)[i].c_str();
  227. S32 index = glGetAttribLocationARB(mProgramObject, name);
  228. if (index != -1)
  229. {
  230. mAttribute[LLShaderMgr::instance()->mReservedAttribs.size() + i] = index;
  231. LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
  232. }
  233. }
  234. }
  236. return TRUE;
  237. }
  239. return FALSE;
  240. }
  242. void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
  243. {
  244. if (index == -1)
  245. {
  246. return;
  247. }
  249. GLenum type;
  250. GLsizei length;
  251. GLint size;
  252. char name[1024]; /* Flawfinder: ignore */
  253. name[0] = 0;
  255. glGetActiveUniformARB(mProgramObject, index, 1024, &length, &size, &type, (GLcharARB *)name);
  256. S32 location = glGetUniformLocationARB(mProgramObject, name);
  257. if (location != -1)
  258. {
  259. //chop off "[0]" so we can always access the first element
  260. //of an array by the array name
  261. char* is_array = strstr(name, "[0]");
  262. if (is_array)
  263. {
  264. is_array[0] = 0;
  265. }
  267. mUniformMap[name] = location;
  268. LL_DEBUGS("ShaderLoading") << "Uniform " << name << " is at location " << location << LL_ENDL;
  270. //find the index of this uniform
  271. for (S32 i = 0; i < (S32) LLShaderMgr::instance()->mReservedUniforms.size(); i++)
  272. {
  273. if ( (mUniform[i] == -1)
  274. && (LLShaderMgr::instance()->mReservedUniforms[i].compare(0, length, name, LLShaderMgr::instance()->mReservedUniforms[i].length()) == 0))
  275. {
  276. //found it
  277. mUniform[i] = location;
  278. mTexture[i] = mapUniformTextureChannel(location, type);
  279. return;
  280. }
  281. }
  283. if (uniforms != NULL)
  284. {
  285. for (U32 i = 0; i < uniforms->size(); i++)
  286. {
  287. if ( (mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] == -1)
  288. && ((*uniforms)[i].compare(0, length, name, (*uniforms)[i].length()) == 0))
  289. {
  290. //found it
  291. mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] = location;
  292. mTexture[i+LLShaderMgr::instance()->mReservedUniforms.size()] = mapUniformTextureChannel(location, type);
  293. return;
  294. }
  295. }
  296. }
  297. }
  298.  }
  300. GLint LLGLSLShader::mapUniformTextureChannel(GLint location, GLenum type)
  301. {
  302. if (type >= GL_SAMPLER_1D_ARB && type <= GL_SAMPLER_2D_RECT_SHADOW_ARB)
  303. { //this here is a texture
  304. glUniform1iARB(location, mActiveTextureChannels);
  305. LL_DEBUGS("ShaderLoading") << "Assigned to texture channel " << mActiveTextureChannels << LL_ENDL;
  306. return mActiveTextureChannels++;
  307. }
  308. return -1;
  309. }
  311. BOOL LLGLSLShader::mapUniforms(const vector<string> * uniforms)
  312. {
  313. BOOL res = TRUE;
  315. mActiveTextureChannels = 0;
  316. mUniform.clear();
  317. mUniformMap.clear();
  318. mTexture.clear();
  319. mValue.clear();
  320. //initialize arrays
  321. U32 numUniforms = (uniforms == NULL) ? 0 : uniforms->size();
  322. mUniform.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
  323. mTexture.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
  325. bind();
  327. //get the number of active uniforms
  328. GLint activeCount;
  329. glGetObjectParameterivARB(mProgramObject, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &activeCount);
  331. for (S32 i = 0; i < activeCount; i++)
  332. {
  333. mapUniform(i, uniforms);
  334. }
  336. unbind();
  338. return res;
  339. }
  341. BOOL LLGLSLShader::link(BOOL suppress_errors)
  342. {
  343. return LLShaderMgr::instance()->linkProgramObject(mProgramObject, suppress_errors);
  344. }
  346. void LLGLSLShader::bind()
  347. {
  348. if (gGLManager.mHasShaderObjects)
  349. {
  350. glUseProgramObjectARB(mProgramObject);
  352. if (mUniformsDirty)
  353. {
  354. LLShaderMgr::instance()->updateShaderUniforms(this);
  355. mUniformsDirty = FALSE;
  356. }
  357. }
  358. }
  360. void LLGLSLShader::unbind()
  361. {
  362. if (gGLManager.mHasShaderObjects)
  363. {
  364. stop_glerror();
  365. if (gGLManager.mIsNVIDIA)
  366. {
  367. for (U32 i = 0; i < mAttribute.size(); ++i)
  368. {
  369. vertexAttrib4f(i, 0,0,0,1);
  370. stop_glerror();
  371. }
  372. }
  373. glUseProgramObjectARB(0);
  374. stop_glerror();
  375. }
  376. }
  378. void LLGLSLShader::bindNoShader(void)
  379. {
  380. glUseProgramObjectARB(0);
  381. }
  383. S32 LLGLSLShader::enableTexture(S32 uniform, LLTexUnit::eTextureType mode)
  384. {
  385. if (uniform < 0 || uniform >= (S32)mTexture.size())
  386. {
  387. UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
  388. return -1;
  389. }
  390. S32 index = mTexture[uniform];
  391. if (index != -1)
  392. {
  393. gGL.getTexUnit(index)->activate();
  394. gGL.getTexUnit(index)->enable(mode);
  395. }
  396. return index;
  397. }
  399. S32 LLGLSLShader::disableTexture(S32 uniform, LLTexUnit::eTextureType mode)
  400. {
  401. if (uniform < 0 || uniform >= (S32)mTexture.size())
  402. {
  403. UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
  404. return -1;
  405. }
  406. S32 index = mTexture[uniform];
  407. if (index != -1 && gGL.getTexUnit(index)->getCurrType() != LLTexUnit::TT_NONE)
  408. {
  409. if (gDebugGL && gGL.getTexUnit(index)->getCurrType() != mode)
  410. {
  411. if (gDebugSession)
  412. {
  413. gFailLog << "Texture channel " << index << " texture type corrupted." << std::endl;
  414. ll_fail("LLGLSLShader::disableTexture failed");
  415. }
  416. else
  417. {
  418. llerrs << "Texture channel " << index << " texture type corrupted." << llendl;
  419. }
  420. }
  421. gGL.getTexUnit(index)->disable();
  422. }
  423. return index;
  424. }
  426. void LLGLSLShader::uniform1i(U32 index, GLint x)
  427. {
  428. if (mProgramObject > 0)
  429. {
  430. if (mUniform.size() <= index)
  431. {
  432. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  433. return;
  434. }
  436. if (mUniform[index] >= 0)
  437. {
  438. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  439. if (iter == mValue.end() || iter->second.mV[0] != x)
  440. {
  441. glUniform1iARB(mUniform[index], x);
  442. mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
  443. }
  444. }
  445. }
  446. }
  448. void LLGLSLShader::uniform1f(U32 index, GLfloat x)
  449. {
  450. if (mProgramObject > 0)
  451. {
  452. if (mUniform.size() <= index)
  453. {
  454. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  455. return;
  456. }
  458. if (mUniform[index] >= 0)
  459. {
  460. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  461. if (iter == mValue.end() || iter->second.mV[0] != x)
  462. {
  463. glUniform1fARB(mUniform[index], x);
  464. mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
  465. }
  466. }
  467. }
  468. }
  470. void LLGLSLShader::uniform2f(U32 index, GLfloat x, GLfloat y)
  471. {
  472. if (mProgramObject > 0)
  473. {
  474. if (mUniform.size() <= index)
  475. {
  476. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  477. return;
  478. }
  480. if (mUniform[index] >= 0)
  481. {
  482. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  483. LLVector4 vec(x,y,0.f,0.f);
  484. if (iter == mValue.end() || shouldChange(iter->second,vec))
  485. {
  486. glUniform2fARB(mUniform[index], x, y);
  487. mValue[mUniform[index]] = vec;
  488. }
  489. }
  490. }
  491. }
  493. void LLGLSLShader::uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z)
  494. {
  495. if (mProgramObject > 0)
  496. {
  497. if (mUniform.size() <= index)
  498. {
  499. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  500. return;
  501. }
  503. if (mUniform[index] >= 0)
  504. {
  505. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  506. LLVector4 vec(x,y,z,0.f);
  507. if (iter == mValue.end() || shouldChange(iter->second,vec))
  508. {
  509. glUniform3fARB(mUniform[index], x, y, z);
  510. mValue[mUniform[index]] = vec;
  511. }
  512. }
  513. }
  514. }
  516. void LLGLSLShader::uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
  517. {
  518. if (mProgramObject > 0)
  519. {
  520. if (mUniform.size() <= index)
  521. {
  522. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  523. return;
  524. }
  526. if (mUniform[index] >= 0)
  527. {
  528. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  529. LLVector4 vec(x,y,z,w);
  530. if (iter == mValue.end() || shouldChange(iter->second,vec))
  531. {
  532. glUniform4fARB(mUniform[index], x, y, z, w);
  533. mValue[mUniform[index]] = vec;
  534. }
  535. }
  536. }
  537. }
  539. void LLGLSLShader::uniform1iv(U32 index, U32 count, const GLint* v)
  540. {
  541. if (mProgramObject > 0)
  542. {
  543. if (mUniform.size() <= index)
  544. {
  545. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  546. return;
  547. }
  549. if (mUniform[index] >= 0)
  550. {
  551. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  552. LLVector4 vec(v[0],0.f,0.f,0.f);
  553. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  554. {
  555. glUniform1ivARB(mUniform[index], count, v);
  556. mValue[mUniform[index]] = vec;
  557. }
  558. }
  559. }
  560. }
  562. void LLGLSLShader::uniform1fv(U32 index, U32 count, const GLfloat* v)
  563. {
  564. if (mProgramObject > 0)
  565. {
  566. if (mUniform.size() <= index)
  567. {
  568. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  569. return;
  570. }
  572. if (mUniform[index] >= 0)
  573. {
  574. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  575. LLVector4 vec(v[0],0.f,0.f,0.f);
  576. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  577. {
  578. glUniform1fvARB(mUniform[index], count, v);
  579. mValue[mUniform[index]] = vec;
  580. }
  581. }
  582. }
  583. }
  585. void LLGLSLShader::uniform2fv(U32 index, U32 count, const GLfloat* v)
  586. {
  587. if (mProgramObject > 0)
  588. {
  589. if (mUniform.size() <= index)
  590. {
  591. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  592. return;
  593. }
  595. if (mUniform[index] >= 0)
  596. {
  597. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  598. LLVector4 vec(v[0],v[1],0.f,0.f);
  599. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  600. {
  601. glUniform2fvARB(mUniform[index], count, v);
  602. mValue[mUniform[index]] = vec;
  603. }
  604. }
  605. }
  606. }
  608. void LLGLSLShader::uniform3fv(U32 index, U32 count, const GLfloat* v)
  609. {
  610. if (mProgramObject > 0)
  611. {
  612. if (mUniform.size() <= index)
  613. {
  614. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  615. return;
  616. }
  618. if (mUniform[index] >= 0)
  619. {
  620. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  621. LLVector4 vec(v[0],v[1],v[2],0.f);
  622. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  623. {
  624. glUniform3fvARB(mUniform[index], count, v);
  625. mValue[mUniform[index]] = vec;
  626. }
  627. }
  628. }
  629. }
  631. void LLGLSLShader::uniform4fv(U32 index, U32 count, const GLfloat* v)
  632. {
  633. if (mProgramObject > 0)
  634. {
  635. if (mUniform.size() <= index)
  636. {
  637. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  638. return;
  639. }
  641. if (mUniform[index] >= 0)
  642. {
  643. std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
  644. LLVector4 vec(v[0],v[1],v[2],v[3]);
  645. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  646. {
  647. glUniform4fvARB(mUniform[index], count, v);
  648. mValue[mUniform[index]] = vec;
  649. }
  650. }
  651. }
  652. }
  654. void LLGLSLShader::uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
  655. {
  656. if (mProgramObject > 0)
  657. {
  658. if (mUniform.size() <= index)
  659. {
  660. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  661. return;
  662. }
  664. if (mUniform[index] >= 0)
  665. {
  666. glUniformMatrix2fvARB(mUniform[index], count, transpose, v);
  667. }
  668. }
  669. }
  671. void LLGLSLShader::uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
  672. {
  673. if (mProgramObject > 0)
  674. {
  675. if (mUniform.size() <= index)
  676. {
  677. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  678. return;
  679. }
  681. if (mUniform[index] >= 0)
  682. {
  683. glUniformMatrix3fvARB(mUniform[index], count, transpose, v);
  684. }
  685. }
  686. }
  688. void LLGLSLShader::uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
  689. {
  690. if (mProgramObject > 0)
  691. {
  692. if (mUniform.size() <= index)
  693. {
  694. UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
  695. return;
  696. }
  698. if (mUniform[index] >= 0)
  699. {
  700. glUniformMatrix4fvARB(mUniform[index], count, transpose, v);
  701. }
  702. }
  703. }
  705. GLint LLGLSLShader::getUniformLocation(const string& uniform)
  706. {
  707. if (mProgramObject > 0)
  708. {
  709. std::map<string, GLint>::iterator iter = mUniformMap.find(uniform);
  710. if (iter != mUniformMap.end())
  711. {
  712. llassert(iter->second == glGetUniformLocationARB(mProgramObject, uniform.c_str()));
  713. return iter->second;
  714. }
  715. }
  717. return -1;
  718. }
  720. void LLGLSLShader::uniform1i(const string& uniform, GLint v)
  721. {
  722. GLint location = getUniformLocation(uniform);
  724. if (location >= 0)
  725. {
  726. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  727. LLVector4 vec(v,0.f,0.f,0.f);
  728. if (iter == mValue.end() || shouldChange(iter->second,vec))
  729. {
  730. glUniform1iARB(location, v);
  731. mValue[location] = vec;
  732. }
  733. }
  734. }
  736. void LLGLSLShader::uniform1f(const string& uniform, GLfloat v)
  737. {
  738. GLint location = getUniformLocation(uniform);
  740. if (location >= 0)
  741. {
  742. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  743. LLVector4 vec(v,0.f,0.f,0.f);
  744. if (iter == mValue.end() || shouldChange(iter->second,vec))
  745. {
  746. glUniform1fARB(location, v);
  747. mValue[location] = vec;
  748. }
  749. }
  750. }
  752. void LLGLSLShader::uniform2f(const string& uniform, GLfloat x, GLfloat y)
  753. {
  754. GLint location = getUniformLocation(uniform);
  756. if (location >= 0)
  757. {
  758. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  759. LLVector4 vec(x,y,0.f,0.f);
  760. if (iter == mValue.end() || shouldChange(iter->second,vec))
  761. {
  762. glUniform2fARB(location, x,y);
  763. mValue[location] = vec;
  764. }
  765. }
  767. }
  769. void LLGLSLShader::uniform3f(const string& uniform, GLfloat x, GLfloat y, GLfloat z)
  770. {
  771. GLint location = getUniformLocation(uniform);
  773. if (location >= 0)
  774. {
  775. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  776. LLVector4 vec(x,y,z,0.f);
  777. if (iter == mValue.end() || shouldChange(iter->second,vec))
  778. {
  779. glUniform3fARB(location, x,y,z);
  780. mValue[location] = vec;
  781. }
  782. }
  783. }
  785. void LLGLSLShader::uniform4f(const string& uniform, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
  786. {
  787. GLint location = getUniformLocation(uniform);
  789. if (location >= 0)
  790. {
  791. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  792. LLVector4 vec(x,y,z,w);
  793. if (iter == mValue.end() || shouldChange(iter->second,vec))
  794. {
  795. glUniform4fARB(location, x,y,z,w);
  796. mValue[location] = vec;
  797. }
  798. }
  799. }
  801. void LLGLSLShader::uniform1fv(const string& uniform, U32 count, const GLfloat* v)
  802. {
  803. GLint location = getUniformLocation(uniform);
  805. if (location >= 0)
  806. {
  807. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  808. LLVector4 vec(v[0],0.f,0.f,0.f);
  809. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  810. {
  811. glUniform1fvARB(location, count, v);
  812. mValue[location] = vec;
  813. }
  814. }
  815. }
  817. void LLGLSLShader::uniform2fv(const string& uniform, U32 count, const GLfloat* v)
  818. {
  819. GLint location = getUniformLocation(uniform);
  821. if (location >= 0)
  822. {
  823. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  824. LLVector4 vec(v[0],v[1],0.f,0.f);
  825. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  826. {
  827. glUniform2fvARB(location, count, v);
  828. mValue[location] = vec;
  829. }
  830. }
  831. }
  833. void LLGLSLShader::uniform3fv(const string& uniform, U32 count, const GLfloat* v)
  834. {
  835. GLint location = getUniformLocation(uniform);
  837. if (location >= 0)
  838. {
  839. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  840. LLVector4 vec(v[0],v[1],v[2],0.f);
  841. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  842. {
  843. glUniform3fvARB(location, count, v);
  844. mValue[location] = vec;
  845. }
  846. }
  847. }
  849. void LLGLSLShader::uniform4fv(const string& uniform, U32 count, const GLfloat* v)
  850. {
  851. GLint location = getUniformLocation(uniform);
  853. if (location >= 0)
  854. {
  855. LLVector4 vec(v);
  856. std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
  857. if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
  858. {
  859. glUniform4fvARB(location, count, v);
  860. mValue[location] = vec;
  861. }
  862. }
  863. }
  865. void LLGLSLShader::uniformMatrix2fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
  866. {
  867. GLint location = getUniformLocation(uniform);
  869. if (location >= 0)
  870. {
  871. glUniformMatrix2fvARB(location, count, transpose, v);
  872. }
  873. }
  875. void LLGLSLShader::uniformMatrix3fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
  876. {
  877. GLint location = getUniformLocation(uniform);
  879. if (location >= 0)
  880. {
  881. glUniformMatrix3fvARB(location, count, transpose, v);
  882. }
  883. }
  885. void LLGLSLShader::uniformMatrix4fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
  886. {
  887. GLint location = getUniformLocation(uniform);
  889. if (location >= 0)
  890. {
  891. glUniformMatrix4fvARB(location, count, transpose, v);
  892. }
  893. }
  896. void LLGLSLShader::vertexAttrib4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
  897. {
  898. if (mAttribute[index] > 0)
  899. {
  900. glVertexAttrib4fARB(mAttribute[index], x, y, z, w);
  901. }
  902. }
  904. void LLGLSLShader::vertexAttrib4fv(U32 index, GLfloat* v)
  905. {
  906. if (mAttribute[index] > 0)
  907. {
  908. glVertexAttrib4fvARB(mAttribute[index], v);
  909. }
  910. }