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

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

游戏引擎

开发平台：

C++ Builder

llpostprocess.cpp：源码内容
  1. /** 
  2.  * @file llpostprocess.cpp
  3.  * @brief LLPostProcess class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2007-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 "llpostprocess.h"
  36. #include "llglslshader.h"
  37. #include "llsdserialize.h"
  38. #include "llrender.h"
  41. LLPostProcess * gPostProcess = NULL;
  44. static const unsigned int NOISE_SIZE = 512;
  46. /// CALCULATING LUMINANCE (Using NTSC lum weights)
  47. /// http://en.wikipedia.org/wiki/Luma_%28video%29
  48. static const float LUMINANCE_R = 0.299f;
  49. static const float LUMINANCE_G = 0.587f;
  50. static const float LUMINANCE_B = 0.114f;
  52. static const char * const XML_FILENAME = "postprocesseffects.xml";
  54. LLPostProcess::LLPostProcess(void) : 
  55. initialized(false),  
  56. mAllEffects(LLSD::emptyMap()),
  57. screenW(1), screenH(1)
  58. {
  59. mSceneRenderTexture = NULL ; 
  60. mNoiseTexture = NULL ;
  61. mTempBloomTexture = NULL ;
  63. noiseTextureScale = 1.0f;
  65. /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
  66. std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
  67. LL_DEBUGS2("AppInit", "Shaders") << "Loading PostProcess Effects settings from " << pathName << LL_ENDL;
  69. llifstream effectsXML(pathName);
  71. if (effectsXML)
  72. {
  73. LLPointer<LLSDParser> parser = new LLSDXMLParser();
  75. parser->parse(effectsXML, mAllEffects, LLSDSerialize::SIZE_UNLIMITED);
  76. }
  78. if (!mAllEffects.has("default"))
  79. {
  80. LLSD & defaultEffect = (mAllEffects["default"] = LLSD::emptyMap());
  82. defaultEffect["enable_night_vision"] = LLSD::Boolean(false);
  83. defaultEffect["enable_bloom"] = LLSD::Boolean(false);
  84. defaultEffect["enable_color_filter"] = LLSD::Boolean(false);
  86. /// NVG Defaults
  87. defaultEffect["brightness_multiplier"] = 3.0;
  88. defaultEffect["noise_size"] = 25.0;
  89. defaultEffect["noise_strength"] = 0.4;
  91. // TODO BTest potentially add this to tweaks?
  92. noiseTextureScale = 1.0f;
  94. /// Bloom Defaults
  95. defaultEffect["extract_low"] = 0.95;
  96. defaultEffect["extract_high"] = 1.0;
  97. defaultEffect["bloom_width"] = 2.25;
  98. defaultEffect["bloom_strength"] = 1.5;
  100. /// Color Filter Defaults
  101. defaultEffect["brightness"] = 1.0;
  102. defaultEffect["contrast"] = 1.0;
  103. defaultEffect["saturation"] = 1.0;
  105. LLSD& contrastBase = (defaultEffect["contrast_base"] = LLSD::emptyArray());
  106. contrastBase.append(1.0);
  107. contrastBase.append(1.0);
  108. contrastBase.append(1.0);
  109. contrastBase.append(0.5);
  110. }
  112. setSelectedEffect("default");
  113. */
  114. }
  116. LLPostProcess::~LLPostProcess(void)
  117. {
  118. invalidate() ;
  119. }
  121. // static
  122. void LLPostProcess::initClass(void)
  123. {
  124. //this will cause system to crash at second time login
  125. //if first time login fails due to network connection --- bao
  126. //***llassert_always(gPostProcess == NULL);
  127. //replaced by the following line:
  128. if(gPostProcess)
  129. return ;
  132. gPostProcess = new LLPostProcess();
  133. }
  135. // static
  136. void LLPostProcess::cleanupClass()
  137. {
  138. delete gPostProcess;
  139. gPostProcess = NULL;
  140. }
  142. void LLPostProcess::setSelectedEffect(std::string const & effectName)
  143. {
  144. mSelectedEffectName = effectName;
  145. static_cast<LLSD &>(tweaks) = mAllEffects[effectName];
  146. }
  148. void LLPostProcess::saveEffect(std::string const & effectName)
  149. {
  150. /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
  151. mAllEffects[effectName] = tweaks;
  153. std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
  154. //llinfos << "Saving PostProcess Effects settings to " << pathName << llendl;
  156. llofstream effectsXML(pathName);
  158. LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
  160. formatter->format(mAllEffects, effectsXML);
  161. */
  162. }
  163. void LLPostProcess::invalidate()
  164. {
  165. mSceneRenderTexture = NULL ;
  166. mNoiseTexture = NULL ;
  167. mTempBloomTexture = NULL ;
  168. initialized = FALSE ;
  169. }
  171. void LLPostProcess::apply(unsigned int width, unsigned int height)
  172. {
  173. if (!initialized || width != screenW || height != screenH){
  174. initialize(width, height);
  175. }
  176. if (shadersEnabled()){
  177. doEffects();
  178. }
  179. }
  181. void LLPostProcess::initialize(unsigned int width, unsigned int height)
  182. {
  183. screenW = width;
  184. screenH = height;
  185. createTexture(mSceneRenderTexture, screenW, screenH);
  186. initialized = true;
  188. checkError();
  189. createNightVisionShader();
  190. createBloomShader();
  191. createColorFilterShader();
  192. checkError();
  193. }
  195. inline bool LLPostProcess::shadersEnabled(void)
  196. {
  197. return (tweaks.useColorFilter().asBoolean() ||
  198. tweaks.useNightVisionShader().asBoolean() ||
  199. tweaks.useBloomShader().asBoolean() );
  201. }
  203. void LLPostProcess::applyShaders(void)
  204. {
  205. if (tweaks.useColorFilter()){
  206. applyColorFilterShader();
  207. checkError();
  208. }
  209. if (tweaks.useNightVisionShader()){
  210. /// If any of the above shaders have been called update the frame buffer;
  211. if (tweaks.useColorFilter())
  212. {
  213. U32 tex = mSceneRenderTexture->getTexName() ;
  214. copyFrameBuffer(tex, screenW, screenH);
  215. }
  216. applyNightVisionShader();
  217. checkError();
  218. }
  219. if (tweaks.useBloomShader()){
  220. /// If any of the above shaders have been called update the frame buffer;
  221. if (tweaks.useColorFilter().asBoolean() || tweaks.useNightVisionShader().asBoolean())
  222. {
  223. U32 tex = mSceneRenderTexture->getTexName() ;
  224. copyFrameBuffer(tex, screenW, screenH);
  225. }
  226. applyBloomShader();
  227. checkError();
  228. }
  229. }
  231. void LLPostProcess::applyColorFilterShader(void)
  232. {
  233. /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
  234. gPostColorFilterProgram.bind();
  236. gGL.getTexUnit(0)->activate();
  237. gGL.getTexUnit(0)->enable(LLTexUnit::TT_RECT_TEXTURE);
  239. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_RECT_TEXTURE, sceneRenderTexture);
  241. getShaderUniforms(colorFilterUniforms, gPostColorFilterProgram.mProgramObject);
  242. glUniform1iARB(colorFilterUniforms["RenderTexture"], 0);
  243. glUniform1fARB(colorFilterUniforms["brightness"], tweaks.getBrightness());
  244. glUniform1fARB(colorFilterUniforms["contrast"], tweaks.getContrast());
  245. float baseI = (tweaks.getContrastBaseR() + tweaks.getContrastBaseG() + tweaks.getContrastBaseB()) / 3.0f;
  246. baseI = tweaks.getContrastBaseIntensity() / ((baseI < 0.001f) ? 0.001f : baseI);
  247. float baseR = tweaks.getContrastBaseR() * baseI;
  248. float baseG = tweaks.getContrastBaseG() * baseI;
  249. float baseB = tweaks.getContrastBaseB() * baseI;
  250. glUniform3fARB(colorFilterUniforms["contrastBase"], baseR, baseG, baseB);
  251. glUniform1fARB(colorFilterUniforms["saturation"], tweaks.getSaturation());
  252. glUniform3fARB(colorFilterUniforms["lumWeights"], LUMINANCE_R, LUMINANCE_G, LUMINANCE_B);
  254. LLGLEnable blend(GL_BLEND);
  255. gGL.setSceneBlendType(LLRender::BT_REPLACE);
  256. LLGLDepthTest depth(GL_FALSE);
  258. /// Draw a screen space quad
  259. drawOrthoQuad(screenW, screenH, QUAD_NORMAL);
  260. gPostColorFilterProgram.unbind();
  261. */
  262. }
  264. void LLPostProcess::createColorFilterShader(void)
  265. {
  266. /// Define uniform names
  267. colorFilterUniforms["RenderTexture"] = 0;
  268. colorFilterUniforms["brightness"] = 0;
  269. colorFilterUniforms["contrast"] = 0;
  270. colorFilterUniforms["contrastBase"] = 0;
  271. colorFilterUniforms["saturation"] = 0;
  272. colorFilterUniforms["lumWeights"] = 0;
  273. }
  275. void LLPostProcess::applyNightVisionShader(void)
  276. {
  277. /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
  278. gPostNightVisionProgram.bind();
  280. gGL.getTexUnit(0)->activate();
  281. gGL.getTexUnit(0)->enable(LLTexUnit::TT_RECT_TEXTURE);
  283. getShaderUniforms(nightVisionUniforms, gPostNightVisionProgram.mProgramObject);
  284. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_RECT_TEXTURE, sceneRenderTexture);
  285. glUniform1iARB(nightVisionUniforms["RenderTexture"], 0);
  287. gGL.getTexUnit(1)->activate();
  288. gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);
  290. gGL.getTexUnit(1)->bindManual(LLTexUnit::TT_TEXTURE, noiseTexture);
  291. glUniform1iARB(nightVisionUniforms["NoiseTexture"], 1);
  294. glUniform1fARB(nightVisionUniforms["brightMult"], tweaks.getBrightMult());
  295. glUniform1fARB(nightVisionUniforms["noiseStrength"], tweaks.getNoiseStrength());
  296. noiseTextureScale = 0.01f + ((101.f - tweaks.getNoiseSize()) / 100.f);
  297. noiseTextureScale *= (screenH / NOISE_SIZE);
  300. glUniform3fARB(nightVisionUniforms["lumWeights"], LUMINANCE_R, LUMINANCE_G, LUMINANCE_B);
  302. LLGLEnable blend(GL_BLEND);
  303. gGL.setSceneBlendType(LLRender::BT_REPLACE);
  304. LLGLDepthTest depth(GL_FALSE);
  306. /// Draw a screen space quad
  307. drawOrthoQuad(screenW, screenH, QUAD_NOISE);
  308. gPostNightVisionProgram.unbind();
  309. gGL.getTexUnit(0)->activate();
  310. */
  311. }
  313. void LLPostProcess::createNightVisionShader(void)
  314. {
  315. /// Define uniform names
  316. nightVisionUniforms["RenderTexture"] = 0;
  317. nightVisionUniforms["NoiseTexture"] = 0;
  318. nightVisionUniforms["brightMult"] = 0;
  319. nightVisionUniforms["noiseStrength"] = 0;
  320. nightVisionUniforms["lumWeights"] = 0;
  322. createNoiseTexture(mNoiseTexture);
  323. }
  325. void LLPostProcess::applyBloomShader(void)
  326. {
  328. }
  330. void LLPostProcess::createBloomShader(void)
  331. {
  332. createTexture(mTempBloomTexture, unsigned(screenW * 0.5), unsigned(screenH * 0.5));
  334. /// Create Bloom Extract Shader
  335. bloomExtractUniforms["RenderTexture"] = 0;
  336. bloomExtractUniforms["extractLow"] = 0;
  337. bloomExtractUniforms["extractHigh"] = 0;
  338. bloomExtractUniforms["lumWeights"] = 0;
  340. /// Create Bloom Blur Shader
  341. bloomBlurUniforms["RenderTexture"] = 0;
  342. bloomBlurUniforms["bloomStrength"] = 0;
  343. bloomBlurUniforms["texelSize"] = 0;
  344. bloomBlurUniforms["blurDirection"] = 0;
  345. bloomBlurUniforms["blurWidth"] = 0;
  346. }
  348. void LLPostProcess::getShaderUniforms(glslUniforms & uniforms, GLhandleARB & prog)
  349. {
  350. /// Find uniform locations and insert into map
  351. std::map<const char *, GLuint>::iterator i;
  352. for (i  = uniforms.begin(); i != uniforms.end(); ++i){
  353. i->second = glGetUniformLocationARB(prog, i->first);
  354. }
  355. }
  357. void LLPostProcess::doEffects(void)
  358. {
  359. /// Save GL State
  360. glPushAttrib(GL_ALL_ATTRIB_BITS);
  361. glPushClientAttrib(GL_ALL_ATTRIB_BITS);
  363. /// Copy the screen buffer to the render texture
  364. {
  365. U32 tex = mSceneRenderTexture->getTexName() ;
  366. copyFrameBuffer(tex, screenW, screenH);
  367. }
  369. /// Clear the frame buffer.
  370. glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  371. glClear(GL_COLOR_BUFFER_BIT);
  373. /// Change to an orthogonal view
  374. viewOrthogonal(screenW, screenH);
  376. checkError();
  377. applyShaders();
  379. LLGLSLShader::bindNoShader();
  380. checkError();
  382. /// Change to a perspective view
  383. viewPerspective();
  385. /// Reset GL State
  386. glPopClientAttrib();
  387. glPopAttrib();
  388. checkError();
  389. }
  391. void LLPostProcess::copyFrameBuffer(U32 & texture, unsigned int width, unsigned int height)
  392. {
  393. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_RECT_TEXTURE, texture);
  394. glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 0, 0, width, height, 0);
  395. }
  397. void LLPostProcess::drawOrthoQuad(unsigned int width, unsigned int height, QuadType type)
  398. {
  399. #if 0
  400. float noiseX = 0.f;
  401. float noiseY = 0.f;
  402. float screenRatio = 1.0f;
  404. if (type == QUAD_NOISE){
  405. noiseX = ((float) rand() / (float) RAND_MAX);
  406. noiseY = ((float) rand() / (float) RAND_MAX);
  407. screenRatio = (float) width / (float) height;
  408. }
  411. glBegin(GL_QUADS);
  412. if (type != QUAD_BLOOM_EXTRACT){
  413. glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, (GLfloat) height);
  414. } else {
  415. glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, (GLfloat) height * 2.0f);
  416. }
  417. if (type == QUAD_NOISE){
  418. glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
  419. noiseX,
  420. noiseTextureScale + noiseY);
  421. } else if (type == QUAD_BLOOM_COMBINE){
  422. glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.f, (GLfloat) height * 0.5f);
  423. }
  424. glVertex2f(0.f, (GLfloat) screenH - height);
  426. if (type != QUAD_BLOOM_EXTRACT){
  427. glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, 0.f);
  428. } else {
  429. glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, 0.f);
  430. }
  431. if (type == QUAD_NOISE){
  432. glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
  433. noiseX,
  434. noiseY);
  435. } else if (type == QUAD_BLOOM_COMBINE){
  436. glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.f, 0.f);
  437. }
  438. glVertex2f(0.f, (GLfloat) height + (screenH - height));
  441. if (type != QUAD_BLOOM_EXTRACT){
  442. glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width, 0.f);
  443. } else {
  444. glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width * 2.0f, 0.f);
  445. }
  446. if (type == QUAD_NOISE){
  447. glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
  448. screenRatio * noiseTextureScale + noiseX,
  449. noiseY);
  450. } else if (type == QUAD_BLOOM_COMBINE){
  451. glMultiTexCoord2fARB(GL_TEXTURE1_ARB, (GLfloat) width * 0.5f, 0.f);
  452. }
  453. glVertex2f((GLfloat) width, (GLfloat) height + (screenH - height));
  456. if (type != QUAD_BLOOM_EXTRACT){
  457. glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width, (GLfloat) height);
  458. } else {
  459. glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width * 2.0f, (GLfloat) height * 2.0f);
  460. }
  461. if (type == QUAD_NOISE){
  462. glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
  463. screenRatio * noiseTextureScale + noiseX,
  464. noiseTextureScale + noiseY);
  465. } else if (type == QUAD_BLOOM_COMBINE){
  466. glMultiTexCoord2fARB(GL_TEXTURE1_ARB, (GLfloat) width * 0.5f, (GLfloat) height * 0.5f);
  467. }
  468. glVertex2f((GLfloat) width, (GLfloat) screenH - height);
  469. glEnd();
  470. #endif
  471. }
  473. void LLPostProcess::viewOrthogonal(unsigned int width, unsigned int height)
  474. {
  475. glMatrixMode(GL_PROJECTION);
  476. glPushMatrix();
  477. glLoadIdentity();
  478. glOrtho( 0.f, (GLdouble) width , (GLdouble) height , 0.f, -1.f, 1.f );
  479. glMatrixMode(GL_MODELVIEW);
  480. glPushMatrix();
  481. glLoadIdentity();
  482. }
  484. void LLPostProcess::viewPerspective(void)
  485. {
  486. glMatrixMode( GL_PROJECTION );
  487. glPopMatrix();
  488. glMatrixMode( GL_MODELVIEW );
  489. glPopMatrix();
  490. }
  492. void LLPostProcess::changeOrthogonal(unsigned int width, unsigned int height)
  493. {
  494. viewPerspective();
  495. viewOrthogonal(width, height);
  496. }
  498. void LLPostProcess::createTexture(LLPointer<LLImageGL>& texture, unsigned int width, unsigned int height)
  499. {
  500. std::vector<GLubyte> data(width * height * 4, 0) ;
  502. texture = new LLImageGL(FALSE) ;
  503. if(texture->createGLTexture())
  504. {
  505. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_RECT_TEXTURE, texture->getTexName());
  506. glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 4, width, height, 0,
  507. GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
  508. gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
  509. gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
  510. }
  511. }
  513. void LLPostProcess::createNoiseTexture(LLPointer<LLImageGL>& texture)
  514. {
  515. std::vector<GLubyte> buffer(NOISE_SIZE * NOISE_SIZE);
  516. for (unsigned int i = 0; i < NOISE_SIZE; i++){
  517. for (unsigned int k = 0; k < NOISE_SIZE; k++){
  518. buffer[(i * NOISE_SIZE) + k] = (GLubyte)((double) rand() / ((double) RAND_MAX + 1.f) * 255.f);
  519. }
  520. }
  522. texture = new LLImageGL(FALSE) ;
  523. if(texture->createGLTexture())
  524. {
  525. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture->getTexName());
  526. LLImageGL::setManualImage(GL_TEXTURE_2D, 0, GL_LUMINANCE, NOISE_SIZE, NOISE_SIZE, GL_LUMINANCE, GL_UNSIGNED_BYTE, &buffer[0]);
  527. gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
  528. gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_WRAP);
  529. }
  530. }
  532. bool LLPostProcess::checkError(void)
  533. {
  534. GLenum glErr;
  535.     bool    retCode = false;
  537.     glErr = glGetError();
  538.     while (glErr != GL_NO_ERROR)
  539.     {
  540. // shaderErrorLog << (const char *) gluErrorString(glErr) << std::endl;
  541. char const * err_str_raw = (const char *) gluErrorString(glErr);
  543. if(err_str_raw == NULL)
  544. {
  545. std::ostringstream err_builder;
  546. err_builder << "unknown error number " << glErr;
  547. mShaderErrorString = err_builder.str();
  548. }
  549. else
  550. {
  551. mShaderErrorString = err_str_raw;
  552. }
  554.         retCode = true;
  555.         glErr = glGetError();
  556.     }
  557.     return retCode;
  558. }
  560. void LLPostProcess::checkShaderError(GLhandleARB shader)
  561. {
  562.     GLint infologLength = 0;
  563.     GLint charsWritten  = 0;
  564.     GLchar *infoLog;
  566.     checkError();  // Check for OpenGL errors
  568.     glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infologLength);
  570.     checkError();  // Check for OpenGL errors
  572.     if (infologLength > 0)
  573.     {
  574.         infoLog = (GLchar *)malloc(infologLength);
  575.         if (infoLog == NULL)
  576.         {
  577.             /// Could not allocate infolog buffer
  578.             return;
  579.         }
  580.         glGetInfoLogARB(shader, infologLength, &charsWritten, infoLog);
  581. // shaderErrorLog << (char *) infoLog << std::endl;
  582. mShaderErrorString = (char *) infoLog;
  583.         free(infoLog);
  584.     }
  585.     checkError();  // Check for OpenGL errors
  586. }