igl::opengl::glfw::Viewer Class Reference

#include <src/libigl/igl/opengl/glfw/Viewer.h>

Collaboration diagram for igl::opengl::glfw::Viewer:

Public Types
enum class	MouseButton { Left , Middle , Right }
enum class	MouseMode {   None , Rotation , Zoom , Pan ,   Translation }

Public Member Functions
IGL_INLINE int	launch (bool resizable=true, bool fullscreen=false)
IGL_INLINE int	launch_init (bool resizable=true, bool fullscreen=false)
IGL_INLINE bool	launch_rendering (bool loop=true)
IGL_INLINE void	launch_shut ()
IGL_INLINE void	init ()
IGL_INLINE void	init_plugins ()
IGL_INLINE void	shutdown_plugins ()
	Viewer ()
	~Viewer ()
IGL_INLINE bool	load_mesh_from_file (const std::string &mesh_file_name)
IGL_INLINE bool	save_mesh_to_file (const std::string &mesh_file_name)
IGL_INLINE bool	key_pressed (unsigned int unicode_key, int modifier)
IGL_INLINE bool	key_down (int key, int modifier)
IGL_INLINE bool	key_up (int key, int modifier)
IGL_INLINE bool	mouse_down (MouseButton button, int modifier)
IGL_INLINE bool	mouse_up (MouseButton button, int modifier)
IGL_INLINE bool	mouse_move (int mouse_x, int mouse_y)
IGL_INLINE bool	mouse_scroll (float delta_y)
IGL_INLINE bool	load_scene ()
IGL_INLINE bool	load_scene (std::string fname)
IGL_INLINE bool	save_scene ()
IGL_INLINE bool	save_scene (std::string fname)
IGL_INLINE void	draw ()
IGL_INLINE void	resize (int w, int h)
IGL_INLINE void	post_resize (int w, int h)
IGL_INLINE void	snap_to_canonical_quaternion ()
IGL_INLINE void	open_dialog_load_mesh ()
IGL_INLINE void	open_dialog_save_mesh ()
IGL_INLINE ViewerData &	data ()
IGL_INLINE int	append_mesh ()
IGL_INLINE bool	erase_mesh (const size_t index)
IGL_INLINE size_t	mesh_index (const int id) const

Public Attributes
enum igl::opengl::glfw::Viewer::MouseMode	mouse_mode
std::vector< ViewerData >	data_list
size_t	selected_data_index
int	next_data_id
GLFWwindow *	window
ViewerCore	core
std::vector< ViewerPlugin * >	plugins
Eigen::Quaternionf	down_rotation
int	current_mouse_x
int	current_mouse_y
int	down_mouse_x
int	down_mouse_y
float	down_mouse_z
Eigen::Vector3f	down_translation
bool	down
bool	hack_never_moved
float	scroll_position
std::function< bool(Viewer &viewer)>	callback_init
std::function< bool(Viewer &viewer)>	callback_pre_draw
std::function< bool(Viewer &viewer)>	callback_post_draw
std::function< bool(Viewer &viewer, int button, int modifier)>	callback_mouse_down
std::function< bool(Viewer &viewer, int button, int modifier)>	callback_mouse_up
std::function< bool(Viewer &viewer, int mouse_x, int mouse_y)>	callback_mouse_move
std::function< bool(Viewer &viewer, float delta_y)>	callback_mouse_scroll
std::function< bool(Viewer &viewer, unsigned int key, int modifiers)>	callback_key_pressed
std::function< bool(Viewer &viewer, unsigned int key, int modifiers)>	callback_key_down
std::function< bool(Viewer &viewer, unsigned int key, int modifiers)>	callback_key_up
void *	callback_init_data
void *	callback_pre_draw_data
void *	callback_post_draw_data
void *	callback_mouse_down_data
void *	callback_mouse_up_data
void *	callback_mouse_move_data
void *	callback_mouse_scroll_data
void *	callback_key_pressed_data
void *	callback_key_down_data
void *	callback_key_up_data

Detailed Description

Member Enumeration Documentation

MouseButton

enum class igl::opengl::glfw::Viewer::MouseButton

strong

Enumerator
Left
Middle
Right

{Left, Middle, Right};

MouseMode

enum class igl::opengl::glfw::Viewer::MouseMode

strong

Enumerator
None
Rotation
Zoom
Pan
Translation

{ None, Rotation, Zoom, Pan, Translation} mouse_mode;

Constructor & Destructor Documentation

Viewer()

IGL_INLINE igl::opengl::glfw::Viewer::Viewer

(

)

                           :
    data_list(1),
    selected_data_index(0),
    next_data_id(1)
  {
    window = nullptr;
    data_list.front().id = 0;
 
    // Temporary variables initialization
    down = false;
    hack_never_moved = true;
    scroll_position = 0.0f;
 
    // Per face
    data().set_face_based(false);
 
    // C-style callbacks
    callback_init         = nullptr;
    callback_pre_draw     = nullptr;
    callback_post_draw    = nullptr;
    callback_mouse_down   = nullptr;
    callback_mouse_up     = nullptr;
    callback_mouse_move   = nullptr;
    callback_mouse_scroll = nullptr;
    callback_key_down     = nullptr;
    callback_key_up       = nullptr;
 
    callback_init_data          = nullptr;
    callback_pre_draw_data      = nullptr;
    callback_post_draw_data     = nullptr;
    callback_mouse_down_data    = nullptr;
    callback_mouse_up_data      = nullptr;
    callback_mouse_move_data    = nullptr;
    callback_mouse_scroll_data  = nullptr;
    callback_key_down_data      = nullptr;
    callback_key_up_data        = nullptr;
 
#ifndef IGL_VIEWER_VIEWER_QUIET
    const std::string usage(R"(igl::opengl::glfw::Viewer usage:
  [drag]  Rotate scene
  A,a     Toggle animation (tight draw loop)
  F,f     Toggle face based
  I,i     Toggle invert normals
  L,l     Toggle wireframe
  O,o     Toggle orthographic/perspective projection
  T,t     Toggle filled faces
  Z       Snap to canonical view
  [,]     Toggle between rotation control types (trackball, two-axis
          valuator with fixed up, 2D mode with no rotation))
  <,>     Toggle between models
  ;       Toggle vertex labels
  :       Toggle face labels)"
);
    std::cout<<usage<<std::endl;
