llgl.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:10k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llgl.h
  3.  * @brief LLGL definition
  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.  */
  32. #ifndef LL_LLGL_H
  33. #define LL_LLGL_H
  34. // This file contains various stuff for handling gl extensions and other gl related stuff.
  35. #include <string>
  36. #include <map>
  37. #include <list>
  38. #include "llerror.h"
  39. #include "v4color.h"
  40. #include "llstring.h"
  41. #include "stdtypes.h"
  42. #include "v4math.h"
  43. #include "llplane.h"
  44. #include "llgltypes.h"
  45. #include "llglheaders.h"
  46. #include "glh/glh_linear.h"
  47. extern BOOL gDebugGL;
  48. extern BOOL gDebugSession;
  49. extern std::ofstream gFailLog;
  50. #define LL_GL_ERRS LL_ERRS("RenderState")
  51. void ll_init_fail_log(std::string filename);
  52. void ll_fail(std::string msg);
  53. void ll_close_fail_log();
  54. class LLSD;
  55. // Manage GL extensions...
  56. class LLGLManager
  57. {
  58. public:
  59. LLGLManager();
  60. bool initGL();
  61. void shutdownGL();
  62. void initWGL(); // Initializes stupid WGL extensions
  63. std::string getRawGLString(); // For sending to simulator
  64. BOOL mInited;
  65. BOOL mIsDisabled;
  66. // Extensions used by everyone
  67. BOOL mHasMultitexture;
  68. S32  mNumTextureUnits;
  69. BOOL mHasMipMapGeneration;
  70. BOOL mHasCompressedTextures;
  71. BOOL mHasFramebufferObject;
  72. BOOL mHasFramebufferMultisample;
  73. // ARB Extensions
  74. BOOL mHasVertexBufferObject;
  75. BOOL mHasPBuffer;
  76. BOOL mHasShaderObjects;
  77. BOOL mHasVertexShader;
  78. BOOL mHasFragmentShader;
  79. BOOL mHasOcclusionQuery;
  80. BOOL mHasPointParameters;
  81. BOOL mHasDrawBuffers;
  82. BOOL mHasTextureRectangle;
  83. // Other extensions.
  84. BOOL mHasAnisotropic;
  85. BOOL mHasARBEnvCombine;
  86. BOOL mHasCubeMap;
  87. // Vendor-specific extensions
  88. BOOL mIsATI;
  89. BOOL mIsNVIDIA;
  90. BOOL mIsIntel;
  91. BOOL mIsGF2or4MX;
  92. BOOL mIsGF3;
  93. BOOL mIsGFFX;
  94. BOOL mATIOffsetVerticalLines;
  95. BOOL mATIOldDriver;
  96. // Whether this version of GL is good enough for SL to use
  97. BOOL mHasRequirements;
  98. // Misc extensions
  99. BOOL mHasSeparateSpecularColor;
  100. S32 mDriverVersionMajor;
  101. S32 mDriverVersionMinor;
  102. S32 mDriverVersionRelease;
  103. F32 mGLVersion; // e.g = 1.4
  104. std::string mDriverVersionVendorString;
  105. S32 mVRAM; // VRAM in MB
  106. S32 mGLMaxVertexRange;
  107. S32 mGLMaxIndexRange;
  108. void getPixelFormat(); // Get the best pixel format
  109. std::string getGLInfoString();
  110. void printGLInfoString();
  111. void getGLInfo(LLSD& info);
  112. // In ALL CAPS
  113. std::string mGLVendor;
  114. std::string mGLVendorShort;
  115. // In ALL CAPS
  116. std::string mGLRenderer;
  117. private:
  118. void initExtensions();
  119. void initGLStates();
  120. void initGLImages();
  121. };
  122. extern LLGLManager gGLManager;
  123. class LLQuaternion;
  124. class LLMatrix4;
  125. void rotate_quat(LLQuaternion& rotation);
  126. void flush_glerror(); // Flush GL errors when we know we're handling them correctly.
  127. void assert_glerror();
  128. void clear_glerror();
  129. //#if LL_DEBUG
  130. # define stop_glerror() assert_glerror()
  131. # define llglassertok() assert_glerror()
  132. //#else
  133. //# define stop_glerror()
  134. //# define llglassertok()
  135. //#endif
  136. #define llglassertok_always() assert_glerror()
  137. ////////////////////////
  138. //
  139. // Note: U32's are GLEnum's...
  140. //
  141. // This is a class for GL state management
  142. /*
  143. GL STATE MANAGEMENT DESCRIPTION
  144. LLGLState and its two subclasses, LLGLEnable and LLGLDisable, manage the current 
  145. enable/disable states of the GL to prevent redundant setting of state within a 
  146. render path or the accidental corruption of what state the next path expects.
  147. Essentially, wherever you would call glEnable set a state and then
  148. subsequently reset it by calling glDisable (or vice versa), make an instance of 
  149. LLGLEnable with the state you want to set, and assume it will be restored to its
  150. original state when that instance of LLGLEnable is destroyed.  It is good practice
  151. to exploit stack frame controls for optimal setting/unsetting and readability of 
  152. code.  In llglstates.h, there are a collection of helper classes that define groups
  153. of enables/disables that can cause multiple states to be set with the creation of
  154. one instance.  
  155. Sample usage:
  156. //disable lighting for rendering hud objects
  157. //INCORRECT USAGE
  158. LLGLEnable lighting(GL_LIGHTING);
  159. renderHUD();
  160. LLGLDisable lighting(GL_LIGHTING);
  161. //CORRECT USAGE
  162. {
  163. LLGLEnable lighting(GL_LIGHTING);
  164. renderHUD();
  165. }
  166. If a state is to be set on a conditional, the following mechanism
  167. is useful:
  168. {
  169. LLGLEnable lighting(light_hud ? GL_LIGHTING : 0);
  170. renderHUD();
  171. }
  172. A LLGLState initialized with a parameter of 0 does nothing.
  173. LLGLState works by maintaining a map of the current GL states, and ignoring redundant
  174. enables/disables.  If a redundant call is attempted, it becomes a noop, otherwise,
  175. it is set in the constructor and reset in the destructor.  
  176. For debugging GL state corruption, running with debug enabled will trigger asserts
  177. if the existing GL state does not match the expected GL state.
  178. */
  179. class LLGLState
  180. {
  181. public:
  182. static void initClass();
  183. static void restoreGL();
  184. static void resetTextureStates();
  185. static void dumpStates();
  186. static void checkStates(const std::string& msg = "");
  187. static void checkTextureChannels(const std::string& msg = "");
  188. static void checkClientArrays(const std::string& msg = "", U32 data_mask = 0x0001);
  189. protected:
  190. static std::map<LLGLenum, LLGLboolean> sStateMap;
  191. public:
  192. enum { CURRENT_STATE = -2 };
  193. LLGLState(LLGLenum state, S32 enabled = CURRENT_STATE);
  194. ~LLGLState();
  195. void setEnabled(S32 enabled);
  196. void enable() { setEnabled(TRUE); }
  197. void disable() { setEnabled(FALSE); }
  198. protected:
  199. LLGLenum mState;
  200. BOOL mWasEnabled;
  201. BOOL mIsEnabled;
  202. };
  203. // New LLGLState class wrappers that don't depend on actual GL flags.
  204. class LLGLEnableBlending : public LLGLState
  205. {
  206. public:
  207. LLGLEnableBlending(bool enable);
  208. };
  209. class LLGLEnableAlphaReject : public LLGLState
  210. {
  211. public:
  212. LLGLEnableAlphaReject(bool enable);
  213. };
  214. /// TODO: Being deprecated.
  215. class LLGLEnable : public LLGLState
  216. {
  217. public:
  218. LLGLEnable(LLGLenum state) : LLGLState(state, TRUE) {}
  219. };
  220. /// TODO: Being deprecated.
  221. class LLGLDisable : public LLGLState
  222. {
  223. public:
  224. LLGLDisable(LLGLenum state) : LLGLState(state, FALSE) {}
  225. };
  226. /*
  227.   Store and modify projection matrix to create an oblique
  228.   projection that clips to the specified plane.  Oblique
  229.   projections alter values in the depth buffer, so this
  230.   class should not be used mid-renderpass.  
  231.   Restores projection matrix on destruction.
  232.   GL_MODELVIEW_MATRIX is active whenever program execution
  233.   leaves this class.
  234.   Does not stack.
  235.   Caches inverse of projection matrix used in gGLObliqueProjectionInverse
  236. */
  237. class LLGLUserClipPlane 
  238. {
  239. public:
  240. LLGLUserClipPlane(const LLPlane& plane, const glh::matrix4f& modelview, const glh::matrix4f& projection);
  241. ~LLGLUserClipPlane();
  242. void setPlane(F32 a, F32 b, F32 c, F32 d);
  243. private:
  244. glh::matrix4f mProjection;
  245. glh::matrix4f mModelview;
  246. };
  247. /*
  248.   Modify and load projection matrix to push depth values to far clip plane.
  249.   Restores projection matrix on destruction.
  250.   GL_MODELVIEW_MATRIX is active whenever program execution
  251.   leaves this class.
  252.   Does not stack.
  253. */
  254. class LLGLClampToFarClip
  255. {
  256. public:
  257. LLGLClampToFarClip(glh::matrix4f projection);
  258. ~LLGLClampToFarClip();
  259. };
  260. /*
  261. Generic pooling scheme for things which use GL names (used for occlusion queries and vertex buffer objects).
  262. Prevents thrashing of GL name caches by avoiding calls to glGenFoo and glDeleteFoo.
  263. */
  264. class LLGLNamePool
  265. {
  266. public:
  267. struct NameEntry
  268. {
  269. GLuint name;
  270. BOOL used;
  271. };
  272. struct CompareUsed
  273. {
  274. bool operator()(const NameEntry& lhs, const NameEntry& rhs)
  275. {
  276. return lhs.used < rhs.used;  //FALSE entries first
  277. }
  278. };
  279. typedef std::vector<NameEntry> name_list_t;
  280. name_list_t mNameList;
  281. LLGLNamePool();
  282. virtual ~LLGLNamePool();
  283. void upkeep();
  284. void cleanup();
  285. GLuint allocate();
  286. void release(GLuint name);
  287. static void registerPool(LLGLNamePool* pool);
  288. static void upkeepPools();
  289. static void cleanupPools();
  290. protected:
  291. typedef std::vector<LLGLNamePool*> pool_list_t;
  292. static pool_list_t sInstances;
  293. virtual GLuint allocateName() = 0;
  294. virtual void releaseName(GLuint name) = 0;
  295. };
  296. /*
  297. Interface for objects that need periodic GL updates applied to them.
  298. Used to synchronize GL updates with GL thread.
  299. */
  300. class LLGLUpdate
  301. {
  302. public:
  303. static std::list<LLGLUpdate*> sGLQ;
  304. BOOL mInQ;
  305. LLGLUpdate()
  306. : mInQ(FALSE)
  307. {
  308. }
  309. virtual ~LLGLUpdate()
  310. {
  311. if (mInQ)
  312. {
  313. std::list<LLGLUpdate*>::iterator iter = std::find(sGLQ.begin(), sGLQ.end(), this);
  314. if (iter != sGLQ.end())
  315. {
  316. sGLQ.erase(iter);
  317. }
  318. }
  319. }
  320. virtual void updateGL() = 0;
  321. };
  322. extern LLMatrix4 gGLObliqueProjectionInverse;
  323. #include "llglstates.h"
  324. void init_glstates();
  325. void enable_vertex_weighting(const S32 index);
  326. void disable_vertex_weighting(const S32 index);
  327. void enable_binormals(const S32 index);
  328. void disable_binormals(const S32 index);
  329. void enable_cloth_weights(const S32 index);
  330. void disable_cloth_weights(const S32 index);
  331. void set_vertex_weights(const S32 index, const U32 stride, const F32 *weights);
  332. void set_vertex_clothing_weights(const S32 index, const U32 stride, const LLVector4 *weights);
  333. void set_binormals(const S32 index, const U32 stride, const LLVector3 *binormals);
  334. void parse_gl_version( S32* major, S32* minor, S32* release, std::string* vendor_specific );
  335. extern BOOL gClothRipple;
  336. extern BOOL gNoRender;
  337. extern BOOL gGLActive;
  338. #endif // LL_LLGL_H