source: trunk/orbital/mesh.h @ 1424 Tweet

//
// Orbital
//
// Copyright: (c) 2009-2012 Cédric Lecacheur <jordx@free.fr>
//            (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
//            (c) 2012 Sam Hocevar <sam@hocevar.net>
//

/* TODO for this file:
 *  - rename "AppendQuadVert" to "AddVertex" or something; it has nothing
 *    to do with quads.
 */

#if !defined __MESH_H__
#define __MESH_H__

extern char const *lolfx_shiny;

class Mesh
{
public:
    Mesh()
      : m_color(0), m_color2(0),
        m_vert_cursor(0), m_quadidx_cursor(0), m_triidx_cursor(0)
    {}

    void SendCommand(char const *command);

    void Flush()
    {
        m_vert_cursor = m_vert.Count();
        m_quadidx_cursor = m_quadidx.Count();
        m_triidx_cursor = m_triidx.Count();
    }

    void MeshConvert()
    {
        m_gpu.shader = Shader::Create(lolfx_shiny);

        m_gpu.modelview = m_gpu.shader->GetUniformLocation("in_ModelView");
        m_gpu.proj = m_gpu.shader->GetUniformLocation("in_Proj");
        m_gpu.normalmat = m_gpu.shader->GetUniformLocation("in_NormalMat");
        m_gpu.damage = m_gpu.shader->GetUniformLocation("in_Damage");
        m_gpu.coord = m_gpu.shader->GetAttribLocation("in_Vertex",
                                              VertexUsage::Position, 0);
        m_gpu.norm = m_gpu.shader->GetAttribLocation("in_Normal",
                                             VertexUsage::Normal, 0);
        m_gpu.color = m_gpu.shader->GetAttribLocation("in_Color",
                                              VertexUsage::Color, 0);

        m_gpu.vdecl = new VertexDeclaration(
            VertexStream<vec3,vec3,u8vec4>(VertexUsage::Position,
                                           VertexUsage::Normal,
                                           VertexUsage::Color));

        Array<vec3,vec3,u8vec4> vertexlist;
        for (int i = 0; i < m_vert.Count(); i++)
            vertexlist.Push(m_vert[i].m1,
                            m_vert[i].m2,
                            (u8vec4)(m_vert[i].m3 * 255.f));

        Array<uint16_t> indexlist;
        for (int i = 0; i < m_triidx.Count(); i += 3)
        {
            indexlist << m_triidx[i + 0];
            indexlist << m_triidx[i + 1];
            indexlist << m_triidx[i + 2];
        }
        for (int i = 0; i < m_quadidx.Count(); i += 4)
        {
            indexlist << m_quadidx[i + 0];
            indexlist << m_quadidx[i + 1];
            indexlist << m_quadidx[i + 2];

            indexlist << m_quadidx[i + 0];
            indexlist << m_quadidx[i + 2];
            indexlist << m_quadidx[i + 3];
        }

        m_gpu.vbo = new VertexBuffer(vertexlist.Bytes());
        void *mesh = m_gpu.vbo->Lock(0, 0);
        memcpy(mesh, &vertexlist[0], vertexlist.Bytes());
        m_gpu.vbo->Unlock();

        m_gpu.ibo = new IndexBuffer(indexlist.Bytes());
        void *indices = m_gpu.ibo->Lock(0, 0);
        memcpy(indices, &indexlist[0], indexlist.Bytes());
        m_gpu.ibo->Unlock();

        m_gpu.vertexcount = vertexlist.Count();
        m_gpu.indexcount = indexlist.Count();
    }

    void Render(mat4 const &model, float damage = 0.f)
    {
        mat4 modelview = Scene::GetDefault()->GetViewMatrix() * model;
        mat3 normalmat = transpose(inverse(mat3(modelview)));

        m_gpu.shader->Bind();
        m_gpu.shader->SetUniform(m_gpu.modelview, modelview);
        m_gpu.shader->SetUniform(m_gpu.proj, Scene::GetDefault()->GetProjMatrix());
        m_gpu.shader->SetUniform(m_gpu.normalmat, normalmat);
        m_gpu.shader->SetUniform(m_gpu.damage, damage);
        m_gpu.vdecl->SetStream(m_gpu.vbo, m_gpu.coord, m_gpu.norm, m_gpu.color);
        m_gpu.vdecl->Bind();
        m_gpu.ibo->Bind();
        m_gpu.vdecl->DrawIndexedElements(MeshPrimitive::Triangles,
                                         0, 0, m_gpu.vertexcount,
                                         0, m_gpu.indexcount / 3);
        m_gpu.ibo->Unbind();
        m_gpu.vdecl->Unbind();
    }

