libigl_Martin/examples/shadow-mapping/example.cpp

// Small GLUT application to test shadow mapping for closed shapes
//

#include <igl/readOBJ.h>
#include <igl/writeOBJ.h>
#include <igl/writeOFF.h>
#include <igl/readWRL.h>
#include <igl/report_gl_error.h>
#include <igl/polygon_mesh_to_triangle_mesh.h>
#include <igl/readOFF.h>
#include <igl/readMESH.h>
#include <igl/draw_mesh.h>
#include <igl/draw_floor.h>
#include <igl/pathinfo.h>
#include <igl/list_to_matrix.h>
#include <igl/quat_to_mat.h>
#include <igl/per_face_normals.h>
#include <igl/material_colors.h>
#include <igl/trackball.h>
#include <igl/snap_to_canonical_view_quat.h>
#include <igl/REDRUM.h>
#include <igl/ReAntTweakBar.h>
#include <igl/get_seconds.h>
#include <igl/jet.h>
#include <igl/randperm.h>
#include <igl/normalize_row_lengths.h>
#include <igl/boost/components.h>
#include <igl/boost/bfs_orient.h>
#include <igl/orient_outward.h>
//#include <igl/embree/orient_outward_ao.h>
#include <igl/unique_simplices.h>
#include <igl/C_STR.h>
#include <igl/write_triangle_mesh.h>

#include <Eigen/Core>
#include <Eigen/Geometry>

#if defined(__APPLE__)
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#ifndef GLUT_WHEEL_UP
#define GLUT_WHEEL_UP    3
#define GLUT_WHEEL_DOWN  4
#define GLUT_WHEEL_RIGHT 5
#define GLUT_WHEEL_LEFT  6
#define GLUT_ACTIVE_COMMAND 1
#endif

#include <ctime>
#include <string>
#include <vector>
#include <stack>
#include <iostream>


struct Camera
{
  Eigen::Vector3d pan;
  Eigen::Quaterniond rotation;
  double zoom;
  double angle;
  Camera():pan(0,0,0),rotation(1,0,0,0),zoom(1),angle(25){}
};

// Initialize shadow textures. Should be called on reshape()
//
// Inputs:
//   windowWidth  width of viewport
//   windowHeight  width of viewport
//   factor  up-/down-sampling factor {1}
// Outputs:
//   shadowMapTexture  texture id of shadow map
//   fbo  buffer id of depth frame buffer
//   cfbo  buffer id of color frame buffer
bool initialize_shadows(
  const double windowWidth,
  const double windowHeight,
  const double factor,
  GLuint & shadowMapTexture,
  GLuint & fbo,
  GLuint & cfbo);
// Implementation
bool initialize_shadows(
  const double windowWidth,
  const double windowHeight,
  const double factor,
  GLuint & shadowMapTexture,
  GLuint & fbo,
  GLuint & cfbo)
{
  //Create the shadow map texture
  glDeleteTextures(1,&shadowMapTexture);
  glGenTextures(1, &shadowMapTexture);
  glBindTexture(GL_TEXTURE_2D, shadowMapTexture);
  glTexImage2D(
    GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
    factor*windowWidth,
    factor*windowHeight,
    0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  glBindTexture(GL_TEXTURE_2D, 0);

  // Frame buffer
  glGenFramebuffersEXT(1, &fbo);
  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
  glFramebufferTexture2DEXT(
    GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D,
    shadowMapTexture,0);
  // Attach color render buffer
  glGenRenderbuffersEXT(1,&cfbo);
  glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,cfbo);
  glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8,
    factor*windowWidth, factor*windowHeight);
  //-------------------------
  //Attach color buffer to FBO
  glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
    GL_RENDERBUFFER_EXT, cfbo);
  //-------------------------
  //Does the GPU support current FBO configuration?
  GLenum status;
  status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
  switch(status)
  {
    case GL_FRAMEBUFFER_COMPLETE_EXT:
      break;
    default:
      assert(false);
      return false;
  }
  glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  return true;
}

GLuint shadowMapTexture=0,fbo=0,cfbo=0;

