polymesh.cpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "renderstack/buffer.hpp"
#include "renderstack/mesh.hpp"
#include "renderstack/rs_gl.h"

#include "mesh3d/geometry.h"
#include "mesh3d/corner.h"
#include "mesh3d/vec2.h"

#include "renderstack/shapes/polymesh.hpp"

#include <set>

namespace renderstack { namespace shapes { 

static const double sq2 = std::sqrt(2.0);
static const double sq3 = std::sqrt(3.0);
static const double sq5 = std::sqrt(5.0);

void polymesh::push_point(float x, float y, float z)
{
    m_geometry.make_point(x, y, z);
}

void polymesh::push_point(double x, double y, double z)
{
    m_geometry.make_point(x, y, z);
}

mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0)
{
    return m_geometry.make_polygon(p0);
}
mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1)
{
    return m_geometry.make_polygon(p0, p1);
}
mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1, mesh3d::point *p2)
{
    return m_geometry.make_polygon(p0, p1, p2);
}

mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1, mesh3d::point *p2, mesh3d::point *p3)
{
    return m_geometry.make_polygon(p0, p1, p2, p3);
}
mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1, mesh3d::point *p2, mesh3d::point *p3, mesh3d::point *p4)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4);
}
mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1, mesh3d::point *p2, mesh3d::point *p3, mesh3d::point *p4, mesh3d::point *p5)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5);
}
mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1, mesh3d::point *p2, mesh3d::point *p3, mesh3d::point *p4, mesh3d::point *p5, mesh3d::point *p6)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5, p6);
}
mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1, mesh3d::point *p2, mesh3d::point *p3, mesh3d::point *p4, mesh3d::point *p5, mesh3d::point *p6, mesh3d::point *p7)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5, p6, p7);
}
mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1, mesh3d::point *p2, mesh3d::point *p3, mesh3d::point *p4, mesh3d::point *p5, mesh3d::point *p6, mesh3d::point *p7, mesh3d::point *p8)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
mesh3d::polygon *polymesh::make_polygon(mesh3d::point *p0, mesh3d::point *p1, mesh3d::point *p2, mesh3d::point *p3, mesh3d::point *p4, mesh3d::point *p5, mesh3d::point *p6, mesh3d::point *p7, mesh3d::point *p8, mesh3d::point *p9)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
}