#endif
  }

References callback_init, callback_init_data, callback_key_down, callback_key_down_data, callback_key_up, callback_key_up_data, callback_mouse_down, callback_mouse_down_data, callback_mouse_move, callback_mouse_move_data, callback_mouse_scroll, callback_mouse_scroll_data, callback_mouse_up, callback_mouse_up_data, callback_post_draw, callback_post_draw_data, callback_pre_draw, callback_pre_draw_data, data(), data_list, down, hack_never_moved, scroll_position, igl::opengl::ViewerData::set_face_based(), usage(), and window.

Here is the call graph for this function:

~Viewer()

IGL_INLINE igl::opengl::glfw::Viewer::~Viewer

(

)

  {
  }

Member Function Documentation

append_mesh()

IGL_INLINE int igl::opengl::glfw::Viewer::append_mesh

(

)

  {
    assert(data_list.size() >= 1);
 
    data_list.emplace_back();
    selected_data_index = data_list.size()-1;
    data_list.back().id = next_data_id++;
    return data_list.back().id;
  }

References data_list, next_data_id, and selected_data_index.

Referenced by load_mesh_from_file().

Here is the caller graph for this function:

data()

IGL_INLINE ViewerData & igl::opengl::glfw::Viewer::data

(

)

  {
    assert(!data_list.empty() && "data_list should never be empty");
    assert(
      (selected_data_index >= 0 && selected_data_index < data_list.size()) &&
      "selected_data_index should be in bounds");
    return data_list[selected_data_index];
  }

References data_list, and selected_data_index.

Referenced by Viewer(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), key_pressed(), launch_init(), launch_shut(), load_mesh_from_file(), load_scene(), mouse_down(), save_mesh_to_file(), and save_scene().

Here is the caller graph for this function:

draw()

IGL_INLINE void igl::opengl::glfw::Viewer::draw

(

)

  {
    using namespace std;
    using namespace Eigen;
 
    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
 
    int width_window, height_window;
    glfwGetWindowSize(window, &width_window, &height_window);
 
    auto highdpi_tmp = width/width_window;
 
    if(fabs(highdpi_tmp-highdpi)>1e-8)
    {
      post_resize(width, height);
      highdpi=highdpi_tmp;
    }
 
    core.clear_framebuffers();
    if (callback_pre_draw)
    {
      if (callback_pre_draw(*this))
      {
        return;
      }
    }
    for (unsigned int i = 0; i<plugins.size(); ++i)
    {
      if (plugins[i]->pre_draw())
      {
        return;
      }
    }
    for(int i = 0;i<data_list.size();i++)
    {
      core.draw(data_list[i]);
    }
    if (callback_post_draw)
    {
      if (callback_post_draw(*this))
      {
        return;
      }
    }
    for (unsigned int i = 0; i<plugins.size(); ++i)
    {
      if (plugins[i]->post_draw())
      {
        break;
      }
    }
  }

References callback_post_draw, callback_pre_draw, igl::opengl::ViewerCore::clear_framebuffers(), core, data_list, igl::opengl::ViewerCore::draw(), highdpi, plugins, post_resize(), and window.

Referenced by launch_rendering().

Here is the call graph for this function:

Here is the caller graph for this function:

erase_mesh()

IGL_INLINE bool igl::opengl::glfw::Viewer::erase_mesh

(

const size_t

index

)

  {
    assert((index >= 0 && index < data_list.size()) && "index should be in bounds");
    assert(data_list.size() >= 1);
    if(data_list.size() == 1)
    {
      // Cannot remove last mesh
      return false;
    }
    data_list[index].meshgl.free();
    data_list.erase(data_list.begin() + index);
    if(selected_data_index >= index && selected_data_index>0)
    {
      selected_data_index--;
    }
    return true;
  }

References data_list, and selected_data_index.

init()

IGL_INLINE void igl::opengl::glfw::Viewer::init

(

)

  {
    core.init();
 
    if (callback_init)
      if (callback_init(*this))
        return;
 
    init_plugins();
  }

References callback_init, core, igl::opengl::ViewerCore::init(), and init_plugins().

Referenced by launch_init().

Here is the call graph for this function:

Here is the caller graph for this function:

init_plugins()

IGL_INLINE void igl::opengl::glfw::Viewer::init_plugins

(

)

  {
    // Init all plugins
    for (unsigned int i = 0; i<plugins.size(); ++i)
    {
      plugins[i]->init(this);
    }
  }

References plugins.

Referenced by init().

Here is the caller graph for this function:

key_down()

