songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cgal/Basic_viewer/include/CGAL/Qt/Basic_viewer.h

1873 lines
75 KiB
C++
Raw Blame History

// Copyright (c) 2018 GeometryFactory Sarl (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
// Mostafa Ashraf <mostaphaashraf1996@gmail.com>
#ifndef CGAL_QT_BASIC_VIEWER_H
#define CGAL_QT_BASIC_VIEWER_H
#ifndef CGAL_USE_BASIC_VIEWER_QT
#define CGAL_USE_BASIC_VIEWER_QT 1
#endif // CGAL_USE_BASIC_VIEWER_QT
#if defined(CGAL_USE_BASIC_VIEWER_QT)
// TODO #include <CGAL/license/GraphicsView.h>
#include <CGAL/Graphics_scene.h>
#include <cstring>
#include <iostream>
#include <string>
#include <tuple>
#ifdef __GNUC__
#if __GNUC__ >= 9
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif
#endif
#include <QApplication>
#include <QKeyEvent>
#include <CGAL/Qt/manipulatedFrame.h>
#include <CGAL/Qt/qglviewer.h>
#include <QOpenGLBuffer>
#include <QOpenGLShaderProgram>
#include <QOpenGLVertexArrayObject>
#ifdef __GNUC__
#if __GNUC__ >= 9
#pragma GCC diagnostic pop
#endif
#endif
#include <cfloat>
#include <cstdlib>
#include <vector>
#include <CGAL/Basic_shaders.h>
#include <CGAL/Qt/CreateOpenGLContext.h>
#include <CGAL/Qt/constraint.h>
#include <CGAL/Qt/init_ogl_context.h>
#include <CGAL/assertions.h>
#define CGAL_BASIC_VIEWER_INIT_SIZE_X 500
#define CGAL_BASIC_VIEWER_INIT_SIZE_Y 450
namespace CGAL {
namespace Qt {
//------------------------------------------------------------------------------
class Basic_viewer : public CGAL::QGLViewer
{
public:
using BufferType = float;
typedef CGAL::Exact_predicates_inexact_constructions_kernel Local_kernel;
typedef Local_kernel::Point_3 Local_point;
typedef Local_kernel::Vector_3 Local_vector;
using GS = Graphics_scene;
// Constructor/Destructor
Basic_viewer(QWidget* parent,
const Graphics_scene& buf,
const char* title = "",
bool draw_vertices = false,
bool draw_edges = true,
bool draw_faces = true,
bool use_default_color = false,
bool inverse_normal = false,
bool draw_rays = true,
bool draw_lines = true,
bool draw_text = true,
bool no_2D_mode = false)
: CGAL::QGLViewer(parent)
, m_scene(buf)
, m_draw_vertices(draw_vertices)
, m_draw_edges(draw_edges)
, m_draw_rays(draw_rays)
, m_draw_lines(draw_lines)
, m_draw_faces(draw_faces)
, m_draw_text(draw_text)
, m_draw_normals(false)
, m_draw_cylinder_edge(false)
, m_draw_sphere_vertex(false)
, m_draw_mesh_triangles(false)
, m_flat_shading(true)
, m_use_default_color(use_default_color)
, m_use_default_color_normal(false)
, m_display_face_normal(false)
, m_inverse_normal(inverse_normal)
, m_no_2D_mode(no_2D_mode)
, m_geometry_feature_enabled(true)
, m_prev_scene_empty(true)
, m_default_color_normal(220, 60, 20)
, m_ambient_color(0.6f, 0.5f, 0.5f, 0.5f)
, m_are_buffers_initialized(false) {
// Define 'Control+Q' as the new exit shortcut (default was 'Escape')
setShortcut(qglviewer::EXIT_VIEWER, ::Qt::CTRL, ::Qt::Key_Q);
// Add custom key description (see keyPressEvent).
setKeyDescription(::Qt::Key_C, "Switch clipping plane display mode");
setKeyDescription(::Qt::AltModifier, ::Qt::Key_C, "Toggle clipping plane rendering on/off");
setKeyDescription(::Qt::Key_E, "Toggles edges display");
setKeyDescription(::Qt::Key_M, "Toggles mono color");
setKeyDescription(::Qt::Key_N, "Inverse direction of normals");
setKeyDescription(::Qt::Key_S, "Switch between flat/Gouraud shading display");
setKeyDescription(::Qt::Key_T, "Toggles text display");
setKeyDescription(::Qt::Key_U, "Move camera direction upside down");
setKeyDescription(::Qt::Key_V, "Toggles vertices display");
setKeyDescription(::Qt::Key_W, "Toggles faces display");
setKeyDescription(::Qt::Key_Plus, "Increase size of edges");
setKeyDescription(::Qt::Key_Minus, "Decrease size of edges");
setKeyDescription(::Qt::ControlModifier, ::Qt::Key_Plus, "Increase size of vertices");
setKeyDescription(::Qt::ControlModifier, ::Qt::Key_Minus, "Decrease size of vertices");
setKeyDescription(::Qt::Key_PageDown, "Increase light (all colors, use shift/alt/ctrl for one rgb component)");
setKeyDescription(::Qt::Key_PageUp, "Decrease light (all colors, use shift/alt/ctrl for one rgb component)");
setKeyDescription(::Qt::Key_O, "Toggles 2D mode only");
setKeyDescription(::Qt::ControlModifier, ::Qt::Key_V, "Toggle vertices display as sphere");
setKeyDescription(::Qt::ControlModifier, ::Qt::Key_E, "Toggle edges display as cylinder");
setKeyDescription(::Qt::ControlModifier, ::Qt::Key_N, "Toggle normals display");
setKeyDescription(::Qt::ShiftModifier, ::Qt::Key_N, "Toggle face/vertex normals for normal display");
setKeyDescription(::Qt::ControlModifier, ::Qt::Key_M, "Toggle normals mono color");
setKeyDescription(::Qt::ControlModifier, ::Qt::Key_T, "Toggle triangles display");
setKeyDescription(::Qt::Key_F2, "Take a screenshot");
// Add custom mouse description
setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::LeftButton,
"Rotate the clipping plane when enabled");
setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::RightButton,
"Translate the clipping plane when enabled");
setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::MiddleButton,
"Control the clipping plane transparency when enabled");
setMouseBinding(::Qt::ControlModifier, ::Qt::LeftButton, qglviewer::FRAME, qglviewer::NO_MOUSE_ACTION);
setMouseBinding(::Qt::ControlModifier, ::Qt::RightButton, qglviewer::FRAME, qglviewer::NO_MOUSE_ACTION);
setMouseBinding(::Qt::ControlModifier, ::Qt::MiddleButton, qglviewer::FRAME, qglviewer::NO_MOUSE_ACTION);
setWheelBinding(::Qt::ControlModifier, qglviewer::FRAME, qglviewer::NO_MOUSE_ACTION);
setMouseBinding(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::LeftButton, qglviewer::FRAME, qglviewer::ROTATE);
setMouseBinding(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::RightButton, qglviewer::FRAME, qglviewer::TRANSLATE);
setMouseBinding(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::MiddleButton, qglviewer::FRAME, qglviewer::ZOOM);
setWheelBinding(::Qt::Key_C, ::Qt::ControlModifier, qglviewer::FRAME, qglviewer::ZOOM);
if(title[0] == 0)
setWindowTitle("CGAL Basic Viewer");
else
setWindowTitle(title);
resize(CGAL_BASIC_VIEWER_INIT_SIZE_X, CGAL_BASIC_VIEWER_INIT_SIZE_Y);
}
~Basic_viewer() {
makeCurrent();
for(unsigned int i = 0; i < NB_GL_BUFFERS; ++i)
buffers[i].destroy();
for(unsigned int i = 0; i < NB_VAO_BUFFERS; ++i)
vao[i].destroy();
Q_FOREACH(QOpenGLShader* shader, rendering_program_p_l.shaders())
delete shader;
Q_FOREACH(QOpenGLShader* shader, rendering_program_line.shaders())
delete shader;
Q_FOREACH(QOpenGLShader* shader, rendering_program_face.shaders())
delete shader;
Q_FOREACH(QOpenGLShader* shader, rendering_program_clipping_plane.shaders())
delete shader;
Q_FOREACH(QOpenGLShader* shader, rendering_program_sphere.shaders())
delete shader;
Q_FOREACH(QOpenGLShader* shader, rendering_program_cylinder.shaders())
delete shader;
Q_FOREACH(QOpenGLShader* shader, rendering_program_normal.shaders())
delete shader;
Q_FOREACH(QOpenGLShader* shader, rendering_program_triangle.shaders())
delete shader;
delete m_frame_plane;
}
/*****SETTERS*****/
inline void size_vertices(float s) { m_size_vertices = s; }
inline void size_edges(float s) { m_size_edges = s; }
inline void size_rays(float s) { m_size_rays = s; }
inline void size_lines(float s) { m_size_lines = s; }
inline void draw_vertices(bool b) { m_draw_vertices = b; }
inline void draw_edges(bool b) { m_draw_edges = b; }
inline void draw_rays(bool b) { m_draw_rays = b; }
inline void draw_lines(bool b) { m_draw_lines = b; }
inline void draw_faces(bool b) { m_draw_faces = b; }
inline void draw_text(bool b) { m_draw_text = b; }
inline void draw_mesh_triangles(bool b) { m_draw_mesh_triangles = b; }
inline void use_default_color(bool b) { m_use_default_color = b; }
inline void use_default_color_normal(bool b) { m_use_default_color_normal = b; }
inline void flat_shading(bool b) { m_flat_shading = b; }
inline void reverse_normal(bool b) { m_inverse_normal = b; }
inline void default_color_normals(const CGAL::IO::Color& c) { m_default_color_normal = c; }
inline void normal_height_factor(float h) { m_height_factor_normals = h; }
inline void toggle_draw_vertices() { m_draw_vertices = !m_draw_vertices; }
inline void toggle_draw_edges() { m_draw_edges = !m_draw_edges; }
inline void toggle_draw_rays() { m_draw_rays = !m_draw_rays; }
inline void toggle_draw_lines() { m_draw_lines = !m_draw_lines; }
inline void toggle_draw_faces() { m_draw_faces = !m_draw_faces; }
inline void toggle_draw_text() { m_draw_text = !m_draw_text; }
inline void toggle_use_default_color() { m_use_default_color = !m_use_default_color; }
inline void toggle_use_normal_default_color() { m_use_default_color_normal = !m_use_default_color_normal; }
inline void toggle_flat_shading() { m_flat_shading = !m_flat_shading; }
inline void toggle_reverse_normal() { m_inverse_normal = !m_inverse_normal; }
/*****************/
/*****GETTERS*****/
inline bool draw_vertices() const { return m_draw_vertices; }
inline bool draw_edges() const { return m_draw_edges; }
inline bool draw_rays() const { return m_draw_rays; }
inline bool draw_lines() const { return m_draw_lines; }
inline bool draw_faces() const { return m_draw_faces; }
inline bool draw_text() const { return m_draw_text; }
inline bool use_default_color() const { return m_use_default_color; }
inline bool reverse_normal() const { return m_inverse_normal; }
inline bool flat_shading() const { return m_flat_shading; }
Local_kernel::Plane_3 clipping_plane() const {
CGAL::qglviewer::Vec n = m_frame_plane->inverseTransformOf(CGAL::qglviewer::Vec(0.f, 0.f, 1.f));
const CGAL::qglviewer::Vec& pos = m_frame_plane->position();
return Local_kernel::Plane_3(n[0], n[1], n[2], -n * pos);
}
bool clipping_plane_enabled() const { return (m_use_clipping_plane != CLIPPING_PLANE_OFF); }
const Graphics_scene& graphics_scene() const { return m_scene; }
/*****************/
virtual void redraw() {
initialize_buffers();
update();
if(m_prev_scene_empty) {
initialize_vertices_and_edges_size();
}
m_prev_scene_empty = (m_scene.empty());
}
void reverse_all_normals() {
m_inverse_normal = !m_inverse_normal;
m_scene.reverse_all_normals();
}
// Returns true if the data structure lies on a plane
bool is_two_dimensional() const { return !m_no_2D_mode && m_scene.is_two_dimensional(); }
virtual void draw() {
glEnable(GL_DEPTH_TEST);
QMatrix4x4 clipping_mMatrix;
clipping_mMatrix.setToIdentity();
for(int i = 0; i < 16; i++) {
clipping_mMatrix.data()[i] = m_frame_plane->matrix()[i];
}
QVector4D clipPlane = clipping_mMatrix * QVector4D(0.0, 0.0, 1.0, 0.0);
QVector4D plane_point = clipping_mMatrix * QVector4D(0, 0, 0, 1);
if(!m_are_buffers_initialized) {
initialize_buffers();
}
QVector3D color;
attrib_buffers(this);
if(m_draw_vertices) {
if(m_draw_sphere_vertex && m_geometry_feature_enabled) {
auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
rendering_program_sphere.bind();
if(m_use_default_color) {
auto vertex_color = m_scene.get_default_color_point();
color = QVector3D((double)vertex_color.red() / (double)255, (double)vertex_color.green() / (double)255,
(double)vertex_color.blue() / (double)255);
rendering_program_sphere.setUniformValue("u_DefaultColor", color);
rendering_program_sphere.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
} else {
rendering_program_sphere.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
}
rendering_program_sphere.setUniformValue("u_Radius",
static_cast<GLfloat>(sceneRadius() * m_size_vertices * 0.002));
rendering_program_sphere.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_sphere.setUniformValue("u_PointPlane", plane_point);
rendering_program_sphere.setUniformValue("u_RenderingMode", rendering_mode);
vao[VAO_POINTS].bind();
glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_POINTS)));
};
enum {
DRAW_ALL = -1, // draw all
DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY) {
renderer(DRAW_INSIDE_ONLY);
} else {
renderer(DRAW_ALL);
}
rendering_program_sphere.release();
} else {
auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
rendering_program_p_l.bind();
if(m_use_default_color) {
auto vertex_color = m_scene.get_default_color_point();
color = QVector3D((double)vertex_color.red() / (double)255, (double)vertex_color.green() / (double)255,
(double)vertex_color.blue() / (double)255);
rendering_program_p_l.setUniformValue("u_DefaultColor", color);
rendering_program_p_l.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
} else {
rendering_program_p_l.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
}
rendering_program_p_l.setUniformValue("u_PointSize", GLfloat(m_size_vertices));
rendering_program_p_l.setUniformValue("u_IsOrthographic", GLint(is_two_dimensional()));
rendering_program_p_l.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_p_l.setUniformValue("u_PointPlane", plane_point);
rendering_program_p_l.setUniformValue("u_RenderingMode", rendering_mode);
vao[VAO_POINTS].bind();
glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_POINTS)));
};
enum {
DRAW_ALL = -1, // draw all
DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY) {
renderer(DRAW_INSIDE_ONLY);
} else {
renderer(DRAW_ALL);
}
rendering_program_p_l.release();
}
}
if(m_draw_edges && !m_draw_mesh_triangles) {
if(m_draw_cylinder_edge && m_geometry_feature_enabled) {
auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
rendering_program_cylinder.bind();
if(m_use_default_color) {
auto edge_color = m_scene.get_default_color_segment();
color = QVector3D((double)edge_color.red() / (double)255, (double)edge_color.green() / (double)255,
(double)edge_color.blue() / (double)255);
rendering_program_cylinder.setUniformValue("u_DefaultColor", color);
rendering_program_cylinder.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
} else {
rendering_program_cylinder.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
}
rendering_program_cylinder.setUniformValue("u_Radius",
static_cast<GLfloat>(sceneRadius() * m_size_edges * 0.001));
rendering_program_cylinder.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_cylinder.setUniformValue("u_PointPlane", plane_point);
rendering_program_cylinder.setUniformValue("u_RenderingMode", rendering_mode);
vao[VAO_SEGMENTS].bind();
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_SEGMENTS)));
};
enum {
DRAW_ALL = -1, // draw all
DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY) {
renderer(DRAW_INSIDE_ONLY);
} else {
renderer(DRAW_ALL);
}
rendering_program_cylinder.release();
} else {
auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
QVector2D viewport = {CGAL_BASIC_VIEWER_INIT_SIZE_X, CGAL_BASIC_VIEWER_INIT_SIZE_Y};
rendering_program_line.bind();
if(m_use_default_color) {
auto edge_color = m_scene.get_default_color_segment();
color = QVector3D((double)edge_color.red() / (double)255, (double)edge_color.green() / (double)255,
(double)edge_color.blue() / (double)255);
rendering_program_line.setUniformValue("u_DefaultColor", color);
rendering_program_line.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
} else {
rendering_program_line.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
}
rendering_program_line.setUniformValue("u_PointSize", static_cast<GLfloat>(m_size_edges));
rendering_program_line.setUniformValue("u_IsOrthographic", static_cast<GLint>(is_two_dimensional()));
rendering_program_line.setUniformValue("u_Viewport", viewport);
rendering_program_line.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_line.setUniformValue("u_PointPlane", plane_point);
rendering_program_line.setUniformValue("u_RenderingMode", rendering_mode);
vao[VAO_SEGMENTS].bind();
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_SEGMENTS)));
};
enum {
DRAW_ALL = -1, // draw all
DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY) {
renderer(DRAW_INSIDE_ONLY);
} else {
renderer(DRAW_ALL);
}
rendering_program_line.release();
}
}
if(m_draw_rays) {
auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
rendering_program_p_l.bind();
if(m_use_default_color) {
auto ray_color = m_scene.get_default_color_ray();
color = QVector3D((double)ray_color.red() / (double)255, (double)ray_color.green() / (double)255,
(double)ray_color.blue() / (double)255);
rendering_program_p_l.setUniformValue("u_DefaultColor", color);
rendering_program_p_l.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
} else {
rendering_program_p_l.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
}
rendering_program_p_l.setUniformValue("u_PointSize", GLfloat(m_size_rays));
rendering_program_p_l.setUniformValue("u_IsOrthographic", GLint(is_two_dimensional()));
rendering_program_p_l.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_p_l.setUniformValue("u_PointPlane", plane_point);
rendering_program_p_l.setUniformValue("u_RenderingMode", rendering_mode);
vao[VAO_RAYS].bind();
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_RAYS)));
};
enum {
DRAW_ALL = -1, // draw all
DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY) {
renderer(DRAW_INSIDE_ONLY);
} else {
renderer(DRAW_ALL);
}
rendering_program_p_l.release();
}
if(m_draw_lines) {
auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
rendering_program_p_l.bind();
if(m_use_default_color) {
auto line_color = m_scene.get_default_color_line();
color = QVector3D((double)line_color.red() / (double)255, (double)line_color.green() / (double)255,
(double)line_color.blue() / (double)255);
rendering_program_p_l.setUniformValue("u_DefaultColor", color);
rendering_program_p_l.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
} else {
rendering_program_p_l.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
}
rendering_program_p_l.setUniformValue("u_PointSize", GLfloat(m_size_lines));
rendering_program_p_l.setUniformValue("u_IsOrthographic", GLint(is_two_dimensional()));
rendering_program_p_l.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_p_l.setUniformValue("u_PointPlane", plane_point);
rendering_program_p_l.setUniformValue("u_RenderingMode", rendering_mode);
vao[VAO_LINES].bind();
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_LINES)));
};
enum {
DRAW_ALL = -1, // draw all
DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY) {
renderer(DRAW_INSIDE_ONLY);
} else {
renderer(DRAW_ALL);
}
rendering_program_p_l.release();
}
// Fix Z-fighting by drawing faces at a depth
GLfloat offset_factor;
GLfloat offset_units;
if(is_two_dimensional()) {
glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &offset_factor);
glGetFloatv(GL_POLYGON_OFFSET_UNITS, &offset_units);
glPolygonOffset(0.1f, 0.9f);
}
if(m_draw_faces) {
// reference: https://stackoverflow.com/questions/37780345/opengl-how-to-create-order-independent-transparency
// rendering_mode == -1: draw all as solid;
// rendering_mode == 0: draw solid only;
// rendering_mode == 1: draw transparent only;
auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(2.0, 2.0);
glDepthFunc(GL_LESS);
rendering_program_face.bind();
if(m_use_default_color) {
auto face_color = m_scene.get_default_color_face();
color = QVector3D((double)face_color.red() / (double)255, (double)face_color.green() / (double)255,
(double)face_color.blue() / (double)255);
rendering_program_face.setUniformValue("u_DefaultColor", color);
rendering_program_face.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
} else {
rendering_program_face.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
}
rendering_program_face.setUniformValue("u_RenderingMode", rendering_mode);
rendering_program_face.setUniformValue("u_RenderingTransparency", clipping_plane_rendering_transparency);
rendering_program_face.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_face.setUniformValue("u_PointPlane", plane_point);
vao[VAO_FACES].bind();
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_FACES)));
glDisable(GL_POLYGON_OFFSET_FILL);
};
auto renderer_clipping_plane = [this](bool clipping_plane_rendering) {
if(!isOpenGL_4_3())
return;
if(!clipping_plane_rendering)
return;
// render clipping plane here
rendering_program_clipping_plane.bind();
vao[VAO_CLIPPING_PLANE].bind();
glLineWidth(0.1f);
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>((m_array_for_clipping_plane.size() / 3)));
glLineWidth(1.0f);
vao[VAO_CLIPPING_PLANE].release();
rendering_program_clipping_plane.release();
};
enum {
DRAW_SOLID_ALL = -1, // draw all mesh in solid mode
DRAW_SOLID_HALF, // draw only the mesh inside the clipping plane as solid
DRAW_TRANSPARENT_HALF // draw only the mesh outside the clipping plane as transparent
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_TRANSPARENT_HALF) {
// The z-buffer will prevent transparent objects from being displayed behind other transparent objects.
// Before rendering all transparent objects, disable z-testing first.
// 1. draw solid first
renderer(DRAW_SOLID_HALF);
// 2. draw transparent layer second with back face culling to avoid messy triangles
glDepthMask(false); // disable z-testing
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
renderer(DRAW_TRANSPARENT_HALF);
// 3. draw solid again without culling and blend to make sure the solid mesh is visible
glDepthMask(true); // enable z-testing
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
renderer(DRAW_SOLID_HALF);
// 4. render clipping plane here
renderer_clipping_plane(clipping_plane_rendering);
} else if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_WIRE_HALF ||
m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY)
{
// 1. draw solid HALF
renderer(DRAW_SOLID_HALF);
// 2. render clipping plane here
renderer_clipping_plane(clipping_plane_rendering);
} else {
// 1. draw solid FOR ALL
renderer(DRAW_SOLID_ALL);
}
if(is_two_dimensional())
glPolygonOffset(offset_factor, offset_units);
rendering_program_face.release();
}
if(m_draw_normals) {
auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
rendering_program_normal.bind();
if(m_use_default_color_normal) {
color = QVector3D((double)m_default_color_normal.red() / (double)255,
(double)m_default_color_normal.green() / (double)255,
(double)m_default_color_normal.blue() / (double)255);
rendering_program_normal.setUniformValue("u_DefaultColor", color);
rendering_program_normal.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
} else {
rendering_program_normal.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
}
rendering_program_normal.setUniformValue("u_Factor", static_cast<GLfloat>(m_height_factor_normals));
rendering_program_normal.setUniformValue("u_SceneRadius", static_cast<GLfloat>(sceneRadius()));
if(m_display_face_normal) {
rendering_program_normal.setUniformValue("u_DisplayFaceNormal", static_cast<GLint>(1));
} else {
rendering_program_normal.setUniformValue("u_DisplayFaceNormal", static_cast<GLint>(0));
}
rendering_program_normal.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_normal.setUniformValue("u_PointPlane", plane_point);
rendering_program_normal.setUniformValue("u_RenderingMode", rendering_mode);
vao[VAO_FACES].bind();
glLineWidth(m_size_normals);
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_FACES)));
};
enum {
DRAW_ALL = -1, // draw all
DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY) {
renderer(DRAW_INSIDE_ONLY);
} else {
renderer(DRAW_ALL);
}
rendering_program_normal.release();
}
if(m_draw_mesh_triangles) {
auto renderer = [this, &clipPlane, &plane_point](float rendering_mode) {
rendering_program_triangle.bind();
rendering_program_triangle.setUniformValue("u_RenderingMode", rendering_mode);
rendering_program_triangle.setUniformValue("u_ClipPlane", clipPlane);
rendering_program_triangle.setUniformValue("u_PointPlane", plane_point);
vao[VAO_FACES].bind();
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_FACES)));
};
enum {
DRAW_ALL = -1, // draw all
DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
};
if(m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY) {
renderer(DRAW_INSIDE_ONLY);
} else {
renderer(DRAW_ALL);
}
rendering_program_triangle.release();
}
if(m_draw_text) {
glDisable(GL_LIGHTING);
for(std::size_t i = 0; i < m_scene.m_texts_size(); ++i) {
auto& m_texts_vec = m_scene.get_m_texts();
CGAL::qglviewer::Vec screenPos = camera()->projectedCoordinatesOf(CGAL::qglviewer::Vec(
std::get<0>(m_texts_vec[i]).x(), std::get<0>(m_texts_vec[i]).y(), std::get<0>(m_texts_vec[i]).z()));
drawText((int)screenPos[0], (int)screenPos[1], QString(std::get<1>(m_texts_vec[i]).c_str()));
}
glEnable(GL_LIGHTING);
}
// Multiply matrix to get in the frame coordinate system.
// glMultMatrixd(manipulatedFrame()->matrix()); // Linker error
// Scale down the drawings
// glScalef(0.3f, 0.3f, 0.3f); // Linker error
// Draw an axis using the QGLViewer static function
// drawAxis();
}
protected:
void compile_shaders() {
rendering_program_face.removeAllShaders();
rendering_program_p_l.removeAllShaders();
rendering_program_line.removeAllShaders();
rendering_program_clipping_plane.removeAllShaders();
rendering_program_sphere.removeAllShaders();
rendering_program_cylinder.removeAllShaders();
rendering_program_normal.removeAllShaders();
rendering_program_triangle.removeAllShaders();
// Create the buffers
for(unsigned int i = 0; i < NB_GL_BUFFERS; ++i) {
if(!buffers[i].isCreated() && !buffers[i].create()) {
std::cerr << "VBO Creation number " << i << " FAILED" << std::endl;
}
}
for(unsigned int i = 0; i < NB_VAO_BUFFERS; ++i) {
if(!vao[i].isCreated() && !vao[i].create()) {
std::cerr << "VAO Creation number " << i << " FAILED" << std::endl;
}
}
// Vertices and segments shader
// const char* source_ = isOpenGL_4_3()
// ? VERTEX_SOURCE_P_L
// : VERTEX_SOURCE_P_L_COMP;
const char* source_ = isOpenGL_4_3() ? VERTEX_SOURCE_P_L : VERTEX_SOURCE_P_L_COMP;
QOpenGLShader* vertex_shader_p_l = new QOpenGLShader(QOpenGLShader::Vertex);
if(!vertex_shader_p_l->compileSourceCode(source_)) {
std::cerr << "Compiling vertex source FAILED" << std::endl;
}
source_ = isOpenGL_4_3() ? FRAGMENT_SOURCE_P_L : FRAGMENT_SOURCE_P_L_COMP;
QOpenGLShader* fragment_shader_p_l = new QOpenGLShader(QOpenGLShader::Fragment);
if(!fragment_shader_p_l->compileSourceCode(source_)) {
std::cerr << "Compiling fragment source FAILED" << std::endl;
}
if(!rendering_program_p_l.addShader(vertex_shader_p_l)) {
std::cerr << "adding vertex shader FAILED" << std::endl;
}
if(!rendering_program_p_l.addShader(fragment_shader_p_l)) {
std::cerr << "adding fragment shader FAILED" << std::endl;
}
if(!rendering_program_p_l.link()) {
std::cerr << "linking Program FAILED" << std::endl;
}
// Faces shader
source_ = isOpenGL_4_3() ? VERTEX_SOURCE_COLOR : VERTEX_SOURCE_COLOR_COMP;
QOpenGLShader* vertex_shader_face = new QOpenGLShader(QOpenGLShader::Vertex);
if(!vertex_shader_face->compileSourceCode(source_)) {
std::cerr << "Compiling vertex source FAILED" << std::endl;
}
source_ = isOpenGL_4_3() ? FRAGMENT_SOURCE_COLOR : FRAGMENT_SOURCE_COLOR_COMP;
QOpenGLShader* fragment_shader_face = new QOpenGLShader(QOpenGLShader::Fragment);
if(!fragment_shader_face->compileSourceCode(source_)) {
std::cerr << "Compiling fragment source FAILED" << std::endl;
}
if(!rendering_program_face.addShader(vertex_shader_face)) {
std::cerr << "adding vertex shader FAILED" << std::endl;
}
if(!rendering_program_face.addShader(fragment_shader_face)) {
std::cerr << "adding fragment shader FAILED" << std::endl;
}
if(!rendering_program_face.link()) {
std::cerr << "linking Program FAILED" << std::endl;
}
if(isOpenGL_4_3()) {
// clipping plane shader
source_ = VERTEX_SOURCE_CLIPPING_PLANE;
QOpenGLShader* vertex_shader_clipping_plane = new QOpenGLShader(QOpenGLShader::Vertex);
if(!vertex_shader_clipping_plane->compileSourceCode(source_)) {
std::cerr << "Compiling vertex source for clipping plane FAILED" << std::endl;
}
source_ = FRAGMENT_SOURCE_CLIPPING_PLANE;
QOpenGLShader* fragment_shader_clipping_plane = new QOpenGLShader(QOpenGLShader::Fragment);
if(!fragment_shader_clipping_plane->compileSourceCode(source_)) {
std::cerr << "Compiling fragment source for clipping plane FAILED" << std::endl;
}
if(!rendering_program_clipping_plane.addShader(vertex_shader_clipping_plane)) {
std::cerr << "Adding vertex shader for clipping plane FAILED" << std::endl;
}
if(!rendering_program_clipping_plane.addShader(fragment_shader_clipping_plane)) {
std::cerr << "Adding fragment shader for clipping plane FAILED" << std::endl;
}
if(!rendering_program_clipping_plane.link()) {
std::cerr << "Linking Program for clipping plane FAILED" << std::endl;
}
}
// source_ = isOpenGL_4_3()
// ? VERTEX_SOURCE_CLIPPING_PLANE
// : vertex_source_clipping_plane_comp;
// QOpenGLShader *vertex_shader_clipping_plane = new QOpenGLShader(QOpenGLShader::Vertex);
// if (!vertex_shader_clipping_plane->compileSourceCode(source_))
// { std::cerr << "Compiling vertex source for clipping plane FAILED" << std::endl; }
// source_ = isOpenGL_4_3()
// ? FRAGMENT_SOURCE_CLIPPING_PLANE
// : fragment_source_clipping_plane_comp;
// QOpenGLShader *fragment_shader_clipping_plane = new QOpenGLShader(QOpenGLShader::Fragment);
// if (!fragment_shader_clipping_plane->compileSourceCode(source_))
// { std::cerr << "Compiling fragment source for clipping plane FAILED" << std::endl; }
// if (!rendering_program_clipping_plane.addShader(vertex_shader_clipping_plane))
// { std::cerr << "Adding vertex shader for clipping plane FAILED" << std::endl;}
// if (!rendering_program_clipping_plane.addShader(fragment_shader_clipping_plane))
// { std::cerr << "Adding fragment shader for clipping plane FAILED" << std::endl; }
// if (!rendering_program_clipping_plane.link())
// { std::cerr << "Linking Program for clipping plane FAILED" << std::endl; }
// Sphere shader
if(isOpenGL_4_3()) {
source_ = VERTEX_SOURCE_SHAPE;
QOpenGLShader* vertex_shader_sphere = new QOpenGLShader(QOpenGLShader::Vertex);
if(!vertex_shader_sphere->compileSourceCode(source_)) {
std::cerr << "Compiling vertex source for sphere FAILED" << std::endl;
}
source_ = GEOMETRY_SOURCE_SPHERE;
QOpenGLShader* geometry_shader_sphere = new QOpenGLShader(QOpenGLShader::Geometry);
if(!geometry_shader_sphere->compileSourceCode(source_)) {
std::cerr << "Compiling geometry source for sphere FAILED" << std::endl;
}
source_ = FRAGMENT_SOURCE_P_L;
QOpenGLShader* fragment_shader_sphere = new QOpenGLShader(QOpenGLShader::Fragment);
if(!fragment_shader_sphere->compileSourceCode(source_)) {
std::cerr << "Compiling fragment source for sphere FAILED" << std::endl;
}
if(!rendering_program_sphere.addShader(vertex_shader_sphere)) {
std::cerr << "Adding vertex shader for sphere FAILED" << std::endl;
}
if(!rendering_program_sphere.addShader(geometry_shader_sphere)) {
std::cerr << "Adding geometry shader for sphere FAILED" << std::endl;
}
if(!rendering_program_sphere.addShader(fragment_shader_sphere)) {
std::cerr << "Adding fragment shader for clipping plane FAILED" << std::endl;
}
if(!rendering_program_sphere.link()) {
std::cerr << "Linking Program for sphere FAILED" << std::endl;
}
}
// Cylinder shader
if(isOpenGL_4_3()) {
// clipping plane shader
source_ = VERTEX_SOURCE_SHAPE;
QOpenGLShader* vertex_shader_cylinder = new QOpenGLShader(QOpenGLShader::Vertex);
if(!vertex_shader_cylinder->compileSourceCode(source_)) {
std::cerr << "Compiling vertex source for cylinder FAILED" << std::endl;
}
source_ = GEOMETRY_SOURCE_CYLINDER;
QOpenGLShader* geometry_shader_cylinder = new QOpenGLShader(QOpenGLShader::Geometry);
if(!geometry_shader_cylinder->compileSourceCode(source_)) {
std::cerr << "Compiling geometry source for cylinder FAILED" << std::endl;
}
source_ = FRAGMENT_SOURCE_P_L;
QOpenGLShader* fragment_shader_cylinder = new QOpenGLShader(QOpenGLShader::Fragment);
if(!fragment_shader_cylinder->compileSourceCode(source_)) {
std::cerr << "Compiling fragment source for cylinder FAILED" << std::endl;
}
if(!rendering_program_cylinder.addShader(vertex_shader_cylinder)) {
std::cerr << "Adding vertex shader for cylinder FAILED" << std::endl;
}
if(!rendering_program_cylinder.addShader(geometry_shader_cylinder)) {
std::cerr << "Adding geometry shader for cylinder FAILED" << std::endl;
}
if(!rendering_program_cylinder.addShader(fragment_shader_cylinder)) {
std::cerr << "Adding fragment shader for clipping plane FAILED" << std::endl;
}
if(!rendering_program_cylinder.link()) {
std::cerr << "Linking Program for cylinder FAILED" << std::endl;
}
}
// Normal shader
if(isOpenGL_4_3()) {
source_ = VERTEX_SOURCE_NORMAL;
QOpenGLShader* vertex_shader_normal = new QOpenGLShader(QOpenGLShader::Vertex);
if(!vertex_shader_normal->compileSourceCode(source_)) {
std::cerr << "Compiling vertex source for normal FAILED" << std::endl;
}
source_ = GEOMETRY_SOURCE_NORMAL;
QOpenGLShader* geometry_shader_normal = new QOpenGLShader(QOpenGLShader::Geometry);
if(!geometry_shader_normal->compileSourceCode(source_)) {
std::cerr << "Compiling geometry source for normal FAILED" << std::endl;
}
source_ = FRAGMENT_SOURCE_P_L;
QOpenGLShader* fragment_shader_normal = new QOpenGLShader(QOpenGLShader::Fragment);
if(!fragment_shader_normal->compileSourceCode(source_)) {
std::cerr << "Compiling fragment source for normal FAILED" << std::endl;
}
if(!rendering_program_normal.addShader(vertex_shader_normal)) {
std::cerr << "Adding vertex shader for normal FAILED" << std::endl;
}
if(!rendering_program_normal.addShader(geometry_shader_normal)) {
std::cerr << "Adding geometry shader for normal FAILED" << std::endl;
}
if(!rendering_program_normal.addShader(fragment_shader_normal)) {
std::cerr << "Adding fragment shader for clipping plane FAILED" << std::endl;
}
if(!rendering_program_normal.link()) {
std::cerr << "Linking Program for normal FAILED" << std::endl;
}
}
// Normal shader
if(isOpenGL_4_3()) {
source_ = VERTEX_SOURCE_TRIANGLE;
QOpenGLShader* vertex_shader_triangle = new QOpenGLShader(QOpenGLShader::Vertex);
if(!vertex_shader_triangle->compileSourceCode(source_)) {
std::cerr << "Compiling vertex source for triangle FAILED" << std::endl;
}
source_ = GEOMETRY_SOURCE_TRIANGLE;
QOpenGLShader* geometry_shader_triangle = new QOpenGLShader(QOpenGLShader::Geometry);
if(!geometry_shader_triangle->compileSourceCode(source_)) {
std::cerr << "Compiling geometry source for triangle FAILED" << std::endl;
}
source_ = FRAGMENT_SOURCE_P_L;
QOpenGLShader* fragment_shader_triangle = new QOpenGLShader(QOpenGLShader::Fragment);
if(!fragment_shader_triangle->compileSourceCode(source_)) {
std::cerr << "Compiling fragment source for triangle FAILED" << std::endl;
}
if(!rendering_program_triangle.addShader(vertex_shader_triangle)) {
std::cerr << "Adding vertex shader for triangle FAILED" << std::endl;
}
if(!rendering_program_triangle.addShader(geometry_shader_triangle)) {
std::cerr << "Adding geometry shader for triangle FAILED" << std::endl;
}
if(!rendering_program_triangle.addShader(fragment_shader_triangle)) {
std::cerr << "Adding fragment shader for clipping plane FAILED" << std::endl;
}
if(!rendering_program_triangle.link()) {
std::cerr << "Linking Program for triangle FAILED" << std::endl;
}
}
// Line shader
if(isOpenGL_4_3()) {
source_ = VERTEX_SOURCE_LINE_WIDTH;
QOpenGLShader* vertex_shader_line = new QOpenGLShader(QOpenGLShader::Vertex);
if(!vertex_shader_line->compileSourceCode(source_)) {
std::cerr << "Compiling vertex source for line FAILED" << std::endl;
}
source_ = GEOMETRY_SOURCE_LINE_WIDTH;
QOpenGLShader* geometry_shader_line = new QOpenGLShader(QOpenGLShader::Geometry);
if(!geometry_shader_line->compileSourceCode(source_)) {
std::cerr << "Compiling geometry source for line FAILED" << std::endl;
}
source_ = FRAGMENT_SOURCE_P_L;
QOpenGLShader* fragment_shader_line = new QOpenGLShader(QOpenGLShader::Fragment);
if(!fragment_shader_line->compileSourceCode(source_)) {
std::cerr << "Compiling fragment source for line FAILED" << std::endl;
}
if(!rendering_program_line.addShader(vertex_shader_line)) {
std::cerr << "Adding vertex shader for line FAILED" << std::endl;
}
if(!rendering_program_line.addShader(geometry_shader_line)) {
std::cerr << "Adding geometry shader for line FAILED" << std::endl;
}
if(!rendering_program_line.addShader(fragment_shader_line)) {
std::cerr << "Adding fragment shader for line FAILED" << std::endl;
}
if(!rendering_program_line.link()) {
std::cerr << "Linking Program for line FAILED" << std::endl;
}
}
}
void initialize_buffers() {
set_camera_mode();
rendering_program_p_l.bind();
unsigned int bufn = 0;
std::vector<float> positions, normals, colors;
// 1) POINT SHADER
vao[VAO_POINTS].bind();
positions = m_scene.get_array_of_index(GS::POS_POINTS);
colors = m_scene.get_array_of_index(GS::COLOR_POINTS);
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(positions.data(), static_cast<int>(positions.size() * sizeof(float)));
rendering_program_p_l.enableAttributeArray("a_Pos");
rendering_program_p_l.setAttributeBuffer("a_Pos", GL_FLOAT, 0, 3);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(colors.data(), static_cast<int>(colors.size() * sizeof(float)));
rendering_program_p_l.enableAttributeArray("a_Color");
rendering_program_p_l.setAttributeBuffer("a_Color", GL_FLOAT, 0, 3);
// 2) SEGMENT SHADER
vao[VAO_SEGMENTS].bind();
positions = m_scene.get_array_of_index(GS::POS_SEGMENTS);
colors = m_scene.get_array_of_index(GS::COLOR_SEGMENTS);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(positions.data(), static_cast<int>(positions.size() * sizeof(float)));
rendering_program_p_l.enableAttributeArray("a_Pos");
rendering_program_p_l.setAttributeBuffer("a_Pos", GL_FLOAT, 0, 3);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(colors.data(), static_cast<int>(colors.size() * sizeof(float)));
rendering_program_p_l.enableAttributeArray("a_Color");
rendering_program_p_l.setAttributeBuffer("a_Color", GL_FLOAT, 0, 3);
// 3) RAYS SHADER
vao[VAO_RAYS].bind();
positions = m_scene.get_array_of_index(GS::POS_RAYS);
colors = m_scene.get_array_of_index(GS::COLOR_RAYS);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(positions.data(), static_cast<int>(positions.size() * sizeof(float)));
rendering_program_p_l.enableAttributeArray("a_Pos");
rendering_program_p_l.setAttributeBuffer("a_Pos", GL_FLOAT, 0, 3);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(colors.data(), static_cast<int>(colors.size() * sizeof(float)));
rendering_program_p_l.enableAttributeArray("a_Color");
rendering_program_p_l.setAttributeBuffer("a_Color", GL_FLOAT, 0, 3);
// 4) LINES SHADER
vao[VAO_LINES].bind();
positions = m_scene.get_array_of_index(GS::POS_LINES);
colors = m_scene.get_array_of_index(GS::COLOR_LINES);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(positions.data(), static_cast<int>(positions.size() * sizeof(float)));
rendering_program_p_l.enableAttributeArray("a_Pos");
rendering_program_p_l.setAttributeBuffer("a_Pos", GL_FLOAT, 0, 3);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(colors.data(), static_cast<int>(colors.size() * sizeof(float)));
rendering_program_p_l.enableAttributeArray("a_Color");
rendering_program_p_l.setAttributeBuffer("a_Color", GL_FLOAT, 0, 3);
// 5) FACE SHADER
vao[VAO_FACES].bind();
positions = m_scene.get_array_of_index(GS::POS_FACES);
normals = m_scene.get_array_of_index(m_flat_shading ? GS::FLAT_NORMAL_FACES : GS::SMOOTH_NORMAL_FACES);
colors = m_scene.get_array_of_index(GS::COLOR_FACES);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(positions.data(), static_cast<int>(positions.size() * sizeof(float)));
rendering_program_face.enableAttributeArray("a_Pos");
rendering_program_face.setAttributeBuffer("a_Pos", GL_FLOAT, 0, 3);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(normals.data(), static_cast<int>(normals.size() * sizeof(float)));
rendering_program_face.enableAttributeArray("a_Normal");
rendering_program_face.setAttributeBuffer("a_Normal", GL_FLOAT, 0, 3);
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(colors.data(), static_cast<int>(colors.size() * sizeof(float)));
rendering_program_face.enableAttributeArray("a_Color");
rendering_program_face.setAttributeBuffer("a_Color", GL_FLOAT, 0, 3);
// 6) clipping plane shader
if(isOpenGL_4_3()) {
generate_clipping_plane();
rendering_program_clipping_plane.bind();
vao[VAO_CLIPPING_PLANE].bind();
++bufn;
CGAL_assertion(bufn < NB_GL_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(m_array_for_clipping_plane.data(),
static_cast<int>(m_array_for_clipping_plane.size() * sizeof(BufferType)));
rendering_program_clipping_plane.enableAttributeArray("a_Pos");
rendering_program_clipping_plane.setAttributeBuffer("a_Pos", GL_FLOAT, 0, 3);
buffers[bufn].release();
rendering_program_clipping_plane.release();
}
m_are_buffers_initialized = true;
}
void attrib_buffers(CGAL::QGLViewer* viewer) {
QMatrix4x4 mvpMatrix;
QMatrix4x4 mvMatrix;
double mat[16];
viewer->camera()->getModelViewProjectionMatrix(mat);
for(unsigned int i = 0; i < 16; i++) {
mvpMatrix.data()[i] = (float)mat[i];
}
viewer->camera()->getModelViewMatrix(mat);
for(unsigned int i = 0; i < 16; i++) {
mvMatrix.data()[i] = (float)mat[i];
}
// define material
QVector4D diffuse(0.9f, 0.9f, 0.9f, 0.9f);
QVector4D specular(0.0f, 0.0f, 0.0f, 1.0f);
CGAL::Bbox_3 bb;
if(bb == m_scene.bounding_box()) // Case of "empty" bounding box
{
bb = Local_point(CGAL::ORIGIN).bbox();
bb = bb + Local_point(1, 1, 1).bbox(); // To avoid a warning from Qglviewer
} else {
bb = m_scene.bounding_box();
}
QVector4D position((bb.xmax() - bb.xmin()) / 2, (bb.ymax() - bb.ymin()) / 2, bb.zmax(), 0.0);
GLfloat shininess = 1.0f;
rendering_program_face.bind();
int mvpLocation = rendering_program_face.uniformLocation("u_Mvp");
int mvLocation = rendering_program_face.uniformLocation("u_Mv");
int lightLocation[5];
lightLocation[0] = rendering_program_face.uniformLocation("u_LightPos");
lightLocation[1] = rendering_program_face.uniformLocation("u_LightDiff");
lightLocation[2] = rendering_program_face.uniformLocation("u_LightSpec");
lightLocation[3] = rendering_program_face.uniformLocation("u_LightAmb");
lightLocation[4] = rendering_program_face.uniformLocation("u_SpecPower");
rendering_program_face.setUniformValue(lightLocation[0], position);
rendering_program_face.setUniformValue(lightLocation[1], diffuse);
rendering_program_face.setUniformValue(lightLocation[2], specular);
rendering_program_face.setUniformValue(lightLocation[3], m_ambient_color);
rendering_program_face.setUniformValue(lightLocation[4], shininess);
rendering_program_face.setUniformValue(mvpLocation, mvpMatrix);
rendering_program_face.setUniformValue(mvLocation, mvMatrix);
rendering_program_face.release();
rendering_program_p_l.bind();
mvpLocation = rendering_program_p_l.uniformLocation("u_Mvp");
rendering_program_p_l.setUniformValue(mvpLocation, mvpMatrix);
rendering_program_p_l.release();
// cylinder edge feature
rendering_program_cylinder.bind();
mvpLocation = rendering_program_cylinder.uniformLocation("u_Mvp");
rendering_program_cylinder.setUniformValue(mvpLocation, mvpMatrix);
rendering_program_cylinder.release();
// sphere vertex feature
rendering_program_sphere.bind();
mvpLocation = rendering_program_sphere.uniformLocation("u_Mvp");
rendering_program_sphere.setUniformValue(mvpLocation, mvpMatrix);
rendering_program_sphere.release();
if(isOpenGL_4_3()) {
QMatrix4x4 clipping_mMatrix;
clipping_mMatrix.setToIdentity();
for(int i = 0; i < 16; i++) {
clipping_mMatrix.data()[i] = m_frame_plane->matrix()[i];
}
rendering_program_clipping_plane.bind();
int vpLocation = rendering_program_clipping_plane.uniformLocation("u_Vp");
int mLocation = rendering_program_clipping_plane.uniformLocation("u_M");
rendering_program_clipping_plane.setUniformValue(vpLocation, mvpMatrix);
rendering_program_clipping_plane.setUniformValue(mLocation, clipping_mMatrix);
rendering_program_clipping_plane.release();
}
if(isOpenGL_4_3()) {
rendering_program_normal.bind();
QMatrix4x4 projection;
double mat[16];
viewer->camera()->getProjectionMatrix(mat);
for(unsigned int i = 0; i < 16; i++) {
projection.data()[i] = (float)mat[i];
}
int mvLocation = rendering_program_normal.uniformLocation("u_Mv");
int pLocation = rendering_program_normal.uniformLocation("u_Projection");
rendering_program_normal.setUniformValue(mvLocation, mvMatrix);
rendering_program_normal.setUniformValue(pLocation, projection);
rendering_program_normal.release();
}
if(isOpenGL_4_3()) {
rendering_program_triangle.bind();
int mvpLocation = rendering_program_triangle.uniformLocation("u_Mvp");
rendering_program_triangle.setUniformValue(mvpLocation, mvpMatrix);
rendering_program_triangle.release();
}
if(isOpenGL_4_3()) {
rendering_program_line.bind();
int mvpLocation = rendering_program_line.uniformLocation("u_Mvp");
rendering_program_line.setUniformValue(mvpLocation, mvpMatrix);
rendering_program_line.release();
}
}
void set_camera_mode() {
if(is_two_dimensional()) {
camera()->setType(CGAL::qglviewer::Camera::ORTHOGRAPHIC);
// Camera Constraint:
constraint.setRotationConstraintType(CGAL::qglviewer::AxisPlaneConstraint::AXIS);
constraint.setTranslationConstraintType(CGAL::qglviewer::AxisPlaneConstraint::FREE);
double cx = 0., cy = 0., cz = 0.;
if(m_scene.has_zero_x()) {
cx = 1.;
} else if(m_scene.has_zero_y()) {
cy = 1.;
} else {
cz = 1.;
}
camera()->setViewDirection(CGAL::qglviewer::Vec(-cx, -cy, -cz));
constraint.setRotationConstraintDirection(CGAL::qglviewer::Vec(cx, cy, cz));
camera()->frame()->setConstraint(&constraint);
} else {
camera()->setType(CGAL::qglviewer::Camera::PERSPECTIVE);
camera()->frame()->setConstraint(nullptr);
}
}
virtual void init() {
set_camera_mode();
initializeOpenGLFunctions();
// Light default parameters
glLineWidth(m_size_edges);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1.f, 1.f);
glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
glDisable(GL_BLEND);
glEnable(GL_PROGRAM_POINT_SIZE);
glEnable(GL_LINE_SMOOTH);
glDisable(GL_POLYGON_SMOOTH_HINT);
glBlendFunc(GL_ONE, GL_ZERO);
glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
compile_shaders();
CGAL::Bbox_3 bb;
if(bb == m_scene.bounding_box()) // Case of "empty" bounding box
{
bb = Local_point(CGAL::ORIGIN).bbox();
bb = bb + Local_point(1, 1, 1).bbox(); // To avoid a warning from Qglviewer
} else {
bb = m_scene.bounding_box();
}
this->camera()->setSceneBoundingBox(CGAL::qglviewer::Vec(bb.xmin(), bb.ymin(), bb.zmin()),
CGAL::qglviewer::Vec(bb.xmax(), bb.ymax(), bb.zmax()));
m_frame_plane = new CGAL::qglviewer::ManipulatedFrame;
// Check for geometry shader availability
int max_geometry_output_vertices = 0;
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES, &max_geometry_output_vertices);
int max_geometry_output_components = 0;
glGetIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, &max_geometry_output_components);
if(max_geometry_output_vertices < 128 || max_geometry_output_components < 1024) {
std::cout << "Cylinder edge and sphere vertex feature disabled! (max_geometry_output_vertices="
<< max_geometry_output_vertices << ", max_geometry_output_components=" << max_geometry_output_components
<< ")\n";
m_geometry_feature_enabled = false;
}
/// This code cannot be done in the constructor, because the Graphics_scene
/// is not yet created (cf. for example LCC demo).
if(m_inverse_normal) {
reverse_all_normals();
}
initialize_vertices_and_edges_size();
this->showEntireScene();
}
void initialize_vertices_and_edges_size() {
if(!m_scene.empty()) {
auto& bbox = m_scene.bounding_box();
double d = CGAL::sqrt(CGAL::squared_distance(Local_point(bbox.xmin(), bbox.ymin(), bbox.zmin()),
Local_point(bbox.xmax(), bbox.ymax(), bbox.zmax())));
// std::cout<<"Length of the diagonal: "<<d<<std::endl;
m_size_vertices = 1.5 * d;
m_size_edges = d;
m_size_rays = m_size_edges;
m_size_lines = m_size_edges;
m_size_normals = d / 3;
m_height_factor_normals = 0.02;
}
}
void generate_clipping_plane() {
qreal size = ((m_scene.bounding_box().xmax() - m_scene.bounding_box().xmin()) +
(m_scene.bounding_box().ymax() - m_scene.bounding_box().ymin()) +
(m_scene.bounding_box().zmax() - m_scene.bounding_box().zmin()));
const unsigned int nb_subdivisions = 30;
auto& array = m_array_for_clipping_plane;
array.clear();
for(unsigned int i = 0; i <= nb_subdivisions; ++i) {
const float pos = float(size * (2.0 * i / nb_subdivisions - 1.0));
array.push_back(pos);
array.push_back(float(-size));
array.push_back(0.f);
array.push_back(pos);
array.push_back(float(+size));
array.push_back(0.f);
array.push_back(float(-size));
array.push_back(pos);
array.push_back(0.f);
array.push_back(float(size));
array.push_back(pos);
array.push_back(0.f);
}
// Normal
array.push_back(0.f);
array.push_back(0.f);
array.push_back(0.f);
array.push_back(0.f);
array.push_back(0.f);
array.push_back(1.f);
}
virtual void mouseDoubleClickEvent(QMouseEvent* e) {
if((e->modifiers() == ::Qt::ShiftModifier) && (e->button() == ::Qt::LeftButton)) {
if(manipulatedFrame()) {
camera()->frame()->alignWithFrame(manipulatedFrame(), true);
}
} else {
CGAL::QGLViewer::mouseDoubleClickEvent(e);
}
}
virtual void keyPressEvent(QKeyEvent* e) {
if(!on_key_pressed || !on_key_pressed(e, this)) {
const ::Qt::KeyboardModifiers modifiers = e->modifiers();
if((e->key() == ::Qt::Key_C) && (modifiers == ::Qt::NoButton)) {
if(!isOpenGL_4_3())
return;
if(!is_two_dimensional()) {
// toggle clipping plane
m_use_clipping_plane = (m_use_clipping_plane + 1) % CLIPPING_PLANE_END_INDEX;
if(m_use_clipping_plane == CLIPPING_PLANE_OFF) {
setManipulatedFrame(nullptr);
} else {
setManipulatedFrame(m_frame_plane);
}
switch(m_use_clipping_plane) {
case CLIPPING_PLANE_OFF:
displayMessage(QString("Draw clipping = false"));
break;
case CLIPPING_PLANE_SOLID_HALF_TRANSPARENT_HALF:
clipping_plane_rendering = true;
displayMessage(QString("Draw clipping = solid half & transparent half"));
break;
case CLIPPING_PLANE_SOLID_HALF_WIRE_HALF:
displayMessage(QString("Draw clipping = solid half & wireframe half"));
break;
case CLIPPING_PLANE_SOLID_HALF_ONLY:
displayMessage(QString("Draw clipping = solid half only"));
break;
default:
break;
}
update();
}
}
else if((e->key() == ::Qt::Key_C) && (modifiers == ::Qt::AltModifier))
{
if(!isOpenGL_4_3())
return;
if(m_use_clipping_plane != CLIPPING_PLANE_OFF) {
clipping_plane_rendering = !clipping_plane_rendering;
displayMessage(QString("Draw clipping plane=%1.").arg(clipping_plane_rendering ? "true" : "false"));
update();
}
} else if((e->key() == ::Qt::Key_E) && (modifiers == ::Qt::NoButton)) {
m_draw_edges = !m_draw_edges;
displayMessage(QString("Draw edges=%1.").arg(m_draw_edges ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_M) && (modifiers == ::Qt::NoButton)) {
m_use_default_color = !m_use_default_color;
displayMessage(QString("Mono color=%1.").arg(m_use_default_color ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_N) && (modifiers == ::Qt::NoButton)) {
reverse_all_normals();
displayMessage(QString("Inverse normal=%1.").arg(m_inverse_normal ? "true" : "false"));
redraw();
} else if((e->key() == ::Qt::Key_S) && (modifiers == ::Qt::NoButton)) {
m_flat_shading = !m_flat_shading;
if(m_flat_shading)
displayMessage("Flat shading.");
else
displayMessage("Gouraud shading.");
redraw();
} else if((e->key() == ::Qt::Key_T) && (modifiers == ::Qt::NoButton)) {
m_draw_text = !m_draw_text;
displayMessage(QString("Draw text=%1.").arg(m_draw_text ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_U) && (modifiers == ::Qt::NoButton)) {
if(is_two_dimensional()) {
displayMessage(QString("Move camera direction upside down."));
/* CGAL::qglviewer::Vec cur=camera()->viewDirection(); // TODO !
double cx=cur.x, cy=cur.y, cz=cur.z;
if (has_zero_x()) { cx=-cx; }
else if (has_zero_y()) { cy=-cy; }
else { cz=-cz; }
double cx=0., cy=0., cz=0.;
if (has_zero_x()) { cx=(cur.x<0?-1.:1); }
else if (has_zero_y()) { cy=(cur.y<0?-1.:1); }
else { cz=(cur.z<0?-1.:1); }*/
camera()->setUpVector(-camera()->upVector());
// camera()->frame()->setConstraint(NULL);
// camera()->setViewDirection(CGAL::qglviewer::Vec(-cx,-cy,-cz));
// constraint.setRotationConstraintDirection(CGAL::qglviewer::Vec(cx, cy, cz));
// camera()->frame()->setConstraint(&constraint);
// update();
redraw();
}
} else if((e->key() == ::Qt::Key_V) && (modifiers == ::Qt::NoButton)) {
m_draw_vertices = !m_draw_vertices;
displayMessage(QString("Draw vertices=%1.").arg(m_draw_vertices ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_W) && (modifiers == ::Qt::NoButton)) {
m_draw_faces = !m_draw_faces;
displayMessage(QString("Draw faces=%1.").arg(m_draw_faces ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_Plus) && (!modifiers.testFlag(::Qt::ControlModifier))) // No ctrl
{
m_size_edges += .5;
displayMessage(QString("Size of edges=%1.").arg(m_size_edges));
update();
} else if((e->key() == ::Qt::Key_Minus) && (!modifiers.testFlag(::Qt::ControlModifier))) // No ctrl
{
if(m_size_edges > .5)
m_size_edges -= .5;
displayMessage(QString("Size of edges=%1.").arg(m_size_edges));
update();
} else if((e->key() == ::Qt::Key_Plus) && (modifiers.testFlag(::Qt::ControlModifier))) {
m_size_vertices += .5;
displayMessage(QString("Size of points=%1.").arg(m_size_vertices));
update();
} else if((e->key() == ::Qt::Key_Minus) && (modifiers.testFlag(::Qt::ControlModifier))) {
if(m_size_vertices > .5)
m_size_vertices -= .5;
displayMessage(QString("Size of points=%1.").arg(m_size_vertices));
update();
} else if((e->key() == ::Qt::Key_PageUp) && (modifiers == ::Qt::NoButton)) {
m_ambient_color.setX(m_ambient_color.x() + .1);
if(m_ambient_color.x() > 1.)
m_ambient_color.setX(1.);
m_ambient_color.setY(m_ambient_color.x() + .1);
if(m_ambient_color.y() > 1.)
m_ambient_color.setY(1.);
m_ambient_color.setZ(m_ambient_color.x() + .1);
if(m_ambient_color.z() > 1.)
m_ambient_color.setZ(1.);
displayMessage(QString("Light color=(%1 %2 %3).")
.arg(m_ambient_color.x())
.arg(m_ambient_color.y())
.arg(m_ambient_color.z()));
update();
} else if((e->key() == ::Qt::Key_PageDown) && (modifiers == ::Qt::NoButton)) {
m_ambient_color.setX(m_ambient_color.x() - .1);
if(m_ambient_color.x() < 0.)
m_ambient_color.setX(0.);
m_ambient_color.setY(m_ambient_color.y() - .1);
if(m_ambient_color.y() < 0.)
m_ambient_color.setY(0.);
m_ambient_color.setZ(m_ambient_color.z() - .1);
if(m_ambient_color.z() < 0.)
m_ambient_color.setZ(0.);
displayMessage(QString("Light color=(%1 %2 %3).")
.arg(m_ambient_color.x())
.arg(m_ambient_color.y())
.arg(m_ambient_color.z()));
update();
} else if((e->key() == ::Qt::Key_PageUp) && (modifiers == ::Qt::ShiftModifier)) {
m_ambient_color.setX(m_ambient_color.x() + .1);
if(m_ambient_color.x() > 1.)
m_ambient_color.setX(1.);
displayMessage(QString("Light color=(%1 %2 %3).")
.arg(m_ambient_color.x())
.arg(m_ambient_color.y())
.arg(m_ambient_color.z()));
update();
} else if((e->key() == ::Qt::Key_PageUp) && (modifiers == ::Qt::AltModifier)) {
m_ambient_color.setY(m_ambient_color.y() + .1);
if(m_ambient_color.y() > 1.)
m_ambient_color.setY(1.);
displayMessage(QString("Light color=(%1 %2 %3).")
.arg(m_ambient_color.x())
.arg(m_ambient_color.y())
.arg(m_ambient_color.z()));
update();
} else if((e->key() == ::Qt::Key_PageUp) && (modifiers == ::Qt::ControlModifier)) {
m_ambient_color.setZ(m_ambient_color.z() + .1);
if(m_ambient_color.z() > 1.)
m_ambient_color.setZ(1.);
displayMessage(QString("Light color=(%1 %2 %3).")
.arg(m_ambient_color.x())
.arg(m_ambient_color.y())
.arg(m_ambient_color.z()));
update();
} else if((e->key() == ::Qt::Key_PageDown) && (modifiers == ::Qt::ShiftModifier)) {
m_ambient_color.setX(m_ambient_color.x() - .1);
if(m_ambient_color.x() < 0.)
m_ambient_color.setX(0.);
displayMessage(QString("Light color=(%1 %2 %3).")
.arg(m_ambient_color.x())
.arg(m_ambient_color.y())
.arg(m_ambient_color.z()));
update();
} else if((e->key() == ::Qt::Key_PageDown) && (modifiers == ::Qt::AltModifier)) {
m_ambient_color.setY(m_ambient_color.y() - .1);
if(m_ambient_color.y() < 0.)
m_ambient_color.setY(0.);
displayMessage(QString("Light color=(%1 %2 %3).")
.arg(m_ambient_color.x())
.arg(m_ambient_color.y())
.arg(m_ambient_color.z()));
update();
} else if((e->key() == ::Qt::Key_PageDown) && (modifiers == ::Qt::ControlModifier)) {
m_ambient_color.setZ(m_ambient_color.z() - .1);
if(m_ambient_color.z() < 0.)
m_ambient_color.setZ(0.);
displayMessage(QString("Light color=(%1 %2 %3).")
.arg(m_ambient_color.x())
.arg(m_ambient_color.y())
.arg(m_ambient_color.z()));
update();
} else if((e->key() == ::Qt::Key_O) && (modifiers == ::Qt::NoButton)) {
bool old_2D = is_two_dimensional();
m_no_2D_mode = !m_no_2D_mode;
if(old_2D != is_two_dimensional()) {
if(is_two_dimensional()) {
displayMessage(QString("Viewer is in 2D mode."));
} else {
displayMessage(QString("Viewer is in 3D mode."));
}
set_camera_mode();
update();
}
} else if((e->key() == ::Qt::Key_V) && (modifiers == ::Qt::ControlModifier)) {
m_draw_sphere_vertex = !m_draw_sphere_vertex;
displayMessage(QString("Draw sphere vertex=%1.").arg(m_draw_sphere_vertex ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_E) && (modifiers == ::Qt::ControlModifier)) {
m_draw_cylinder_edge = !m_draw_cylinder_edge;
displayMessage(QString("Draw cylinder edge=%1.").arg(m_draw_cylinder_edge ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_N) && (modifiers == ::Qt::ControlModifier)) {
m_draw_normals = !m_draw_normals;
displayMessage(QString("Draw normals=%1.").arg(m_draw_normals ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_T) && (modifiers == ::Qt::ControlModifier)) {
m_draw_mesh_triangles = !m_draw_mesh_triangles;
displayMessage(QString("Draw triangles=%1.").arg(m_draw_mesh_triangles ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_M) && (modifiers == ::Qt::ControlModifier)) {
m_use_default_color_normal = !m_use_default_color_normal;
displayMessage(QString("Normal mono color=%1.").arg(m_use_default_color_normal ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_N) && (modifiers == ::Qt::ShiftModifier)) {
m_display_face_normal = !m_display_face_normal;
displayMessage(QString("Display face normal=%1.").arg(m_display_face_normal ? "true" : "false"));
update();
} else if((e->key() == ::Qt::Key_F2)) {
capture_screenshot(QString("./screenshot.png"));
displayMessage(QString("Screenshot saved in ./screenshot"));
} else {
CGAL::QGLViewer::keyPressEvent(e);
} // By default call QGLViewer key press
}
}
virtual QString helpString() const { return helpString("CGAL Basic Viewer"); }
virtual QString helpString(const char* title) const {
QString text(QString("<h2>") + QString(title) + QString("</h2>"));
text += "Use the mouse to move the camera around the object. ";
text += "You can respectively revolve around, zoom and translate with "
"the three mouse buttons. ";
text += "Left and middle buttons pressed together rotate around the "
"camera view direction axis<br><br>";
text += "Pressing <b>Alt</b> and one of the function keys "
"(<b>F1</b>..<b>F12</b>) defines a camera keyFrame. ";
text += "Simply press the function key again to restore it. "
"Several keyFrames define a ";
text += "camera path. Paths are saved when you quit the application "
"and restored at next start.<br><br>";
text += "Press <b>F</b> to display the frame rate, <b>A</b> for the "
"world axis, ";
text += "<b>Alt+Return</b> for full screen mode and <b>Control+S</b> "
"to save a snapshot. ";
text += "See the <b>Keyboard</b> tab in this window for a complete "
"shortcut list.<br><br>";
text += "Double clicks automates single click actions: A left button "
"double click aligns the closer axis with the camera (if close enough). ";
text += "A middle button double click fits the zoom of the camera and "
"the right button re-centers the scene.<br><br>";
text += "A left button double click while holding right button pressed "
"defines the camera <i>Revolve Around Point</i>. ";
text += "See the <b>Mouse</b> tab and the documentation web pages for "
"details.<br><br>";
text += "Press <b>Escape</b> to exit the viewer.";
return text;
}
void capture_screenshot(const QString& file_path) {
QScreen* screen;
screen = QApplication::primaryScreen();
// auto geom = screen->geometry();
auto qpx_pixmap = screen->grabWindow(this->winId());
qpx_pixmap.save(file_path);
}
public:
std::function<bool(QKeyEvent*, CGAL::Qt::Basic_viewer*)> on_key_pressed;
protected:
const Graphics_scene& m_scene;
bool m_draw_vertices;
bool m_draw_edges;
bool m_draw_rays;
bool m_draw_lines;
bool m_draw_faces;
bool m_draw_text;
bool m_draw_normals;
bool m_draw_cylinder_edge;
bool m_draw_sphere_vertex;
bool m_draw_mesh_triangles;
bool m_flat_shading;
bool m_use_default_color;
bool m_use_default_color_normal;
bool m_display_face_normal;
bool m_inverse_normal;
bool m_no_2D_mode;
bool m_geometry_feature_enabled;
bool m_prev_scene_empty;
enum {
CLIPPING_PLANE_OFF = 0,
CLIPPING_PLANE_SOLID_HALF_TRANSPARENT_HALF,
CLIPPING_PLANE_SOLID_HALF_WIRE_HALF,
CLIPPING_PLANE_SOLID_HALF_ONLY,
CLIPPING_PLANE_END_INDEX
};
int m_use_clipping_plane = CLIPPING_PLANE_OFF;
CGAL::qglviewer::ManipulatedFrame* m_frame_plane = nullptr;
// Buffer for clipping plane is not stored in the scene because it is not
// filled by users but by the basic viewer.
std::vector<BufferType> m_array_for_clipping_plane;
double m_size_vertices = 1.;
double m_size_edges = 1.;
double m_size_rays = 1.;
double m_size_lines = 1.;
double m_size_normals = .2;
double m_height_factor_normals = .02;
CGAL::IO::Color m_default_color_normal;
QVector4D m_ambient_color;
bool m_are_buffers_initialized;
// CGAL::qglviewer::LocalConstraint constraint;
CGAL::qglviewer::WorldConstraint constraint;
static const unsigned int NB_GL_BUFFERS = (GS::END_POS - GS::BEGIN_POS) + (GS::END_COLOR - GS::BEGIN_COLOR) +
3; // +2 for normals (mono and color), +1 for clipping plane
QOpenGLBuffer buffers[NB_GL_BUFFERS]; // +1 for the buffer of clipping plane
// The following enum gives the indices of the different vao.
enum { VAO_POINTS = 0, VAO_SEGMENTS, VAO_RAYS, VAO_LINES, VAO_FACES, VAO_CLIPPING_PLANE, NB_VAO_BUFFERS };
QOpenGLVertexArrayObject vao[NB_VAO_BUFFERS];
QOpenGLShaderProgram rendering_program_face;
QOpenGLShaderProgram rendering_program_p_l;
QOpenGLShaderProgram rendering_program_line;
QOpenGLShaderProgram rendering_program_clipping_plane;
QOpenGLShaderProgram rendering_program_sphere;
QOpenGLShaderProgram rendering_program_cylinder;
QOpenGLShaderProgram rendering_program_normal;
QOpenGLShaderProgram rendering_program_triangle;
// variables for clipping plane
bool clipping_plane_rendering = true; // will be toggled when alt+c is pressed, which is used for indicating whether
// or not to render the clipping plane ;
float clipping_plane_rendering_transparency = 0.5f; // to what extent the transparent part should be rendered;
};
//------------------------------------------------------------------------------
class QApplication_and_basic_viewer
{
public:
QApplication_and_basic_viewer(const CGAL::Graphics_scene& buffer, const char* title = "CGAL Basic Viewer")
: m_application(nullptr)
, m_basic_viewer(nullptr)
, m_argc(1) {
m_argv[0] = new char[strlen(title) + 1];
memcpy(m_argv[0], title, strlen(title) + 1);
m_argv[1] = nullptr;
#if defined(CGAL_TEST_SUITE)
bool cgal_test_suite = true;
#else
bool cgal_test_suite = qEnvironmentVariableIsSet("CGAL_TEST_SUITE");
#endif
if(cgal_test_suite) {
return;
}
Qt::init_ogl_context(4, 3);
m_application = new QApplication(m_argc, const_cast<char**>(m_argv));
m_basic_viewer = new Basic_viewer(m_application->activeWindow(), buffer, title);
}
~QApplication_and_basic_viewer() {
delete[] m_argv[0];
delete m_basic_viewer;
delete m_application;
}
operator bool() const { return m_application != nullptr; }
void run() {
if(m_application != nullptr) {
m_basic_viewer->show();
m_application->exec();
}
}
Basic_viewer& basic_viewer() {
CGAL_assertion(m_basic_viewer != nullptr);
return *m_basic_viewer;
}
protected:
QApplication* m_application;
Basic_viewer* m_basic_viewer;
char* m_argv[2];
int m_argc;
};
} // End namespace Qt
// A shortcut to use directly CGAL::Basic_viewer instead of CGAL::Qt::Basic_viewer.
// Can be changed later if we have several viewers.
using Qt::Basic_viewer;
inline void draw_graphics_scene(const Graphics_scene& graphics_scene, const char* title = "CGAL Basic Viewer (Qt)") {
#if defined(CGAL_TEST_SUITE)
bool cgal_test_suite = true;
#else
bool cgal_test_suite = qEnvironmentVariableIsSet("CGAL_TEST_SUITE");
#endif
if(!cgal_test_suite) {
Qt::init_ogl_context(4, 3);
int argc = 1;
const char* argv[2] = {title, nullptr};
QApplication app(argc, const_cast<char**>(argv));
Basic_viewer basic_viewer(app.activeWindow(), graphics_scene, title);
basic_viewer.show();
app.exec();
}
}
} // End namespace CGAL
#endif // CGAL_USE_BASIC_VIEWER
#endif // CGAL_QT_BASIC_VIEWER_H
Reference in New Issue View Git Blame Copy Permalink