mesh3d::polygon *polymesh::make_polygon(size_t p0)
{
    return m_geometry.make_polygon(p0);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1)
{
    return m_geometry.make_polygon(p0, p1);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1, size_t p2)
{
    return m_geometry.make_polygon(p0, p1, p2);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3)
{
    return m_geometry.make_polygon(p0, p1, p2, p3);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5, p6);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6, size_t p7)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5, p6, p7);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6, size_t p7, size_t p8)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5, p6, p7, p8);
}
mesh3d::polygon *polymesh::make_polygon(size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6, size_t p7, size_t p8, size_t p9)
{
    return m_geometry.make_polygon(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
}

void polymesh::fix_normals()
{
    mesh3d::geometry &g = m_geometry;

    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_normals = g.polygon_attributes().find<mesh3d::vec3>("polygon_normals");
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec3> > point_locations = g.point_attributes  ().find<mesh3d::vec3>("point_locations");

    mesh3d::geometry::polygon_collection &polygons = g.polygons();

    bool recompute_needed = false;

    for(
        mesh3d::geometry::polygon_collection::iterator i = polygons.begin();
        i != polygons.end();
        ++i
    )
    {
        mesh3d::polygon *pol = *i;
        if(pol->corners().size() < 3)
        {
            continue;
        }
        mesh3d::vec3    pn = polygon_normals->value(pol);
        mesh3d::corner  *first_corner       = *pol->corners().begin();
        mesh3d::point   *first_point        = first_corner->point();
        mesh3d::vec3    reference_location  = point_locations->value(first_point);

        float d = dot(pn, reference_location);

        if(d < 0)
        {
            pol->reverse();
            recompute_needed = true;
        }
    }

    if(recompute_needed == true)
    {
        g.compute_polygon_normals();
    }
}




struct edge
{
public:
    edge(mesh3d::point *p0, mesh3d::point *p1)
    {
        if(p0 < p1)
        {
            m_pair.first  = p0;
            m_pair.second = p1;
        }
        else
        {
            m_pair.first  = p1;
            m_pair.second = p0;
        }
    }

    bool operator<(edge const &other) const
    {
        return m_pair < other.m_pair;
    }

    std::pair<mesh3d::point*, mesh3d::point*> m_pair;
};

/*  Compute normals  */ 
/*  Unify normal directions - currently only works for convex polyhedra  */ 
/*  Setup mesh with                */ 
/*    position                     */ 
/*    smoothed corner normals      */ 
/*    polygon face normals         */ 
/*    per vertex polygon ids       */ 
/*  Create all vertices and index buffers for  */ 
/*    corner points                */ 
/*    centroid points              */ 
/*    polygon edges                */ 
/*    polygon triangles            */ 
void polymesh::build_mesh_from_geometry(bool fix_convex_normals)
{
    mesh3d::geometry &g = m_geometry;
    /*                                                                                    */ 
    /*  FIRST: Figure out what sources we have, and compute some if necessary / possible  */ 
    /*                                                                                    */ 

    /*  If polygon centroids or normals are not present, the can be computed  */ 
    if(g.polygon_attributes().has("polygon_normals") == false)
    {
        g.compute_polygon_normals();
    }

    if(g.polygon_attributes().has("polygon_centroids") == false)
    {
        g.compute_polygon_centroids();
    }

    /*  Optionally, face normals can be flipped outward from the center  */ 
    /*  of the mesh. This only does good to convex polyhedra.            */ 
    if(fix_convex_normals == true)
    {
        fix_normals();
    }

    /*  Polygon ID's are always generated here  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, uint32> >  polygon_ids;

    polygon_ids = g.polygon_attributes().find_or_create<uint32>("polygon_ids");

    /*  Corner normals are generated, if no corner or  */ 
    /*  point normals are available so far.            */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::corner*, mesh3d::vec3> > corner_normals;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,  mesh3d::vec3> > point_normals;
    if(g.corner_attributes().has("corner_normals") == true)
    {
        corner_normals = g.corner_attributes().find_or_create<mesh3d::vec3>("corner_normals");
    }
    else if(g.point_attributes().has("point_normals") == true)
    {
        point_normals = g.point_attributes().find_or_create<mesh3d::vec3>("point_normals");
    }
    else
    {
        g.compute_corner_normals(RS_TWO_PI);
        corner_normals = g.corner_attributes().find_or_create<mesh3d::vec3>("corner_normals");
    }

    /*  Texcoords are processed if found for corners or points, in that order  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec2> > point_texcoords;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::corner*,  mesh3d::vec2> > corner_texcoords;
    if(g.corner_attributes().has("corner_texcoords") == true)
    {
        corner_texcoords = g.corner_attributes().find_or_create<mesh3d::vec2>("corner_texcoords");
    }
    else if(g.point_attributes().has("point_texcoords") == true)
    {
        point_texcoords = g.point_attributes().find_or_create<mesh3d::vec2>("point_texcoords");
    }

    /*  These should now be there  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_normals;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_centroids;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec3> > point_locations;

    polygon_normals   = g.polygon_attributes().find<mesh3d::vec3>("polygon_normals");
    polygon_centroids = g.polygon_attributes().find<mesh3d::vec3>("polygon_centroids");
    point_locations   = g.point_attributes  ().find<mesh3d::vec3>("point_locations");

    /*  Corner indices are always generated here  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::corner*, int> > corner_indices;

    corner_indices = g.corner_attributes ().find_or_create<int>("corner_indices");

    /*                                       */ 
    /*  SECOND: Prepare buffers for writing  */ 
    /*                                       */ 

    /*  Setup vertex format  */ 
    vertex_attribute  attribute_position(vertex_attribute_usage_position, GL_FLOAT,        0, 3);
    vertex_attribute  attribute_normal  (vertex_attribute_usage_normal,   GL_FLOAT,        0, 3);
    vertex_attribute  attribute_normal2 (vertex_attribute_usage_normal,   GL_FLOAT,        1, 3);
    vertex_attribute  attribute_texcoord(vertex_attribute_usage_texcoord, GL_FLOAT,        0, 2);
    vertex_attribute  attribute_id      (vertex_attribute_usage_id,       GL_UNSIGNED_INT, 0, 1);

    buffer *vertex_buffer = mesh::vertex_buffer();
    vertex_buffer->vertex_format().append(attribute_position);
    vertex_buffer->vertex_format().append(attribute_normal);
    vertex_buffer->vertex_format().append(attribute_normal2);
    vertex_buffer->vertex_format().append(attribute_id);
    if(corner_texcoords || point_texcoords)
    {
        vertex_buffer->vertex_format().append(attribute_texcoord);
    }

    buffer* polygon_fill_indices     = mesh::find_or_create_index_buffer(mesh_mode_polygon_fill     , GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, GL_UNSIGNED_INT, GL_TRIANGLES);
    buffer* edge_line_indices        = mesh::find_or_create_index_buffer(mesh_mode_edge_lines       , GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, GL_UNSIGNED_INT, GL_LINES);
    buffer* corner_point_indices     = mesh::find_or_create_index_buffer(mesh_mode_corner_points    , GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, GL_UNSIGNED_INT, GL_POINTS);
    buffer* polygon_centroid_indices = mesh::find_or_create_index_buffer(mesh_mode_polygon_centroids, GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, GL_UNSIGNED_INT, GL_POINTS);

    /*  Prepare writing to buffers  */ 
    vertex_buffer           ->begin_edit();
    polygon_fill_indices    ->begin_edit();
    edge_line_indices       ->begin_edit();
    corner_point_indices    ->begin_edit();
    polygon_centroid_indices->begin_edit();

    int index = 0;
    int vertex_index[mesh_mode_count] = {};

    /*  Edges are collected to this work database while working through  */ 
    /*  polygons.                                                        */ 
    std::set<edge> edges;

    uint32 polygon_index = 0;
    mesh3d::geometry::polygon_collection &polygons = g.polygons();

    /*  Go through polygons, create triangles, collect edges  */ 
    for(
        mesh3d::geometry::polygon_collection::iterator i = polygons.begin();
        i != polygons.end();
        ++i
    )
    {
        mesh3d::polygon *pol        = *i;
        mesh3d::vec3    pn;
        if(pol->corners().size() > 2)
        {
            pn          = polygon_normals->value(pol);
        }
        else
        {
            pn          = mesh3d::vec3(0.0f, 1.0f, 0.0f);
        }
        int             first_index = index;
        int             prev_index  = -1;

        mesh3d::corner  *first_corner       = *pol->corners().begin();
        mesh3d::corner  *last_corner        = *pol->corners().rbegin();
        mesh3d::point   *first_point        = first_corner->point();
        mesh3d::point   *last_point         = last_corner->point();
        mesh3d::point   *prev_point         = NULL;
        mesh3d::vec3    reference_location  = point_locations->value(first_point);

        for
        (
            mesh3d::polygon::corner_collection::iterator j = pol->corners().begin();
            j != pol->corners().end();
            ++j
        )
        {
            mesh3d::corner *cor = *j;
            mesh3d::point  *pnt = cor->point();
            mesh3d::vec3   p    = point_locations->value(pnt);

            /*  Set vertex attributes  */ 
            vertex_buffer->set_index(index); 
            vertex_buffer->put_position(p.x, p.y, p.z);

            if(corner_normals && pol->corners().size() > 2)
            {
                mesh3d::vec3 n = corner_normals->value(cor);

                vertex_buffer->put_normal(n.x, n.y, n.z);
            }
            else if(point_normals)
            {
                mesh3d::vec3 n = point_normals->value(pnt);

                vertex_buffer->put_normal(n.x, n.y, n.z);
            }
            else
            {
                vertex_buffer->put_normal(0.0f, 1.0f, 0.0f);
            }

            vertex_buffer->put_normal(pn.x, pn.y, pn.z, 1);

            if(corner_texcoords)
            {
                mesh3d::vec2 texcoord = corner_texcoords->value(cor);
                vertex_buffer->put_texcoord(texcoord.x, texcoord.y);
            }
            else if(point_texcoords)
            {
                mesh3d::vec2 texcoord = point_texcoords->value(pnt);
                vertex_buffer->put_texcoord(texcoord.x, texcoord.y);
            }

            vertex_buffer->put_uint32(attribute_id, polygon_index);

            /*  Store polygon index to geometry database  */ 
            polygon_ids->set_value(pol, polygon_index);

            /*  Write corner point index buffer */ 
            corner_point_indices->set_index(
                vertex_index[mesh_mode_corner_points]
            );
            corner_point_indices->point(index);
            ++vertex_index[mesh_mode_corner_points];

            /*  Store corner index to geometry database  */ 
            corner_indices->set_value(cor, index);

            /*  Write polygon fill triangle  */ 
            if(prev_index != -1)
            {
                polygon_fill_indices->set_index(
                    vertex_index[mesh_mode_polygon_fill]
                );
                polygon_fill_indices->triangle(
                    first_index,
                    index,
                    prev_index
                );
                vertex_index[mesh_mode_polygon_fill] += 3;
            }

            /*  Store edge line to working database  */ 
            if(prev_point != NULL)
            {
                edge e(prev_point, pnt);
                edges.insert(e);
            }

            prev_index = index;
            prev_point = pnt;

            ++index;
        }

        /*  Add last edge to working database  */ 
        {
            edge e(last_point, first_point);
            edges.insert(e);
        }

        ++polygon_index;
    }

    /*  Write all edge lines from working database  */ 
    for(
        std::set<edge>::iterator k = edges.begin();
        k != edges.end();
        ++k
    )
    {
        edge            &e = *k;
        mesh3d::corner  *c0 = e.m_pair.first->corners().front();
        mesh3d::corner  *c1 = e.m_pair.second->corners().front();
        int             i0  = corner_indices->value(c0);
        int             i1  = corner_indices->value(c1);
        edge_line_indices->set_index(
            vertex_index[mesh_mode_edge_lines]
        );
        edge_line_indices->line(i0, i1);
        vertex_index[mesh_mode_edge_lines] += 2;
    }

    /*  Generate polygon centroid vertices and index buffer  */ 
    for(
        mesh3d::geometry::polygon_collection::iterator i = polygons.begin();
        i != polygons.end();
        ++i
    )
    {
        mesh3d::polygon *pol = *i;
        mesh3d::vec3    n;
        if(pol->corners().size() > 2)
        {
            n    = polygon_normals->value(pol);
        }
        else
        {
            n = mesh3d::vec3(0.0f, 1.0f, 0.0f);
        }
        mesh3d::vec3    p    = polygon_centroids->value(pol);

        vertex_buffer->set_index   (index); 
        vertex_buffer->put_position(p.x, p.y, p.z);
        vertex_buffer->put_normal  (n.x, n.y, n.z, 0);
        vertex_buffer->put_normal  (n.x, n.y, n.z, 1);

        polygon_centroid_indices->set_index(
            vertex_index[mesh_mode_polygon_centroids]
        );
        polygon_centroid_indices->point(index);
        ++index;
        ++vertex_index[mesh_mode_polygon_centroids];
    }

    vertex_buffer           ->end_edit(index);
    polygon_fill_indices    ->end_edit(vertex_index[mesh_mode_polygon_fill     ]);
    edge_line_indices       ->end_edit(vertex_index[mesh_mode_edge_lines       ]);
    corner_point_indices    ->end_edit(vertex_index[mesh_mode_corner_points    ]);
    polygon_centroid_indices->end_edit(vertex_index[mesh_mode_polygon_centroids]);
}

mesh *polymesh::make_mesh_from_set_of_polygons(
    std::set<uint32> const &polygon_indices
)
{
    mesh3d::geometry &g = m_geometry;
    mesh3d::geometry sub_g;

    /*                                                                                    */ 
    /*  FIRST: Figure out what sources we have, and compute some if necessary / possible  */ 
    /*                                                                                    */ 

#if 0  //  not done for submesh
    /*  If polygon centroids or normals are not present, the can be computed  */ 
    if(g.polygon_attributes().has("polygon_normals") == false)
    {
        g.compute_polygon_normals();
    }

    if(g.polygon_attributes().has("polygon_centroids") == false)
    {
        g.compute_polygon_centroids();
    }
#endif

    /*  Polygon ID's are always generated here  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, uint32> >  polygon_ids;

    //polygon_ids = g.polygon_attributes().find_or_create<uint32>("polygon_ids");
    polygon_ids = g.polygon_attributes().find<uint32>("polygon_ids");

    /*  Corner normals are generated, if no corner or  */ 
    /*  point normals are available so far.            */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::corner*, mesh3d::vec3> > corner_normals;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,  mesh3d::vec3> > point_normals;
    if(g.corner_attributes().has("corner_normals") == true)
    {
        //corner_normals = g.corner_attributes().find_or_create<mesh3d::vec3>("corner_normals");
        corner_normals = g.corner_attributes().find<mesh3d::vec3>("corner_normals");
    }
    else if(g.point_attributes().has("point_normals") == true)
    {
        //point_normals = g.point_attributes().find_or_create<mesh3d::vec3>("point_normals");
        point_normals = g.point_attributes().find<mesh3d::vec3>("point_normals");
    }
    else
    {
        //g.compute_corner_normals(RS_TWO_PI);
        //corner_normals = g.corner_attributes().find_or_create<mesh3d::vec3>("corner_normals");
        corner_normals = g.corner_attributes().find<mesh3d::vec3>("corner_normals");
    }

    /*  Texcoords are processed if found for corners or points, in that order  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec2> > point_texcoords;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::corner*,  mesh3d::vec2> > corner_texcoords;
    if(g.corner_attributes().has("corner_texcoords") == true)
    {
        //corner_texcoords = g.corner_attributes().find_or_create<mesh3d::vec2>("corner_texcoords");
        corner_texcoords = g.corner_attributes().find<mesh3d::vec2>("corner_texcoords");
    }
    else if(g.point_attributes().has("point_texcoords") == true)
    {
        //point_texcoords = g.point_attributes().find_or_create<mesh3d::vec2>("point_texcoords");
        point_texcoords = g.point_attributes().find<mesh3d::vec2>("point_texcoords");
    }

    /*  These should now be there  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_normals;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_centroids;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec3> > point_locations;

    polygon_normals   = g.polygon_attributes().find<mesh3d::vec3>("polygon_normals");
    polygon_centroids = g.polygon_attributes().find<mesh3d::vec3>("polygon_centroids");
    point_locations   = g.point_attributes  ().find<mesh3d::vec3>("point_locations");

    /*  Corner indices are always generated here  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::corner*, int> > corner_indices;

    //corner_indices = g.corner_attributes().find_or_create<int>("corner_indices");
    corner_indices = sub_g.corner_attributes().find_or_create<int>("corner_indices");

#if 1
    /*  Point indices are? needed? when making submeshes  */ 
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*, int> > point_indices;
    point_indices = sub_g.point_attributes().find_or_create<int>("point_indices");
#endif

    /*                                       */ 
    /*  SECOND: Prepare buffers for writing  */ 
    /*                                       */ 

    /*  Setup vertex format  */ 
    vertex_attribute  attribute_position(vertex_attribute_usage_position, GL_FLOAT,        0, 3);
    vertex_attribute  attribute_normal  (vertex_attribute_usage_normal,   GL_FLOAT,        0, 3);
    vertex_attribute  attribute_normal2 (vertex_attribute_usage_normal,   GL_FLOAT,        1, 3);
    vertex_attribute  attribute_texcoord(vertex_attribute_usage_texcoord, GL_FLOAT,        0, 2);
    vertex_attribute  attribute_id      (vertex_attribute_usage_id,       GL_UNSIGNED_INT, 0, 1);

    mesh *submesh = new mesh();
    buffer *vertex_buffer = submesh->vertex_buffer();
    vertex_buffer->vertex_format().append(attribute_position);
    vertex_buffer->vertex_format().append(attribute_normal);
    vertex_buffer->vertex_format().append(attribute_normal2);
    vertex_buffer->vertex_format().append(attribute_id);
    if(corner_texcoords || point_texcoords)
    {
        vertex_buffer->vertex_format().append(attribute_texcoord);
    }

    buffer* polygon_fill_indices     = submesh->find_or_create_index_buffer(mesh_mode_polygon_fill     , GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, GL_UNSIGNED_INT, GL_TRIANGLES);
    buffer* edge_line_indices        = submesh->find_or_create_index_buffer(mesh_mode_edge_lines       , GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, GL_UNSIGNED_INT, GL_LINES);
    buffer* corner_point_indices     = submesh->find_or_create_index_buffer(mesh_mode_corner_points    , GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, GL_UNSIGNED_INT, GL_POINTS);
    buffer* polygon_centroid_indices = submesh->find_or_create_index_buffer(mesh_mode_polygon_centroids, GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, GL_UNSIGNED_INT, GL_POINTS);

    /*  Prepare writing to buffers  */ 
    vertex_buffer           ->begin_edit();
    polygon_fill_indices    ->begin_edit();
    edge_line_indices       ->begin_edit();
    corner_point_indices    ->begin_edit();
    polygon_centroid_indices->begin_edit();

    int index = 0;
    int vertex_index[mesh_mode_count] = {};

    /*  Edges are collected to this work database while working through  */ 
    /*  polygons.                                                        */ 
    std::set<edge> edges;

    uint32 polygon_index = 0;
    //mesh3d::geometry::polygon_collection &polygons = g.polygons();

    /*  Go through polygons, create triangles, collect edges  */ 
    for(
        std::set<uint32>::const_iterator i = polygon_indices.begin();
        i != polygon_indices.end();
        ++i
    )
    {
        mesh3d::polygon *pol        = g.polygons()[*i];
        mesh3d::vec3    pn          = polygon_normals->value(pol);
        int             first_index = index;
        int             prev_index  = -1;

        mesh3d::corner  *first_corner       = *pol->corners().begin();
        mesh3d::corner  *last_corner        = *pol->corners().rbegin();
        mesh3d::point   *first_point        = first_corner->point();
        mesh3d::point   *last_point         = last_corner->point();
        mesh3d::point   *prev_point         = NULL;
        mesh3d::vec3    reference_location  = point_locations->value(first_point);

        for
        (
            mesh3d::polygon::corner_collection::iterator j = pol->corners().begin();
            j != pol->corners().end();
            ++j
        )
        {
            mesh3d::corner *cor = *j;
            mesh3d::point  *pnt = cor->point();
            mesh3d::vec3   p    = point_locations->value(pnt);

            /*  Set vertex attributes  */ 
            vertex_buffer->set_index(index); 
            vertex_buffer->put_position(p.x, p.y, p.z);

            if(corner_normals)
            {
                mesh3d::vec3 n = corner_normals->value(cor);

                vertex_buffer->put_normal(n.x, n.y, n.z);
            }
            else if(point_normals)
            {
                mesh3d::vec3 n = point_normals->value(pnt);

                vertex_buffer->put_normal(n.x, n.y, n.z);
            }

            vertex_buffer->put_normal(pn.x, pn.y, pn.z, 1);

            if(corner_texcoords)
            {
                mesh3d::vec2 texcoord = corner_texcoords->value(cor);
                vertex_buffer->put_texcoord(texcoord.x, texcoord.y);
            }
            else if(point_texcoords)
            {
                mesh3d::vec2 texcoord = point_texcoords->value(pnt);
                vertex_buffer->put_texcoord(texcoord.x, texcoord.y);
            }

            vertex_buffer->put_uint32(attribute_id, polygon_index);

#if 0  //  not done for submesh
            /*  Store polygon index to geometry database  */ 
            polygon_ids->set_value(pol, polygon_index);
#endif

            /*  Write corner point index buffer */ 
            corner_point_indices->set_index(
                vertex_index[mesh_mode_corner_points]
            );
            corner_point_indices->point(index);
            ++vertex_index[mesh_mode_corner_points];

            /*  Store corner index to geometry database  */ 
            corner_indices->set_value(cor, index);
            point_indices->set_value(pnt, index);

            /*  Write polygon fill triangle  */ 
            if(prev_index != -1)
            {
                polygon_fill_indices->set_index(
                    vertex_index[mesh_mode_polygon_fill]
                );
                polygon_fill_indices->triangle(
                    first_index,
                    index,
                    prev_index
                );
                vertex_index[mesh_mode_polygon_fill] += 3;
            }

            /*  Store edge line to working database  */ 
            if(prev_point != NULL)
            {
                edge e(prev_point, pnt);
                edges.insert(e);
            }

            prev_index = index;
            prev_point = pnt;

            ++index;
        }

        /*  Add last edge to working database  */ 
        {
            edge e(last_point, first_point);
            edges.insert(e);
        }

        ++polygon_index;
    }

    /*  Write all edge lines from working database  */ 
    for(
        std::set<edge>::iterator k = edges.begin();
        k != edges.end();
        ++k
    )
    {
        edge            &e = *k;
#if 0
        mesh3d::corner  *c0 = e.m_pair.first->corners().front();
        mesh3d::corner  *c1 = e.m_pair.second->corners().front();
        int             i0  = corner_indices->value(c0);
        int             i1  = corner_indices->value(c1);
#endif
        int             i0  = point_indices->value(e.m_pair.first);
        int             i1  = point_indices->value(e.m_pair.second);

        edge_line_indices->set_index(
            vertex_index[mesh_mode_edge_lines]
        );
        edge_line_indices->line(i0, i1);
        vertex_index[mesh_mode_edge_lines] += 2;
    }

    /*  Generate polygon centroid vertices and index buffer  */ 
    for(
        std::set<uint32>::const_iterator i = polygon_indices.begin();
        i != polygon_indices.end();
        ++i
    )
    {
        mesh3d::polygon *pol    = g.polygons()[*i];
        mesh3d::vec3    n       = polygon_normals->value(pol);
        mesh3d::vec3    p       = polygon_centroids->value(pol);

        vertex_buffer->set_index   (index); 
        vertex_buffer->put_position(p.x, p.y, p.z);
        vertex_buffer->put_normal  (n.x, n.y, n.z, 0);
        vertex_buffer->put_normal  (n.x, n.y, n.z, 1);

        polygon_centroid_indices->set_index(
            vertex_index[mesh_mode_polygon_centroids]
        );
        polygon_centroid_indices->point(index);
        ++index;
        ++vertex_index[mesh_mode_polygon_centroids];
    }

    vertex_buffer           ->end_edit(index);
    polygon_fill_indices    ->end_edit(vertex_index[mesh_mode_polygon_fill     ]);
    edge_line_indices       ->end_edit(vertex_index[mesh_mode_edge_lines       ]);
    corner_point_indices    ->end_edit(vertex_index[mesh_mode_corner_points    ]);
    polygon_centroid_indices->end_edit(vertex_index[mesh_mode_polygon_centroids]);

    return submesh;
}

mesh3d::point *sphere::make_point(
    double rel_slice, 
    double rel_stack, 
    double radius
)
{
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*, mesh3d::vec3> > point_locations;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*, mesh3d::vec3> > point_normals;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*, mesh3d::vec2> > point_texcoords;

    mesh3d::geometry &g = m_geometry;
    point_locations = g.point_attributes().find_or_create<mesh3d::vec3>("point_locations");
    point_normals   = g.point_attributes().find_or_create<mesh3d::vec3>("point_normals");
    point_texcoords = g.point_attributes().find_or_create<mesh3d::vec2>("point_texcoords");

    double  phi             = (RS_TWO_PI * rel_slice);
    double  sin_phi         = std::sin(phi);
    double  cos_phi         = std::cos(phi);

    double  theta           = (RS_HALF_PI * rel_stack);
    double  sin_theta       = std::sin(theta);
    double  cos_theta       = std::cos(theta);

    double  stack_radius    = cos_theta;

    float   xVN             = (float)(stack_radius * cos_phi);
    float   yVN             = (float)(sin_theta);
    float   zVN             = (float)(stack_radius * sin_phi);

    float   xP              = (float)(radius * xVN);
    float   yP              = (float)(radius * yVN);
    float   zP              = (float)(radius * zVN);

    float   s               = (float)(rel_slice);
    float   t               = (float)(0.5f * (1.0f + rel_stack));

    mesh3d::point* pnt = g.make_point();

    point_locations->set_value(pnt, mesh3d::vec3(xP, yP, zP));
    point_normals  ->set_value(pnt, mesh3d::vec3(xVN, yVN, zVN));
    point_texcoords->set_value(pnt, mesh3d::vec2(s, t));

    return pnt;
}


/*  Classic slices and stacks sphere                          */ 
/*  Note that lines rel_slice == 0 and rel_slice == 1 have    */ 
/*  separate vertices on purpose, as they have different      */ 
/*  texcoords.                                                */ 
/*  Also note that bottom and top fans are made of triangles  */ 
/*  instead of quads, and interpolation of texcoords will     */ 
/*  just fail there. If you texture map a sphere, make sure   */ 
/*  the polar fans have unified texel color.                  */ 
sphere::sphere(float radius, int stack_division, int slice_count)
{
    int stack_count = (2 * stack_division) + 1;

    int slice;
    int stack;

    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec3> > point_locations;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::point*,   mesh3d::vec3> > point_normals;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_centroids;
    std::tr1::shared_ptr<mesh3d::attribute_map<mesh3d::polygon*, mesh3d::vec3> > polygon_normals;

    mesh3d::geometry &g = m_geometry;
    point_locations   = g.point_attributes  ().find_or_create<mesh3d::vec3>("point_locations");
    point_normals     = g.point_attributes  ().find_or_create<mesh3d::vec3>("point_normals");
    polygon_centroids = g.polygon_attributes().find_or_create<mesh3d::vec3>("polygon_centroids");
    polygon_normals   = g.polygon_attributes().find_or_create<mesh3d::vec3>("polygon_normals");

    /*  Bottom and top vertices  */ 
    mesh3d::point *bottom = make_point(0.5f, -1.0f, radius);
    mesh3d::point *top    = make_point(0.5f, 1.0f, radius);

    /*  Other vertices  */ 
    std::vector<mesh3d::point*> points;
    for(slice = 0; slice <= slice_count; ++slice)
    {
        double rel_slice = (double)(slice) / (double)(slice_count);
        for(stack = -stack_division; stack <= stack_division; ++stack)
        {
            double rel_stack = (double)(stack) / (double)(stack_division + 1);

            mesh3d::point *pnt = make_point(rel_slice, rel_stack, radius);

            points.push_back(pnt);
        }
    }

    /*  Bottom fan  */ 
    std::vector<mesh3d::point*> centroids;
    {
        for(slice = 0; slice < slice_count; ++slice)
        {
            int next_slice  = (slice + 1);
            int stack_base0 = 0;

            double rel_slice = ((double)(slice) + 0.5) / (double)(slice_count);
            double rel_stack = 0.5 / (double)(stack_division + 1);

            mesh3d::point *centroid = make_point(rel_slice, rel_stack, radius);

            mesh3d::polygon *pol = g.make_polygon(
                points[(slice      * stack_count) + stack_base0],
                bottom,
                points[(next_slice * stack_count) + stack_base0]
            );

            polygon_centroids->set_value(pol, point_locations->value(centroid));
            polygon_normals  ->set_value(pol, point_normals  ->value(centroid));
        }
    }

    /*  Middle quads, bottom up  */ 
    for(
        stack = -stack_division; 
        stack < stack_division; 
        ++stack
    )
    {
        int stack_base0      = stack + stack_division;
        int next_stack_base0 = stack_base0 + 1;

        double rel_stack = ((double)(stack) + 0.5) / (double)(stack_division + 1);

        for(slice = 0; slice < slice_count; ++slice)
        {
            int next_slice = (slice + 1);

            double rel_slice = ((double)(slice) + 0.5) / (double)(slice_count);

            mesh3d::point *centroid = make_point(rel_slice, rel_stack, radius);

            mesh3d::polygon *pol = g.make_polygon(
                points[(next_slice * stack_count) + next_stack_base0],
                points[(slice      * stack_count) + next_stack_base0],
                points[(slice      * stack_count) + stack_base0],
                points[(next_slice * stack_count) + stack_base0]
            );

            polygon_centroids->set_value(pol, point_locations->value(centroid));
            polygon_normals  ->set_value(pol, point_normals  ->value(centroid));
        }
    }

    /*  Top fan   */ 
    for(slice = 0; slice < slice_count; ++slice)
    {
        int next_slice  = (slice + 1);
        int stack       =  stack_division;
        int stack_base0 =  stack + stack_division;

        double rel_slice = ((double)(slice) + 0.5) / (double)(slice_count);
        double rel_stack = 1.0 - (0.5 / (double)(stack_division + 1));

        mesh3d::point *centroid = make_point(rel_slice, rel_stack, radius);

        mesh3d::polygon *pol = g.make_polygon(
            top,
            points[(slice      * stack_count) + stack_base0],
            points[(next_slice * stack_count) + stack_base0]
        );

        polygon_centroids->set_value(pol, point_locations->value(centroid));
        polygon_normals  ->set_value(pol, point_normals  ->value(centroid));
    }

    build_mesh_from_geometry(false);
}

quad::quad()
{
    push_point(0.0,  0.0,  0.0);
    push_point(1.0,  0.0,  0.0);
    push_point(1.0,  1.0,  0.0);
    push_point(0.0,  1.0,  0.0);

    make_polygon(0, 1, 2, 3);

    build_mesh_from_geometry();
}


cube::cube(double r)
{
    push_point(-r / sq3,  r / sq3,  r / sq3);
    push_point( r / sq3,  r / sq3,  r / sq3);
    push_point( r / sq3, -r / sq3,  r / sq3);
    push_point(-r / sq3, -r / sq3,  r / sq3);
    push_point(-r / sq3,  r / sq3, -r / sq3);
    push_point( r / sq3,  r / sq3, -r / sq3);
    push_point( r / sq3, -r / sq3, -r / sq3);
    push_point(-r / sq3, -r / sq3, -r / sq3);

    make_polygon(  0, 1, 2, 3  );
    make_polygon(  0, 3, 7, 4  );
    make_polygon(  0, 4, 5, 1  );
    make_polygon(  6, 7, 4, 5  );
    make_polygon(  6, 5, 1, 2  );
    make_polygon(  6, 2, 3, 7  );

    build_mesh_from_geometry();
}


cuboctahedron::cuboctahedron(double r)
{
    push_point(      0,      r,            0 );
    push_point(  r / 2,  r / 2,  r * sq2 / 2 );
    push_point(  r / 2,  r / 2, -r * sq2 / 2 );
    push_point(      r,      0,            0 );
    push_point(  r / 2, -r / 2,  r * sq2 / 2 );
    push_point(  r / 2, -r / 2, -r * sq2 / 2 );
    push_point(      0,     -r,            0 );
    push_point( -r / 2, -r / 2,  r * sq2 / 2 );
    push_point( -r / 2, -r / 2, -r * sq2 / 2 );
    push_point(     -r,      0,            0 );
    push_point( -r / 2,  r / 2,  r * sq2 / 2 );
    push_point( -r / 2,  r / 2, -r * sq2 / 2 );

    make_polygon(  1, 4,  7, 10 );
    make_polygon(  4, 3,  5,  6 );
    make_polygon(  1, 3,  2,  0 );
    make_polygon(  2, 5,  8, 11 );
    make_polygon( 10, 9, 11,  0 );
    make_polygon(  7, 6,  8,  9 );

    make_polygon(  0, 1, 10 );
    make_polygon(  3, 4,  1 );
    make_polygon(  4, 6,  7 );
    make_polygon( 10, 7,  9 );
    make_polygon(  0, 2, 11 );
    make_polygon(  3, 5,  2 );
    make_polygon(  5, 6,  8 );
    make_polygon( 11, 8,  9 );

    build_mesh_from_geometry();
}

dodecahedron::dodecahedron(double r)
{
    double a = 2.0 / (sq3 + sq3 * sq5);
    double b = 1.0 / (3.0 * a);

    push_point( r / sq3,  r / sq3,  r / sq3);
    push_point( r / sq3,  r / sq3, -r / sq3);
    push_point( r / sq3, -r / sq3,  r / sq3);
    push_point( r / sq3, -r / sq3, -r / sq3);
    push_point(-r / sq3,  r / sq3,  r / sq3);
    push_point(-r / sq3,  r / sq3, -r / sq3);
    push_point(-r / sq3, -r / sq3,  r / sq3);
    push_point(-r / sq3, -r / sq3, -r / sq3);
    push_point(       0,  r * a,  r * b);
    push_point(       0,  r * a, -r * b);
    push_point(       0, -r * a,  r * b);
    push_point(       0, -r * a, -r * b);
    push_point( r * a,  r * b,        0);
    push_point( r * a, -r * b,        0);
    push_point(-r * a,  r * b,        0);
    push_point(-r * a, -r * b,        0);
    push_point( r * b,        0,  r * a);
    push_point( r * b,        0, -r * a);
    push_point(-r * b,        0,  r * a);
    push_point(-r * b,        0, -r * a);

    make_polygon( 10,  8, 4, 18, 6 );
    make_polygon( 10,  8, 0, 16, 2 );
    make_polygon( 11,  9, 1, 17, 3 );
    make_polygon(  9, 11, 7, 19, 5 );
    make_polygon( 17, 16, 2, 13, 3 );
    make_polygon( 17, 16, 0, 12, 1 );
    make_polygon( 19, 18, 6, 15, 7 );
    make_polygon( 19, 18, 4, 14, 5 );
    make_polygon( 12, 14, 4,  8, 0 );
    make_polygon( 12, 14, 5,  9, 1 );
    make_polygon( 13, 15, 6, 10, 2 );
    make_polygon( 13, 15, 7, 11, 3 );

    build_mesh_from_geometry();
}

icosahedron::icosahedron(double r)
{
    double a = 2.0 / (1.0 + sq5);
    double b = sqrt((3.0 + sq5) / (1.0 + sq5));
    a /= b;

    push_point(      0,  r * a,  r / b );
    push_point(      0,  r * a, -r / b );
    push_point(      0, -r * a,  r / b );
    push_point(      0, -r * a, -r / b );
    push_point(  r * a,  r / b,      0 );
    push_point(  r * a, -r / b,      0 );
    push_point( -r * a,  r / b,      0 );
    push_point( -r * a, -r / b,      0 );
    push_point(  r / b,      0,  r * a );
    push_point(  r / b,      0, -r * a );
    push_point( -r / b,      0,  r * a );
    push_point( -r / b,      0, -r * a );

    make_polygon( 1,  4,  6);
    make_polygon( 0,  6,  4);
    make_polygon( 0,  2, 10);
    make_polygon( 0,  8,  2);
    make_polygon( 1,  3,  9);
    make_polygon( 1, 11,  3);
    make_polygon( 2,  5,  7);
    make_polygon( 3,  7,  5);
    make_polygon( 6, 10, 11);
    make_polygon( 7, 11, 10);
    make_polygon( 4,  9,  8);
    make_polygon( 5,  8,  9);
    make_polygon( 0, 10,  6);
    make_polygon( 0,  4,  8);
    make_polygon( 1,  6, 11);
    make_polygon( 1,  9,  4);
    make_polygon( 3, 11,  7);
    make_polygon( 3,  5,  9);
    make_polygon( 2,  7, 10);
    make_polygon( 2,  8,  5);

    build_mesh_from_geometry();
}

octahedron::octahedron(double r)
{
    push_point( 0,  r,  0);
    push_point( 0, -r,  0);
    push_point(-r,  0,  0);
    push_point( 0,  0, -r);
    push_point( r,  0,  0);
    push_point( 0,  0,  r);

    make_polygon( 0, 2, 3 );
    make_polygon( 0, 3, 4 );
    make_polygon( 0, 4, 5 );
    make_polygon( 0, 5, 2 );
    make_polygon( 1, 2, 3 );
    make_polygon( 1, 3, 4 );
    make_polygon( 1, 4, 5 );
    make_polygon( 1, 5, 2 );

    build_mesh_from_geometry();
}

tetrahedron::tetrahedron(double r)
{
    push_point(                 0,          r,                  0   );
    push_point(                 0,   -r / 3.0,  r * 2.0 * sq2 / 3.0 );
    push_point(-r * sq3 * sq2 / 3.0, -r / 3.0,       -r * sq2 / 3.0 );
    push_point( r * sq3 * sq2 / 3.0, -r / 3.0,       -r * sq2 / 3.0 );

    make_polygon( 0, 1, 2 );
    make_polygon( 0, 1, 3 );
    make_polygon( 0, 2, 3 );
    make_polygon( 1, 2, 3 );

    build_mesh_from_geometry();
}

truncated_cube::truncated_cube(double r)
{
    double a = (1.0 + sq2) / (2.0 * sqrt(5.0 / 2.0 + sq2));
    double b = 1.0 / (2.0 * sqrt(5.0 / 2.0 + sq2));

    push_point( r * b,  r * a,  r * a);
    push_point( r * a,  r * b,  r * a);
    push_point( r * a, -r * b,  r * a);
    push_point( r * b, -r * a,  r * a);
    push_point(-r * b, -r * a,  r * a);
    push_point(-r * a, -r * b,  r * a);
    push_point(-r * a,  r * b,  r * a);
    push_point(-r * b,  r * a,  r * a);
    push_point( r * a,  r * a,  r * b);
    push_point( r * a, -r * a,  r * b);
    push_point(-r * a, -r * a,  r * b);
    push_point(-r * a,  r * a,  r * b);
    push_point( r * a,  r * a, -r * b);
    push_point( r * a, -r * a, -r * b);
    push_point(-r * a, -r * a, -r * b);
    push_point(-r * a,  r * a, -r * b);
    push_point( r * b,  r * a, -r * a);
    push_point( r * a,  r * b, -r * a);
    push_point( r * a, -r * b, -r * a);
    push_point( r * b, -r * a, -r * a);
    push_point(-r * b, -r * a, -r * a);
    push_point(-r * a, -r * b, -r * a);
    push_point(-r * a,  r * b, -r * a);
    push_point(-r * b,  r * a, -r * a);

    make_polygon(  0,  1,  8 );
    make_polygon(  2,  3,  9 );
    make_polygon(  4,  5, 10 );
    make_polygon(  6,  7, 11 );
    make_polygon( 16, 17, 12 );
    make_polygon( 18, 19, 13 );
    make_polygon( 20, 21, 14 );
    make_polygon( 22, 23, 15 );

    make_polygon(  0,  1,  2,  3,  4,  5,  6,  7 );
    make_polygon(  1,  2,  9, 13, 18, 17, 12,  8 );
    make_polygon(  3,  4, 10, 14, 20, 19, 13,  9 );
    make_polygon(  5,  6, 11, 15, 22, 21, 14, 10 );
    make_polygon(  7,  0,  8, 12, 16, 23, 15, 11 );
    make_polygon( 16, 17, 18, 19, 20, 21, 22, 23 );

    build_mesh_from_geometry();
}

#if 0 // this one is broken
truncated_cuboctahedron::truncated_cuboctahedron(double r)
{
    push_point(-r / (sq2 * sq3),  r / (sq2 * sq3),  r *  sq2 / sq3 );
    push_point( r / (sq2 * sq3),  r / (sq2 * sq3),  r *  sq2 / sq3 );
    push_point( r / (sq2 * sq3), -r / (sq2 * sq3),  r *  sq2 / sq3 );
    push_point(-r / (sq2 * sq3), -r / (sq2 * sq3),  r *  sq2 / sq3 );
    push_point(-r / (sq2 * sq3),  r *  sq2 / sq3 ,  r / (sq2 * sq3));
    push_point(-r / (sq2 * sq3),  r *  sq2 / sq3 , -r / (sq2 * sq3));
    push_point( r / (sq2 * sq3),  r *  sq2 / sq3 , -r / (sq2 * sq3));
    push_point( r / (sq2 * sq3),  r *  sq2 / sq3 ,  r / (sq2 * sq3));
    push_point( r *  sq2 / sq3 ,  r / (sq2 * sq3),  r / (sq2 * sq3));
    push_point( r *  sq2 / sq3 ,  r / (sq2 * sq3), -r / (sq2 * sq3));
    push_point( r *  sq2 / sq3 , -r / (sq2 * sq3), -r / (sq2 * sq3));
    push_point( r *  sq2 / sq3 , -r / (sq2 * sq3),  r / (sq2 * sq3));
    push_point( r / (sq2 * sq3),  r / (sq2 * sq3),  r / (sq2 * sq3));
    push_point( r / (sq2 * sq3),  r / (sq2 * sq3), -r / (sq2 * sq3));
    push_point(-r / (sq2 * sq3),  r / (sq2 * sq3), -r / (sq2 * sq3));
    push_point(-r / (sq2 * sq3),  r / (sq2 * sq3),  r / (sq2 * sq3));
    push_point(-r *  sq2 / sq3 , -r / (sq2 * sq3),  r / (sq2 * sq3));
    push_point(-r *  sq2 / sq3 , -r / (sq2 * sq3), -r / (sq2 * sq3));
    push_point(-r *  sq2 / sq3 ,  r / (sq2 * sq3), -r / (sq2 * sq3));
    push_point(-r *  sq2 / sq3 ,  r / (sq2 * sq3),  r / (sq2 * sq3));
    push_point(-r / (sq2 * sq3),  r / (sq2 * sq3), -r *  sq2 / sq3 );
    push_point( r / (sq2 * sq3),  r / (sq2 * sq3), -r *  sq2 / sq3 );
    push_point( r / (sq2 * sq3), -r / (sq2 * sq3), -r *  sq2 / sq3 );
    push_point(-r / (sq2 * sq3), -r / (sq2 * sq3), -r *  sq2 / sq3 );

    make_polygon(  0, 19,  4 );
    make_polygon(  1,  7,  8 );
    make_polygon(  2, 11, 12 );
    make_polygon(  3, 15, 16 );
    make_polygon( 20,  5, 18 );
    make_polygon( 21,  9,  6 );
    make_polygon( 22, 13, 10 );
    make_polygon( 23, 17, 14 );

    make_polygon(  0,  1,  2,  3 );
    make_polygon(  4,  5,  6,  7 );
    make_polygon(  8,  9, 10, 11 );
    make_polygon( 12, 13, 14, 15 );
    make_polygon( 16, 17, 18, 19 );
    make_polygon( 20, 21, 22, 23 );

    make_polygon(  0,  4,  7,  1 );
    make_polygon(  1,  8, 11,  2 );
    make_polygon(  2, 12, 15,  3 );
    make_polygon(  3, 16, 19,  0 );
    make_polygon( 20,  5,  6, 21 );
    make_polygon( 21,  9, 10, 22 );
    make_polygon( 22, 13, 14, 23 );
    make_polygon( 23, 17, 18, 20 );

    build_mesh_from_geometry();
}

#endif
truncated_octahedron::truncated_octahedron(double r)
{
    push_point(           0,      r / sq5,  r * 2 / sq5);
    push_point(     r / sq5,            0,  r * 2 / sq5);
    push_point(           0,     -r / sq5,  r * 2 / sq5);
    push_point(    -r / sq5,            0,  r * 2 / sq5);
    push_point(           0,  r * 2 / sq5,      r / sq5);
    push_point(    -r / sq5,  r * 2 / sq5,            0);
    push_point(           0,  r * 2 / sq5,     -r / sq5);
    push_point(     r / sq5,  r * 2 / sq5,            0);
    push_point( r * 2 / sq5,            0,      r / sq5);
    push_point( r * 2 / sq5,      r / sq5,            0);
    push_point( r * 2 / sq5,            0,     -r / sq5);
    push_point( r * 2 / sq5,     -r / sq5,            0);
    push_point(           0, -r * 2 / sq5,      r / sq5);
    push_point(     r / sq5, -r * 2 / sq5,            0);
    push_point(           0, -r * 2 / sq5,     -r / sq5);
    push_point(    -r / sq5, -r * 2 / sq5,            0);
    push_point(-r * 2 / sq5,            0,      r / sq5);
    push_point(-r * 2 / sq5,     -r / sq5,            0);
    push_point(-r * 2 / sq5,            0,     -r / sq5);
    push_point(-r * 2 / sq5,      r / sq5,            0);
    push_point(           0,      r / sq5, -r * 2 / sq5);
    push_point(     r / sq5,            0, -r * 2 / sq5);
    push_point(           0,     -r / sq5, -r * 2 / sq5);
    push_point(    -r / sq5,            0, -r * 2 / sq5);

    make_polygon(  0,  1,  2,  3 );
    make_polygon(  4,  5,  6,  7 );
    make_polygon(  8,  9, 10, 11 );
    make_polygon( 12, 13, 14, 15 );
    make_polygon( 16, 17, 18, 19 );
    make_polygon( 20, 21, 22, 23 );

    make_polygon(  0,  4,  7,  9,  8,  1 );
    make_polygon(  1,  8, 11, 13, 12,  2 );
    make_polygon(  2, 12, 15, 17, 16,  3 );
    make_polygon(  3, 16, 19,  5,  4,  0 );
    make_polygon( 20,  6,  7,  9, 10, 21 );
    make_polygon( 21, 10, 11, 13, 14, 22 );
    make_polygon( 22, 14, 15, 17, 18, 23 );
    make_polygon( 23, 18, 19,  5,  6, 20 );

    build_mesh_from_geometry();
}

truncated_icosahedron::truncated_icosahedron()
{
    push_point( 0.0,                  0.0,                 0.0 );
    push_point(-0.16245984811645317, -2.118033988749895,   1.2759762125280598 );
    push_point(-0.16245984811645317,  2.118033988749895,   1.2759762125280598);
    push_point( 0.16245984811645317, -2.118033988749895,  -1.27597621252806 );
    push_point( 0.16245984811645317,  2.118033988749895,  -1.27597621252806 );
    push_point(-0.2628655560595668,  -0.8090169943749473, -2.327438436766327 );
    push_point(-0.2628655560595668,  -2.4270509831248424, -0.42532540417601994 );
    push_point(-0.2628655560595668,   0.8090169943749475, -2.327438436766327 );
    push_point(-0.2628655560595668,   2.4270509831248424, -0.42532540417601994 );
    push_point( 0.2628655560595668,  -0.8090169943749473,  2.327438436766327 );
    push_point( 0.2628655560595668,  -2.4270509831248424,  0.42532540417601994 );
    push_point( 0.2628655560595668,   0.8090169943749475,  2.327438436766327);
    push_point( 0.2628655560595668,   2.4270509831248424,  0.42532540417601994 );
    push_point( 0.6881909602355868,  -0.5,                -2.327438436766327 );
    push_point( 0.6881909602355868,   0.5,                -2.327438436766327 );
    push_point( 1.2139220723547204,  -2.118033988749895,   0.42532540417601994 );
    push_point( 1.2139220723547204,   2.118033988749895,   0.42532540417601994 );
    push_point(-2.0645728807067605,  -0.5,                 1.2759762125280598 );
    push_point(-2.0645728807067605,   0.5,                 1.2759762125280598 );
    push_point(-1.3763819204711736,  -1,                   1.8017073246471935 );
    push_point(-1.3763819204711736,   1,                   1.8017073246471935 );
    push_point(-1.3763819204711736,  -1.6180339887498947, -1.27597621252806 );
    push_point(-1.3763819204711736,   1.618033988749895,  -1.27597621252806 );
    push_point(-0.6881909602355868,  -0.5,                 2.327438436766327 );
    push_point(-0.6881909602355868,   0.5,                 2.327438436766327 );
    push_point( 1.3763819204711736,  -1,                  -1.8017073246471933 );
    push_point( 1.3763819204711736,   1,                  -1.8017073246471933 );
    push_point( 1.3763819204711736,  -1.6180339887498947,  1.2759762125280598 );
    push_point( 1.3763819204711736,   1.618033988749895,   1.2759762125280598);
    push_point(-1.7013016167040798,   0,                  -1.8017073246471933 );
    push_point( 1.7013016167040798,   0,                   1.8017073246471935 );
    push_point(-1.2139220723547204,  -2.118033988749895,  -0.42532540417601994 );
    push_point(-1.2139220723547204,   2.118033988749895,  -0.42532540417601994 );
    push_point(-1.9641671727636467,  -0.8090169943749473, -1.27597621252806 );
    push_point(-1.9641671727636467,   0.8090169943749475, -1.27597621252806 );
    push_point( 2.0645728807067605,  -0.5,                -1.27597621252806 );
    push_point( 2.0645728807067605,   0.5,                -1.27597621252806 );
    push_point( 2.2270327288232132,  -1,                  -0.42532540417601994 );
    push_point( 2.2270327288232132,   1,                  -0.42532540417601994 );
    push_point( 2.3894925769396664,  -0.5,                 0.42532540417601994 );
    push_point( 2.3894925769396664,   0.5,                 0.42532540417601994 );
    push_point(-1.1135163644116066,  -1.8090169943749475,  1.2759762125280598 );
    push_point(-1.1135163644116066,   1.8090169943749475,  1.2759762125280598 );
    push_point( 1.1135163644116066,  -1.8090169943749475, -1.27597621252806 );
    push_point( 1.1135163644116066,   1.8090169943749475, -1.27597621252806 );
    push_point(-2.3894925769396664,  -0.5,                -0.42532540417601994 );
    push_point(-2.3894925769396664,   0.5,                -0.42532540417601994 );
    push_point(-1.6392474765307403,  -1.8090169943749475,  0.42532540417601994 );
    push_point(-1.6392474765307403,   1.8090169943749475,  0.42532540417601994 );
    push_point( 1.6392474765307403,  -1.8090169943749475, -0.42532540417601994);
    push_point( 1.6392474765307403,   1.8090169943749475, -0.42532540417601994 );
    push_point( 1.9641671727636467,  -0.8090169943749473,  1.2759762125280598);
    push_point( 1.9641671727636467,   0.8090169943749475,  1.2759762125280598);
    push_point( 0.85065080835204,     0,                   2.327438436766327 );
    push_point(-2.2270327288232132,  -1,                   0.42532540417601994 );
    push_point(-2.2270327288232132,   1,                   0.42532540417601994 );
    push_point(-0.85065080835204,     0,                  -2.327438436766327 );
    push_point(-0.5257311121191336,  -1.6180339887498947, -1.8017073246471933 );
    push_point(-0.5257311121191336,   1.618033988749895,  -1.8017073246471933);
    push_point( 0.5257311121191336,  -1.6180339887498947,  1.8017073246471935 );
    push_point( 0.5257311121191336,   1.618033988749895,   1.8017073246471935);

    make_polygon( 53, 11, 24, 23,  9 );
    make_polygon( 51, 39, 40, 52, 30 );
    make_polygon( 60, 28, 16, 12,  2 );
    make_polygon( 20, 42, 48, 55, 18 );
    make_polygon( 19, 17, 54, 47, 41 );
    make_polygon(  1, 10, 15, 27, 59 );
    make_polygon( 36, 26, 44, 50, 38 );
    make_polygon(  4, 58, 22, 32,  8 );
    make_polygon( 34, 29, 33, 45, 46 );
    make_polygon( 21, 57,  3,  6, 31 );
    make_polygon( 37, 49, 43, 25, 35 );
    make_polygon( 13,  5, 56,  7, 14 );
    make_polygon(  9, 59, 27, 51, 30, 53 );
    make_polygon( 53, 30, 52, 28, 60, 11 );
    make_polygon( 11, 60,  2, 42, 20, 24 );
    make_polygon( 24, 20, 18, 17, 19, 23 );
    make_polygon( 23, 19, 41,  1, 59,  9 );
    make_polygon( 13, 25, 43,  3, 57,  5 );
    make_polygon(  5, 57, 21, 33, 29, 56 );
    make_polygon( 56, 29, 34, 22, 58,  7 );
    make_polygon(  7, 58,  4, 44, 26, 14 );
    make_polygon( 14, 26, 36, 35, 25, 13 );
    make_polygon( 40, 38, 50, 16, 28, 52 );
    make_polygon( 16, 50, 44,  4,  8, 12 );
    make_polygon( 12,  8, 32, 48, 42,  2 );
    make_polygon( 48, 32, 22, 34, 46, 55 );
    make_polygon( 55, 46, 45, 54, 17, 18 );
    make_polygon( 54, 45, 33, 21, 31, 47 );
    make_polygon( 47, 31,  6, 10,  1, 41 );
    make_polygon( 10,  6,  3, 43, 49, 15 );
    make_polygon( 15, 49, 37, 39, 51, 27 );
    make_polygon( 39, 37, 35, 36, 38, 40 );

    build_mesh_from_geometry();
}

great_rhombicosidodecahedron::great_rhombicosidodecahedron()
{
    push_point(0.0, 0.0, 0.0 );
    push_point(-1, -1.3090169943749475, -3.4270509831248424 );
    push_point(-1, -1.3090169943749475, 3.4270509831248424 );
    push_point(-1, 1.3090169943749475, -3.4270509831248424 );
    push_point(-1, 1.3090169943749475, 3.4270509831248424 );
    push_point(-0.5, -0.5, -3.73606797749979 );
    push_point(-0.5, -0.5, 3.73606797749979 );
    push_point(-0.5, 0.5, -3.73606797749979 );
    push_point(-0.5, 0.5, 3.73606797749979 );
    push_point(-0.5, -3.73606797749979, -0.5 );
    push_point(-0.5, -3.73606797749979,  0.5 );
    push_point(-0.5, -2.118033988749895, -3.118033988749895 );
    push_point(-0.5, -2.118033988749895, 3.118033988749895 );
    push_point(-0.5, 3.73606797749979, -0.5 );
    push_point(-0.5, 3.73606797749979, 0.5 );
    push_point(-0.5, 2.118033988749895, -3.118033988749895 );
    push_point(-0.5, 2.118033988749895, 3.118033988749895 );
    push_point(0.5, -0.5, -3.73606797749979 );
    push_point(0.5, -0.5, 3.73606797749979 );
    push_point(0.5, 0.5, -3.73606797749979 );
    push_point(0.5, 0.5, 3.73606797749979 );
    push_point(0.5, -3.73606797749979, -0.5 );
    push_point(0.5, -3.73606797749979, 0.5 );
    push_point(0.5, -2.118033988749895, -3.118033988749895 );
    push_point(0.5, -2.118033988749895, 3.118033988749895 );
    push_point(0.5, 3.73606797749979, -0.5 );
    push_point(0.5, 3.73606797749979, 0.5 );
    push_point(0.5, 2.118033988749895, -3.118033988749895 );
    push_point(0.5, 2.118033988749895, 3.118033988749895 );
    push_point(1, -1.3090169943749475, -3.4270509831248424 );
    push_point(1, -1.3090169943749475, 3.4270509831248424 );
    push_point(1, 1.3090169943749475, -3.4270509831248424 );
    push_point(1, 1.3090169943749475, 3.4270509831248424 );
    push_point(-3.4270509831248424, -1, -1.3090169943749475 );
    push_point(-3.4270509831248424, -1, 1.3090169943749475 );
    push_point(-3.4270509831248424, 1, -1.3090169943749475 );
    push_point(-3.4270509831248424, 1, 1.3090169943749475 );
    push_point(-2.9270509831248424, -1.8090169943749475, -1.618033988749895 );
    push_point(-2.9270509831248424, -1.8090169943749475, 1.618033988749895 );
    push_point(-2.9270509831248424, 1.8090169943749475, -1.618033988749895 );
    push_point(-2.9270509831248424, 1.8090169943749475, 1.618033988749895 );
    push_point(-1.8090169943749475, -1.618033988749895, -2.9270509831248424 );
    push_point(-1.8090169943749475, -1.618033988749895, 2.9270509831248424 );
    push_point(-1.8090169943749475, 1.618033988749895, -2.9270509831248424 );
    push_point(-1.8090169943749475, 1.618033988749895, 2.9270509831248424 );
    push_point(-1.3090169943749475, -3.4270509831248424, -1 );
    push_point(-1.3090169943749475, -3.4270509831248424, 1 );
    push_point(-1.3090169943749475, -2.4270509831248424, -2.618033988749895 );
    push_point(-1.3090169943749475, -2.4270509831248424, 2.618033988749895 );
    push_point(-1.3090169943749475, 2.4270509831248424, -2.618033988749895 );
    push_point(-1.3090169943749475, 2.4270509831248424, 2.618033988749895 );
    push_point(-1.3090169943749475, 3.4270509831248424, -1 );
    push_point(-1.3090169943749475, 3.4270509831248424, 1 );
    push_point(-2.618033988749895, -1.3090169943749475, -2.4270509831248424 );
    push_point(-2.618033988749895, -1.3090169943749475, 2.4270509831248424 );
    push_point(-2.618033988749895, 1.3090169943749475, -2.4270509831248424 );
    push_point(-2.618033988749895, 1.3090169943749475, 2.4270509831248424 );
    push_point(-3.73606797749979, -0.5, -0.5 );
    push_point(-3.73606797749979, -0.5, 0.5 );
    push_point(-3.73606797749979, 0.5, -0.5 );
    push_point(-3.73606797749979, 0.5, 0.5 );
    push_point(-1.618033988749895, -2.9270509831248424, -1.8090169943749475 );
    push_point(-1.618033988749895, -2.9270509831248424, 1.8090169943749475 );
    push_point(-1.618033988749895, 2.9270509831248424, -1.8090169943749475 );
    push_point(-1.618033988749895, 2.9270509831248424, 1.8090169943749475 );
    push_point(-3.118033988749895, -0.5, -2.118033988749895 );
    push_point(-3.118033988749895, -0.5, 2.118033988749895 );
    push_point(-3.118033988749895, 0.5, -2.118033988749895 );
    push_point(-3.118033988749895, 0.5, 2.118033988749895 );
    push_point(-2.118033988749895, -3.118033988749895, -0.5 );
    push_point(-2.118033988749895, -3.118033988749895, 0.5 );
    push_point(-2.118033988749895, 3.118033988749895, -0.5 );
    push_point(-2.118033988749895, 3.118033988749895, 0.5 );
    push_point(-2.4270509831248424, -2.618033988749895, -1.3090169943749475 );
    push_point(-2.4270509831248424, -2.618033988749895, 1.3090169943749475 );
    push_point(-2.4270509831248424, 2.618033988749895, -1.3090169943749475 );
    push_point(-2.4270509831248424, 2.618033988749895, 1.3090169943749475 );
    push_point( 1.618033988749895, -2.9270509831248424, -1.8090169943749475);
    push_point( 1.618033988749895, -2.9270509831248424, 1.8090169943749475);
    push_point( 1.618033988749895, 2.9270509831248424, -1.8090169943749475);
    push_point( 1.618033988749895, 2.9270509831248424, 1.8090169943749475 );
    push_point( 2.4270509831248424, -2.618033988749895, -1.3090169943749475 );
    push_point( 2.4270509831248424, -2.618033988749895, 1.3090169943749475 );
    push_point( 2.4270509831248424, 2.618033988749895, -1.3090169943749475 );
    push_point( 2.4270509831248424, 2.618033988749895, 1.3090169943749475 );
    push_point( 3.73606797749979, -0.5, -0.5 );
    push_point( 3.73606797749979, -0.5, 0.5 );
    push_point( 3.73606797749979, 0.5, -0.5 );
    push_point( 3.73606797749979, 0.5, 0.5 );
    push_point( 2.118033988749895, -3.118033988749895, -0.5 );
    push_point( 2.118033988749895, -3.118033988749895, 0.5 );
    push_point( 2.118033988749895, 3.118033988749895, -0.5 );
    push_point( 2.118033988749895, 3.118033988749895, 0.5 );
    push_point( 1.3090169943749475, -3.4270509831248424, -1 );
    push_point( 1.3090169943749475, -3.4270509831248424, 1 );
    push_point( 1.3090169943749475, -2.4270509831248424, -2.618033988749895 );
    push_point( 1.3090169943749475, -2.4270509831248424, 2.618033988749895 );
    push_point( 1.3090169943749475, 2.4270509831248424, -2.618033988749895 );
    push_point( 1.3090169943749475, 2.4270509831248424, 2.618033988749895 );
    push_point( 1.3090169943749475, 3.4270509831248424, -1 );
    push_point( 1.3090169943749475, 3.4270509831248424, 1 );
    push_point( 2.618033988749895, -1.3090169943749475, -2.4270509831248424);
    push_point( 2.618033988749895, -1.3090169943749475, 2.4270509831248424 );
    push_point( 2.618033988749895, 1.3090169943749475, -2.4270509831248424);
    push_point( 2.618033988749895, 1.3090169943749475, 2.4270509831248424 );
    push_point( 3.118033988749895, -0.5, -2.118033988749895 );
    push_point( 3.118033988749895, -0.5, 2.118033988749895 );
    push_point( 3.118033988749895, 0.5, -2.118033988749895 );
    push_point( 3.118033988749895, 0.5,  2.118033988749895 );
    push_point( 1.8090169943749475, -1.618033988749895, -2.9270509831248424 );
    push_point( 1.8090169943749475, -1.618033988749895, 2.9270509831248424 );
    push_point( 1.8090169943749475, 1.618033988749895, -2.9270509831248424 );
    push_point( 1.8090169943749475, 1.618033988749895, 2.9270509831248424 );
    push_point( 2.9270509831248424, -1.8090169943749475, -1.618033988749895 );
    push_point( 2.9270509831248424, -1.8090169943749475, 1.618033988749895 );
    push_point( 2.9270509831248424, 1.8090169943749475, -1.618033988749895 );
    push_point( 2.9270509831248424, 1.8090169943749475, 1.618033988749895 );
    push_point( 3.4270509831248424, -1, -1.3090169943749475 );
    push_point( 3.4270509831248424, -1, 1.3090169943749475 );
    push_point( 3.4270509831248424, 1, -1.3090169943749475 );
    push_point( 3.4270509831248424, 1, 1.3090169943749475);

    make_polygon(   2,   6,   8,   4,  44,  56,  68,  66,  54,  42 );
    make_polygon( 109,  29,  17,  19,  31, 111, 103, 107, 105, 101 );
    make_polygon(  58,  57,  33,  37,  73,  69,  70,  74,  38,  34 );
    make_polygon(  84, 116, 120,  88,  87, 119, 115,  83,  91,  92 );
    make_polygon(  90,  89,  81, 113, 117,  85,  86, 118, 114,  82 );
    make_polygon(  36,  40,  76,  72,  71,  75,  39,  35,  59,  60 );
    make_polygon(  67,  55,  43,   3,   7,   5,   1,  41,  53,  65 );
    make_polygon(  18,  30, 110, 102, 106, 108, 104, 112,  32,  20 );
    make_polygon(  61,  47,  11,  23,  95,  77,  93,  21,   9,  45 );
    make_polygon(  50,  16,  28,  98,  80, 100,  26,  14,  52,  64 );
    make_polygon(  63,  51,  13,  25,  99,  79,  97,  27,  15,  49 );
    make_polygon(  46,  10,  22,  94,  78,  96,  24,  12,  48,  62 );
    make_polygon(  24,  30,  18,   6,   2,  12 );
    make_polygon(   7,   3,  15,  27,  31,  19 );
    make_polygon(   5,  17,  29,  23,  11,   1 );
    make_polygon(   4,   8,  20,  32,  28,  16 );
    make_polygon(  79,  83, 115, 103, 111,  97 );
    make_polygon(  38,  74,  62,  48,  42,  54 );
    make_polygon(  53,  41,  47,  61,  73,  37 );
    make_polygon(  98, 112, 104, 116,  84,  80 );
    make_polygon(  69,  45,   9,  10,  46,  70 );
    make_polygon(  26, 100,  92,  91,  99,  25 );
    make_polygon(  82, 114, 102, 110,  96,  78 );
    make_polygon(  55,  39,  75,  63,  49,  43 );
    make_polygon(  44,  50,  64,  76,  40,  56 );
    make_polygon(  77,  95, 109, 101, 113,  81 );
    make_polygon(  52,  14,  13,  51,  71,  72 );
    make_polygon(  22,  21,  93,  89,  90,  94 );
    make_polygon(  59,  35,  67,  65,  33,  57 );
    make_polygon( 106, 118,  86,  88, 120, 108 );
    make_polygon(  34,  66,  68,  36,  60,  58 );
    make_polygon( 105, 107, 119,  87,  85, 117 );
    make_polygon(   4,  16,  50,  44 );
    make_polygon(  23,  29, 109,  95 );
    make_polygon(  96, 110,  30,  24 );
    make_polygon(  43,  49,  15,   3 );
    make_polygon(   1,  11,  47,  41 );
    make_polygon(  28,  32, 112,  98 );
    make_polygon(  97, 111,  31,  27 );
    make_polygon(  42,  48,  12,   2 );
    make_polygon( 115, 119, 107, 103 );
    make_polygon(  34,  38,  54,  66 );
    make_polygon(  71,  51,  63,  75 );
    make_polygon(  94,  90,  82,  78 );
    make_polygon( 114, 118, 106, 102 );
    make_polygon(  35,  39,  55,  67 );
    make_polygon(  70,  46,  62,  74 );
    make_polygon(  99,  91,  83,  79 );
    make_polygon(  65,  53,  37,  33 );
    make_polygon( 104, 108, 120, 116 );
    make_polygon(  77,  81,  89,  93 );
    make_polygon(  76,  64,  52,  72 );
    make_polygon(  68,  56,  40,  36 );
    make_polygon( 101, 105, 117, 113 );
    make_polygon(  80,  84,  92, 100 );
    make_polygon(  73,  61,  45,  69 );
    make_polygon(   7,  19,  17,   5 );
    make_polygon(   6,  18,  20,   8 );
    make_polygon(  14,  26,  25,  13 );
    make_polygon(   9,  21,  22,  10 );
    make_polygon(  58,  60,  59,  57 );
    make_polygon(  85,  87,  88,  86 );

    build_mesh_from_geometry();
}

truncated_dodecahedron::truncated_dodecahedron()
{
    push_point(0.0, 0.0, 0.0 );
    push_point(0, -1.618033988749895, 2.48989828488278);
    push_point(0, -1.618033988749895, -2.48989828488278);
    push_point(0, 1.618033988749895, 2.48989828488278);
    push_point(0, 1.618033988749895, -2.48989828488278);
    push_point(0.42532540417601994, -2.9270509831248424, 0.2628655560595668);
    push_point(0.42532540417601994, 2.9270509831248424, 0.2628655560595668);
    push_point(0.6881909602355868, -2.118033988749895, 1.9641671727636467);
    push_point(0.6881909602355868, 2.118033988749895, 1.9641671727636467);
    push_point(-2.752763840942347, 0, -1.1135163644116068);
    push_point(-2.0645728807067605, -2.118033988749895, 0.2628655560595668);
    push_point(-2.0645728807067605, 2.118033988749895, 0.2628655560595668);
    push_point(-1.3763819204711736, -2.618033988749895, -0.2628655560595668);
    push_point(-1.3763819204711736, 2.618033988749895, -0.2628655560595668);
    push_point(-0.6881909602355868, -2.118033988749895, -1.9641671727636467);
    push_point(-0.6881909602355868, 2.118033988749895, -1.9641671727636467);
    push_point(1.3763819204711736, -2.618033988749895, 0.2628655560595668);
    push_point(1.3763819204711736, 2.618033988749895, 0.2628655560595668);
    push_point(2.752763840942347, 0, 1.1135163644116066);
    push_point(1.8017073246471935, -1.3090169943749475, -1.9641671727636467);
    push_point(1.8017073246471935, 1.3090169943749475, -1.9641671727636467);
    push_point(2.0645728807067605, -2.118033988749895, -0.2628655560595668);
    push_point(2.0645728807067605, 2.118033988749895, -0.2628655560595668);
    push_point(2.2270327288232132, 0, 1.9641671727636467);
    push_point(2.2270327288232132, -1.618033988749895, -1.1135163644116068);
    push_point(2.2270327288232132, 1.618033988749895, -1.1135163644116068);
    push_point(-2.6523581329992334, -1.3090169943749475, 0.2628655560595668);
    push_point(-2.6523581329992334, 1.3090169943749475, 0.2628655560595668);
    push_point(2.6523581329992334, -1.3090169943749475, -0.2628655560595668);
    push_point(2.6523581329992334, 1.3090169943749475, -0.2628655560595668);
    push_point(2.9152236890588, -0.5, 0.2628655560595668);
    push_point(2.9152236890588, 0.5, 0.2628655560595668);
    push_point(-2.9152236890588, -0.5, -0.2628655560595668);
    push_point(-2.9152236890588, 0.5, -0.2628655560595668);
    push_point(0.9510565162951535, -1.3090169943749475, 2.48989828488278);
    push_point(0.9510565162951535, -1.3090169943749475, -2.48989828488278);
    push_point(0.9510565162951535, 1.3090169943749475, 2.48989828488278);
    push_point(0.9510565162951535, 1.3090169943749475, -2.48989828488278);
    push_point(0.85065080835204, -2.618033988749895, 1.1135163644116066);
    push_point(0.85065080835204, 2.618033988749895, 1.1135163644116066);
    push_point(-0.9510565162951535, -1.3090169943749475, 2.48989828488278);
    push_point(-0.9510565162951535, -1.3090169943749475, -2.48989828488278);
    push_point(-0.9510565162951535, 1.3090169943749475, 2.48989828488278);
    push_point(-0.9510565162951535, 1.3090169943749475, -2.48989828488278);
    push_point(-1.5388417685876268, -0.5, 2.48989828488278);
    push_point(-1.5388417685876268, -0.5, -2.48989828488278);
    push_point(-1.5388417685876268, 0.5, 2.48989828488278);
    push_point(-1.5388417685876268, 0.5, -2.48989828488278);
    push_point(1.5388417685876268, -0.5, 2.48989828488278);
    push_point(1.5388417685876268, -0.5, -2.48989828488278);
    push_point(1.5388417685876268, 0.5, 2.48989828488278);
    push_point(1.5388417685876268, 0.5, -2.48989828488278);
    push_point(-2.2270327288232132, 0, -1.9641671727636467);
    push_point(-2.2270327288232132, -1.618033988749895, 1.1135163644116066);
    push_point(-2.2270327288232132, 1.618033988749895, 1.1135163644116066);
    push_point(-0.85065080835204, -2.618033988749895, -1.1135163644116068);
    push_point(-0.85065080835204, 2.618033988749895, -1.1135163644116068);
    push_point(-1.8017073246471933, -1.3090169943749475, 1.9641671727636467);
    push_point(-1.8017073246471933, 1.3090169943749475, 1.9641671727636467);
    push_point(-0.42532540417601994, -2.9270509831248424, -0.2628655560595668);
    push_point(-0.42532540417601994, 2.9270509831248424, -0.2628655560595668);

    make_polygon(  3, 42, 46, 44, 40,  1, 34, 48, 50, 36);
    make_polygon( 47, 43,  4, 37, 51, 49, 35,  2, 41, 45);
    make_polygon(  2, 35, 19, 24, 21, 16,  5, 59, 55, 14);
    make_polygon( 49, 51, 20, 25, 29, 31, 30, 28, 24, 19);
    make_polygon( 37,  4, 15, 56, 60,  6, 17, 22, 25, 20);
    make_polygon( 43, 47, 52,  9, 33, 27, 11, 13, 56, 15);
    make_polygon( 45, 41, 14, 55, 12, 10, 26, 32,  9, 52);
    make_polygon(  6, 60, 13, 11, 54, 58, 42,  3,  8, 39);
    make_polygon( 27, 33, 32, 26, 53, 57, 44, 46, 58, 54);
    make_polygon( 10, 12, 59,  5, 38,  7,  1, 40, 57, 53);
    make_polygon( 16, 21, 28, 30, 18, 23, 48, 34,  7, 38);
    make_polygon( 31, 29, 22, 17, 39,  8, 36, 50, 23, 18);
    make_polygon(  9, 32, 33);
    make_polygon( 18, 30, 31);
    make_polygon( 47, 45, 52);
    make_polygon( 50, 48, 23);
    make_polygon( 10, 53, 26);
    make_polygon( 27, 54, 11);
    make_polygon( 21, 24, 28);
    make_polygon( 29, 25, 22);
    make_polygon( 40, 44, 57);
    make_polygon( 58, 46, 42);
    make_polygon( 35, 49, 19);
    make_polygon( 20, 51, 37);
    make_polygon( 12, 55, 59);
    make_polygon( 60, 56, 13);
    make_polygon( 41,  2, 14);
    make_polygon( 15,  4, 43);
    make_polygon( 34,  1,  7);
    make_polygon(  8,  3, 36);
    make_polygon( 38,  5, 16);
    make_polygon( 17,  6, 39);

    build_mesh_from_geometry();
}

johnson_solid::johnson_solid(int number)
{
    if(number != 83)
    {
        throw false;
    }
    push_point(0.622866913219, 0.618689929055, 0.268875295373);
    push_point(0.632830203313, 0.667979230789, -0.15223981211);
    push_point(0.260097696343, 0.86976646536, -0.137440272303);
    push_point(0.25013440625, 0.820477163625, 0.283674835181);
    push_point(-0.108878198249, 0.894110390313, 0.0702392854136);
    push_point(0.051935606844, 0.787120294271, -0.497585786041);
    push_point(-0.317040287749, 0.811464219225, -0.289906228324);
    push_point(0.655029471832, 0.46062169024, -0.521531944467);
    push_point(0.296016867333, 0.534254916928, -0.734967494234);
    push_point(-0.87205832873, 0.228232662749, -0.239314442373);
    push_point(-0.669974565739, 0.597988139875, -0.191255353363);
    push_point(0.32197274823, 0.149454066762, -0.911379608681);
    push_point(0.119888985239, -0.220301410364, -0.959438697691);
    push_point(-0.233045292752, -0.433777489714, -0.86078782273);
    push_point(-0.602021187345, -0.409433564761, -0.653108265014);
    push_point(-0.846102447834, -0.156568187418, -0.415726556821);
    push_point(-0.33316122976, 0.731712453736, 0.39147232876);
    push_point(0.0258513747388, 0.658079227048, 0.604907878527);
    push_point(-0.327082903252, 0.444603147699, 0.703558753488);
    push_point(-0.679937855833, 0.54869883814, 0.22985975412);
    push_point(-0.673859529325, 0.261589532103, 0.541946178848);
    push_point(-0.882021618824, 0.178943361014, 0.18180066511);
    push_point(-0.862223389845, -0.236319952906, 0.265652000264);
    push_point(-0.654061300346, -0.153673781818, 0.625797514001);
    push_point(-0.840024121326, -0.443677493455, -0.103640132093);
    push_point(-0.595942860836, -0.696542870798, -0.341021840286);
    push_point(-0.092964932856, 0.142448468621, 0.887292152778);
    push_point(0.259969345135, 0.35592454797, 0.788641277817);
    push_point(0.279767574113, -0.0593387659499, 0.872492612971);
    push_point(-0.295048695847, -0.227307008505, 0.839233063768);
    push_point(0.0776838111221, -0.429094243076, 0.824433523961);
    push_point(0.343964340131, -0.889317160968, 0.217759683411);
    push_point(0.321765071612, -0.681959620419, 0.587051815768);
    push_point(-0.223210353867, -0.898330105369, -0.355821380093);
    push_point(0.135802250632, -0.971963332057, -0.142385830326);
    push_point(0.648743468706, -0.0836826909031, 0.664813055254);
    push_point(0.628945239727, 0.331580623017, 0.580961720101);
    push_point(0.674699349602, -0.46848354107, 0.488400940807);
    push_point(0.696898618122, -0.675841081619, 0.119108808451);
    push_point(0.706861908215, -0.626551779884, -0.302006299033);
    push_point(0.700783581707, -0.339442473847, -0.614092723761);
    push_point(0.680985352729, 0.0758208400738, -0.697944058914);
    push_point(0.360085282143, -0.80956539548, -0.463618873673);
    push_point(0.00107267764377, -0.735932168792, -0.67705442344);
    push_point(0.354006955634, -0.522456089442, -0.775705298401);

    make_polygon(  9, 10,  6,  5,  8, 11, 12, 13, 14, 15);
    make_polygon( 31, 32, 30, 29, 23, 22, 24, 25, 33, 34);
    make_polygon( 36, 35, 37, 38, 39, 40, 41,  7,  1,  0);
    make_polygon(  1,  7,  8,  5,  2);
    make_polygon(  4,  6, 10, 19, 16);
    make_polygon(  9, 15, 24, 22, 21);
    make_polygon( 18, 20, 23, 29, 26);
    make_polygon( 28, 30, 32, 37, 35);
    make_polygon( 31, 34, 42, 39, 38);
    make_polygon( 40, 44, 12, 11, 41);
    make_polygon(  0,  3, 17, 27, 36);
    make_polygon( 43, 33, 25, 14, 13);
    make_polygon(  0,  1,  2,  3);
    make_polygon(  2,  5,  6,  4);
    make_polygon(  3,  4, 16, 17);
    make_polygon( 16, 19, 20, 18);
    make_polygon( 20, 21, 22, 23);
    make_polygon( 10,  9, 21, 19);
    make_polygon( 15, 14, 25, 24);
    make_polygon( 17, 18, 26, 27);
    make_polygon( 26, 29, 30, 28);
    make_polygon( 27, 28, 35, 36);
    make_polygon( 32, 31, 38, 37);
    make_polygon( 34, 33, 43, 42);
    make_polygon(  7, 41, 11,  8);
    make_polygon( 39, 42, 44, 40);
    make_polygon( 44, 43, 13, 12);
    make_polygon(  3,  2,  4);
    make_polygon( 17, 16, 18);
    make_polygon( 19, 21, 20);
    make_polygon( 27, 26, 28);
    make_polygon( 42, 43, 44);

    build_mesh_from_geometry();
}

grid::grid(float cell_width, int positive_cell_count)
{
    /*    2   9  11  13   3    0.. 3  corners              */ 
    /*                         2.. 7  min_x...max_x lines  */ 
    /*    6   .   .   .   7    8..13  min_z..,max_z lines  */ 
    /*                                                     */ 
    /*    4   .   x   .   5    positive_cell_count = 2     */ 
    /*                                                     */ 
    /*    2   .   .   .   3                                */ 
    /*                                                     */ 
    /*    0   8  10  12   1                                */ 

    float extreme = (float)(positive_cell_count) * cell_width;
    int index = 0;

    /*  Corner vertices  */ 
    {
        push_point(-extreme, -extreme, 0.0f); index++;
        push_point( extreme, -extreme, 0.0f); index++;
        push_point(-extreme,  extreme, 0.0f); index++;
        push_point( extreme,  extreme, 0.0f); index++;
    }

    /*  min x...max x vertices  */ 
    {
        /*  min z :  min_x...max_x  */ 
        {
            make_polygon(0, 1);
        }
        {
            int z;
            int range = (positive_cell_count - 1);

            for(z = -range; z <= range; ++z)
            {
                float   z_position = (float)(z) * cell_width;
                int     v0 = index++;
                int     v1 = index++;
                push_point(-extreme, z_position, 0.0f);
                push_point( extreme, z_position, 0.0f);
                make_polygon(v0, v1);
            }
        }

        /*  max z :  min_x...max_x  */ 
        {
            make_polygon(2, 3);
        }
    }

    /*  min z...max z vertices  */ 
    {
        /*  min x :  min_z...max_z  */ 
        {
            make_polygon(0, 2);
        }

        {
            int x;
            int range = (positive_cell_count - 1);

            for(x = -range; x <= range; ++x)
            {
                float   x_position = (float)(x) * cell_width;
                int     v0 = index++;
                int     v1 = index++;
                push_point(x_position, -extreme, 0.0f);
                push_point(x_position,  extreme, 0.0f);
                make_polygon(v0, v1);
            }
        }

        /*  max x :  min_z...max_z  */ 
        {
            make_polygon(1, 3);
        }
    }

    /*  Done  */ 
    build_mesh_from_geometry();
}

}


}