vcglib refine example

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <sstream>

#include "GL/glew.h"
#include "GL/glfw.h"
#include <GL/gl.h>

#include <vcg/space/point3.h>
#include <vcg/space/box3.h>

#include <vcg/math/perlin_noise.h>

#include <vcg/simplex/vertex/base.h>
#include <vcg/simplex/face/base.h>
#include <vcg/simplex/vertex/component_ocf.h>
#include <vcg/simplex/face/component_ocf.h>

#include <vcg/complex/complex.h>
#include <vcg/complex/allocate.h>

#include <vcg/complex/algorithms/smooth.h>

#include <vcg/complex/algorithms/create/marching_cubes.h>
#include <vcg/complex/algorithms/create/extended_marching_cubes.h>
#include <vcg/complex/algorithms/create/mc_trivial_walker.h>
#include <vcg/complex/algorithms/create/platonic.h>

#include <vcg/complex/algorithms/update/bounding.h>
#include <vcg/complex/algorithms/update/normal.h>
#include <vcg/complex/algorithms/update/topology.h>
#include <vcg/complex/algorithms/update/flag.h>

#include <vcg/complex/algorithms/refine.h>

// for opengl
#include <wrap/gl/trimesh.h>

using namespace std;
using namespace vcg;

typedef float ScalarType;

class MyFace;
class MyVertex;

struct MyUsedTypes : public UsedTypes<
Use<MyVertex>   ::AsVertexType,
Use<MyFace>     ::AsFaceType>{};

class MyVertex: public Vertex< MyUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags, vertex::VFAdj, vertex::InfoOcf, vertex::Mark>{};
class MyFace: public Face< MyUsedTypes, face::FFAdj, face::Mark, face::VertexRef, face::Normal3f, face::BitFlags, face::InfoOcf> {};
class MyMesh: public vcg::tri::TriMesh< std::vector< MyVertex>, std::vector< MyFace > > {};

int main(int argc, char *argv[])
{
    int running = GL_TRUE;
    int width = 800;
    int height = 800;

    if (!glfwInit()){
        exit(EXIT_FAILURE);
    }

    if (!glfwOpenWindow(width,height, 0,0,0,0,8,0, GLFW_WINDOW)){
        glfwTerminate();
        exit(EXIT_FAILURE);
    }

    GLenum err = glewInit();
    if (GLEW_OK != err){
        glfwTerminate();
        exit(EXIT_FAILURE);
    }

    MyMesh mc_mesh;
    vcg::tri::Icosahedron<MyMesh>(mc_mesh);

    // update infos
    vcg::tri::UpdateBounding<MyMesh>::Box(mc_mesh);
    vcg::tri::UpdateNormals<MyMesh>::PerVertexNormalizedPerFace(mc_mesh);
    vcg::tri::UpdateNormals<MyMesh>::PerFaceNormalized(mc_mesh);
    vcg::tri::UpdateTopology<MyMesh>::FaceFace(mc_mesh);
    vcg::tri::UpdateTopology<MyMesh>::VertexFace(mc_mesh);

    Refine(mc_mesh,MidPointButterfly<MyMesh>());
    Refine(mc_mesh,MidPointButterfly<MyMesh>());
    Refine(mc_mesh,MidPointButterfly<MyMesh>());

    vcg::tri::UpdateNormals<MyMesh>::PerVertexNormalizedPerFace(mc_mesh);
    vcg::tri::UpdateNormals<MyMesh>::PerFaceNormalized(mc_mesh);

    GlTrimesh<MyMesh> tm;
    tm.m = &mc_mesh;
    tm.Update();

    glClearColor(0, 0, 0, 0);

    glEnable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_NORMALIZE);
    glLineWidth(2.0);

    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    GLfloat amb[] = {0,0,0,1};
    GLfloat diff[] = {1,1,1,1};
    glLightfv(GL_LIGHT0,GL_AMBIENT,amb);
    glLightfv(GL_LIGHT0,GL_DIFFUSE,diff);

    GLfloat global_ambient[] = { 0.1f, 0.1f, 0.1f, 1.0f };
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient);

    glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50);

    GLfloat col[] = {1.f,0.f,1.f,0.f};
    glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,col);
    GLfloat white[] = {1.f,1.f,1.f,0.f};
    glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,white);

    float rotate = 0;
    vcg::Point3<float> c = mc_mesh.bbox.Center();
    float meshSize = mc_mesh.bbox.DimY();

    std::cout << "meshSize: " << meshSize << "\n";

    while(running){
        double time = glfwGetTime();

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(40, 1.0*width/height, 0.1, 100);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(.7,.7,1.7,   0,0,0,   0,1,0);

        glColor3f(1,1,1);

        GLfloat lp[] = {0,1,1,0};
        glLightfv(GL_LIGHT0,GL_POSITION,lp);

        glRotatef(10*time,0,1,0);
        // glScalef(.15,.15,.15);
        glScalef(1/meshSize,1/meshSize,1/meshSize);

        glTranslatef(-c.X(),-c.Y(),-c.Z());

        tm.Draw<vcg::GLW::DMSmooth, vcg::GLW::CMNone, vcg::GLW::TMNone> ();

        glfwSwapBuffers();

        running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
    }

    glfwTerminate();
    exit(EXIT_SUCCESS);
};