IGL_INLINE bool igl::opengl::glfw::Viewer::key_down	(	int	key,
		int	modifier
	)

  {
    if (callback_key_down)
      if (callback_key_down(*this,key,modifiers))
        return true;
    for (unsigned int i = 0; i<plugins.size(); ++i)
      if (plugins[i]->key_down(key, modifiers))
        return true;
    return false;
  }

References callback_key_down, key_down(), and plugins.

Referenced by glfw_key_callback(), and key_down().

Here is the call graph for this function:

Here is the caller graph for this function:

key_pressed()

IGL_INLINE bool igl::opengl::glfw::Viewer::key_pressed	(	unsigned int	unicode_key,
		int	modifier
	)

  {
    if (callback_key_pressed)
      if (callback_key_pressed(*this,unicode_key,modifiers))
        return true;
 
    for (unsigned int i = 0; i<plugins.size(); ++i)
    {
      if (plugins[i]->key_pressed(unicode_key, modifiers))
      {
        return true;
      }
    }
 
    switch(unicode_key)
    {
      case 'A':
      case 'a':
      {
        core.is_animating = !core.is_animating;
        return true;
      }
      case 'F':
      case 'f':
      {
        data().set_face_based(!data().face_based);
        return true;
      }
      case 'I':
      case 'i':
      {
        data().dirty |= MeshGL::DIRTY_NORMAL;
        data().invert_normals = !data().invert_normals;
        return true;
      }
      case 'L':
      case 'l':
      {
        data().show_lines = !data().show_lines;
        return true;
      }
      case 'O':
      case 'o':
      {
        core.orthographic = !core.orthographic;
        return true;
      }
      case 'T':
      case 't':
      {
        data().show_faces = !data().show_faces;
        return true;
      }
      case 'Z':
      {
        snap_to_canonical_quaternion();
        return true;
      }
      case '[':
      case ']':
      {
        if(core.rotation_type == ViewerCore::ROTATION_TYPE_TRACKBALL)
          core.set_rotation_type(ViewerCore::ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP);
        else
          core.set_rotation_type(ViewerCore::ROTATION_TYPE_TRACKBALL);
 
        return true;
      }
      case '<':
      case '>':
      {
        selected_data_index =
          (selected_data_index + data_list.size() + (unicode_key=='>'?1:-1))%data_list.size();
        return true;
      }
      case ';':
        data().show_vertid = !data().show_vertid;
        return true;
      case ':':
        data().show_faceid = !data().show_faceid;
        return true;
      default: break;//do nothing
    }
    return false;
  }

References callback_key_pressed, core, data(), data_list, igl::opengl::ViewerData::dirty, igl::opengl::MeshGL::DIRTY_NORMAL, igl::opengl::ViewerData::invert_normals, igl::opengl::ViewerCore::is_animating, key_pressed(), igl::opengl::ViewerCore::orthographic, plugins, igl::opengl::ViewerCore::rotation_type, igl::opengl::ViewerCore::ROTATION_TYPE_TRACKBALL, igl::opengl::ViewerCore::ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP, selected_data_index, igl::opengl::ViewerData::set_face_based(), igl::opengl::ViewerCore::set_rotation_type(), igl::opengl::ViewerData::show_faceid, igl::opengl::ViewerData::show_faces, igl::opengl::ViewerData::show_lines, igl::opengl::ViewerData::show_vertid, and snap_to_canonical_quaternion().

Referenced by glfw_char_mods_callback(), and key_pressed().

Here is the call graph for this function:

Here is the caller graph for this function:

key_up()

IGL_INLINE bool igl::opengl::glfw::Viewer::key_up	(	int	key,
		int	modifier
	)

  {
    if (callback_key_up)
      if (callback_key_up(*this,key,modifiers))
        return true;
 
    for (unsigned int i = 0; i<plugins.size(); ++i)
      if (plugins[i]->key_up(key, modifiers))
        return true;
 
    return false;
  }

References callback_key_up, key_up(), and plugins.

Referenced by glfw_key_callback(), and key_up().

Here is the call graph for this function:

Here is the caller graph for this function:

launch()

IGL_INLINE int igl::opengl::glfw::Viewer::launch	(	bool	resizable = true,
		bool	fullscreen = false
	)

  {
    // TODO return values are being ignored...
    launch_init(resizable,fullscreen);
    launch_rendering(true);
    launch_shut();
    return EXIT_SUCCESS;
  }

References launch_init(), launch_rendering(), and launch_shut().

Here is the call graph for this function:

launch_init()

