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

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

游戏引擎

开发平台：

C++ Builder

llrender.cpp：源码内容
  1. /** 
  2.  * @file llrender.cpp
  3.  * @brief LLRender 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. #include "linden_common.h"
  35. #include "llrender.h"
  37. #include "llvertexbuffer.h"
  38. #include "llcubemap.h"
  39. #include "llimagegl.h"
  40. #include "llrendertarget.h"
  41. #include "lltexture.h"
  43. LLRender gGL;
  45. // Handy copies of last good GL matrices
  46. F64 gGLModelView[16];
  47. F64 gGLLastModelView[16];
  48. F64 gGLLastProjection[16];
  49. F64 gGLProjection[16];
  50. S32 gGLViewport[4];
  52. static const U32 LL_NUM_TEXTURE_LAYERS = 16; 
  54. static GLenum sGLTextureType[] =
  55. {
  56. GL_TEXTURE_2D,
  57. GL_TEXTURE_RECTANGLE_ARB,
  58. GL_TEXTURE_CUBE_MAP_ARB
  59. };
  61. static GLint sGLAddressMode[] =
  62. {
  63. GL_REPEAT,
  64. GL_MIRRORED_REPEAT,
  65. GL_CLAMP_TO_EDGE
  66. };
  68. static GLenum sGLCompareFunc[] =
  69. {
  70. GL_NEVER,
  71. GL_ALWAYS,
  72. GL_LESS,
  73. GL_LEQUAL,
  74. GL_EQUAL,
  75. GL_NOTEQUAL,
  76. GL_GEQUAL,
  77. GL_GREATER
  78. };
  80. const U32 immediate_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXCOORD0;
  82. static GLenum sGLBlendFactor[] =
  83. {
  84. GL_ONE,
  85. GL_ZERO,
  86. GL_DST_COLOR,
  87. GL_SRC_COLOR,
  88. GL_ONE_MINUS_DST_COLOR,
  89. GL_ONE_MINUS_SRC_COLOR,
  90. GL_DST_ALPHA,
  91. GL_SRC_ALPHA,
  92. GL_ONE_MINUS_DST_ALPHA,
  93. GL_ONE_MINUS_SRC_ALPHA
  94. };
  96. LLTexUnit::LLTexUnit(S32 index)
  97. : mCurrTexType(TT_NONE), mCurrBlendType(TB_MULT), 
  98. mCurrColorOp(TBO_MULT), mCurrAlphaOp(TBO_MULT),
  99. mCurrColorSrc1(TBS_TEX_COLOR), mCurrColorSrc2(TBS_PREV_COLOR),
  100. mCurrAlphaSrc1(TBS_TEX_ALPHA), mCurrAlphaSrc2(TBS_PREV_ALPHA),
  101. mCurrColorScale(1), mCurrAlphaScale(1), mCurrTexture(0),
  102. mHasMipMaps(false)
  103. {
  104. llassert_always(index < (S32)LL_NUM_TEXTURE_LAYERS);
  105. mIndex = index;
  106. }
  108. //static
  109. U32 LLTexUnit::getInternalType(eTextureType type)
  110. {
  111. return sGLTextureType[type];
  112. }
  114. void LLTexUnit::refreshState(void)
  115. {
  116. // We set dirty to true so that the tex unit knows to ignore caching
  117. // and we reset the cached tex unit state
  119. glActiveTextureARB(GL_TEXTURE0_ARB + mIndex);
  120. if (mCurrTexType != TT_NONE)
  121. {
  122. glEnable(sGLTextureType[mCurrTexType]);
  123. glBindTexture(sGLTextureType[mCurrTexType], mCurrTexture);
  124. }
  125. else
  126. {
  127. glDisable(GL_TEXTURE_2D);
  128. glBindTexture(GL_TEXTURE_2D, 0);
  129. }
  131. if (mCurrBlendType != TB_COMBINE)
  132. {
  133. setTextureBlendType(mCurrBlendType);
  134. }
  135. else
  136. {
  137. setTextureCombiner(mCurrColorOp, mCurrColorSrc1, mCurrColorSrc2, false);
  138. setTextureCombiner(mCurrAlphaOp, mCurrAlphaSrc1, mCurrAlphaSrc2, true);
  139. }
  140. }
  142. void LLTexUnit::activate(void)
  143. {
  144. if (mIndex < 0) return;
  146. if ((S32)gGL.mCurrTextureUnitIndex != mIndex || gGL.mDirty)
  147. {
  148. glActiveTextureARB(GL_TEXTURE0_ARB + mIndex);
  149. gGL.mCurrTextureUnitIndex = mIndex;
  150. }
  151. }
  153. void LLTexUnit::enable(eTextureType type)
  154. {
  155. if (mIndex < 0) return;
  157. if ( (mCurrTexType != type || gGL.mDirty) && (type != TT_NONE) )
  158. {
  159. activate();
  160. if (mCurrTexType != TT_NONE && !gGL.mDirty)
  161. {
  162. disable(); // Force a disable of a previous texture type if it's enabled.
  163. }
  164. mCurrTexType = type;
  166. gGL.flush();
  167. glEnable(sGLTextureType[type]);
  168. }
  169. }
  171. void LLTexUnit::disable(void)
  172. {
  173. if (mIndex < 0) return;
  175. if (mCurrTexType != TT_NONE)
  176. {
  177. activate();
  178. unbind(mCurrTexType);
  179. glDisable(sGLTextureType[mCurrTexType]);
  180. mCurrTexType = TT_NONE;
  181. }
  182. }
  184. bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
  185. {
  186. stop_glerror();
  187. if (mIndex < 0) return false;
  189. gGL.flush();
  191. LLImageGL* gl_tex = NULL ;
  192. if (texture == NULL || !(gl_tex = texture->getGLTexture()))
  193. {
  194. llwarns << "NULL LLTexUnit::bind texture" << llendl;
  195. return false;
  196. }
  198. if (!gl_tex->getTexName()) //if texture does not exist
  199. {
  200. //if deleted, will re-generate it immediately
  201. texture->forceImmediateUpdate() ;
  203. gl_tex->forceUpdateBindStats() ;
  204. return texture->bindDefaultImage(mIndex);
  205. }
  207. //in audit, replace the selected texture by the default one.
  208. if(gAuditTexture && for_rendering && LLImageGL::sCurTexPickSize > 0)
  209. {
  210. if(texture->getWidth() * texture->getHeight() == LLImageGL::sCurTexPickSize)
  211. {
  212. gl_tex->updateBindStats(gl_tex->mTextureMemory);
  213. return bind(LLImageGL::sHighlightTexturep.get());
  214. }
  215. }
  216. if ((mCurrTexture != gl_tex->getTexName()) || forceBind)
  217. {
  218. activate();
  219. enable(gl_tex->getTarget());
  220. mCurrTexture = gl_tex->getTexName();
  221. glBindTexture(sGLTextureType[gl_tex->getTarget()], mCurrTexture);
  222. if(gl_tex->updateBindStats(gl_tex->mTextureMemory))
  223. {
  224. texture->setActive() ;
  225. texture->updateBindStatsForTester() ;
  226. }
  227. mHasMipMaps = gl_tex->mHasMipMaps;
  228. if (gl_tex->mTexOptionsDirty)
  229. {
  230. gl_tex->mTexOptionsDirty = false;
  231. setTextureAddressMode(gl_tex->mAddressMode);
  232. setTextureFilteringOption(gl_tex->mFilterOption);
  233. }
  234. }
  235. return true;
  236. }
  238. bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind)
  239. {
  240. stop_glerror();
  241. if (mIndex < 0) return false;
  243. if(!texture)
  244. {
  245. llwarns << "NULL LLTexUnit::bind texture" << llendl;
  246. return false;
  247. }
  249. if(!texture->getTexName())
  250. {
  251. if(LLImageGL::sDefaultGLTexture && LLImageGL::sDefaultGLTexture->getTexName())
  252. {
  253. return bind(LLImageGL::sDefaultGLTexture) ;
  254. }
  255. return false ;
  256. }
  258. gGL.flush();
  260. if ((mCurrTexture != texture->getTexName()) || forceBind)
  261. {
  262. activate();
  263. enable(texture->getTarget());
  264. mCurrTexture = texture->getTexName();
  265. glBindTexture(sGLTextureType[texture->getTarget()], mCurrTexture);
  266. texture->updateBindStats(texture->mTextureMemory);
  267. mHasMipMaps = texture->mHasMipMaps;
  268. if (texture->mTexOptionsDirty)
  269. {
  270. texture->mTexOptionsDirty = false;
  271. setTextureAddressMode(texture->mAddressMode);
  272. setTextureFilteringOption(texture->mFilterOption);
  273. }
  274. }
  276. return true;
  277. }
  279. bool LLTexUnit::bind(LLCubeMap* cubeMap)
  280. {
  281. if (mIndex < 0) return false;
  283. gGL.flush();
  285. if (cubeMap == NULL)
  286. {
  287. llwarns << "NULL LLTexUnit::bind cubemap" << llendl;
  288. return false;
  289. }
  291. if (mCurrTexture != cubeMap->mImages[0]->getTexName())
  292. {
  293. if (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps)
  294. {
  295. activate();
  296. enable(LLTexUnit::TT_CUBE_MAP);
  297. mCurrTexture = cubeMap->mImages[0]->getTexName();
  298. glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, mCurrTexture);
  299. mHasMipMaps = cubeMap->mImages[0]->mHasMipMaps;
  300. cubeMap->mImages[0]->updateBindStats(cubeMap->mImages[0]->mTextureMemory);
  301. if (cubeMap->mImages[0]->mTexOptionsDirty)
  302. {
  303. cubeMap->mImages[0]->mTexOptionsDirty = false;
  304. setTextureAddressMode(cubeMap->mImages[0]->mAddressMode);
  305. setTextureFilteringOption(cubeMap->mImages[0]->mFilterOption);
  306. }
  307. return true;
  308. }
  309. else
  310. {
  311. llwarns << "Using cube map without extension!" << llendl;
  312. return false;
  313. }
  314. }
  315. return true;
  316. }
  318. // LLRenderTarget is unavailible on the mapserver since it uses FBOs.
  319. #if !LL_MESA_HEADLESS
  320. bool LLTexUnit::bind(LLRenderTarget* renderTarget, bool bindDepth)
  321. {
  322. if (mIndex < 0) return false;
  324. gGL.flush();
  326. if (bindDepth)
  327. {
  328. if (renderTarget->hasStencil())
  329. {
  330. llerrs << "Cannot bind a render buffer for sampling.  Allocate render target without a stencil buffer if sampling of depth buffer is required." << llendl;
  331. }
  333. bindManual(renderTarget->getUsage(), renderTarget->getDepth());
  334. }
  335. else
  336. {
  337. bindManual(renderTarget->getUsage(), renderTarget->getTexture());
  338. }
  340. return true;
  341. }
  342. #endif // LL_MESA_HEADLESS
  344. bool LLTexUnit::bindManual(eTextureType type, U32 texture, bool hasMips)
  345. {
  346. if (mIndex < 0)  
  347. {
  348. return false;
  349. }
  351. if(mCurrTexture != texture)
  352. {
  353. gGL.flush();
  355. activate();
  356. enable(type);
  357. mCurrTexture = texture;
  358. glBindTexture(sGLTextureType[type], texture);
  359. mHasMipMaps = hasMips;
  360. }
  361. return true;
  362. }
  364. void LLTexUnit::unbind(eTextureType type)
  365. {
  366. stop_glerror();
  368. if (mIndex < 0) return;
  370. // Disabled caching of binding state.
  371. if (mCurrTexType == type)
  372. {
  373. gGL.flush();
  375. activate();
  376. mCurrTexture = 0;
  377. glBindTexture(sGLTextureType[type], 0);
  378. }
  379. }
  381. void LLTexUnit::setTextureAddressMode(eTextureAddressMode mode)
  382. {
  383. if (mIndex < 0 || mCurrTexture == 0) return;
  385. activate();
  387. glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_S, sGLAddressMode[mode]);
  388. glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_T, sGLAddressMode[mode]);
  389. if (mCurrTexType == TT_CUBE_MAP)
  390. {
  391. glTexParameteri (GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, sGLAddressMode[mode]);
  392. }
  393. }
  395. void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions option)
  396. {
  397. if (mIndex < 0 || mCurrTexture == 0) return;
  399. if (option == TFO_POINT)
  400. {
  401. glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  402. }
  403. else
  404. {
  405. glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  406. }
  408. if (option >= TFO_TRILINEAR && mHasMipMaps)
  409. {
  410. glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  411. } 
  412. else if (option >= TFO_BILINEAR)
  413. {
  414. glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  415. }
  416. else
  417. {
  418. glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  419. }
  421. if (gGLManager.mHasAnisotropic)
  422. {
  423. if (LLImageGL::sGlobalUseAnisotropic && option == TFO_ANISOTROPIC)
  424. {
  425. if (gGL.mMaxAnisotropy < 1.f)
  426. {
  427. glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gGL.mMaxAnisotropy);
  428. }
  429. glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY_EXT, gGL.mMaxAnisotropy);
  430. }
  431. else
  432. {
  433. glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.f);
  434. }
  435. }
  436. }
  438. void LLTexUnit::setTextureBlendType(eTextureBlendType type)
  439. {
  440. if (mIndex < 0) return;
  442. // Do nothing if it's already correctly set.
  443. if (mCurrBlendType == type && !gGL.mDirty)
  444. {
  445. return;
  446. }
  448. activate();
  449. mCurrBlendType = type;
  450. S32 scale_amount = 1;
  451. switch (type) 
  452. {
  453. case TB_REPLACE:
  454. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  455. break;
  456. case TB_ADD:
  457. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
  458. break;
  459. case TB_MULT:
  460. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  461. break;
  462. case TB_MULT_X2:
  463. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  464. scale_amount = 2;
  465. break;
  466. case TB_ALPHA_BLEND:
  467. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  468. break;
  469. case TB_COMBINE:
  470. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
  471. break;
  472. default:
  473. llerrs << "Unknown Texture Blend Type: " << type << llendl;
  474. break;
  475. }
  476. setColorScale(scale_amount);
  477. setAlphaScale(1);
  478. }
  480. GLint LLTexUnit::getTextureSource(eTextureBlendSrc src)
  481. {
  482. switch(src)
  483. {
  484. // All four cases should return the same value.
  485. case TBS_PREV_COLOR:
  486. case TBS_PREV_ALPHA:
  487. case TBS_ONE_MINUS_PREV_COLOR:
  488. case TBS_ONE_MINUS_PREV_ALPHA:
  489. return GL_PREVIOUS_ARB;
  491. // All four cases should return the same value.
  492. case TBS_TEX_COLOR:
  493. case TBS_TEX_ALPHA:
  494. case TBS_ONE_MINUS_TEX_COLOR:
  495. case TBS_ONE_MINUS_TEX_ALPHA:
  496. return GL_TEXTURE;
  498. // All four cases should return the same value.
  499. case TBS_VERT_COLOR:
  500. case TBS_VERT_ALPHA:
  501. case TBS_ONE_MINUS_VERT_COLOR:
  502. case TBS_ONE_MINUS_VERT_ALPHA:
  503. return GL_PRIMARY_COLOR_ARB;
  505. // All four cases should return the same value.
  506. case TBS_CONST_COLOR:
  507. case TBS_CONST_ALPHA:
  508. case TBS_ONE_MINUS_CONST_COLOR:
  509. case TBS_ONE_MINUS_CONST_ALPHA:
  510. return GL_CONSTANT_ARB;
  512. default:
  513. llwarns << "Unknown eTextureBlendSrc: " << src << ".  Using Vertex Color instead." << llendl;
  514. return GL_PRIMARY_COLOR_ARB;
  515. }
  516. }
  518. GLint LLTexUnit::getTextureSourceType(eTextureBlendSrc src, bool isAlpha)
  519. {
  520. switch(src)
  521. {
  522. // All four cases should return the same value.
  523. case TBS_PREV_COLOR:
  524. case TBS_TEX_COLOR:
  525. case TBS_VERT_COLOR:
  526. case TBS_CONST_COLOR:
  527. return (isAlpha) ? GL_SRC_ALPHA: GL_SRC_COLOR;
  529. // All four cases should return the same value.
  530. case TBS_PREV_ALPHA:
  531. case TBS_TEX_ALPHA:
  532. case TBS_VERT_ALPHA:
  533. case TBS_CONST_ALPHA:
  534. return GL_SRC_ALPHA;
  536. // All four cases should return the same value.
  537. case TBS_ONE_MINUS_PREV_COLOR:
  538. case TBS_ONE_MINUS_TEX_COLOR:
  539. case TBS_ONE_MINUS_VERT_COLOR:
  540. case TBS_ONE_MINUS_CONST_COLOR:
  541. return (isAlpha) ? GL_ONE_MINUS_SRC_ALPHA : GL_ONE_MINUS_SRC_COLOR;
  543. // All four cases should return the same value.
  544. case TBS_ONE_MINUS_PREV_ALPHA:
  545. case TBS_ONE_MINUS_TEX_ALPHA:
  546. case TBS_ONE_MINUS_VERT_ALPHA:
  547. case TBS_ONE_MINUS_CONST_ALPHA:
  548. return GL_ONE_MINUS_SRC_ALPHA;
  550. default:
  551. llwarns << "Unknown eTextureBlendSrc: " << src << ".  Using Source Color or Alpha instead." << llendl;
  552. return (isAlpha) ? GL_SRC_ALPHA: GL_SRC_COLOR;
  553. }
  554. }
  556. void LLTexUnit::setTextureCombiner(eTextureBlendOp op, eTextureBlendSrc src1, eTextureBlendSrc src2, bool isAlpha)
  557. {
  558. if (mIndex < 0) return;
  560. activate();
  561. if (mCurrBlendType != TB_COMBINE || gGL.mDirty)
  562. {
  563. mCurrBlendType = TB_COMBINE;
  564. glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
  565. }
  567. // We want an early out, because this function does a LOT of stuff.
  568. if ( ( (isAlpha && (mCurrAlphaOp == op) && (mCurrAlphaSrc1 == src1) && (mCurrAlphaSrc2 == src2))
  569. || (!isAlpha && (mCurrColorOp == op) && (mCurrColorSrc1 == src1) && (mCurrColorSrc2 == src2)) ) && !gGL.mDirty)
  570. {
  571. return;
  572. }
  574. // Get the gl source enums according to the eTextureBlendSrc sources passed in
  575. GLint source1 = getTextureSource(src1);
  576. GLint source2 = getTextureSource(src2);
  577. // Get the gl operand enums according to the eTextureBlendSrc sources passed in
  578. GLint operand1 = getTextureSourceType(src1, isAlpha);
  579. GLint operand2 = getTextureSourceType(src2, isAlpha);
  580. // Default the scale amount to 1
  581. S32 scale_amount = 1;
  582. GLenum comb_enum, src0_enum, src1_enum, src2_enum, operand0_enum, operand1_enum, operand2_enum;
  584. if (isAlpha)
  585. {
  586. // Set enums to ALPHA ones
  587. comb_enum = GL_COMBINE_ALPHA_ARB;
  588. src0_enum = GL_SOURCE0_ALPHA_ARB;
  589. src1_enum = GL_SOURCE1_ALPHA_ARB;
  590. src2_enum = GL_SOURCE2_ALPHA_ARB;
  591. operand0_enum = GL_OPERAND0_ALPHA_ARB;
  592. operand1_enum = GL_OPERAND1_ALPHA_ARB;
  593. operand2_enum = GL_OPERAND2_ALPHA_ARB;
  595. // cache current combiner
  596. mCurrAlphaOp = op;
  597. mCurrAlphaSrc1 = src1;
  598. mCurrAlphaSrc2 = src2;
  599. }
  600. else 
  601. {
  602. // Set enums to RGB ones
  603. comb_enum = GL_COMBINE_RGB_ARB;
  604. src0_enum = GL_SOURCE0_RGB_ARB;
  605. src1_enum = GL_SOURCE1_RGB_ARB;
  606. src2_enum = GL_SOURCE2_RGB_ARB;
  607. operand0_enum = GL_OPERAND0_RGB_ARB;
  608. operand1_enum = GL_OPERAND1_RGB_ARB;
  609. operand2_enum = GL_OPERAND2_RGB_ARB;
  611. // cache current combiner
  612. mCurrColorOp = op;
  613. mCurrColorSrc1 = src1;
  614. mCurrColorSrc2 = src2;
  615. }
  617. switch(op)
  618. {
  619. case TBO_REPLACE:
  620. // Slightly special syntax (no second sources), just set all and return.
  621. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_REPLACE);
  622. glTexEnvi(GL_TEXTURE_ENV, src0_enum, source1);
  623. glTexEnvi(GL_TEXTURE_ENV, operand0_enum, operand1);
  624. (isAlpha) ? setAlphaScale(1) : setColorScale(1);
  625. return;
  627. case TBO_MULT:
  628. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_MODULATE);
  629. break;
  631. case TBO_MULT_X2:
  632. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_MODULATE);
  633. scale_amount = 2;
  634. break;
  636. case TBO_MULT_X4:
  637. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_MODULATE);
  638. scale_amount = 4;
  639. break;
  641. case TBO_ADD:
  642. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_ADD);
  643. break;
  645. case TBO_ADD_SIGNED:
  646. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_ADD_SIGNED_ARB);
  647. break;
  649. case TBO_SUBTRACT:
  650. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_SUBTRACT_ARB);
  651. break;
  653. case TBO_LERP_VERT_ALPHA:
  654. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_INTERPOLATE);
  655. glTexEnvi(GL_TEXTURE_ENV, src2_enum, GL_PRIMARY_COLOR_ARB);
  656. glTexEnvi(GL_TEXTURE_ENV, operand2_enum, GL_SRC_ALPHA);
  657. break;
  659. case TBO_LERP_TEX_ALPHA:
  660. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_INTERPOLATE);
  661. glTexEnvi(GL_TEXTURE_ENV, src2_enum, GL_TEXTURE);
  662. glTexEnvi(GL_TEXTURE_ENV, operand2_enum, GL_SRC_ALPHA);
  663. break;
  665. case TBO_LERP_PREV_ALPHA:
  666. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_INTERPOLATE);
  667. glTexEnvi(GL_TEXTURE_ENV, src2_enum, GL_PREVIOUS_ARB);
  668. glTexEnvi(GL_TEXTURE_ENV, operand2_enum, GL_SRC_ALPHA);
  669. break;
  671. case TBO_LERP_CONST_ALPHA:
  672. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_INTERPOLATE);
  673. glTexEnvi(GL_TEXTURE_ENV, src2_enum, GL_CONSTANT_ARB);
  674. glTexEnvi(GL_TEXTURE_ENV, operand2_enum, GL_SRC_ALPHA);
  675. break;
  677. case TBO_LERP_VERT_COLOR:
  678. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_INTERPOLATE);
  679. glTexEnvi(GL_TEXTURE_ENV, src2_enum, GL_PRIMARY_COLOR_ARB);
  680. glTexEnvi(GL_TEXTURE_ENV, operand2_enum, (isAlpha) ? GL_SRC_ALPHA : GL_SRC_COLOR);
  681. break;
  683. default:
  684. llwarns << "Unknown eTextureBlendOp: " << op << ".  Setting op to replace." << llendl;
  685. // Slightly special syntax (no second sources), just set all and return.
  686. glTexEnvi(GL_TEXTURE_ENV, comb_enum, GL_REPLACE);
  687. glTexEnvi(GL_TEXTURE_ENV, src0_enum, source1);
  688. glTexEnvi(GL_TEXTURE_ENV, operand0_enum, operand1);
  689. (isAlpha) ? setAlphaScale(1) : setColorScale(1);
  690. return;
  691. }
  693. // Set sources, operands, and scale accordingly
  694. glTexEnvi(GL_TEXTURE_ENV, src0_enum, source1);
  695. glTexEnvi(GL_TEXTURE_ENV, operand0_enum, operand1);
  696. glTexEnvi(GL_TEXTURE_ENV, src1_enum, source2);
  697. glTexEnvi(GL_TEXTURE_ENV, operand1_enum, operand2);
  698. (isAlpha) ? setAlphaScale(scale_amount) : setColorScale(scale_amount);
  699. }
  701. void LLTexUnit::setColorScale(S32 scale)
  702. {
  703. if (mCurrColorScale != scale || gGL.mDirty)
  704. {
  705. mCurrColorScale = scale;
  706. glTexEnvi( GL_TEXTURE_ENV, GL_RGB_SCALE, scale );
  707. }
  708. }
  710. void LLTexUnit::setAlphaScale(S32 scale)
  711. {
  712. if (mCurrAlphaScale != scale || gGL.mDirty)
  713. {
  714. mCurrAlphaScale = scale;
  715. glTexEnvi( GL_TEXTURE_ENV, GL_ALPHA_SCALE, scale );
  716. }
  717. }
  719. // Useful for debugging that you've manually assigned a texture operation to the correct 
  720. // texture unit based on the currently set active texture in opengl.
  721. void LLTexUnit::debugTextureUnit(void)
  722. {
  723. if (mIndex < 0) return;
  725. GLint activeTexture;
  726. glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &activeTexture);
  727. if ((GL_TEXTURE0_ARB + mIndex) != activeTexture)
  728. {
  729. U32 set_unit = (activeTexture - GL_TEXTURE0_ARB);
  730. llwarns << "Incorrect Texture Unit!  Expected: " << set_unit << " Actual: " << mIndex << llendl;
  731. }
  732. }
  735. LLRender::LLRender()
  736.   : mDirty(false),
  737.     mCount(0),
  738.     mMode(LLRender::TRIANGLES),
  739.     mCurrTextureUnitIndex(0),
  740.     mMaxAnisotropy(0.f) 
  741. {
  742. mBuffer = new LLVertexBuffer(immediate_mask, 0);
  743. mBuffer->allocateBuffer(4096, 0, TRUE);
  744. mBuffer->getVertexStrider(mVerticesp);
  745. mBuffer->getTexCoord0Strider(mTexcoordsp);
  746. mBuffer->getColorStrider(mColorsp);
  748. mTexUnits.reserve(LL_NUM_TEXTURE_LAYERS);
  749. for (U32 i = 0; i < LL_NUM_TEXTURE_LAYERS; i++)
  750. {
  751. mTexUnits.push_back(new LLTexUnit(i));
  752. }
  753. mDummyTexUnit = new LLTexUnit(-1);
  755. for (U32 i = 0; i < 4; i++)
  756. {
  757. mCurrColorMask[i] = true;
  758. }
  760. mCurrAlphaFunc = CF_DEFAULT;
  761. mCurrAlphaFuncVal = 0.01f;
  762. }
  764. LLRender::~LLRender()
  765. {
  766. shutdown();
  767. }
  769. void LLRender::shutdown()
  770. {
  771. for (U32 i = 0; i < mTexUnits.size(); i++)
  772. {
  773. delete mTexUnits[i];
  774. }
  775. mTexUnits.clear();
  776. delete mDummyTexUnit;
  777. mDummyTexUnit = NULL;
  778. }
  780. void LLRender::refreshState(void)
  781. {
  782. mDirty = true;
  784. U32 active_unit = mCurrTextureUnitIndex;
  786. for (U32 i = 0; i < mTexUnits.size(); i++)
  787. {
  788. mTexUnits[i]->refreshState();
  789. }
  791. mTexUnits[active_unit]->activate();
  793. setColorMask(mCurrColorMask[0], mCurrColorMask[1], mCurrColorMask[2], mCurrColorMask[3]);
  795. setAlphaRejectSettings(mCurrAlphaFunc, mCurrAlphaFuncVal);
  797. mDirty = false;
  798. }
  800. void LLRender::translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
  801. {
  802. flush();
  803. glTranslatef(x,y,z);
  804. }
  806. void LLRender::scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
  807. {
  808. flush();
  809. glScalef(x,y,z);
  810. }
  812. void LLRender::pushMatrix()
  813. {
  814. flush();
  815. glPushMatrix();
  816. }
  818. void LLRender::popMatrix()
  819. {
  820. flush();
  821. glPopMatrix();
  822. }
  824. void LLRender::setColorMask(bool writeColor, bool writeAlpha)
  825. {
  826. setColorMask(writeColor, writeColor, writeColor, writeAlpha);
  827. }
  829. void LLRender::setColorMask(bool writeColorR, bool writeColorG, bool writeColorB, bool writeAlpha)
  830. {
  831. flush();
  833. mCurrColorMask[0] = writeColorR;
  834. mCurrColorMask[1] = writeColorG;
  835. mCurrColorMask[2] = writeColorB;
  836. mCurrColorMask[3] = writeAlpha;
  838. glColorMask(writeColorR ? GL_TRUE : GL_FALSE, 
  839. writeColorG ? GL_TRUE : GL_FALSE,
  840. writeColorB ? GL_TRUE : GL_FALSE,
  841. writeAlpha ? GL_TRUE : GL_FALSE);
  842. }
  844. void LLRender::setSceneBlendType(eBlendType type)
  845. {
  846. flush();
  847. switch (type) 
  848. {
  849. case BT_ALPHA:
  850. glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  851. break;
  852. case BT_ADD:
  853. glBlendFunc(GL_ONE, GL_ONE);
  854. break;
  855. case BT_ADD_WITH_ALPHA:
  856. glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  857. break;
  858. case BT_MULT:
  859. glBlendFunc(GL_DST_COLOR, GL_ZERO);
  860. break;
  861. case BT_MULT_ALPHA:
  862. glBlendFunc(GL_DST_ALPHA, GL_ZERO);
  863. break;
  864. case BT_MULT_X2:
  865. glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
  866. break;
  867. case BT_REPLACE:
  868. glBlendFunc(GL_ONE, GL_ZERO);
  869. break;
  870. default:
  871. llerrs << "Unknown Scene Blend Type: " << type << llendl;
  872. break;
  873. }
  874. }
  876. void LLRender::setAlphaRejectSettings(eCompareFunc func, F32 value)
  877. {
  878. flush();
  880. mCurrAlphaFunc = func;
  881. mCurrAlphaFuncVal = value;
  882. if (func == CF_DEFAULT)
  883. {
  884. glAlphaFunc(GL_GREATER, 0.01f);
  885. } 
  886. else
  887. {
  888. glAlphaFunc(sGLCompareFunc[func], value);
  889. }
  890. }
  892. void LLRender::blendFunc(eBlendFactor sfactor, eBlendFactor dfactor)
  893. {
  894. flush();
  895. glBlendFunc(sGLBlendFactor[sfactor], sGLBlendFactor[dfactor]);
  896. }
  898. LLTexUnit* LLRender::getTexUnit(U32 index)
  899. {
  900. if (index < mTexUnits.size())
  901. {
  902. return mTexUnits[index];
  903. }
  904. else 
  905. {
  906. lldebugs << "Non-existing texture unit layer requested: " << index << llendl;
  907. return mDummyTexUnit;
  908. }
  909. }
  911. bool LLRender::verifyTexUnitActive(U32 unitToVerify)
  912. {
  913. if (mCurrTextureUnitIndex == unitToVerify)
  914. {
  915. return true;
  916. }
  917. else 
  918. {
  919. llwarns << "TexUnit currently active: " << mCurrTextureUnitIndex << " (expecting " << unitToVerify << ")" << llendl;
  920. return false;
  921. }
  922. }
  924. void LLRender::clearErrors()
  925. {
  926. while (glGetError())
  927. {
  928. //loop until no more error flags left
  929. }
  930. }
  932. void LLRender::begin(const GLuint& mode)
  933. {
  934. if (mode != mMode)
  935. {
  936. if (mMode == LLRender::QUADS ||
  937. mMode == LLRender::LINES ||
  938. mMode == LLRender::TRIANGLES ||
  939. mMode == LLRender::POINTS)
  940. {
  941. flush();
  942. }
  943. else if (mCount != 0)
  944. {
  945. llerrs << "gGL.begin() called redundantly." << llendl;
  946. }
  948. mMode = mode;
  949. }
  950. }
  952. void LLRender::end()
  953. { 
  954. if (mCount == 0)
  955. {
  956. return;
  957. //IMM_ERRS << "GL begin and end called with no vertices specified." << llendl;
  958. }
  960. if ((mMode != LLRender::QUADS && 
  961. mMode != LLRender::LINES &&
  962. mMode != LLRender::TRIANGLES &&
  963. mMode != LLRender::POINTS) ||
  964. mCount > 2048)
  965. {
  966. flush();
  967. }
  968. }
  969. void LLRender::flush()
  970. {
  971. if (mCount > 0)
  972. {
  973. #if 0
  974. if (!glIsEnabled(GL_VERTEX_ARRAY))
  975. {
  976. llerrs << "foo 1" << llendl;
  977. }
  979. if (!glIsEnabled(GL_COLOR_ARRAY))
  980. {
  981. llerrs << "foo 2" << llendl;
  982. }
  984. if (!glIsEnabled(GL_TEXTURE_COORD_ARRAY))
  985. {
  986. llerrs << "foo 3" << llendl;
  987. }
  989. if (glIsEnabled(GL_NORMAL_ARRAY))
  990. {
  991. llerrs << "foo 7" << llendl;
  992. }
  994. GLvoid* pointer;
  996. glGetPointerv(GL_VERTEX_ARRAY_POINTER, &pointer);
  997. if (pointer != &(mBuffer[0].v))
  998. {
  999. llerrs << "foo 4" << llendl;
  1000. }
  1002. glGetPointerv(GL_COLOR_ARRAY_POINTER, &pointer);
  1003. if (pointer != &(mBuffer[0].c))
  1004. {
  1005. llerrs << "foo 5" << llendl;
  1006. }
  1008. glGetPointerv(GL_TEXTURE_COORD_ARRAY_POINTER, &pointer);
  1009. if (pointer != &(mBuffer[0].uv))
  1010. {
  1011. llerrs << "foo 6" << llendl;
  1012. }
  1013. #endif
  1015. mBuffer->setBuffer(immediate_mask);
  1016. mBuffer->drawArrays(mMode, 0, mCount);
  1018. mVerticesp[0] = mVerticesp[mCount];
  1019. mTexcoordsp[0] = mTexcoordsp[mCount];
  1020. mColorsp[0] = mColorsp[mCount];
  1021. mCount = 0;
  1022. }
  1023. }
  1025. void LLRender::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
  1026. { 
  1027. //the range of mVerticesp, mColorsp and mTexcoordsp is [0, 4095]
  1028. if (mCount > 4094)
  1029. {
  1030. // llwarns << "GL immediate mode overflow.  Some geometry not drawn." << llendl;
  1031. return;
  1032. }
  1034. mVerticesp[mCount] = LLVector3(x,y,z);
  1035. mCount++;
  1036. if (mCount < 4096)
  1037. {
  1038. mVerticesp[mCount] = mVerticesp[mCount-1];
  1039. mColorsp[mCount] = mColorsp[mCount-1];
  1040. mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
  1041. }
  1042. }
  1043. void LLRender::vertex2i(const GLint& x, const GLint& y)
  1044. {
  1045. vertex3f((GLfloat) x, (GLfloat) y, 0);
  1046. }
  1048. void LLRender::vertex2f(const GLfloat& x, const GLfloat& y)
  1049. { 
  1050. vertex3f(x,y,0);
  1051. }
  1053. void LLRender::vertex2fv(const GLfloat* v)
  1054. { 
  1055. vertex3f(v[0], v[1], 0);
  1056. }
  1058. void LLRender::vertex3fv(const GLfloat* v)
  1059. {
  1060. vertex3f(v[0], v[1], v[2]);
  1061. }
  1063. void LLRender::texCoord2f(const GLfloat& x, const GLfloat& y)
  1064. { 
  1065. mTexcoordsp[mCount] = LLVector2(x,y);
  1066. }
  1068. void LLRender::texCoord2i(const GLint& x, const GLint& y)
  1069. { 
  1070. texCoord2f((GLfloat) x, (GLfloat) y);
  1071. }
  1073. void LLRender::texCoord2fv(const GLfloat* tc)
  1074. { 
  1075. texCoord2f(tc[0], tc[1]);
  1076. }
  1078. void LLRender::color4ub(const GLubyte& r, const GLubyte& g, const GLubyte& b, const GLubyte& a)
  1079. {
  1080. mColorsp[mCount] = LLColor4U(r,g,b,a);
  1081. }
  1082. void LLRender::color4ubv(const GLubyte* c)
  1083. {
  1084. color4ub(c[0], c[1], c[2], c[3]);
  1085. }
  1087. void LLRender::color4f(const GLfloat& r, const GLfloat& g, const GLfloat& b, const GLfloat& a)
  1088. {
  1089. color4ub((GLubyte) (llclamp(r, 0.f, 1.f)*255),
  1090. (GLubyte) (llclamp(g, 0.f, 1.f)*255),
  1091. (GLubyte) (llclamp(b, 0.f, 1.f)*255),
  1092. (GLubyte) (llclamp(a, 0.f, 1.f)*255));
  1093. }
  1095. void LLRender::color4fv(const GLfloat* c)
  1096. { 
  1097. color4f(c[0],c[1],c[2],c[3]);
  1098. }
  1100. void LLRender::color3f(const GLfloat& r, const GLfloat& g, const GLfloat& b)
  1101. { 
  1102. color4f(r,g,b,1);
  1103. }
  1105. void LLRender::color3fv(const GLfloat* c)
  1106. { 
  1107. color4f(c[0],c[1],c[2],1);
  1108. }
  1110. void LLRender::debugTexUnits(void)
  1111. {
  1112. LL_INFOS("TextureUnit") << "Active TexUnit: " << mCurrTextureUnitIndex << LL_ENDL;
  1113. std::string active_enabled = "false";
  1114. for (U32 i = 0; i < mTexUnits.size(); i++)
  1115. {
  1116. if (getTexUnit(i)->mCurrTexType != LLTexUnit::TT_NONE)
  1117. {
  1118. if (i == mCurrTextureUnitIndex) active_enabled = "true";
  1119. LL_INFOS("TextureUnit") << "TexUnit: " << i << " Enabled" << LL_ENDL;
  1120. LL_INFOS("TextureUnit") << "Enabled As: " ;
  1121. switch (getTexUnit(i)->mCurrTexType)
  1122. {
  1123. case LLTexUnit::TT_TEXTURE:
  1124. LL_CONT << "Texture 2D";
  1125. break;
  1126. case LLTexUnit::TT_RECT_TEXTURE:
  1127. LL_CONT << "Texture Rectangle";
  1128. break;
  1129. case LLTexUnit::TT_CUBE_MAP:
  1130. LL_CONT << "Cube Map";
  1131. break;
  1132. default:
  1133. LL_CONT << "ARGH!!! NONE!";
  1134. break;
  1135. }
  1136. LL_CONT << ", Texture Bound: " << getTexUnit(i)->mCurrTexture << LL_ENDL;
  1137. }
  1138. }
  1139. LL_INFOS("TextureUnit") << "Active TexUnit Enabled : " << active_enabled << LL_ENDL;
  1140. }