    void SetCurColor(vec4 const &color) { m_color = color; }
    void SetCurColor2(vec4 const &color) { m_color2 = color; }

    void AppendQuadVert(vec3 const &coord)
    {
        m_vert.Push(coord, vec3(0.f, 1.f, 0.f), m_color);
    }

    void AppendDuplicateQuadVert(int i)
    {
        m_vert.Push(m_vert[i].m1, vec3(0.f, 1.f, 0.f), m_vert[i].m3);
    }

    void AppendQuad(int i1, int i2, int i3, int i4, int base)
    {
        m_quadidx << base + i1;
        m_quadidx << base + i2;
        m_quadidx << base + i3;
        m_quadidx << base + i4;
    }

    void AppendQuadDuplicateVerts(int i1, int i2, int i3, int i4, int base)
    {
        m_quadidx << m_vert.Count(); AppendDuplicateQuadVert(base + i1);
        m_quadidx << m_vert.Count(); AppendDuplicateQuadVert(base + i2);
        m_quadidx << m_vert.Count(); AppendDuplicateQuadVert(base + i3);
        m_quadidx << m_vert.Count(); AppendDuplicateQuadVert(base + i4);
    }

    void AppendTriangle(int i1, int i2, int i3, int base)
    {
        m_triidx << base + i1;
        m_triidx << base + i2;
        m_triidx << base + i3;
    }

    void AppendTriangleDuplicateVerts(int i1, int i2, int i3, int base)
    {
        m_triidx << m_vert.Count(); AppendDuplicateQuadVert(base + i1);
        m_triidx << m_vert.Count(); AppendDuplicateQuadVert(base + i2);
        m_triidx << m_vert.Count(); AppendDuplicateQuadVert(base + i3);
    }

    void ComputeQuadNormals(int start, int vcount)
    {
        for (int i = 0; i < vcount; i += 4)
        {
            vec3 v0 = m_vert[m_quadidx[start + i + 2]].m1
                    - m_vert[m_quadidx[start + i + 0]].m1;
            vec3 v1 = m_vert[m_quadidx[start + i + 1]].m1
                    - m_vert[m_quadidx[start + i + 0]].m1;
            vec3 n = normalize(cross(v1, v0));

            for (int j = 0; j < 4; j++)
                m_vert[m_quadidx[start + i + j]].m2 = n;
        }
    }

    void ComputeTriNormals(int start, int vcount)
    {
        for (int i = 0; i < vcount; i += 3)
        {
            vec3 v0 = m_vert[m_triidx[start + i + 2]].m1
                    - m_vert[m_triidx[start + i + 0]].m1;
            vec3 v1 = m_vert[m_triidx[start + i + 1]].m1
                    - m_vert[m_triidx[start + i + 0]].m1;
            vec3 n = normalize(cross(v1, v0));

            for (int j = 0; j < 3; j++)
                m_vert[m_triidx[start + i + j]].m2 = n;
        }
    }

    void SetVertColor(vec4 const &color)
    {
        for (int i = m_vert_cursor; i < m_vert.Count(); i++)
            m_vert[i].m3 = color;
    }

    void SetCurVertNormal(vec3 const &normal)
    {
        m_vert[m_vert.Count() - 1].m2 = normal;
    }

    void SetCurVertColor(vec4 const &color)
    {
        m_vert[m_vert.Count() - 1].m3 = color;
    }

    void Translate(vec3 const &v)
    {
        for (int i = m_vert_cursor; i < m_vert.Count(); i++)
            m_vert[i].m1 += v;
    }

    void RotateX(float t) { Rotate(t, vec3(1, 0, 0)); }
    void RotateY(float t) { Rotate(t, vec3(0, 1, 0)); }
    void RotateZ(float t) { Rotate(t, vec3(0, 0, 1)); }

