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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llvertexbuffer.h
  3.  * @brief LLVertexBuffer wrapper for OpengGL vertex buffer objects
  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.  */
  32. #ifndef LL_LLVERTEXBUFFER_H
  33. #define LL_LLVERTEXBUFFER_H
  34. #include "llgl.h"
  35. #include "v2math.h"
  36. #include "v3math.h"
  37. #include "v4math.h"
  38. #include "v4coloru.h"
  39. #include "llstrider.h"
  40. #include "llrender.h"
  41. #include <set>
  42. #include <vector>
  43. #include <list>
  44. //============================================================================
  45. // NOTES
  46. // Threading:
  47. //  All constructors should take an 'create' paramater which should only be
  48. //  'true' when called from the main thread. Otherwise createGLBuffer() will
  49. //  be called as soon as getVertexPointer(), etc is called (which MUST ONLY be
  50. //  called from the main (i.e OpenGL) thread)
  51. //============================================================================
  52. // gl name pools for dynamic and streaming buffers
  53. class LLVBOPool : public LLGLNamePool
  54. {
  55. protected:
  56. virtual GLuint allocateName()
  57. {
  58. GLuint name;
  59. glGenBuffersARB(1, &name);
  60. return name;
  61. }
  62. virtual void releaseName(GLuint name)
  63. {
  64. glDeleteBuffersARB(1, &name);
  65. }
  66. };
  67. //============================================================================
  68. // base class
  69. class LLVertexBuffer : public LLRefCount
  70. {
  71. public:
  72. static LLVBOPool sStreamVBOPool;
  73. static LLVBOPool sDynamicVBOPool;
  74. static LLVBOPool sStreamIBOPool;
  75. static LLVBOPool sDynamicIBOPool;
  76. static void initClass(bool use_vbo);
  77. static void cleanupClass();
  78. static void setupClientArrays(U32 data_mask);
  79.   static void clientCopy(F64 max_time = 0.005); //copy data from client to GL
  80. static void unbind(); //unbind any bound vertex buffer
  81. //get the size of a vertex with the given typemask
  82. //if offsets is not NULL, its contents will be filled
  83. //with the offset of each vertex component in the buffer, 
  84. // indexed by the following enum
  85. static S32 calcStride(const U32& typemask, S32* offsets = NULL); 
  86. enum {
  87. TYPE_VERTEX,
  88. TYPE_NORMAL,
  89. TYPE_TEXCOORD0,
  90. TYPE_TEXCOORD1,
  91. TYPE_TEXCOORD2,
  92. TYPE_TEXCOORD3,
  93. TYPE_COLOR,
  94. // These use VertexAttribPointer and should possibly be made generic
  95. TYPE_BINORMAL,
  96. TYPE_WEIGHT,
  97. TYPE_CLOTHWEIGHT,
  98. TYPE_MAX,
  99. TYPE_INDEX,
  100. };
  101. enum {
  102. MAP_VERTEX = (1<<TYPE_VERTEX),
  103. MAP_NORMAL = (1<<TYPE_NORMAL),
  104. MAP_TEXCOORD0 = (1<<TYPE_TEXCOORD0),
  105. MAP_TEXCOORD1 = (1<<TYPE_TEXCOORD1),
  106. MAP_TEXCOORD2 = (1<<TYPE_TEXCOORD2),
  107. MAP_TEXCOORD3 = (1<<TYPE_TEXCOORD3),
  108. MAP_COLOR = (1<<TYPE_COLOR),
  109. // These use VertexAttribPointer and should possibly be made generic
  110. MAP_BINORMAL = (1<<TYPE_BINORMAL),
  111. MAP_WEIGHT = (1<<TYPE_WEIGHT),
  112. MAP_CLOTHWEIGHT = (1<<TYPE_CLOTHWEIGHT),
  113. };
  114. protected:
  115. friend class LLRender;
  116. virtual ~LLVertexBuffer(); // use unref()
  117. virtual void setupVertexBuffer(U32 data_mask) const; // pure virtual, called from mapBuffer()
  118. void genBuffer();
  119. void genIndices();
  120. void releaseBuffer();
  121. void releaseIndices();
  122. void createGLBuffer();
  123. void createGLIndices();
  124. void  destroyGLBuffer();
  125. void  destroyGLIndices();
  126. void updateNumVerts(S32 nverts);
  127. void updateNumIndices(S32 nindices); 
  128. virtual BOOL useVBOs() const;
  129. void unmapBuffer();
  130. public:
  131. LLVertexBuffer(U32 typemask, S32 usage);
  132. // map for data access
  133. U8* mapBuffer(S32 access = -1);
  134. // set for rendering
  135. virtual void setBuffer(U32 data_mask);  // calls  setupVertexBuffer() if data_mask is not 0
  136. // allocate buffer
  137. void allocateBuffer(S32 nverts, S32 nindices, bool create);
  138. virtual void resizeBuffer(S32 newnverts, S32 newnindices);
  139. // Only call each getVertexPointer, etc, once before calling unmapBuffer()
  140. // call unmapBuffer() after calls to getXXXStrider() before any cals to setBuffer()
  141. // example:
  142. //   vb->getVertexBuffer(verts);
  143. //   vb->getNormalStrider(norms);
  144. //   setVertsNorms(verts, norms);
  145. //   vb->unmapBuffer();
  146. bool getVertexStrider(LLStrider<LLVector3>& strider, S32 index=0);
  147. bool getIndexStrider(LLStrider<U16>& strider, S32 index=0);
  148. bool getTexCoord0Strider(LLStrider<LLVector2>& strider, S32 index=0);
  149. bool getTexCoord1Strider(LLStrider<LLVector2>& strider, S32 index=0);
  150. bool getNormalStrider(LLStrider<LLVector3>& strider, S32 index=0);
  151. bool getBinormalStrider(LLStrider<LLVector3>& strider, S32 index=0);
  152. bool getColorStrider(LLStrider<LLColor4U>& strider, S32 index=0);
  153. bool getWeightStrider(LLStrider<F32>& strider, S32 index=0);
  154. bool getClothWeightStrider(LLStrider<LLVector4>& strider, S32 index=0);
  155. BOOL isEmpty() const { return mEmpty; }
  156. BOOL isLocked() const { return mLocked; }
  157. S32 getNumVerts() const { return mNumVerts; }
  158. S32 getNumIndices() const { return mNumIndices; }
  159. S32 getRequestedVerts() const { return mRequestedNumVerts; }
  160. S32 getRequestedIndices() const { return mRequestedNumIndices; }
  161. U8* getIndicesPointer() const { return useVBOs() ? NULL : mMappedIndexData; }
  162. U8* getVerticesPointer() const { return useVBOs() ? NULL : mMappedData; }
  163. S32 getStride() const { return mStride; }
  164. S32 getTypeMask() const { return mTypeMask; }
  165. BOOL hasDataType(S32 type) const { return ((1 << type) & getTypeMask()) ? TRUE : FALSE; }
  166. S32 getSize() const { return mNumVerts*mStride; }
  167. S32 getIndicesSize() const { return mNumIndices * sizeof(U16); }
  168. U8* getMappedData() const { return mMappedData; }
  169. U8* getMappedIndices() const { return mMappedIndexData; }
  170. S32 getOffset(S32 type) const { return mOffsets[type]; }
  171. S32 getUsage() const { return mUsage; }
  172. void setStride(S32 type, S32 new_stride);
  173. void markDirty(U32 vert_index, U32 vert_count, U32 indices_index, U32 indices_count);
  174. void draw(U32 mode, U32 count, U32 indices_offset) const;
  175. void drawArrays(U32 mode, U32 offset, U32 count) const;
  176. void drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indices_offset) const;
  177. protected:
  178. S32 mNumVerts; // Number of vertices allocated
  179. S32 mNumIndices; // Number of indices allocated
  180. S32 mRequestedNumVerts;  // Number of vertices requested
  181. S32 mRequestedNumIndices;  // Number of indices requested
  182. S32 mStride;
  183. U32 mTypeMask;
  184. S32 mUsage; // GL usage
  185. U32 mGLBuffer; // GL VBO handle
  186. U32 mGLIndices; // GL IBO handle
  187. U8* mMappedData; // pointer to currently mapped data (NULL if unmapped)
  188. U8* mMappedIndexData; // pointer to currently mapped indices (NULL if unmapped)
  189. BOOL mLocked; // if TRUE, buffer is being or has been written to in client memory
  190. BOOL mFinal; // if TRUE, buffer can not be mapped again
  191. BOOL mFilthy; // if TRUE, entire buffer must be copied (used to prevent redundant dirty flags)
  192. BOOL mEmpty; // if TRUE, client buffer is empty (or NULL). Old values have been discarded.
  193. S32 mOffsets[TYPE_MAX];
  194. BOOL mResized; // if TRUE, client buffer has been resized and GL buffer has not
  195. BOOL mDynamicSize; // if TRUE, buffer has been resized at least once (and should be padded)
  196. class DirtyRegion
  197. {
  198. public:
  199. U32 mIndex;
  200. U32 mCount;
  201. U32 mIndicesIndex;
  202. U32 mIndicesCount;
  203. DirtyRegion(U32 vi, U32 vc, U32 ii, U32 ic)
  204. : mIndex(vi), mCount(vc), mIndicesIndex(ii), mIndicesCount(ic)
  205. { }
  206. };
  207. std::vector<DirtyRegion> mDirtyRegions; //vector of dirty regions to rebuild
  208. public:
  209. static S32 sCount;
  210. static S32 sGLCount;
  211. static S32 sMappedCount;
  212. static BOOL sMapped;
  213. static std::vector<U32> sDeleteList;
  214. typedef std::list<LLVertexBuffer*> buffer_list_t;
  215. static BOOL sEnableVBOs;
  216. static S32 sTypeOffsets[TYPE_MAX];
  217. static U32 sGLMode[LLRender::NUM_MODES];
  218. static U32 sGLRenderBuffer;
  219. static U32 sGLRenderIndices;
  220. static BOOL sVBOActive;
  221. static BOOL sIBOActive;
  222. static U32 sLastMask;
  223. static U32 sAllocatedBytes;
  224. static U32 sBindCount;
  225. static U32 sSetCount;
  226. };
  227. #endif // LL_LLVERTEXBUFFER_H