Changeset 1507


Ignore:
Timestamp:
Jun 21, 2012, 1:41:04 PM (8 years ago)
Author:
sam
Message:

orbital: get rid of quads in the mesh builders, triangles FTW!

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/orbital/mesh.h

    r1506 r1507  
    77//
    88
    9 /* TODO for this file:
    10  *  - rename "AppendQuadVert" to "AddVertex" or something; it has nothing
    11  *    to do with quads.
    12  */
    13 
    149#if !defined __MESH_H__
    1510#define __MESH_H__
     
    2318      : m_color(0), m_color2(0)
    2419    {
    25         m_cursors.Push(0, 0, 0);
     20        m_cursors.Push(0, 0);
    2621    }
    2722
     
    3025    void OpenBrace()
    3126    {
    32         m_cursors.Push(m_vert.Count(), m_quadidx.Count(), m_triidx.Count());
     27        m_cursors.Push(m_vert.Count(), m_indices.Count());
    3328    }
    3429
     
    6560
    6661        Array<uint16_t> indexlist;
    67         for (int i = 0; i < m_triidx.Count(); i += 3)
    68         {
    69             indexlist << m_triidx[i + 0];
    70             indexlist << m_triidx[i + 1];
    71             indexlist << m_triidx[i + 2];
    72         }
    73         for (int i = 0; i < m_quadidx.Count(); i += 4)
    74         {
    75             indexlist << m_quadidx[i + 0];
    76             indexlist << m_quadidx[i + 1];
    77             indexlist << m_quadidx[i + 2];
    78 
    79             indexlist << m_quadidx[i + 0];
    80             indexlist << m_quadidx[i + 2];
    81             indexlist << m_quadidx[i + 3];
     62        for (int i = 0; i < m_indices.Count(); i += 3)
     63        {
     64            indexlist << m_indices[i + 0];
     65            indexlist << m_indices[i + 1];
     66            indexlist << m_indices[i + 2];
    8267        }
    8368
     
    119104    void SetCurColor2(vec4 const &color) { m_color2 = color; }
    120105
    121     void AppendQuadVert(vec3 const &coord)
     106    void AddVertex(vec3 const &coord)
    122107    {
    123108        m_vert.Push(coord, vec3(0.f, 1.f, 0.f), m_color);
    124109    }
    125110
    126     void AppendDuplicateQuadVert(int i)
     111    void AddDuplicateVertex(int i)
    127112    {
    128113        m_vert.Push(m_vert[i].m1, vec3(0.f, 1.f, 0.f), m_vert[i].m3);
     
    131116    void AppendQuad(int i1, int i2, int i3, int i4, int base)
    132117    {
    133         m_quadidx << base + i1;
    134         m_quadidx << base + i2;
    135         m_quadidx << base + i3;
    136         m_quadidx << base + i4;
     118        m_indices << base + i1;
     119        m_indices << base + i2;
     120        m_indices << base + i3;
     121
     122        m_indices << base + i4;
     123        m_indices << base + i1;
     124        m_indices << base + i3;
    137125    }
    138126
    139127    void AppendQuadDuplicateVerts(int i1, int i2, int i3, int i4, int base)
    140128    {
    141         m_quadidx << m_vert.Count(); AppendDuplicateQuadVert(base + i1);
    142         m_quadidx << m_vert.Count(); AppendDuplicateQuadVert(base + i2);
    143         m_quadidx << m_vert.Count(); AppendDuplicateQuadVert(base + i3);
    144         m_quadidx << m_vert.Count(); AppendDuplicateQuadVert(base + i4);
     129        m_indices << m_vert.Count(); AddDuplicateVertex(base + i1);
     130        m_indices << m_vert.Count(); AddDuplicateVertex(base + i2);
     131        m_indices << m_vert.Count(); AddDuplicateVertex(base + i3);
     132
     133        m_indices << m_vert.Count(); AddDuplicateVertex(base + i4);
     134        m_indices << m_vert.Count(); AddDuplicateVertex(base + i1);
     135        m_indices << m_vert.Count(); AddDuplicateVertex(base + i3);
    145136    }
    146137
    147138    void AppendTriangle(int i1, int i2, int i3, int base)
    148139    {
    149         m_triidx << base + i1;
    150         m_triidx << base + i2;
    151         m_triidx << base + i3;
     140        m_indices << base + i1;
     141        m_indices << base + i2;
     142        m_indices << base + i3;
    152143    }
    153144
    154145    void AppendTriangleDuplicateVerts(int i1, int i2, int i3, int base)
    155146    {
    156         m_triidx << m_vert.Count(); AppendDuplicateQuadVert(base + i1);
    157         m_triidx << m_vert.Count(); AppendDuplicateQuadVert(base + i2);
    158         m_triidx << m_vert.Count(); AppendDuplicateQuadVert(base + i3);
    159     }
    160 
    161     void ComputeQuadNormals(int start, int vcount)
    162     {
    163         for (int i = 0; i < vcount; i += 4)
    164         {
    165             vec3 v0 = m_vert[m_quadidx[start + i + 2]].m1
    166                     - m_vert[m_quadidx[start + i + 0]].m1;
    167             vec3 v1 = m_vert[m_quadidx[start + i + 1]].m1
    168                     - m_vert[m_quadidx[start + i + 0]].m1;
     147        m_indices << m_vert.Count(); AddDuplicateVertex(base + i1);
     148        m_indices << m_vert.Count(); AddDuplicateVertex(base + i2);
     149        m_indices << m_vert.Count(); AddDuplicateVertex(base + i3);
     150    }
     151
     152    void ComputeNormals(int start, int vcount)
     153    {
     154        for (int i = 0; i < vcount; i += 3)
     155        {
     156            vec3 v0 = m_vert[m_indices[start + i + 2]].m1
     157                    - m_vert[m_indices[start + i + 0]].m1;
     158            vec3 v1 = m_vert[m_indices[start + i + 1]].m1
     159                    - m_vert[m_indices[start + i + 0]].m1;
    169160            vec3 n = normalize(cross(v1, v0));
    170161
    171             for (int j = 0; j < 4; j++)
    172                 m_vert[m_quadidx[start + i + j]].m2 = n;
    173         }
    174     }
    175 
    176     void ComputeTriNormals(int start, int vcount)
    177     {
    178         for (int i = 0; i < vcount; i += 3)
    179         {
    180             vec3 v0 = m_vert[m_triidx[start + i + 2]].m1
    181                     - m_vert[m_triidx[start + i + 0]].m1;
    182             vec3 v1 = m_vert[m_triidx[start + i + 1]].m1
    183                     - m_vert[m_triidx[start + i + 0]].m1;
    184             vec3 n = normalize(cross(v1, v0));
    185 
    186162            for (int j = 0; j < 3; j++)
    187                 m_vert[m_triidx[start + i + j]].m2 = n;
     163                m_vert[m_indices[start + i + j]].m2 = n;
    188164        }
    189165    }
     
    266242        if (s.x * s.y * s.z < 0)
    267243        {
    268             for (int i = m_cursors.Last().m2; i < m_quadidx.Count(); i += 2)
    269             {
    270                 uint16_t tmp = m_quadidx[i + 0];
    271                 m_quadidx[i + 0] = m_quadidx[i + 1];
    272                 m_quadidx[i + 1] = tmp;
    273             }
    274 
    275             for (int i = m_cursors.Last().m3; i < m_triidx.Count(); i += 3)
    276             {
    277                 uint16_t tmp = m_triidx[i + 0];
    278                 m_triidx[i + 0] = m_triidx[i + 1];
    279                 m_triidx[i + 1] = tmp;
     244            for (int i = m_cursors.Last().m2; i < m_indices.Count(); i += 3)
     245            {
     246                uint16_t tmp = m_indices[i + 0];
     247                m_indices[i + 0] = m_indices[i + 1];
     248                m_indices[i + 1] = tmp;
    280249            }
    281250        }
     
    289258    {
    290259        int vlen = m_vert.Count() - m_cursors.Last().m1;
    291         int qlen = m_quadidx.Count() - m_cursors.Last().m2;
    292         int tlen = m_triidx.Count() - m_cursors.Last().m3;
     260        int tlen = m_indices.Count() - m_cursors.Last().m2;
    293261
    294262        for (int i = 0; i < vlen; i++)
    295263            m_vert << m_vert[m_cursors.Last().m1++];
    296264
    297         for (int i = 0; i < qlen; i++)
    298             m_quadidx << m_quadidx[m_cursors.Last().m2++] + vlen;
    299 
    300265        for (int i = 0; i < tlen; i++)
    301             m_triidx << m_triidx[m_cursors.Last().m3++] + vlen;
     266            m_indices << m_indices[m_cursors.Last().m2++] + vlen;
    302267
    303268        Scale(s);
    304269
    305270        m_cursors.Last().m1 -= vlen;
    306         m_cursors.Last().m2 -= qlen;
    307         m_cursors.Last().m3 -= tlen;
     271        m_cursors.Last().m2 -= tlen;
    308272    }
    309273
     
    327291        for (int i = 0; i < nsides; i++)
    328292        {
    329             AppendQuadVert(p1); SetCurVertNormal(n);
    330             AppendQuadVert(p2); SetCurVertNormal(n);
     293            AddVertex(p1); SetCurVertNormal(n);
     294            AddVertex(p2); SetCurVertNormal(n);
    331295            SetCurVertColor(m_color2);
    332296
     
    344308            if (!smooth)
    345309            {
    346                 AppendQuadVert(p1); SetCurVertNormal(n);
    347                 AppendQuadVert(p2); SetCurVertNormal(n);
     310                AddVertex(p1); SetCurVertNormal(n);
     311                AddVertex(p2); SetCurVertNormal(n);
    348312                SetCurVertColor(m_color2);
    349313
     
    361325        ndivisions *= 2;
    362326
    363         int ibase = m_quadidx.Count();
     327        int ibase = m_indices.Count();
    364328        int vbase = m_vert.Count();
    365329
     
    378342                int i2 = (i + 1) % ndivisions;
    379343
    380                 AppendQuadVert(d * vec3(table[i], 1.0f) * table[j].xxy);
    381                 AppendQuadVert(d * vec3(table[i2], 1.0f) * table[j].xxy);
    382                 AppendQuadVert(d * vec3(table[i2], 1.0f) * table[j2].xxy);
    383                 AppendQuadVert(d * vec3(table[i], 1.0f) * table[j2].xxy);
     344                AddVertex(d * vec3(table[i], 1.0f) * table[j].xxy);
     345                AddVertex(d * vec3(table[i2], 1.0f) * table[j].xxy);
     346                AddVertex(d * vec3(table[i2], 1.0f) * table[j2].xxy);
     347                AddVertex(d * vec3(table[i], 1.0f) * table[j2].xxy);
    384348            }
    385349
     
    387351            AppendQuad(0, 1, 2, 3, i);
    388352
    389         ComputeQuadNormals(ibase, m_quadidx.Count() - ibase);
     353        ComputeNormals(ibase, m_indices.Count() - ibase);
    390354    }
    391355
     
    407371    void AppendBox(vec3 const &size, float chamf, bool smooth)
    408372    {
    409                 if (chamf < 0.0f)
    410                 {
    411                         AppendBox(size + vec3(chamf * 2.0f), -chamf, smooth);
    412                         return;
    413                 }
     373        if (chamf < 0.0f)
     374        {
     375            AppendBox(size + vec3(chamf * 2.0f), -chamf, smooth);
     376            return;
     377        }
     378
    414379        int vbase = m_vert.Count();
    415         int qibase = m_quadidx.Count();
    416         int tibase = m_triidx.Count();
     380        int ibase = m_indices.Count();
    417381
    418382        vec3 d = size * 0.5f;
    419383
    420         AppendQuadVert(vec3(-d.x, -d.y, -d.z - chamf));
    421         AppendQuadVert(vec3(-d.x, +d.y, -d.z - chamf));
    422         AppendQuadVert(vec3(+d.x, +d.y, -d.z - chamf));
    423         AppendQuadVert(vec3(+d.x, -d.y, -d.z - chamf));
    424 
    425         AppendQuadVert(vec3(-d.x - chamf, -d.y, +d.z));
    426         AppendQuadVert(vec3(-d.x - chamf, +d.y, +d.z));
    427         AppendQuadVert(vec3(-d.x - chamf, +d.y, -d.z));
    428         AppendQuadVert(vec3(-d.x - chamf, -d.y, -d.z));
    429 
    430         AppendQuadVert(vec3(+d.x, -d.y, +d.z + chamf));
    431         AppendQuadVert(vec3(+d.x, +d.y, +d.z + chamf));
    432         AppendQuadVert(vec3(-d.x, +d.y, +d.z + chamf));
    433         AppendQuadVert(vec3(-d.x, -d.y, +d.z + chamf));
    434 
    435         AppendQuadVert(vec3(+d.x + chamf, -d.y, -d.z));
    436         AppendQuadVert(vec3(+d.x + chamf, +d.y, -d.z));
    437         AppendQuadVert(vec3(+d.x + chamf, +d.y, +d.z));
    438         AppendQuadVert(vec3(+d.x + chamf, -d.y, +d.z));
    439 
    440         AppendQuadVert(vec3(-d.x, -d.y - chamf, +d.z));
    441         AppendQuadVert(vec3(-d.x, -d.y - chamf, -d.z));
    442         AppendQuadVert(vec3(+d.x, -d.y - chamf, -d.z));
    443         AppendQuadVert(vec3(+d.x, -d.y - chamf, +d.z));
    444 
    445         AppendQuadVert(vec3(-d.x, +d.y + chamf, -d.z));
    446         AppendQuadVert(vec3(-d.x, +d.y + chamf, +d.z));
    447         AppendQuadVert(vec3(+d.x, +d.y + chamf, +d.z));
    448         AppendQuadVert(vec3(+d.x, +d.y + chamf, -d.z));
     384        AddVertex(vec3(-d.x, -d.y, -d.z - chamf));
     385        AddVertex(vec3(-d.x, +d.y, -d.z - chamf));
     386        AddVertex(vec3(+d.x, +d.y, -d.z - chamf));
     387        AddVertex(vec3(+d.x, -d.y, -d.z - chamf));
     388
     389        AddVertex(vec3(-d.x - chamf, -d.y, +d.z));
     390        AddVertex(vec3(-d.x - chamf, +d.y, +d.z));
     391        AddVertex(vec3(-d.x - chamf, +d.y, -d.z));
     392        AddVertex(vec3(-d.x - chamf, -d.y, -d.z));
     393
     394        AddVertex(vec3(+d.x, -d.y, +d.z + chamf));
     395        AddVertex(vec3(+d.x, +d.y, +d.z + chamf));
     396        AddVertex(vec3(-d.x, +d.y, +d.z + chamf));
     397        AddVertex(vec3(-d.x, -d.y, +d.z + chamf));
     398
     399        AddVertex(vec3(+d.x + chamf, -d.y, -d.z));
     400        AddVertex(vec3(+d.x + chamf, +d.y, -d.z));
     401        AddVertex(vec3(+d.x + chamf, +d.y, +d.z));
     402        AddVertex(vec3(+d.x + chamf, -d.y, +d.z));
     403
     404        AddVertex(vec3(-d.x, -d.y - chamf, +d.z));
     405        AddVertex(vec3(-d.x, -d.y - chamf, -d.z));
     406        AddVertex(vec3(+d.x, -d.y - chamf, -d.z));
     407        AddVertex(vec3(+d.x, -d.y - chamf, +d.z));
     408
     409        AddVertex(vec3(-d.x, +d.y + chamf, -d.z));
     410        AddVertex(vec3(-d.x, +d.y + chamf, +d.z));
     411        AddVertex(vec3(+d.x, +d.y + chamf, +d.z));
     412        AddVertex(vec3(+d.x, +d.y + chamf, -d.z));
    449413
    450414        /* The 6 quads on each side of the box */
     
    452416            AppendQuad(i, i + 1, i + 2, i + 3, vbase);
    453417
    454         ComputeQuadNormals(qibase, m_quadidx.Count() - qibase);
    455         qibase = m_quadidx.Count();
     418        ComputeNormals(ibase, m_indices.Count() - ibase);
     419        ibase = m_indices.Count();
    456420
    457421        /* The 8 quads at each edge of the box */
     
    497461
    498462        if (!smooth)
    499         {
    500             ComputeQuadNormals(qibase, m_quadidx.Count() - qibase);
    501             ComputeTriNormals(tibase, m_triidx.Count() - tibase);
    502         }
     463            ComputeNormals(ibase, m_indices.Count() - ibase);
    503464    }
    504465
     
    508469        int vbase = m_vert.Count();
    509470
    510         AppendQuadVert(vec3(0.f, 0.f, 0.f));
     471        AddVertex(vec3(0.f, 0.f, 0.f));
    511472
    512473        mat3 rotmat = mat3::rotate(180.0f / nbranches, 0.f, 1.f, 0.f);
     
    518479        for (int i = 0; i < nbranches; i++)
    519480        {
    520             AppendQuadVert(p1);
     481            AddVertex(p1);
    521482            if (fade2)
    522483                SetCurVertColor(m_color2);
    523484
    524             AppendQuadVert(p2);
     485            AddVertex(p2);
    525486            if (fade)
    526487                SetCurVertColor(m_color2);
     
    538499        int vbase = m_vert.Count();
    539500
    540         AppendQuadVert(vec3(0.f, 0.f, 0.f));
     501        AddVertex(vec3(0.f, 0.f, 0.f));
    541502
    542503        mat3 rotmat = mat3::rotate(180.0f / nbranches, 0.f, 1.f, 0.f);
     
    550511        for (int i = 0; i < nbranches; i++)
    551512        {
    552             AppendQuadVert(p1);
    553             AppendQuadVert(p2);
    554             AppendQuadVert(p3); SetCurVertColor(m_color2);
    555             AppendQuadVert(p4); SetCurVertColor(m_color2);
     513            AddVertex(p1);
     514            AddVertex(p2);
     515            AddVertex(p3); SetCurVertColor(m_color2);
     516            AddVertex(p4); SetCurVertColor(m_color2);
    556517
    557518            int j = (i + 1) % nbranches;
     
    571532        int vbase = m_vert.Count();
    572533
    573         AppendQuadVert(vec3(0.f, 0.f, 0.f));
     534        AddVertex(vec3(0.f, 0.f, 0.f));
    574535
    575536        mat3 rotmat = mat3::rotate(360.0f / nsides, 0.f, 1.f, 0.f);
     
    578539        for (int i = 0; i < nsides; i++)
    579540        {
    580             AppendQuadVert(p1);
     541            AddVertex(p1);
    581542            if (fade)
    582543                SetCurVertColor(m_color2);
     
    591552        vec3 p(0.f, 0.f, size);
    592553
    593         AppendQuadVert(p);
     554        AddVertex(p);
    594555        p = m * p;
    595         AppendQuadVert(p);
     556        AddVertex(p);
    596557        if (fade)
    597558            SetCurVertColor(m_color2);
    598559        p = m * p;
    599         AppendQuadVert(p);
     560        AddVertex(p);
    600561        if (fade)
    601562            SetCurVertColor(m_color2);
     
    611572    void AppendSimpleQuad(vec2 p1, vec2 p2, float z = 0.f, int fade = 0)
    612573    {
    613         AppendQuadVert(vec3(p2.x, z, -p1.y));
    614         AppendQuadVert(vec3(p2.x, z, -p2.y));
    615         AppendQuadVert(vec3(p1.x, z, -p2.y));
     574        AddVertex(vec3(p2.x, z, -p1.y));
     575        AddVertex(vec3(p2.x, z, -p2.y));
     576        AddVertex(vec3(p1.x, z, -p2.y));
    616577        if (fade)
    617578            SetCurVertColor(m_color2);
    618         AppendQuadVert(vec3(p1.x, z, -p1.y));
     579        AddVertex(vec3(p1.x, z, -p1.y));
    619580        if (fade)
    620581            SetCurVertColor(m_color2);
    621582
    622583        AppendQuad(3, 2, 1, 0, m_vert.Count() - 4);
    623         ComputeQuadNormals(m_quadidx.Count() - 4, 4);
     584        ComputeNormals(m_indices.Count() - 6, 6);
    624585    }
    625586
     
    627588                   float r12, float r22, float sidemul, int offset)
    628589    {
    629         int qibase = m_quadidx.Count();
     590        int ibase = m_indices.Count();
    630591        int vbase = m_vert.Count();
    631592
    632         AppendQuadVert(vec3(0.f, h * .5f, 0.f));
    633         AppendQuadVert(vec3(0.f, h * -.5f, 0.f));
     593        AddVertex(vec3(0.f, h * .5f, 0.f));
     594        AddVertex(vec3(0.f, h * -.5f, 0.f));
    634595        SetCurVertColor(m_color2);
    635596
     
    662623            for (int n = 0; n < 24; n++)
    663624            {
    664                 AppendQuadVert(p[n / 3]);
     625                AddVertex(p[n / 3]);
    665626                if (n / 3 >= 4)
    666627                    SetCurVertColor(m_color2);
     
    685646        }
    686647
    687         ComputeQuadNormals(qibase, m_quadidx.Count() - qibase);
     648        ComputeNormals(ibase, m_indices.Count() - ibase);
    688649    }
    689650
     
    695656private:
    696657    vec4 m_color, m_color2;
    697     Array<uint16_t> m_triidx, m_quadidx;
     658    Array<uint16_t> m_indices;
    698659    Array<vec3, vec3, vec4> m_vert;
    699     Array<int, int, int> m_cursors;
     660    Array<int, int> m_cursors;
    700661
    701662    /* FIXME: put this in a separate class so that we can copy meshes. */
Note: See TracChangeset for help on using the changeset viewer.