    void Rotate(float t, vec3 const &axis)
    {
        mat3 m = mat3::rotate(t, axis);
        for (int i = m_vert_cursor; i < m_vert.Count(); i++)
        {
            m_vert[i].m1 = m * m_vert[i].m1;
            m_vert[i].m2 = m * m_vert[i].m2;
        }
    }

    void TaperX(float y, float z, float xoff)
    {
        /* FIXME: this code breaks normals! */
        for (int i = m_vert_cursor; i < m_vert.Count(); i++)
        {
            m_vert[i].m1.y *= 1.f + (y * m_vert[i].m1.x + xoff);
            m_vert[i].m1.z *= 1.f + (z * m_vert[i].m1.x + xoff);
        }
    }

    void TaperY(float x, float z, float yoff)
    {
        for (int i = m_vert_cursor; i < m_vert.Count(); i++)
        {
            m_vert[i].m1.x *= 1.f + (x * m_vert[i].m1.y + yoff);
            m_vert[i].m1.z *= 1.f + (z * m_vert[i].m1.y + yoff);
        }
    }

    void TaperZ(float x, float y, float zoff)
    {
        for (int i = m_vert_cursor; i < m_vert.Count(); i++)
        {
            m_vert[i].m1.x *= 1.f + (x * m_vert[i].m1.z + zoff);
            m_vert[i].m1.y *= 1.f + (y * m_vert[i].m1.z + zoff);
        }
    }

    void Scale(vec3 const &s)
    {
        vec3 const invs = vec3(1) / s;

        for (int i = m_vert_cursor; i < m_vert.Count(); i++)
        {
            m_vert[i].m1 *= s;
            m_vert[i].m2 = normalize(m_vert[i].m2 * invs);
        }

        /* Flip winding if the scaling involves mirroring */
        if (s.x * s.y * s.z < 0)
        {
            for (int i = m_quadidx_cursor; i < m_quadidx.Count(); i += 2)
            {
                uint16_t tmp = m_quadidx[i + 0];
                m_quadidx[i + 0] = m_quadidx[i + 1];
                m_quadidx[i + 1] = tmp;
            }

            for (int i = m_triidx_cursor; i < m_triidx.Count(); i += 3)
            {
                uint16_t tmp = m_triidx[i + 0];
                m_triidx[i + 0] = m_triidx[i + 1];
                m_triidx[i + 1] = tmp;
            }
        }
    }

    void MirrorX() { Duplicate(); Scale(vec3(-1, 1, 1)); }
    void MirrorY() { Duplicate(); Scale(vec3(1, -1, 1)); }
    void MirrorZ() { Duplicate(); Scale(vec3(1, 1, -1)); }

    void Duplicate()
    {
        int vlen = m_vert.Count() - m_vert_cursor;
        int qlen = m_quadidx.Count() - m_quadidx_cursor;
        int tlen = m_triidx.Count() - m_triidx_cursor;

        for (int i = 0; i < vlen; i++)
            m_vert << m_vert[m_vert_cursor++];

        for (int i = 0; i < qlen; i++)
            m_quadidx << m_quadidx[m_quadidx_cursor++] + vlen;

        for (int i = 0; i < tlen; i++)
            m_triidx << m_triidx[m_triidx_cursor++] + vlen;
    }

