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

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

游戏引擎

开发平台：

C++ Builder

llrendertarget.cpp：源码内容
  1. /** 
  2.  * @file llrendertarget.cpp
  3.  * @brief LLRenderTarget 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 "llrendertarget.h"
  36. #include "llrender.h"
  37. #include "llgl.h"
  39. LLRenderTarget* LLRenderTarget::sBoundTarget = NULL;
  43. void check_framebuffer_status()
  44. {
  45. if (gDebugGL)
  46. {
  47. GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
  48. switch (status)
  49. {
  50. case GL_FRAMEBUFFER_COMPLETE_EXT:
  51. break;
  52. default:
  53. ll_fail("check_framebuffer_status failed");
  54. break;
  55. }
  56. }
  57. }
  59. BOOL LLRenderTarget::sUseFBO = FALSE;
  61. LLRenderTarget::LLRenderTarget() :
  62. mResX(0),
  63. mResY(0),
  64. mTex(0),
  65. mFBO(0),
  66. mDepth(0),
  67. mStencil(0),
  68. mUseDepth(FALSE),
  69. mRenderDepth(FALSE),
  70. mUsage(LLTexUnit::TT_TEXTURE),
  71. mSamples(0),
  72. mSampleBuffer(NULL)
  73. {
  74. }
  76. LLRenderTarget::~LLRenderTarget()
  77. {
  78. release();
  79. }
  82. void LLRenderTarget::setSampleBuffer(LLMultisampleBuffer* buffer)
  83. {
  84. mSampleBuffer = buffer;
  85. }
  87. void LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil, LLTexUnit::eTextureType usage, BOOL use_fbo)
  88. {
  89. stop_glerror();
  90. mResX = resx;
  91. mResY = resy;
  93. mStencil = stencil;
  94. mUsage = usage;
  95. mUseDepth = depth;
  97. release();
  99. if ((sUseFBO || use_fbo) && gGLManager.mHasFramebufferObject)
  100. {
  101. if (depth)
  102. {
  103. stop_glerror();
  104. allocateDepth();
  105. stop_glerror();
  106. }
  108. glGenFramebuffersEXT(1, (GLuint *) &mFBO);
  110. if (mDepth)
  111. {
  112. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
  113. if (mStencil)
  114. {
  115. glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
  116. stop_glerror();
  117. glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
  118. stop_glerror();
  119. }
  120. else
  121. {
  122. glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
  123. stop_glerror();
  124. }
  125. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  126. }
  128. stop_glerror();
  129. }
  131. addColorAttachment(color_fmt);
  132. }
  134. void LLRenderTarget::addColorAttachment(U32 color_fmt)
  135. {
  136. if (color_fmt == 0)
  137. {
  138. return;
  139. }
  141. U32 offset = mTex.size();
  142. if (offset >= 4 ||
  143. (offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
  144. {
  145. llerrs << "Too many color attachments!" << llendl;
  146. }
  148. U32 tex;
  149. LLImageGL::generateTextures(1, &tex);
  150. gGL.getTexUnit(0)->bindManual(mUsage, tex);
  152. stop_glerror();
  154. LLImageGL::setManualImage(LLTexUnit::getInternalType(mUsage), 0, color_fmt, mResX, mResY, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
  156. stop_glerror();
  158. if (offset == 0)
  159. {
  160. gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
  161. }
  162. else
  163. { //don't filter data attachments
  164. gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
  165. }
  166. if (mUsage != LLTexUnit::TT_RECT_TEXTURE)
  167. {
  168. gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_MIRROR);
  169. }
  170. else
  171. {
  172. // ATI doesn't support mirrored repeat for rectangular textures.
  173. gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
  174. }
  175. if (mFBO)
  176. {
  177. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
  178. glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+offset,
  179. LLTexUnit::getInternalType(mUsage), tex, 0);
  180. stop_glerror();
  182. check_framebuffer_status();
  184. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  185. }
  187. mTex.push_back(tex);
  189. }
  191. void LLRenderTarget::allocateDepth()
  192. {
  193. if (mStencil)
  194. {
  195. //use render buffers where stencil buffers are in play
  196. glGenRenderbuffersEXT(1, (GLuint *) &mDepth);
  197. glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mDepth);
  198. glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, mResX, mResY);
  199. glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
  200. }
  201. else
  202. {
  203. LLImageGL::generateTextures(1, &mDepth);
  204. gGL.getTexUnit(0)->bindManual(mUsage, mDepth);
  205. U32 internal_type = LLTexUnit::getInternalType(mUsage);
  206. gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
  207. LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT32_ARB, mResX, mResY, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
  208. }
  209. }
  211. void LLRenderTarget::shareDepthBuffer(LLRenderTarget& target)
  212. {
  213. if (!mFBO || !target.mFBO)
  214. {
  215. llerrs << "Cannot share depth buffer between non FBO render targets." << llendl;
  216. }
  218. if (mDepth)
  219. {
  220. stop_glerror();
  221. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, target.mFBO);
  222. stop_glerror();
  224. if (mStencil)
  225. {
  226. glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
  227. stop_glerror();
  228. glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
  229. stop_glerror();
  230. }
  231. else
  232. {
  233. glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
  234. stop_glerror();
  235. if (mStencil)
  236. {
  237. glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
  238. stop_glerror();
  239. }
  240. }
  241. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  243. target.mUseDepth = TRUE;
  244. }
  245. }
  247. void LLRenderTarget::release()
  248. {
  249. if (mFBO)
  250. {
  251. glDeleteFramebuffersEXT(1, (GLuint *) &mFBO);
  252. mFBO = 0;
  253. }
  255. if (mTex.size() > 0)
  256. {
  257. LLImageGL::deleteTextures(mTex.size(), &mTex[0]);
  258. mTex.clear();
  259. }
  261. if (mDepth)
  262. {
  263. if (mStencil)
  264. {
  265. glDeleteRenderbuffersEXT(1, (GLuint*) &mDepth);
  266. stop_glerror();
  267. }
  268. else
  269. {
  270. LLImageGL::deleteTextures(1, &mDepth);
  271. stop_glerror();
  272. }
  273. mDepth = 0;
  274. }
  276. mSampleBuffer = NULL;
  277. sBoundTarget = NULL;
  278. }
  280. void LLRenderTarget::bindTarget()
  281. {
  282. if (mFBO)
  283. {
  284. stop_glerror();
  285. if (mSampleBuffer)
  286. {
  287. mSampleBuffer->bindTarget(this);
  288. stop_glerror();
  289. }
  290. else
  291. {
  292. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
  293. stop_glerror();
  294. if (gGLManager.mHasDrawBuffers)
  295. { //setup multiple render targets
  296. GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0_EXT,
  297. GL_COLOR_ATTACHMENT1_EXT,
  298. GL_COLOR_ATTACHMENT2_EXT,
  299. GL_COLOR_ATTACHMENT3_EXT};
  300. glDrawBuffersARB(mTex.size(), drawbuffers);
  301. }
  303. if (mTex.empty())
  304. { //no color buffer to draw to
  305. glDrawBuffer(GL_NONE);
  306. glReadBuffer(GL_NONE);
  307. }
  309. check_framebuffer_status();
  311. stop_glerror();
  312. }
  313. }
  315. glViewport(0, 0, mResX, mResY);
  316. sBoundTarget = this;
  317. }
  319. // static
  320. void LLRenderTarget::unbindTarget()
  321. {
  322. if (gGLManager.mHasFramebufferObject)
  323. {
  324. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  325. }
  326. sBoundTarget = NULL;
  327. }
  329. void LLRenderTarget::clear(U32 mask_in)
  330. {
  331. U32 mask = GL_COLOR_BUFFER_BIT;
  332. if (mUseDepth)
  333. {
  334. mask |= GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
  335. }
  336. if (mFBO)
  337. {
  338. check_framebuffer_status();
  339. stop_glerror();
  340. glClear(mask & mask_in);
  341. stop_glerror();
  342. }
  343. else
  344. {
  345. LLGLEnable scissor(GL_SCISSOR_TEST);
  346. glScissor(0, 0, mResX, mResY);
  347. stop_glerror();
  348. glClear(mask & mask_in);
  349. }
  350. }
  352. U32 LLRenderTarget::getTexture(U32 attachment) const
  353. {
  354. if (attachment > mTex.size()-1)
  355. {
  356. llerrs << "Invalid attachment index." << llendl;
  357. }
  358. return mTex[attachment];
  359. }
  361. void LLRenderTarget::bindTexture(U32 index, S32 channel)
  362. {
  363. if (index > mTex.size()-1)
  364. {
  365. llerrs << "Invalid attachment index." << llendl;
  366. }
  367. gGL.getTexUnit(channel)->bindManual(mUsage, mTex[index]);
  368. }
  370. void LLRenderTarget::flush(BOOL fetch_depth)
  371. {
  372. gGL.flush();
  373. if (!mFBO)
  374. {
  375. gGL.getTexUnit(0)->bind(this);
  376. glCopyTexSubImage2D(LLTexUnit::getInternalType(mUsage), 0, 0, 0, 0, 0, mResX, mResY);
  378. if (fetch_depth)
  379. {
  380. if (!mDepth)
  381. {
  382. allocateDepth();
  383. }
  385. gGL.getTexUnit(0)->bind(this);
  386. glCopyTexImage2D(LLTexUnit::getInternalType(mUsage), 0, GL_DEPTH24_STENCIL8_EXT, 0, 0, mResX, mResY, 0);
  387. }
  389. gGL.getTexUnit(0)->disable();
  390. }
  391. else
  392. {
  393. #if !LL_DARWIN
  395. stop_glerror();
  397. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  399. stop_glerror();
  401. if (mSampleBuffer)
  402. {
  403. LLGLEnable multisample(GL_MULTISAMPLE_ARB);
  404. stop_glerror();
  405. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
  406. stop_glerror();
  407. check_framebuffer_status();
  408. glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, mSampleBuffer->mFBO);
  409. check_framebuffer_status();
  411. stop_glerror();
  412. glBlitFramebufferEXT(0, 0, mResX, mResY, 0, 0, mResX, mResY, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_NEAREST);
  413. stop_glerror();
  415. if (mTex.size() > 1)
  416. {
  417. for (U32 i = 1; i < mTex.size(); ++i)
  418. {
  419. glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
  420. LLTexUnit::getInternalType(mUsage), mTex[i], 0);
  421. stop_glerror();
  422. glFramebufferRenderbufferEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, mSampleBuffer->mTex[i]);
  423. stop_glerror();
  424. glBlitFramebufferEXT(0, 0, mResX, mResY, 0, 0, mResX, mResY, GL_COLOR_BUFFER_BIT, GL_NEAREST);
  425. stop_glerror();
  426. }
  428. for (U32 i = 0; i < mTex.size(); ++i)
  429. {
  430. glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+i,
  431. LLTexUnit::getInternalType(mUsage), mTex[i], 0);
  432. stop_glerror();
  433. glFramebufferRenderbufferEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+i, GL_RENDERBUFFER_EXT, mSampleBuffer->mTex[i]);
  434. stop_glerror();
  435. }
  436. }
  437. }
  438. #endif
  440. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  441. }
  442. }
  444. void LLRenderTarget::copyContents(LLRenderTarget& source, S32 srcX0, S32 srcY0, S32 srcX1, S32 srcY1,
  445. S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter)
  446. {
  447. #if !LL_DARWIN
  448. gGL.flush();
  449. if (!source.mFBO || !mFBO)
  450. {
  451. llerrs << "Cannot copy framebuffer contents for non FBO render targets." << llendl;
  452. }
  454. if (mSampleBuffer)
  455. {
  456. mSampleBuffer->copyContents(source, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  457. }
  458. else
  459. {
  460. if (mask == GL_DEPTH_BUFFER_BIT && source.mStencil != mStencil)
  461. {
  462. stop_glerror();
  464. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, source.mFBO);
  465. gGL.getTexUnit(0)->bind(this, true);
  466. stop_glerror();
  467. glCopyTexSubImage2D(LLTexUnit::getInternalType(mUsage), 0, srcX0, srcY0, dstX0, dstY0, dstX1, dstY1);
  468. stop_glerror();
  469. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  470. stop_glerror();
  471. }
  472. else
  473. {
  474. glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, source.mFBO);
  475. stop_glerror();
  476. glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, mFBO);
  477. stop_glerror();
  478. check_framebuffer_status();
  479. stop_glerror();
  480. glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  481. stop_glerror();
  482. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  483. stop_glerror();
  484. }
  485. }
  486. #endif
  487. }
  489. //static
  490. void LLRenderTarget::copyContentsToFramebuffer(LLRenderTarget& source, S32 srcX0, S32 srcY0, S32 srcX1, S32 srcY1,
  491. S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter)
  492. {
  493. #if !LL_DARWIN
  494. if (!source.mFBO)
  495. {
  496. llerrs << "Cannot copy framebuffer contents for non FBO render targets." << llendl;
  497. }
  498. {
  499. glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, source.mFBO);
  500. stop_glerror();
  501. glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
  502. stop_glerror();
  503. check_framebuffer_status();
  504. stop_glerror();
  505. glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  506. stop_glerror();
  507. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  508. stop_glerror();
  509. }
  510. #endif
  511. }
  513. BOOL LLRenderTarget::isComplete() const
  514. {
  515. return (!mTex.empty() || mDepth) ? TRUE : FALSE;
  516. }
  518. void LLRenderTarget::getViewport(S32* viewport)
  519. {
  520. viewport[0] = 0;
  521. viewport[1] = 0;
  522. viewport[2] = mResX;
  523. viewport[3] = mResY;
  524. }
  526. //==================================================
  527. // LLMultisampleBuffer implementation
  528. //==================================================
  529. LLMultisampleBuffer::LLMultisampleBuffer()
  530. {
  532. }
  534. LLMultisampleBuffer::~LLMultisampleBuffer()
  535. {
  536. releaseSampleBuffer();
  537. }
  539. void LLMultisampleBuffer::releaseSampleBuffer()
  540. {
  541. if (mFBO)
  542. {
  543. glDeleteFramebuffersEXT(1, (GLuint *) &mFBO);
  544. mFBO = 0;
  545. }
  547. if (mTex.size() > 0)
  548. {
  549. glDeleteRenderbuffersEXT(mTex.size(), (GLuint *) &mTex[0]);
  550. mTex.clear();
  551. }
  553. if (mDepth)
  554. {
  555. glDeleteRenderbuffersEXT(1, (GLuint *) &mDepth);
  556. mDepth = 0;
  557. }
  558. }
  560. void LLMultisampleBuffer::bindTarget()
  561. {
  562. bindTarget(this);
  563. }
  565. void LLMultisampleBuffer::bindTarget(LLRenderTarget* ref)
  566. {
  567. if (!ref)
  568. {
  569. ref = this;
  570. }
  572. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
  573. if (gGLManager.mHasDrawBuffers)
  574. { //setup multiple render targets
  575. GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0_EXT,
  576. GL_COLOR_ATTACHMENT1_EXT,
  577. GL_COLOR_ATTACHMENT2_EXT,
  578. GL_COLOR_ATTACHMENT3_EXT};
  579. glDrawBuffersARB(ref->mTex.size(), drawbuffers);
  580. }
  582. check_framebuffer_status();
  584. glViewport(0, 0, mResX, mResY);
  586. sBoundTarget = this;
  587. }
  589. void LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil,  LLTexUnit::eTextureType usage, BOOL use_fbo )
  590. {
  591. allocate(resx,resy,color_fmt,depth,stencil,usage,use_fbo,2);
  592. }
  594. void LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil,  LLTexUnit::eTextureType usage, BOOL use_fbo, U32 samples )
  595. {
  596. stop_glerror();
  597. mResX = resx;
  598. mResY = resy;
  600. mUsage = usage;
  601. mUseDepth = depth;
  602. mStencil = stencil;
  604. releaseSampleBuffer();
  606. if (!gGLManager.mHasFramebufferMultisample)
  607. {
  608. llerrs << "Attempting to allocate unsupported render target type!" << llendl;
  609. }
  611. mSamples = samples;
  613. if (mSamples <= 1)
  614. {
  615. llerrs << "Cannot create a multisample buffer with less than 2 samples." << llendl;
  616. }
  618. stop_glerror();
  620. if ((sUseFBO || use_fbo) && gGLManager.mHasFramebufferObject)
  621. {
  623. if (depth)
  624. {
  625. stop_glerror();
  626. allocateDepth();
  627. stop_glerror();
  628. }
  630. glGenFramebuffersEXT(1, (GLuint *) &mFBO);
  632. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
  634. if (mDepth)
  635. {
  636. glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
  637. if (mStencil)
  638. {
  639. glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
  640. }
  641. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  642. }
  644. stop_glerror();
  646. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  647. stop_glerror();
  648. }
  650. addColorAttachment(color_fmt);
  651. }
  653. void LLMultisampleBuffer::addColorAttachment(U32 color_fmt)
  654. {
  655. #if !LL_DARWIN
  656. if (color_fmt == 0)
  657. {
  658. return;
  659. }
  661. U32 offset = mTex.size();
  662. if (offset >= 4 ||
  663. (offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
  664. {
  665. llerrs << "Too many color attachments!" << llendl;
  666. }
  668. U32 tex;
  669. glGenRenderbuffersEXT(1, &tex);
  671. glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, tex);
  672. glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, color_fmt, mResX, mResY);
  673. stop_glerror();
  675. if (mFBO)
  676. {
  677. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
  678. glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+offset, GL_RENDERBUFFER_EXT, tex);
  679. stop_glerror();
  680. GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
  681. switch (status)
  682. {
  683. case GL_FRAMEBUFFER_COMPLETE_EXT:
  684. break;
  685. case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
  686. llerrs << "WTF?" << llendl;
  687. break;
  688. default:
  689. llerrs << "WTF?" << llendl;
  690. }
  692. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  693. }
  695. mTex.push_back(tex);
  696. #endif
  697. }
  699. void LLMultisampleBuffer::allocateDepth()
  700. {
  701. #if !LL_DARWIN
  702. glGenRenderbuffersEXT(1, (GLuint* ) &mDepth);
  703. glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mDepth);
  704. if (mStencil)
  705. {
  706. glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, GL_DEPTH24_STENCIL8_EXT, mResX, mResY);
  707. }
  708. else
  709. {
  710. glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, GL_DEPTH_COMPONENT16_ARB, mResX, mResY);
  711. }
  712. #endif
  713. }