lolengine
/
lol
peilaus alkaen https://github.com/lolengine/lol
1
0
Fork 0
Koodi Ongelmat 0 Julkaisut 0 Wiki Toiminta
2180 Commitit
5 Branchit
521 MiB
 
 
 
Puu: fe665f85b4
lol/src/gpu/vertexbuffer.cpp

734 rivejä
23 KiB
Raaka Blame Historia 

  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. using namespace std;

  29. 

  30. namespace lol

  31. {

  32. 

  33. //

  34. // The VertexBufferData class

  35. // --------------------------

  36. //

  37. 

  38. class VertexBufferData

  39. {

  40.     friend class VertexBuffer;

  41.     friend class VertexDeclaration;

  42. 

  43.     size_t m_size;

  44. 

  45. #if defined USE_D3D9

  46.     IDirect3DDevice9 *m_dev;

  47.     IDirect3DVertexBuffer9 *m_vbo;

  48. #elif defined _XBOX

  49.     D3DDevice *m_dev;

  50.     D3DVertexBuffer *m_vbo;

  51. #else

  52.     GLuint m_vbo;

  53.     uint8_t *m_memory;

  54. #endif

  55. };

  56. 

  57. //

  58. // The VertexDeclarationData class

  59. // -------------------------------

  60. //

  61. 

  62. class VertexDeclarationData

  63. {

  64.     friend class VertexBuffer;

  65.     friend class VertexDeclaration;

  66. 

  67. #if defined USE_D3D9

  68.     IDirect3DDevice9 *m_dev;

  69.     IDirect3DVertexDeclaration9 *m_vdecl;

  70. #elif defined _XBOX

  71.     D3DDevice *m_dev;

  72.     D3DVertexDeclaration *m_vdecl;

  73. #else

  74. #endif

  75. };

  76. 

  77. //

  78. // The VertexDeclaration class

  79. // ---------------------------

  80. //

  81. 

  82. VertexStreamBase const VertexStreamBase::Empty;

  83. 

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

  85.                                      VertexStreamBase const &s2,

  86.                                      VertexStreamBase const &s3,

  87.                                      VertexStreamBase const &s4,

  88.                                      VertexStreamBase const &s5,

  89.                                      VertexStreamBase const &s6,

  90.                                      VertexStreamBase const &s7,

  91.                                      VertexStreamBase const &s8,

  92.                                      VertexStreamBase const &s9,

  93.                                      VertexStreamBase const &s10,

  94.                                      VertexStreamBase const &s11,

  95.                                      VertexStreamBase const &s12)

  96.   : m_count(0),

  97.     m_data(new VertexDeclarationData())

  98. {

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

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

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

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

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

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

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

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

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

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

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

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

  111.     Initialize();

  112. }

  113. 

  114. VertexDeclaration::~VertexDeclaration()

  115. {

  116. #if defined _XBOX || defined USE_D3D9

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

  118.         Abort();

  119. #else

  120. 

  121. #endif

  122. 

  123.     delete m_data;

  124. }

  125. 

  126. void VertexDeclaration::Bind()

  127. {

  128. #if defined _XBOX || defined USE_D3D9

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

  130.         Abort();

  131. #else

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

  133. #endif

  134. }

  135. 

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

  137. {

  138.     if (count <= 0)

  139.         return;

  140. 

  141. #if defined _XBOX || defined USE_D3D9

  142.     switch (type.ToScalar())

  143.     {

  144.     case MeshPrimitive::Triangles:

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

  146.                                                 skip, count)))

  147.             Abort();

  148.         break;

  149.     case MeshPrimitive::TriangleStrips:

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

  151.                                                 skip, count)))

  152.             Abort();

  153.         break;

  154.     case MeshPrimitive::TriangleFans:

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

  156.                                                 skip, count)))

  157.             Abort();

  158.         break;

  159.     case MeshPrimitive::Points:

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

  161.                                                 skip, count)))

  162.             Abort();

  163.         break;

  164.     case MeshPrimitive::Lines:

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

  166.                                                 skip, count)))

  167.             Abort();

  168.         break;

  169.     }

  170. #else

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

  172.     switch (type.ToScalar())

  173.     {

  174.     case MeshPrimitive::Triangles:

  175.         glDrawArrays(GL_TRIANGLES, skip, count);

  176.         break;

  177.     case MeshPrimitive::TriangleStrips:

  178.         glDrawArrays(GL_TRIANGLE_STRIP, skip, count);

  179.         break;

  180.     case MeshPrimitive::TriangleFans:

  181.         glDrawArrays(GL_TRIANGLE_FAN, skip, count);

  182.         break;

  183.     case MeshPrimitive::Points:

  184.         glDrawArrays(GL_POINTS, skip, count);

  185.         break;

  186.     case MeshPrimitive::Lines:

  187.         glDrawArrays(GL_LINES, skip, count);

  188.         break;

  189.     }

  190. #endif

  191. }

  192. 

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

  194.                                             int vskip, int vcount,

  195.                                             int skip, int count)

  196. {

  197.     if (count <= 0)

  198.         return;

  199. 

  200. #if defined _XBOX || defined USE_D3D9

  201.     switch (type.ToScalar())

  202.     {

  203.     case MeshPrimitive::Triangles:

  204.         count = count / 3;

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

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

  207.             Abort();

  208.         break;

  209.     case MeshPrimitive::TriangleStrips:

  210.         count = count - 2;

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

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

  213.             Abort();

  214.         break;

  215.     case MeshPrimitive::TriangleFans:

  216.         count = count - 2;

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

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

  219.             Abort();

  220.         break;

  221.     case MeshPrimitive::Points:

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

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

  224.             Abort();

  225.         break;

  226.     case MeshPrimitive::Lines:

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

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

  229.             Abort();

  230.         break;

  231.     }

  232. #else

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

  234.     switch (type.ToScalar())

  235.     {

  236.     case MeshPrimitive::Triangles:

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

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

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

  240.         break;

  241.     case MeshPrimitive::TriangleStrips:

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

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

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

  245.         break;

  246.     case MeshPrimitive::TriangleFans:

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

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

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

  250.         break;

  251.     case MeshPrimitive::Points:

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

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

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

  255.         break;

  256.     case MeshPrimitive::Lines:

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

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

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

  260.         break;

  261.     }

  262. #endif

  263. }

  264. 

  265. void VertexDeclaration::Unbind()

  266. {

  267. #if defined _XBOX || defined USE_D3D9

  268.     int stream = -1;

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

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

  271.         {

  272.             stream = m_streams[i].index;

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

  274.                 Abort();

  275.         }

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

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

  278. #elif !defined __CELLOS_LV2__

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

  280.     {

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

  282.         {

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

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

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

  286. 

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

  288.         }

  289.     }

  290.     glBindBuffer(GL_ARRAY_BUFFER, 0);

  291. #else

  292.     /* Or even: */

  293.     glDisableClientState(GL_VERTEX_ARRAY);

  294.     glDisableClientState(GL_TEXTURE_COORD_ARRAY);

  295.     glDisableClientState(GL_NORMAL_ARRAY);

  296.     glDisableClientState(GL_COLOR_ARRAY);

  297. #endif

  298. }

  299. 

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

  301.                                                     ShaderAttrib attr2,

  302.                                                     ShaderAttrib attr3,

  303.                                                     ShaderAttrib attr4,

  304.                                                     ShaderAttrib attr5,

  305.                                                     ShaderAttrib attr6,

  306.                                                     ShaderAttrib attr7,

  307.                                                     ShaderAttrib attr8,

  308.                                                     ShaderAttrib attr9,

  309.                                                     ShaderAttrib attr10,

  310.                                                     ShaderAttrib attr11,

  311.                                                     ShaderAttrib attr12)

  312. {

  313. #if defined _XBOX || defined USE_D3D9

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

  315.     SetStream(vb, NULL);

  316. #else

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

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

  319. 

  320.     SetStream(vb, attribs);

  321. #endif

  322. }

  323. 

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

  325. {

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

  327.         return;

  328. 

  329. #if defined _XBOX || defined USE_D3D9

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

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

  332.      * vertex declaration already. */

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

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

  335. 

  336.     /* Find the stream number */

  337.     uint32_t usage_index = 0;

  338.     int stream = -1;

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

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

  341.             if (usage_index++ == index)

  342.             {

  343.                 stream = m_streams[i].index;

  344.                 break;

  345.             }

  346. 

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

  348.     int stride = 0;

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

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

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

  352. 

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

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

  355.     if (stream >= 0)

  356.     {

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

  358.                                                   0, stride)))

  359.             Abort();

  360.     }

  361. #else

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

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

  364.     {

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

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

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

  368. 

  369. #   if !defined __CELLOS_LV2__

  370.         if (reg != 0xffffffffu)

  371.             glEnableVertexAttribArray((GLint)reg);

  372. #   else

  373.         switch (usage.ToScalar())

  374.         {

  375.         case VertexUsage::Position:

  376.             glEnableClientState(GL_VERTEX_ARRAY);

  377.             break;

  378.         case VertexUsage::TexCoord:

  379.         case VertexUsage::TexCoordExt:

  380.             glEnableClientState(GL_TEXTURE_COORD_ARRAY);

  381.             break;

  382.         case VertexUsage::Normal:

  383.             glEnableClientState(GL_NORMAL_ARRAY);

  384.             break;

  385.         case VertexUsage::Color:

  386.             glEnableClientState(GL_COLOR_ARRAY);

  387.             break;

  388.         }

  389. #   endif

  390. 

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

  392.          * the information. It sucks. */

  393. 

  394.         int attr_index = 0;

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

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

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

  398.                 if (usage_index++ == index)

  399.                     break;

  400. 

  401.         if (attr_index == m_count)

  402.         {

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

  404.                        index, usage);

  405.             attr_index = 0;

  406.         }

  407. 

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

  409.         int stride = 0, offset = 0;

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

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

  412.             {

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

  414.                 m_streams[i].reg = reg;

  415. 

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

  417.                 if (i < attr_index)

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

  419.             }

  420. 

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

  422. #   if !defined GL_DOUBLE

  423. #       define GL_DOUBLE 0

  424. #   endif

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

  426.         {

  427.             { 0, 0 },

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

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

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

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

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

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

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

  435.             { 1, GL_UNSIGNED_BYTE }, { 2, GL_UNSIGNED_BYTE },

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

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

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

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

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

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

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

  443.             { 1, GL_UNSIGNED_INT }, { 2, GL_UNSIGNED_INT },

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

  445.         };

  446. 

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

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

  449.             type_index = 0;

  450. 

  451. 

  452. #   if !defined __CELLOS_LV2__

  453.         if (reg != 0xffffffff)

  454.         {

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

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

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

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

  459. #       if defined USE_GLEW && !defined __APPLE__

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

  461.                  || !glVertexAttribIPointer

  462. #       endif

  463.                  || false)

  464.             {

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

  466.                  * some color information. */

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

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

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

  470.                                       tlut[type_index].type, normalize,

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

  472.             }

  473. #       if defined GL_VERSION_3_0

  474.             else

  475.             {

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

  477.                                        tlut[type_index].type,

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

  479.             }

  480. #       endif

  481.         }

  482. #   else

  483.         switch (usage)

  484.         {

  485.         case VertexUsage::Position:

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

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

  488.             break;

  489.         case VertexUsage::TexCoord:

  490.         case VertexUsage::TexCoordExt:

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

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

  493.             break;

  494.         case VertexUsage::Normal:

  495.             glNormalPointer(tlut[type_index].type,

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

  497.             break;

  498.         case VertexUsage::Color:

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

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

  501.             break;

  502.         default:

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

  504.             break;

  505.         }

  506. #   endif

  507.     }

  508. #endif

  509. }

  510. 

  511. void VertexDeclaration::Initialize()

  512. {

  513. #if defined _XBOX || defined USE_D3D9

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

  515.     static D3DDECLTYPE const X = D3DDECLTYPE_UNUSED;

  516.     static D3DDECLTYPE const tlut[] =

  517.     {

  518.         D3DDECLTYPE_UNUSED,

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

  520.         D3DDECLTYPE_FLOAT1, D3DDECLTYPE_FLOAT2, D3DDECLTYPE_FLOAT3,

  521.             D3DDECLTYPE_FLOAT4, /* float */

  522.         X, X, X, X, /* double */

  523.         X, X, X, X, /* int8_t */

  524.         X, X, X, D3DDECLTYPE_UBYTE4N, /* uint8_t */

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

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

  527.         X, X, X, X, /* int32_t */

  528.         X, X, X, X, /* uint32_t */

  529.     };

  530.     static D3DDECLUSAGE const ulut[] =

  531.     {

  532.         D3DDECLUSAGE_POSITION,

  533.         D3DDECLUSAGE_BLENDWEIGHT,

  534.         D3DDECLUSAGE_BLENDINDICES,

  535.         D3DDECLUSAGE_NORMAL,

  536.         D3DDECLUSAGE_PSIZE,

  537.         D3DDECLUSAGE_TEXCOORD,

  538.         D3DDECLUSAGE_TANGENT,

  539.         D3DDECLUSAGE_BINORMAL,

  540.         D3DDECLUSAGE_TESSFACTOR,

  541. #if defined _XBOX

  542.         D3DDECLUSAGE_TEXCOORD, /* FIXME: nonexistent */

  543. #else

  544.         D3DDECLUSAGE_POSITIONT,

  545. #endif

  546.         D3DDECLUSAGE_COLOR,

  547.         D3DDECLUSAGE_FOG,

  548.         D3DDECLUSAGE_DEPTH,

  549.         D3DDECLUSAGE_SAMPLE,

  550.     };

  551. 

  552.     D3DVERTEXELEMENT9 elements[12 + 1];

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

  554.     {

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

  556.         elements[n].Offset = 0;

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

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

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

  560. 

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

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

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

  564.         else

  565.             elements[n].Type = D3DDECLTYPE_UNUSED;

  566. 

  567.         elements[n].Method = D3DDECLMETHOD_DEFAULT;

  568. 

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

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

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

  572.         else

  573.             elements[n].Usage = D3DDECLUSAGE_POSITION;

  574. 

  575.         elements[n].UsageIndex = 0;

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

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

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

  579.                 elements[n].UsageIndex++;

  580.     }

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

  582. 

  583. #   if defined USE_D3D9

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

  585. #   elif defined _XBOX

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

  587. #   endif

  588. 

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

  590.                                                       &m_data->m_vdecl)))

  591.         Abort();

  592. #else

  593. 

  594. #endif

  595. }

  596. 

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

  598. {

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

  600. 

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

  602.     {

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

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

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

  606.         m_streams[m_count].index = index;

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

  608.         m_count++;

  609.     }

  610. }

  611. 

  612. int VertexDeclaration::GetStreamCount() const

  613. {

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

  615. }

  616. 

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

  618. {

  619.     VertexStreamBase stream;

  620.     int n = 0;

  621.     int count = 0;

  622. 

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

  624.     {

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

  626.             continue;

  627. 

  628.         switch (m_streams[i].stream_type)

  629.         {

  630. #define __T(T) \

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

  632. 

  633.             __T(void)

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

  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 */