    void AppendCylinder(int nsides, float h, float r1, float r2,
                        int dualside, int smooth)
    {
        int vbase = m_vert.Count();

        mat3 rotmat = mat3::rotate(360.0f / nsides, 0.f, 1.f, 0.f);
        vec3 p1(r1, -h * .5f, 0.f), p2(r2, h * .5f, 0.f), n;

        /* Construct normal */
        n = p2;
        n.y = r1 * (r1 - r2) / h;
        if (!smooth)
            n = mat3::rotate(180.0f / nsides, 0.f, 1.f, 0.f) * n;
        n = normalize(n);

        /* FIXME: normals should be flipped in two-sided mode, but that
         * means duplicating the vertices again... */
        for (int i = 0; i < nsides; i++)
        {
            AppendQuadVert(p1); SetCurVertNormal(n);
            AppendQuadVert(p2); SetCurVertNormal(n);
            SetCurVertColor(m_color2);

            if (smooth)
            {
                int j = (i + 1) % nsides;
                AppendQuad(j * 2, j * 2 + 1, i * 2 + 1, i * 2, vbase);
                if (dualside)
                    AppendQuad(i * 2, i * 2 + 1, j * 2 + 1, j * 2, vbase);
            }

            p1 = rotmat * p1;
            p2 = rotmat * p2;

            if (!smooth)
            {
                AppendQuadVert(p1); SetCurVertNormal(n);
                AppendQuadVert(p2); SetCurVertNormal(n);
                SetCurVertColor(m_color2);

                AppendQuad(i * 4 + 2, i * 4 + 3, i * 4 + 1, i * 4, vbase);
                if (dualside)
                    AppendQuad(i * 4, i * 4 + 1, i * 4 + 3, i * 4 + 2, vbase);
            }

            n = rotmat * n;
        }
    }

    void AppendSphere(int ndivisions, vec3 const &size)
    {
        ndivisions *= 2;

        int ibase = m_quadidx.Count();
        int vbase = m_vert.Count();

        vec3 d = size * 0.5f;
        float const pi = std::acos(-1.0f);

        Array<vec2> table;
        for (int i = 0; i <= ndivisions; i++)
            table.Push(vec2(std::sin(pi * 2 / ndivisions * i) + 1e-5f,
                            std::cos(pi * 2 / ndivisions * i) + 1e-5f));

        for (int j = 0; j <= ndivisions / 2; j++)
            for (int i = 0; i < ndivisions; i++)
            {
                int j2 = j + 1;
                int i2 = (i + 1) % ndivisions;

                AppendQuadVert(d * vec3(table[i], 1.0f) * table[j].xxy);
                AppendQuadVert(d * vec3(table[i2], 1.0f) * table[j].xxy);
                AppendQuadVert(d * vec3(table[i2], 1.0f) * table[j2].xxy);
                AppendQuadVert(d * vec3(table[i], 1.0f) * table[j2].xxy);
            }

        for (int i = vbase; i < m_vert.Count(); i += 4)
            AppendQuad(0, 1, 2, 3, i);

        ComputeQuadNormals(ibase, m_quadidx.Count() - ibase);
    }

    void AppendBox(vec3 const &size, float chamf = 0.f)
    {
        AppendBox(size, chamf, false);
    }

    void AppendSmoothChamfBox(vec3 const &size, float chamf)
    {
        AppendBox(size, chamf, true);
    }

    void AppendFlatChamfBox(vec3 const &size, float chamf)
    {
        AppendBox(size, chamf, false);
    }

    void AppendBox(vec3 const &size, float chamf, bool smooth)
    {
        int vbase = m_vert.Count();
        int qibase = m_quadidx.Count();
        int tibase = m_triidx.Count();

        vec3 d = size * 0.5f;

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

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

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

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

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

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

        /* The 6 quads on each side of the box */
        for (int i = 0; i < 24; i += 4)
            AppendQuad(i, i + 1, i + 2, i + 3, vbase);

        ComputeQuadNormals(qibase, m_quadidx.Count() - qibase);
        qibase = m_quadidx.Count();

        /* The 8 quads at each edge of the box */
        if (chamf)
        {
            static int const quadlist[48] =
            {
                0, 3, 18, 17, 4, 7, 17, 16, 8, 11, 16, 19, 12, 15, 19, 18,
                2, 1, 20, 23, 6, 5, 21, 20, 10, 9, 22, 21, 14, 13, 23, 22,
                1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12, 3, 2,
            };

            for (int i = 0; i < 48; i += 4)
            {
                if (smooth)
                    AppendQuad(quadlist[i], quadlist[i + 1],
                               quadlist[i + 2], quadlist[i + 3], vbase);
                else
                    AppendQuadDuplicateVerts(quadlist[i], quadlist[i + 1],
                                     quadlist[i + 2], quadlist[i + 3], vbase);
            }
        }

        /* The 8 triangles at each corner of the box */
        if (chamf)
        {
            static int const trilist[24] =
            {
                3, 12, 18, 15, 8, 19, 11, 4, 16, 7, 0, 17,
                2, 23, 13, 14, 22, 9, 10, 21, 5, 6, 20, 1,
            };

            for (int i = 0; i < 24; i += 3)
            {
                if (smooth)
                    AppendTriangle(trilist[i], trilist[i + 1],
                                   trilist[i + 2], vbase);
                else
                    AppendTriangleDuplicateVerts(trilist[i], trilist[i + 1],
                                                 trilist[i + 2], vbase);
            }
        }

        if (!smooth)
        {
            ComputeQuadNormals(qibase, m_quadidx.Count() - qibase);
            ComputeTriNormals(tibase, m_triidx.Count() - tibase);
        }
    }

