lolengine
/
lol
镜像自地址 https://github.com/lolengine/lol
1
0
派生 0
代码 工单 0 版本发布 0 百科 动态
2230 提交
5 分支
1.3 GiB
 
 
 
目录树: ffa21ed0d0
lol/src/gpu/vertexbuffer.cpp

734 行
23 KiB
原始文件 Blame 文件历史 

  1. //

  2. // Lol Engine

  3. //

  4. // Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>

  5. //   This program is free software; you can redistribute it and/or

  6. //   modify it under the terms of the Do What The Fuck You Want To

  7. //   Public License, Version 2, as published by Sam Hocevar. See

  8. //   http://www.wtfpl.net/ for more details.

  9. //

  10. 

  11. #if defined HAVE_CONFIG_H

  12. #   include "config.h"

  13. #endif

  14. 

  15. #include <lol/main.h>

  16. #include "lolgl.h"

  17. 

  18. #if defined _WIN32 && defined USE_D3D9

  19. #   define FAR

  20. #   define NEAR

  21. #   include <d3d9.h>

  22. #elif defined _XBOX

  23. #   include <xtl.h>

  24. #   undef near /* Fuck Microsoft */

  25. #   undef far /* Fuck Microsoft again */

  26. #endif

  27. 

  28. namespace lol

  29. {

  30. 

  31. //

  32. // The VertexBufferData class

  33. // --------------------------

  34. //

  35. 

  36. class VertexBufferData

  37. {

  38.     friend class VertexBuffer;

  39.     friend class VertexDeclaration;

  40. 

  41.     size_t m_size;

  42. 

  43. #if defined USE_D3D9

  44.     IDirect3DDevice9 *m_dev;

  45.     IDirect3DVertexBuffer9 *m_vbo;

  46. #elif defined _XBOX

  47.     D3DDevice *m_dev;

  48.     D3DVertexBuffer *m_vbo;

  49. #else

  50.     GLuint m_vbo;

  51.     uint8_t *m_memory;

  52. #endif

  53. };

  54. 

  55. //

  56. // The VertexDeclarationData class

  57. // -------------------------------

  58. //

  59. 

  60. class VertexDeclarationData

  61. {

  62.     friend class VertexBuffer;

  63.     friend class VertexDeclaration;

  64. 

  65. #if defined USE_D3D9

  66.     IDirect3DDevice9 *m_dev;

  67.     IDirect3DVertexDeclaration9 *m_vdecl;

  68. #elif defined _XBOX

  69.     D3DDevice *m_dev;

  70.     D3DVertexDeclaration *m_vdecl;

  71. #else

  72. #endif

  73. };

  74. 

  75. //

  76. // The VertexDeclaration class

  77. // ---------------------------

  78. //

  79. 

  80. VertexStreamBase const VertexStreamBase::Empty;

  81. 

  82. VertexDeclaration::VertexDeclaration(VertexStreamBase const &s1,

  83.                                      VertexStreamBase const &s2,

  84.                                      VertexStreamBase const &s3,

  85.                                      VertexStreamBase const &s4,

  86.                                      VertexStreamBase const &s5,

  87.                                      VertexStreamBase const &s6,

  88.                                      VertexStreamBase const &s7,

  89.                                      VertexStreamBase const &s8,

  90.                                      VertexStreamBase const &s9,

  91.                                      VertexStreamBase const &s10,

  92.                                      VertexStreamBase const &s11,

  93.                                      VertexStreamBase const &s12)

  94.   : m_count(0),

  95.     m_data(new VertexDeclarationData())

  96. {

  97.     if (&s1 != &VertexStreamBase::Empty) AddStream(s1);

  98.     if (&s2 != &VertexStreamBase::Empty) AddStream(s2);

  99.     if (&s3 != &VertexStreamBase::Empty) AddStream(s3);

  100.     if (&s4 != &VertexStreamBase::Empty) AddStream(s4);

  101.     if (&s5 != &VertexStreamBase::Empty) AddStream(s5);

  102.     if (&s6 != &VertexStreamBase::Empty) AddStream(s6);

  103.     if (&s7 != &VertexStreamBase::Empty) AddStream(s7);

  104.     if (&s8 != &VertexStreamBase::Empty) AddStream(s8);

  105.     if (&s9 != &VertexStreamBase::Empty) AddStream(s9);

  106.     if (&s10 != &VertexStreamBase::Empty) AddStream(s10);

  107.     if (&s11 != &VertexStreamBase::Empty) AddStream(s11);

  108.     if (&s12 != &VertexStreamBase::Empty) AddStream(s12);

  109.     Initialize();

  110. }

  111. 

  112. VertexDeclaration::~VertexDeclaration()

  113. {

  114. #if defined _XBOX || defined USE_D3D9

  115.     if (FAILED(m_data->m_vdecl->Release()))

  116.         Abort();

  117. #else

  118. 

  119. #endif

  120. 

  121.     delete m_data;

  122. }

  123. 

  124. void VertexDeclaration::Bind()

  125. {

  126. #if defined _XBOX || defined USE_D3D9

  127.     if (FAILED(m_data->m_dev->SetVertexDeclaration(m_data->m_vdecl)))

  128.         Abort();

  129. #else

  130.     /* FIXME: Nothing to do? */

  131. #endif

  132. }

  133. 

  134. void VertexDeclaration::DrawElements(MeshPrimitive type, int skip, int count)

  135. {

  136.     if (count <= 0)

  137.         return;

  138. 

  139. #if defined _XBOX || defined USE_D3D9

  140.     switch (type.ToScalar())

  141.     {

  142.     case MeshPrimitive::Triangles:

  143.         if (FAILED(m_data->m_dev->DrawPrimitive(D3DPT_TRIANGLELIST,

  144.                                                 skip, count)))

  145.             Abort();

  146.         break;

  147.     case MeshPrimitive::TriangleStrips:

  148.         if (FAILED(m_data->m_dev->DrawPrimitive(D3DPT_TRIANGLESTRIP,

  149.                                                 skip, count)))

  150.             Abort();

  151.         break;

  152.     case MeshPrimitive::TriangleFans:

  153.         if (FAILED(m_data->m_dev->DrawPrimitive(D3DPT_TRIANGLEFAN,

  154.                                                 skip, count)))

  155.             Abort();

  156.         break;

  157.     case MeshPrimitive::Points:

  158.         if (FAILED(m_data->m_dev->DrawPrimitive(D3DPT_POINTLIST,

  159.                                                 skip, count)))

  160.             Abort();

  161.         break;

  162.     case MeshPrimitive::Lines:

  163.         if (FAILED(m_data->m_dev->DrawPrimitive(D3DPT_LINELIST,

  164.                                                 skip, count)))

  165.             Abort();

  166.         break;

  167.     }

  168. #else

  169.     /* FIXME: this has nothing to do here! */

  170.     switch (type.ToScalar())

  171.     {

  172.     case MeshPrimitive::Triangles:

  173.         glDrawArrays(GL_TRIANGLES, skip, count);

  174.         break;

  175.     case MeshPrimitive::TriangleStrips:

  176.         glDrawArrays(GL_TRIANGLE_STRIP, skip, count);

  177.         break;

  178.     case MeshPrimitive::TriangleFans:

  179.         glDrawArrays(GL_TRIANGLE_FAN, skip, count);

  180.         break;

  181.     case MeshPrimitive::Points:

  182.         glDrawArrays(GL_POINTS, skip, count);

  183.         break;

  184.     case MeshPrimitive::Lines:

  185.         glDrawArrays(GL_LINES, skip, count);

  186.         break;

  187.     }

  188. #endif

  189. }

  190. 

  191. void VertexDeclaration::DrawIndexedElements(MeshPrimitive type, int vbase,

  192.                                             int vskip, int vcount,

  193.                                             int skip, int count)

  194. {

  195.     if (count <= 0)

  196.         return;

  197. 

  198. #if defined _XBOX || defined USE_D3D9

  199.     switch (type.ToScalar())

  200.     {

  201.     case MeshPrimitive::Triangles:

  202.         count = count / 3;

  203.         if (FAILED(m_data->m_dev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,

  204.                                            vbase, vskip, vcount, skip, count)))

  205.             Abort();

  206.         break;

  207.     case MeshPrimitive::TriangleStrips:

  208.         count = count - 2;

  209.         if (FAILED(m_data->m_dev->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP,

  210.                                            vbase, vskip, vcount, skip, count)))

  211.             Abort();

  212.         break;

  213.     case MeshPrimitive::TriangleFans:

  214.         count = count - 2;

  215.         if (FAILED(m_data->m_dev->DrawIndexedPrimitive(D3DPT_TRIANGLEFAN,

  216.                                            vbase, vskip, vcount, skip, count)))

  217.             Abort();

  218.         break;

  219.     case MeshPrimitive::Points:

  220.         if (FAILED(m_data->m_dev->DrawIndexedPrimitive(D3DPT_POINTLIST,

  221.                                            vbase, vskip, vcount, skip, count)))

  222.             Abort();

  223.         break;

  224.     case MeshPrimitive::Lines:

  225.         if (FAILED(m_data->m_dev->DrawIndexedPrimitive(D3DPT_LINELIST,

  226.                                            vbase, vskip, vcount, skip, count)))

  227.             Abort();

  228.         break;

  229.     }

  230. #else

  231.     /* FIXME: this has nothing to do here! */

  232.     switch (type.ToScalar())

  233.     {

  234.     case MeshPrimitive::Triangles:

  235.         /* FIXME: ignores most of the arguments! */

  236.         UNUSED(vbase, vskip, vcount, skip);

  237.         glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, 0);

  238.         break;

  239.     case MeshPrimitive::TriangleStrips:

  240.         /* FIXME: ignores most of the arguments! */

  241.         UNUSED(vbase, vskip, vcount, skip);

  242.         glDrawElements(GL_TRIANGLE_STRIP, count, GL_UNSIGNED_SHORT, 0);

  243.         break;

  244.     case MeshPrimitive::TriangleFans:

  245.         /* FIXME: ignores most of the arguments! */

  246.         UNUSED(vbase, vskip, vcount, skip);

  247.         glDrawElements(GL_TRIANGLE_FAN, count, GL_UNSIGNED_SHORT, 0);

  248.         break;

  249.     case MeshPrimitive::Points:

  250.         /* FIXME: ignores most of the arguments! */

  251.         UNUSED(vbase, vskip, vcount, skip);

  252.         glDrawElements(GL_POINTS, count, GL_UNSIGNED_SHORT, 0);

  253.         break;

  254.     case MeshPrimitive::Lines:

  255.         /* FIXME: ignores most of the arguments! */

  256.         UNUSED(vbase, vskip, vcount, skip);

  257.         glDrawElements(GL_LINES, count, GL_UNSIGNED_SHORT, 0);

  258.         break;

  259.     }

  260. #endif

  261. }

  262. 

  263. void VertexDeclaration::Unbind()

  264. {

  265. #if defined _XBOX || defined USE_D3D9

  266.     int stream = -1;

  267.     for (int i = 0; i < m_count; i++)

  268.         if (m_streams[i].index != stream)

  269.         {

  270.             stream = m_streams[i].index;

  271.             if (FAILED(m_data->m_dev->SetStreamSource(stream, 0, 0, 0)))

  272.                 Abort();

  273.         }

  274.     /* "NULL is an invalid input to SetVertexDeclaration" (DX9 guide), so

  275.      * we just don't touch the current vertex declaration. */

  276. #elif !defined __CELLOS_LV2__

  277.     for (int i = 0; i < m_count; i++)

  278.     {

  279.         if (m_streams[i].reg >= 0)

  280.         {

  281.             for (int j = i + 1; j < m_count; j++)

  282.                 if (m_streams[j].reg == m_streams[i].reg)

  283.                     m_streams[j].reg = -1;

  284. 

  285.             glDisableVertexAttribArray(m_streams[i].reg);

  286.         }

  287.     }

  288.     glBindBuffer(GL_ARRAY_BUFFER, 0);

  289. #else

  290.     /* Or even: */

  291.     glDisableClientState(GL_VERTEX_ARRAY);

  292.     glDisableClientState(GL_TEXTURE_COORD_ARRAY);

  293.     glDisableClientState(GL_NORMAL_ARRAY);

  294.     glDisableClientState(GL_COLOR_ARRAY);

  295. #endif

  296. }

  297. 

  298. void VertexDeclaration::SetStream(VertexBuffer *vb, ShaderAttrib attr1,

  299.                                                     ShaderAttrib attr2,

  300.                                                     ShaderAttrib attr3,

  301.                                                     ShaderAttrib attr4,

  302.                                                     ShaderAttrib attr5,

  303.                                                     ShaderAttrib attr6,

  304.                                                     ShaderAttrib attr7,

  305.                                                     ShaderAttrib attr8,

  306.                                                     ShaderAttrib attr9,

  307.                                                     ShaderAttrib attr10,

  308.                                                     ShaderAttrib attr11,

  309.                                                     ShaderAttrib attr12)

  310. {

  311. #if defined _XBOX || defined USE_D3D9

  312.     // Don't bother in DirectX world, shader attributes are not used

  313.     SetStream(vb, nullptr);

  314. #else

  315.     ShaderAttrib attribs[12] = { attr1, attr2, attr3, attr4, attr5, attr6,

  316.                            attr7, attr8, attr9, attr10, attr11, attr12 };

  317. 

  318.     SetStream(vb, attribs);

  319. #endif

  320. }

  321. 

  322. void VertexDeclaration::SetStream(VertexBuffer *vb, ShaderAttrib attribs[])

  323. {

  324.     if (!vb->m_data->m_size)

  325.         return;

  326. 

  327. #if defined _XBOX || defined USE_D3D9

  328.     /* Only the first item is required to know which stream this

  329.      * is about; the rest of the information is stored in the

  330.      * vertex declaration already. */

  331.     VertexUsage usage = VertexUsage((attr1.m_flags >> 16) & 0xffff);

  332.     uint32_t index = attr1.m_flags & 0xffff;

  333. 

  334.     /* Find the stream number */

  335.     uint32_t usage_index = 0;

  336.     int stream = -1;

  337.     for (int i = 0; i < m_count; i++)

  338.         if (m_streams[i].usage == usage)

  339.             if (usage_index++ == index)

  340.             {

  341.                 stream = m_streams[i].index;

  342.                 break;

  343.             }

  344. 

  345.     /* Compute this stream's stride */

  346.     int stride = 0;

  347.     for (int i = 0; i < m_count; i++)

  348.         if (stream == m_streams[i].index)

  349.             stride += m_streams[i].size;

  350. 

  351.     /* Now we know the stream index and the element stride */

  352.     /* FIXME: precompute most of the crap above! */

  353.     if (stream >= 0)

  354.     {

  355.         if (FAILED(m_data->m_dev->SetStreamSource(stream, vb->m_data->m_vbo,

  356.                                                   0, stride)))

  357.             Abort();

  358.     }

  359. #else

  360.     glBindBuffer(GL_ARRAY_BUFFER, vb->m_data->m_vbo);

  361.     for (int n = 0; n < 12 && attribs[n].m_flags != (uint64_t)0 - 1; n++)

  362.     {

  363.         VertexUsage usage = VertexUsage((attribs[n].m_flags >> 16) & 0xffff);

  364.         uint32_t index = attribs[n].m_flags & 0xffff;

  365.         uint32_t reg = attribs[n].m_flags >> 32;

  366. 

  367. #   if !defined __CELLOS_LV2__

  368.         if (reg != 0xffffffffu)

  369.             glEnableVertexAttribArray((GLint)reg);

  370. #   else

  371.         switch (usage.ToScalar())

  372.         {

  373.         case VertexUsage::Position:

  374.             glEnableClientState(GL_VERTEX_ARRAY);

  375.             break;

  376.         case VertexUsage::TexCoord:

  377.         case VertexUsage::TexCoordExt:

  378.             glEnableClientState(GL_TEXTURE_COORD_ARRAY);

  379.             break;

  380.         case VertexUsage::Normal:

  381.             glEnableClientState(GL_NORMAL_ARRAY);

  382.             break;

  383.         case VertexUsage::Color:

  384.             glEnableClientState(GL_COLOR_ARRAY);

  385.             break;

  386.         }

  387. #   endif

  388. 

  389.         /* We need to parse the whole vertex declaration to retrieve

  390.          * the information. It sucks. */

  391. 

  392.         int attr_index = 0;

  393.         /* First, find the stream index */

  394.         for (uint32_t usage_index = 0; attr_index < m_count; attr_index++)

  395.             if (m_streams[attr_index].usage == usage)

  396.                 if (usage_index++ == index)

  397.                     break;

  398. 

  399.         if (attr_index == m_count)

  400.         {

  401.             Log::Error("stream #%d with usage %x not found in declaration\n",

  402.                        index, usage);

  403.             attr_index = 0;

  404.         }

  405. 

  406.         /* Now compute the stride and offset up to this stream index */

  407.         int stride = 0, offset = 0;

  408.         for (int i = 0; i < m_count; i++)

  409.             if (m_streams[i].index == m_streams[attr_index].index)

  410.             {

  411.                 /* Remember the register used for this stream */

  412.                 m_streams[i].reg = reg;

  413. 

  414.                 stride += m_streams[i].size;

  415.                 if (i < attr_index)

  416.                     offset += m_streams[i].size;

  417.             }

  418. 

  419.         /* Finally, we need to retrieve the type of the data */

  420. #   if !defined GL_DOUBLE

  421. #       define GL_DOUBLE 0

  422. #   endif

  423.         static struct { GLint size; GLenum type; } const tlut[] =

  424.         {

  425.             { 0, 0 },

  426.             { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, /* half */

  427.             { 1, GL_FLOAT }, { 2, GL_FLOAT }, { 3, GL_FLOAT },

  428.                 { 4, GL_FLOAT }, /* float */

  429.             { 1, GL_DOUBLE }, { 2, GL_DOUBLE }, { 3, GL_DOUBLE },

  430.                 { 4, GL_DOUBLE }, /* double */

  431.             { 1, GL_BYTE }, { 2, GL_BYTE }, { 3, GL_BYTE },

  432.                 { 4, GL_BYTE }, /* int8_t */

  433.             { 1, GL_UNSIGNED_BYTE }, { 2, GL_UNSIGNED_BYTE },

  434.                 { 3, GL_UNSIGNED_BYTE }, { 4, GL_UNSIGNED_BYTE }, /* uint8_t */

  435.             { 1, GL_SHORT }, { 2, GL_SHORT }, { 3, GL_SHORT },

  436.                 { 4, GL_SHORT }, /* int16_t */

  437.             { 1, GL_UNSIGNED_SHORT }, { 2, GL_UNSIGNED_SHORT }, { 3,

  438.                 GL_UNSIGNED_SHORT }, { 4, GL_UNSIGNED_SHORT }, /* uint16_t */

  439.             { 1, GL_INT }, { 2, GL_INT }, { 3, GL_INT },

  440.                 { 4, GL_INT }, /* int32_t */

  441.             { 1, GL_UNSIGNED_INT }, { 2, GL_UNSIGNED_INT },

  442.                 { 3, GL_UNSIGNED_INT }, { 4, GL_UNSIGNED_INT }, /* uint32_t */

  443.         };

  444. 

  445.         int type_index = m_streams[attr_index].stream_type;

  446.         if (type_index < 0 || type_index >= (int)(sizeof(tlut) / sizeof(*tlut)))

  447.             type_index = 0;

  448. 

  449. 

  450. #   if !defined __CELLOS_LV2__

  451.         if (reg != 0xffffffff)

  452.         {

  453.             if (tlut[type_index].type == GL_FLOAT

  454.                  || tlut[type_index].type == GL_DOUBLE

  455.                  || tlut[type_index].type == GL_BYTE

  456.                  || tlut[type_index].type == GL_UNSIGNED_BYTE

  457. #       if defined USE_GLEW && !defined __APPLE__

  458.                  /* If this is not available, don't use it */

  459.                  || !glVertexAttribIPointer

  460. #       endif

  461.                  || false)

  462.             {

  463.                 /* Normalize unsigned bytes by default, because it's usually

  464.                  * some color information. */

  465.                 GLboolean normalize = (tlut[type_index].type == GL_UNSIGNED_BYTE)

  466.                                    || (tlut[type_index].type == GL_BYTE);

  467.                 glVertexAttribPointer((GLint)reg, tlut[type_index].size,

  468.                                       tlut[type_index].type, normalize,

  469.                                       stride, (GLvoid const *)(uintptr_t)offset);

  470.             }

  471. #       if defined GL_VERSION_3_0

  472.             else

  473.             {

  474.                 glVertexAttribIPointer((GLint)reg, tlut[type_index].size,

  475.                                        tlut[type_index].type,

  476.                                        stride, (GLvoid const *)(uintptr_t)offset);

  477.             }

  478. #       endif

  479.         }

  480. #   else

  481.         switch (usage)

  482.         {

  483.         case VertexUsage::Position:

  484.             glVertexPointer(tlut[type_index].size, tlut[type_index].type,

  485.                             stride, (GLvoid const *)(uintptr_t)offset);

  486.             break;

  487.         case VertexUsage::TexCoord:

  488.         case VertexUsage::TexCoordExt:

  489.             glTexCoordPointer(tlut[type_index].size, tlut[type_index].type,

  490.                               stride, (GLvoid const *)(uintptr_t)offset);

  491.             break;

  492.         case VertexUsage::Normal:

  493.             glNormalPointer(tlut[type_index].type,

  494.                             stride, (GLvoid const *)(uintptr_t)offset);

  495.             break;

  496.         case VertexUsage::Color:

  497.             glColorPointer(tlut[type_index].size, tlut[type_index].type,

  498.                            stride, (GLvoid const *)(uintptr_t)offset);

  499.             break;

  500.         default:

  501.             Log::Error("vertex usage %d is not supported yet\n", usage);

  502.             break;

  503.         }

  504. #   endif

  505.     }

  506. #endif

  507. }

  508. 

  509. void VertexDeclaration::Initialize()

  510. {

  511. #if defined _XBOX || defined USE_D3D9

  512.     static D3DVERTEXELEMENT9 const end_element[] = { D3DDECL_END() };

  513.     static D3DDECLTYPE const X = D3DDECLTYPE_UNUSED;

  514.     static D3DDECLTYPE const tlut[] =

  515.     {

  516.         D3DDECLTYPE_UNUSED,

  517.         X, D3DDECLTYPE_FLOAT16_2, X, D3DDECLTYPE_FLOAT16_4, /* half */

  518.         D3DDECLTYPE_FLOAT1, D3DDECLTYPE_FLOAT2, D3DDECLTYPE_FLOAT3,

  519.             D3DDECLTYPE_FLOAT4, /* float */

  520.         X, X, X, X, /* double */

  521.         X, X, X, X, /* int8_t */

  522.         X, X, X, D3DDECLTYPE_UBYTE4N, /* uint8_t */

  523.         X, D3DDECLTYPE_SHORT2N, X, D3DDECLTYPE_SHORT4N, /* int16_t */

  524.         X, D3DDECLTYPE_USHORT2N, X, D3DDECLTYPE_USHORT4N, /* uint16_t */

  525.         X, X, X, X, /* int32_t */

  526.         X, X, X, X, /* uint32_t */

  527.     };

  528.     static D3DDECLUSAGE const ulut[] =

  529.     {

  530.         D3DDECLUSAGE_POSITION,

  531.         D3DDECLUSAGE_BLENDWEIGHT,

  532.         D3DDECLUSAGE_BLENDINDICES,

  533.         D3DDECLUSAGE_NORMAL,

  534.         D3DDECLUSAGE_PSIZE,

  535.         D3DDECLUSAGE_TEXCOORD,

  536.         D3DDECLUSAGE_TANGENT,

  537.         D3DDECLUSAGE_BINORMAL,

  538.         D3DDECLUSAGE_TESSFACTOR,

  539. #if defined _XBOX

  540.         D3DDECLUSAGE_TEXCOORD, /* FIXME: nonexistent */

  541. #else

  542.         D3DDECLUSAGE_POSITIONT,

  543. #endif

  544.         D3DDECLUSAGE_COLOR,

  545.         D3DDECLUSAGE_FOG,

  546.         D3DDECLUSAGE_DEPTH,

  547.         D3DDECLUSAGE_SAMPLE,

  548.     };

  549. 

  550.     D3DVERTEXELEMENT9 elements[12 + 1];

  551.     for (int n = 0; n < m_count; n++)

  552.     {

  553.         elements[n].Stream = m_streams[n].index;

  554.         elements[n].Offset = 0;

  555.         for (int i = 0; i < n; i++)

  556.             if (m_streams[i].index == m_streams[n].index)

  557.                 elements[n].Offset += m_streams[i].size;

  558. 

  559.         if (m_streams[n].stream_type >= 0

  560.              && m_streams[n].stream_type < sizeof(tlut) / sizeof(*tlut))

  561.             elements[n].Type = tlut[m_streams[n].stream_type];

  562.         else

  563.             elements[n].Type = D3DDECLTYPE_UNUSED;

  564. 

  565.         elements[n].Method = D3DDECLMETHOD_DEFAULT;

  566. 

  567.         if (m_streams[n].usage >= 0

  568.              && m_streams[n].usage < sizeof(ulut) / sizeof(*ulut))

  569.             elements[n].Usage = ulut[m_streams[n].usage];

  570.         else

  571.             elements[n].Usage = D3DDECLUSAGE_POSITION;

  572. 

  573.         elements[n].UsageIndex = 0;

  574.         for (int i = 0; i < n; i++)

  575.             if (elements[i].Stream == elements[n].Stream

  576.                  && elements[i].Usage == elements[n].Usage)

  577.                 elements[n].UsageIndex++;

  578.     }

  579.     elements[m_count] = end_element[0];

  580. 

  581. #   if defined USE_D3D9

  582.     m_data->m_dev = (IDirect3DDevice9 *)g_renderer->GetDevice();

  583. #   elif defined _XBOX

  584.     m_data->m_dev = (D3DDevice *)g_renderer->GetDevice();

  585. #   endif

  586. 

  587.     if (FAILED(m_data->m_dev->CreateVertexDeclaration(elements,

  588.                                                       &m_data->m_vdecl)))

  589.         Abort();

  590. #else

  591. 

  592. #endif

  593. }

  594. 

  595. void VertexDeclaration::AddStream(VertexStreamBase const &s)

  596. {

  597.     int index = m_count ? m_streams[m_count - 1].index + 1 : 0;

  598. 

  599.     for (int i = 0; s.m_streams[i].size; i++)

  600.     {

  601.         m_streams[m_count].stream_type = s.m_streams[i].stream_type;

  602.         m_streams[m_count].usage = s.m_streams[i].usage;

  603.         m_streams[m_count].size = s.m_streams[i].size;

  604.         m_streams[m_count].index = index;

  605.         m_streams[m_count].reg = -1;

  606.         m_count++;

  607.     }

  608. }

  609. 

  610. int VertexDeclaration::GetStreamCount() const

  611. {

  612.     return m_count ? m_streams[m_count - 1].index + 1 : 0;

  613. }

  614. 

  615. VertexStreamBase VertexDeclaration::GetStream(int index) const

  616. {

  617.     VertexStreamBase stream;

  618.     int n = 0;

  619.     int count = 0;

  620. 

  621.     for (int i = 0; i < m_count; ++i)

  622.     {

  623.         if (m_streams[i].index != index)

  624.             continue;

  625. 

  626.         switch (m_streams[i].stream_type)

  627.         {

  628. #define __T(T) \

  629.             case VertexStreamBase::Type##T: stream.AddStream<T>(n++, m_streams[i].usage); break;

  630. 

  631.             __T(void)

  632. #if LOL_FEATURE_CXX11_UNRESTRICTED_UNIONS

  633.             __T(half)     __T(f16vec2) __T(f16vec3) __T(f16vec4)

  634. #endif

  635.             __T(float)    __T(vec2)    __T(vec3)    __T(vec4)

  636.             __T(double)   __T(dvec2)   __T(dvec3)   __T(dvec4)

  637.             __T(int8_t)   __T(i8vec2)  __T(i8vec3)  __T(i8vec4)

  638.             __T(uint8_t)  __T(u8vec2)  __T(u8vec3)  __T(u8vec4)

  639.             __T(int16_t)  __T(i16vec2) __T(i16vec3) __T(i16vec4)

  640.             __T(uint16_t) __T(u16vec2) __T(u16vec3) __T(u16vec4)

  641.             __T(int32_t)  __T(ivec2)   __T(ivec3)   __T(ivec4)

  642.             __T(uint32_t) __T(uvec2)   __T(uvec3)   __T(uvec4)

  643. #undef __T

  644.         }

  645.         ++count;

  646.     }

  647. 

  648.     while (count < 12)

  649.         stream.AddStream<void>(count++, VertexUsage::Position);

  650. 

  651.     return stream;

  652. }

  653. 

  654. //

  655. // The VertexBuffer class

  656. // ----------------------

  657. //

  658. 

  659. VertexBuffer::VertexBuffer(size_t size)

  660.   : m_data(new VertexBufferData)

  661. {

  662.     m_data->m_size = size;

  663.     if (!size)

  664.         return;

  665. #if defined USE_D3D9 || defined _XBOX

  666. #   if defined USE_D3D9

  667.     m_data->m_dev = (IDirect3DDevice9 *)g_renderer->GetDevice();

  668. #   elif defined _XBOX

  669.     m_data->m_dev = (D3DDevice *)g_renderer->GetDevice();

  670. #   endif

  671. 

  672.     if (FAILED(m_data->m_dev->CreateVertexBuffer(size, D3DUSAGE_WRITEONLY, nullptr,

  673.                                                D3DPOOL_MANAGED, &m_data->m_vbo, nullptr)))

  674.         Abort();

  675. #else

  676.     glGenBuffers(1, &m_data->m_vbo);

  677.     m_data->m_memory = new uint8_t[size];

  678. #endif

  679. }

  680. 

  681. VertexBuffer::~VertexBuffer()

  682. {

  683.     if (m_data->m_size)

  684.     {

  685. #if defined USE_D3D9 || defined _XBOX

  686.         if (FAILED(m_data->m_vbo->Release()))

  687.             Abort();

  688. #else

  689.         glDeleteBuffers(1, &m_data->m_vbo);

  690.         delete[] m_data->m_memory;

  691. #endif

  692.     }

  693.     delete m_data;

  694. }

  695. 

  696. size_t VertexBuffer::GetSize()

  697. {

  698.     return m_data->m_size;

  699. }

  700. 

  701. void *VertexBuffer::Lock(size_t offset, size_t size)

  702. {

  703.     if (!m_data->m_size)

  704.         return nullptr;

  705. #if defined USE_D3D9 || defined _XBOX

  706.     void *ret;

  707.     if (FAILED(m_data->m_vbo->Lock(offset, size, (void **)&ret, 0)))

  708.         Abort();

  709.     return ret;

  710. #else

  711.     /* FIXME: is there a way to use "size"? */

  712.     UNUSED(size);

  713.     return m_data->m_memory + offset;

  714. #endif

  715. }

  716. 

  717. void VertexBuffer::Unlock()

  718. {

  719.     if (!m_data->m_size)

  720.         return;

  721. #if defined USE_D3D9 || defined _XBOX

  722.     if (FAILED(m_data->m_vbo->Unlock()))

  723.         Abort();

  724. #else

  725.     glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo);

  726.     glBufferData(GL_ARRAY_BUFFER, m_data->m_size, m_data->m_memory,

  727.                  GL_STATIC_DRAW);

  728.     glBindBuffer(GL_ARRAY_BUFFER, 0);

  729. #endif

  730. }

  731. 

  732. } /* namespace lol */