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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llrender.h
  3.  * @brief LLRender definition
  4.  *
  5.  * This class acts as a wrapper for OpenGL calls.
  6.  * The goal of this class is to minimize the number of api calls due to legacy rendering
  7.  * code, to define an interface for a multiple rendering API abstraction of the UI
  8.  * rendering, and to abstract out direct rendering calls in a way that is cleaner and easier to maintain.
  9.  *
  10.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  11.  * 
  12.  * Copyright (c) 2001-2010, Linden Research, Inc.
  13.  * 
  14.  * Second Life Viewer Source Code
  15.  * The source code in this file ("Source Code") is provided by Linden Lab
  16.  * to you under the terms of the GNU General Public License, version 2.0
  17.  * ("GPL"), unless you have obtained a separate licensing agreement
  18.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  19.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  20.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  21.  * 
  22.  * There are special exceptions to the terms and conditions of the GPL as
  23.  * it is applied to this Source Code. View the full text of the exception
  24.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  25.  * online at
  26.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  27.  * 
  28.  * By copying, modifying or distributing this software, you acknowledge
  29.  * that you have read and understood your obligations described above,
  30.  * and agree to abide by those obligations.
  31.  * 
  32.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  33.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  34.  * COMPLETENESS OR PERFORMANCE.
  35.  * $/LicenseInfo$
  36.  */
  37. #ifndef LL_LLGLRENDER_H
  38. #define LL_LLGLRENDER_H
  39. //#include "linden_common.h"
  40. #include "v2math.h"
  41. #include "v3math.h"
  42. #include "v4coloru.h"
  43. #include "llstrider.h"
  44. #include "llpointer.h"
  45. #include "llglheaders.h"
  46. class LLVertexBuffer;
  47. class LLCubeMap;
  48. class LLImageGL;
  49. class LLRenderTarget;
  50. class LLTexture ;
  51. class LLTexUnit
  52. {
  53. friend class LLRender;
  54. public:
  55. typedef enum
  56. {
  57. TT_TEXTURE = 0, // Standard 2D Texture
  58. TT_RECT_TEXTURE, // Non power of 2 texture
  59. TT_CUBE_MAP, // 6-sided cube map texture
  60. TT_NONE  // No texture type is currently enabled
  61. } eTextureType;
  62. typedef enum
  63. {
  64. TAM_WRAP = 0, // Standard 2D Texture
  65. TAM_MIRROR, // Non power of 2 texture
  66. TAM_CLAMP  // No texture type is currently enabled
  67. } eTextureAddressMode;
  68. typedef enum
  69. { // Note: If mipmapping or anisotropic are not enabled or supported it should fall back gracefully
  70. TFO_POINT = 0, // Equal to: min=point, mag=point, mip=none.
  71. TFO_BILINEAR, // Equal to: min=linear, mag=linear, mip=point.
  72. TFO_TRILINEAR, // Equal to: min=linear, mag=linear, mip=linear.
  73. TFO_ANISOTROPIC // Equal to: min=anisotropic, max=anisotropic, mip=linear.
  74. } eTextureFilterOptions;
  75. typedef enum 
  76. {
  77. TB_REPLACE = 0,
  78. TB_ADD,
  79. TB_MULT,
  80. TB_MULT_X2,
  81. TB_ALPHA_BLEND,
  82. TB_COMBINE // Doesn't need to be set directly, setTexture___Blend() set TB_COMBINE automatically
  83. } eTextureBlendType;
  84. typedef enum 
  85. {
  86. TBO_REPLACE = 0, // Use Source 1
  87. TBO_MULT, // Multiply: ( Source1 * Source2 )
  88. TBO_MULT_X2, // Multiply then scale by 2:  ( 2.0 * ( Source1 * Source2 ) )
  89. TBO_MULT_X4, // Multiply then scale by 4:  ( 4.0 * ( Source1 * Source2 ) )
  90. TBO_ADD, // Add: ( Source1 + Source2 )
  91. TBO_ADD_SIGNED, // Add then subtract 0.5: ( ( Source1 + Source2 ) - 0.5 )
  92. TBO_SUBTRACT, // Subtract Source2 from Source1: ( Source1 - Source2 )
  93. TBO_LERP_VERT_ALPHA, // Interpolate based on Vertex Alpha (VA): ( Source1 * VA + Source2 * (1-VA) )
  94. TBO_LERP_TEX_ALPHA, // Interpolate based on Texture Alpha (TA): ( Source1 * TA + Source2 * (1-TA) )
  95. TBO_LERP_PREV_ALPHA, // Interpolate based on Previous Alpha (PA): ( Source1 * PA + Source2 * (1-PA) )
  96. TBO_LERP_CONST_ALPHA, // Interpolate based on Const Alpha (CA): ( Source1 * CA + Source2 * (1-CA) )
  97. TBO_LERP_VERT_COLOR // Interpolate based on Vertex Col (VC): ( Source1 * VC + Source2 * (1-VC) )
  98. // *Note* TBO_LERP_VERTEX_COLOR only works with setTextureColorBlend(),
  99. // and falls back to TBO_LERP_VERTEX_ALPHA for setTextureAlphaBlend().
  100. } eTextureBlendOp;
  101. typedef enum 
  102. {
  103. TBS_PREV_COLOR = 0, // Color from the previous texture stage
  104. TBS_PREV_ALPHA,
  105. TBS_ONE_MINUS_PREV_COLOR,
  106. TBS_ONE_MINUS_PREV_ALPHA,
  107. TBS_TEX_COLOR, // Color from the texture bound to this stage
  108. TBS_TEX_ALPHA,
  109. TBS_ONE_MINUS_TEX_COLOR,
  110. TBS_ONE_MINUS_TEX_ALPHA,
  111. TBS_VERT_COLOR, // The vertex color currently set
  112. TBS_VERT_ALPHA,
  113. TBS_ONE_MINUS_VERT_COLOR,
  114. TBS_ONE_MINUS_VERT_ALPHA,
  115. TBS_CONST_COLOR, // The constant color value currently set
  116. TBS_CONST_ALPHA,
  117. TBS_ONE_MINUS_CONST_COLOR,
  118. TBS_ONE_MINUS_CONST_ALPHA
  119. } eTextureBlendSrc;
  120. LLTexUnit(S32 index);
  121. // Refreshes renderer state of the texture unit to the cached values
  122. // Needed when the render context has changed and invalidated the current state
  123. void refreshState(void);
  124. // returns the index of this texture unit
  125. S32 getIndex(void) const { return mIndex; }
  126. // Sets this tex unit to be the currently active one
  127. void activate(void); 
  128. // Enables this texture unit for the given texture type 
  129. // (automatically disables any previously enabled texture type)
  130. void enable(eTextureType type); 
  131. // Disables the current texture unit
  132. void disable(void);
  133. // Binds the LLImageGL to this texture unit 
  134. // (automatically enables the unit for the LLImageGL's texture type)
  135. bool bind(LLImageGL* texture, bool for_rendering = false, bool forceBind = false);
  136. bool bind(LLTexture* texture, bool for_rendering = false, bool forceBind = false);
  137. // Binds a cubemap to this texture unit 
  138. // (automatically enables the texture unit for cubemaps)
  139. bool bind(LLCubeMap* cubeMap);
  140. // Binds a render target to this texture unit 
  141. // (automatically enables the texture unit for the RT's texture type)
  142. bool bind(LLRenderTarget * renderTarget, bool bindDepth = false);
  143. // Manually binds a texture to the texture unit 
  144. // (automatically enables the tex unit for the given texture type)
  145. bool bindManual(eTextureType type, U32 texture, bool hasMips = false);
  146. // Unbinds the currently bound texture of the given type 
  147. // (only if there's a texture of the given type currently bound)
  148. void unbind(eTextureType type);
  149. // Sets the addressing mode used to sample the texture
  150. // Warning: this stays set for the bound texture forever, 
  151. // make sure you want to permanently change the address mode  for the bound texture.
  152. void setTextureAddressMode(eTextureAddressMode mode);
  153. // Sets the filtering options used to sample the texture
  154. // Warning: this stays set for the bound texture forever, 
  155. // make sure you want to permanently change the filtering for the bound texture.
  156. void setTextureFilteringOption(LLTexUnit::eTextureFilterOptions option);
  157. void setTextureBlendType(eTextureBlendType type);
  158. inline void setTextureColorBlend(eTextureBlendOp op, eTextureBlendSrc src1, eTextureBlendSrc src2 = TBS_PREV_COLOR)
  159. { setTextureCombiner(op, src1, src2, false); }
  160. // NOTE: If *_COLOR enums are passed to src1 or src2, the corresponding *_ALPHA enum will be used instead.
  161. inline void setTextureAlphaBlend(eTextureBlendOp op, eTextureBlendSrc src1, eTextureBlendSrc src2 = TBS_PREV_ALPHA)
  162. { setTextureCombiner(op, src1, src2, true); }
  163. static U32 getInternalType(eTextureType type);
  164. U32 getCurrTexture(void) { return mCurrTexture; }
  165. eTextureType getCurrType(void) { return mCurrTexType; }
  166. void setHasMipMaps(bool hasMips) { mHasMipMaps = hasMips; }
  167. protected:
  168. S32 mIndex;
  169. U32 mCurrTexture;
  170. eTextureType mCurrTexType;
  171. eTextureBlendType mCurrBlendType;
  172. eTextureBlendOp mCurrColorOp;
  173. eTextureBlendSrc mCurrColorSrc1;
  174. eTextureBlendSrc mCurrColorSrc2;
  175. eTextureBlendOp mCurrAlphaOp;
  176. eTextureBlendSrc mCurrAlphaSrc1;
  177. eTextureBlendSrc mCurrAlphaSrc2;
  178. S32 mCurrColorScale;
  179. S32 mCurrAlphaScale;
  180. bool mHasMipMaps;
  181. void debugTextureUnit(void);
  182. void setColorScale(S32 scale);
  183. void setAlphaScale(S32 scale);
  184. GLint getTextureSource(eTextureBlendSrc src);
  185. GLint getTextureSourceType(eTextureBlendSrc src, bool isAlpha = false);
  186. void setTextureCombiner(eTextureBlendOp op, eTextureBlendSrc src1, eTextureBlendSrc src2, bool isAlpha = false);
  187. };
  188. class LLRender
  189. {
  190. friend class LLTexUnit;
  191. public:
  192. typedef enum {
  193. TRIANGLES = 0,
  194. TRIANGLE_STRIP,
  195. TRIANGLE_FAN,
  196. POINTS,
  197. LINES,
  198. LINE_STRIP,
  199. QUADS,
  200. LINE_LOOP,
  201. NUM_MODES
  202. } eGeomModes;
  203. typedef enum 
  204. {
  205. CF_NEVER = 0,
  206. CF_ALWAYS,
  207. CF_LESS,
  208. CF_LESS_EQUAL,
  209. CF_EQUAL,
  210. CF_NOT_EQUAL,
  211. CF_GREATER_EQUAL,
  212. CF_GREATER,
  213. CF_DEFAULT
  214. }  eCompareFunc;
  215. typedef enum 
  216. {
  217. BT_ALPHA = 0,
  218. BT_ADD,
  219. BT_ADD_WITH_ALPHA, // Additive blend modulated by the fragment's alpha.
  220. BT_MULT,
  221. BT_MULT_ALPHA,
  222. BT_MULT_X2,
  223. BT_REPLACE
  224. } eBlendType;
  225. typedef enum 
  226. {
  227. BF_ONE = 0,
  228. BF_ZERO,
  229. BF_DEST_COLOR,
  230. BF_SOURCE_COLOR,
  231. BF_ONE_MINUS_DEST_COLOR,
  232. BF_ONE_MINUS_SOURCE_COLOR,
  233. BF_DEST_ALPHA,
  234. BF_SOURCE_ALPHA,
  235. BF_ONE_MINUS_DEST_ALPHA,
  236. BF_ONE_MINUS_SOURCE_ALPHA
  237. } eBlendFactor;
  238. LLRender();
  239. ~LLRender();
  240. void shutdown();
  241. // Refreshes renderer state to the cached values
  242. // Needed when the render context has changed and invalidated the current state
  243. void refreshState(void);
  244. void translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z);
  245. void scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z);
  246. void pushMatrix();
  247. void popMatrix();
  248. void flush();
  249. void begin(const GLuint& mode);
  250. void end();
  251. void vertex2i(const GLint& x, const GLint& y);
  252. void vertex2f(const GLfloat& x, const GLfloat& y);
  253. void vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z);
  254. void vertex2fv(const GLfloat* v);
  255. void vertex3fv(const GLfloat* v);
  256. void texCoord2i(const GLint& x, const GLint& y);
  257. void texCoord2f(const GLfloat& x, const GLfloat& y);
  258. void texCoord2fv(const GLfloat* tc);
  259. void color4ub(const GLubyte& r, const GLubyte& g, const GLubyte& b, const GLubyte& a);
  260. void color4f(const GLfloat& r, const GLfloat& g, const GLfloat& b, const GLfloat& a);
  261. void color4fv(const GLfloat* c);
  262. void color3f(const GLfloat& r, const GLfloat& g, const GLfloat& b);
  263. void color3fv(const GLfloat* c);
  264. void color4ubv(const GLubyte* c);
  265. void setColorMask(bool writeColor, bool writeAlpha);
  266. void setColorMask(bool writeColorR, bool writeColorG, bool writeColorB, bool writeAlpha);
  267. void setSceneBlendType(eBlendType type);
  268. void setAlphaRejectSettings(eCompareFunc func, F32 value = 0.01f);
  269. void blendFunc(eBlendFactor sfactor, eBlendFactor dfactor);
  270. LLTexUnit* getTexUnit(U32 index);
  271. U32 getCurrentTexUnitIndex(void) const { return mCurrTextureUnitIndex; }
  272. bool verifyTexUnitActive(U32 unitToVerify);
  273. void debugTexUnits(void);
  274. void clearErrors();
  275. struct Vertex
  276. {
  277. GLfloat v[3];
  278. GLubyte c[4];
  279. GLfloat uv[2];
  280. };
  281. public:
  282. private:
  283. bool mDirty;
  284. U32 mCount;
  285. U32 mMode;
  286. U32 mCurrTextureUnitIndex;
  287. bool mCurrColorMask[4];
  288. eCompareFunc mCurrAlphaFunc;
  289. F32 mCurrAlphaFuncVal;
  290. LLPointer<LLVertexBuffer> mBuffer;
  291. LLStrider<LLVector3> mVerticesp;
  292. LLStrider<LLVector2> mTexcoordsp;
  293. LLStrider<LLColor4U> mColorsp;
  294. std::vector<LLTexUnit*> mTexUnits;
  295. LLTexUnit* mDummyTexUnit;
  296. F32 mMaxAnisotropy;
  297. };
  298. extern F64 gGLModelView[16];
  299. extern F64 gGLLastModelView[16];
  300. extern F64 gGLLastProjection[16];
  301. extern F64 gGLProjection[16];
  302. extern S32 gGLViewport[4];
  303. extern LLRender gGL;
  304. #endif