    void AppendStar(int nbranches, float r1, float r2,
                    int fade = 0, int fade2 = 0)
    {
        int vbase = m_vert.Count();

        AppendQuadVert(vec3(0.f, 0.f, 0.f));

        mat3 rotmat = mat3::rotate(180.0f / nbranches, 0.f, 1.f, 0.f);
        vec3 p1(r1, 0.f, 0.f), p2(r2, 0.f, 0.f);

        p2 = rotmat * p2;
        rotmat = rotmat * rotmat;

        for (int i = 0; i < nbranches; i++)
        {
            AppendQuadVert(p1);
            if (fade2)
                SetCurVertColor(m_color2);

            AppendQuadVert(p2);
            if (fade)
                SetCurVertColor(m_color2);

            AppendQuad(0, 2 * i + 1, 2 * i + 2, (2 * i + 3) % (2 * nbranches),
                       vbase);

            p1 = rotmat * p1;
            p2 = rotmat * p2;
        }
    }

    void AppendExpandedStar(int nbranches, float r1, float r2, float extrar)
    {
        int vbase = m_vert.Count();

        AppendQuadVert(vec3(0.f, 0.f, 0.f));

        mat3 rotmat = mat3::rotate(180.0f / nbranches, 0.f, 1.f, 0.f);
        vec3 p1(r1, 0.f, 0.f), p2(r2, 0.f, 0.f),
             p3(r1 + extrar, 0.f, 0.f), p4(r2 + extrar, 0.f, 0.f);;

        p2 = rotmat * p2;
        p4 = rotmat * p4;
        rotmat = rotmat * rotmat;

        for (int i = 0; i < nbranches; i++)
        {
            AppendQuadVert(p1);
            AppendQuadVert(p2);
            AppendQuadVert(p3); SetCurVertColor(m_color2);
            AppendQuadVert(p4); SetCurVertColor(m_color2);

            int j = (i + 1) % nbranches;
            AppendQuad(0, 4 * i + 1, 4 * i + 2, 4 * j + 1, vbase);
            AppendQuad(4 * i + 1, 4 * i + 3, 4 * i + 4, 4 * i + 2, vbase);
            AppendQuad(4 * j + 1, 4 * i + 2, 4 * i + 4, 4 * j + 3, vbase);

            p1 = rotmat * p1;
            p2 = rotmat * p2;
            p3 = rotmat * p3;
            p4 = rotmat * p4;
        }
    }

    void AppendDisc(int nsides, float r, int fade = 0)
    {
        int vbase = m_vert.Count();

        AppendQuadVert(vec3(0.f, 0.f, 0.f));

        mat3 rotmat = mat3::rotate(360.0f / nsides, 0.f, 1.f, 0.f);
        vec3 p1(r, 0.f, 0.f);

        for (int i = 0; i < nsides; i++)
        {
            AppendQuadVert(p1);
            if (fade)
                SetCurVertColor(m_color2);
            AppendTriangle(0, i + 1, ((i + 1) % nsides) + 1, vbase);
            p1 = rotmat * p1;
        }
    }