#define MAX_SPEED 0.01
struct Mesh
{
  Eigen::MatrixXd V,N;
  Eigen::MatrixXi F;
  Eigen::Affine3d a,da;
  Mesh():V(),N(),F(),a(Eigen::Affine3d::Identity()),da(Eigen::Affine3d::Identity())
  {
    using namespace Eigen;
    Quaterniond r(Eigen::Vector4d::Random());
    Quaterniond i(1,0,0,0);
    const double speed = 0.001;
    Quaterniond q = Quaterniond((   speed)*r.coeffs() + (1.-speed)*i.coeffs()).normalized();
    da.rotate(q);
    da.translate(Eigen::Vector3d::Random().normalized()*MAX_SPEED);
  }
};
std::vector<Mesh> meshes;

struct State
{
  ::Camera camera;
  State():
    camera()
  {
    camera.pan[1] = 1;
  }
} s;

// See README for descriptions
enum RotationType
{
  ROTATION_TYPE_IGL_TRACKBALL = 0,
  ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP = 1,
  NUM_ROTATION_TYPES = 2,
} rotation_type;

std::stack<State> undo_stack;
std::stack<State> redo_stack;

bool is_rotating = false;
int down_x,down_y;
::Camera down_camera;

bool is_animating = false;
double animation_start_time = 0;
double ANIMATION_DURATION = 0.5;
Eigen::Quaterniond animation_from_quat;
Eigen::Quaterniond animation_to_quat;

int width,height;
bool is_view_from_light = false;
Eigen::Vector4f light_pos(9,9,1,1);

#define REBAR_NAME "temp.rbr"
igl::ReTwBar rebar;

// Forward
void init_mesh();

void push_undo()
{
  undo_stack.push(s);
  // Clear
  redo_stack = std::stack<State>();
}

void reshape(int width, int height)
{
  ::width = width;
  ::height = height;
  glViewport(0,0,width,height);
  // Send the new window size to AntTweakBar
  TwWindowSize(width, height);
  if(!initialize_shadows(width,height,1,shadowMapTexture,fbo,cfbo))
  {
    assert(false);
    exit(-1);
  }
}

void push_scene(
  const int width,
  const int height,
  const double angle,
  const double zNear = 1e-2,
  const double zFar = 100,
  const bool correct_perspective_scaling = true)
{
  using namespace igl;
  using namespace std;
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  double aspect = ((double)width)/((double)height);
  // Amount of scaling needed to "fix" perspective z-shift
  double z_fix = 1.0;
  // 5 is far enough to see unit "things" well
  const double camera_z = 2;
  // Test if should be using true orthographic projection
  if(angle == 0)
  {
    glOrtho(
      -0.5*camera_z*aspect,
      0.5*camera_z*aspect,
      -0.5*camera_z,
      0.5*camera_z,
      zNear,
      zFar);
  }else
  {
    // Make sure aspect is sane
    aspect = aspect < 0.01 ? 0.01 : aspect;
    gluPerspective(angle,aspect,zNear,zFar);
    if(correct_perspective_scaling)
    {
      z_fix = 2.*tan(angle/2./360.*2.*M_PI);
    }
  }

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();
  glTranslatef(0,0,-camera_z);
  // Adjust scale to correct perspective
  if(correct_perspective_scaling)
  {
    glScaled(z_fix,z_fix,z_fix);
  }
}

void push_lightview_camera(const Eigen::Vector4f & light_pos)
{
  using namespace igl;
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  //glTranslatef(-light_pos(0),-light_pos(1),-light_pos(2));
  gluLookAt(
    light_pos(0), light_pos(1), light_pos(2),
    0,0,0,
    0,1,0);
}

void push_camera(const ::Camera & camera)
{
  using namespace igl;
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  // scale, pan
  glScaled(camera.zoom, camera.zoom, camera.zoom);
  double mat[4*4];
  quat_to_mat(camera.rotation.coeffs().data(),mat);
  glMultMatrixd(mat);
}

void pop_camera()
{
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}

void pop_scene()
{
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}

