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

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

游戏引擎

开发平台：

C++ Builder

llvertexbuffer.cpp：源码内容
  1. /** 
  2.  * @file llvertexbuffer.cpp
  3.  * @brief LLVertexBuffer implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2003-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 <boost/static_assert.hpp>
  37. #include "llvertexbuffer.h"
  38. // #include "llrender.h"
  39. #include "llglheaders.h"
  40. #include "llmemtype.h"
  41. #include "llrender.h"
  43. //============================================================================
  45. //static
  46. LLVBOPool LLVertexBuffer::sStreamVBOPool;
  47. LLVBOPool LLVertexBuffer::sDynamicVBOPool;
  48. LLVBOPool LLVertexBuffer::sStreamIBOPool;
  49. LLVBOPool LLVertexBuffer::sDynamicIBOPool;
  51. U32 LLVertexBuffer::sBindCount = 0;
  52. U32 LLVertexBuffer::sSetCount = 0;
  53. S32 LLVertexBuffer::sCount = 0;
  54. S32 LLVertexBuffer::sGLCount = 0;
  55. S32 LLVertexBuffer::sMappedCount = 0;
  56. BOOL LLVertexBuffer::sEnableVBOs = TRUE;
  57. U32 LLVertexBuffer::sGLRenderBuffer = 0;
  58. U32 LLVertexBuffer::sGLRenderIndices = 0;
  59. U32 LLVertexBuffer::sLastMask = 0;
  60. BOOL LLVertexBuffer::sVBOActive = FALSE;
  61. BOOL LLVertexBuffer::sIBOActive = FALSE;
  62. U32 LLVertexBuffer::sAllocatedBytes = 0;
  63. BOOL LLVertexBuffer::sMapped = FALSE;
  65. std::vector<U32> LLVertexBuffer::sDeleteList;
  67. S32 LLVertexBuffer::sTypeOffsets[LLVertexBuffer::TYPE_MAX] =
  68. {
  69. sizeof(LLVector3), // TYPE_VERTEX,
  70. sizeof(LLVector3), // TYPE_NORMAL,
  71. sizeof(LLVector2), // TYPE_TEXCOORD0,
  72. sizeof(LLVector2), // TYPE_TEXCOORD1,
  73. sizeof(LLVector2), // TYPE_TEXCOORD2,
  74. sizeof(LLVector2), // TYPE_TEXCOORD3,
  75. sizeof(LLColor4U), // TYPE_COLOR,
  76. sizeof(LLVector3), // TYPE_BINORMAL,
  77. sizeof(F32),    // TYPE_WEIGHT,
  78. sizeof(LLVector4), // TYPE_CLOTHWEIGHT,
  79. };
  81. U32 LLVertexBuffer::sGLMode[LLRender::NUM_MODES] = 
  82. {
  83. GL_TRIANGLES,
  84. GL_TRIANGLE_STRIP,
  85. GL_TRIANGLE_FAN,
  86. GL_POINTS,
  87. GL_LINES,
  88. GL_LINE_STRIP,
  89. GL_QUADS,
  90. GL_LINE_LOOP,
  91. };
  93. //static
  94. void LLVertexBuffer::setupClientArrays(U32 data_mask)
  95. {
  96. /*if (LLGLImmediate::sStarted)
  97. {
  98. llerrs << "Cannot use LLGLImmediate and LLVertexBuffer simultaneously!" << llendl;
  99. }*/
  101. if (sLastMask != data_mask)
  102. {
  103. U32 mask[] =
  104. {
  105. MAP_VERTEX,
  106. MAP_NORMAL,
  107. MAP_TEXCOORD0,
  108. MAP_COLOR,
  109. };
  111. GLenum array[] =
  112. {
  113. GL_VERTEX_ARRAY,
  114. GL_NORMAL_ARRAY,
  115. GL_TEXTURE_COORD_ARRAY,
  116. GL_COLOR_ARRAY,
  117. };
  119. BOOL error = FALSE;
  120. for (U32 i = 0; i < 4; ++i)
  121. {
  122. if (sLastMask & mask[i])
  123. { //was enabled
  124. if (!(data_mask & mask[i]) && i > 0)
  125. { //needs to be disabled
  126. glDisableClientState(array[i]);
  127. }
  128. else if (gDebugGL)
  129. { //needs to be enabled, make sure it was (DEBUG TEMPORARY)
  130. if (i > 0 && !glIsEnabled(array[i]))
  131. {
  132. if (gDebugSession)
  133. {
  134. error = TRUE;
  135. gFailLog << "Bad client state! " << array[i] << " disabled." << std::endl;
  136. }
  137. else
  138. {
  139. llerrs << "Bad client state! " << array[i] << " disabled." << llendl;
  140. }
  141. }
  142. }
  143. }
  144. else 
  145. { //was disabled
  146. if (data_mask & mask[i])
  147. { //needs to be enabled
  148. glEnableClientState(array[i]);
  149. }
  150. else if (gDebugGL && glIsEnabled(array[i]))
  151. { //needs to be disabled, make sure it was (DEBUG TEMPORARY)
  152. if (gDebugSession)
  153. {
  154. error = TRUE;
  155. gFailLog << "Bad client state! " << array[i] << " enabled." << std::endl;
  156. }
  157. else
  158. {
  159. llerrs << "Bad client state! " << array[i] << " enabled." << llendl;
  160. }
  161. }
  162. }
  163. }
  165. if (error)
  166. {
  167. ll_fail("LLVertexBuffer::setupClientArrays failed");
  168. }
  170. U32 map_tc[] = 
  171. {
  172. MAP_TEXCOORD1,
  173. MAP_TEXCOORD2,
  174. MAP_TEXCOORD3
  175. };
  177. for (U32 i = 0; i < 3; i++)
  178. {
  179. if (sLastMask & map_tc[i])
  180. {
  181. if (!(data_mask & map_tc[i]))
  182. {
  183. glClientActiveTextureARB(GL_TEXTURE1_ARB+i);
  184. glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  185. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  186. }
  187. }
  188. else if (data_mask & map_tc[i])
  189. {
  190. glClientActiveTextureARB(GL_TEXTURE1_ARB+i);
  191. glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  192. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  193. }
  194. }
  196. if (sLastMask & MAP_BINORMAL)
  197. {
  198. if (!(data_mask & MAP_BINORMAL))
  199. {
  200. glClientActiveTextureARB(GL_TEXTURE2_ARB);
  201. glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  202. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  203. }
  204. }
  205. else if (data_mask & MAP_BINORMAL)
  206. {
  207. glClientActiveTextureARB(GL_TEXTURE2_ARB);
  208. glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  209. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  210. }
  212. sLastMask = data_mask;
  213. }
  214. }
  216. void LLVertexBuffer::drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indices_offset) const
  217. {
  218. llassert(mRequestedNumVerts >= 0);
  220. if (start >= (U32) mRequestedNumVerts ||
  221.     end >= (U32) mRequestedNumVerts)
  222. {
  223. llerrs << "Bad vertex buffer draw range: [" << start << ", " << end << "]" << llendl;
  224. }
  226. llassert(mRequestedNumIndices >= 0);
  228. if (indices_offset >= (U32) mRequestedNumIndices ||
  229.     indices_offset + count > (U32) mRequestedNumIndices)
  230. {
  231. llerrs << "Bad index buffer draw range: [" << indices_offset << ", " << indices_offset+count << "]" << llendl;
  232. }
  234. if (mGLIndices != sGLRenderIndices)
  235. {
  236. llerrs << "Wrong index buffer bound." << llendl;
  237. }
  239. if (mGLBuffer != sGLRenderBuffer)
  240. {
  241. llerrs << "Wrong vertex buffer bound." << llendl;
  242. }
  244. if (mode >= LLRender::NUM_MODES)
  245. {
  246. llerrs << "Invalid draw mode: " << mode << llendl;
  247. return;
  248. }
  250. stop_glerror();
  251. glDrawRangeElements(sGLMode[mode], start, end, count, GL_UNSIGNED_SHORT, 
  252. ((U16*) getIndicesPointer()) + indices_offset);
  253. stop_glerror();
  254. }
  256. void LLVertexBuffer::draw(U32 mode, U32 count, U32 indices_offset) const
  257. {
  258. llassert(mRequestedNumIndices >= 0);
  259. if (indices_offset >= (U32) mRequestedNumIndices ||
  260.     indices_offset + count > (U32) mRequestedNumIndices)
  261. {
  262. llerrs << "Bad index buffer draw range: [" << indices_offset << ", " << indices_offset+count << "]" << llendl;
  263. }
  265. if (mGLIndices != sGLRenderIndices)
  266. {
  267. llerrs << "Wrong index buffer bound." << llendl;
  268. }
  270. if (mGLBuffer != sGLRenderBuffer)
  271. {
  272. llerrs << "Wrong vertex buffer bound." << llendl;
  273. }
  275. if (mode >= LLRender::NUM_MODES)
  276. {
  277. llerrs << "Invalid draw mode: " << mode << llendl;
  278. return;
  279. }
  281. stop_glerror();
  282. glDrawElements(sGLMode[mode], count, GL_UNSIGNED_SHORT,
  283. ((U16*) getIndicesPointer()) + indices_offset);
  284. stop_glerror();
  285. }
  287. void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
  288. {
  289. llassert(mRequestedNumVerts >= 0);
  290. if (first >= (U32) mRequestedNumVerts ||
  291.     first + count > (U32) mRequestedNumVerts)
  292. {
  293. llerrs << "Bad vertex buffer draw range: [" << first << ", " << first+count << "]" << llendl;
  294. }
  296. if (mGLBuffer != sGLRenderBuffer || useVBOs() != sVBOActive)
  297. {
  298. llerrs << "Wrong vertex buffer bound." << llendl;
  299. }
  301. if (mode >= LLRender::NUM_MODES)
  302. {
  303. llerrs << "Invalid draw mode: " << mode << llendl;
  304. return;
  305. }
  307. stop_glerror();
  308. glDrawArrays(sGLMode[mode], first, count);
  309. stop_glerror();
  310. }
  312. //static
  313. void LLVertexBuffer::initClass(bool use_vbo)
  314. {
  315. sEnableVBOs = use_vbo;
  316. LLGLNamePool::registerPool(&sDynamicVBOPool);
  317. LLGLNamePool::registerPool(&sDynamicIBOPool);
  318. LLGLNamePool::registerPool(&sStreamVBOPool);
  319. LLGLNamePool::registerPool(&sStreamIBOPool);
  320. }
  322. //static 
  323. void LLVertexBuffer::unbind()
  324. {
  325. if (sVBOActive)
  326. {
  327. glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
  328. sVBOActive = FALSE;
  329. }
  330. if (sIBOActive)
  331. {
  332. glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
  333. sIBOActive = FALSE;
  334. }
  336. sGLRenderBuffer = 0;
  337. sGLRenderIndices = 0;
  339. setupClientArrays(0);
  340. }
  342. //static
  343. void LLVertexBuffer::cleanupClass()
  344. {
  345. LLMemType mt2(LLMemType::MTYPE_VERTEX_CLEANUP_CLASS);
  346. unbind();
  347. clientCopy(); // deletes GL buffers
  348. }
  350. void LLVertexBuffer::clientCopy(F64 max_time)
  351. {
  352. if (!sDeleteList.empty())
  353. {
  354. glDeleteBuffersARB(sDeleteList.size(), (GLuint*) &(sDeleteList[0]));
  355. sDeleteList.clear();
  356. }
  357. }
  359. //----------------------------------------------------------------------------
  361. LLVertexBuffer::LLVertexBuffer(U32 typemask, S32 usage) :
  362. LLRefCount(),
  364. mNumVerts(0),
  365. mNumIndices(0),
  366. mRequestedNumVerts(-1),
  367. mRequestedNumIndices(-1),
  368. mUsage(usage),
  369. mGLBuffer(0),
  370. mGLIndices(0), 
  371. mMappedData(NULL),
  372. mMappedIndexData(NULL), mLocked(FALSE),
  373. mFinal(FALSE),
  374. mFilthy(FALSE),
  375. mEmpty(TRUE),
  376. mResized(FALSE),
  377. mDynamicSize(FALSE)
  378. {
  379. LLMemType mt2(LLMemType::MTYPE_VERTEX_CONSTRUCTOR);
  380. if (!sEnableVBOs)
  381. {
  382. mUsage = 0 ; 
  383. }
  385. S32 stride = calcStride(typemask, mOffsets);
  387. mTypeMask = typemask;
  388. mStride = stride;
  389. sCount++;
  390. }
  392. //static
  393. S32 LLVertexBuffer::calcStride(const U32& typemask, S32* offsets)
  394. {
  395. S32 stride = 0;
  396. for (S32 i=0; i<TYPE_MAX; i++)
  397. {
  398. U32 mask = 1<<i;
  399. if (typemask & mask)
  400. {
  401. if (offsets)
  402. {
  403. offsets[i] = stride;
  404. }
  405. stride += sTypeOffsets[i];
  406. }
  407. }
  409. return stride;
  410. }
  412. // protected, use unref()
  413. //virtual
  414. LLVertexBuffer::~LLVertexBuffer()
  415. {
  416. LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTRUCTOR);
  417. destroyGLBuffer();
  418. destroyGLIndices();
  419. sCount--;
  420. };
  422. //----------------------------------------------------------------------------
  424. void LLVertexBuffer::genBuffer()
  425. {
  426. if (mUsage == GL_STREAM_DRAW_ARB)
  427. {
  428. mGLBuffer = sStreamVBOPool.allocate();
  429. }
  430. else if (mUsage == GL_DYNAMIC_DRAW_ARB)
  431. {
  432. mGLBuffer = sDynamicVBOPool.allocate();
  433. }
  434. else
  435. {
  436. BOOST_STATIC_ASSERT(sizeof(mGLBuffer) == sizeof(GLuint));
  437. glGenBuffersARB(1, (GLuint*)&mGLBuffer);
  438. }
  439. sGLCount++;
  440. }
  442. void LLVertexBuffer::genIndices()
  443. {
  444. if (mUsage == GL_STREAM_DRAW_ARB)
  445. {
  446. mGLIndices = sStreamIBOPool.allocate();
  447. }
  448. else if (mUsage == GL_DYNAMIC_DRAW_ARB)
  449. {
  450. mGLIndices = sDynamicIBOPool.allocate();
  451. }
  452. else
  453. {
  454. BOOST_STATIC_ASSERT(sizeof(mGLBuffer) == sizeof(GLuint));
  455. glGenBuffersARB(1, (GLuint*)&mGLIndices);
  456. }
  457. sGLCount++;
  458. }
  460. void LLVertexBuffer::releaseBuffer()
  461. {
  462. if (mUsage == GL_STREAM_DRAW_ARB)
  463. {
  464. sStreamVBOPool.release(mGLBuffer);
  465. }
  466. else if (mUsage == GL_DYNAMIC_DRAW_ARB)
  467. {
  468. sDynamicVBOPool.release(mGLBuffer);
  469. }
  470. else
  471. {
  472. sDeleteList.push_back(mGLBuffer);
  473. }
  474. sGLCount--;
  475. }
  477. void LLVertexBuffer::releaseIndices()
  478. {
  479. if (mUsage == GL_STREAM_DRAW_ARB)
  480. {
  481. sStreamIBOPool.release(mGLIndices);
  482. }
  483. else if (mUsage == GL_DYNAMIC_DRAW_ARB)
  484. {
  485. sDynamicIBOPool.release(mGLIndices);
  486. }
  487. else
  488. {
  489. sDeleteList.push_back(mGLIndices);
  490. }
  491. sGLCount--;
  492. }
  494. void LLVertexBuffer::createGLBuffer()
  495. {
  496. LLMemType mt2(LLMemType::MTYPE_VERTEX_CREATE_VERTICES);
  498. U32 size = getSize();
  499. if (mGLBuffer)
  500. {
  501. destroyGLBuffer();
  502. }
  504. if (size == 0)
  505. {
  506. return;
  507. }
  509. mEmpty = TRUE;
  511. if (useVBOs())
  512. {
  513. mMappedData = NULL;
  514. genBuffer();
  515. mResized = TRUE;
  516. }
  517. else
  518. {
  519. static int gl_buffer_idx = 0;
  520. mGLBuffer = ++gl_buffer_idx;
  521. mMappedData = new U8[size];
  522. memset(mMappedData, 0, size);
  523. }
  524. }
  526. void LLVertexBuffer::createGLIndices()
  527. {
  528. LLMemType mt2(LLMemType::MTYPE_VERTEX_CREATE_INDICES);
  529. U32 size = getIndicesSize();
  531. if (mGLIndices)
  532. {
  533. destroyGLIndices();
  534. }
  536. if (size == 0)
  537. {
  538. return;
  539. }
  541. mEmpty = TRUE;
  543. if (useVBOs())
  544. {
  545. mMappedIndexData = NULL;
  546. genIndices();
  547. mResized = TRUE;
  548. }
  549. else
  550. {
  551. mMappedIndexData = new U8[size];
  552. memset(mMappedIndexData, 0, size);
  553. static int gl_buffer_idx = 0;
  554. mGLIndices = ++gl_buffer_idx;
  555. }
  556. }
  558. void LLVertexBuffer::destroyGLBuffer()
  559. {
  560. LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTROY_BUFFER);
  561. if (mGLBuffer)
  562. {
  563. if (useVBOs())
  564. {
  565. if (mMappedData || mMappedIndexData)
  566. {
  567. llerrs << "Vertex buffer destroyed while mapped!" << llendl;
  568. }
  569. releaseBuffer();
  570. }
  571. else
  572. {
  573. delete [] mMappedData;
  574. mMappedData = NULL;
  575. mEmpty = TRUE;
  576. }
  578. sAllocatedBytes -= getSize();
  579. }
  581. mGLBuffer = 0;
  582. unbind();
  583. }
  585. void LLVertexBuffer::destroyGLIndices()
  586. {
  587. LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTROY_INDICES);
  588. if (mGLIndices)
  589. {
  590. if (useVBOs())
  591. {
  592. if (mMappedData || mMappedIndexData)
  593. {
  594. llerrs << "Vertex buffer destroyed while mapped." << llendl;
  595. }
  596. releaseIndices();
  597. }
  598. else
  599. {
  600. delete [] mMappedIndexData;
  601. mMappedIndexData = NULL;
  602. mEmpty = TRUE;
  603. }
  605. sAllocatedBytes -= getIndicesSize();
  606. }
  608. mGLIndices = 0;
  609. unbind();
  610. }
  612. void LLVertexBuffer::updateNumVerts(S32 nverts)
  613. {
  614. LLMemType mt2(LLMemType::MTYPE_VERTEX_UPDATE_VERTS);
  616. llassert(nverts >= 0);
  618. if (nverts >= 65535)
  619. {
  620. llwarns << "Vertex buffer overflow!" << llendl;
  621. nverts = 65535;
  622. }
  624. mRequestedNumVerts = nverts;
  626. if (!mDynamicSize)
  627. {
  628. mNumVerts = nverts;
  629. }
  630. else if (mUsage == GL_STATIC_DRAW_ARB ||
  631. nverts > mNumVerts ||
  632. nverts < mNumVerts/2)
  633. {
  634. if (mUsage != GL_STATIC_DRAW_ARB && nverts + nverts/4 <= 65535)
  635. {
  636. nverts += nverts/4;
  637. }
  638. mNumVerts = nverts;
  639. }
  641. }
  643. void LLVertexBuffer::updateNumIndices(S32 nindices)
  644. {
  645. LLMemType mt2(LLMemType::MTYPE_VERTEX_UPDATE_INDICES);
  647. llassert(nindices >= 0);
  649. mRequestedNumIndices = nindices;
  650. if (!mDynamicSize)
  651. {
  652. mNumIndices = nindices;
  653. }
  654. else if (mUsage == GL_STATIC_DRAW_ARB ||
  655. nindices > mNumIndices ||
  656. nindices < mNumIndices/2)
  657. {
  658. if (mUsage != GL_STATIC_DRAW_ARB)
  659. {
  660. nindices += nindices/4;
  661. }
  663. mNumIndices = nindices;
  664. }
  665. }
  667. void LLVertexBuffer::allocateBuffer(S32 nverts, S32 nindices, bool create)
  668. {
  669. LLMemType mt2(LLMemType::MTYPE_VERTEX_ALLOCATE_BUFFER);
  671. updateNumVerts(nverts);
  672. updateNumIndices(nindices);
  674. if (mMappedData)
  675. {
  676. llerrs << "LLVertexBuffer::allocateBuffer() called redundantly." << llendl;
  677. }
  678. if (create && (nverts || nindices))
  679. {
  680. createGLBuffer();
  681. createGLIndices();
  682. }
  684. sAllocatedBytes += getSize() + getIndicesSize();
  685. }
  687. void LLVertexBuffer::resizeBuffer(S32 newnverts, S32 newnindices)
  688. {
  689. llassert(newnverts >= 0);
  690. llassert(newnindices >= 0);
  692. mRequestedNumVerts = newnverts;
  693. mRequestedNumIndices = newnindices;
  695. LLMemType mt2(LLMemType::MTYPE_VERTEX_RESIZE_BUFFER);
  696. mDynamicSize = TRUE;
  697. if (mUsage == GL_STATIC_DRAW_ARB)
  698. { //always delete/allocate static buffers on resize
  699. destroyGLBuffer();
  700. destroyGLIndices();
  701. allocateBuffer(newnverts, newnindices, TRUE);
  702. mFinal = FALSE;
  703. }
  704. else if (newnverts > mNumVerts || newnindices > mNumIndices ||
  705.  newnverts < mNumVerts/2 || newnindices < mNumIndices/2)
  706. {
  707. sAllocatedBytes -= getSize() + getIndicesSize();
  709. S32 oldsize = getSize();
  710. S32 old_index_size = getIndicesSize();
  712. updateNumVerts(newnverts);
  713. updateNumIndices(newnindices);
  715. S32 newsize = getSize();
  716. S32 new_index_size = getIndicesSize();
  718. sAllocatedBytes += newsize + new_index_size;
  720. if (newsize)
  721. {
  722. if (!mGLBuffer)
  723. { //no buffer exists, create a new one
  724. createGLBuffer();
  725. }
  726. else
  727. {
  728. //delete old buffer, keep GL buffer for now
  729. if (!useVBOs())
  730. {
  731. U8* old = mMappedData;
  732. mMappedData = new U8[newsize];
  733. if (old)
  734. {
  735. memcpy(mMappedData, old, llmin(newsize, oldsize));
  736. if (newsize > oldsize)
  737. {
  738. memset(mMappedData+oldsize, 0, newsize-oldsize);
  739. }
  741. delete [] old;
  742. }
  743. else
  744. {
  745. memset(mMappedData, 0, newsize);
  746. mEmpty = TRUE;
  747. }
  748. }
  749. mResized = TRUE;
  750. }
  751. }
  752. else if (mGLBuffer)
  753. {
  754. destroyGLBuffer();
  755. }
  757. if (new_index_size)
  758. {
  759. if (!mGLIndices)
  760. {
  761. createGLIndices();
  762. }
  763. else
  764. {
  765. if (!useVBOs())
  766. {
  767. //delete old buffer, keep GL buffer for now
  768. U8* old = mMappedIndexData;
  769. mMappedIndexData = new U8[new_index_size];
  771. if (old)
  772. {
  773. memcpy(mMappedIndexData, old, llmin(new_index_size, old_index_size));
  774. if (new_index_size > old_index_size)
  775. {
  776. memset(mMappedIndexData+old_index_size, 0, new_index_size - old_index_size);
  777. }
  778. delete [] old;
  779. }
  780. else
  781. {
  782. memset(mMappedIndexData, 0, new_index_size);
  783. mEmpty = TRUE;
  784. }
  785. }
  786. mResized = TRUE;
  787. }
  788. }
  789. else if (mGLIndices)
  790. {
  791. destroyGLIndices();
  792. }
  793. }
  795. if (mResized && useVBOs())
  796. {
  797. setBuffer(0);
  798. }
  799. }
  801. BOOL LLVertexBuffer::useVBOs() const
  802. {
  803. //it's generally ineffective to use VBO for things that are streaming on apple
  805. #if LL_DARWIN
  806. if (!mUsage || mUsage == GL_STREAM_DRAW_ARB)
  807. {
  808. return FALSE;
  809. }
  810. #else
  811. if (!mUsage)
  812. {
  813. return FALSE;
  814. }
  815. #endif
  816. return sEnableVBOs;
  817. }
  819. //----------------------------------------------------------------------------
  821. // Map for data access
  822. U8* LLVertexBuffer::mapBuffer(S32 access)
  823. {
  824. LLMemType mt2(LLMemType::MTYPE_VERTEX_MAP_BUFFER);
  825. if (mFinal)
  826. {
  827. llerrs << "LLVertexBuffer::mapBuffer() called on a finalized buffer." << llendl;
  828. }
  829. if (!useVBOs() && !mMappedData && !mMappedIndexData)
  830. {
  831. llerrs << "LLVertexBuffer::mapBuffer() called on unallocated buffer." << llendl;
  832. }
  834. if (!mLocked && useVBOs())
  835. {
  836. {
  837. LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_VERTICES);
  838. setBuffer(0);
  839. mLocked = TRUE;
  840. stop_glerror();
  841. mMappedData = (U8*) glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
  842. stop_glerror();
  843. }
  844. {
  845. LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_INDICES);
  846. mMappedIndexData = (U8*) glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
  847. stop_glerror();
  848. }
  850. if (!mMappedData)
  851. {
  852. //--------------------
  853. //print out more debug info before crash
  854. llinfos << "vertex buffer size: (num verts : num indices) = " << getNumVerts() << " : " << getNumIndices() << llendl ;
  855. GLint size ;
  856. glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_SIZE_ARB, &size) ;
  857. llinfos << "GL_ARRAY_BUFFER_ARB size is " << size << llendl ;
  858. //--------------------
  860. GLint buff;
  861. glGetIntegerv(GL_ARRAY_BUFFER_BINDING_ARB, &buff);
  862. if ((GLuint)buff != mGLBuffer)
  863. {
  864. llerrs << "Invalid GL vertex buffer bound: " << buff << llendl;
  865. }
  868. llerrs << "glMapBuffer returned NULL (no vertex data)" << llendl;
  869. }
  871. if (!mMappedIndexData)
  872. {
  873. GLint buff;
  874. glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, &buff);
  875. if ((GLuint)buff != mGLIndices)
  876. {
  877. llerrs << "Invalid GL index buffer bound: " << buff << llendl;
  878. }
  880. llerrs << "glMapBuffer returned NULL (no index data)" << llendl;
  881. }
  883. sMappedCount++;
  884. }
  886. return mMappedData;
  887. }
  889. void LLVertexBuffer::unmapBuffer()
  890. {
  891. LLMemType mt2(LLMemType::MTYPE_VERTEX_UNMAP_BUFFER);
  892. if (mMappedData || mMappedIndexData)
  893. {
  894. if (useVBOs() && mLocked)
  895. {
  896. stop_glerror();
  897. glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
  898. stop_glerror();
  899. glUnmapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB);
  900. stop_glerror();
  902. /*if (!sMapped)
  903. {
  904. llerrs << "Redundantly unmapped VBO!" << llendl;
  905. }
  906. sMapped = FALSE;*/
  907. sMappedCount--;
  909. if (mUsage == GL_STATIC_DRAW_ARB)
  910. { //static draw buffers can only be mapped a single time
  911. //throw out client data (we won't be using it again)
  912. mEmpty = TRUE;
  913. mFinal = TRUE;
  914. }
  915. else
  916. {
  917. mEmpty = FALSE;
  918. }
  920. mMappedIndexData = NULL;
  921. mMappedData = NULL;
  923. mLocked = FALSE;
  924. }
  925. }
  926. }
  928. //----------------------------------------------------------------------------
  930. template <class T,S32 type> struct VertexBufferStrider
  931. {
  932. typedef LLStrider<T> strider_t;
  933. static bool get(LLVertexBuffer& vbo, 
  934. strider_t& strider, 
  935. S32 index)
  936. {
  937. if (vbo.mapBuffer() == NULL)
  938. {
  939. llwarns << "mapBuffer failed!" << llendl;
  940. return FALSE;
  941. }
  943. if (type == LLVertexBuffer::TYPE_INDEX)
  944. {
  945. S32 stride = sizeof(T);
  946. strider = (T*)(vbo.getMappedIndices() + index*stride);
  947. strider.setStride(0);
  948. return TRUE;
  949. }
  950. else if (vbo.hasDataType(type))
  951. {
  952. S32 stride = vbo.getStride();
  953. strider = (T*)(vbo.getMappedData() + vbo.getOffset(type) + index*stride);
  954. strider.setStride(stride);
  955. return TRUE;
  956. }
  957. else
  958. {
  959. llerrs << "VertexBufferStrider could not find valid vertex data." << llendl;
  960. }
  961. return FALSE;
  962. }
  963. };
  966. bool LLVertexBuffer::getVertexStrider(LLStrider<LLVector3>& strider, S32 index)
  967. {
  968. return VertexBufferStrider<LLVector3,TYPE_VERTEX>::get(*this, strider, index);
  969. }
  970. bool LLVertexBuffer::getIndexStrider(LLStrider<U16>& strider, S32 index)
  971. {
  972. return VertexBufferStrider<U16,TYPE_INDEX>::get(*this, strider, index);
  973. }
  974. bool LLVertexBuffer::getTexCoord0Strider(LLStrider<LLVector2>& strider, S32 index)
  975. {
  976. return VertexBufferStrider<LLVector2,TYPE_TEXCOORD0>::get(*this, strider, index);
  977. }
  978. bool LLVertexBuffer::getTexCoord1Strider(LLStrider<LLVector2>& strider, S32 index)
  979. {
  980. return VertexBufferStrider<LLVector2,TYPE_TEXCOORD1>::get(*this, strider, index);
  981. }
  982. /*bool LLVertexBuffer::getTexCoord2Strider(LLStrider<LLVector2>& strider, S32 index)
  983. {
  984. return VertexBufferStrider<LLVector2,TYPE_TEXCOORD2>::get(*this, strider, index);
  985. }
  986. bool LLVertexBuffer::getTexCoord3Strider(LLStrider<LLVector2>& strider, S32 index)
  987. {
  988. return VertexBufferStrider<LLVector2,TYPE_TEXCOORD3>::get(*this, strider, index);
  989. }*/
  990. bool LLVertexBuffer::getNormalStrider(LLStrider<LLVector3>& strider, S32 index)
  991. {
  992. return VertexBufferStrider<LLVector3,TYPE_NORMAL>::get(*this, strider, index);
  993. }
  994. bool LLVertexBuffer::getBinormalStrider(LLStrider<LLVector3>& strider, S32 index)
  995. {
  996. return VertexBufferStrider<LLVector3,TYPE_BINORMAL>::get(*this, strider, index);
  997. }
  998. bool LLVertexBuffer::getColorStrider(LLStrider<LLColor4U>& strider, S32 index)
  999. {
  1000. return VertexBufferStrider<LLColor4U,TYPE_COLOR>::get(*this, strider, index);
  1001. }
  1002. bool LLVertexBuffer::getWeightStrider(LLStrider<F32>& strider, S32 index)
  1003. {
  1004. return VertexBufferStrider<F32,TYPE_WEIGHT>::get(*this, strider, index);
  1005. }
  1006. bool LLVertexBuffer::getClothWeightStrider(LLStrider<LLVector4>& strider, S32 index)
  1007. {
  1008. return VertexBufferStrider<LLVector4,TYPE_CLOTHWEIGHT>::get(*this, strider, index);
  1009. }
  1011. void LLVertexBuffer::setStride(S32 type, S32 new_stride)
  1012. {
  1013. LLMemType mt2(LLMemType::MTYPE_VERTEX_SET_STRIDE);
  1014. if (mNumVerts)
  1015. {
  1016. llerrs << "LLVertexBuffer::setOffset called with mNumVerts = " << mNumVerts << llendl;
  1017. }
  1018. // This code assumes that setStride() will only be called once per VBO per type.
  1019. S32 delta = new_stride - sTypeOffsets[type];
  1020. for (S32 i=type+1; i<TYPE_MAX; i++)
  1021. {
  1022. if (mTypeMask & (1<<i))
  1023. {
  1024. mOffsets[i] += delta;
  1025. }
  1026. }
  1027. mStride += delta;
  1028. }
  1030. //----------------------------------------------------------------------------
  1032. // Set for rendering
  1033. void LLVertexBuffer::setBuffer(U32 data_mask)
  1034. {
  1035. LLMemType mt2(LLMemType::MTYPE_VERTEX_SET_BUFFER);
  1036. //set up pointers if the data mask is different ...
  1037. BOOL setup = (sLastMask != data_mask);
  1039. if (useVBOs())
  1040. {
  1041. if (mGLBuffer && (mGLBuffer != sGLRenderBuffer || !sVBOActive))
  1042. {
  1043. /*if (sMapped)
  1044. {
  1045. llerrs << "VBO bound while another VBO mapped!" << llendl;
  1046. }*/
  1047. stop_glerror();
  1048. glBindBufferARB(GL_ARRAY_BUFFER_ARB, mGLBuffer);
  1049. stop_glerror();
  1050. sBindCount++;
  1051. sVBOActive = TRUE;
  1052. setup = TRUE; // ... or the bound buffer changed
  1053. }
  1054. if (mGLIndices && (mGLIndices != sGLRenderIndices || !sIBOActive))
  1055. {
  1056. /*if (sMapped)
  1057. {
  1058. llerrs << "VBO bound while another VBO mapped!" << llendl;
  1059. }*/
  1060. stop_glerror();
  1061. glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mGLIndices);
  1062. stop_glerror();
  1063. sBindCount++;
  1064. sIBOActive = TRUE;
  1065. }
  1067. BOOL error = FALSE;
  1068. if (gDebugGL)
  1069. {
  1070. GLint buff;
  1071. glGetIntegerv(GL_ARRAY_BUFFER_BINDING_ARB, &buff);
  1072. if ((GLuint)buff != mGLBuffer)
  1073. {
  1074. if (gDebugSession)
  1075. {
  1076. error = TRUE;
  1077. gFailLog << "Invalid GL vertex buffer bound: " << buff << std::endl;
  1078. }
  1079. else
  1080. {
  1081. llerrs << "Invalid GL vertex buffer bound: " << buff << llendl;
  1082. }
  1083. }
  1085. if (mGLIndices)
  1086. {
  1087. glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, &buff);
  1088. if ((GLuint)buff != mGLIndices)
  1089. {
  1090. if (gDebugSession)
  1091. {
  1092. error = TRUE;
  1093. gFailLog << "Invalid GL index buffer bound: " << buff <<  std::endl;
  1094. }
  1095. else
  1096. {
  1097. llerrs << "Invalid GL index buffer bound: " << buff << llendl;
  1098. }
  1099. }
  1100. }
  1101. }
  1103. if (mResized)
  1104. {
  1105. if (gDebugGL)
  1106. {
  1107. GLint buff;
  1108. glGetIntegerv(GL_ARRAY_BUFFER_BINDING_ARB, &buff);
  1109. if ((GLuint)buff != mGLBuffer)
  1110. {
  1111. if (gDebugSession)
  1112. {
  1113. error = TRUE;
  1114. gFailLog << "Invalid GL vertex buffer bound: " << std::endl;
  1115. }
  1116. else
  1117. {
  1118. llerrs << "Invalid GL vertex buffer bound: " << buff << llendl;
  1119. }
  1120. }
  1122. if (mGLIndices != 0)
  1123. {
  1124. glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, &buff);
  1125. if ((GLuint)buff != mGLIndices)
  1126. {
  1127. if (gDebugSession)
  1128. {
  1129. error = TRUE;
  1130. gFailLog << "Invalid GL index buffer bound: "<< std::endl;
  1131. }
  1132. else
  1133. {
  1134. llerrs << "Invalid GL index buffer bound: " << buff << llendl;
  1135. }
  1136. }
  1137. }
  1138. }
  1140. if (mGLBuffer)
  1141. {
  1142. stop_glerror();
  1143. glBufferDataARB(GL_ARRAY_BUFFER_ARB, getSize(), NULL, mUsage);
  1144. stop_glerror();
  1145. }
  1146. if (mGLIndices)
  1147. {
  1148. stop_glerror();
  1149. glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, getIndicesSize(), NULL, mUsage);
  1150. stop_glerror();
  1151. }
  1153. mEmpty = TRUE;
  1154. mResized = FALSE;
  1156. if (data_mask != 0)
  1157. {
  1158. if (gDebugSession)
  1159. {
  1160. error = TRUE;
  1161. gFailLog << "Buffer set for rendering before being filled after resize." << std::endl;
  1162. }
  1163. else
  1164. {
  1165. llerrs << "Buffer set for rendering before being filled after resize." << llendl;
  1166. }
  1167. }
  1168. }
  1170. if (error)
  1171. {
  1172. ll_fail("LLVertexBuffer::mapBuffer failed");
  1173. }
  1174. unmapBuffer();
  1175. }
  1176. else
  1177. {
  1178. if (mGLBuffer)
  1179. {
  1180. if (sEnableVBOs && sVBOActive)
  1181. {
  1182. glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
  1183. sBindCount++;
  1184. sVBOActive = FALSE;
  1185. setup = TRUE; // ... or a VBO is deactivated
  1186. }
  1187. if (sGLRenderBuffer != mGLBuffer)
  1188. {
  1189. setup = TRUE; // ... or a client memory pointer changed
  1190. }
  1191. }
  1192. if (sEnableVBOs && mGLIndices && sIBOActive)
  1193. {
  1194. /*if (sMapped)
  1195. {
  1196. llerrs << "VBO unbound while potentially mapped!" << llendl;
  1197. }*/
  1198. glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
  1199. sBindCount++;
  1200. sIBOActive = FALSE;
  1201. }
  1202. }
  1204. setupClientArrays(data_mask);
  1206. if (mGLIndices)
  1207. {
  1208. sGLRenderIndices = mGLIndices;
  1209. }
  1210. if (mGLBuffer)
  1211. {
  1212. sGLRenderBuffer = mGLBuffer;
  1213. if (data_mask && setup)
  1214. {
  1215. setupVertexBuffer(data_mask); // subclass specific setup (virtual function)
  1216. sSetCount++;
  1217. }
  1218. }
  1219. }
  1221. // virtual (default)
  1222. void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const
  1223. {
  1224. LLMemType mt2(LLMemType::MTYPE_VERTEX_SETUP_VERTEX_BUFFER);
  1225. stop_glerror();
  1226. U8* base = useVBOs() ? NULL : mMappedData;
  1227. S32 stride = mStride;
  1229. if ((data_mask & mTypeMask) != data_mask)
  1230. {
  1231. llerrs << "LLVertexBuffer::setupVertexBuffer missing required components for supplied data mask." << llendl;
  1232. }
  1234. if (data_mask & MAP_NORMAL)
  1235. {
  1236. glNormalPointer(GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_NORMAL]));
  1237. }
  1238. if (data_mask & MAP_TEXCOORD3)
  1239. {
  1240. glClientActiveTextureARB(GL_TEXTURE3_ARB);
  1241. glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD3]));
  1242. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  1243. }
  1244. if (data_mask & MAP_TEXCOORD2)
  1245. {
  1246. glClientActiveTextureARB(GL_TEXTURE2_ARB);
  1247. glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD2]));
  1248. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  1249. }
  1250. if (data_mask & MAP_TEXCOORD1)
  1251. {
  1252. glClientActiveTextureARB(GL_TEXTURE1_ARB);
  1253. glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD1]));
  1254. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  1255. }
  1256. if (data_mask & MAP_BINORMAL)
  1257. {
  1258. glClientActiveTextureARB(GL_TEXTURE2_ARB);
  1259. glTexCoordPointer(3,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_BINORMAL]));
  1260. glClientActiveTextureARB(GL_TEXTURE0_ARB);
  1261. }
  1262. if (data_mask & MAP_TEXCOORD0)
  1263. {
  1264. glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD0]));
  1265. }
  1266. if (data_mask & MAP_COLOR)
  1267. {
  1268. glColorPointer(4, GL_UNSIGNED_BYTE, stride, (void*)(base + mOffsets[TYPE_COLOR]));
  1269. }
  1271. if (data_mask & MAP_WEIGHT)
  1272. {
  1273. glVertexAttribPointerARB(1, 1, GL_FLOAT, FALSE, stride, (void*)(base + mOffsets[TYPE_WEIGHT]));
  1274. }
  1275. if (data_mask & MAP_CLOTHWEIGHT)
  1276. {
  1277. glVertexAttribPointerARB(4, 4, GL_FLOAT, TRUE,  stride, (void*)(base + mOffsets[TYPE_CLOTHWEIGHT]));
  1278. }
  1279. if (data_mask & MAP_VERTEX)
  1280. {
  1281. glVertexPointer(3,GL_FLOAT, stride, (void*)(base + 0));
  1282. }
  1284. llglassertok();
  1285. }
  1287. void LLVertexBuffer::markDirty(U32 vert_index, U32 vert_count, U32 indices_index, U32 indices_count)
  1288. {
  1289. // TODO: use GL_APPLE_flush_buffer_range here
  1290. /*if (useVBOs() && !mFilthy)
  1291. {
  1293. }*/
  1294. }