    void AppendSimpleTriangle(float size, int fade = 0)
    {
        mat3 m = mat3::rotate(120.f, 0.f, 1.f, 0.f);
        vec3 p(0.f, 0.f, size);

        AppendQuadVert(p);
        p = m * p;
        AppendQuadVert(p);
        if (fade)
            SetCurVertColor(m_color2);
        p = m * p;
        AppendQuadVert(p);
        if (fade)
            SetCurVertColor(m_color2);

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

    void AppendSimpleQuad(float size, int fade = 0)
    {
        AppendSimpleQuad(vec2(size * .5f), vec2(size * -.5f), 0.f, fade);
    }

    void AppendSimpleQuad(vec2 p1, vec2 p2, float z = 0.f, int fade = 0)
    {
        AppendQuadVert(vec3(p2.x, z, -p1.y));
        AppendQuadVert(vec3(p2.x, z, -p2.y));
        AppendQuadVert(vec3(p1.x, z, -p2.y));
        if (fade)
            SetCurVertColor(m_color2);
        AppendQuadVert(vec3(p1.x, z, -p1.y));
        if (fade)
            SetCurVertColor(m_color2);

        AppendQuad(3, 2, 1, 0, m_vert.Count() - 4);
        ComputeQuadNormals(m_quadidx.Count() - 4, 4);
    }

    void AppendCog(int nbsides, float h, float r1, float r2,
                   float r12, float r22, float sidemul, int offset)
    {
        int qibase = m_quadidx.Count();
        int vbase = m_vert.Count();

        AppendQuadVert(vec3(0.f, h * .5f, 0.f));
        AppendQuadVert(vec3(0.f, h * -.5f, 0.f));
        SetCurVertColor(m_color2);

        mat3 rotmat = mat3::rotate(180.0f / nbsides, 0.f, 1.f, 0.f);
        mat3 smat1 = mat3::rotate(sidemul * 180.0f / nbsides, 0.f, 1.f, 0.f);
        mat3 smat2 = mat3::rotate(sidemul * -360.0f / nbsides, 0.f, 1.f, 0.f);

        vec3 p[8];

        p[0] = vec3(r1, h * .5f, 0.f);
        p[1] = rotmat * p[0];
        p[2] = smat1 * (rotmat * vec3(r1 + r12, h * .5f, 0.f));
        p[3] = smat2 * (rotmat * p[2]);

        p[4] = vec3(r2, h * -.5f, 0.f);
        p[5] = rotmat * p[4];
        p[6] = smat1 * (rotmat * vec3(r2 + r22, h * -.5f, 0.f));
        p[7] = smat2 * (rotmat * p[6]);

        if (offset & 1)
            for (int n = 0; n < 8; n++)
                p[n] = rotmat * p[n];

        rotmat = rotmat * rotmat;

        for (int i = 0; i < nbsides; i++)
        {
            /* Each vertex will share three faces, so three different
             * normals, therefore we add each vertex three times. */
            for (int n = 0; n < 24; n++)
            {
                AppendQuadVert(p[n / 3]);
                if (n / 3 >= 4)
                    SetCurVertColor(m_color2);
            }

            int j = 24 * i, k = 24 * ((i + 1) % nbsides);

            /* The top and bottom faces */
            AppendQuad(0, j + 2, j + 5, k + 2, vbase);
            AppendQuad(1, k + 14, j + 17, j + 14, vbase);
            AppendQuad(j + 5, j + 8, j + 11, k + 2, vbase);
            AppendQuad(k + 14, j + 23, j + 20, j + 17, vbase);

            /* The side quads */
            AppendQuad(j + 6, j + 3, j + 15, j + 18, vbase);
            AppendQuad(j + 9, j + 7, j + 19, j + 21, vbase);
            AppendQuad(j + 12, j + 10, j + 22, j + 24, vbase);
            AppendQuad(k + 4, j + 13, j + 25, k + 16, vbase);

            for (int n = 0; n < 8; n++)
                p[n] = rotmat * p[n];
        }

        ComputeQuadNormals(qibase, m_quadidx.Count() - qibase);
    }

private:
    vec4 m_color, m_color2;
    Array<uint16_t> m_triidx, m_quadidx;
    Array<vec3, vec3, vec4> m_vert;
    int m_vert_cursor, m_quadidx_cursor, m_triidx_cursor;

    /* FIXME: put this in a separate class so that we can copy meshes. */
    struct
    {
        Shader *shader;
        ShaderAttrib coord, norm, color;
        ShaderUniform modelview, proj, normalmat, damage;
        VertexDeclaration *vdecl;
        VertexBuffer *vbo;
        IndexBuffer *ibo;
        int vertexcount, indexcount;
    }
    m_gpu;
};

#endif /* __MESH_H__ */