// Set up double-sided lights
void lights(const Eigen::Vector4f & pos)
{
  using namespace std;
  using namespace Eigen;
  glEnable(GL_LIGHTING);
  glLightModelf(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
  glEnable(GL_LIGHT0);
  float WHITE[4] = {1,1,1,1.};
  float BLACK[4] = {0.,0.,0.,1.};
  glLightfv(GL_LIGHT0,GL_AMBIENT,BLACK);
  glLightfv(GL_LIGHT0,GL_DIFFUSE,WHITE);
  glLightfv(GL_LIGHT0,GL_SPECULAR,BLACK);
  glLightfv(GL_LIGHT0,GL_POSITION,pos.data());
}

void update_meshes()
{
  using namespace Eigen;
  for(auto & mesh : meshes)
  {
    //mesh.da.translate(Vector3d::Random()*0.001);
    mesh.a = mesh.a * mesh.da;
    Vector3d o = mesh.a.translation();
    const Vector3d xo(5,5,5);
    const Vector3d no(5,0,5);
    for(int d = 0;d<3;d++)
    {
      if(o(d) > xo(d))
      {
        o(d) = xo(d);
        mesh.da.translation()(d) *= -1.;
      }
      if(o(d) < -no(d))
      {
        o(d) = -no(d);
        mesh.da.translation()(d) *= -1.;
      }
    }
    mesh.a.translation() = o;
    mesh.da.translation() = MAX_SPEED*mesh.da.translation().normalized();
  }
}

void draw_objects()
{
  using namespace igl;
  using namespace std;
  using namespace Eigen;

  for(int m = 0;m<(int)meshes.size();m++)
  {
    Mesh & mesh = meshes[m];
    Vector4f color(0,0,0,1);
    jet(1.f-(float)m/(float)meshes.size(),color.data());
    // Set material properties
    glDisable(GL_COLOR_MATERIAL);
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,  SILVER_AMBIENT);
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,  color.data());
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, SILVER_SPECULAR);
    glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 128);
    glPushMatrix();
    glMultMatrixd(mesh.a.matrix().data());
    draw_mesh(mesh.V,mesh.F,mesh.N);
    glPopMatrix();
  }

  // Draw a nice floor
  glPushMatrix();
  {
    const float GREY[4] = {0.5,0.5,0.6,1.0};
    const float DARK_GREY[4] = {0.2,0.2,0.3,1.0};
    //draw_floor(GREY,DARK_GREY);
    glTranslatef(0,0.3,0);
    glScaled(10,0.1,10);
    glDisable(GL_COLOR_MATERIAL);
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,  DARK_GREY);
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,  GREY);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, SILVER_SPECULAR);
    glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 128);
    glutSolidCube(1.0);
  }
  glPopMatrix();

}

void draw_scene()
{
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_NORMALIZE);
  push_scene(width,height,s.camera.angle,1e-2,100,true);
  if(is_view_from_light)
  {
    push_lightview_camera(light_pos);
  }else
  {
    push_camera(s.camera);
  }
  lights(light_pos);
  draw_objects();
  glPushMatrix();
    glTranslatef(light_pos(0),light_pos(1),light_pos(2));
    glutWireSphere(1,20,20);
  glPopMatrix();
  pop_camera();
  pop_scene();

  ////First pass - from light's point of view
  //glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
  //glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, cfbo);
  //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  //glMatrixMode(GL_PROJECTION);
  //glLoadMatrixf(lightProjectionMatrix);
  //glMatrixMode(GL_MODELVIEW);
  //glLoadMatrixf(lightViewMatrix);
  ////Use viewport the same size as the shadow map
  //glViewport(0, 0, factor*windowWidth, factor*windowHeight);
  ////Draw back faces into the shadow map
  //glEnable(GL_CULL_FACE);
  //glCullFace(GL_FRONT);
  ////Disable color writes, and use flat shading for speed
  //glShadeModel(GL_FLAT);
  //glColorMask(0, 0, 0, 0);
  ////Draw the scene
  //draw_objects();
  //////Read the depth buffer into the shadow map texture
  ////glBindTexture(GL_TEXTURE_2D, shadowMapTexture);
  ////glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, factor*windowWidth, factor*windowHeight);
  //glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  //glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}

