Changeset 2426


Ignore:
Timestamp:
Feb 17, 2013, 7:18:44 PM (6 years ago)
Author:
touky
Message:

easymesh : vertices datas are now stored in a very user-friendly struct. Heavier on datas, though.
vertexbuffer : added TexCoordExt, which is the same as TexCoord but means "use vec4 for TexCoord"

Location:
trunk/src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/easymesh/easymesh.cpp

    r2425 r2426  
    4646{
    4747
    48 //-----------------------------------------------------------------------------
    49 EasyMesh::EasyMesh()
    50   : m_color(0), m_color2(0), m_ignore_winding_on_scale(0),
    51     m_texcoord_offset(vec2(.0f)), m_texcoord_scale(vec2(1.f))
    52 {
    53     m_cursors.Push(0, 0);
    54 }
    55 
    56 //-----------------------------------------------------------------------------
    57 bool EasyMesh::Compile(char const *command)
    58 {
    59     EasyMeshCompiler mc(*this);
    60     return mc.ParseString(command);
    61 }
    62 
    63 //-----------------------------------------------------------------------------
    64 void EasyMesh::OpenBrace()
    65 {
    66     m_cursors.Push(m_vert.Count(), m_indices.Count());
    67 }
    68 
    69 //-----------------------------------------------------------------------------
    70 void EasyMesh::CloseBrace()
    71 {
    72     m_cursors.Pop();
    73 }
    7448
    7549//-----------------------------------------------------------------------------
     
    268242    new_vbo->Unlock();
    269243
    270     if (vdecl_flags ==  ((VertexUsage::Position<<1) |
    271                          (VertexUsage::Normal<<1)   |
    272                          (VertexUsage::Color<<1)    |
    273                          (VertexUsage::TexCoord<<1)))
     244    if (vdecl_flags ==  ((VertexUsage::Position<<1) | (VertexUsage::Normal<<1) |
     245                         (VertexUsage::Color<<1)    | (VertexUsage::TexCoord<<1)))
    274246    {
    275247        new_vdecl = new VertexDeclaration(
     
    282254        Array<vec3, vec3, u8vec4, vec2> vertexlist;
    283255        for (int i = 0; i < src_mesh->m_vert.Count(); i++)
    284             vertexlist.Push(src_mesh->m_vert[i].m1,
    285                             src_mesh->m_vert[i].m2,
    286                             (u8vec4)(src_mesh->m_vert[i].m3 * 255.f),
    287                             src_mesh->m_vert[i].m4);
     256            vertexlist.Push(src_mesh->m_vert[i].m_coord,
     257                            src_mesh->m_vert[i].m_normal,
     258                            (u8vec4)(src_mesh->m_vert[i].m_color * 255.f),
     259                            src_mesh->m_vert[i].m_texcoord.xy);
    288260
    289261        vbo_data = &vertexlist[0];
     
    293265        COPY_VBO;
    294266    }
    295     else if (vdecl_flags ==  ((VertexUsage::Position<<1) |
    296                               (VertexUsage::Normal<<1)   |
     267    else if (vdecl_flags == ((VertexUsage::Position<<1) | (VertexUsage::Normal<<1) |
     268                             (VertexUsage::Color<<1)    | (VertexUsage::TexCoordExt<<1)))
     269    {
     270        new_vdecl = new VertexDeclaration(
     271                         VertexStream<vec3,vec3,u8vec4,vec4>(
     272                          VertexUsage::Position,
     273                          VertexUsage::Normal,
     274                          VertexUsage::Color,
     275                          VertexUsage::TexCoord));
     276
     277        Array<vec3, vec3, u8vec4, vec4> vertexlist;
     278        for (int i = 0; i < src_mesh->m_vert.Count(); i++)
     279            vertexlist.Push(src_mesh->m_vert[i].m_coord,
     280                            src_mesh->m_vert[i].m_normal,
     281                            (u8vec4)(src_mesh->m_vert[i].m_color * 255.f),
     282                            src_mesh->m_vert[i].m_texcoord);
     283
     284        vbo_data = &vertexlist[0];
     285        vbo_bytes = vertexlist.Bytes();
     286        m_vertexcount = vertexlist.Count();
     287
     288        COPY_VBO;
     289    }
     290    else if (vdecl_flags ==  ((VertexUsage::Position<<1) | (VertexUsage::Normal<<1) |
    297291                              (VertexUsage::Color<<1)))
    298292    {
     
    305299        Array<vec3,vec3,u8vec4> vertexlist;
    306300        for (int i = 0; i < src_mesh->m_vert.Count(); i++)
    307             vertexlist.Push(src_mesh->m_vert[i].m1,
    308                             src_mesh->m_vert[i].m2,
    309                             (u8vec4)(src_mesh->m_vert[i].m3 * 255.f));
     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));
    310304
    311305        vbo_data = &vertexlist[0];
     
    364358}
    365359
     360//-----------------------------------------------------------------------------
     361EasyMesh::EasyMesh()
     362  : m_color(0), m_color2(0), m_ignore_winding_on_scale(0),
     363    m_texcoord_offset(vec2(.0f)), m_texcoord_scale(vec2(1.f))
     364{
     365    m_cursors.Push(0, 0);
     366}
     367
     368//-----------------------------------------------------------------------------
     369bool EasyMesh::Compile(char const *command)
     370{
     371    EasyMeshCompiler mc(*this);
     372    return mc.ParseString(command);
     373}
     374
     375//-----------------------------------------------------------------------------
     376void EasyMesh::OpenBrace()
     377{
     378    m_cursors.Push(m_vert.Count(), m_indices.Count());
     379}
     380
     381//-----------------------------------------------------------------------------
     382void EasyMesh::CloseBrace()
     383{
     384    m_cursors.Pop();
     385}
    366386//-----------------------------------------------------------------------------
    367387void EasyMesh::MeshConvert(GpuShaderData* new_gpu_sdata)
     
    590610        CsgBsp &mesh_bsp  = (mesh_id == 0)?(mesh_bsp_0):(mesh_bsp_1);
    591611        for (int i = start_point; i < end_point; i += 3)
    592             mesh_bsp.AddTriangleToTree(i, m_vert[m_indices[i]].m1, m_vert[m_indices[i + 1]].m1, m_vert[m_indices[i + 2]].m1);
     612            mesh_bsp.AddTriangleToTree(i, m_vert[m_indices[i]].m_coord,
     613                                          m_vert[m_indices[i + 1]].m_coord,
     614                                          m_vert[m_indices[i + 2]].m_coord);
    593615    }
    594616
     
    611633        for (int i = start_point; i < end_point; i += 3)
    612634        {
    613             int Result = mesh_bsp.TestTriangleToTree(m_vert[m_indices[i]].m1, m_vert[m_indices[i + 1]].m1, m_vert[m_indices[i + 2]].m1, vert_list, tri_list);
     635            int Result = mesh_bsp.TestTriangleToTree(m_vert[m_indices[i]].m_coord,
     636                                                     m_vert[m_indices[i + 1]].m_coord,
     637                                                     m_vert[m_indices[i + 2]].m_coord, vert_list, tri_list);
    614638            int tri_base_idx = m_indices.Count();
    615639
     
    628652
    629653                    //Normal : bad calculations there.
    630                     n0 = m_vert[P0].m2;
    631                     n1 = m_vert[P1].m2;
     654                    n0 = m_vert[P0].m_normal;
     655                    n1 = m_vert[P1].m_normal;
    632656                    SetCurVertNormal(normalize(n0 + (n1 - n0) * vert_list[k].m4));
    633657
    634658#if 1
    635659                    //Color
    636                     c0 = m_vert[P0].m3;
    637                     c1 = m_vert[P1].m3;
     660                    c0 = m_vert[P0].m_color;
     661                    c1 = m_vert[P1].m_color;
    638662                    vec4 res = c0 + ((c1 - c0) * vert_list[k].m4);
    639663                    SetCurVertColor(res);
     
    708732
    709733    for (int i = 0; i < m_vert.Count(); i++)
    710         if (length(m_vert[i].m2) < 1.0f)
     734        if (length(m_vert[i].m_normal) < 1.0f)
    711735            i = i;
    712736
     
    761785void EasyMesh::AddVertex(vec3 const &coord)
    762786{
    763     m_vert.Push(
    764         coord, vec3(0.f, 1.f, 0.f), m_color
    765 #if VERTEX_USEAGE == VU_VANILLA
    766     //-- VANILLA --
    767 #elif VERTEX_USEAGE == VU_BONES
    768     //TODO : -- BONE SUPPORT --
    769         , ivec2(0), vec2(0)
    770 #elif VERTEX_USEAGE == VU_TEX_UV
    771     //-- UV SUPPORT --
    772         , vec2(-1)
    773 #endif
    774     );
     787    m_vert.Push(VertexData(coord, vec3(0.f, 1.f, 0.f), m_color));
    775788}
    776789
     
    784797void EasyMesh::AddLerpVertex(int i, int j, float alpha)
    785798{
    786     m_vert.Push(
    787         lol::lerp(m_vert[i].m1, m_vert[j].m1, alpha),
    788         lol::lerp(m_vert[i].m2, m_vert[j].m2, alpha),
    789         lol::lerp(m_vert[i].m3, m_vert[j].m3, alpha)
    790 #if VERTEX_USEAGE == VU_VANILLA
    791     //-- VANILLA --
    792 #elif VERTEX_USEAGE == VU_BONES
    793     //TODO : -- BONE SUPPORT --
    794         , lol::lerp(m_vert[i].m4, m_vert[j].m4, alpha),
    795         lol::lerp(m_vert[i].m5, m_vert[j].m5, alpha)
    796 #elif VERTEX_USEAGE == VU_TEX_UV
    797     //-- UV SUPPORT --
    798         , lol::lerp(m_vert[i].m4, m_vert[j].m4, alpha)
    799 #endif
    800     );
     799    m_vert.Push(VertexData(
     800        lol::lerp(m_vert[i].m_coord,    m_vert[j].m_coord,      alpha),
     801        lol::lerp(m_vert[i].m_normal,   m_vert[j].m_normal,     alpha),
     802        lol::lerp(m_vert[i].m_color,    m_vert[j].m_color,      alpha),
     803        lol::lerp(m_vert[i].m_texcoord, m_vert[j].m_texcoord,   alpha),
     804        ((alpha < .5f) ? (m_vert[i].m_bone_id) : (m_vert[j].m_bone_id)), /* FIXME ? */
     805        lol::lerp(m_vert[i].m_bone_weight, m_vert[j].m_bone_weight, alpha)));
    801806}
    802807
     
    846851    for (int i = 0; i < vcount; i += 3)
    847852    {
    848         vec3 v0 = m_vert[m_indices[start + i + 2]].m1
    849                 - m_vert[m_indices[start + i + 0]].m1;
    850         vec3 v1 = m_vert[m_indices[start + i + 1]].m1
    851                 - m_vert[m_indices[start + i + 0]].m1;
     853        vec3 v0 = m_vert[m_indices[start + i + 2]].m_coord
     854                - m_vert[m_indices[start + i + 0]].m_coord;
     855        vec3 v1 = m_vert[m_indices[start + i + 1]].m_coord
     856                - m_vert[m_indices[start + i + 0]].m_coord;
    852857        vec3 n = normalize(cross(v1, v0));
    853858
    854859        for (int j = 0; j < 3; j++)
    855             m_vert[m_indices[start + i + j]].m2 = n;
     860            m_vert[m_indices[start + i + j]].m_normal = n;
    856861    }
    857862}
     
    860865void EasyMesh::ComputeTexCoord(float uv_scale, int uv_offset)
    861866{
    862 #if 0//VERTEX_USEAGE == VU_TEX_UV
     867#if 1
    863868    VertexDictionnary vert_dict;
    864869    Array<int> tri_list;
     
    10441049{
    10451050    for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    1046         m_vert[i].m3 = color;
     1051        m_vert[i].m_color = color;
    10471052}
    10481053
     
    10571062void EasyMesh::SetCurVertNormal(vec3 const &normal)
    10581063{
    1059     m_vert[m_vert.Count() - 1].m2 = normal;
     1064    m_vert[m_vert.Count() - 1].m_normal = normal;
    10601065}
    10611066
     
    10631068void EasyMesh::SetCurVertColor(vec4 const &color)
    10641069{
    1065     m_vert[m_vert.Count() - 1].m3 = color;
     1070    m_vert[m_vert.Count() - 1].m_color = color;
    10661071}
    10671072
     
    10691074void EasyMesh::SetCurVertTexCoord(vec2 const &texcoord)
    10701075{
    1071 #if VERTEX_USEAGE == VU_BONES
    1072 #elif VERTEX_USEAGE == VU_TEX_UV
    1073     m_vert[m_vert.Count() - 1].m4 = (texcoord * m_texcoord_scale) + m_texcoord_offset;
    1074 #endif
     1076    m_vert[m_vert.Count() - 1].m_texcoord = vec4(texcoord, m_vert[m_vert.Count() - 1].m_texcoord.zw);
     1077}
     1078
     1079//-----------------------------------------------------------------------------
     1080void EasyMesh::SetCurVertTexCoord(vec4 const &texcoord)
     1081{
     1082    m_vert[m_vert.Count() - 1].m_texcoord = texcoord;
    10751083}
    10761084
     
    10791087{
    10801088    for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    1081         m_vert[i].m1 += v;
     1089        m_vert[i].m_coord += v;
    10821090}
    10831091
     
    10931101    for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    10941102    {
    1095         m_vert[i].m1 = m * m_vert[i].m1;
    1096         m_vert[i].m2 = m * m_vert[i].m2;
     1103        m_vert[i].m_coord  = m * m_vert[i].m_coord;
     1104        m_vert[i].m_normal = m * m_vert[i].m_normal;
    10971105    }
    10981106}
     
    11101118            if(Welded[k] < 0)
    11111119            {
    1112                 vec3 diff = m_vert[i].m1 - m_vert[j].m1;
     1120                vec3 diff = m_vert[i].m_coord - m_vert[j].m_coord;
    11131121
    11141122                if(diff.x > 0.1f || diff.x < -0.1f)
     
    11351143    {
    11361144        if(Welded[j] == -1)
    1137             m_vert[i].m1 *= 1.0f + RandF(r);
     1145            m_vert[i].m_coord *= 1.0f + RandF(r);
    11381146        else
    1139             m_vert[i].m1 = m_vert[Welded[j]].m1;
     1147            m_vert[i].m_coord = m_vert[Welded[j]].m_coord;
    11401148    }
    11411149
     
    11801188            case MeshTransform::Taper:
    11811189            {
    1182                 float value = m_vert[i].m1[axis0];
     1190                float value = m_vert[i].m_coord[axis0];
    11831191                if (absolute) value = abs(value);
    1184                 m_vert[i].m1[(axis0 + 1) % 3] *= max(0.f, 1.f + (n0 * value + noff));
    1185                 m_vert[i].m1[(axis0 + 2) % 3] *= max(0.f, 1.f + (n1 * value + noff));
     1192                m_vert[i].m_coord[(axis0 + 1) % 3] *= max(0.f, 1.f + (n0 * value + noff));
     1193                m_vert[i].m_coord[(axis0 + 2) % 3] *= max(0.f, 1.f + (n1 * value + noff));
    11861194                break;
    11871195            }
     
    11891197            {
    11901198                vec3 rotaxis = vec3(1.f); rotaxis[(axis0 + 1) % 3] = .0f; rotaxis[(axis0 + 2) % 3] = .0f;
    1191                 m_vert[i].m1 = mat3::rotate(m_vert[i].m1[axis0] * n0 + noff, rotaxis) * m_vert[i].m1;
     1199                m_vert[i].m_coord = mat3::rotate(m_vert[i].m_coord[axis0] * n0 + noff, rotaxis) * m_vert[i].m_coord;
    11921200                break;
    11931201            }
    11941202            case MeshTransform::Shear:
    11951203            {
    1196                 float value = m_vert[i].m1[axis0];
     1204                float value = m_vert[i].m_coord[axis0];
    11971205                if (absolute) value = abs(value);
    1198                 m_vert[i].m1[(axis0 + 1) % 3] += (n0 * value + noff);
    1199                 m_vert[i].m1[(axis0 + 2) % 3] += (n1 * value + noff);
     1206                m_vert[i].m_coord[(axis0 + 1) % 3] += (n0 * value + noff);
     1207                m_vert[i].m_coord[(axis0 + 2) % 3] += (n1 * value + noff);
    12001208                break;
    12011209            }
     
    12101218            {
    12111219                vec3 rotaxis = vec3(1.f); rotaxis[(axis1 + 1) % 3] = .0f; rotaxis[(axis1 + 2) % 3] = .0f;
    1212                 m_vert[i].m1 = mat3::rotate(m_vert[i].m1[axis0] * n0 + noff, rotaxis) * m_vert[i].m1;
     1220                m_vert[i].m_coord = mat3::rotate(m_vert[i].m_coord[axis0] * n0 + noff, rotaxis) * m_vert[i].m_coord;
    12131221                break;
    12141222            }
     
    12251233    for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    12261234    {
    1227         m_vert[i].m1 *= s;
    1228         m_vert[i].m2 = normalize(m_vert[i].m2 * invs);
     1235        m_vert[i].m_coord *= s;
     1236        m_vert[i].m_normal = normalize(m_vert[i].m_normal * invs);
    12291237    }
    12301238
     
    21222130    #endif
    21232131
    2124         vec3 bary = 1.f / 3.f * (m_vert[m_indices[i * 3]].m1 +
    2125                                  m_vert[m_indices[i * 3 + 1]].m1 +
    2126                                  m_vert[m_indices[i * 3 + 2]].m1);
     2132        vec3 bary = 1.f / 3.f * (m_vert[m_indices[i * 3]].m_coord +
     2133                                 m_vert[m_indices[i * 3 + 1]].m_coord +
     2134                                 m_vert[m_indices[i * 3 + 2]].m_coord);
    21272135        for (int k = 0; k < 3; k++)
    21282136        {
    2129             vec3 &p = m_vert[m_indices[i * 3 + k]].m1;
     2137            vec3 &p = m_vert[m_indices[i * 3 + k]].m_coord;
    21302138            p -= normalize(p - bary) * f;
    21312139        }
     
    21502158                AddLerpVertex(m_indices[i + j], m_indices[i + (j + 1) % 3], .5f);
    21512159                if (vert_dict)
    2152                     vert_dict->AddVertex(vbase + j, m_vert[vbase + j].m1);
     2160                    vert_dict->AddVertex(vbase + j, m_vert[vbase + j].m_coord);
    21532161            }
    21542162            //Add new triangles
     
    21652173
    21662174//-----------------------------------------------------------------------------
     2175//TODO : Add an half-edges implementation to refine smooth.
     2176//TODO : Smooth should only use connected vertices that are on edges of the mesh (See box).
    21672177void EasyMesh::SmoothMesh(int main_pass, int split_per_main_pass, int smooth_per_main_pass)
    21682178{
     
    21752185
    21762186    for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    2177         vert_dict.AddVertex(i, m_vert[i].m1);
     2187        vert_dict.AddVertex(i, m_vert[i].m_coord);
    21782188
    21792189    while (main_pass--)
     
    21902200
    21912201        for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
    2192             smooth_buf[smbuf][i - m_cursors.Last().m1] = m_vert[i].m1;
     2202            smooth_buf[smbuf][i - m_cursors.Last().m1] = m_vert[i].m_coord;
    21932203
    21942204        while (smooth_pass--)
     
    22302240
    22312241        for (int i = 0; i < smooth_buf[smbuf].Count(); i++)
    2232             m_vert[i + m_cursors.Last().m1].m1 = smooth_buf[smbuf][i];
     2242            m_vert[i + m_cursors.Last().m1].m_coord = smooth_buf[smbuf][i];
    22332243    }
    22342244}
  • trunk/src/easymesh/easymesh.h

    r2425 r2426  
    1616//
    1717
    18 #define VU_BONES   2
    19 #define VU_TEX_UV  1
    20 #define VU_VANILLA 0
    21 
    22 #define VERTEX_USEAGE VU_TEX_UV
    23 
    2418#if !defined __EASYMESH_EASYMESH_H__
    2519#define __EASYMESH_EASYMESH_H__
     
    2822{
    2923
    30 //-----------------------------------------------------------------------------
     24//Vertex datas for easymesh vertex list.
     25//TODO : <COORD, NORM, COLOR, UV>
     26struct VertexData
     27{
     28    vec3    m_coord;
     29    vec3    m_normal;
     30    vec4    m_color;
     31    vec4    m_texcoord;
     32    ivec4   m_bone_id;
     33    vec4    m_bone_weight;
     34
     35    VertexData(vec3  new_coord      = vec3(0.f),
     36               vec3  new_normal     = vec3(0.f, 1.f, 0.f),
     37               vec4  new_color      = vec4(0.f),
     38               vec4  new_texcoord   = vec4(0.f),
     39               ivec4 new_bone_id    = ivec4(0),
     40               vec4  new_bone_weight= vec4(0.f))
     41    {
     42        m_coord         = new_coord;
     43        m_normal        = new_normal;
     44        m_color         = new_color;
     45        m_texcoord      = new_texcoord;
     46        m_bone_id       = new_bone_id;
     47        m_bone_weight   = new_bone_weight;
     48    }
     49};
     50
    3151//Base class to declare shader datas
    3252class GpuShaderData
     
    122142};
    123143
     144/* TODO : replace VDict by a proper Half-edge system */
    124145//a class whose goal is to keep a list of the adjacent vertices for mesh operations purposes
    125146class VertexDictionnary
     
    239260    void SetCurVertColor(vec4 const &color);
    240261    void SetCurVertTexCoord(vec2 const &texcoord);
     262    void SetCurVertTexCoord(vec4 const &texcoord);
    241263
    242264public:
     
    480502public:
    481503    int GetVertexCount() { return m_vert.Count(); }
    482     vec3 const &GetVertexLocation(int i) { return m_vert[i].m1; }
     504    vec3 const &GetVertexLocation(int i) { return m_vert[i].m_coord; }
    483505
    484506private:
    485507    vec4 m_color, m_color2;
    486508    Array<uint16_t> m_indices;
    487 #if VERTEX_USEAGE == VU_BONES
    488     //TODO : -- BONE SUPPORT --
    489     //TODO : <COORD, NORM, COLOR, BONE_ID, BONE_WEIGHT>
    490     Array<vec3, vec3, vec4, ivec2, vec2> m_vert;
    491     //TODO : More bone blend support than 2 ?
    492 #elif VERTEX_USEAGE == VU_TEX_UV
    493     //TODO : -- UV SUPPORT --
    494     //TODO : <COORD, NORM, COLOR, UV>
    495     Array<vec3, vec3, vec4, vec2> m_vert;
    496 #else
    497     //-- VANILLA --
    498     //<COORD, NORM, COLOR>
    499     Array<vec3, vec3, vec4> m_vert;
    500 #endif
     509    Array<VertexData> m_vert;
    501510
    502511    //<vert count, indices count>
  • trunk/src/gpu/vertexbuffer.cpp

    r2370 r2426  
    352352            break;
    353353        case VertexUsage::TexCoord:
     354        case VertexUsage::TexCoordExt:
    354355            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    355356            break;
     
    459460            break;
    460461        case VertexUsage::TexCoord:
     462        case VertexUsage::TexCoordExt:
    461463            glTexCoordPointer(tlut[type_index].size, tlut[type_index].type,
    462464                              stride, (GLvoid const *)(uintptr_t)offset);
  • trunk/src/lol/gpu/vertexbuffer.h

    r2354 r2426  
    5151        PointSize,
    5252        TexCoord,
     53        TexCoordExt,
    5354        Tangent,
    5455        Binormal,
Note: See TracChangeset for help on using the changeset viewer.