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

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

游戏引擎

开发平台：

C++ Builder

llgl.cpp：源码内容
  1. /** 
  2.  * @file llgl.cpp
  3.  * @brief LLGL implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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. // This file sets some global GL parameters, and implements some 
  34. // useful functions for GL operations.
  36. #define GLH_EXT_SINGLE_FILE
  38. #include "linden_common.h"
  40. #include "boost/tokenizer.hpp"
  42. #include "llsys.h"
  44. #include "llgl.h"
  45. #include "llrender.h"
  47. #include "llerror.h"
  48. #include "llerrorcontrol.h"
  49. #include "llquaternion.h"
  50. #include "llmath.h"
  51. #include "m4math.h"
  52. #include "llstring.h"
  53. #include "llmemtype.h"
  54. #include "llstacktrace.h"
  56. #include "llglheaders.h"
  58. #ifdef _DEBUG
  59. //#define GL_STATE_VERIFY
  60. #endif
  63. BOOL gDebugSession = FALSE;
  64. BOOL gDebugGL = FALSE;
  65. BOOL gClothRipple = FALSE;
  66. BOOL gNoRender = FALSE;
  67. BOOL gGLActive = FALSE;
  70. std::ofstream gFailLog;
  72. void ll_init_fail_log(std::string filename)
  73. {
  74. gFailLog.open(filename.c_str());
  75. }
  78. void ll_fail(std::string msg)
  79. {
  81. if (gDebugSession)
  82. {
  83. std::vector<std::string> lines;
  85. gFailLog << LLError::utcTime() << " " << msg << std::endl;
  87. gFailLog << "Stack Trace:" << std::endl;
  89. ll_get_stack_trace(lines);
  91. for(size_t i = 0; i < lines.size(); ++i)
  92. {
  93. gFailLog << lines[i] << std::endl;
  94. }
  96. gFailLog << "End of Stack Trace." << std::endl << std::endl;
  98. gFailLog.flush();
  99. }
  100. };
  102. void ll_close_fail_log()
  103. {
  104. gFailLog.close();
  105. }
  107. LLMatrix4 gGLObliqueProjectionInverse;
  109. #define LL_GL_NAME_POOLING 0
  111. LLGLNamePool::pool_list_t LLGLNamePool::sInstances;
  112. std::list<LLGLUpdate*> LLGLUpdate::sGLQ;
  114. #if (LL_WINDOWS || LL_LINUX || LL_SOLARIS)  && !LL_MESA_HEADLESS
  115. // ATI prototypes
  116. // vertex blending prototypes
  117. PFNGLWEIGHTPOINTERARBPROC glWeightPointerARB = NULL;
  118. PFNGLVERTEXBLENDARBPROC glVertexBlendARB = NULL;
  119. PFNGLWEIGHTFVARBPROC glWeightfvARB = NULL;
  121. // Vertex buffer object prototypes
  122. PFNGLBINDBUFFERARBPROC glBindBufferARB = NULL;
  123. PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = NULL;
  124. PFNGLGENBUFFERSARBPROC glGenBuffersARB = NULL;
  125. PFNGLISBUFFERARBPROC glIsBufferARB = NULL;
  126. PFNGLBUFFERDATAARBPROC glBufferDataARB = NULL;
  127. PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB = NULL;
  128. PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB = NULL;
  129. PFNGLMAPBUFFERARBPROC glMapBufferARB = NULL;
  130. PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = NULL;
  131. PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB = NULL;
  132. PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB = NULL;
  134. // vertex object prototypes
  135. PFNGLNEWOBJECTBUFFERATIPROC glNewObjectBufferATI = NULL;
  136. PFNGLISOBJECTBUFFERATIPROC glIsObjectBufferATI = NULL;
  137. PFNGLUPDATEOBJECTBUFFERATIPROC glUpdateObjectBufferATI = NULL;
  138. PFNGLGETOBJECTBUFFERFVATIPROC glGetObjectBufferfvATI = NULL;
  139. PFNGLGETOBJECTBUFFERIVATIPROC glGetObjectBufferivATI = NULL;
  140. PFNGLFREEOBJECTBUFFERATIPROC glFreeObjectBufferATI = NULL;
  141. PFNGLARRAYOBJECTATIPROC glArrayObjectATI = NULL;
  142. PFNGLVERTEXATTRIBARRAYOBJECTATIPROC glVertexAttribArrayObjectATI = NULL;
  143. PFNGLGETARRAYOBJECTFVATIPROC glGetArrayObjectfvATI = NULL;
  144. PFNGLGETARRAYOBJECTIVATIPROC glGetArrayObjectivATI = NULL;
  145. PFNGLVARIANTARRAYOBJECTATIPROC glVariantObjectArrayATI = NULL;
  146. PFNGLGETVARIANTARRAYOBJECTFVATIPROC glGetVariantArrayObjectfvATI = NULL;
  147. PFNGLGETVARIANTARRAYOBJECTIVATIPROC glGetVariantArrayObjectivATI = NULL;
  149. // GL_ARB_occlusion_query
  150. PFNGLGENQUERIESARBPROC glGenQueriesARB = NULL;
  151. PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB = NULL;
  152. PFNGLISQUERYARBPROC glIsQueryARB = NULL;
  153. PFNGLBEGINQUERYARBPROC glBeginQueryARB = NULL;
  154. PFNGLENDQUERYARBPROC glEndQueryARB = NULL;
  155. PFNGLGETQUERYIVARBPROC glGetQueryivARB = NULL;
  156. PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB = NULL;
  157. PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB = NULL;
  159. // GL_ARB_point_parameters
  160. PFNGLPOINTPARAMETERFARBPROC glPointParameterfARB = NULL;
  161. PFNGLPOINTPARAMETERFVARBPROC glPointParameterfvARB = NULL;
  163. // GL_EXT_framebuffer_object
  164. PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT = NULL;
  165. PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT = NULL;
  166. PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT = NULL;
  167. PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT = NULL;
  168. PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT = NULL;
  169. PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT = NULL;
  170. PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT = NULL;
  171. PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT = NULL;
  172. PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT = NULL;
  173. PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT = NULL;
  174. PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT = NULL;
  175. PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT = NULL;
  176. PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT = NULL;
  177. PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT = NULL;
  178. PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT = NULL;
  179. PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT = NULL;
  180. PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT = NULL;
  182. // GL_EXT_framebuffer_multisample
  183. PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC glRenderbufferStorageMultisampleEXT = NULL;
  185. // GL_EXT_framebuffer_blit
  186. PFNGLBLITFRAMEBUFFEREXTPROC glBlitFramebufferEXT = NULL;
  188. // GL_ARB_draw_buffers
  189. PFNGLDRAWBUFFERSARBPROC glDrawBuffersARB = NULL;
  191. //shader object prototypes
  192. PFNGLDELETEOBJECTARBPROC glDeleteObjectARB = NULL;
  193. PFNGLGETHANDLEARBPROC glGetHandleARB = NULL;
  194. PFNGLDETACHOBJECTARBPROC glDetachObjectARB = NULL;
  195. PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB = NULL;
  196. PFNGLSHADERSOURCEARBPROC glShaderSourceARB = NULL;
  197. PFNGLCOMPILESHADERARBPROC glCompileShaderARB = NULL;
  198. PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB = NULL;
  199. PFNGLATTACHOBJECTARBPROC glAttachObjectARB = NULL;
  200. PFNGLLINKPROGRAMARBPROC glLinkProgramARB = NULL;
  201. PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB = NULL;
  202. PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB = NULL;
  203. PFNGLUNIFORM1FARBPROC glUniform1fARB = NULL;
  204. PFNGLUNIFORM2FARBPROC glUniform2fARB = NULL;
  205. PFNGLUNIFORM3FARBPROC glUniform3fARB = NULL;
  206. PFNGLUNIFORM4FARBPROC glUniform4fARB = NULL;
  207. PFNGLUNIFORM1IARBPROC glUniform1iARB = NULL;
  208. PFNGLUNIFORM2IARBPROC glUniform2iARB = NULL;
  209. PFNGLUNIFORM3IARBPROC glUniform3iARB = NULL;
  210. PFNGLUNIFORM4IARBPROC glUniform4iARB = NULL;
  211. PFNGLUNIFORM1FVARBPROC glUniform1fvARB = NULL;
  212. PFNGLUNIFORM2FVARBPROC glUniform2fvARB = NULL;
  213. PFNGLUNIFORM3FVARBPROC glUniform3fvARB = NULL;
  214. PFNGLUNIFORM4FVARBPROC glUniform4fvARB = NULL;
  215. PFNGLUNIFORM1IVARBPROC glUniform1ivARB = NULL;
  216. PFNGLUNIFORM2IVARBPROC glUniform2ivARB = NULL;
  217. PFNGLUNIFORM3IVARBPROC glUniform3ivARB = NULL;
  218. PFNGLUNIFORM4IVARBPROC glUniform4ivARB = NULL;
  219. PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB = NULL;
  220. PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB = NULL;
  221. PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB = NULL;
  222. PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB = NULL;
  223. PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB = NULL;
  224. PFNGLGETINFOLOGARBPROC glGetInfoLogARB = NULL;
  225. PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB = NULL;
  226. PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB = NULL;
  227. PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB = NULL;
  228. PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB = NULL;
  229. PFNGLGETUNIFORMIVARBPROC glGetUniformivARB = NULL;
  230. PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB = NULL;
  232. // vertex shader prototypes
  233. #if LL_LINUX || LL_SOLARIS
  234. PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB = NULL;
  235. PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB = NULL;
  236. PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB = NULL;
  237. PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB = NULL;
  238. PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB = NULL;
  239. PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB = NULL;
  240. PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB = NULL;
  241. PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB = NULL;
  242. PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB = NULL;
  243. PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB = NULL;
  244. PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB = NULL;
  245. PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB = NULL;
  246. PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB = NULL;
  247. PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB = NULL;
  248. PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB = NULL;
  249. PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB = NULL;
  250. PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB = NULL;
  251. PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB = NULL;
  252. #endif // LL_LINUX || LL_SOLARIS
  253. PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4nbvARB = NULL;
  254. PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4nivARB = NULL;
  255. PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4nsvARB = NULL;
  256. PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4nubARB = NULL;
  257. PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4nubvARB = NULL;
  258. PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4nuivARB = NULL;
  259. PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4nusvARB = NULL;
  260. #if LL_LINUX  || LL_SOLARIS
  261. PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB = NULL;
  262. PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB = NULL;
  263. PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB = NULL;
  264. PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB = NULL;
  265. PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB = NULL;
  266. PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB = NULL;
  267. PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB = NULL;
  268. PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB = NULL;
  269. PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB = NULL;
  270. PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB = NULL;
  271. PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB = NULL;
  272. PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB = NULL;
  273. PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB = NULL;
  274. PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB = NULL;
  275. PFNGLPROGRAMSTRINGARBPROC glProgramStringARB = NULL;
  276. PFNGLBINDPROGRAMARBPROC glBindProgramARB = NULL;
  277. PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB = NULL;
  278. PFNGLGENPROGRAMSARBPROC glGenProgramsARB = NULL;
  279. PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB = NULL;
  280. PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB = NULL;
  281. PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB = NULL;
  282. PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB = NULL;
  283. PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB = NULL;
  284. PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB = NULL;
  285. PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB = NULL;
  286. PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB = NULL;
  287. PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB = NULL;
  288. PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB = NULL;
  289. PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB = NULL;
  290. PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB = NULL;
  291. PFNGLGETPROGRAMIVARBPROC glGetProgramivARB = NULL;
  292. PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB = NULL;
  293. PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB = NULL;
  294. PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB = NULL;
  295. PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB = NULL;
  296. PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB = NULL;
  297. PFNGLISPROGRAMARBPROC glIsProgramARB = NULL;
  298. #endif // LL_LINUX || LL_SOLARIS
  299. PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB = NULL;
  300. PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB = NULL;
  301. PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB = NULL;
  303. #if LL_WINDOWS
  304. PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
  305. #endif
  307. #if LL_LINUX_NV_GL_HEADERS
  308. // linux nvidia headers.  these define these differently to mesa's.  ugh.
  309. PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = NULL;
  310. PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = NULL;
  311. PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements = NULL;
  312. #endif // LL_LINUX_NV_GL_HEADERS
  313. #endif
  315. LLGLManager gGLManager;
  317. LLGLManager::LLGLManager() :
  318. mInited(FALSE),
  319. mIsDisabled(FALSE),
  321. mHasMultitexture(FALSE),
  322. mNumTextureUnits(1),
  323. mHasMipMapGeneration(FALSE),
  324. mHasCompressedTextures(FALSE),
  325. mHasFramebufferObject(FALSE),
  326. mHasFramebufferMultisample(FALSE),
  328. mHasVertexBufferObject(FALSE),
  329. mHasPBuffer(FALSE),
  330. mHasShaderObjects(FALSE),
  331. mHasVertexShader(FALSE),
  332. mHasFragmentShader(FALSE),
  333. mHasOcclusionQuery(FALSE),
  334. mHasPointParameters(FALSE),
  335. mHasDrawBuffers(FALSE),
  336. mHasTextureRectangle(FALSE),
  338. mHasAnisotropic(FALSE),
  339. mHasARBEnvCombine(FALSE),
  340. mHasCubeMap(FALSE),
  342. mIsATI(FALSE),
  343. mIsNVIDIA(FALSE),
  344. mIsIntel(FALSE),
  345. mIsGF2or4MX(FALSE),
  346. mIsGF3(FALSE),
  347. mIsGFFX(FALSE),
  348. mATIOffsetVerticalLines(FALSE),
  349. mATIOldDriver(FALSE),
  351. mHasRequirements(TRUE),
  353. mHasSeparateSpecularColor(FALSE),
  355. mDriverVersionMajor(1),
  356. mDriverVersionMinor(0),
  357. mDriverVersionRelease(0),
  358. mGLVersion(1.0f),
  360. mVRAM(0),
  361. mGLMaxVertexRange(0),
  362. mGLMaxIndexRange(0)
  363. {
  364. }
  366. //---------------------------------------------------------------------
  367. // Global initialization for GL
  368. //---------------------------------------------------------------------
  369. void LLGLManager::initWGL()
  370. {
  371. mHasPBuffer = FALSE;
  372. #if LL_WINDOWS && !LL_MESA_HEADLESS
  373. if (!glh_init_extensions("WGL_ARB_pixel_format"))
  374. {
  375. LL_WARNS("RenderInit") << "No ARB pixel format extensions" << LL_ENDL;
  376. }
  378. if (ExtensionExists("WGL_EXT_swap_control", gGLHExts.mSysExts))
  379. {
  380.         GLH_EXT_NAME(wglSwapIntervalEXT) = (PFNWGLSWAPINTERVALEXTPROC)GLH_EXT_GET_PROC_ADDRESS("wglSwapIntervalEXT");
  381. }
  383. if( !glh_init_extensions("WGL_ARB_pbuffer") )
  384. {
  385. LL_WARNS("RenderInit") << "No ARB WGL PBuffer extensions" << LL_ENDL;
  386. }
  388. if( !glh_init_extensions("WGL_ARB_render_texture") )
  389. {
  390. LL_WARNS("RenderInit") << "No ARB WGL render texture extensions" << LL_ENDL;
  391. }
  393. mHasPBuffer = ExtensionExists("WGL_ARB_pbuffer", gGLHExts.mSysExts) &&
  394. ExtensionExists("WGL_ARB_render_texture", gGLHExts.mSysExts) &&
  395. ExtensionExists("WGL_ARB_pixel_format", gGLHExts.mSysExts);
  396. #endif
  397. }
  399. // return false if unable (or unwilling due to old drivers) to init GL
  400. bool LLGLManager::initGL()
  401. {
  402. if (mInited)
  403. {
  404. LL_ERRS("RenderInit") << "Calling init on LLGLManager after already initialized!" << LL_ENDL;
  405. }
  407. GLint alpha_bits;
  408. glGetIntegerv( GL_ALPHA_BITS, &alpha_bits );
  409. if( 8 != alpha_bits )
  410. {
  411. LL_WARNS("RenderInit") << "Frame buffer has less than 8 bits of alpha.  Avatar texture compositing will fail." << LL_ENDL;
  412. }
  414. // Extract video card strings and convert to upper case to
  415. // work around driver-to-driver variation in capitalization.
  416. mGLVendor = std::string((const char *)glGetString(GL_VENDOR));
  417. LLStringUtil::toUpper(mGLVendor);
  419. mGLRenderer = std::string((const char *)glGetString(GL_RENDERER));
  420. LLStringUtil::toUpper(mGLRenderer);
  422. parse_gl_version( &mDriverVersionMajor, 
  423. &mDriverVersionMinor, 
  424. &mDriverVersionRelease, 
  425. &mDriverVersionVendorString );
  427. mGLVersion = mDriverVersionMajor + mDriverVersionMinor * .1f;
  429. // Trailing space necessary to keep "nVidia Corpor_ati_on" cards
  430. // from being recognized as ATI.
  431. if (mGLVendor.substr(0,4) == "ATI ")
  432. {
  433. mGLVendorShort = "ATI";
  434. BOOL mobile = FALSE;
  435. if (mGLRenderer.find("MOBILITY") != std::string::npos)
  436. {
  437. mobile = TRUE;
  438. }
  439. mIsATI = TRUE;
  441. #if LL_WINDOWS && !LL_MESA_HEADLESS
  442. if (mDriverVersionRelease < 3842)
  443. {
  444. mATIOffsetVerticalLines = TRUE;
  445. }
  446. #endif // LL_WINDOWS
  448. #if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
  449. // release 7277 is a point at which we verify that ATI OpenGL
  450. // drivers get pretty stable with SL, ~Catalyst 8.2,
  451. // for both Win32 and Linux.
  452. if (mDriverVersionRelease < 7277 &&
  453.     mDriverVersionRelease != 0) // 0 == Undetectable driver version - these get to pretend to be new ATI drivers, though that decision may be revisited.
  454. {
  455. mATIOldDriver = TRUE;
  456. }
  457. #endif // (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
  458. }
  459. else if (mGLVendor.find("NVIDIA ") != std::string::npos)
  460. {
  461. mGLVendorShort = "NVIDIA";
  462. mIsNVIDIA = TRUE;
  463. if (   mGLRenderer.find("GEFORCE4 MX") != std::string::npos
  464. || mGLRenderer.find("GEFORCE2") != std::string::npos
  465. || mGLRenderer.find("GEFORCE 2") != std::string::npos
  466. || mGLRenderer.find("GEFORCE4 460 GO") != std::string::npos
  467. || mGLRenderer.find("GEFORCE4 440 GO") != std::string::npos
  468. || mGLRenderer.find("GEFORCE4 420 GO") != std::string::npos)
  469. {
  470. mIsGF2or4MX = TRUE;
  471. }
  472. else if (mGLRenderer.find("GEFORCE FX") != std::string::npos
  473.  || mGLRenderer.find("QUADRO FX") != std::string::npos
  474.  || mGLRenderer.find("NV34") != std::string::npos)
  475. {
  476. mIsGFFX = TRUE;
  477. }
  478. else if(mGLRenderer.find("GEFORCE3") != std::string::npos)
  479. {
  480. mIsGF3 = TRUE;
  481. }
  483. }
  484. else if (mGLVendor.find("INTEL") != std::string::npos
  485. #if LL_LINUX
  486.  // The Mesa-based drivers put this in the Renderer string,
  487.  // not the Vendor string.
  488.  || mGLRenderer.find("INTEL") != std::string::npos
  489. #endif //LL_LINUX
  490.  )
  491. {
  492. mGLVendorShort = "INTEL";
  493. mIsIntel = TRUE;
  494. }
  495. else
  496. {
  497. mGLVendorShort = "MISC";
  498. }
  500. // This is called here because it depends on the setting of mIsGF2or4MX, and sets up mHasMultitexture.
  501. initExtensions();
  503. if (mHasMultitexture)
  504. {
  505. GLint num_tex_units;
  506. glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &num_tex_units);
  507. mNumTextureUnits = llmin(num_tex_units, (GLint)MAX_GL_TEXTURE_UNITS);
  508. if (mIsIntel)
  509. {
  510. mNumTextureUnits = llmin(mNumTextureUnits, 2);
  511. }
  512. }
  513. else
  514. {
  515. mHasRequirements = FALSE;
  517. // We don't support cards that don't support the GL_ARB_multitexture extension
  518. LL_WARNS("RenderInit") << "GL Drivers do not support GL_ARB_multitexture" << LL_ENDL;
  519. return false;
  520. }
  523. initGLStates();
  524. return true;
  525. }
  527. void LLGLManager::getGLInfo(LLSD& info)
  528. {
  529. info["GLInfo"]["GLVendor"] = std::string((const char *)glGetString(GL_VENDOR));
  530. info["GLInfo"]["GLRenderer"] = std::string((const char *)glGetString(GL_RENDERER));
  531. info["GLInfo"]["GLVersion"] = std::string((const char *)glGetString(GL_VERSION));
  533. #if !LL_MESA_HEADLESS
  534. std::string all_exts = ll_safe_string((const char *)gGLHExts.mSysExts);
  535. boost::char_separator<char> sep(" ");
  536. boost::tokenizer<boost::char_separator<char> > tok(all_exts, sep);
  537. for(boost::tokenizer<boost::char_separator<char> >::iterator i = tok.begin(); i != tok.end(); ++i)
  538. {
  539. info["GLInfo"]["GLExtensions"].append(*i);
  540. }
  541. #endif
  542. }
  544. std::string LLGLManager::getGLInfoString()
  545. {
  546. std::string info_str;
  547. std::string all_exts, line;
  549. info_str += std::string("GL_VENDOR      ") + ll_safe_string((const char *)glGetString(GL_VENDOR)) + std::string("n");
  550. info_str += std::string("GL_RENDERER    ") + ll_safe_string((const char *)glGetString(GL_RENDERER)) + std::string("n");
  551. info_str += std::string("GL_VERSION     ") + ll_safe_string((const char *)glGetString(GL_VERSION)) + std::string("n");
  553. #if !LL_MESA_HEADLESS 
  554. all_exts = (const char *)gGLHExts.mSysExts;
  555. LLStringUtil::replaceChar(all_exts, ' ', 'n');
  556. info_str += std::string("GL_EXTENSIONS:n") + all_exts + std::string("n");
  557. #endif
  559. return info_str;
  560. }
  562. void LLGLManager::printGLInfoString()
  563. {
  564. std::string info_str;
  565. std::string all_exts, line;
  567. LL_INFOS("RenderInit") << "GL_VENDOR:     " << ((const char *)glGetString(GL_VENDOR)) << LL_ENDL;
  568. LL_INFOS("RenderInit") << "GL_RENDERER:   " << ((const char *)glGetString(GL_RENDERER)) << LL_ENDL;
  569. LL_INFOS("RenderInit") << "GL_VERSION:    " << ((const char *)glGetString(GL_VERSION)) << LL_ENDL;
  571. #if !LL_MESA_HEADLESS
  572. all_exts = std::string(gGLHExts.mSysExts);
  573. LLStringUtil::replaceChar(all_exts, ' ', 'n');
  574. LL_DEBUGS("RenderInit") << "GL_EXTENSIONS:n" << all_exts << LL_ENDL;
  575. #endif
  576. }
  578. std::string LLGLManager::getRawGLString()
  579. {
  580. std::string gl_string;
  581. gl_string = ll_safe_string((char*)glGetString(GL_VENDOR)) + " " + ll_safe_string((char*)glGetString(GL_RENDERER));
  582. return gl_string;
  583. }
  585. void LLGLManager::shutdownGL()
  586. {
  587. if (mInited)
  588. {
  589. glFinish();
  590. stop_glerror();
  591. mInited = FALSE;
  592. }
  593. }
  595. // these are used to turn software blending on. They appear in the Debug/Avatar menu
  596. // presence of vertex skinning/blending or vertex programs will set these to FALSE by default.
  598. void LLGLManager::initExtensions()
  599. {
  600. #if LL_MESA_HEADLESS
  601. # if GL_ARB_multitexture
  602. mHasMultitexture = TRUE;
  603. # else
  604. mHasMultitexture = FALSE;
  605. # endif
  606. # if GL_ARB_texture_env_combine
  607. mHasARBEnvCombine = TRUE;
  608. # else
  609. mHasARBEnvCombine = FALSE;
  610. # endif
  611. # if GL_ARB_texture_compression
  612. mHasCompressedTextures = TRUE;
  613. # else
  614. mHasCompressedTextures = FALSE;
  615. # endif
  616. # if GL_ARB_vertex_buffer_object
  617. mHasVertexBufferObject = TRUE;
  618. # else
  619. mHasVertexBufferObject = FALSE;
  620. # endif
  621. # if GL_EXT_framebuffer_object
  622. mHasFramebufferObject = TRUE;
  623. # else
  624. mHasFramebufferObject = FALSE;
  625. # endif
  626. # if GL_EXT_framebuffer_multisample
  627. mHasFramebufferMultisample = TRUE;
  628. # else
  629. mHasFramebufferMultisample = FALSE;
  630. # endif
  631. # if GL_ARB_draw_buffers
  632. mHasDrawBuffers = TRUE;
  633. #else
  634. mHasDrawBuffers = FALSE;
  635. # endif
  636. mHasMipMapGeneration = FALSE;
  637. mHasSeparateSpecularColor = FALSE;
  638. mHasAnisotropic = FALSE;
  639. mHasCubeMap = FALSE;
  640. mHasOcclusionQuery = FALSE;
  641. mHasPointParameters = FALSE;
  642. mHasShaderObjects = FALSE;
  643. mHasVertexShader = FALSE;
  644. mHasFragmentShader = FALSE;
  645. mHasTextureRectangle = FALSE;
  646. #else // LL_MESA_HEADLESS
  647. mHasMultitexture = glh_init_extensions("GL_ARB_multitexture");
  648. mHasMipMapGeneration = glh_init_extensions("GL_SGIS_generate_mipmap");
  649. mHasSeparateSpecularColor = glh_init_extensions("GL_EXT_separate_specular_color");
  650. mHasAnisotropic = glh_init_extensions("GL_EXT_texture_filter_anisotropic");
  651. glh_init_extensions("GL_ARB_texture_cube_map");
  652. mHasCubeMap = ExtensionExists("GL_ARB_texture_cube_map", gGLHExts.mSysExts);
  653. mHasARBEnvCombine = ExtensionExists("GL_ARB_texture_env_combine", gGLHExts.mSysExts);
  654. mHasCompressedTextures = glh_init_extensions("GL_ARB_texture_compression");
  655. mHasOcclusionQuery = ExtensionExists("GL_ARB_occlusion_query", gGLHExts.mSysExts);
  656. mHasVertexBufferObject = ExtensionExists("GL_ARB_vertex_buffer_object", gGLHExts.mSysExts);
  657. // mask out FBO support when packed_depth_stencil isn't there 'cause we need it for LLRenderTarget -Brad
  658. mHasFramebufferObject = ExtensionExists("GL_EXT_framebuffer_object", gGLHExts.mSysExts)
  659. && ExtensionExists("GL_EXT_packed_depth_stencil", gGLHExts.mSysExts);
  660. mHasFramebufferMultisample = mHasFramebufferObject && ExtensionExists("GL_EXT_framebuffer_multisample", gGLHExts.mSysExts);
  661. mHasDrawBuffers = ExtensionExists("GL_ARB_draw_buffers", gGLHExts.mSysExts);
  662. mHasTextureRectangle = ExtensionExists("GL_ARB_texture_rectangle", gGLHExts.mSysExts);
  663. #if !LL_DARWIN
  664. mHasPointParameters = !mIsATI && ExtensionExists("GL_ARB_point_parameters", gGLHExts.mSysExts);
  665. #endif
  666. mHasShaderObjects = ExtensionExists("GL_ARB_shader_objects", gGLHExts.mSysExts) && ExtensionExists("GL_ARB_shading_language_100", gGLHExts.mSysExts);
  667. mHasVertexShader = ExtensionExists("GL_ARB_vertex_program", gGLHExts.mSysExts) && ExtensionExists("GL_ARB_vertex_shader", gGLHExts.mSysExts)
  668. && ExtensionExists("GL_ARB_shading_language_100", gGLHExts.mSysExts);
  669. mHasFragmentShader = ExtensionExists("GL_ARB_fragment_shader", gGLHExts.mSysExts) && ExtensionExists("GL_ARB_shading_language_100", gGLHExts.mSysExts);
  670. #endif
  672. #if LL_LINUX || LL_SOLARIS
  673. llinfos << "initExtensions() checking shell variables to adjust features..." << llendl;
  674. // Our extension support for the Linux Client is very young with some
  675. // potential driver gotchas, so offer a semi-secret way to turn it off.
  676. if (getenv("LL_GL_NOEXT"))
  677. {
  678. //mHasMultitexture = FALSE; // NEEDED!
  679. mHasARBEnvCombine = FALSE;
  680. mHasCompressedTextures = FALSE;
  681. mHasVertexBufferObject = FALSE;
  682. mHasFramebufferObject = FALSE;
  683. mHasFramebufferMultisample = FALSE;
  684. mHasDrawBuffers = FALSE;
  685. mHasMipMapGeneration = FALSE;
  686. mHasSeparateSpecularColor = FALSE;
  687. mHasAnisotropic = FALSE;
  688. mHasCubeMap = FALSE;
  689. mHasOcclusionQuery = FALSE;
  690. mHasPointParameters = FALSE;
  691. mHasShaderObjects = FALSE;
  692. mHasVertexShader = FALSE;
  693. mHasFragmentShader = FALSE;
  694. LL_WARNS("RenderInit") << "GL extension support DISABLED via LL_GL_NOEXT" << LL_ENDL;
  695. }
  696. else if (getenv("LL_GL_BASICEXT")) /* Flawfinder: ignore */
  697. {
  698. // This switch attempts to turn off all support for exotic
  699. // extensions which I believe correspond to fatal driver
  700. // bug reports.  This should be the default until we get a
  701. // proper blacklist/whitelist on Linux.
  702. mHasMipMapGeneration = FALSE;
  703. mHasAnisotropic = FALSE;
  704. //mHasCubeMap = FALSE; // apparently fatal on Intel 915 & similar
  705. //mHasOcclusionQuery = FALSE; // source of many ATI system hangs
  706. mHasShaderObjects = FALSE;
  707. mHasVertexShader = FALSE;
  708. mHasFragmentShader = FALSE;
  709. LL_WARNS("RenderInit") << "GL extension support forced to SIMPLE level via LL_GL_BASICEXT" << LL_ENDL;
  710. }
  711. if (getenv("LL_GL_BLACKLIST")) /* Flawfinder: ignore */
  712. {
  713. // This lets advanced troubleshooters disable specific
  714. // GL extensions to isolate problems with their hardware.
  715. // SL-28126
  716. const char *const blacklist = getenv("LL_GL_BLACKLIST"); /* Flawfinder: ignore */
  717. LL_WARNS("RenderInit") << "GL extension support partially disabled via LL_GL_BLACKLIST: " << blacklist << LL_ENDL;
  718. if (strchr(blacklist,'a')) mHasARBEnvCombine = FALSE;
  719. if (strchr(blacklist,'b')) mHasCompressedTextures = FALSE;
  720. if (strchr(blacklist,'c')) mHasVertexBufferObject = FALSE;
  721. if (strchr(blacklist,'d')) mHasMipMapGeneration = FALSE;//S
  722. //  if (strchr(blacklist,'f')) mHasNVVertexArrayRange = FALSE;//S
  723. //  if (strchr(blacklist,'g')) mHasNVFence = FALSE;//S
  724. if (strchr(blacklist,'h')) mHasSeparateSpecularColor = FALSE;
  725. if (strchr(blacklist,'i')) mHasAnisotropic = FALSE;//S
  726. if (strchr(blacklist,'j')) mHasCubeMap = FALSE;//S
  727. //  if (strchr(blacklist,'k')) mHasATIVAO = FALSE;//S
  728. if (strchr(blacklist,'l')) mHasOcclusionQuery = FALSE;
  729. if (strchr(blacklist,'m')) mHasShaderObjects = FALSE;//S
  730. if (strchr(blacklist,'n')) mHasVertexShader = FALSE;//S
  731. if (strchr(blacklist,'o')) mHasFragmentShader = FALSE;//S
  732. if (strchr(blacklist,'p')) mHasPointParameters = FALSE;//S
  733. if (strchr(blacklist,'q')) mHasFramebufferObject = FALSE;//S
  734. if (strchr(blacklist,'r')) mHasDrawBuffers = FALSE;//S
  735. if (strchr(blacklist,'s')) mHasFramebufferMultisample = FALSE;
  736. if (strchr(blacklist,'t')) mHasTextureRectangle = FALSE;
  738. }
  739. #endif // LL_LINUX || LL_SOLARIS
  741. if (!mHasMultitexture)
  742. {
  743. LL_INFOS("RenderInit") << "Couldn't initialize multitexturing" << LL_ENDL;
  744. }
  745. if (!mHasMipMapGeneration)
  746. {
  747. LL_INFOS("RenderInit") << "Couldn't initialize mipmap generation" << LL_ENDL;
  748. }
  749. if (!mHasARBEnvCombine)
  750. {
  751. LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_texture_env_combine" << LL_ENDL;
  752. }
  753. if (!mHasSeparateSpecularColor)
  754. {
  755. LL_INFOS("RenderInit") << "Couldn't initialize separate specular color" << LL_ENDL;
  756. }
  757. if (!mHasAnisotropic)
  758. {
  759. LL_INFOS("RenderInit") << "Couldn't initialize anisotropic filtering" << LL_ENDL;
  760. }
  761. if (!mHasCompressedTextures)
  762. {
  763. LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_texture_compression" << LL_ENDL;
  764. }
  765. if (!mHasOcclusionQuery)
  766. {
  767. LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_occlusion_query" << LL_ENDL;
  768. }
  769. if (!mHasPointParameters)
  770. {
  771. LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_point_parameters" << LL_ENDL;
  772. }
  773. if (!mHasShaderObjects)
  774. {
  775. LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_shader_objects" << LL_ENDL;
  776. }
  777. if (!mHasVertexShader)
  778. {
  779. LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_vertex_shader" << LL_ENDL;
  780. }
  781. if (!mHasFragmentShader)
  782. {
  783. LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_fragment_shader" << LL_ENDL;
  784. }
  786. // Disable certain things due to known bugs
  787. if (mIsIntel && mHasMipMapGeneration)
  788. {
  789. LL_INFOS("RenderInit") << "Disabling mip-map generation for Intel GPUs" << LL_ENDL;
  790. mHasMipMapGeneration = FALSE;
  791. }
  792. if (mIsATI && mHasMipMapGeneration)
  793. {
  794. LL_INFOS("RenderInit") << "Disabling mip-map generation for ATI GPUs (performance opt)" << LL_ENDL;
  795. mHasMipMapGeneration = FALSE;
  796. }
  798. // Misc
  799. glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, (GLint*) &mGLMaxVertexRange);
  800. glGetIntegerv(GL_MAX_ELEMENTS_INDICES, (GLint*) &mGLMaxIndexRange);
  802. #if (LL_WINDOWS || LL_LINUX || LL_SOLARIS) && !LL_MESA_HEADLESS
  803. LL_DEBUGS("RenderInit") << "GL Probe: Getting symbols" << LL_ENDL;
  804. if (mHasVertexBufferObject)
  805. {
  806. glBindBufferARB = (PFNGLBINDBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBindBufferARB");
  807. if (glBindBufferARB)
  808. {
  809. glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)GLH_EXT_GET_PROC_ADDRESS("glDeleteBuffersARB");
  810. glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGenBuffersARB");
  811. glIsBufferARB = (PFNGLISBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glIsBufferARB");
  812. glBufferDataARB = (PFNGLBUFFERDATAARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBufferDataARB");
  813. glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBufferSubDataARB");
  814. glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetBufferSubDataARB");
  815. glMapBufferARB = (PFNGLMAPBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glMapBufferARB");
  816. glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glUnmapBufferARB");
  817. glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetBufferParameterivARB");
  818. glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetBufferPointervARB");
  819. }
  820. else
  821. {
  822. mHasVertexBufferObject = FALSE;
  823. }
  824. }
  825. if (mHasFramebufferObject)
  826. {
  827. llinfos << "initExtensions() FramebufferObject-related procs..." << llendl;
  828. glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glIsRenderbufferEXT");
  829. glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBindRenderbufferEXT");
  830. glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteRenderbuffersEXT");
  831. glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGenRenderbuffersEXT");
  832. glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glRenderbufferStorageEXT");
  833. glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGetRenderbufferParameterivEXT");
  834. glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glIsFramebufferEXT");
  835. glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBindFramebufferEXT");
  836. glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteFramebuffersEXT");
  837. glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGenFramebuffersEXT");
  838. glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glCheckFramebufferStatusEXT");
  839. glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glFramebufferTexture1DEXT");
  840. glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glFramebufferTexture2DEXT");
  841. glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glFramebufferTexture3DEXT");
  842. glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glFramebufferRenderbufferEXT");
  843. glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGetFramebufferAttachmentParameterivEXT");
  844. glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGenerateMipmapEXT");
  845. }
  846. if (mHasFramebufferMultisample)
  847. {
  848. glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glRenderbufferStorageMultisampleEXT");
  849. glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBlitFramebufferEXT");
  850. }
  851. if (mHasDrawBuffers)
  852. {
  853. glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDrawBuffersARB");
  854. }
  855. #if (!LL_LINUX && !LL_SOLARIS) || LL_LINUX_NV_GL_HEADERS
  856. // This is expected to be a static symbol on Linux GL implementations, except if we use the nvidia headers - bah
  857. glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)GLH_EXT_GET_PROC_ADDRESS("glDrawRangeElements");
  858. if (!glDrawRangeElements)
  859. {
  860. mGLMaxVertexRange = 0;
  861. mGLMaxIndexRange = 0;
  862. }
  863. #endif // !LL_LINUX || LL_LINUX_NV_GL_HEADERS
  864. #if LL_LINUX_NV_GL_HEADERS
  865. // nvidia headers are critically different from mesa-esque
  866.   glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)GLH_EXT_GET_PROC_ADDRESS("glActiveTextureARB");
  867.   glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)GLH_EXT_GET_PROC_ADDRESS("glClientActiveTextureARB");
  868. #endif // LL_LINUX_NV_GL_HEADERS
  870. if (mHasOcclusionQuery)
  871. {
  872. llinfos << "initExtensions() OcclusionQuery-related procs..." << llendl;
  873. glGenQueriesARB = (PFNGLGENQUERIESARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGenQueriesARB");
  874. glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)GLH_EXT_GET_PROC_ADDRESS("glDeleteQueriesARB");
  875. glIsQueryARB = (PFNGLISQUERYARBPROC)GLH_EXT_GET_PROC_ADDRESS("glIsQueryARB");
  876. glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBeginQueryARB");
  877. glEndQueryARB = (PFNGLENDQUERYARBPROC)GLH_EXT_GET_PROC_ADDRESS("glEndQueryARB");
  878. glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetQueryivARB");
  879. glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetQueryObjectivARB");
  880. glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetQueryObjectuivARB");
  881. }
  882. if (mHasPointParameters)
  883. {
  884. llinfos << "initExtensions() PointParameters-related procs..." << llendl;
  885. glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)GLH_EXT_GET_PROC_ADDRESS("glPointParameterfARB");
  886. glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glPointParameterfvARB");
  887. }
  888. if (mHasShaderObjects)
  889. {
  890. glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteObjectARB");
  891. glGetHandleARB = (PFNGLGETHANDLEARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetHandleARB");
  892. glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDetachObjectARB");
  893. glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glCreateShaderObjectARB");
  894. glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) GLH_EXT_GET_PROC_ADDRESS("glShaderSourceARB");
  895. glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) GLH_EXT_GET_PROC_ADDRESS("glCompileShaderARB");
  896. glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glCreateProgramObjectARB");
  897. glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glAttachObjectARB");
  898. glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glLinkProgramARB");
  899. glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUseProgramObjectARB");
  900. glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glValidateProgramARB");
  901. glUniform1fARB = (PFNGLUNIFORM1FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform1fARB");
  902. glUniform2fARB = (PFNGLUNIFORM2FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform2fARB");
  903. glUniform3fARB = (PFNGLUNIFORM3FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform3fARB");
  904. glUniform4fARB = (PFNGLUNIFORM4FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform4fARB");
  905. glUniform1iARB = (PFNGLUNIFORM1IARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform1iARB");
  906. glUniform2iARB = (PFNGLUNIFORM2IARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform2iARB");
  907. glUniform3iARB = (PFNGLUNIFORM3IARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform3iARB");
  908. glUniform4iARB = (PFNGLUNIFORM4IARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform4iARB");
  909. glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform1fvARB");
  910. glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform2fvARB");
  911. glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform3fvARB");
  912. glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform4fvARB");
  913. glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform1ivARB");
  914. glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform2ivARB");
  915. glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform3ivARB");
  916. glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform4ivARB");
  917. glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniformMatrix2fvARB");
  918. glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniformMatrix3fvARB");
  919. glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniformMatrix4fvARB");
  920. glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetObjectParameterfvARB");
  921. glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetObjectParameterivARB");
  922. glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetInfoLogARB");
  923. glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetAttachedObjectsARB");
  924. glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetUniformLocationARB");
  925. glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetActiveUniformARB");
  926. glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetUniformfvARB");
  927. glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetUniformivARB");
  928. glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetShaderSourceARB");
  929. }
  930. if (mHasVertexShader)
  931. {
  932. llinfos << "initExtensions() VertexShader-related procs..." << llendl;
  933. glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetAttribLocationARB");
  934. glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC) GLH_EXT_GET_PROC_ADDRESS("glBindAttribLocationARB");
  935. glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetActiveAttribARB");
  936. glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1dARB");
  937. glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1dvARB");
  938. glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1fARB");
  939. glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1fvARB");
  940. glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1sARB");
  941. glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1svARB");
  942. glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2dARB");
  943. glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2dvARB");
  944. glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2fARB");
  945. glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2fvARB");
  946. glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2sARB");
  947. glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2svARB");
  948. glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3dARB");
  949. glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3dvARB");
  950. glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3fARB");
  951. glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3fvARB");
  952. glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3sARB");
  953. glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3svARB");
  954. glVertexAttrib4nbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nbvARB");
  955. glVertexAttrib4nivARB = (PFNGLVERTEXATTRIB4NIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nivARB");
  956. glVertexAttrib4nsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nsvARB");
  957. glVertexAttrib4nubARB = (PFNGLVERTEXATTRIB4NUBARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nubARB");
  958. glVertexAttrib4nubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nubvARB");
  959. glVertexAttrib4nuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nuivARB");
  960. glVertexAttrib4nusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nusvARB");
  961. glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4bvARB");
  962. glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4dARB");
  963. glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4dvARB");
  964. glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4fARB");
  965. glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4fvARB");
  966. glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4ivARB");
  967. glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4sARB");
  968. glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4svARB");
  969. glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4ubvARB");
  970. glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4uivARB");
  971. glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4usvARB");
  972. glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttribPointerARB");
  973. glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC) GLH_EXT_GET_PROC_ADDRESS("glEnableVertexAttribArrayARB");
  974. glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDisableVertexAttribArrayARB");
  975. glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramStringARB");
  976. glBindProgramARB = (PFNGLBINDPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glBindProgramARB");
  977. glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteProgramsARB");
  978. glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGenProgramsARB");
  979. glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramEnvParameter4dARB");
  980. glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramEnvParameter4dvARB");
  981. glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramEnvParameter4fARB");
  982. glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramEnvParameter4fvARB");
  983. glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramLocalParameter4dARB");
  984. glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramLocalParameter4dvARB");
  985. glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramLocalParameter4fARB");
  986. glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramLocalParameter4fvARB");
  987. glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramEnvParameterdvARB");
  988. glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramEnvParameterfvARB");
  989. glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramLocalParameterdvARB");
  990. glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramLocalParameterfvARB");
  991. glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramivARB");
  992. glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramStringARB");
  993. glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetVertexAttribdvARB");
  994. glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetVertexAttribfvARB");
  995. glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetVertexAttribivARB");
  996. glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glgetVertexAttribPointervARB");
  997. glIsProgramARB = (PFNGLISPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glIsProgramARB");
  998. }
  999. LL_DEBUGS("RenderInit") << "GL Probe: Got symbols" << LL_ENDL;
  1000. #endif
  1002. mInited = TRUE;
  1003. }
  1005. void rotate_quat(LLQuaternion& rotation)
  1006. {
  1007. F32 angle_radians, x, y, z;
  1008. rotation.getAngleAxis(&angle_radians, &x, &y, &z);
  1009. glRotatef(angle_radians * RAD_TO_DEG, x, y, z);
  1010. }
  1012. void flush_glerror()
  1013. {
  1014. glGetError();
  1015. }
  1017. void assert_glerror()
  1018. {
  1019. if (!gGLActive)
  1020. {
  1021. //llwarns << "GL used while not active!" << llendl;
  1023. if (gDebugSession)
  1024. {
  1025. //ll_fail("GL used while not active");
  1026. }
  1027. }
  1029. if (gNoRender || !gDebugGL) 
  1030. {
  1031. return;
  1032. }
  1034. if (!gGLManager.mInited)
  1035. {
  1036. LL_ERRS("RenderInit") << "GL not initialized" << LL_ENDL;
  1037. }
  1038. //  Create or update texture to be used with this data 
  1039. GLenum error;
  1040. error = glGetError();
  1041. BOOL quit = FALSE;
  1042. while (error)
  1043. {
  1044. quit = TRUE;
  1045. #ifndef LL_LINUX // *FIX: !  This should be an error for linux as well.
  1046. GLubyte const * gl_error_msg = gluErrorString(error);
  1047. if (NULL != gl_error_msg)
  1048. {
  1049. LL_WARNS("RenderState") << "GL Error:" << error<< LL_ENDL;
  1050. LL_WARNS("RenderState") << "GL Error String:" << gl_error_msg << LL_ENDL;
  1052. if (gDebugSession)
  1053. {
  1054. gFailLog << "GL Error:" << gl_error_msg << std::endl;
  1055. }
  1056. }
  1057. else
  1058. {
  1059. // gluErrorString returns NULL for some extensions' error codes.
  1060. // you'll probably have to grep for the number in glext.h.
  1061. LL_WARNS("RenderState") << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << LL_ENDL;
  1063. if (gDebugSession)
  1064. {
  1065. gFailLog << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << std::endl;
  1066. }
  1067. }
  1068. error = glGetError();
  1069. #endif
  1070. }
  1072. if (quit)
  1073. {
  1074. if (gDebugSession)
  1075. {
  1076. ll_fail("assert_glerror failed");
  1077. }
  1078. else
  1079. {
  1080. llerrs << "One or more unhandled GL errors." << llendl;
  1081. }
  1082. }
  1083. }
  1085. void clear_glerror()
  1086. {
  1087. //  Create or update texture to be used with this data 
  1088. GLenum error;
  1089. error = glGetError();
  1090. }
  1092. ///////////////////////////////////////////////////////////////
  1093. //
  1094. // LLGLState
  1095. //
  1097. // Static members
  1098. std::map<LLGLenum, LLGLboolean> LLGLState::sStateMap;
  1100. GLboolean LLGLDepthTest::sDepthEnabled = GL_FALSE; // OpenGL default
  1101. GLenum LLGLDepthTest::sDepthFunc = GL_LESS; // OpenGL default
  1102. GLboolean LLGLDepthTest::sWriteEnabled = GL_TRUE; // OpenGL default
  1104. //static
  1105. void LLGLState::initClass() 
  1106. {
  1107. sStateMap[GL_DITHER] = GL_TRUE;
  1108. // sStateMap[GL_TEXTURE_2D] = GL_TRUE;
  1110. //make sure multisample defaults to disabled
  1111. sStateMap[GL_MULTISAMPLE_ARB] = GL_FALSE;
  1112. glDisable(GL_MULTISAMPLE_ARB);
  1114. sStateMap[GL_MULTISAMPLE_ARB] = GL_FALSE;
  1115. glDisable(GL_MULTISAMPLE_ARB);
  1117. glEnableClientState(GL_VERTEX_ARRAY);
  1118. }
  1120. //static
  1121. void LLGLState::restoreGL()
  1122. {
  1123. sStateMap.clear();
  1124. initClass();
  1125. }
  1127. //static
  1128. // Really shouldn't be needed, but seems we sometimes do.
  1129. void LLGLState::resetTextureStates()
  1130. {
  1131. gGL.flush();
  1132. GLint maxTextureUnits;
  1134. glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
  1135. for (S32 j = maxTextureUnits-1; j >=0; j--)
  1136. {
  1137. gGL.getTexUnit(j)->activate();
  1138. glClientActiveTextureARB(GL_TEXTURE0_ARB+j);
  1139. j == 0 ? gGL.getTexUnit(j)->enable(LLTexUnit::TT_TEXTURE) : gGL.getTexUnit(j)->disable();
  1140. }
  1141. }
  1143. void LLGLState::dumpStates() 
  1144. {
  1145. LL_INFOS("RenderState") << "GL States:" << LL_ENDL;
  1146. for (std::map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
  1147.  iter != sStateMap.end(); ++iter)
  1148. {
  1149. LL_INFOS("RenderState") << llformat(" 0x%04x : %s",(S32)iter->first,iter->second?"TRUE":"FALSE") << LL_ENDL;
  1150. }
  1151. }
  1153. void LLGLState::checkStates(const std::string& msg)  
  1154. {
  1155. if (!gDebugGL)
  1156. {
  1157. return;
  1158. }
  1160. stop_glerror();
  1162. GLint src;
  1163. GLint dst;
  1164. glGetIntegerv(GL_BLEND_SRC, &src);
  1165. glGetIntegerv(GL_BLEND_DST, &dst);
  1167. BOOL error = FALSE;
  1169. if (src != GL_SRC_ALPHA || dst != GL_ONE_MINUS_SRC_ALPHA)
  1170. {
  1171. if (gDebugSession)
  1172. {
  1173. gFailLog << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << "  " << msg << std::dec << std::endl;
  1174. error = TRUE;
  1175. }
  1176. else
  1177. {
  1178. LL_GL_ERRS << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << "  " << msg << std::dec << LL_ENDL;
  1179. }
  1180. }
  1182. for (std::map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
  1183.  iter != sStateMap.end(); ++iter)
  1184. {
  1185. LLGLenum state = iter->first;
  1186. LLGLboolean cur_state = iter->second;
  1187. LLGLboolean gl_state = glIsEnabled(state);
  1188. if(cur_state != gl_state)
  1189. {
  1190. dumpStates();
  1191. if (gDebugSession)
  1192. {
  1193. gFailLog << llformat("LLGLState error. State: 0x%04x",state) << std::endl;
  1194. error = TRUE;
  1195. }
  1196. else
  1197. {
  1198. LL_GL_ERRS << llformat("LLGLState error. State: 0x%04x",state) << LL_ENDL;
  1199. }
  1200. }
  1201. }
  1203. if (error)
  1204. {
  1205. ll_fail("LLGLState::checkStates failed.");
  1206. }
  1207. stop_glerror();
  1208. }
  1210. void LLGLState::checkTextureChannels(const std::string& msg)
  1211. {
  1212. if (!gDebugGL)
  1213. {
  1214. return;
  1215. }
  1217. stop_glerror();
  1219. GLint activeTexture;
  1220. glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &activeTexture);
  1221. stop_glerror();
  1223. BOOL error = FALSE;
  1225. if (activeTexture == GL_TEXTURE0_ARB)
  1226. {
  1227. GLint tex_env_mode = 0;
  1229. glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &tex_env_mode);
  1230. stop_glerror();
  1232. if (tex_env_mode != GL_MODULATE)
  1233. {
  1234. error = TRUE;
  1235. LL_WARNS("RenderState") << "GL_TEXTURE_ENV_MODE invalid: " << std::hex << tex_env_mode << std::dec << LL_ENDL;
  1236. if (gDebugSession)
  1237. {
  1238. gFailLog << "GL_TEXTURE_ENV_MODE invalid: " << std::hex << tex_env_mode << std::dec << std::endl;
  1239. }
  1240. }
  1241. }
  1243. GLint maxTextureUnits = 0;
  1244. glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
  1245. stop_glerror();
  1247. static const char* label[] =
  1248. {
  1249. "GL_TEXTURE_2D",
  1250. "GL_TEXTURE_COORD_ARRAY",
  1251. "GL_TEXTURE_1D",
  1252. "GL_TEXTURE_CUBE_MAP_ARB",
  1253. "GL_TEXTURE_GEN_S",
  1254. "GL_TEXTURE_GEN_T",
  1255. "GL_TEXTURE_GEN_Q",
  1256. "GL_TEXTURE_GEN_R",
  1257. "GL_TEXTURE_RECTANGLE_ARB"
  1258. };
  1260. static GLint value[] =
  1261. {
  1262. GL_TEXTURE_2D,
  1263. GL_TEXTURE_COORD_ARRAY,
  1264. GL_TEXTURE_1D,
  1265. GL_TEXTURE_CUBE_MAP_ARB,
  1266. GL_TEXTURE_GEN_S,
  1267. GL_TEXTURE_GEN_T,
  1268. GL_TEXTURE_GEN_Q,
  1269. GL_TEXTURE_GEN_R,
  1270. GL_TEXTURE_RECTANGLE_ARB
  1271. };
  1273. GLint stackDepth = 0;
  1275. glh::matrix4f mat;
  1276. glh::matrix4f identity;
  1277. identity.identity();
  1279. for (GLint i = 1; i < maxTextureUnits; i++)
  1280. {
  1281. gGL.getTexUnit(i)->activate();
  1282. glClientActiveTextureARB(GL_TEXTURE0_ARB+i);
  1283. stop_glerror();
  1284. glGetIntegerv(GL_TEXTURE_STACK_DEPTH, &stackDepth);
  1285. stop_glerror();
  1287. if (stackDepth != 1)
  1288. {
  1289. error = TRUE;
  1290. LL_WARNS("RenderState") << "Texture matrix stack corrupted." << LL_ENDL;
  1292. if (gDebugSession)
  1293. {
  1294. gFailLog << "Texture matrix stack corrupted." << std::endl;
  1295. }
  1296. }
  1298. glGetFloatv(GL_TEXTURE_MATRIX, (GLfloat*) mat.m);
  1299. stop_glerror();
  1301. if (mat != identity)
  1302. {
  1303. error = TRUE;
  1304. LL_WARNS("RenderState") << "Texture matrix in channel " << i << " corrupt." << LL_ENDL;
  1305. if (gDebugSession)
  1306. {
  1307. gFailLog << "Texture matrix in channel " << i << " corrupt." << std::endl;
  1308. }
  1309. }
  1312. for (S32 j = (i == 0 ? 1 : 0); 
  1313. j < (gGLManager.mHasTextureRectangle ? 9 : 8); j++)
  1314. {
  1315. if (glIsEnabled(value[j]))
  1316. {
  1317. error = TRUE;
  1318. LL_WARNS("RenderState") << "Texture channel " << i << " still has " << label[j] << " enabled." << LL_ENDL;
  1319. if (gDebugSession)
  1320. {
  1321. gFailLog << "Texture channel " << i << " still has " << label[j] << " enabled." << std::endl;
  1322. }
  1323. }
  1324. stop_glerror();
  1325. }
  1327. glGetFloatv(GL_TEXTURE_MATRIX, mat.m);
  1328. stop_glerror();
  1330. if (mat != identity)
  1331. {
  1332. error = TRUE;
  1333. LL_WARNS("RenderState") << "Texture matrix " << i << " is not identity." << LL_ENDL;
  1334. if (gDebugSession)
  1335. {
  1336. gFailLog << "Texture matrix " << i << " is not identity." << std::endl;
  1337. }
  1338. }
  1339. }
  1341. gGL.getTexUnit(0)->activate();
  1342. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  1343. stop_glerror();
  1345. if (error)
  1346. {
  1347. if (gDebugSession)
  1348. {
  1349. ll_fail("LLGLState::checkTextureChannels failed.");
  1350. }
  1351. else
  1352. {
  1353. LL_GL_ERRS << "GL texture state corruption detected.  " << msg << LL_ENDL;
  1354. }
  1355. }
  1356. }
  1358. void LLGLState::checkClientArrays(const std::string& msg, U32 data_mask)
  1359. {
  1360. if (!gDebugGL)
  1361. {
  1362. return;
  1363. }
  1365. stop_glerror();
  1366. BOOL error = FALSE;
  1368. GLint active_texture;
  1369. glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE_ARB, &active_texture);
  1371. if (active_texture != GL_TEXTURE0_ARB)
  1372. {
  1373. llwarns << "Client active texture corrupted: " << active_texture << llendl;
  1374. if (gDebugSession)
  1375. {
  1376. gFailLog << "Client active texture corrupted: " << active_texture << std::endl;
  1377. }
  1378. error = TRUE;
  1379. }
  1381. glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &active_texture);
  1382. if (active_texture != GL_TEXTURE0_ARB)
  1383. {
  1384. llwarns << "Active texture corrupted: " << active_texture << llendl;
  1385. if (gDebugSession)
  1386. {
  1387. gFailLog << "Active texture corrupted: " << active_texture << std::endl;
  1388. }
  1389. error = TRUE;
  1390. }
  1392. static const char* label[] =
  1393. {
  1394. "GL_VERTEX_ARRAY",
  1395. "GL_NORMAL_ARRAY",
  1396. "GL_COLOR_ARRAY",
  1397. "GL_TEXTURE_COORD_ARRAY"
  1398. };
  1400. static GLint value[] =
  1401. {
  1402. GL_VERTEX_ARRAY,
  1403. GL_NORMAL_ARRAY,
  1404. GL_COLOR_ARRAY,
  1405. GL_TEXTURE_COORD_ARRAY
  1406. };
  1408.  U32 mask[] = 
  1409. { //copied from llvertexbuffer.h
  1410. 0x0001, //MAP_VERTEX,
  1411. 0x0002, //MAP_NORMAL,
  1412. 0x0010, //MAP_COLOR,
  1413. 0x0004, //MAP_TEXCOORD
  1414. };
  1417. for (S32 j = 0; j < 4; j++)
  1418. {
  1419. if (glIsEnabled(value[j]))
  1420. {
  1421. if (!(mask[j] & data_mask))
  1422. {
  1423. error = TRUE;
  1424. LL_WARNS("RenderState") << "GL still has " << label[j] << " enabled." << LL_ENDL;
  1425. if (gDebugSession)
  1426. {
  1427. gFailLog << "GL still has " << label[j] << " enabled." << std::endl;
  1428. }
  1429. }
  1430. }
  1431. else
  1432. {
  1433. if (mask[j] & data_mask)
  1434. {
  1435. error = TRUE;
  1436. LL_WARNS("RenderState") << "GL does not have " << label[j] << " enabled." << LL_ENDL;
  1437. if (gDebugSession)
  1438. {
  1439. gFailLog << "GL does not have " << label[j] << " enabled." << std::endl;
  1440. }
  1441. }
  1442. }
  1443. }
  1445. glClientActiveTextureARB(GL_TEXTURE1_ARB);
  1446. gGL.getTexUnit(1)->activate();
  1447. if (glIsEnabled(GL_TEXTURE_COORD_ARRAY))
  1448. {
  1449. if (!(data_mask & 0x0008))
  1450. {
  1451. error = TRUE;
  1452. LL_WARNS("RenderState") << "GL still has GL_TEXTURE_COORD_ARRAY enabled on channel 1." << LL_ENDL;
  1453. if (gDebugSession)
  1454. {
  1455. gFailLog << "GL still has GL_TEXTURE_COORD_ARRAY enabled on channel 1." << std::endl;
  1456. }
  1457. }
  1458. }
  1459. else
  1460. {
  1461. if (data_mask & 0x0008)
  1462. {
  1463. error = TRUE;
  1464. LL_WARNS("RenderState") << "GL does not have GL_TEXTURE_COORD_ARRAY enabled on channel 1." << LL_ENDL;
  1465. if (gDebugSession)
  1466. {
  1467. gFailLog << "GL does not have GL_TEXTURE_COORD_ARRAY enabled on channel 1." << std::endl;
  1468. }
  1469. }
  1470. }
  1472. if (glIsEnabled(GL_TEXTURE_2D))
  1473. {
  1474. if (!(data_mask & 0x0008))
  1475. {
  1476. error = TRUE;
  1477. LL_WARNS("RenderState") << "GL still has GL_TEXTURE_2D enabled on channel 1." << LL_ENDL;
  1478. if (gDebugSession)
  1479. {
  1480. gFailLog << "GL still has GL_TEXTURE_2D enabled on channel 1." << std::endl;
  1481. }
  1482. }
  1483. }
  1484. else
  1485. {
  1486. if (data_mask & 0x0008)
  1487. {
  1488. error = TRUE;
  1489. LL_WARNS("RenderState") << "GL does not have GL_TEXTURE_2D enabled on channel 1." << LL_ENDL;
  1490. if (gDebugSession)
  1491. {
  1492. gFailLog << "GL does not have GL_TEXTURE_2D enabled on channel 1." << std::endl;
  1493. }
  1494. }
  1495. }
  1497. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  1498. gGL.getTexUnit(0)->activate();
  1500. if (gGLManager.mHasVertexShader)
  1501. { //make sure vertex attribs are all disabled
  1502. GLint count;
  1503. glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &count);
  1504. for (GLint i = 0; i < count; i++)
  1505. {
  1506. GLint enabled;
  1507. glGetVertexAttribivARB((GLuint) i, GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, &enabled);
  1508. if (enabled)
  1509. {
  1510. error = TRUE;
  1511. LL_WARNS("RenderState") << "GL still has vertex attrib array " << i << " enabled." << LL_ENDL;
  1512. if (gDebugSession)
  1513. {
  1514. gFailLog <<  "GL still has vertex attrib array " << i << " enabled." << std::endl;
  1515. }
  1516. }
  1517. }
  1518. }
  1520. if (error)
  1521. {
  1522. if (gDebugSession)
  1523. {
  1524. ll_fail("LLGLState::checkClientArrays failed.");
  1525. }
  1526. else
  1527. {
  1528. LL_GL_ERRS << "GL client array corruption detected.  " << msg << LL_ENDL;
  1529. }
  1530. }
  1531. }
  1533. ///////////////////////////////////////////////////////////////////////
  1535. LLGLState::LLGLState(LLGLenum state, S32 enabled) :
  1536. mState(state), mWasEnabled(FALSE), mIsEnabled(FALSE)
  1537. {
  1538. stop_glerror();
  1539. if (state)
  1540. {
  1541. mWasEnabled = sStateMap[state];
  1542. llassert(mWasEnabled == glIsEnabled(state));
  1543. setEnabled(enabled);
  1544. stop_glerror();
  1545. }
  1546. }
  1548. void LLGLState::setEnabled(S32 enabled)
  1549. {
  1550. if (!mState)
  1551. {
  1552. return;
  1553. }
  1554. if (enabled == CURRENT_STATE)
  1555. {
  1556. enabled = sStateMap[mState] == GL_TRUE ? TRUE : FALSE;
  1557. }
  1558. else if (enabled == TRUE && sStateMap[mState] != GL_TRUE)
  1559. {
  1560. gGL.flush();
  1561. glEnable(mState);
  1562. sStateMap[mState] = GL_TRUE;
  1563. }
  1564. else if (enabled == FALSE && sStateMap[mState] != GL_FALSE)
  1565. {
  1566. gGL.flush();
  1567. glDisable(mState);
  1568. sStateMap[mState] = GL_FALSE;
  1569. }
  1570. mIsEnabled = enabled;
  1571. }
  1573. LLGLState::~LLGLState() 
  1574. {
  1575. stop_glerror();
  1576. if (mState)
  1577. {
  1578. if (gDebugGL)
  1579. {
  1580. if (!gDebugSession)
  1581. {
  1582. llassert_always(sStateMap[mState] == glIsEnabled(mState));
  1583. }
  1584. else
  1585. {
  1586. if (sStateMap[mState] != glIsEnabled(mState))
  1587. {
  1588. ll_fail("GL enabled state does not match expected");
  1589. }
  1590. }
  1591. }
  1593. if (mIsEnabled != mWasEnabled)
  1594. {
  1595. gGL.flush();
  1596. if (mWasEnabled)
  1597. {
  1598. glEnable(mState);
  1599. sStateMap[mState] = GL_TRUE;
  1600. }
  1601. else
  1602. {
  1603. glDisable(mState);
  1604. sStateMap[mState] = GL_FALSE;
  1605. }
  1606. }
  1607. }
  1608. stop_glerror();
  1609. }
  1611. ////////////////////////////////////////////////////////////////////////////////
  1613. void LLGLManager::initGLStates()
  1614. {
  1615. //gl states moved to classes in llglstates.h
  1616. LLGLState::initClass();
  1617. }
  1619. ////////////////////////////////////////////////////////////////////////////////
  1621. void enable_vertex_weighting(const S32 index)
  1622. {
  1623. #if GL_ARB_vertex_program
  1624. if (index > 0) glEnableVertexAttribArrayARB(index); // vertex weights
  1625. #endif
  1626. }
  1628. void disable_vertex_weighting(const S32 index)
  1629. {
  1630. #if GL_ARB_vertex_program
  1631. if (index > 0) glDisableVertexAttribArrayARB(index); // vertex weights
  1632. #endif
  1633. }
  1635. void enable_binormals(const S32 index)
  1636. {
  1637. #if GL_ARB_vertex_program
  1638. if (index > 0)
  1639. {
  1640. glEnableVertexAttribArrayARB(index); // binormals
  1641. }
  1642. #endif
  1643. }
  1645. void disable_binormals(const S32 index)
  1646. {
  1647. #if GL_ARB_vertex_program
  1648. if (index > 0)
  1649. {
  1650. glDisableVertexAttribArrayARB(index); // binormals
  1651. }
  1652. #endif
  1653. }
  1656. void enable_cloth_weights(const S32 index)
  1657. {
  1658. #if GL_ARB_vertex_program
  1659. if (index > 0) glEnableVertexAttribArrayARB(index);
  1660. #endif
  1661. }
  1663. void disable_cloth_weights(const S32 index)
  1664. {
  1665. #if GL_ARB_vertex_program
  1666. if (index > 0) glDisableVertexAttribArrayARB(index);
  1667. #endif
  1668. }
  1670. void set_vertex_weights(const S32 index, const U32 stride, const F32 *weights)
  1671. {
  1672. #if GL_ARB_vertex_program
  1673. if (index > 0) glVertexAttribPointerARB(index, 1, GL_FLOAT, FALSE, stride, weights);
  1674. stop_glerror();
  1675. #endif
  1676. }
  1678. void set_vertex_clothing_weights(const S32 index, const U32 stride, const LLVector4 *weights)
  1679. {
  1680. #if GL_ARB_vertex_program
  1681. if (index > 0) glVertexAttribPointerARB(index, 4, GL_FLOAT, TRUE, stride, weights);
  1682. stop_glerror();
  1683. #endif
  1684. }
  1686. void set_binormals(const S32 index, const U32 stride,const LLVector3 *binormals)
  1687. {
  1688. #if GL_ARB_vertex_program
  1689. if (index > 0) glVertexAttribPointerARB(index, 3, GL_FLOAT, FALSE, stride, binormals);
  1690. stop_glerror();
  1691. #endif
  1692. }
  1694. void parse_gl_version( S32* major, S32* minor, S32* release, std::string* vendor_specific )
  1695. {
  1696. // GL_VERSION returns a null-terminated string with the format: 
  1697. // <major>.<minor>[.<release>] [<vendor specific>]
  1699. const char* version = (const char*) glGetString(GL_VERSION);
  1700. *major = 0;
  1701. *minor = 0;
  1702. *release = 0;
  1703. vendor_specific->assign("");
  1705. if( !version )
  1706. {
  1707. return;
  1708. }
  1710. std::string ver_copy( version );
  1711. S32 len = (S32)strlen( version ); /* Flawfinder: ignore */
  1712. S32 i = 0;
  1713. S32 start;
  1714. // Find the major version
  1715. start = i;
  1716. for( ; i < len; i++ )
  1717. {
  1718. if( '.' == version[i] )
  1719. {
  1720. break;
  1721. }
  1722. }
  1723. std::string major_str = ver_copy.substr(start,i-start);
  1724. LLStringUtil::convertToS32(major_str, *major);
  1726. if( '.' == version[i] )
  1727. {
  1728. i++;
  1729. }
  1731. // Find the minor version
  1732. start = i;
  1733. for( ; i < len; i++ )
  1734. {
  1735. if( ('.' == version[i]) || isspace(version[i]) )
  1736. {
  1737. break;
  1738. }
  1739. }
  1740. std::string minor_str = ver_copy.substr(start,i-start);
  1741. LLStringUtil::convertToS32(minor_str, *minor);
  1743. // Find the release number (optional)
  1744. if( '.' == version[i] )
  1745. {
  1746. i++;
  1748. start = i;
  1749. for( ; i < len; i++ )
  1750. {
  1751. if( isspace(version[i]) )
  1752. {
  1753. break;
  1754. }
  1755. }
  1757. std::string release_str = ver_copy.substr(start,i-start);
  1758. LLStringUtil::convertToS32(release_str, *release);
  1759. }
  1761. // Skip over any white space
  1762. while( version[i] && isspace( version[i] ) )
  1763. {
  1764. i++;
  1765. }
  1767. // Copy the vendor-specific string (optional)
  1768. if( version[i] )
  1769. {
  1770. vendor_specific->assign( version + i );
  1771. }
  1772. }
  1774. LLGLUserClipPlane::LLGLUserClipPlane(const LLPlane& p, const glh::matrix4f& modelview, const glh::matrix4f& projection)
  1775. {
  1776. mModelview = modelview;
  1777. mProjection = projection;
  1779. setPlane(p.mV[0], p.mV[1], p.mV[2], p.mV[3]);
  1780. }
  1782. void LLGLUserClipPlane::setPlane(F32 a, F32 b, F32 c, F32 d)
  1783. {
  1784. glh::matrix4f& P = mProjection;
  1785. glh::matrix4f& M = mModelview;
  1786.     
  1787. glh::matrix4f invtrans_MVP = (P * M).inverse().transpose();
  1788.     glh::vec4f oplane(a,b,c,d);
  1789.     glh::vec4f cplane;
  1790.     invtrans_MVP.mult_matrix_vec(oplane, cplane);
  1792.     cplane /= fabs(cplane[2]); // normalize such that depth is not scaled
  1793.     cplane[3] -= 1;
  1795.     if(cplane[2] < 0)
  1796.         cplane *= -1;
  1798.     glh::matrix4f suffix;
  1799.     suffix.set_row(2, cplane);
  1800.     glh::matrix4f newP = suffix * P;
  1801.     glMatrixMode(GL_PROJECTION);
  1802. glPushMatrix();
  1803.     glLoadMatrixf(newP.m);
  1804. gGLObliqueProjectionInverse = LLMatrix4(newP.inverse().transpose().m);
  1805.     glMatrixMode(GL_MODELVIEW);
  1806. }
  1808. LLGLUserClipPlane::~LLGLUserClipPlane()
  1809. {
  1810. glMatrixMode(GL_PROJECTION);
  1811. glPopMatrix();
  1812. glMatrixMode(GL_MODELVIEW);
  1813. }
  1815. LLGLNamePool::LLGLNamePool()
  1816. {
  1817. }
  1819. void LLGLNamePool::registerPool(LLGLNamePool* pool)
  1820. {
  1821. pool_list_t::iterator iter = std::find(sInstances.begin(), sInstances.end(), pool);
  1822. if (iter == sInstances.end())
  1823. {
  1824. sInstances.push_back(pool);
  1825. }
  1826. }
  1828. LLGLNamePool::~LLGLNamePool()
  1829. {
  1830. pool_list_t::iterator iter = std::find(sInstances.begin(), sInstances.end(), this);
  1831. if (iter != sInstances.end())
  1832. {
  1833. sInstances.erase(iter);
  1834. }
  1835. }
  1837. void LLGLNamePool::upkeep()
  1838. {
  1839. std::sort(mNameList.begin(), mNameList.end(), CompareUsed());
  1840. }
  1842. void LLGLNamePool::cleanup()
  1843. {
  1844. for (name_list_t::iterator iter = mNameList.begin(); iter != mNameList.end(); ++iter)
  1845. {
  1846. releaseName(iter->name);
  1847. }
  1849. mNameList.clear();
  1850. }
  1852. GLuint LLGLNamePool::allocate()
  1853. {
  1854. #if LL_GL_NAME_POOLING
  1855. for (name_list_t::iterator iter = mNameList.begin(); iter != mNameList.end(); ++iter)
  1856. {
  1857. if (!iter->used)
  1858. {
  1859. iter->used = TRUE;
  1860. return iter->name;
  1861. }
  1862. }
  1864. NameEntry entry;
  1865. entry.name = allocateName();
  1866. entry.used = TRUE;
  1867. mNameList.push_back(entry);
  1869. return entry.name;
  1870. #else
  1871. return allocateName();
  1872. #endif
  1873. }
  1875. void LLGLNamePool::release(GLuint name)
  1876. {
  1877. #if LL_GL_NAME_POOLING
  1878. for (name_list_t::iterator iter = mNameList.begin(); iter != mNameList.end(); ++iter)
  1879. {
  1880. if (iter->name == name)
  1881. {
  1882. if (iter->used)
  1883. {
  1884. iter->used = FALSE;
  1885. return;
  1886. }
  1887. else
  1888. {
  1889. llerrs << "Attempted to release a pooled name that is not in use!" << llendl;
  1890. }
  1891. }
  1892. }
  1893. llerrs << "Attempted to release a non pooled name!" << llendl;
  1894. #else
  1895. releaseName(name);
  1896. #endif
  1897. }
  1899. //static
  1900. void LLGLNamePool::upkeepPools()
  1901. {
  1902. LLMemType mt(LLMemType::MTYPE_UPKEEP_POOLS);
  1903. for (pool_list_t::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
  1904. {
  1905. LLGLNamePool* pool = *iter;
  1906. pool->upkeep();
  1907. }
  1908. }
  1910. //static
  1911. void LLGLNamePool::cleanupPools()
  1912. {
  1913. for (pool_list_t::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
  1914. {
  1915. LLGLNamePool* pool = *iter;
  1916. pool->cleanup();
  1917. }
  1918. }
  1920. LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, GLenum depth_func)
  1921. : mPrevDepthEnabled(sDepthEnabled), mPrevDepthFunc(sDepthFunc), mPrevWriteEnabled(sWriteEnabled)
  1922. {
  1923. stop_glerror();
  1925. checkState();
  1927. if (!depth_enabled)
  1928. { // always disable depth writes if depth testing is disabled
  1929.   // GL spec defines this as a requirement, but some implementations allow depth writes with testing disabled
  1930.   // The proper way to write to depth buffer with testing disabled is to enable testing and use a depth_func of GL_ALWAYS
  1931. write_enabled = FALSE;
  1932. }
  1934. if (depth_enabled != sDepthEnabled)
  1935. {
  1936. gGL.flush();
  1937. if (depth_enabled) glEnable(GL_DEPTH_TEST);
  1938. else glDisable(GL_DEPTH_TEST);
  1939. sDepthEnabled = depth_enabled;
  1940. }
  1941. if (depth_func != sDepthFunc)
  1942. {
  1943. gGL.flush();
  1944. glDepthFunc(depth_func);
  1945. sDepthFunc = depth_func;
  1946. }
  1947. if (write_enabled != sWriteEnabled)
  1948. {
  1949. gGL.flush();
  1950. glDepthMask(write_enabled);
  1951. sWriteEnabled = write_enabled;
  1952. }
  1953. }
  1955. LLGLDepthTest::~LLGLDepthTest()
  1956. {
  1957. checkState();
  1958. if (sDepthEnabled != mPrevDepthEnabled )
  1959. {
  1960. gGL.flush();
  1961. if (mPrevDepthEnabled) glEnable(GL_DEPTH_TEST);
  1962. else glDisable(GL_DEPTH_TEST);
  1963. sDepthEnabled = mPrevDepthEnabled;
  1964. }
  1965. if (sDepthFunc != mPrevDepthFunc)
  1966. {
  1967. gGL.flush();
  1968. glDepthFunc(mPrevDepthFunc);
  1969. sDepthFunc = mPrevDepthFunc;
  1970. }
  1971. if (sWriteEnabled != mPrevWriteEnabled )
  1972. {
  1973. gGL.flush();
  1974. glDepthMask(mPrevWriteEnabled);
  1975. sWriteEnabled = mPrevWriteEnabled;
  1976. }
  1977. }
  1979. void LLGLDepthTest::checkState()
  1980. {
  1981. if (gDebugGL)
  1982. {
  1983. GLint func = 0;
  1984. GLboolean mask = FALSE;
  1986. glGetIntegerv(GL_DEPTH_FUNC, &func);
  1987. glGetBooleanv(GL_DEPTH_WRITEMASK, &mask);
  1989. if (glIsEnabled(GL_DEPTH_TEST) != sDepthEnabled ||
  1990. sWriteEnabled != mask ||
  1991. sDepthFunc != func)
  1992. {
  1993. if (gDebugSession)
  1994. {
  1995. gFailLog << "Unexpected depth testing state." << std::endl;
  1996. }
  1997. else
  1998. {
  1999. LL_GL_ERRS << "Unexpected depth testing state." << LL_ENDL;
  2000. }
  2001. }
  2002. }
  2003. }
  2005. LLGLClampToFarClip::LLGLClampToFarClip(glh::matrix4f P)
  2006. {
  2007. for (U32 i = 0; i < 4; i++)
  2008. {
  2009. P.element(2, i) = P.element(3, i) * 0.99999f;
  2010. }
  2012. glMatrixMode(GL_PROJECTION);
  2013. glPushMatrix();
  2014. glLoadMatrixf(P.m);
  2015. glMatrixMode(GL_MODELVIEW);
  2016. }
  2018. LLGLClampToFarClip::~LLGLClampToFarClip()
  2019. {
  2020. glMatrixMode(GL_PROJECTION);
  2021. glPopMatrix();
  2022. glMatrixMode(GL_MODELVIEW);
  2023. }