void display()
{
  using namespace igl;
  using namespace std;
  using namespace Eigen;
  glClearColor(1,1,1,0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  if(is_animating)
  {
    double t = (get_seconds() - animation_start_time)/ANIMATION_DURATION;
    if(t > 1)
    {
      t = 1;
      is_animating = false;
    }
    Quaterniond q;
    q.coeffs() =
      animation_to_quat.coeffs()*t + animation_from_quat.coeffs()*(1.-t);
    q.normalize();
    s.camera.rotation = q;
  }
  update_meshes();

  draw_scene();

  report_gl_error();
  TwDraw();
  glutSwapBuffers();
  glutPostRedisplay();
}

void mouse_wheel(int wheel, int direction, int mouse_x, int mouse_y)
{
  using namespace std;
  if(wheel == 0)
  {
    static double mouse_scroll_y = 0;
    const double delta_y = 0.125*direction;
    mouse_scroll_y += delta_y;
    // absolute scale difference when changing zooms (+1)
    const double z_diff = 0.01;
    GLint viewport[4];
    glGetIntegerv(GL_VIEWPORT,viewport);
    if(TwMouseMotion(mouse_x, viewport[3] - mouse_y))
    {
      TwMouseWheel(mouse_scroll_y);
    }else
    {
      s.camera.zoom *= (1.0+double(direction)*z_diff);
      const double min_zoom = 0.01;
      const double max_zoom = 10.0;
      s.camera.zoom = min(max_zoom,max(min_zoom,s.camera.zoom));
    }
  }else
  {
    if(!is_rotating)
    {
      // Change viewing angle (reshape will take care of adjust zoom)
      const double a_diff = 1.0;
      s.camera.angle += double(direction)*a_diff;
      const double min_angle = 15.0;
      s.camera.angle =
        min(90.0,max(min_angle,s.camera.angle));
    }
  }
}

void mouse(int glutButton, int glutState, int mouse_x, int mouse_y)
{
  using namespace std;
  using namespace Eigen;
  using namespace igl;
  bool tw_using = TwEventMouseButtonGLUT(glutButton,glutState,mouse_x,mouse_y);
  switch(glutButton)
  {
    case GLUT_RIGHT_BUTTON:
    case GLUT_LEFT_BUTTON:
    {
      switch(glutState)
      {
        case 1:
          // up
          glutSetCursor(GLUT_CURSOR_INHERIT);
          is_rotating = false;
          break;
        case 0:
          if(!tw_using)
          {
            push_undo();
            glutSetCursor(GLUT_CURSOR_CYCLE);
            // collect information for trackball
            is_rotating = true;
            down_camera = s.camera;
            down_x = mouse_x;
            down_y = mouse_y;
          }
        break;
      }
      break;
      // Scroll down
      case GLUT_WHEEL_DOWN:
      {
        mouse_wheel(0,-1,mouse_x,mouse_y);
        break;
      }
      // Scroll up
      case GLUT_WHEEL_UP:
      {
        mouse_wheel(0,1,mouse_x,mouse_y);
        break;
      }
      // Scroll left
      case GLUT_WHEEL_LEFT:
      {
        mouse_wheel(1,-1,mouse_x,mouse_y);
        break;
      }
      // Scroll right
      case GLUT_WHEEL_RIGHT:
      {
        mouse_wheel(1,1,mouse_x,mouse_y);
        break;
      }
    }
  }
}

void mouse_drag(int mouse_x, int mouse_y)
{
  using namespace igl;
  using namespace std;
  using namespace Eigen;
  /*bool tw_using =*/ TwMouseMotion(mouse_x,mouse_y);

  if(is_rotating)
  {
    glutSetCursor(GLUT_CURSOR_CYCLE);
    switch(rotation_type)
    {
      case ROTATION_TYPE_IGL_TRACKBALL:
      {
        // Rotate according to trackball
        igl::trackball(
          width,
          height,
          2.0,
          down_camera.rotation,
          down_x,
          down_y,
          mouse_x,
          mouse_y,
          s.camera.rotation);
          break;
      }
      case ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP:
      {
        Quaterniond down_q = down_camera.rotation;
        Vector3d axis(0,1,0);
        const double speed = 2.0;
        Quaterniond q;
        q = down_q *
          Quaterniond(
            AngleAxisd(
              M_PI*((double)(mouse_x-down_x))/(double)width*speed/2.0,
              axis.normalized()));
        q.normalize();
        {
          Vector3d axis(1,0,0);
          const double speed = 2.0;
          if(axis.norm() != 0)
          {
            q =
              Quaterniond(
                AngleAxisd(
                  M_PI*(mouse_y-down_y)/(double)width*speed/2.0,
                  axis.normalized())) * q;
            q.normalize();
          }
        }
        s.camera.rotation = q;
        break;
      }
      default:
        break;
    }
  }
}

void init_mesh(Mesh & mesh)
{
  using namespace Eigen;
  using namespace igl;
  per_face_normals(mesh.V,mesh.F,mesh.N);
  normalize_row_lengths(mesh.N,mesh.N);
  // Rescale so bounding box fits in unit ball
  Vector3d Vmax = mesh.V.colwise().maxCoeff();
  Vector3d Vmin = mesh.V.colwise().minCoeff();
  Vector3d Vmid = 0.5*(Vmax + Vmin);
  mesh.V.rowwise() -= Vmid.transpose();
  const double bbd = (Vmax-Vmin).norm();
  mesh.V /= (bbd*0.5);
}

void undo()
{
  using namespace std;
  if(!undo_stack.empty())
  {
    redo_stack.push(s);
    s = undo_stack.top();
    undo_stack.pop();
  }
}

void redo()
{
  using namespace std;
  if(!redo_stack.empty())
  {
    undo_stack.push(s);
    s = redo_stack.top();
    redo_stack.pop();
  }
}

void key(unsigned char key, int mouse_x, int mouse_y)
{
  using namespace std;
  int mod = glutGetModifiers();
  switch(key)
  {
    // ESC
    case char(27):
      rebar.save(REBAR_NAME);
    // ^C
    case char(3):
      exit(0);
    case 'z':
    case 'Z':
      if(mod & GLUT_ACTIVE_COMMAND)
      {
        if(mod & GLUT_ACTIVE_SHIFT)
        {
          redo();
        }else
        {
          undo();
        }
        break;
      }else
      {
        push_undo();
        igl::snap_to_canonical_view_quat(
          s.camera.rotation,
          1.0,
          s.camera.rotation);
        break;
      }
    default:
      if(!TwEventKeyboardGLUT(key,mouse_x,mouse_y))
      {
        cout<<"Unknown key command: "<<key<<" "<<int(key)<<endl;
      }
  }
}
void TW_CALL set_rotation_type(const void * value, void * clientData)
{
  using namespace Eigen;
  using namespace std;
  using namespace igl;
  const RotationType old_rotation_type = rotation_type;
  rotation_type = *(const RotationType *)(value);
  if(rotation_type == ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP &&
    old_rotation_type != ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP)
  {
    push_undo();
    animation_from_quat = s.camera.rotation;
    const Vector3d up = animation_from_quat.matrix() * Vector3d(0,1,0);
    Vector3d proj_up(0,up(1),up(2));
    if(proj_up.norm() == 0)
    {
      proj_up = Vector3d(0,1,0);
    }
    proj_up.normalize();
    Quaterniond dq;
    dq = Quaterniond::FromTwoVectors(up,proj_up);
    animation_to_quat = dq * animation_from_quat;
    // start animation
    animation_start_time = get_seconds();
    is_animating = true;
  }
}
void TW_CALL get_rotation_type(void * value, void *clientData)
{
  RotationType * rt = (RotationType *)(value);
  *rt = rotation_type;
}

int main(int argc, char * argv[])
{
  using namespace std;
  using namespace Eigen;
  using namespace igl;
  vector<string> filenames;
  switch(argc)
  {
    default:
      // Read and prepare meshes
      for(int a = 1;a<argc;a++)
      {
        filenames.push_back(argv[a]);
      }
      break;
    case 1:
      cerr<<"Usage:"<<endl<<
        "    ./example input1.obj input2.obj input3.obj ..."<<endl;
      cerr<<endl<<"Opening default mesh..."<<endl;
      string filename = "../shared/truck.obj";
      filenames.push_back(filename);
      break;
  }

  // print key commands
  cout<<"[Click] and [drag]  Rotate model using trackball."<<endl;
  cout<<"[Z,z]               Snap rotation to canonical view."<<endl;
  cout<<"[Command+Z]         Undo."<<endl;
  cout<<"[Shift+Command+Z]   Redo."<<endl;
  cout<<"[^C,ESC]            Exit."<<endl;

  for(auto & filename : filenames)
  {
    meshes.push_back(Mesh());
    Mesh & mesh = meshes.back();
    mesh.a.translate(Vector3d(0,1,0));
    Vector3d offset = Vector3d::Random()*3;
    offset(1) = 0;
    mesh.a.translate(offset);
    // dirname, basename, extension and filename
    string d,b,ext,f;
    pathinfo(filename,d,b,ext,f);
    // Convert extension to lower case
    transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
    vector<vector<double > > vV,vN,vTC;
    vector<vector<int > > vF,vFTC,vFN;
    if(ext == "obj")
    {
      // Convert extension to lower case
      if(!igl::readOBJ(filename,vV,vTC,vN,vF,vFTC,vFN))
      {
        return 1;
      }
    }else if(ext == "off")
    {
      // Convert extension to lower case
      if(!igl::readOFF(filename,vV,vF,vN))
      {
        return 1;
      }
    }else if(ext == "wrl")
    {
      // Convert extension to lower case
      if(!igl::readWRL(filename,vV,vF))
      {
        return 1;
      }
    }
    if(vV.size() > 0)
    {
      if(!list_to_matrix(vV,mesh.V))
      {
        return 1;
      }
      polygon_mesh_to_triangle_mesh(vF,mesh.F);
    }
    init_mesh(mesh);
  }

  // Init glut
  glutInit(&argc,argv);
  if( !TwInit(TW_OPENGL, NULL) )
  {
    // A fatal error occured
    fprintf(stderr, "AntTweakBar initialization failed: %s\n", TwGetLastError());
    return 1;
  }
  // Create a tweak bar
  rebar.TwNewBar("bar");
  TwDefine("bar label='Shadow Mapping' size='200 550' text=light alpha='200' color='68 68 68'");
  rebar.TwAddVarRW("camera_zoom", TW_TYPE_DOUBLE,&s.camera.zoom,"");
  rebar.TwAddVarRW("camera_rotation", TW_TYPE_QUAT4D,s.camera.rotation.coeffs().data(),"");
  TwType RotationTypeTW = ReTwDefineEnumFromString("RotationType","igl_trackball,two_axis_fixed_up");
  rebar.TwAddVarCB( "rotation_type", RotationTypeTW,
    set_rotation_type,get_rotation_type,NULL,"keyIncr=] keyDecr=[");
  rebar.TwAddVarRW( "is_view_from_light",TW_TYPE_BOOLCPP,&is_view_from_light,
    "key=l");
  rebar.load(REBAR_NAME);

  animation_from_quat = Quaterniond(1,0,0,0);
  animation_from_quat = s.camera.rotation;
  animation_start_time = get_seconds();

  // Init antweakbar
  glutInitDisplayString( "rgba depth double samples>=8");
  // Top right corner
  glutInitWindowSize(glutGet(GLUT_SCREEN_WIDTH)/2.0,glutGet(GLUT_SCREEN_HEIGHT)/2.0);
  glutInitWindowPosition(glutGet(GLUT_SCREEN_WIDTH)/2.0,-1);
  glutCreateWindow("Shadow Mapping");
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutKeyboardFunc(key);
  glutMouseFunc(mouse);
  glutMotionFunc(mouse_drag);
  glutPassiveMotionFunc((GLUTmousemotionfun)TwEventMouseMotionGLUT);

  glutMainLoop();

  return 0;
}