IGL_INLINE int igl::opengl::glfw::Viewer::launch_init	(	bool	resizable = true,
		bool	fullscreen = false
	)

  {
    glfwSetErrorCallback(glfw_error_callback);
    if (!glfwInit())
    {
      return EXIT_FAILURE;
    }
    glfwWindowHint(GLFW_SAMPLES, 8);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    #ifdef __APPLE__
      glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
      glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    #endif
    if(fullscreen)
    {
      GLFWmonitor *monitor = glfwGetPrimaryMonitor();
      const GLFWvidmode *mode = glfwGetVideoMode(monitor);
      window = glfwCreateWindow(mode->width,mode->height,"libigl viewer",monitor,nullptr);
    }
    else
    {
      if (core.viewport.tail<2>().any()) {
        window = glfwCreateWindow(core.viewport(2),core.viewport(3),"libigl viewer",nullptr,nullptr);
      } else {
        window = glfwCreateWindow(1280,800,"libigl viewer",nullptr,nullptr);
      }
    }
    if (!window)
    {
      glfwTerminate();
      return EXIT_FAILURE;
    }
    glfwMakeContextCurrent(window);
    // Load OpenGL and its extensions
    if (!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress))
    {
      printf("Failed to load OpenGL and its extensions\n");
      return(-1);
    }
    #if defined(DEBUG) || defined(_DEBUG)
      printf("OpenGL Version %d.%d loaded\n", GLVersion.major, GLVersion.minor);
      int major, minor, rev;
      major = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
      minor = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
      rev = glfwGetWindowAttrib(window, GLFW_CONTEXT_REVISION);
      printf("OpenGL version received: %d.%d.%d\n", major, minor, rev);
      printf("Supported OpenGL is %s\n", (const char*)glGetString(GL_VERSION));
      printf("Supported GLSL is %s\n", (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
    #endif
    glfwSetInputMode(window,GLFW_CURSOR,GLFW_CURSOR_NORMAL);
    // Initialize FormScreen
    __viewer = this;
    // Register callbacks
    glfwSetKeyCallback(window, glfw_key_callback);
    glfwSetCursorPosCallback(window,glfw_mouse_move);
    glfwSetWindowSizeCallback(window,glfw_window_size);
    glfwSetMouseButtonCallback(window,glfw_mouse_press);
    glfwSetScrollCallback(window,glfw_mouse_scroll);
    glfwSetCharModsCallback(window,glfw_char_mods_callback);
    glfwSetDropCallback(window,glfw_drop_callback);
    // Handle retina displays (windows and mac)
    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
    int width_window, height_window;
    glfwGetWindowSize(window, &width_window, &height_window);
    highdpi = width/width_window;
    glfw_window_size(window,width_window,height_window);
    //opengl.init();
    core.align_camera_center(data().V,data().F);
    // Initialize IGL viewer
    init();
    return EXIT_SUCCESS;
  }

References __viewer, igl::opengl::ViewerCore::align_camera_center(), core, data(), GL_TRUE, glfw_char_mods_callback(), glfw_drop_callback(), glfw_error_callback(), glfw_key_callback(), glfw_mouse_move(), glfw_mouse_press(), glfw_mouse_scroll(), glfw_window_size(), highdpi, init(), igl::mode(), igl::opengl::ViewerCore::viewport, and window.

Referenced by launch().

Here is the call graph for this function:

Here is the caller graph for this function:

launch_rendering()

IGL_INLINE bool igl::opengl::glfw::Viewer::launch_rendering

(

bool

loop = true

)

  {
    // glfwMakeContextCurrent(window);
    // Rendering loop
    const int num_extra_frames = 5;
    int frame_counter = 0;
    while (!glfwWindowShouldClose(window))
    {
      double tic = get_seconds();
      draw();
      glfwSwapBuffers(window);
      if(core.is_animating || frame_counter++ < num_extra_frames)
      {
        glfwPollEvents();
        // In microseconds
        double duration = 1000000.*(get_seconds()-tic);
        const double min_duration = 1000000./core.animation_max_fps;
        if(duration<min_duration)
        {
          std::this_thread::sleep_for(std::chrono::microseconds((int)(min_duration-duration)));
        }
      }
      else
      {
        glfwWaitEvents();
        frame_counter = 0;
      }
      if (!loop)
        return !glfwWindowShouldClose(window);
    }
    return EXIT_SUCCESS;
  }

References igl::opengl::ViewerCore::animation_max_fps, core, draw(), igl::get_seconds(), igl::opengl::ViewerCore::is_animating, igl::loop(), and window.

Referenced by launch().

Here is the call graph for this function:

Here is the caller graph for this function:

launch_shut()

IGL_INLINE void igl::opengl::glfw::Viewer::launch_shut

(

)

  {
    for(auto & data : data_list)
    {
      data.meshgl.free();
    }
    core.shut();
    shutdown_plugins();
    glfwDestroyWindow(window);
    glfwTerminate();
    return;
  }

References core, data(), data_list, igl::opengl::MeshGL::free(), igl::opengl::ViewerData::meshgl, igl::opengl::ViewerCore::shut(), shutdown_plugins(), and window.

Referenced by launch().

Here is the call graph for this function:

Here is the caller graph for this function:

load_mesh_from_file()

IGL_INLINE bool igl::opengl::glfw::Viewer::load_mesh_from_file

(

const std::string &

mesh_file_name

)

  {
 
    // first try to load it with a plugin
    for (unsigned int i = 0; i<plugins.size(); ++i)
    {
      if (plugins[i]->load(mesh_file_name_string))
      {
        return true;
      }
    }
 
    // Create new data slot and set to selected
    if(!(data().F.rows() == 0  && data().V.rows() == 0))
    {
      append_mesh();
    }
    data().clear();
 
    size_t last_dot = mesh_file_name_string.rfind('.');
    if (last_dot == std::string::npos)
    {
      std::cerr<<"Error: No file extension found in "<<
        mesh_file_name_string<<std::endl;
      return false;
    }
 
    std::string extension = mesh_file_name_string.substr(last_dot+1);
 
    if (extension == "off" || extension =="OFF")
    {
      Eigen::MatrixXd V;
      Eigen::MatrixXi F;
      if (!igl::readOFF(mesh_file_name_string, V, F))
        return false;
      data().set_mesh(V,F);
    }
    else if (extension == "obj" || extension =="OBJ")
    {
      Eigen::MatrixXd corner_normals;
      Eigen::MatrixXi fNormIndices;
 
      Eigen::MatrixXd UV_V;
      Eigen::MatrixXi UV_F;
      Eigen::MatrixXd V;
      Eigen::MatrixXi F;
 
      if (!(
            igl::readOBJ(
              mesh_file_name_string,
              V, UV_V, corner_normals, F, UV_F, fNormIndices)))
      {
        return false;
      }
 
      data().set_mesh(V,F);
      data().set_uv(UV_V,UV_F);
 
    }
    else
    {
      // unrecognized file type
      printf("Error: %s is not a recognized file type.\n",extension.c_str());
      return false;
    }
 
    data().compute_normals();
    data().uniform_colors(Eigen::Vector3d(51.0/255.0,43.0/255.0,33.3/255.0),
                   Eigen::Vector3d(255.0/255.0,228.0/255.0,58.0/255.0),
                   Eigen::Vector3d(255.0/255.0,235.0/255.0,80.0/255.0));
 
    // Alec: why?
    if (data().V_uv.rows() == 0)
    {
      data().grid_texture();
    }
 
    core.align_camera_center(data().V,data().F);
 
    for (unsigned int i = 0; i<plugins.size(); ++i)
      if (plugins[i]->post_load())
        return true;
 
    return true;
  }

References igl::opengl::ViewerCore::align_camera_center(), append_mesh(), igl::opengl::ViewerData::clear(), igl::opengl::ViewerData::compute_normals(), core, data(), igl::opengl::ViewerData::grid_texture(), load(), plugins, igl::readOBJ(), igl::readOFF(), igl::opengl::ViewerData::set_mesh(), igl::opengl::ViewerData::set_uv(), and igl::opengl::ViewerData::uniform_colors().

Referenced by open_dialog_load_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

load_scene() [1/2]

IGL_INLINE bool igl::opengl::glfw::Viewer::load_scene

(

)

  {
    std::string fname = igl::file_dialog_open();
    if(fname.length() == 0)
      return false;
    return load_scene(fname);
  }

References igl::file_dialog_open(), and load_scene().

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and load_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

load_scene() [2/2]

IGL_INLINE bool igl::opengl::glfw::Viewer::load_scene

(

std::string

fname

)

  {
    igl::deserialize(core,"Core",fname.c_str());
    igl::deserialize(data(),"Data",fname.c_str());
    return true;
  }

References core, data(), and igl::deserialize().

Here is the call graph for this function:

mesh_index()

IGL_INLINE size_t igl::opengl::glfw::Viewer::mesh_index

(

const int

id

)

const

                                                         {
    for (size_t i = 0; i < data_list.size(); ++i)
    {
      if (data_list[i].id == id)
        return i;
    }
    return 0;
  }

References data_list.

mouse_down()

IGL_INLINE bool igl::opengl::glfw::Viewer::mouse_down	(	MouseButton	button,
		int	modifier
	)

  {
    // Remember mouse location at down even if used by callback/plugin
    down_mouse_x = current_mouse_x;
    down_mouse_y = current_mouse_y;
 
    if (callback_mouse_down)
      if (callback_mouse_down(*this,static_cast<int>(button),modifier))
        return true;
 
    for (unsigned int i = 0; i<plugins.size(); ++i)
      if(plugins[i]->mouse_down(static_cast<int>(button),modifier))
        return true;
 
    down = true;
 
    down_translation = core.camera_translation;
 
 
    // Initialization code for the trackball
    Eigen::RowVector3d center;
    if (data().V.rows() == 0)
    {
      center << 0,0,0;
    }else
    {
      center = data().V.colwise().sum()/data().V.rows();
    }
 
    Eigen::Vector3f coord =
      igl::project(
        Eigen::Vector3f(center(0),center(1),center(2)),
        core.view,
        core.proj,
        core.viewport);
    down_mouse_z = coord[2];
    down_rotation = core.trackball_angle;
 
    mouse_mode = MouseMode::Rotation;
 
    switch (button)
    {
      case MouseButton::Left:
        if (core.rotation_type == ViewerCore::ROTATION_TYPE_NO_ROTATION) {
          mouse_mode = MouseMode::Translation;
        } else {
          mouse_mode = MouseMode::Rotation;
        }
        break;
 
      case MouseButton::Right:
        mouse_mode = MouseMode::Translation;
        break;
 
      default:
        mouse_mode = MouseMode::None;
        break;
    }
 
    return true;
  }

References callback_mouse_down, igl::opengl::ViewerCore::camera_translation, core, current_mouse_x, current_mouse_y, data(), down, down_mouse_x, down_mouse_y, down_mouse_z, down_rotation, down_translation, Left, mouse_down(), mouse_mode, None, plugins, igl::opengl::ViewerCore::proj, igl::project(), Right, Rotation, igl::opengl::ViewerCore::rotation_type, igl::opengl::ViewerCore::ROTATION_TYPE_NO_ROTATION, igl::opengl::ViewerCore::trackball_angle, Translation, igl::opengl::ViewerData::V, igl::opengl::ViewerCore::view, and igl::opengl::ViewerCore::viewport.

Referenced by glfw_mouse_press(), and mouse_down().

Here is the call graph for this function:

Here is the caller graph for this function:

mouse_move()

IGL_INLINE bool igl::opengl::glfw::Viewer::mouse_move	(	int	mouse_x,
		int	mouse_y
	)

  {
    if(hack_never_moved)
    {
      down_mouse_x = mouse_x;
      down_mouse_y = mouse_y;
      hack_never_moved = false;
    }
    current_mouse_x = mouse_x;
    current_mouse_y = mouse_y;
 
    if (callback_mouse_move)
      if (callback_mouse_move(*this,mouse_x,mouse_y))
        return true;
 
    for (unsigned int i = 0; i<plugins.size(); ++i)
      if (plugins[i]->mouse_move(mouse_x, mouse_y))
        return true;
 
    if (down)
    {
      switch (mouse_mode)
      {
        case MouseMode::Rotation:
        {
          switch(core.rotation_type)
          {
            default:
              assert(false && "Unknown rotation type");
            case ViewerCore::ROTATION_TYPE_NO_ROTATION:
              break;
            case ViewerCore::ROTATION_TYPE_TRACKBALL:
              igl::trackball(
                core.viewport(2),
                core.viewport(3),
                2.0f,
                down_rotation,
                down_mouse_x,
                down_mouse_y,
                mouse_x,
                mouse_y,
                core.trackball_angle);
              break;
            case ViewerCore::ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP:
              igl::two_axis_valuator_fixed_up(
                core.viewport(2),core.viewport(3),
                2.0,
                down_rotation,
                down_mouse_x, down_mouse_y, mouse_x, mouse_y,
                core.trackball_angle);
              break;
          }
          //Eigen::Vector4f snapq = core.trackball_angle;
 
          break;
        }
 
        case MouseMode::Translation:
        {
          //translation
          Eigen::Vector3f pos1 = igl::unproject(Eigen::Vector3f(mouse_x, core.viewport[3] - mouse_y, down_mouse_z), core.view, core.proj, core.viewport);
          Eigen::Vector3f pos0 = igl::unproject(Eigen::Vector3f(down_mouse_x, core.viewport[3] - down_mouse_y, down_mouse_z), core.view, core.proj, core.viewport);
 
          Eigen::Vector3f diff = pos1 - pos0;
          core.camera_translation = down_translation + Eigen::Vector3f(diff[0],diff[1],diff[2]);
 
          break;
        }
        case MouseMode::Zoom:
        {
          float delta = 0.001f * (mouse_x - down_mouse_x + mouse_y - down_mouse_y);
          core.camera_zoom *= 1 + delta;
          down_mouse_x = mouse_x;
          down_mouse_y = mouse_y;
          break;
        }
 
        default:
          break;
      }
    }
    return true;
  }

References callback_mouse_move, igl::opengl::ViewerCore::camera_translation, igl::opengl::ViewerCore::camera_zoom, core, current_mouse_x, current_mouse_y, down, down_mouse_x, down_mouse_y, down_mouse_z, down_rotation, down_translation, hack_never_moved, mouse_mode, mouse_move(), plugins, igl::opengl::ViewerCore::proj, Rotation, igl::opengl::ViewerCore::rotation_type, igl::opengl::ViewerCore::ROTATION_TYPE_NO_ROTATION, igl::opengl::ViewerCore::ROTATION_TYPE_TRACKBALL, igl::opengl::ViewerCore::ROTATION_TYPE_TWO_AXIS_VALUATOR_FIXED_UP, igl::trackball(), igl::opengl::ViewerCore::trackball_angle, Translation, igl::two_axis_valuator_fixed_up(), igl::unproject(), igl::opengl::ViewerCore::view, igl::opengl::ViewerCore::viewport, and Zoom.

Referenced by glfw_mouse_move(), and mouse_move().

Here is the call graph for this function:

Here is the caller graph for this function:

mouse_scroll()

IGL_INLINE bool igl::opengl::glfw::Viewer::mouse_scroll

(

float

delta_y

)

  {
    scroll_position += delta_y;
 
    if (callback_mouse_scroll)
      if (callback_mouse_scroll(*this,delta_y))
        return true;
 
    for (unsigned int i = 0; i<plugins.size(); ++i)
      if (plugins[i]->mouse_scroll(delta_y))
        return true;
 
    // Only zoom if there's actually a change
    if(delta_y != 0)
    {
      float mult = (1.0+((delta_y>0)?1.:-1.)*0.05);
      const float min_zoom = 0.1f;
      core.camera_zoom = (core.camera_zoom * mult > min_zoom ? core.camera_zoom * mult : min_zoom);
    }
    return true;
  }

References callback_mouse_scroll, igl::opengl::ViewerCore::camera_zoom, core, mouse_scroll(), plugins, and scroll_position.

Referenced by glfw_mouse_scroll(), and mouse_scroll().

Here is the call graph for this function:

Here is the caller graph for this function:

mouse_up()

IGL_INLINE bool igl::opengl::glfw::Viewer::mouse_up	(	MouseButton	button,
		int	modifier
	)

  {
    down = false;
 
    if (callback_mouse_up)
      if (callback_mouse_up(*this,static_cast<int>(button),modifier))
        return true;
 
    for (unsigned int i = 0; i<plugins.size(); ++i)
      if(plugins[i]->mouse_up(static_cast<int>(button),modifier))
          return true;
 
    mouse_mode = MouseMode::None;
 
    return true;
  }

References callback_mouse_up, down, mouse_mode, mouse_up(), None, and plugins.

Referenced by glfw_mouse_press(), and mouse_up().

Here is the call graph for this function:

Here is the caller graph for this function:

open_dialog_load_mesh()

IGL_INLINE void igl::opengl::glfw::Viewer::open_dialog_load_mesh

(

)

  {
    std::string fname = igl::file_dialog_open();
 
    if (fname.length() == 0)
      return;
 
    this->load_mesh_from_file(fname.c_str());
  }

References igl::file_dialog_open(), and load_mesh_from_file().

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

open_dialog_save_mesh()

IGL_INLINE void igl::opengl::glfw::Viewer::open_dialog_save_mesh

(

)

  {
    std::string fname = igl::file_dialog_save();
 
    if(fname.length() == 0)
      return;
 
    this->save_mesh_to_file(fname.c_str());
  }

References igl::file_dialog_save(), and save_mesh_to_file().

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

post_resize()

IGL_INLINE void igl::opengl::glfw::Viewer::post_resize	(	int	w,
		int	h
	)

  {
    core.viewport = Eigen::Vector4f(0,0,w,h);
    for (unsigned int i = 0; i<plugins.size(); ++i)
    {
      plugins[i]->post_resize(w, h);
    }
  }

References core, plugins, and igl::opengl::ViewerCore::viewport.

Referenced by draw(), glfw_window_size(), and resize().

Here is the caller graph for this function:

resize()

IGL_INLINE void igl::opengl::glfw::Viewer::resize	(	int	w,
		int	h
	)

  {
    if (window) {
      glfwSetWindowSize(window, w/highdpi, h/highdpi);
    }
    post_resize(w, h);
  }

References highdpi, post_resize(), and window.

Here is the call graph for this function:

save_mesh_to_file()

IGL_INLINE bool igl::opengl::glfw::Viewer::save_mesh_to_file

(

const std::string &

mesh_file_name

)

  {
    // first try to load it with a plugin
    for (unsigned int i = 0; i<plugins.size(); ++i)
      if (plugins[i]->save(mesh_file_name_string))
        return true;
 
    size_t last_dot = mesh_file_name_string.rfind('.');
    if (last_dot == std::string::npos)
    {
      // No file type determined
      std::cerr<<"Error: No file extension found in "<<
        mesh_file_name_string<<std::endl;
      return false;
    }
    std::string extension = mesh_file_name_string.substr(last_dot+1);
    if (extension == "off" || extension =="OFF")
    {
      return igl::writeOFF(
        mesh_file_name_string,data().V,data().F);
    }
    else if (extension == "obj" || extension =="OBJ")
    {
      Eigen::MatrixXd corner_normals;
      Eigen::MatrixXi fNormIndices;
 
      Eigen::MatrixXd UV_V;
      Eigen::MatrixXi UV_F;
 
      return igl::writeOBJ(mesh_file_name_string,
          data().V,
          data().F,
          corner_normals, fNormIndices, UV_V, UV_F);
    }
    else
    {
      // unrecognized file type
      printf("Error: %s is not a recognized file type.\n",extension.c_str());
      return false;
    }
    return true;
  }

References data(), plugins, save(), igl::writeOBJ(), and igl::writeOFF().

Referenced by open_dialog_save_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

save_scene() [1/2]

IGL_INLINE bool igl::opengl::glfw::Viewer::save_scene

(

)

  {
    std::string fname = igl::file_dialog_save();
    if (fname.length() == 0)
      return false;
    return save_scene(fname);
  }

References igl::file_dialog_save(), and save_scene().

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and save_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

save_scene() [2/2]

IGL_INLINE bool igl::opengl::glfw::Viewer::save_scene

(

std::string

fname

)

  {
    igl::serialize(core,"Core",fname.c_str(),true);
    igl::serialize(data(),"Data",fname.c_str());
 
    return true;
  }

References core, data(), and igl::serialize().

Here is the call graph for this function:

shutdown_plugins()

IGL_INLINE void igl::opengl::glfw::Viewer::shutdown_plugins

(

)

  {
    for (unsigned int i = 0; i<plugins.size(); ++i)
    {
      plugins[i]->shutdown();
    }
  }

References plugins.

Referenced by launch_shut().

Here is the caller graph for this function:

snap_to_canonical_quaternion()

IGL_INLINE void igl::opengl::glfw::Viewer::snap_to_canonical_quaternion

(

)

  {
    Eigen::Quaternionf snapq = this->core.trackball_angle;
    igl::snap_to_canonical_view_quat(snapq,1.0f,this->core.trackball_angle);
  }

References core, igl::snap_to_canonical_view_quat(), and igl::opengl::ViewerCore::trackball_angle.

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and key_pressed().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

callback_init

std::function<bool(Viewer& viewer)> igl::opengl::glfw::Viewer::callback_init

Referenced by Viewer(), and init().

callback_init_data

void* igl::opengl::glfw::Viewer::callback_init_data

Referenced by Viewer().

callback_key_down

std::function<bool(Viewer& viewer, unsigned int key, int modifiers)> igl::opengl::glfw::Viewer::callback_key_down

Referenced by Viewer(), and key_down().

callback_key_down_data

void* igl::opengl::glfw::Viewer::callback_key_down_data

Referenced by Viewer().

callback_key_pressed

std::function<bool(Viewer& viewer, unsigned int key, int modifiers)> igl::opengl::glfw::Viewer::callback_key_pressed

Referenced by key_pressed().

callback_key_pressed_data

void* igl::opengl::glfw::Viewer::callback_key_pressed_data

callback_key_up

std::function<bool(Viewer& viewer, unsigned int key, int modifiers)> igl::opengl::glfw::Viewer::callback_key_up

Referenced by Viewer(), and key_up().

callback_key_up_data

void* igl::opengl::glfw::Viewer::callback_key_up_data

Referenced by Viewer().

callback_mouse_down

std::function<bool(Viewer& viewer, int button, int modifier)> igl::opengl::glfw::Viewer::callback_mouse_down

Referenced by Viewer(), and mouse_down().

callback_mouse_down_data

void* igl::opengl::glfw::Viewer::callback_mouse_down_data

Referenced by Viewer().

callback_mouse_move

std::function<bool(Viewer& viewer, int mouse_x, int mouse_y)> igl::opengl::glfw::Viewer::callback_mouse_move

Referenced by Viewer(), and mouse_move().

callback_mouse_move_data

void* igl::opengl::glfw::Viewer::callback_mouse_move_data

Referenced by Viewer().

callback_mouse_scroll

std::function<bool(Viewer& viewer, float delta_y)> igl::opengl::glfw::Viewer::callback_mouse_scroll

Referenced by Viewer(), and mouse_scroll().

callback_mouse_scroll_data

void* igl::opengl::glfw::Viewer::callback_mouse_scroll_data

Referenced by Viewer().

callback_mouse_up

std::function<bool(Viewer& viewer, int button, int modifier)> igl::opengl::glfw::Viewer::callback_mouse_up

Referenced by Viewer(), and mouse_up().

callback_mouse_up_data

void* igl::opengl::glfw::Viewer::callback_mouse_up_data

Referenced by Viewer().

callback_post_draw

std::function<bool(Viewer& viewer)> igl::opengl::glfw::Viewer::callback_post_draw

Referenced by Viewer(), and draw().

callback_post_draw_data

void* igl::opengl::glfw::Viewer::callback_post_draw_data

Referenced by Viewer().

callback_pre_draw

std::function<bool(Viewer& viewer)> igl::opengl::glfw::Viewer::callback_pre_draw

Referenced by Viewer(), and draw().

callback_pre_draw_data

void* igl::opengl::glfw::Viewer::callback_pre_draw_data

Referenced by Viewer().

core

ViewerCore igl::opengl::glfw::Viewer::core

Referenced by draw(), igl::opengl::glfw::imgui::ImGuiMenu::draw_text(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), init(), key_pressed(), launch_init(), launch_rendering(), launch_shut(), load_mesh_from_file(), load_scene(), mouse_down(), mouse_move(), mouse_scroll(), post_resize(), save_scene(), and snap_to_canonical_quaternion().

current_mouse_x

int igl::opengl::glfw::Viewer::current_mouse_x

Referenced by mouse_down(), and mouse_move().

current_mouse_y

int igl::opengl::glfw::Viewer::current_mouse_y

Referenced by mouse_down(), and mouse_move().

data_list

std::vector<ViewerData> igl::opengl::glfw::Viewer::data_list

Referenced by Viewer(), append_mesh(), data(), draw(), igl::opengl::glfw::imgui::ImGuiMenu::draw_labels_window(), erase_mesh(), key_pressed(), launch_shut(), and mesh_index().

down

bool igl::opengl::glfw::Viewer::down

Referenced by Viewer(), mouse_down(), mouse_move(), and mouse_up().

down_mouse_x

int igl::opengl::glfw::Viewer::down_mouse_x

Referenced by mouse_down(), and mouse_move().

down_mouse_y

int igl::opengl::glfw::Viewer::down_mouse_y

Referenced by mouse_down(), and mouse_move().

down_mouse_z

float igl::opengl::glfw::Viewer::down_mouse_z

Referenced by mouse_down(), and mouse_move().

down_rotation

Eigen::Quaternionf igl::opengl::glfw::Viewer::down_rotation

Referenced by mouse_down(), and mouse_move().

down_translation

Eigen::Vector3f igl::opengl::glfw::Viewer::down_translation

Referenced by mouse_down(), and mouse_move().

hack_never_moved

bool igl::opengl::glfw::Viewer::hack_never_moved

Referenced by Viewer(), and mouse_move().

mouse_mode

enum igl::opengl::glfw::Viewer::MouseMode igl::opengl::glfw::Viewer::mouse_mode

Referenced by mouse_down(), mouse_move(), and mouse_up().

next_data_id

int igl::opengl::glfw::Viewer::next_data_id

Referenced by append_mesh().

plugins

std::vector<ViewerPlugin*> igl::opengl::glfw::Viewer::plugins

Referenced by draw(), init_plugins(), key_down(), key_pressed(), key_up(), load_mesh_from_file(), mouse_down(), mouse_move(), mouse_scroll(), mouse_up(), post_resize(), save_mesh_to_file(), and shutdown_plugins().

scroll_position

float igl::opengl::glfw::Viewer::scroll_position

Referenced by Viewer(), and mouse_scroll().

selected_data_index

size_t igl::opengl::glfw::Viewer::selected_data_index

Referenced by append_mesh(), data(), erase_mesh(), and key_pressed().

window

GLFWwindow* igl::opengl::glfw::Viewer::window

Referenced by Viewer(), draw(), igl::opengl::glfw::imgui::ImGuiMenu::init(), igl::opengl::glfw::imgui::ImGuiMenu::key_down(), igl::opengl::glfw::imgui::ImGuiMenu::key_up(), launch_init(), launch_rendering(), launch_shut(), igl::opengl::glfw::imgui::ImGuiMenu::mouse_down(), igl::opengl::glfw::imgui::ImGuiMenu::mouse_scroll(), and resize().

---

The documentation for this class was generated from the following files:

• src/libigl/igl/opengl/glfw/Viewer.h
• src/libigl/igl/opengl/glfw/Viewer.cpp