lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
1482 Commits
5 Branches
27 MiB
 
 
 
Tree: 2b1932b325
lol/src/easymesh/easymesh.cpp

2352 lines
86 KiB
Raw Blame History 

  1. //

  2. // Lol Engine

  3. //

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

  5. //            (c) 2009-2013 Cédric Lecacheur <jordx@free.fr>

  6. //            (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com>

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

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

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

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

  11. //

  12. 

  13. //

  14. // The EasyMesh class

  15. // ------------------

  16. //

  17. 

  18. #if defined HAVE_CONFIG_H

  19. #   include "config.h"

  20. #endif

  21. 

  22. #if defined _XBOX

  23. #   define _USE_MATH_DEFINES /* for M_PI */

  24. #   include <xtl.h>

  25. #   undef near /* Fuck Microsoft */

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

  27. #elif defined _WIN32

  28. #   define _USE_MATH_DEFINES /* for M_PI */

  29. #   define WIN32_LEAN_AND_MEAN

  30. #   include <windows.h>

  31. #   undef near /* Fuck Microsoft */

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

  33. #endif

  34. 

  35. #include "core.h"

  36. #include "easymesh/easymesh-compiler.h"

  37. 

  38. LOLFX_RESOURCE_DECLARE(shiny);

  39. LOLFX_RESOURCE_DECLARE(shinydebugwireframe);

  40. LOLFX_RESOURCE_DECLARE(shinydebuglighting);

  41. LOLFX_RESOURCE_DECLARE(shinydebugnormal);

  42. LOLFX_RESOURCE_DECLARE(shinydebugUV);

  43. LOLFX_RESOURCE_DECLARE(shiny_SK);

  44. 

  45. namespace lol

  46. {

  47. 

  48. 

  49. //-----------------------------------------------------------------------------

  50. GpuShaderData::GpuShaderData()

  51. {

  52.     m_render_mode = DebugRenderMode::Default;

  53. }

  54. 

  55. //-----------------------------------------------------------------------------

  56. GpuShaderData::GpuShaderData(uint16_t vert_decl_flags, Shader* shader, DebugRenderMode render_mode)

  57. {

  58.     m_render_mode = render_mode;

  59.     m_shader = shader;

  60.     m_vert_decl_flags = vert_decl_flags;

  61. }

  62. 

  63. //-----------------------------------------------------------------------------

  64. GpuShaderData::~GpuShaderData()

  65. {

  66.     m_shader_uniform.Empty();

  67.     m_shader_attrib.Empty();

  68. }

  69. 

  70. //-----------------------------------------------------------------------------

  71. void GpuShaderData::AddUniform(const lol::String &new_uniform)

  72. {

  73.     m_shader_uniform.Push(new_uniform, m_shader->GetUniformLocation(new_uniform.C()));

  74. }

  75. 

  76. //-----------------------------------------------------------------------------

  77. void GpuShaderData::AddAttribute(const lol::String &new_attribute, VertexUsage usage, int index)

  78. {

  79.     m_shader_attrib.Push(new_attribute, m_shader->GetAttribLocation(new_attribute.C(), usage, index));

  80. }

  81. 

  82. //-----------------------------------------------------------------------------

  83. ShaderUniform const *GpuShaderData::GetUniform(const lol::String &uniform)

  84. {

  85.     for (int i = 0; i < m_shader_uniform.Count(); ++i)

  86.         if (m_shader_uniform[i].m1 == uniform)

  87.             return &m_shader_uniform[i].m2;

  88.     return NULL;

  89. }

  90. 

  91. //-----------------------------------------------------------------------------

  92. ShaderAttrib const *GpuShaderData::GetAttribute(const lol::String &attribute)

  93. {

  94.     for (int i = 0; i < m_shader_attrib.Count(); ++i)

  95.         if (m_shader_attrib[i].m1 == attribute)

  96.             return &m_shader_attrib[i].m2;

  97.     return NULL;

  98. }

  99. 

  100. //-----------------------------------------------------------------------------

  101. DefaultShaderData::DefaultShaderData(DebugRenderMode render_mode)

  102. {

  103.     bool with_UV = false;

  104.     m_render_mode = render_mode;

  105.     m_vert_decl_flags = (1 << VertexUsage::Position) |

  106.                         (1 << VertexUsage::Normal)   |

  107.                         (1 << VertexUsage::Color);

  108. 

  109.     if (render_mode == DebugRenderMode::Default)

  110.         m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shiny));

  111.     else if (render_mode == DebugRenderMode::Wireframe)

  112.         m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinydebugwireframe));

  113.     else if (render_mode == DebugRenderMode::Lighting)

  114.         m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinydebuglighting));

  115.     else if (render_mode == DebugRenderMode::Normal)

  116.         m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinydebugnormal));

  117.     else if (render_mode == DebugRenderMode::UV)

  118.     {

  119.         m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinydebugUV));

  120.         m_vert_decl_flags |= (1 << VertexUsage::TexCoord);

  121.         with_UV = true;

  122.     }

  123.     SetupDefaultData(with_UV);

  124. }

  125. 

  126. //-----------------------------------------------------------------------------

  127. DefaultShaderData::DefaultShaderData(uint16_t vert_decl_flags, Shader* shader, bool with_UV)

  128.     : GpuShaderData(vert_decl_flags, shader, DebugRenderMode::Default)

  129. {

  130.     SetupDefaultData(with_UV);

  131. }

  132. 

  133. //-----------------------------------------------------------------------------

  134. void DefaultShaderData::SetupDefaultData(bool with_UV)

  135. {

  136.     AddUniform("in_ModelView");

  137.     AddUniform("in_Inv_ModelView");

  138.     AddUniform("in_View");

  139.     AddUniform("in_Inv_View");

  140.     AddUniform("in_Proj");

  141.     AddUniform("in_NormalMat");

  142.     AddUniform("in_Damage");

  143.     AddUniform("u_Lights");

  144.     AddAttribute("in_Vertex", VertexUsage::Position, 0);

  145.     AddAttribute("in_Normal", VertexUsage::Normal, 0);

  146.     AddAttribute("in_Color",  VertexUsage::Color, 0);

  147.     if (with_UV)

  148.         AddAttribute("in_TexCoord", VertexUsage::TexCoord, 0);

  149. }

  150. 

  151. //-----------------------------------------------------------------------------

  152. void DefaultShaderData::SetupShaderDatas(mat4 const &model)

  153. {

  154.     mat4 modelview = Scene::GetDefault()->GetViewMatrix() * model;

  155.     mat3 normalmat = transpose(inverse(mat3(modelview)));

  156. 

  157.     /* FIXME: this should be hidden in the shader */

  158.     /* FIXME: the 4th component of the position can be used for other things */

  159.     /* FIXME: GetUniform("blabla") is costly */

  160.     Array<Light *> const lights = Scene::GetDefault()->GetLights();

  161.     Array<vec4> light_data;

  162.     for (int i = 0; i < lights.Count(); ++i)

  163.         light_data << lights[i]->GetPosition() << lights[i]->GetColor();

  164.     while (light_data.Count() < 8)

  165.         light_data << vec4(0.f) << vec4(0.f);

  166.     m_shader->SetUniform(*GetUniform("u_Lights"), light_data);

  167. 

  168.     m_shader->SetUniform(*GetUniform("in_ModelView"), modelview);

  169.     m_shader->SetUniform(*GetUniform("in_Inv_ModelView"), inverse(modelview));

  170.     m_shader->SetUniform(*GetUniform("in_View"), Scene::GetDefault()->GetViewMatrix());

  171.     m_shader->SetUniform(*GetUniform("in_Inv_View"), inverse(Scene::GetDefault()->GetViewMatrix()));

  172.     m_shader->SetUniform(*GetUniform("in_Proj"), Scene::GetDefault()->GetProjMatrix());

  173.     m_shader->SetUniform(*GetUniform("in_NormalMat"), normalmat);

  174.     m_shader->SetUniform(*GetUniform("in_Damage"), 0);

  175. }

  176. 

  177. //-----------------------------------------------------------------------------

  178. GpuEasyMeshData::GpuEasyMeshData()

  179. {

  180.     m_vertexcount = 0;

  181.     m_indexcount = 0;

  182.     m_ibo = NULL;

  183. }

  184. 

  185. //-----------------------------------------------------------------------------

  186. GpuEasyMeshData::~GpuEasyMeshData()

  187. {

  188.     m_gpudatas.Empty();

  189.     m_vdatas.Empty();

  190.     if (m_ibo)

  191.         delete(m_ibo);

  192. }

  193. 

  194. //-----------------------------------------------------------------------------

  195. void GpuEasyMeshData::AddGpuData(GpuShaderData* gpudata, EasyMesh* src_mesh)

  196. {

  197.     SetupVertexData(gpudata->m_vert_decl_flags, src_mesh);

  198. 

  199.     if (!m_ibo)

  200.     {

  201.         Array<uint16_t> indexlist;

  202.         for (int i = 0; i < src_mesh->m_indices.Count(); i += 3)

  203.         {

  204.             indexlist << src_mesh->m_indices[i + 0];

  205.             indexlist << src_mesh->m_indices[i + 1];

  206.             indexlist << src_mesh->m_indices[i + 2];

  207.         }

  208. 

  209.         m_ibo = new IndexBuffer(indexlist.Bytes());

  210.         void *indices = m_ibo->Lock(0, 0);

  211.         memcpy(indices, &indexlist[0], indexlist.Bytes());

  212.         m_ibo->Unlock();

  213. 

  214.         m_indexcount = indexlist.Count();

  215.     }

  216. 

  217.     if (m_gpudatas.Count() != DebugRenderMode::Max)

  218.     {

  219.         m_gpudatas.Reserve(DebugRenderMode::Max);

  220.         for (int i = 0; i < DebugRenderMode::Max; i++)

  221.             m_gpudatas << NULL;

  222.     }

  223.     m_gpudatas[gpudata->m_render_mode] = gpudata;

  224. }

  225. 

  226. //-----------------------------------------------------------------------------

  227. void GpuEasyMeshData::SetupVertexData(uint16_t vdecl_flags, EasyMesh* src_mesh)

  228. {

  229.     for (int i = 0; i < m_vdatas.Count(); ++i)

  230.         if (m_vdatas[i].m1 == vdecl_flags)

  231.             return;

  232. 

  233.     VertexDeclaration* new_vdecl = NULL;

  234.     VertexBuffer* new_vbo = NULL;

  235.     void *vbo_data = NULL;

  236.     int vbo_bytes = 0;

  237. 

  238. #define COPY_VBO \

  239.     new_vbo = new VertexBuffer(vbo_bytes); \

  240.     void *mesh = new_vbo->Lock(0, 0); \

  241.     memcpy(mesh, vbo_data, vbo_bytes); \

  242.     new_vbo->Unlock();

  243. 

  244.     uint16_t baseflag = (1 << VertexUsage::Position) | (1 << VertexUsage::Normal) | (1 << VertexUsage::Color);

  245.     if (vdecl_flags == (baseflag | (1 << VertexUsage::TexCoordExt)) ||

  246.         vdecl_flags == (baseflag | (1 << VertexUsage::TexCoord) |

  247.                                    (1 << VertexUsage::TexCoordExt)))

  248.     {

  249.         new_vdecl = new VertexDeclaration(

  250.                          VertexStream<vec3,vec3,u8vec4,vec4>(

  251.                           VertexUsage::Position,

  252.                           VertexUsage::Normal,

  253.                           VertexUsage::Color,

  254.                           VertexUsage::TexCoord));

  255. 

  256.         Array<vec3, vec3, u8vec4, vec4> vertexlist;

  257.         for (int i = 0; i < src_mesh->m_vert.Count(); i++)

  258.             vertexlist.Push(src_mesh->m_vert[i].m_coord,

  259.                             src_mesh->m_vert[i].m_normal,

  260.                             (u8vec4)(src_mesh->m_vert[i].m_color * 255.f),

  261.                             src_mesh->m_vert[i].m_texcoord);

  262. 

  263.         vbo_data = &vertexlist[0];

  264.         vbo_bytes = vertexlist.Bytes();

  265.         m_vertexcount = vertexlist.Count();

  266. 

  267.         COPY_VBO;

  268.     }

  269.     else if (vdecl_flags ==  (baseflag | (1 << VertexUsage::TexCoord)))

  270.     {

  271.         new_vdecl = new VertexDeclaration(

  272.                          VertexStream<vec3,vec3,u8vec4,vec2>(

  273.                           VertexUsage::Position,

  274.                           VertexUsage::Normal,

  275.                           VertexUsage::Color,

  276.                           VertexUsage::TexCoord));

  277. 

  278.         Array<vec3, vec3, u8vec4, vec2> vertexlist;

  279.         for (int i = 0; i < src_mesh->m_vert.Count(); i++)

  280.             vertexlist.Push(src_mesh->m_vert[i].m_coord,

  281.                             src_mesh->m_vert[i].m_normal,

  282.                             (u8vec4)(src_mesh->m_vert[i].m_color * 255.f),

  283.                             src_mesh->m_vert[i].m_texcoord.xy);

  284. 

  285.         vbo_data = &vertexlist[0];

  286.         vbo_bytes = vertexlist.Bytes();

  287.         m_vertexcount = vertexlist.Count();

  288. 

  289.         COPY_VBO;

  290.     }

  291.     else if (vdecl_flags == baseflag)

  292.     {

  293.         new_vdecl = new VertexDeclaration(

  294.                          VertexStream<vec3,vec3,u8vec4>(

  295.                           VertexUsage::Position,

  296.                           VertexUsage::Normal,

  297.                           VertexUsage::Color));

  298. 

  299.         Array<vec3,vec3,u8vec4> vertexlist;

  300.         for (int i = 0; i < src_mesh->m_vert.Count(); i++)

  301.             vertexlist.Push(src_mesh->m_vert[i].m_coord,

  302.                             src_mesh->m_vert[i].m_normal,

  303.                             (u8vec4)(src_mesh->m_vert[i].m_color * 255.f));

  304. 

  305.         vbo_data = &vertexlist[0];

  306.         vbo_bytes = vertexlist.Bytes();

  307.         m_vertexcount = vertexlist.Count();

  308. 

  309.         COPY_VBO;

  310.     }

  311. 

  312.     m_vdatas.Push(vdecl_flags, new_vdecl, new_vbo);

  313. }

  314. 

  315. //-----------------------------------------------------------------------------

  316. void GpuEasyMeshData::RenderMeshData(mat4 const &model)

  317. {

  318.     DebugRenderMode d = Video::GetDebugRenderMode();

  319.     GpuShaderData& gpu_sd = *(m_gpudatas[d]);

  320. 

  321.     int vdecl_idx = 0;

  322.     for (; vdecl_idx < m_vdatas.Count(); ++vdecl_idx)

  323.         if (m_vdatas[vdecl_idx].m1 == gpu_sd.m_vert_decl_flags)

  324.             break;

  325. 

  326.     if (vdecl_idx >= m_vdatas.Count())

  327.         return;

  328. 

  329.     uint16_t vflags = m_vdatas[vdecl_idx].m1;

  330.     VertexDeclaration* vdecl = m_vdatas[vdecl_idx].m2;

  331.     VertexBuffer* vbo = m_vdatas[vdecl_idx].m3;

  332. 

  333.     gpu_sd.m_shader->Bind();

  334.     gpu_sd.SetupShaderDatas(model);

  335. 

  336.     vdecl->Bind();

  337. 

  338.     uint16_t baseflag = (1 << VertexUsage::Position) | (1 << VertexUsage::Normal) | (1 << VertexUsage::Color);

  339.     if (vflags == (baseflag | (1 << VertexUsage::TexCoord)) ||

  340.         vflags == (baseflag | (1 << VertexUsage::TexCoordExt)) ||

  341.         vflags == (baseflag | (1 << VertexUsage::TexCoord) |

  342.                               (1 << VertexUsage::TexCoordExt)))

  343. 

  344.     {

  345.         vdecl->SetStream(vbo, *gpu_sd.GetAttribute(lol::String("in_Vertex")),

  346.                               *gpu_sd.GetAttribute(lol::String("in_Normal")),

  347.                               *gpu_sd.GetAttribute(lol::String("in_Color")),

  348.                               *gpu_sd.GetAttribute(lol::String("in_TexCoord")));

  349.     }

  350.     else if (vflags == baseflag)

  351.     {

  352.         vdecl->SetStream(vbo, *gpu_sd.GetAttribute(lol::String("in_Vertex")),

  353.                               *gpu_sd.GetAttribute(lol::String("in_Normal")),

  354.                               *gpu_sd.GetAttribute(lol::String("in_Color")));

  355.     }

  356. 

  357.     m_ibo->Bind();

  358.     vdecl->DrawIndexedElements(MeshPrimitive::Triangles, 0, 0, m_vertexcount, 0, m_indexcount);

  359.     m_ibo->Unbind();

  360.     vdecl->Unbind();

  361. }

  362. 

  363. //-----------------------------------------------------------------------------

  364. EasyMesh::EasyMesh()

  365.   : m_build_data(NULL)

  366. {

  367.     m_cursors.Push(0, 0);

  368. }

  369. 

  370. //-----------------------------------------------------------------------------

  371. bool EasyMesh::Compile(char const *command)

  372. {

  373.     EasyMeshCompiler mc(*this);

  374.     bool res = mc.ParseString(command);

  375.     delete(m_build_data);

  376.     return res;

  377. }

  378. 

  379. //-----------------------------------------------------------------------------

  380. void EasyMesh::OpenBrace()

  381. {

  382.     m_cursors.Push(m_vert.Count(), m_indices.Count());

  383. }

  384. 

  385. //-----------------------------------------------------------------------------

  386. void EasyMesh::CloseBrace()

  387. {

  388.     m_cursors.Pop();

  389. }

  390. //-----------------------------------------------------------------------------

  391. void EasyMesh::MeshConvert(GpuShaderData* new_gpu_sdata)

  392. {

  393.     if (new_gpu_sdata)

  394.     {

  395.         m_gpu_data.AddGpuData(new_gpu_sdata, this);

  396.         for (int i = DebugRenderMode::Default + 1; i < DebugRenderMode::Max; i++)

  397.             m_gpu_data.AddGpuData(new DefaultShaderData(DebugRenderMode(i)), this);

  398.     }

  399. }

  400. 

  401. //-----------------------------------------------------------------------------

  402. void EasyMesh::MeshConvert(Shader* provided_shader)

  403. {

  404.     if (provided_shader)

  405.     {

  406.         GpuShaderData *new_gpu_sdata = new DefaultShaderData(((1 << VertexUsage::Position) |

  407.                                                               (1 << VertexUsage::Normal) |

  408.                                                               (1 << VertexUsage::Color)),

  409.                                                               provided_shader,

  410.                                                               false);

  411.         m_gpu_data.AddGpuData(new_gpu_sdata, this);

  412.     }

  413.     else

  414.         m_gpu_data.AddGpuData(new DefaultShaderData(DebugRenderMode::Default), this);

  415.     for (int i = DebugRenderMode::Default + 1; i < DebugRenderMode::Max; i++)

  416.         m_gpu_data.AddGpuData(new DefaultShaderData(DebugRenderMode(i)), this);

  417. }

  418. 

  419. //-----------------------------------------------------------------------------

  420. void EasyMesh::Render(mat4 const &model, float damage)

  421. {

  422.     m_gpu_data.RenderMeshData(model);

  423. }

  424. 

  425. //-------------------

  426. // "Collisions" functions

  427. //-------------------

  428. #define VX_ALONE -2

  429. #define VX_MASTER -1

  430. 

  431. //-----------------------------------------------------------------------------

  432. //helpers func to retrieve a vertex.

  433. int VertexDictionnary::FindVertexMaster(const int search_idx)

  434. {

  435.     //Resolve current vertex idx in the dictionnary (if exist)

  436.     for (int j = 0; j < vertex_list.Count(); j++)

  437.         if (vertex_list[j].m1 == search_idx)

  438.             return vertex_list[j].m3;

  439.     return VDictType::DoesNotExist;

  440. }

  441. 

  442. //-----------------------------------------------------------------------------

  443. //retrieve a list of matching vertices, doesn't include search_idx.

  444. bool VertexDictionnary::FindMatchingVertices(const int search_idx, Array<int> &matching_ids)

  445. {

  446.     int cur_mast = FindVertexMaster(search_idx);

  447. 

  448.     if (cur_mast == VDictType::DoesNotExist || cur_mast == VDictType::Alone)

  449.         return false;

  450. 

  451.     if (cur_mast == VDictType::Master)

  452.         cur_mast = search_idx;

  453.     else

  454.         matching_ids << vertex_list[cur_mast].m1;

  455. 

  456.     for (int j = 0; j < vertex_list.Count(); j++)

  457.         if (vertex_list[j].m3 == cur_mast && vertex_list[j].m1 != search_idx)

  458.             matching_ids << vertex_list[j].m1;

  459. 

  460.     return (matching_ids.Count() > 0);

  461. }

  462. 

  463. //-----------------------------------------------------------------------------

  464. //Will return connected vertices (through triangles), if returned vertex has matching ones, it only returns the master.

  465. bool VertexDictionnary::FindConnectedVertices(const int search_idx, const Array<uint16_t> &tri_list, const int tri0, Array<int> &connected_vert, Array<int> const *ignored_tri)

  466. {

  467.     Array<int> connected_tri;

  468.     FindConnectedTriangles(search_idx, tri_list, tri0, connected_tri, ignored_tri);

  469. 

  470.     for (int i = 0; i < connected_tri.Count(); i++)

  471.     {

  472.         for (int j = 0; j < 3; j++)

  473.         {

  474.             int v_indice = tri_list[connected_tri[i] + j];

  475.             if (v_indice != search_idx)

  476.             {

  477.                 int found_master = FindVertexMaster(tri_list[connected_tri[i] + j]);

  478.                 if (found_master == VDictType::Alone || found_master == VDictType::Master)

  479.                     found_master = v_indice;

  480.                 if (found_master != search_idx)

  481.                 {

  482.                     bool already_exist = false;

  483.                     for (int k = 0; !already_exist && k < connected_vert.Count(); k++)

  484.                         if (connected_vert[k] == found_master)

  485.                             already_exist = true;

  486.                     if (!already_exist)

  487.                         connected_vert << found_master;

  488.                 }

  489.             }

  490.         }

  491.     }

  492.     return (connected_vert.Count() > 0);

  493. }

  494. //-----------------------------------------------------------------------------

  495. bool VertexDictionnary::FindConnectedTriangles(const int search_idx, const Array<uint16_t> &tri_list, const int tri0, Array<int> &connected_tri, Array<int> const *ignored_tri)

  496. {

  497.     return FindConnectedTriangles(ivec3(search_idx, search_idx, search_idx), tri_list, tri0, connected_tri, ignored_tri);

  498. }

  499. //-----------------------------------------------------------------------------

  500. bool VertexDictionnary::FindConnectedTriangles(const ivec2 &search_idx, const Array<uint16_t> &tri_list, const int tri0, Array<int> &connected_tri, Array<int> const *ignored_tri)

  501. {

  502.     return FindConnectedTriangles(ivec3(search_idx, search_idx.x), tri_list, tri0, connected_tri, ignored_tri);

  503. }

  504. //-----------------------------------------------------------------------------

  505. bool VertexDictionnary::FindConnectedTriangles(const ivec3 &search_idx, const Array<uint16_t> &tri_list, const int tri0, Array<int> &connected_tri, Array<int> const *ignored_tri)

  506. {

  507.     int needed_validation = 0;

  508.     Array<int> vert_list[3];

  509.     for (int i = 0; i < 3; i++)

  510.     {

  511.         //Small optim since above func will use this one

  512.         if ((i == 1 && search_idx[0] == search_idx[1]) ||

  513.             (i == 2 && (search_idx[0] == search_idx[2] || search_idx[1] == search_idx[2])))

  514.             continue;

  515.         else

  516.         {

  517.             //increment the validation info, hence empty list aren't taken into account.

  518.             needed_validation++;

  519.             vert_list[i] << search_idx[i];

  520.             FindMatchingVertices(search_idx[i], vert_list[i]);

  521.         }

  522.     }

  523. 

  524.     for (int i = tri0; i < tri_list.Count(); i += 3)

  525.     {

  526.         if (ignored_tri)

  527.         {

  528.             bool should_pass = false;

  529.             for (int j = 0; !should_pass && j < ignored_tri->Count(); j++)

  530.                 if ((*ignored_tri)[j] == i)

  531.                     should_pass = true;

  532.             if (should_pass)

  533.                 continue;

  534.         }

  535.         int found_validation = 0;

  536.         for (int j = 0; j < 3; j++)

  537.         {

  538.             bool validated = false;

  539.             for (int k = 0; !validated && k < vert_list[j].Count(); k++)

  540.                 for (int l = 0; !validated && l < 3; l++)

  541.                     if (vert_list[j][k] == tri_list[i + l])

  542.                         validated = true;

  543.             found_validation += (validated)?(1):(0);

  544.         }

  545.         //triangle is validated store it

  546.         if (found_validation == needed_validation)

  547.             connected_tri << i;

  548.     }

  549. 

  550.     return (connected_tri.Count() > 0);

  551. }

  552. 

  553. //-----------------------------------------------------------------------------

  554. //Will update the given list with all the vertices on the same spot.

  555. void VertexDictionnary::AddVertex(const int vert_id, const vec3 vert_coord)

  556. {

  557.     for (int j = 0; j < vertex_list.Count(); j++)

  558.         if (vertex_list[j].m1 == vert_id)

  559.             return;

  560. 

  561.     //First, build the vertex Dictionnary

  562.     int i = 0;

  563.     for (; i < master_list.Count(); i++)

  564.     {

  565.         int cur_mast  = master_list[i];

  566.         int cur_id    = vertex_list[cur_mast].m1;

  567.         vec3 cur_loc  = vertex_list[cur_mast].m2;

  568.         int &cur_type = vertex_list[cur_mast].m3;

  569. 

  570.         if (cur_id == vert_id)

  571.             return;

  572. 

  573.         if (sqlength(cur_loc - vert_coord) < CSG_EPSILON)

  574.         {

  575.             if (cur_type == VDictType::Alone)

  576.                 cur_type = VDictType::Master;

  577.             vertex_list.Push(vert_id, vert_coord, cur_mast);

  578.             return;

  579.         }

  580.     }

  581. 

  582.     //We're here because we couldn't find any matching vertex

  583.     master_list.Push(vertex_list.Count());

  584.     vertex_list.Push(vert_id, vert_coord, VDictType::Alone);

  585. }

  586. 

  587. //-----------------------------------------------------------------------------

  588. void EasyMesh::MeshCsg(CSGUsage csg_operation)

  589. {

  590.     //A vertex dictionnary for vertices on the same spot.

  591.     Array< int, int > vertex_dict;

  592.     //This list keeps track of the triangle that will need deletion at the end.

  593.     Array< int > triangle_to_kill;

  594.     //Listing for each triangle of the vectors intersecting it. <tri_Id, <Point0, Point1, tri_isec_Normal>>

  595.     Array< int, Array< vec3, vec3, vec3 > > triangle_isec;

  596.     //keep a track of the intersection point on the triangle. <pos, side_id>

  597.     Array< vec3, int > triangle_vertex;

  598.     for (int k = 0; k < 10; k++)

  599.         triangle_vertex.Push(vec3(.0f), 0);

  600. 

  601.     //bsp infos

  602.     CsgBsp mesh_bsp_0;

  603.     CsgBsp mesh_bsp_1;

  604. 

  605.     if (m_cursors.Count() == 0)

  606.         return;

  607. 

  608.     //BSP BUILD : We use the brace logic, csg should be used as : "[ exp .... [exp .... csg]]"

  609.     int cursor_start = (m_cursors.Count() < 2)?(0):(m_cursors[(m_cursors.Count() - 2)].m2);

  610.     for (int mesh_id = 0; mesh_id < 2; mesh_id++)

  611.     {

  612.         int start_point     = (mesh_id == 0)?(cursor_start):(m_cursors.Last().m2);

  613.         int end_point       = (mesh_id == 0)?(m_cursors.Last().m2):(m_indices.Count());

  614.         CsgBsp &mesh_bsp  = (mesh_id == 0)?(mesh_bsp_0):(mesh_bsp_1);

  615.         for (int i = start_point; i < end_point; i += 3)

  616.             mesh_bsp.AddTriangleToTree(i, m_vert[m_indices[i]].m_coord,

  617.                                           m_vert[m_indices[i + 1]].m_coord,

  618.                                           m_vert[m_indices[i + 2]].m_coord);

  619.     }

  620. 

  621.     //BSP Useage : let's crunch all triangles on the correct BSP

  622.     int indices_count = m_indices.Count();

  623.     for (int mesh_id = 0; mesh_id < 2; mesh_id++)

  624.     {

  625.         int start_point     = (mesh_id == 0)?(cursor_start):(m_cursors.Last().m2);

  626.         int end_point       = (mesh_id == 0)?(m_cursors.Last().m2):(indices_count);

  627.         CsgBsp &mesh_bsp  = (mesh_id == 0)?(mesh_bsp_1):(mesh_bsp_0);

  628.         Array< vec3, int, int, float > vert_list;

  629.         Array< int, int, int, int > tri_list;

  630.         vec3 n0(.0f); vec3 n1(.0f);

  631.         vec4 c0(.0f); vec4 c1(.0f);

  632. 

  633.         //Reserve some memory

  634.         vert_list.Reserve(3);

  635.         tri_list.Reserve(3);

  636. 

  637.         for (int i = start_point; i < end_point; i += 3)

  638.         {

  639.             int Result = mesh_bsp.TestTriangleToTree(m_vert[m_indices[i]].m_coord,

  640.                                                      m_vert[m_indices[i + 1]].m_coord,

  641.                                                      m_vert[m_indices[i + 2]].m_coord, vert_list, tri_list);

  642.             int tri_base_idx = m_indices.Count();

  643. 

  644.             //one split has been done, we need to had the new vertices & the new triangles.

  645.             if (Result == 1)

  646.             {

  647.                 triangle_to_kill.Push(i);

  648. #if 1

  649.                 int base_idx = m_vert.Count();

  650.                 for (int k = 3; k < vert_list.Count(); k++)

  651.                 {

  652.                     int P0 = (vert_list[k].m2 < 3)?(m_indices[i + vert_list[k].m2]):(base_idx + vert_list[k].m2 - 3);

  653.                     int P1 = (vert_list[k].m3 < 3)?(m_indices[i + vert_list[k].m3]):(base_idx + vert_list[k].m3 - 3);

  654. 

  655.                     AddVertex(vert_list[k].m1);

  656. 

  657.                     //Normal : bad calculations there.

  658.                     n0 = m_vert[P0].m_normal;

  659.                     n1 = m_vert[P1].m_normal;

  660.                     SetCurVertNormal(normalize(n0 + (n1 - n0) * vert_list[k].m4));

  661. 

  662. #if 1

  663.                     //Color

  664.                     c0 = m_vert[P0].m_color;

  665.                     c1 = m_vert[P1].m_color;

  666.                     vec4 res = c0 + ((c1 - c0) * vert_list[k].m4);

  667.                     SetCurVertColor(res);

  668. #else

  669.                     if (mesh_id == 0)

  670.                         SetCurVertColor(vec4(1.0f, .0f, .0f, 1.0f));

  671.                     else

  672.                         SetCurVertColor(vec4(.0f, 1.0f, 1.0f, 1.0f));

  673. #endif

  674.                 }

  675.                 for (int k = 0; k < tri_list.Count(); k++)

  676.                 {

  677.                     int P0 = (tri_list[k].m2 < 3)?(m_indices[i + tri_list[k].m2]):(base_idx + (tri_list[k].m2 - 3));

  678.                     int P1 = (tri_list[k].m3 < 3)?(m_indices[i + tri_list[k].m3]):(base_idx + (tri_list[k].m3 - 3));

  679.                     int P2 = (tri_list[k].m4 < 3)?(m_indices[i + tri_list[k].m4]):(base_idx + (tri_list[k].m4 - 3));

  680.                     AppendTriangle(P0, P1, P2, 0);

  681.                 }

  682. #endif

  683.             }

  684. #if 1

  685.             //Main case

  686.             if (Result >= 0)

  687.             {

  688.                 for (int k = 0; k < tri_list.Count(); k++)

  689.                 {

  690.                     int tri_idx = ((tri_list.Count() == 1)?(i):(tri_base_idx + k * 3));

  691. 

  692.                     //Triangle Kill Test

  693.                     if (//csgu : CSGUnion() -> m0_Outside + m1_Outside

  694.                         (csg_operation == CSGUsage::Union && tri_list[k].m1 == LEAF_BACK) ||

  695.                         //csgs : CSGSubstract() -> m0_Outside + m1_Inside-inverted

  696.                         (csg_operation == CSGUsage::Substract &&

  697.                             ((mesh_id == 0 && tri_list[k].m1 == LEAF_BACK) ||

  698.                             (mesh_id == 1 && tri_list[k].m1 == LEAF_FRONT))) ||

  699.                         //csgs : CSGSubstractLoss() -> m0_Outside

  700.                         (csg_operation == CSGUsage::SubstractLoss &&

  701.                             ((mesh_id == 0 && tri_list[k].m1 == LEAF_BACK) || mesh_id == 1)) ||

  702.                         //csga : CSGAnd() -> m0_Inside + m1_Inside

  703.                         (csg_operation == CSGUsage::And && tri_list[k].m1 == LEAF_FRONT))

  704.                     {

  705.                         triangle_to_kill.Push(tri_idx);

  706.                     }

  707. 

  708.                     //Triangle Invert Test

  709.                     if (//csgs : CSGSubstract() -> m0_Outside + m1_Inside-inverted

  710.                         (csg_operation == CSGUsage::Substract && mesh_id == 1 && tri_list[k].m1 == LEAF_BACK) ||

  711.                         //csgx : CSGXor() -> m0_Outside/m0_Inside-inverted + m1_Outside/m1_Inside-inverted

  712.                         (csg_operation == CSGUsage::Xor && tri_list[k].m1 == LEAF_BACK))

  713.                     {

  714.                         //a Xor means we will share vertices with the outside, so duplicate the vertices.

  715.                         //TODO : This operation disconnect all triangle, in some cases, not a good thing.

  716.                         if (csg_operation == CSGUsage::Xor)

  717.                         {

  718.                             for (int l = 0; l < 3; l++)

  719.                             {

  720.                                 AddDuplicateVertex(m_indices[tri_idx + l]);

  721.                                 m_indices[tri_idx + l] = m_vert.Count() - 1;

  722.                             }

  723.                         }

  724.                         m_indices[tri_idx + 1] += m_indices[tri_idx + 2];

  725.                         m_indices[tri_idx + 2]  = m_indices[tri_idx + 1] - m_indices[tri_idx + 2];

  726.                         m_indices[tri_idx + 1]  = m_indices[tri_idx + 1] - m_indices[tri_idx + 2];

  727.                         ComputeNormals(tri_idx, 3);

  728.                     }

  729.                 }

  730.             }

  731. #endif

  732.             vert_list.Empty();

  733.             tri_list.Empty();

  734.         }

  735.     }

  736. 

  737.     for (int i = 0; i < m_vert.Count(); i++)

  738.         if (length(m_vert[i].m_normal) < 1.0f)

  739.             i = i;

  740. 

  741.     int dir = 1;

  742.     for (int i = 0; i >= 0 && i < triangle_to_kill.Count() - 1; i += dir)

  743.     {

  744.         if (triangle_to_kill[i] < triangle_to_kill[i + 1] && dir < 0)

  745.             dir = 1;

  746.         if (triangle_to_kill[i] == triangle_to_kill[i + 1])

  747.         {

  748.             triangle_to_kill.Remove(i);

  749.             dir = -1;

  750.         }

  751.         if (triangle_to_kill[i] > triangle_to_kill[i + 1])

  752.         {

  753.             triangle_to_kill[i]     += triangle_to_kill[i + 1];

  754.             triangle_to_kill[i + 1]  = triangle_to_kill[i] - triangle_to_kill[i + 1];

  755.             triangle_to_kill[i]      = triangle_to_kill[i] - triangle_to_kill[i + 1];

  756.             dir = -1;

  757.         }

  758.         if (i == 0 && dir == -1)

  759.             dir = 1;

  760.     }

  761.     for (int i = triangle_to_kill.Count() - 1; i >= 0; i--)

  762.         m_indices.Remove(triangle_to_kill[i], 3);

  763. 

  764.     m_cursors.Last().m1 = m_vert.Count();

  765.     m_cursors.Last().m2 = m_indices.Count();

  766. 

  767.     //DONE for the splitting !

  768. }

  769. 

  770. //-----------------------------------------------------------------------------

  771. void EasyMesh::ToggleScaleWinding()

  772. {

  773.     BD()->Toggle(MeshBuildOperation::Scale_Winding);

  774. }

  775. 

  776. //-----------------------------------------------------------------------------

  777. void EasyMesh::SetCurColor(vec4 const &color)

  778. {

  779.     BD()->Color() = color;

  780. }

  781. 

  782. //-----------------------------------------------------------------------------

  783. void EasyMesh::SetCurColor2(vec4 const &color)

  784. {

  785.     BD()->Color2() = color;

  786. }

  787. 

  788. //-----------------------------------------------------------------------------

  789. void EasyMesh::AddVertex(vec3 const &coord)

  790. {

  791.     m_vert.Push(VertexData(coord, vec3(0.f, 1.f, 0.f), BD()->Color()));

  792. }

  793. 

  794. //-----------------------------------------------------------------------------

  795. void EasyMesh::AddDuplicateVertex(int i)

  796. {

  797.     m_vert << m_vert[i];

  798. }

  799. 

  800. //-----------------------------------------------------------------------------

  801. void EasyMesh::AddLerpVertex(int i, int j, float alpha)

  802. {

  803.     m_vert.Push(VertexData(

  804.         lol::lerp(m_vert[i].m_coord,    m_vert[j].m_coord,      alpha),

  805.         lol::lerp(m_vert[i].m_normal,   m_vert[j].m_normal,     alpha),

  806.         lol::lerp(m_vert[i].m_color,    m_vert[j].m_color,      alpha),

  807.         lol::lerp(m_vert[i].m_texcoord, m_vert[j].m_texcoord,   alpha),

  808.         ((alpha < .5f) ? (m_vert[i].m_bone_id) : (m_vert[j].m_bone_id)), /* FIXME ? */

  809.         lol::lerp(m_vert[i].m_bone_weight, m_vert[j].m_bone_weight, alpha)));

  810. }

  811. 

  812. //-----------------------------------------------------------------------------

  813. void EasyMesh::AppendQuad(int i1, int i2, int i3, int i4, int base)

  814. {

  815.     m_indices << base + i1;

  816.     m_indices << base + i2;

  817.     m_indices << base + i3;

  818. 

  819.     m_indices << base + i4;

  820.     m_indices << base + i1;

  821.     m_indices << base + i3;

  822. }

  823. 

  824. //-----------------------------------------------------------------------------

  825. void EasyMesh::AppendQuadDuplicateVerts(int i1, int i2, int i3, int i4, int base)

  826. {

  827.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i1);

  828.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i2);

  829.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i3);

  830. 

  831.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i4);

  832.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i1);

  833.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i3);

  834. }

  835. 

  836. //-----------------------------------------------------------------------------

  837. void EasyMesh::AppendTriangle(int i1, int i2, int i3, int base)

  838. {

  839.     m_indices << base + i1;

  840.     m_indices << base + i2;

  841.     m_indices << base + i3;

  842. }

  843. 

  844. //-----------------------------------------------------------------------------

  845. void EasyMesh::AppendTriangleDuplicateVerts(int i1, int i2, int i3, int base)

  846. {

  847.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i1);

  848.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i2);

  849.     m_indices << m_vert.Count(); AddDuplicateVertex(base + i3);

  850. }

  851. 

  852. //-----------------------------------------------------------------------------

  853. void EasyMesh::ComputeNormals(int start, int vcount)

  854. {

  855.     for (int i = 0; i < vcount; i += 3)

  856.     {

  857.         vec3 v0 = m_vert[m_indices[start + i + 2]].m_coord

  858.                 - m_vert[m_indices[start + i + 0]].m_coord;

  859.         vec3 v1 = m_vert[m_indices[start + i + 1]].m_coord

  860.                 - m_vert[m_indices[start + i + 0]].m_coord;

  861.         vec3 n = normalize(cross(v1, v0));

  862. 

  863.         for (int j = 0; j < 3; j++)

  864.             m_vert[m_indices[start + i + j]].m_normal = n;

  865.     }

  866. }

  867. 

  868. //-----------------------------------------------------------------------------

  869. void EasyMesh::ComputeTexCoord(float uv_scale, int uv_offset)

  870. {

  871. #if 0

  872.     VertexDictionnary vert_dict;

  873.     Array<int> tri_list;

  874. 

  875.     tri_list.Reserve(m_indices.Count() - m_cursors.Last().m2);

  876.     for (int i = m_cursors.Last().m2; i < m_indices.Count(); i++)

  877.     {

  878.         vert_dict.AddVertex(m_indices[i], m_vert[m_indices[i]].m_coord);

  879.         tri_list << m_indices[i];

  880.     }

  881. 

  882.     //full triangle count

  883.     Array<int> tri_done;

  884.     Array<int> tri_check;

  885.     int tri_count = (m_indices.Count() - m_cursors.Last().m2) / 3;

  886. 

  887.     tri_check << tri_list[0];

  888. 

  889.     while (tri_check.Count())

  890.     {

  891.         int cur_tri = tri_check[0];

  892.         int v[3]   = { tri_list[cur_tri + uv_offset % 3], tri_list[cur_tri + (1 + uv_offset) % 3], tri_list[cur_tri + (2 + uv_offset) % 3] };

  893.         vec2 uv[3] = { m_vert[tri_list[cur_tri]].m_texcoord.xy, m_vert[tri_list[cur_tri + 1]].m_texcoord.xy, m_vert[tri_list[cur_tri + 2]].m_texcoord.xy };

  894.         for (int j = 0; j < 3; j++)

  895.         {

  896.             if (uv[j] != vec2(-1.0f) && uv[j] == uv[(j + 1) % 3])

  897.             {

  898.                 uv[0] = vec2(-1.0f);

  899.                 uv[1] = vec2(-1.0f);

  900.                 uv[2] = vec2(-1.0f);

  901.                 break;

  902.             }

  903.         }

  904.         int uv_set = 0;

  905.         for (int j = 0; j < 3; j++)

  906.             uv_set += (uv[j].x < 0.f)?(0):(1);

  907. 

  908.         //this case shouldn't happen.

  909.         if (uv_set == 1)

  910.         {

  911.             /*

  912.             for (int j = 0; j < 3; j++)

  913.             {

  914.                 if (uv[j] != vec2(-1.0f))

  915.                 {

  916.                     uv[(j + 1) % 2] = uv[j] + vec2(.0f, uv_scale * length(m_vert[v[j]].m1 - m_vert[v[(j + 1) % 3]].m1));

  917.                     uv_set = 2;

  918.                     break;

  919.                 }

  920.             }

  921.             */

  922.         }

  923.         //No UV is set, let's do the arbitrary set and use the basic method.

  924.         if (uv_set == 0)

  925.         {

  926.             float new_dot = FLT_MAX;

  927.             int base_i = 0;

  928.             for (int j = 0; j < 3; j++)

  929.             {

  930.                 float tmp_dot = abs(dot(normalize(m_vert[v[(j + 1) % 3]].m_coord - m_vert[v[j]].m_coord),

  931.                                         normalize(m_vert[v[(j + 2) % 3]].m_coord - m_vert[v[j]].m_coord)));

  932.                 if (tmp_dot < new_dot)

  933.                 {

  934.                     base_i = j;

  935.                     new_dot = tmp_dot;

  936.                 }

  937.             }

  938.             uv[base_i] = vec2(.0f);

  939.             uv[(base_i + 1) % 3] = vec2(.0f, uv_scale * length(m_vert[v[base_i]].m_coord - m_vert[v[(base_i + 1) % 3]].m_coord));

  940.             uv_set = 2;

  941.         }

  942.         //2 points have been set, let's figure the third

  943.         if (uv_set == 2)

  944.         {

  945.             {

  946.                 //invert values so the two set uv are in [0, 1] slots.

  947.                 int new_v[3];

  948.                 vec2 new_uv[3];

  949.                 bool ignore_set = false;

  950.                 if (uv[0].x >= 0.f && uv[1].x < 0.f)

  951.                 {

  952.                     new_v[0] = v[2]; new_v[1] = v[0]; new_v[2] = v[1];

  953.                     new_uv[0] = uv[2]; new_uv[1] = uv[0]; new_uv[2] = uv[1];

  954.                 }

  955.                 else if (uv[0].x < 0.f && uv[1].x >= 0.f)

  956.                 {

  957.                     new_v[0] = v[1]; new_v[1] = v[2]; new_v[2] = v[0];

  958.                     new_uv[0] = uv[1]; new_uv[1] = uv[2]; new_uv[2] = uv[0];

  959.                 }

  960.                 else

  961.                     ignore_set = true;

  962.                 if (!ignore_set)

  963.                 {

  964.                     v[0]  = new_v[0];  v[1]  = new_v[1];  v[2]  = new_v[2];

  965.                     uv[0] = new_uv[0]; uv[1] = new_uv[1]; uv[2] = new_uv[2];

  966.                 }

  967.             }

  968. 

  969.             //Do this to be sure the normal is OK.

  970.             ComputeNormals(cur_tri, 3);

  971.             vec3 v01 = normalize(m_vert[v[1]].m_coord - m_vert[v[0]].m_coord);

  972.             vec3 v02 = m_vert[v[2]].m_coord - m_vert[v[0]].m_coord;

  973.             vec3 v_dir = normalize(cross(m_vert[m_indices[cur_tri]].m_normal, v01));

  974.             vec2 texu_dir = uv[1] - uv[0];

  975.             vec2 texv_dir = vec2(texu_dir.y, texu_dir.x);

  976.             //Final calculations

  977.             uv[2] = texu_dir * dot(v01, v02) + texv_dir * dot(v_dir, v02);

  978. 

  979.             //Set UV on ALL matching vertices!

  980.             Array<int> matching_vert;

  981.             for (int i = 0; i < 3; i++)

  982.             {

  983. #if 1

  984.                 //This marks all same position UV to the same values

  985.                 //Deactivation is a test.

  986.                 matching_vert << v[i];

  987.                 vert_dict.FindMatchingVertices(v[i], matching_vert);

  988.                 for (int j = 0; j < matching_vert.Count(); j++)

  989.                     if (m_vert[matching_vert[j]].m_texcoord.xy == vec2(-1.0f))

  990.                         m_vert[matching_vert[j]].m_texcoord = vec4(abs(uv[i]), m_vert[matching_vert[j]].m_texcoord.zw);

  991. #else

  992.                 m_vert[v[i]].m_texcoord = abs(uv[i]);

  993. #endif

  994.             }

  995. 

  996.             tri_done << cur_tri;

  997.             tri_check.Remove(0);

  998. 

  999.             //Get connected triangles and go from there.

  1000.             for (int j = 0; j < 3; j++)

  1001.             {

  1002. #if 1

  1003.                 //This finds triangle that are connected to this triangle

  1004.                 vert_dict.FindConnectedTriangles(ivec2(v[j], v[(j + 1) % 3]), tri_list, tri_check, &tri_done);

  1005. #else

  1006.                 //This finds triangle that are connected to the vertices of this triangle

  1007.                 vert_dict.FindConnectedTriangles(v[j], tri_list, tri_check, &tri_done);

  1008. #endif

  1009.             }

  1010.         }

  1011.         else if (uv_set == 3)

  1012.         {

  1013.             for (int j = 0; j < 3; j++)

  1014.             {

  1015.                 m_vert[tri_list[cur_tri]].m_texcoord     = vec4(vec2(-1.0f), m_vert[tri_list[cur_tri]].m_texcoord.zw);

  1016.                 m_vert[tri_list[cur_tri + 1]].m_texcoord = vec4(vec2(-1.0f), m_vert[tri_list[cur_tri + 1]].m_texcoord.zw);

  1017.                 m_vert[tri_list[cur_tri + 2]].m_texcoord = vec4(vec2(-1.0f), m_vert[tri_list[cur_tri + 2]].m_texcoord.zw);

  1018.             }

  1019. 

  1020.             //uv[0] = vec2(-1.0f);

  1021.             //uv[1] = vec2(-1.0f);

  1022.             //uv[2] = vec2(-1.0f);

  1023.             /*

  1024.             bool tri_present = false;

  1025.             for (int j = 0; j < tri_done.Count(); j++)

  1026.                 if (cur_tri == tri_done[j])

  1027.                     tri_present = true;

  1028.             if (!tri_present)

  1029.                 tri_done << cur_tri;

  1030.             tri_check.Remove(0);

  1031.             */

  1032.         }

  1033. 

  1034.         if (tri_check.Count() == 0 && tri_done.Count() != tri_count)

  1035.         {

  1036.             //look for unset triangle

  1037.             for (int i = 0; !tri_check.Count() && i < tri_list.Count(); i += 3)

  1038.             {

  1039.                 bool tri_present = false;

  1040.                 for (int j = 0; j < tri_done.Count(); j++)

  1041.                     if (i == tri_done[j])

  1042.                         tri_present = true;

  1043.                 if (!tri_present)

  1044.                     tri_check << i;

  1045.             }

  1046.         }

  1047.     }

  1048. #endif

  1049. }

  1050. 

  1051. //-----------------------------------------------------------------------------

  1052. void EasyMesh::SetVertColor(vec4 const &color)

  1053. {

  1054.     for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)

  1055.         m_vert[i].m_color = color;

  1056. }

  1057. 

  1058. //-----------------------------------------------------------------------------

  1059. void EasyMesh::SetTexCoordData(vec2 const &new_offset, vec2 const &new_scale)

  1060. {

  1061.     BD()->TexCoordOffset() = new_offset;

  1062.     BD()->TexCoordScale() = new_scale;

  1063. }

  1064. 

  1065. //-----------------------------------------------------------------------------

  1066. void EasyMesh::SetTexCoordData2(vec2 const &new_offset, vec2 const &new_scale)

  1067. {

  1068.     BD()->TexCoordOffset2() = new_offset;

  1069.     BD()->TexCoordScale2() = new_scale;

  1070. }

  1071. 

  1072. //-----------------------------------------------------------------------------

  1073. void EasyMesh::SetCurVertNormal(vec3 const &normal)

  1074. {

  1075.     m_vert[m_vert.Count() - 1].m_normal = normal;

  1076. }

  1077. 

  1078. //-----------------------------------------------------------------------------

  1079. void EasyMesh::SetCurVertColor(vec4 const &color)

  1080. {

  1081.     m_vert[m_vert.Count() - 1].m_color = color;

  1082. }

  1083. 

  1084. //-----------------------------------------------------------------------------

  1085. void EasyMesh::SetCurVertTexCoord(vec2 const &texcoord)

  1086. {

  1087.     m_vert[m_vert.Count() - 1].m_texcoord = vec4(texcoord, m_vert[m_vert.Count() - 1].m_texcoord.zw);

  1088. }

  1089. 

  1090. //-----------------------------------------------------------------------------

  1091. void EasyMesh::SetCurVertTexCoord2(vec2 const &texcoord)

  1092. {

  1093.     m_vert[m_vert.Count() - 1].m_texcoord = vec4(m_vert[m_vert.Count() - 1].m_texcoord.xy, texcoord);

  1094. }

  1095. 

  1096. //-----------------------------------------------------------------------------

  1097. void EasyMesh::Translate(vec3 const &v)

  1098. {

  1099.     for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)

  1100.         m_vert[i].m_coord += v;

  1101. }

  1102. 

  1103. //-----------------------------------------------------------------------------

  1104. void EasyMesh::RotateX(float angle) { Rotate(angle, vec3(1, 0, 0)); }

  1105. void EasyMesh::RotateY(float angle) { Rotate(angle, vec3(0, 1, 0)); }

  1106. void EasyMesh::RotateZ(float angle) { Rotate(angle, vec3(0, 0, 1)); }

  1107. 

  1108. //-----------------------------------------------------------------------------

  1109. void EasyMesh::Rotate(float angle, vec3 const &axis)

  1110. {

  1111.     mat3 m = mat3::rotate(angle, axis);

  1112.     for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)

  1113.     {

  1114.         m_vert[i].m_coord  = m * m_vert[i].m_coord;

  1115.         m_vert[i].m_normal = m * m_vert[i].m_normal;

  1116.     }

  1117. }

  1118. 

  1119. //-----------------------------------------------------------------------------

  1120. void EasyMesh::RadialJitter(float r)

  1121. {

  1122.     Array<int> Welded;

  1123.     Welded.Push(-1);

  1124.     for (int i = m_cursors.Last().m1 + 1; i < m_vert.Count(); i++)

  1125.     {

  1126.         int j, k;

  1127.         for (j = m_cursors.Last().m1, k = 0; j < i; j++, k++)

  1128.         {

  1129.             if(Welded[k] < 0)

  1130.             {

  1131.                 vec3 diff = m_vert[i].m_coord - m_vert[j].m_coord;

  1132. 

  1133.                 if(diff.x > 0.1f || diff.x < -0.1f)

  1134.                     continue;

  1135. 

  1136.                 if(diff.y > 0.1f || diff.y < -0.1f)

  1137.                     continue;

  1138. 

  1139.                 if(diff.z > 0.1f || diff.z < -0.1f)

  1140.                     continue;

  1141. 

  1142.                 break;

  1143.             }

  1144.         }

  1145. 

  1146.         if(j == i)

  1147.             Welded.Push(-1);

  1148.         else

  1149.             Welded.Push(j);

  1150.     }

  1151. 

  1152.     int i, j;

  1153.     for (i = m_cursors.Last().m1, j = 0; i < m_vert.Count(); i++, j++)

  1154.     {

  1155.         if(Welded[j] == -1)

  1156.             m_vert[i].m_coord *= 1.0f + RandF(r);

  1157.         else

  1158.             m_vert[i].m_coord = m_vert[Welded[j]].m_coord;

  1159.     }

  1160. 

  1161.     ComputeNormals(m_cursors.Last().m2, m_indices.Count() - m_cursors.Last().m2);

  1162. }

  1163. 

  1164. //-----------------------------------------------------------------------------

  1165. void EasyMesh::TaperX(float ny, float nz, float xoff, int absolute) { DoMeshTransform(MeshTransform::Taper, Axis::X, Axis::X, ny, nz, xoff, absolute); }

  1166. void EasyMesh::TaperY(float nx, float nz, float yoff, int absolute) { DoMeshTransform(MeshTransform::Taper, Axis::Y, Axis::Y, nz, nx, yoff, absolute); }

  1167. void EasyMesh::TaperZ(float nx, float ny, float zoff, int absolute) { DoMeshTransform(MeshTransform::Taper, Axis::Z, Axis::Z, nx, ny, zoff, absolute); }

  1168. 

  1169. //-----------------------------------------------------------------------------

  1170. void EasyMesh::TwistX(float t, float toff) { DoMeshTransform(MeshTransform::Twist, Axis::X, Axis::X, t, t, toff, 0); }

  1171. void EasyMesh::TwistY(float t, float toff) { DoMeshTransform(MeshTransform::Twist, Axis::Y, Axis::Y, t, t, toff, 0); }

  1172. void EasyMesh::TwistZ(float t, float toff) { DoMeshTransform(MeshTransform::Twist, Axis::Z, Axis::Z, t, t, toff, 0); }

  1173. 

  1174. //-----------------------------------------------------------------------------

  1175. void EasyMesh::ShearX(float ny, float nz, float xoff, int absolute) { DoMeshTransform(MeshTransform::Shear, Axis::X, Axis::X, ny, nz, xoff, absolute); }

  1176. void EasyMesh::ShearY(float nx, float nz, float yoff, int absolute) { DoMeshTransform(MeshTransform::Shear, Axis::Y, Axis::Y, nz, nx, yoff, absolute); }

  1177. void EasyMesh::ShearZ(float nx, float ny, float zoff, int absolute) { DoMeshTransform(MeshTransform::Shear, Axis::Z, Axis::Z, nx, ny, zoff, absolute); }

  1178. 

  1179. //-----------------------------------------------------------------------------

  1180. void EasyMesh::StretchX(float ny, float nz, float xoff) { DoMeshTransform(MeshTransform::Stretch, Axis::X, Axis::X, ny, nz, xoff, 0); }

  1181. void EasyMesh::StretchY(float nx, float nz, float yoff) { DoMeshTransform(MeshTransform::Stretch, Axis::Y, Axis::Y, nz, nx, yoff, 0); }

  1182. void EasyMesh::StretchZ(float nx, float ny, float zoff) { DoMeshTransform(MeshTransform::Stretch, Axis::Z, Axis::Z, nx, ny, zoff, 0); }

  1183. 

  1184. //-----------------------------------------------------------------------------

  1185. void EasyMesh::BendXY(float t, float toff) { DoMeshTransform(MeshTransform::Bend, Axis::X, Axis::Y, t, t, toff, 0); }

  1186. void EasyMesh::BendXZ(float t, float toff) { DoMeshTransform(MeshTransform::Bend, Axis::X, Axis::Z, t, t, toff, 0); }

  1187. void EasyMesh::BendYX(float t, float toff) { DoMeshTransform(MeshTransform::Bend, Axis::Y, Axis::X, t, t, toff, 0); }

  1188. void EasyMesh::BendYZ(float t, float toff) { DoMeshTransform(MeshTransform::Bend, Axis::Y, Axis::Z, t, t, toff, 0); }

  1189. void EasyMesh::BendZX(float t, float toff) { DoMeshTransform(MeshTransform::Bend, Axis::Z, Axis::X, t, t, toff, 0); }

  1190. void EasyMesh::BendZY(float t, float toff) { DoMeshTransform(MeshTransform::Bend, Axis::Z, Axis::Y, t, t, toff, 0); }

  1191. 

  1192. //-----------------------------------------------------------------------------

  1193. void EasyMesh::DoMeshTransform(MeshTransform ct, Axis axis0, Axis axis1, float n0, float n1, float noff, int absolute)

  1194. {

  1195.     for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)

  1196.     {

  1197.         switch (ct)

  1198.         {

  1199.             case MeshTransform::Taper:

  1200.             {

  1201.                 float value = m_vert[i].m_coord[axis0];

  1202.                 if (absolute) value = abs(value);

  1203.                 m_vert[i].m_coord[(axis0 + 1) % 3] *= max(0.f, 1.f + (n0 * value + noff));

  1204.                 m_vert[i].m_coord[(axis0 + 2) % 3] *= max(0.f, 1.f + (n1 * value + noff));

  1205.                 break;

  1206.             }

  1207.             case MeshTransform::Twist:

  1208.             {

  1209.                 vec3 rotaxis = vec3(1.f); rotaxis[(axis0 + 1) % 3] = .0f; rotaxis[(axis0 + 2) % 3] = .0f;

  1210.                 m_vert[i].m_coord = mat3::rotate(m_vert[i].m_coord[axis0] * n0 + noff, rotaxis) * m_vert[i].m_coord;

  1211.                 break;

  1212.             }

  1213.             case MeshTransform::Shear:

  1214.             {

  1215.                 float value = m_vert[i].m_coord[axis0];

  1216.                 if (absolute) value = abs(value);

  1217.                 m_vert[i].m_coord[(axis0 + 1) % 3] += (n0 * value + noff);

  1218.                 m_vert[i].m_coord[(axis0 + 2) % 3] += (n1 * value + noff);

  1219.                 break;

  1220.             }

  1221.             case MeshTransform::Stretch:

  1222.             {

  1223.                 //float value = abs(m_vert[i].m1[axis0]);

  1224.                 //m_vert[i].m1[(axis0 + 1) % 3] += (lol::pow(value, n0) + noff);

  1225.                 //m_vert[i].m1[(axis0 + 2) % 3] += (lol::pow(value, n1) + noff);

  1226.                 break;

  1227.             }

  1228.             case MeshTransform::Bend:

  1229.             {

  1230.                 vec3 rotaxis = vec3(1.f); rotaxis[(axis1 + 1) % 3] = .0f; rotaxis[(axis1 + 2) % 3] = .0f;

  1231.                 m_vert[i].m_coord = mat3::rotate(m_vert[i].m_coord[axis0] * n0 + noff, rotaxis) * m_vert[i].m_coord;

  1232.                 break;

  1233.             }

  1234.         }

  1235.     }

  1236.     ComputeNormals(m_cursors.Last().m2, m_indices.Count() - m_cursors.Last().m2);

  1237. }

  1238. 

  1239. //-----------------------------------------------------------------------------

  1240. void EasyMesh::Scale(vec3 const &s)

  1241. {

  1242.     vec3 const invs = vec3(1) / s;

  1243. 

  1244.     for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)

  1245.     {

  1246.         m_vert[i].m_coord *= s;

  1247.         m_vert[i].m_normal = normalize(m_vert[i].m_normal * invs);

  1248.     }

  1249. 

  1250.     /* Flip winding if the scaling involves mirroring */

  1251.     if (!BD()->IsEnabled(MeshBuildOperation::Scale_Winding) && s.x * s.y * s.z < 0)

  1252.     {

  1253.         for (int i = m_cursors.Last().m2; i < m_indices.Count(); i += 3)

  1254.         {

  1255.             uint16_t tmp = m_indices[i + 0];

  1256.             m_indices[i + 0] = m_indices[i + 1];

  1257.             m_indices[i + 1] = tmp;

  1258.         }

  1259.     }

  1260. }

  1261. 

  1262. //-----------------------------------------------------------------------------

  1263. void EasyMesh::MirrorX() { DupAndScale(vec3(-1, 1, 1)); }

  1264. void EasyMesh::MirrorY() { DupAndScale(vec3(1, -1, 1)); }

  1265. void EasyMesh::MirrorZ() { DupAndScale(vec3(1, 1, -1)); }

  1266. 

  1267. //-----------------------------------------------------------------------------

  1268. void EasyMesh::DupAndScale(vec3 const &s)

  1269. {

  1270.     int vlen = m_vert.Count() - m_cursors.Last().m1;

  1271.     int tlen = m_indices.Count() - m_cursors.Last().m2;

  1272. 

  1273.     for (int i = 0; i < vlen; i++)

  1274.         AddDuplicateVertex(m_cursors.Last().m1++);

  1275. 

  1276.     for (int i = 0; i < tlen; i++)

  1277.         m_indices << m_indices[m_cursors.Last().m2++] + vlen;

  1278. 

  1279.     Scale(s);

  1280. 

  1281.     m_cursors.Last().m1 -= vlen;

  1282.     m_cursors.Last().m2 -= tlen;

  1283. }

  1284. 

  1285. //-----------------------------------------------------------------------------

  1286. void EasyMesh::AppendCylinder(int nsides, float h, float d1, float d2,

  1287.                               int dualside, int smooth, int close)

  1288. {

  1289.     //XXX : This operation is done to convert radius to diameter without changing all the code.

  1290.     float r1 = d1 * .5f;

  1291.     float r2 = d2 * .5f;

  1292. 

  1293.     //SAVE

  1294.     vec4 Saved_Color = BD()->Color();

  1295.     vec4 Saved_Color2 = BD()->Color2();

  1296.     vec2 Save_texcoord_offset = BD()->TexCoordOffset();

  1297.     vec2 Save_texcoord_scale = BD()->TexCoordScale();

  1298. 

  1299.     int vbase = m_vert.Count();

  1300. 

  1301.     mat3 rotmat = mat3::rotate(360.0f / (float)nsides, 0.f, 1.f, 0.f);

  1302.     vec3 p1(r1, -h * .5f, 0.f), p2(r2, h * .5f, 0.f), n;

  1303.     vec2 uv1(.0f, .0f), uv2(.0f, 1.0f), uvadd(1.0f / (float)nsides, .0f);

  1304.     if (close)

  1305.         SetTexCoordData(vec2(.0f), vec2(1.0f, .5f));

  1306. 

  1307.     /* Construct normal */

  1308.     if (r2 != .0f)

  1309.         n = vec3(r2, h * .5f, 0.f);

  1310.     else

  1311.         n = vec3(r1, h * .5f, 0.f);

  1312.     n.y = r1 * (r1 - r2) / h;

  1313.     if (!smooth)

  1314.         n = mat3::rotate(180.0f / nsides, 0.f, 1.f, 0.f) * n;

  1315.     n = normalize(n);

  1316. 

  1317.     /* FIXME: normals should be flipped in two-sided mode, but that

  1318.      * means duplicating the vertices again... */

  1319.     for (int i = 0; i < nsides; i++)

  1320.     {

  1321.         AddVertex(p1); SetCurVertNormal(n); SetCurVertTexCoord(uv1); SetCurVertTexCoord2(uv1);

  1322.         AddVertex(p2); SetCurVertNormal(n); SetCurVertTexCoord(uv2); SetCurVertTexCoord2(uv2);

  1323.         SetCurVertColor(BD()->Color2());

  1324. 

  1325.         if (smooth)

  1326.         {

  1327.             int j = (i + 1) % nsides;

  1328.             AppendQuad(j * 2, j * 2 + 1, i * 2 + 1, i * 2, vbase);

  1329.             if (dualside)

  1330.                 AppendQuad(i * 2, i * 2 + 1, j * 2 + 1, j * 2, vbase);

  1331.         }

  1332. 

  1333.         p1 = rotmat * p1; uv1 += uvadd;

  1334.         p2 = rotmat * p2; uv2 += uvadd;

  1335. 

  1336.         if (!smooth)

  1337.         {

  1338.             AddVertex(p1); SetCurVertNormal(n); SetCurVertTexCoord(uv1); SetCurVertTexCoord2(uv1);

  1339.             AddVertex(p2); SetCurVertNormal(n); SetCurVertTexCoord(uv2); SetCurVertTexCoord2(uv2);

  1340.             SetCurVertColor(BD()->Color2());

  1341. 

  1342.             AppendQuad(i * 4 + 2, i * 4 + 3, i * 4 + 1, i * 4, vbase);

  1343.             if (dualside)

  1344.                 AppendQuad(i * 4, i * 4 + 1, i * 4 + 3, i * 4 + 2, vbase);

  1345.         }

  1346. 

  1347.         n = rotmat * n;

  1348.     }

  1349. 

  1350.     if (close)

  1351.     {

  1352.         //START

  1353.         OpenBrace();

  1354.         //LOWER DISC

  1355.         SetTexCoordData(vec2(.0f, .5f), vec2(.5f, .5f));

  1356.         SetCurColor(BD()->Color());

  1357.         AppendDisc(nsides, d1);

  1358.         Translate(vec3(.0f, h, .0f));

  1359.         RotateX(180.0f);

  1360.         //UPPER DISC

  1361.         SetTexCoordData(vec2(.5f, .5f), vec2(.5f, .5f));

  1362.         SetCurColor(BD()->Color2());

  1363.         AppendDisc(nsides, d2);

  1364.         Translate(vec3(.0f, h * .5f, .0f));

  1365.         CloseBrace();

  1366.     }

  1367.     //RESTORE

  1368.     SetCurColor(Saved_Color);

  1369.     SetCurColor2(Saved_Color2);

  1370.     SetTexCoordData(Save_texcoord_offset, Save_texcoord_scale);

  1371. }

  1372. 

  1373. //-----------------------------------------------------------------------------

  1374. void EasyMesh::AppendSphere(int ndivisions, float d)

  1375. {

  1376.     AppendCapsule(ndivisions, 0.f, d);

  1377. }

  1378. 

  1379. //-----------------------------------------------------------------------------

  1380. void EasyMesh::AppendCapsule(int ndivisions, float h, float d)

  1381. {

  1382.     //XXX : This operation is done to convert radius to diameter without changing all the code.

  1383.     float r = d * .5f;

  1384. 

  1385.     int ibase = m_indices.Count();

  1386. 

  1387.     Array<vec3> vertices;

  1388.     float uv_h = 0;

  1389.     float uv_r = 0;

  1390. 

  1391.     /* FIXME: we don't know how to handle even-divided capsules, so we

  1392.      * force the count to be odd. */

  1393.     if (h)

  1394.     {

  1395.         ndivisions |= 1;

  1396.         //calculate uv h&r percents

  1397.         uv_h = (float)h / (float)(h + r * 2);

  1398.         uv_r = (float)r / (float)(h + r * 2);

  1399.     }

  1400. 

  1401.     /* Fill in the icosahedron vertices, rotating them so that there

  1402.      * is a vertex at [0 1 0] and [0 -1 0] after normalisation. */

  1403.     float phi = 0.5f + 0.5f * sqrt(5.f);

  1404.     mat3 mat = mat3::rotate(asin(1.f / sqrt(2.f + phi)) * (180.f / (float)M_PI),

  1405.                             vec3(0.f, 0.f, 1.f));

  1406.     for (int i = 0; i < 4; i++)

  1407.     {

  1408.         float x = (i & 1) ? 0.5f : -0.5f;

  1409.         float y = (i & 2) ? phi * 0.5f : phi * -0.5f;

  1410.         vertices << mat * vec3(x, y, 0.f);

  1411.         vertices << mat * vec3(0.f, x, y);

  1412.         vertices << mat * vec3(y, 0.f, x);

  1413.     }

  1414. 

  1415.     static int const trilist[] =

  1416.     {

  1417.         0, 1, 2, 2, 4, 6, 3, 8, 1, 9, 4, 8,

  1418.         7, 0, 5, 7, 11, 3, 10, 5, 6, 10, 9, 11,

  1419. 

  1420.         0, 3, 1, 7, 3, 0, 1, 4, 2, 8, 4, 1,

  1421.         2, 5, 0, 6, 5, 2, 6, 9, 10, 4, 9, 6,

  1422.         7, 10, 11, 5, 10, 7, 8, 11, 9, 3, 11, 8

  1423.     };

  1424. 

  1425.     for (unsigned i = 0; i < sizeof(trilist) / sizeof(*trilist); i += 3)

  1426.     {

  1427.         vec3 const &a = vertices[trilist[i]];

  1428.         vec3 const &b = vertices[trilist[i + 1]];

  1429.         vec3 const &c = vertices[trilist[i + 2]];

  1430. 

  1431.         vec3 const vb = 1.f / ndivisions * (b - a);

  1432.         vec3 const vc = 1.f / ndivisions * (c - a);

  1433. 

  1434.         int line = ndivisions + 1;

  1435. 

  1436.         for (int v = 0, x = 0, y = 0; x < ndivisions + 1; v++)

  1437.         {

  1438.             vec3 p[] = { a + (float)x * vb + (float)y * vc,

  1439.                          p[0] + vb,

  1440.                          p[0] + vc,

  1441.                          p[0] + vb + vc };

  1442.             vec2 uv[4];

  1443. 

  1444.             /* FIXME: when we normalise here, we get a volume that is slightly

  1445.              * smaller than the sphere of radius 1, since we are not using

  1446.              * the midradius. */

  1447.             for (int k = 0; k < 4; k++)

  1448.             {

  1449.                 //keep normalized until the end of the UV calculations

  1450.                 p[k] = normalize(p[k]);

  1451. 

  1452.                 uv[k].x = (lol::atan2(p[k].z, p[k].x) + (float)M_PI) / ((float)M_PI * 2.f);

  1453.                 if (abs(p[k].y) >= 1.0f)

  1454.                     uv[k].x = -1.f;

  1455.                 uv[k].y = lol::atan2(p[k].y, dot(p[k], normalize(p[k] * vec3(1.f,0.f,1.f)))) / (float)M_PI + 0.5f;

  1456.                 if (h)

  1457.                 {

  1458.                     if (uv[k].y > .5f)

  1459.                         uv[k].y = uv_r + uv_h + (uv[k].y - .5f) * uv_r * 2.f;

  1460.                     else

  1461.                         uv[k].y *= uv_r * 2.f;

  1462.                 }

  1463.                 p[k] *= r;

  1464.             }

  1465. 

  1466.             /* If this is a capsule, grow in the Y direction */

  1467.             if (h > 0.f)

  1468.             {

  1469.                 for (int k = 0; k < 4; k++)

  1470.                     p[k].y += (p[k].y > 0.f) ? 0.5f * h : -0.5f * h;

  1471.             }

  1472. 

  1473.             /* Add zero, one or two triangles */

  1474.             int id[] = { 0, 1, 2,

  1475.                          1, 3 ,2 };

  1476.             int l = 6;

  1477.             while ((l -= 3) >= 0)

  1478.             {

  1479.                 if ((l == 0 && y < line - 1) || (l == 3 && y < line - 2))

  1480.                 {

  1481.                     int k = -1;

  1482.                     while (++k < 3)

  1483.                     {

  1484.                         int rid[] = { id[k + l], id[(k + 1) % 3 + l] };

  1485.                         if (uv[rid[0]].x >= .0f &&

  1486.                             uv[rid[1]].x >= .0f &&

  1487.                             abs(uv[rid[0]].x - uv[rid[1]].x) > .5f)

  1488.                         {

  1489.                             if (uv[rid[0]].x < uv[rid[1]].x)

  1490.                                 uv[rid[0]].x += 1.0f;

  1491.                             else

  1492.                                 uv[rid[1]].x += 1.0f;

  1493.                         }

  1494.                     }

  1495.                     k = -1;

  1496.                     while (++k < 3)

  1497.                     {

  1498.                         int rid[] = { id[k + l], id[(k + 1) % 3 + l], id[(k + 2) % 3 + l] };

  1499.                         AddVertex(p[rid[0]]);

  1500.                         vec2 new_uv;

  1501.                         if (uv[rid[0]].x < .0f)

  1502.                             new_uv = vec2((uv[rid[1]].x + uv[rid[2]].x) * .5f, uv[rid[0]].y);

  1503.                         else

  1504.                             new_uv = uv[rid[0]];

  1505.                         SetCurVertTexCoord(vec2(0.f, 1.f) - new_uv);

  1506.                         SetCurVertTexCoord2(vec2(0.f, 1.f) - new_uv);

  1507.                     }

  1508.                     AppendTriangle(0, 2, 1, m_vert.Count() - 3);

  1509.                 }

  1510.             }

  1511. 

  1512.             y++;

  1513.             if (y == line)

  1514.             {

  1515.                 x++;

  1516.                 y = 0;

  1517.                 line--;

  1518.             }

  1519.         }

  1520.     }

  1521. 

  1522.     ComputeNormals(ibase, m_indices.Count() - ibase);

  1523. }

  1524. 

  1525. //-----------------------------------------------------------------------------

  1526. void EasyMesh::AppendTorus(int ndivisions, float d1, float d2)

  1527. {

  1528.     //XXX : This operation is done to convert radius to diameter without changing all the code.

  1529.     float r1 = d1 * .5f;

  1530.     float r2 = d2 * .5f;

  1531. 

  1532.     int ibase = m_indices.Count();

  1533.     int nidiv = ndivisions; /* Cross-section */

  1534.     int njdiv = ndivisions; /* Full circumference */

  1535. 

  1536.     for (int j = 0; j < njdiv; j++)

  1537.     for (int i = 0; i < 2 * nidiv; i++)

  1538.     {

  1539.         for (int di = 0; di < 2; di++)

  1540.         for (int dj = 0; dj < 2; dj++)

  1541.         {

  1542.             int i2 = (i + di) % nidiv;

  1543.             int j2 = (j + dj) % njdiv;

  1544. 

  1545.             //Location on the donut

  1546.             float x = 0.5f * (r2 - r1) * (float)lol::cos(2.0 * M_PI * i2 / nidiv) + 0.5f * (r1 + r2);

  1547.             float y = 0.5f * (r2 - r1) * (float)lol::sin(2.0 * M_PI * i2 / nidiv);

  1548.             float z = 0.0f;

  1549. 

  1550.             //Center circle

  1551.             float ca = (float)lol::cos(2.0 * M_PI * j2 / njdiv);

  1552.             float sa = (float)lol::sin(2.0 * M_PI * j2 / njdiv);

  1553. 

  1554.             //Actual location

  1555.             float x2 = x * ca - z * sa;

  1556.             float z2 = z * ca + x * sa;

  1557. 

  1558.             AddVertex(vec3(x2, y, z2));

  1559.             SetCurVertTexCoord(vec2((float)(i + di) / (float)nidiv, (float)(j + dj) / (float)nidiv));

  1560.             SetCurVertTexCoord2(vec2((float)(i + di) / (float)nidiv, (float)(j + dj) / (float)nidiv));

  1561.         }

  1562. 

  1563.         AppendTriangle(0, 2, 3, m_vert.Count() - 4);

  1564.         AppendTriangle(0, 3, 1, m_vert.Count() - 4);

  1565.     }

  1566. 

  1567.     ComputeNormals(ibase, m_indices.Count() - ibase);

  1568. }

  1569. 

  1570. //-----------------------------------------------------------------------------

  1571. void EasyMesh::AppendBox(vec3 const &size, float chamf)

  1572. {

  1573.     AppendBox(size, chamf, false);

  1574. }

  1575. 

  1576. //-----------------------------------------------------------------------------

  1577. void EasyMesh::AppendSmoothChamfBox(vec3 const &size, float chamf)

  1578. {

  1579.     AppendBox(size, chamf, true);

  1580. }

  1581. 

  1582. //-----------------------------------------------------------------------------

  1583. void EasyMesh::AppendFlatChamfBox(vec3 const &size, float chamf)

  1584. {

  1585.     AppendBox(size, chamf, false);

  1586. }

  1587. 

  1588. //-----------------------------------------------------------------------------

  1589. void EasyMesh::AppendBox(vec3 const &size, float chamf, bool smooth)

  1590. {

  1591.     if (chamf < 0.0f)

  1592.     {

  1593.         AppendBox(size + vec3(chamf * 2.0f), -chamf, smooth);

  1594.         return;

  1595.     }

  1596. 

  1597.     int vbase = m_vert.Count();

  1598.     int ibase = m_indices.Count();

  1599. 

  1600.     vec3 d = size * 0.5f;

  1601. 

  1602.     MeshType mt = MeshType::Box;

  1603.     TexCoordPos bl = TexCoordPos::BL;

  1604.     TexCoordPos br = TexCoordPos::BR;

  1605.     TexCoordPos tl = TexCoordPos::TL;

  1606.     TexCoordPos tr = TexCoordPos::TR;

  1607. 

  1608.     //--

  1609.     //Side vertices

  1610.     //--

  1611.     MeshFaceType mft = MeshFaceType::BoxFront;

  1612.     AddVertex(vec3(-d.x, -d.y, -d.z - chamf));

  1613.     SetCurVertTexCoord(BD()->TexCoord(mt, tr, mft));

  1614.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1615.     //--

  1616.     AddVertex(vec3(-d.x, +d.y, -d.z - chamf));

  1617.     SetCurVertTexCoord(BD()->TexCoord(mt, br, mft));

  1618.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1619.     //--

  1620.     AddVertex(vec3(+d.x, +d.y, -d.z - chamf));

  1621.     SetCurVertTexCoord(BD()->TexCoord(mt, bl, mft));

  1622.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1623.     //--

  1624.     AddVertex(vec3(+d.x, -d.y, -d.z - chamf));

  1625.     SetCurVertTexCoord(BD()->TexCoord(mt, tl, mft));

  1626.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1627. 

  1628.     //--

  1629.     mft = MeshFaceType::BoxLeft;

  1630.     AddVertex(vec3(-d.x - chamf, -d.y, +d.z));

  1631.     SetCurVertTexCoord(BD()->TexCoord(mt, tr, mft));

  1632.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1633.     //--

  1634.     AddVertex(vec3(-d.x - chamf, +d.y, +d.z));

  1635.     SetCurVertTexCoord(BD()->TexCoord(mt, br, mft));

  1636.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1637.     //--

  1638.     AddVertex(vec3(-d.x - chamf, +d.y, -d.z));

  1639.     SetCurVertTexCoord(BD()->TexCoord(mt, bl, mft));

  1640.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1641.     //--

  1642.     AddVertex(vec3(-d.x - chamf, -d.y, -d.z));

  1643.     SetCurVertTexCoord(BD()->TexCoord(mt, tl, mft));

  1644.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1645. 

  1646.     //--

  1647.     mft = MeshFaceType::BoxBack;

  1648.     AddVertex(vec3(+d.x, -d.y, +d.z + chamf));

  1649.     SetCurVertTexCoord(BD()->TexCoord(mt, tr, mft));

  1650.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1651.     //--

  1652.     AddVertex(vec3(+d.x, +d.y, +d.z + chamf));

  1653.     SetCurVertTexCoord(BD()->TexCoord(mt, br, mft));

  1654.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1655.     //--

  1656.     AddVertex(vec3(-d.x, +d.y, +d.z + chamf));

  1657.     SetCurVertTexCoord(BD()->TexCoord(mt, bl, mft));

  1658.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1659.     //--

  1660.     AddVertex(vec3(-d.x, -d.y, +d.z + chamf));

  1661.     SetCurVertTexCoord(BD()->TexCoord(mt, tl, mft));

  1662.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1663. 

  1664.     //--

  1665.     mft = MeshFaceType::BoxRight;

  1666.     AddVertex(vec3(+d.x + chamf, -d.y, -d.z));

  1667.     SetCurVertTexCoord(BD()->TexCoord(mt, tr, mft));

  1668.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1669.     //--

  1670.     AddVertex(vec3(+d.x + chamf, +d.y, -d.z));

  1671.     SetCurVertTexCoord(BD()->TexCoord(mt, br, mft));

  1672.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1673.     //--

  1674.     AddVertex(vec3(+d.x + chamf, +d.y, +d.z));

  1675.     SetCurVertTexCoord(BD()->TexCoord(mt, bl, mft));

  1676.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1677.     //--

  1678.     AddVertex(vec3(+d.x + chamf, -d.y, +d.z));

  1679.     SetCurVertTexCoord(BD()->TexCoord(mt, tl, mft));

  1680.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1681. 

  1682.     //--

  1683.     //Bottom vertices

  1684.     //--

  1685.     mft = MeshFaceType::BoxBottom;

  1686.     AddVertex(vec3(-d.x, -d.y - chamf, +d.z));

  1687.     SetCurVertTexCoord(BD()->TexCoord(mt, tr, mft));

  1688.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1689.     //--

  1690.     AddVertex(vec3(-d.x, -d.y - chamf, -d.z));

  1691.     SetCurVertTexCoord(BD()->TexCoord(mt, br, mft));

  1692.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1693.     //--

  1694.     AddVertex(vec3(+d.x, -d.y - chamf, -d.z));

  1695.     SetCurVertTexCoord(BD()->TexCoord(mt, bl, mft));

  1696.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1697.     //--

  1698.     AddVertex(vec3(+d.x, -d.y - chamf, +d.z));

  1699.     SetCurVertTexCoord(BD()->TexCoord(mt, tl, mft));

  1700.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1701. 

  1702.     //--

  1703.     //Top vertices

  1704.     //--

  1705.     mft = MeshFaceType::BoxTop;

  1706.     AddVertex(vec3(-d.x, +d.y + chamf, -d.z));

  1707.     SetCurVertTexCoord(BD()->TexCoord(mt, tr, mft));

  1708.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1709.     //--

  1710.     AddVertex(vec3(-d.x, +d.y + chamf, +d.z));

  1711.     SetCurVertTexCoord(BD()->TexCoord(mt, br, mft));

  1712.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1713.     //--

  1714.     AddVertex(vec3(+d.x, +d.y + chamf, +d.z));

  1715.     SetCurVertTexCoord(BD()->TexCoord(mt, bl, mft));

  1716.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1717.     //--

  1718.     AddVertex(vec3(+d.x, +d.y + chamf, -d.z));

  1719.     SetCurVertTexCoord(BD()->TexCoord(mt, tl, mft));

  1720.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1721. 

  1722.     /* The 6 quads on each side of the box */

  1723.     for (int i = 0; i < 24; i += 4)

  1724.         AppendQuad(i, i + 1, i + 2, i + 3, vbase);

  1725. 

  1726.     ComputeNormals(ibase, m_indices.Count() - ibase);

  1727.     ibase = m_indices.Count();

  1728. 

  1729.     /* The 8 quads at each edge of the box */

  1730.     if (chamf)

  1731.     {

  1732.         static int const quadlist[48] =

  1733.         {

  1734.             0, 3, 18, 17, 4, 7, 17, 16, 8, 11, 16, 19, 12, 15, 19, 18,

  1735.             2, 1, 20, 23, 6, 5, 21, 20, 10, 9, 22, 21, 14, 13, 23, 22,

  1736.             1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12, 3, 2,

  1737.         };

  1738. 

  1739.         for (int i = 0; i < 48; i += 4)

  1740.         {

  1741.             if (smooth)

  1742.                 AppendQuad(quadlist[i], quadlist[i + 1],

  1743.                            quadlist[i + 2], quadlist[i + 3], vbase);

  1744.             else

  1745.                 AppendQuadDuplicateVerts(quadlist[i], quadlist[i + 1],

  1746.                                  quadlist[i + 2], quadlist[i + 3], vbase);

  1747.         }

  1748.     }

  1749. 

  1750.     /* The 8 triangles at each corner of the box */

  1751.     if (chamf)

  1752.     {

  1753.         static int const trilist[24] =

  1754.         {

  1755.             3, 12, 18, 15, 8, 19, 11, 4, 16, 7, 0, 17,

  1756.             2, 23, 13, 14, 22, 9, 10, 21, 5, 6, 20, 1,

  1757.         };

  1758. 

  1759.         for (int i = 0; i < 24; i += 3)

  1760.         {

  1761.             if (smooth)

  1762.                 AppendTriangle(trilist[i], trilist[i + 1],

  1763.                                trilist[i + 2], vbase);

  1764.             else

  1765.                 AppendTriangleDuplicateVerts(trilist[i], trilist[i + 1],

  1766.                                              trilist[i + 2], vbase);

  1767.         }

  1768.     }

  1769. 

  1770.     if (!smooth)

  1771.         ComputeNormals(ibase, m_indices.Count() - ibase);

  1772. }

  1773. 

  1774. //-----------------------------------------------------------------------------

  1775. void EasyMesh::AppendStar(int nbranches, float d1, float d2,

  1776.                           int fade, int fade2)

  1777. {

  1778.     //XXX : This operation is done to convert radius to diameter without changing all the code.

  1779.     float r1 = d1 * .5f;

  1780.     float r2 = d2 * .5f;

  1781. 

  1782.     //TODO: It would probably be good to think of another way of UV painting this, like "branch repeating"

  1783.     int vbase = m_vert.Count();

  1784.     float maxr = max(r1, r2);

  1785. 

  1786.     AddVertex(vec3(0.f, 0.f, 0.f)); SetCurVertTexCoord(vec2(.5f, .5f)); SetCurVertTexCoord2(vec2(.5f, .5f));

  1787. 

  1788.     mat3 rotmat = mat3::rotate(180.0f / nbranches, 0.f, 1.f, 0.f);

  1789.     vec3 p1(r1, 0.f, 0.f), p2(r2, 0.f, 0.f);

  1790.     vec3 uv1(0.f, 0.f, -.5f * ((float)r1 / maxr)),

  1791.          uv2(0.f, 0.f, -.5f * ((float)r2 / maxr));

  1792. 

  1793.     p2 = rotmat * p2; uv2 = rotmat * uv2;

  1794.     rotmat = rotmat * rotmat;

  1795. 

  1796.     for (int i = 0; i < nbranches; i++)

  1797.     {

  1798.         AddVertex(p1); SetCurVertTexCoord(uv1.xz + vec2(.5f)); SetCurVertTexCoord2(uv1.xz + vec2(.5f));

  1799.         if (fade2)

  1800.             SetCurVertColor(BD()->Color2());

  1801. 

  1802.         AddVertex(p2); SetCurVertTexCoord(uv2.xz + vec2(.5f)); SetCurVertTexCoord2(uv2.xz + vec2(.5f));

  1803.         if (fade)

  1804.             SetCurVertColor(BD()->Color2());

  1805. 

  1806.         AppendQuad(0, 2 * i + 1, 2 * i + 2, (2 * i + 3) % (2 * nbranches),

  1807.                    vbase);

  1808. 

  1809.         p1 = rotmat * p1; uv1 = rotmat * uv1;

  1810.         p2 = rotmat * p2; uv2 = rotmat * uv2;

  1811.     }

  1812. }

  1813. 

  1814. //-----------------------------------------------------------------------------

  1815. void EasyMesh::AppendExpandedStar(int nbranches, float d1, float d2, float extrad)

  1816. {

  1817.     //XXX : This operation is done to convert radius to diameter without changing all the code.

  1818.     float r1 = d1 * .5f;

  1819.     float r2 = d2 * .5f;

  1820.     float extrar = extrad * .5f;

  1821. 

  1822.     int vbase = m_vert.Count();

  1823.     float maxr = (float)max(max(r1, r2), max(r1 + extrar, r2 + extrar));

  1824. 

  1825.     AddVertex(vec3(0.f, 0.f, 0.f)); SetCurVertTexCoord(vec2(.5f, .5f)); SetCurVertTexCoord2(vec2(.5f, .5f));

  1826. 

  1827.     mat3 rotmat = mat3::rotate(180.0f / nbranches, 0.f, 1.f, 0.f);

  1828.     vec3 p1(r1, 0.f, 0.f), p2(r2, 0.f, 0.f),

  1829.          p3(r1 + extrar, 0.f, 0.f), p4(r2 + extrar, 0.f, 0.f);;

  1830.     vec3 uv1(0.f, 0.f, -.5f * ((float)r1 / maxr)),

  1831.          uv2(0.f, 0.f, -.5f * ((float)r2 / maxr)),

  1832.          uv3(0.f, 0.f, -.5f * ((float)(r1 + extrar) / maxr)),

  1833.          uv4(0.f, 0.f, -.5f * ((float)(r2 + extrar) / maxr));

  1834. 

  1835.     p2 = rotmat * p2; uv2 = rotmat * uv2;

  1836.     p4 = rotmat * p4; uv4 = rotmat * uv4;

  1837.     rotmat = rotmat * rotmat;

  1838. 

  1839.     for (int i = 0; i < nbranches; i++)

  1840.     {

  1841.         AddVertex(p1); SetCurVertTexCoord(uv1.xz + vec2(.5f)); SetCurVertTexCoord2(uv1.xz + vec2(.5f));

  1842.         AddVertex(p2); SetCurVertTexCoord(uv2.xz + vec2(.5f)); SetCurVertTexCoord2(uv2.xz + vec2(.5f));

  1843.         AddVertex(p3); SetCurVertTexCoord(uv3.xz + vec2(.5f)); SetCurVertTexCoord2(uv3.xz + vec2(.5f)); SetCurVertColor(BD()->Color2());

  1844.         AddVertex(p4); SetCurVertTexCoord(uv4.xz + vec2(.5f)); SetCurVertTexCoord2(uv4.xz + vec2(.5f)); SetCurVertColor(BD()->Color2());

  1845. 

  1846.         int j = (i + 1) % nbranches;

  1847.         AppendQuad(0, 4 * i + 1, 4 * i + 2, 4 * j + 1, vbase);

  1848.         AppendQuad(4 * i + 1, 4 * i + 3, 4 * i + 4, 4 * i + 2, vbase);

  1849.         AppendQuad(4 * j + 1, 4 * i + 2, 4 * i + 4, 4 * j + 3, vbase);

  1850. 

  1851.         p1 = rotmat * p1; uv1 = rotmat * uv1;

  1852.         p2 = rotmat * p2; uv2 = rotmat * uv2;

  1853.         p3 = rotmat * p3; uv3 = rotmat * uv3;

  1854.         p4 = rotmat * p4; uv4 = rotmat * uv4;

  1855.     }

  1856. }

  1857. 

  1858. //-----------------------------------------------------------------------------

  1859. void EasyMesh::AppendDisc(int nsides, float d, int fade)

  1860. {

  1861.     //XXX : This operation is done to convert radius to diameter without changing all the code.

  1862.     float r = d * .5f;

  1863. 

  1864.     int vbase = m_vert.Count();

  1865. 

  1866.     AddVertex(vec3(0.f, 0.f, 0.f)); SetCurVertTexCoord(vec2(.5f, .5f)); SetCurVertTexCoord2(vec2(.5f, .5f));

  1867. 

  1868.     mat3 rotmat = mat3::rotate(360.0f / nsides, 0.f, 1.f, 0.f);

  1869.     vec3 p1(r, 0.f, 0.f);

  1870.     vec3 uv(.5f, .0f, .0f);

  1871. 

  1872.     for (int i = 0; i < nsides; i++)

  1873.     {

  1874.         AddVertex(p1); SetCurVertTexCoord(uv.xz + vec2(.5f, .5f)); SetCurVertTexCoord2(uv.xz + vec2(.5f, .5f));

  1875.         if (fade)

  1876.             SetCurVertColor(BD()->Color2());

  1877.         AppendTriangle(0, i + 1, ((i + 1) % nsides) + 1, vbase);

  1878.         p1 = rotmat * p1;

  1879.         uv = rotmat * uv;

  1880.     }

  1881. }

  1882. 

  1883. //-----------------------------------------------------------------------------

  1884. void EasyMesh::AppendSimpleTriangle(float d, int fade)

  1885. {

  1886.     //XXX : This operation is done to convert radius to diameter without changing all the code.

  1887.     float size = d * .5f;

  1888. 

  1889.     mat3 m = mat3::rotate(120.f, 0.f, 1.f, 0.f);

  1890.     vec3 p(0.f, 0.f, size);

  1891. 

  1892.     AddVertex(p); SetCurVertTexCoord(vec2(.5f, 0.133975f)); SetCurVertTexCoord2(vec2(.5f, 0.133975f));

  1893.     p = m * p;

  1894.     AddVertex(p); SetCurVertTexCoord(vec2(0.f, 1.f)); SetCurVertTexCoord2(vec2(0.f, 1.f));

  1895.     if (fade)

  1896.         SetCurVertColor(BD()->Color2());

  1897.     p = m * p;

  1898.     AddVertex(p); SetCurVertTexCoord(vec2(1.f, 1.f)); SetCurVertTexCoord2(vec2(1.f, 1.f));

  1899.     if (fade)

  1900.         SetCurVertColor(BD()->Color2());

  1901. 

  1902.     AppendTriangle(0, 1, 2, m_vert.Count() - 3);

  1903. }

  1904. 

  1905. //-----------------------------------------------------------------------------

  1906. void EasyMesh::AppendSimpleQuad(float size, int fade)

  1907. {

  1908.     AppendSimpleQuad(vec2(size * .5f), vec2(size * -.5f), 0.f, fade);

  1909. }

  1910. 

  1911. //-----------------------------------------------------------------------------

  1912. void EasyMesh::AppendSimpleQuad(vec2 p1, vec2 p2, float z, int fade)

  1913. {

  1914.     MeshType mt = MeshType::Quad;

  1915.     MeshFaceType mft = MeshFaceType::QuadDefault;

  1916. 

  1917.     //--

  1918.     AddVertex(vec3(p2.x, z, -p1.y));

  1919.     TexCoordPos br = TexCoordPos::BR;

  1920.     SetCurVertTexCoord(BD()->TexCoord(mt, br, mft));

  1921.     SetCurVertTexCoord2(BD()->TexCoord2(mt, br, mft));

  1922.     //--

  1923.     AddVertex(vec3(p2.x, z, -p2.y));

  1924.     TexCoordPos bl = TexCoordPos::BL;

  1925.     SetCurVertTexCoord(BD()->TexCoord(mt, bl, mft));

  1926.     SetCurVertTexCoord2(BD()->TexCoord2(mt, bl, mft));

  1927.     //--

  1928.     AddVertex(vec3(p1.x, z, -p2.y));

  1929.     TexCoordPos tl = TexCoordPos::TL;

  1930.     SetCurVertTexCoord(BD()->TexCoord(mt, tl, mft));

  1931.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tl, mft));

  1932.     if (fade) SetCurVertColor(BD()->Color2());

  1933.     //--

  1934.     AddVertex(vec3(p1.x, z, -p1.y));

  1935.     TexCoordPos tr = TexCoordPos::TR;

  1936.     SetCurVertTexCoord(BD()->TexCoord(mt, tr, mft));

  1937.     SetCurVertTexCoord2(BD()->TexCoord2(mt, tr, mft));

  1938.     if (fade) SetCurVertColor(BD()->Color2());

  1939. 

  1940.     AppendQuad(0, 1, 2, 3, m_vert.Count() - 4);

  1941.     ComputeNormals(m_indices.Count() - 6, 6);

  1942. }

  1943. 

  1944. //-----------------------------------------------------------------------------

  1945. void EasyMesh::AppendCog(int nbsides, float h, float d10, float d20,

  1946.                          float d1, float d2, float d12, float d22,

  1947.                          float sidemul, int offset)

  1948. {

  1949.     //XXX : This operation is done to convert radius to diameter without changing all the code.

  1950.     float r10 = d10 * .5f;

  1951.     float r20 = d20 * .5f;

  1952.     float r1  = d1  * .5f;

  1953.     float r2  = d2  * .5f;

  1954.     float r12 = d12 * .5f;

  1955.     float r22 = d22 * .5f;

  1956. 

  1957.     int ibase = m_indices.Count();

  1958.     int vbase = m_vert.Count();

  1959. 

  1960.     /* FIXME: enforce this some other way */

  1961.     if (r12 < 0)

  1962.         h = -h;

  1963. 

  1964.     mat3 rotmat = mat3::rotate(180.0f / nbsides, 0.f, 1.f, 0.f);

  1965.     mat3 smat1 = mat3::rotate(sidemul * 180.0f / nbsides, 0.f, 1.f, 0.f);

  1966.     mat3 smat2 = mat3::rotate(sidemul * -360.0f / nbsides, 0.f, 1.f, 0.f);

  1967. 

  1968.     vec3 p[12];

  1969. 

  1970.     //Upper points

  1971.     p[0] = vec3(r10, h * .5f, 0.f);

  1972.     p[1] = rotmat * p[0];

  1973.     p[2] = vec3(r1, h * .5f, 0.f);

  1974.     p[3] = rotmat * p[2];

  1975.     p[4] = smat1 * (rotmat * vec3(r1 + r12, h * .5f, 0.f));

  1976.     p[5] = smat2 * (rotmat * p[4]);

  1977. 

  1978.     //Lower points

  1979.     p[6] = vec3(r20, h * -.5f, 0.f);

  1980.     p[7] = rotmat * p[6];

  1981.     p[8] = vec3(r2, h * -.5f, 0.f);

  1982.     p[9] = rotmat * p[8];

  1983.     p[10] = smat1 * (rotmat * vec3(r2 + r22, h * -.5f, 0.f));

  1984.     p[11] = smat2 * (rotmat * p[10]);

  1985. 

  1986.     if (offset & 1)

  1987.         for (int n = 0; n < 12; n++)

  1988.             p[n] = rotmat * p[n];

  1989. 

  1990.     rotmat = rotmat * rotmat;

  1991. 

  1992.     //UV base computation

  1993.     float maxr = max(max(r1 + r12, r2 + r22), max(r10, r20));

  1994.     float InLn = length(p[1] - p[0]);

  1995.     float CogLn[8] = { .0f, .0f, .0f, .0f, .0f, .0f, .0f, .0f };

  1996.     for (int i = 0; i < 3; i++)

  1997.     {

  1998.         for (int j = 0, k = 2; j < 8 && k < 12; j += 4, k += 6)

  1999.         {

  2000.             CogLn[j + i] = length(p[k + i + 1] - p[k + i]);

  2001.             CogLn[j + 3] += CogLn[j + i];

  2002.             if (i == 1) //Add 3to4 twice since it's automatically completed by +1 loop.

  2003.                 CogLn[j + 3] += CogLn[j + i];

  2004.         }

  2005.     }

  2006. 

  2007.     //Choose the biggest cog length

  2008.     int CogSrc = (CogLn[7] > CogLn[3])?(4):(0);

  2009.     CogLn[3] = CogLn[CogSrc + 3];

  2010.     for (int i = 0; i < 3; i++)

  2011.         CogLn[i] = CogLn[CogSrc + i] / CogLn[CogSrc + 3];

  2012. 

  2013.     //Calculate Cog Modifiers

  2014.     vec2 InUV[2] = { vec2(.0f), vec2(.5f) };

  2015.     vec2 CogUV[2] = { vec2(.0f), vec2(.5f) };

  2016.     vec2 upadd = vec2(.25f, .75f);

  2017.     vec2 lowadd = vec2(.75f, .75f);

  2018.     {

  2019.         if (h < InLn)

  2020.         {

  2021.             InUV[0].x  = 1.0f;

  2022.             InUV[0].y  = h / InLn;

  2023.             InUV[1].x  = .0f;

  2024.             InUV[1].y -= InUV[0].y * .5f;

  2025.         }

  2026.         else

  2027.         {

  2028.             InUV[0].x  = InLn / h;

  2029.             InUV[0].y  = 1.0f;

  2030.             InUV[1].x -= InUV[0].x * .5f;

  2031.             InUV[1].y = .0f;

  2032.         }

  2033.         if (h < CogLn[3])

  2034.         {

  2035.             CogUV[0].x  = 1.0f;

  2036.             CogUV[0].y  = h / CogLn[3];

  2037.             CogUV[1].x  = .0f;

  2038.             CogUV[1].y -= CogUV[0].y * .5f;

  2039.         }

  2040.         else

  2041.         {

  2042.             CogUV[0].x  = CogLn[3] / h;

  2043.             CogUV[0].y  = 1.0f;

  2044.             CogUV[1].x -= CogUV[0].x * .5f;

  2045.             CogUV[1].y  = .0f;

  2046.         }

  2047.         if (InUV[0].x + CogUV[0].x < .5f)

  2048.         {

  2049.             InUV[1].x = .0f;

  2050.             CogUV[1].x = .5f - CogUV[0].x;

  2051.             upadd  = vec2(.75f, .25f);

  2052.             lowadd = vec2(.75f, .75f);

  2053.         }

  2054.         else if (InUV[0].y + CogUV[0].y < .5f)

  2055.         {

  2056.             InUV[1].y = .0f;

  2057.             CogUV[1].y = .5f - CogUV[0].y;

  2058.         }

  2059.         else

  2060.         {

  2061.             InUV[0] *= .5f;

  2062.             InUV[1] *= .5f;

  2063.             CogUV[0] *= .5f;

  2064.             CogUV[1] *= .5f;

  2065.             InUV[1] += vec2(.5f, .0f);

  2066.         }

  2067.     }

  2068. 

  2069.     //Build UV tab

  2070.     vec2 uv[12]; float CogSz;

  2071.     //Upper points

  2072.     CogSz = 1.0f - CogLn[1];

  2073.     uv[0]  = vec2(0.f,   0.f) * InUV[0]  + InUV[1];

  2074.     uv[1]  = vec2(1.f,   0.f) * InUV[0]  + InUV[1];

  2075.     uv[5]  = vec2(CogSz, 0.f) * CogUV[0] + CogUV[1]; CogSz -= CogLn[2];

  2076.     uv[4]  = vec2(CogSz, 0.f) * CogUV[0] + CogUV[1]; CogSz -= CogLn[1];

  2077.     uv[3]  = vec2(CogSz, 0.f) * CogUV[0] + CogUV[1]; CogSz -= CogLn[0];

  2078.     uv[2]  = vec2(0.f,   0.f) * CogUV[0] + CogUV[1];

  2079. 

  2080.     //Lower points

  2081.     CogSz = 1.0f - CogLn[1];

  2082.     uv[6]  = vec2(0.f,   1.f) * InUV[0]  + InUV[1];

  2083.     uv[7]  = vec2(1.f,   1.f) * InUV[0]  + InUV[1];

  2084.     uv[11] = vec2(CogSz, 1.f) * CogUV[0] + CogUV[1]; CogSz -= CogLn[2];

  2085.     uv[10] = vec2(CogSz, 1.f) * CogUV[0] + CogUV[1]; CogSz -= CogLn[1];

  2086.     uv[ 9] = vec2(CogSz, 1.f) * CogUV[0] + CogUV[1]; CogSz -= CogLn[0];

  2087.     uv[ 8] = vec2(0.f,   1.f) * CogUV[0] + CogUV[1];

  2088. 

  2089.     //Gear generation loop

  2090.     for (int i = 0; i < nbsides; i++)

  2091.     {

  2092.         int j = 3 * 12 * i,

  2093.             k = 3 * 12 * ((i + 1) % nbsides);

  2094. 

  2095.         int q[] = { /* The top and bottom faces */

  2096.                     j, j, j, j,

  2097.                     j, j, j, j,

  2098.                     j, j, k, k,

  2099.                     k, k, j, j,

  2100.                     j, j, j, k,

  2101.                     k, j, j, j,

  2102.                     /* The inner side quads */

  2103.                     j, j, j, j,

  2104.                     j, k, k, j,

  2105.                     /* The outer side quads */

  2106.                     j, j, j, j,

  2107.                     j, j, j, j,

  2108.                     j, j, j, j,

  2109.                     k, j, j, k

  2110.                     };

  2111.         int m[] = { /* The top and bottom faces */

  2112.                     0,  2,  3,  1,

  2113.                     7,  9,  8,  6,

  2114.                     1,  3,  2,  0,

  2115.                     6,  8,  9,  7,

  2116.                     3,  4,  5,  2,

  2117.                     8, 11, 10,  9,

  2118.                     /* The inner side quads */

  2119.                     0,  1,  7,  6,

  2120.                     1,  0,  6,  7,

  2121.                     /* The outer side quads */

  2122.                     3,  2,  8,  9,

  2123.                     4,  3,  9, 10,

  2124.                     5,  4, 10, 11,

  2125.                     2,  5, 11, 8

  2126.                     };

  2127.         int a[] = { /* The top and bottom faces */

  2128.                     0, 0, 0, 0,

  2129.                     0, 0, 0, 0,

  2130.                     0, 0, 0, 0,

  2131.                     0, 0, 0, 0,

  2132.                     0, 0, 0, 0,

  2133.                     0, 0, 0, 0,

  2134.                     /* The inner side quads */

  2135.                     1, 1, 1, 1,

  2136.                     2, 2, 2, 2,

  2137.                     /* The outer side quads */

  2138.                     1, 1, 1, 1,

  2139.                     1, 2, 2, 1,

  2140.                     1, 2, 2, 1,

  2141.                     2, 2, 2, 2

  2142.                     };

  2143. 

  2144.         /* Each vertex will share three faces, so three different

  2145.          * normals, therefore we add each vertex three times. */

  2146.         for (int n = 0; n < 3 * 12; n++)

  2147.         {

  2148.             int d = n / 3;

  2149.             int m = d % 6;

  2150.             AddVertex(p[d]);

  2151.             if (n % 3 == 0) //Top-Bottom logic

  2152.             {

  2153.                 vec2 tmp = (p[d].xz / maxr);

  2154.                 vec2 add;

  2155.                 if (d >= 6)

  2156.                 {

  2157.                     tmp *= -1.0f;

  2158.                     add = lowadd;

  2159.                 }

  2160.                 else

  2161.                     add = upadd;

  2162.                 SetCurVertTexCoord(tmp * vec2(.25f) + add);

  2163.                 SetCurVertTexCoord2(tmp * vec2(.25f) + add);

  2164.             }

  2165.             else if (m == 0 || m == 1) //inner Logic

  2166.             {

  2167.                 SetCurVertTexCoord(uv[d]);

  2168.                 SetCurVertTexCoord2(uv[d]);

  2169.             }

  2170.             else //Cog logic

  2171.             {

  2172.                 if (m == 2 && n % 3 == 2)

  2173.                 {

  2174.                     SetCurVertTexCoord(vec2(1.f, (d == 2)?(0.f):(1.f)) * CogUV[0] + CogUV[1]);

  2175.                     SetCurVertTexCoord2(vec2(1.f, (d == 2)?(0.f):(1.f)) * CogUV[0] + CogUV[1]);

  2176.                 }

  2177.                 else

  2178.                 {

  2179.                     SetCurVertTexCoord(uv[d]);

  2180.                     SetCurVertTexCoord2(uv[d]);

  2181.                 }

  2182.             }

  2183.             if (d >= 6)

  2184.                 SetCurVertColor(BD()->Color2());

  2185.         }

  2186. 

  2187.         int l = -4;

  2188.         while ((l += 4) < 48)

  2189.             AppendQuad(q[l + 0] + m[l + 0] * 3 + a[l + 0],

  2190.                        q[l + 1] + m[l + 1] * 3 + a[l + 1],

  2191.                        q[l + 2] + m[l + 2] * 3 + a[l + 2],

  2192.                        q[l + 3] + m[l + 3] * 3 + a[l + 3],

  2193.                        vbase);

  2194. 

  2195.         for (int n = 0; n < 12; n++)

  2196.             p[n] = rotmat * p[n];

  2197.     }

  2198. 

  2199.     ComputeNormals(ibase, m_indices.Count() - ibase);

  2200. }

  2201. 

  2202. //-----------------------------------------------------------------------------

  2203. void EasyMesh::Chamfer(float f)

  2204. {

  2205.     int vlen = m_vert.Count() - m_cursors.Last().m1;

  2206.     int ilen = m_indices.Count() - m_cursors.Last().m2;

  2207. 

  2208.     /* Step 1: enumerate all faces. This is done by merging triangles

  2209.      * that are coplanar and share an edge. */

  2210.     int *triangle_classes = new int[ilen / 3];

  2211.     for (int i = 0; i < ilen / 3; i++)

  2212.         triangle_classes[i] = -1;

  2213. 

  2214.     for (int i = 0; i < ilen / 3; i++)

  2215.     {

  2216. 

  2217.     }

  2218. 

  2219.     /* Fun shit: reduce all triangles */

  2220.     int *vertices = new int[vlen];

  2221.     memset(vertices, 0, vlen * sizeof(int));

  2222.     for (int i = 0; i < ilen; i++)

  2223.         vertices[m_indices[i]]++;

  2224. 

  2225.     for (int i = 0; i < ilen / 3; i++)

  2226. 

  2227.     {

  2228.     #if 0

  2229.         if (vertices[m_indices[i * 3]] > 1)

  2230.             continue;

  2231.         if (vertices[m_indices[i * 3 + 1]] > 1)

  2232.             continue;

  2233.         if (vertices[m_indices[i * 3 + 2]] > 1)

  2234.             continue;

  2235.     #endif

  2236. 

  2237.         vec3 bary = 1.f / 3.f * (m_vert[m_indices[i * 3]].m_coord +

  2238.                                  m_vert[m_indices[i * 3 + 1]].m_coord +

  2239.                                  m_vert[m_indices[i * 3 + 2]].m_coord);

  2240.         for (int k = 0; k < 3; k++)

  2241.         {

  2242.             vec3 &p = m_vert[m_indices[i * 3 + k]].m_coord;

  2243.             p -= normalize(p - bary) * f;

  2244.         }

  2245.     }

  2246. }

  2247. 

  2248. //-----------------------------------------------------------------------------

  2249. void EasyMesh::SplitTriangles(int pass) { SplitTriangles(pass, NULL); }

  2250. 

  2251. //-----------------------------------------------------------------------------

  2252. void EasyMesh::SplitTriangles(int pass, VertexDictionnary *vert_dict)

  2253. {

  2254.     while (pass--)

  2255.     {

  2256.         int trimax = m_indices.Count();

  2257.         for (int i = m_cursors.Last().m2; i < trimax; i += 3)

  2258.         {

  2259.             int vbase = m_vert.Count();

  2260.             int j = -1;

  2261.             while (++j < 3)

  2262.             {

  2263.                 AddLerpVertex(m_indices[i + j], m_indices[i + (j + 1) % 3], .5f);

  2264.                 if (vert_dict)

  2265.                     vert_dict->AddVertex(vbase + j, m_vert[vbase + j].m_coord);

  2266.             }

  2267.             //Add new triangles

  2268.             AppendTriangle(vbase, m_indices[i + 1], vbase + 1, 0);

  2269.             AppendTriangle(vbase + 2, vbase + 1, m_indices[i + 2], 0);

  2270.             AppendTriangle(vbase, vbase + 1, vbase + 2, 0);

  2271.             //Change current triangle

  2272.             m_indices[i + 1] = vbase;

  2273.             m_indices[i + 2] = vbase + 2;

  2274.         }

  2275.     }

  2276.     ComputeNormals(m_cursors.Last().m2, m_indices.Count() - m_cursors.Last().m2);

  2277. }

  2278. 

  2279. //-----------------------------------------------------------------------------

  2280. //TODO : Add an half-edges implementation to refine smooth.

  2281. //TODO : Smooth should only use connected vertices that are on edges of the mesh (See box).

  2282. void EasyMesh::SmoothMesh(int main_pass, int split_per_main_pass, int smooth_per_main_pass)

  2283. {

  2284.     VertexDictionnary vert_dict;

  2285.     Array<vec3> smooth_buf[2];

  2286.     Array<int> master_list;

  2287.     Array<int> matching_ids;

  2288.     Array<int> connected_vert;

  2289.     int smbuf = 0;

  2290. 

  2291.     for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)

  2292.         vert_dict.AddVertex(i, m_vert[i].m_coord);

  2293. 

  2294.     while (main_pass--)

  2295.     {

  2296.         int split_pass = split_per_main_pass;

  2297.         int smooth_pass = smooth_per_main_pass;

  2298. 

  2299.         SplitTriangles(split_pass, &vert_dict);

  2300. 

  2301.         matching_ids.Reserve(m_vert.Count() - m_cursors.Last().m1);

  2302.         connected_vert.Reserve(m_vert.Count() - m_cursors.Last().m1);

  2303.         smooth_buf[0].Resize(m_vert.Count() - m_cursors.Last().m1);

  2304.         smooth_buf[1].Resize(m_vert.Count() - m_cursors.Last().m1);

  2305. 

  2306.         for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)

  2307.             smooth_buf[smbuf][i - m_cursors.Last().m1] = m_vert[i].m_coord;

  2308. 

  2309.         while (smooth_pass--)

  2310.         {

  2311.             master_list.Empty();

  2312.             if (vert_dict.GetMasterList(master_list))

  2313.             {

  2314.                 for (int i = 0; i < master_list.Count(); i++)

  2315.                 {

  2316.                     connected_vert.Empty();

  2317.                     if (vert_dict.FindConnectedVertices(master_list[i], m_indices, m_cursors.Last().m2, connected_vert))

  2318.                     {

  2319.                         //Calculate vertices sum

  2320.                         vec3 vert_sum = vec3(.0f);

  2321.                         for (int j = 0; j < connected_vert.Count(); j++)

  2322.                             vert_sum += smooth_buf[smbuf][connected_vert[j] - m_cursors.Last().m1];

  2323. 

  2324.                         //Calculate new master vertex

  2325.                         float n = (float)connected_vert.Count();

  2326.                         //b(n) = 5/4 - pow(3 + 2 * cos(2 * M_PI / n), 2) / 32

  2327.                         float beta = 3.f + 2.f * cos(2.f * (float)M_PI / n);

  2328.                         beta = 5.f / 4.f - beta * beta / 32.f;

  2329.                         //a(n) = n * (1 - b(n)) / b(n)

  2330.                         float alpha = (n * (1 - beta)) / beta;

  2331.                         //V = (a(n) * v + v1 + ... + vn) / (a(n) + n)

  2332.                         vec3 new_vert = (alpha * smooth_buf[smbuf][master_list[i] - m_cursors.Last().m1] + vert_sum) / (alpha + n);

  2333. 

  2334.                         //Set all matching vertices to new value

  2335.                         matching_ids.Empty();

  2336.                         matching_ids << master_list[i];

  2337.                         vert_dict.FindMatchingVertices(master_list[i], matching_ids);

  2338.                         for (int j = 0; j < matching_ids.Count(); j++)

  2339.                             smooth_buf[1 - smbuf][matching_ids[j] - m_cursors.Last().m1] = new_vert;

  2340.                     }

  2341.                 }

  2342.             }

  2343.             smbuf = 1 - smbuf;

  2344.         }

  2345. 

  2346.         for (int i = 0; i < smooth_buf[smbuf].Count(); i++)

  2347.             m_vert[i + m_cursors.Last().m1].m_coord = smooth_buf[smbuf][i];

  2348.     }

  2349. }

  2350. 

  2351. } /* namespace lol */