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

fix warning in camera and fix fps display in cgal_qt5 so we don't have to overwrite it in the viewer 

Begin the implementation of the graphcal hints
This commit is contained in:
Maxime Gimeno 2018-03-21 12:26:36 +01:00
parent 6584abd90b
commit 3995c80524
6 changed files with 528 additions and 618 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
GraphicsView/include/CGAL/Qt/qglviewer.h
View File

@ -27,7 +27,11 @@
#include <QClipboard> #include <QClipboard>
#include <QOpenGLFunctions_2_1> #include <QOpenGLFunctions_2_1>
#include <QOpenGLShaderProgram>
#include <QOpenGLVertexArrayObject>
#include <QOpenGLBuffer>
#include <QMap> #include <QMap>
#include <QVector>
#include <QTime> #include <QTime>
#include <QGLContext> #include <QGLContext>
@ -118,6 +122,8 @@ public Q_SLOTS:
/*! Sets the state of axisIsDrawn(). Emits the axisIsDrawnChanged() signal. /*! Sets the state of axisIsDrawn(). Emits the axisIsDrawnChanged() signal.
* See also toggleAxisIsDrawn(). */ * See also toggleAxisIsDrawn(). */
void setAxisIsDrawn(bool draw = true) { void setAxisIsDrawn(bool draw = true) {
if(!draw)
axis_size = 0;
axisIsDrawn_ = draw; axisIsDrawn_ = draw;
Q_EMIT axisIsDrawnChanged(draw); Q_EMIT axisIsDrawnChanged(draw);
update(); update();
@ -125,6 +131,11 @@ public Q_SLOTS:
/*! Sets the state of gridIsDrawn(). Emits the gridIsDrawnChanged() signal. /*! Sets the state of gridIsDrawn(). Emits the gridIsDrawnChanged() signal.
* See also toggleGridIsDrawn(). */ * See also toggleGridIsDrawn(). */
void setGridIsDrawn(bool draw = true) { void setGridIsDrawn(bool draw = true) {
if(!draw)
{
grid_size=0;
g_axis_size=0;
}
gridIsDrawn_ = draw; gridIsDrawn_ = draw;
Q_EMIT gridIsDrawnChanged(draw); Q_EMIT gridIsDrawnChanged(draw);
update(); update();
@ -357,6 +368,10 @@ public:
\c QTimer, when animationIsStarted() or when the camera is manipulated with \c QTimer, when animationIsStarted() or when the camera is manipulated with
the mouse. */ the mouse. */
qreal currentFPS() { return f_p_s_; } qreal currentFPS() { return f_p_s_; }
/*!
* Returns the string used to display the current fps.
*/
QString fpsString() { return fpsString_; }
/*! Returns \c true if the viewer is in fullScreen mode. /*! Returns \c true if the viewer is in fullScreen mode.
Default value is \c false. Set by setFullScreen() or toggleFullScreen(). Default value is \c false. Set by setFullScreen() or toggleFullScreen().
@ -404,12 +419,10 @@ private:
/*! @name Display methods */ /*! @name Display methods */
//@{ //@{
public: public:
static void drawArrow(qreal = 1.0, qreal = -1.0, void drawArrow(double r, double R, int prec,
int = 12); qglviewer::Vec from, qglviewer::Vec to, qglviewer::Vec color, std::vector<float> &data);
static void drawArrow(const qglviewer::Vec &, const qglviewer::Vec &, void drawAxis(qreal l = 1.0);
qreal = -1.0, int = 12); void drawGrid(qreal size= 1.0, int nbSubdivisions = 10);
static void drawAxis(qreal = 1.0);
static void drawGrid(qreal = 1.0, int = 10);
virtual void startScreenCoordinatesSystem(bool upward = false) const; virtual void startScreenCoordinatesSystem(bool upward = false) const;
virtual void stopScreenCoordinatesSystem() const; virtual void stopScreenCoordinatesSystem() const;
@ -1456,6 +1469,30 @@ private:
// H e l p w i n d o w // H e l p w i n d o w
QTabWidget *helpWidget_; QTabWidget *helpWidget_;
//internal drawing buffers
enum VBO
{
Grid = 0,
Grid_axis,
Axis,
VBO_size
};
enum VAO
{
GRID = 0,
GRID_AXIS,
AXIS,
VAO_size
};
QOpenGLShaderProgram rendering_program;
QOpenGLShaderProgram rendering_program_light;
QOpenGLVertexArrayObject vaos[VAO_size];
QVector<QOpenGLBuffer> vbos;
std::size_t grid_size;
std::size_t g_axis_size;
std::size_t axis_size;
}; };
#endif // QGLVIEWER_QGLVIEWER_H #endif // QGLVIEWER_QGLVIEWER_H

12
GraphicsView/src/CGAL_Qt5/camera.cpp
View File

@ -1664,11 +1664,11 @@ void MultiplyMatrices4by4OpenGL_GLdouble(GLdouble *result, GLdouble *matrix1, GL
r3[2] = MAT(m, 3, 2), r3[3] = MAT(m, 3, 3), r3[2] = MAT(m, 3, 2), r3[3] = MAT(m, 3, 3),
r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0; r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0;
/* choose pivot - or die */ /* choose pivot - or die */
if (fabsf(r3[0]) > fabsf(r2[0])) if (fabs(r3[0]) > fabs(r2[0]))
SWAP_ROWS_GLdouble(r3, r2); SWAP_ROWS_GLdouble(r3, r2);
if (fabsf(r2[0]) > fabsf(r1[0])) if (fabs(r2[0]) > fabs(r1[0]))
SWAP_ROWS_GLdouble(r2, r1); SWAP_ROWS_GLdouble(r2, r1);
if (fabsf(r1[0]) > fabsf(r0[0])) if (fabs(r1[0]) > fabs(r0[0]))
SWAP_ROWS_GLdouble(r1, r0); SWAP_ROWS_GLdouble(r1, r0);
if (0.0 == r0[0]) if (0.0 == r0[0])
return 0; return 0;
@ -1713,9 +1713,9 @@ void MultiplyMatrices4by4OpenGL_GLdouble(GLdouble *result, GLdouble *matrix1, GL
r3[7] -= m3 * s; r3[7] -= m3 * s;
} }
/* choose pivot - or die */ /* choose pivot - or die */
if (fabsf(r3[1]) > fabsf(r2[1])) if (fabs(r3[1]) > fabs(r2[1]))
SWAP_ROWS_GLdouble(r3, r2); SWAP_ROWS_GLdouble(r3, r2);
if (fabsf(r2[1]) > fabsf(r1[1])) if (fabs(r2[1]) > fabs(r1[1]))
SWAP_ROWS_GLdouble(r2, r1); SWAP_ROWS_GLdouble(r2, r1);
if (0.0 == r1[1]) if (0.0 == r1[1])
return 0; return 0;
@ -1747,7 +1747,7 @@ void MultiplyMatrices4by4OpenGL_GLdouble(GLdouble *result, GLdouble *matrix1, GL
r3[7] -= m3 * s; r3[7] -= m3 * s;
} }
/* choose pivot - or die */ /* choose pivot - or die */
if (fabsf(r3[2]) > fabsf(r2[2])) if (fabs(r3[2]) > fabs(r2[2]))
SWAP_ROWS_GLdouble(r3, r2); SWAP_ROWS_GLdouble(r3, r2);
if (0.0 == r2[2]) if (0.0 == r2[2])
return 0; return 0;

4
GraphicsView/src/CGAL_Qt5/keyFrameInterpolator.cpp
View File

@ -409,8 +409,8 @@ void KeyFrameInterpolator::drawPath(int mask, int nbFrames, qreal scale) {
glMultMatrixd(fr.matrix()); glMultMatrixd(fr.matrix());
if (mask & 2) if (mask & 2)
drawCamera(scale); drawCamera(scale);
if (mask & 4) //if (mask & 4)
QGLViewer::drawAxis(scale / 10.0); // QGLViewer::drawAxis(scale / 10.0);
glPopMatrix(); glPopMatrix();
} }
} }

548
GraphicsView/src/CGAL_Qt5/qglviewer.cpp
View File

@ -70,11 +70,6 @@ are provided.
See the project main page for details on the project and installation steps. */ See the project main page for details on the project and installation steps. */
void QGLViewer::defaultConstructor() { void QGLViewer::defaultConstructor() {
// Test OpenGL context
// if (glGetString(GL_VERSION) == 0)
// qWarning("Unable to get OpenGL version, context may not be available -
// Check your configuration");
int poolIndex = QGLViewer::QGLViewerPool_.indexOf(NULL); int poolIndex = QGLViewer::QGLViewerPool_.indexOf(NULL);
setFocusPolicy(Qt::StrongFocus); setFocusPolicy(Qt::StrongFocus);
@ -149,6 +144,7 @@ void QGLViewer::defaultConstructor() {
currentlyPressedKey_ = Qt::Key(0); currentlyPressedKey_ = Qt::Key(0);
setAttribute(Qt::WA_NoSystemBackground); setAttribute(Qt::WA_NoSystemBackground);
axisIsDrawn_ = true;
tileRegion_ = NULL; tileRegion_ = NULL;
} }
@ -256,6 +252,153 @@ void QGLViewer::initializeGL() {
} else } else
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//OpenGL buffers and programs initialization
for(int i=0; i<VAO_size; ++i)
{
vaos[i].create();
}
vbos.resize(VBO_size);
for(int i=0; i<VBO_size; ++i)
{
vbos[i].create();
}
//program without light
{
//Vertex source code
const char v_s[] =
{
"#version 120 \n"
"attribute highp vec4 vertex;\n"
"uniform highp mat4 mvp_matrix;\n"
"void main(void)\n"
"{\n"
" gl_Position = mvp_matrix * vertex; \n"
"} \n"
"\n"
};
//Fragment source code
const char f_s[] =
{
"#version 120 \n"
"uniform highp vec4 color; \n"
"void main(void) { \n"
"gl_FragColor = color; \n"
"} \n"
"\n"
};
//It is said in the doc that a QOpenGLShader is
// only destroyed with the QOpenGLShaderProgram
//it has been linked with.
QOpenGLShader vertex_shader(QOpenGLShader::Vertex);
if(!vertex_shader.compileSourceCode(v_s))
{
std::cerr<<"Compiling vertex source FAILED"<<std::endl;
}
QOpenGLShader fragment_shader(QOpenGLShader::Fragment);
if(!fragment_shader.compileSourceCode(f_s))
{
std::cerr<<"Compiling fragmentsource FAILED"<<std::endl;
}
if(!rendering_program.addShader(&vertex_shader))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!rendering_program.addShader(&fragment_shader))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
if(!rendering_program.link())
{
qDebug() << rendering_program.log();
}
}
//program with light
{
//Vertex source code
const char vertex_source[] =
{
"#version 120 \n"
"attribute highp vec4 vertex;\n"
"attribute highp vec3 normal;\n"
"attribute highp vec4 colors;\n"
"uniform highp mat4 mvp_matrix;\n"
"uniform highp mat4 mv_matrix; \n"
"varying highp vec4 fP; \n"
"varying highp vec3 fN; \n"
"varying highp vec4 color; \n"
"void main(void)\n"
"{\n"
" color = vec4(colors.xyz, 1.0f); \n"
" fP = mv_matrix * vertex; \n"
" fN = mat3(mv_matrix)* normal; \n"
" gl_Position = vec4(mvp_matrix * vertex); \n"
"} \n"
"\n"
};
//Fragment source code
const char fragment_source[] =
{
"#version 120 \n"
"varying highp vec4 color; \n"
"varying highp vec4 fP; \n"
"varying highp vec3 fN; \n"
"void main(void) { \n"
" highp vec4 light_pos = vec4(0.0f, 0.0f, 1.0f, 1.0f); \n"
" highp vec4 light_diff = vec4(1.0f, 1.0f, 1.0f, 1.0f); \n"
" highp vec4 light_spec = vec4(0.0f, 0.0f, 0.0f, 1.0f); \n"
" highp vec4 light_amb = vec4(0.4f, 0.4f, 0.4f, 0.4f); \n"
" highp float spec_power = 51.8f ; \n"
" vec3 L = light_pos.xyz - fP.xyz; \n"
" vec3 V = -fP.xyz; \n"
" vec3 N; \n"
" if(fN == vec3(0.0,0.0,0.0)) \n"
" N = vec3(0.0,0.0,0.0); \n"
" else \n"
" N = normalize(fN); \n"
" L = normalize(L); \n"
" V = normalize(V); \n"
" vec3 R = reflect(-L, N); \n"
" vec4 diffuse = max(abs(dot(N,L)),0.0) * light_diff*color; \n"
" vec4 specular = pow(max(dot(R,V), 0.0), spec_power) * light_spec; \n"
"gl_FragColor = color*light_amb + diffuse + specular; \n"
"gl_FragColor = vec4(gl_FragColor.xyz, 1.0f); \n"
"} \n"
"\n"
};
//It is said in the doc that a QOpenGLShader is
// only destroyed with the QOpenGLShaderProgram
//it has been linked with.
QOpenGLShader vertex_shader(QOpenGLShader::Vertex);
if(!vertex_shader.compileSourceCode(vertex_source))
{
std::cerr<<"Compiling vertex source FAILED"<<std::endl;
}
QOpenGLShader fragment_shader(QOpenGLShader::Fragment);
if(!fragment_shader.compileSourceCode(fragment_source))
{
std::cerr<<"Compiling fragmentsource FAILED"<<std::endl;
}
if(!rendering_program_light.addShader(&vertex_shader))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!rendering_program_light.addShader(&fragment_shader))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
if(!rendering_program_light.link())
{
qDebug() << rendering_program_light.log();
}
}
// Calls user defined method. Default emits a signal. // Calls user defined method. Default emits a signal.
init(); init();
@ -334,40 +477,7 @@ that in draw(), the user can rely on the OpenGL context he defined. Respect this
convention (by pushing/popping the different attributes) if you overload this convention (by pushing/popping the different attributes) if you overload this
method. */ method. */
void QGLViewer::postDraw() { void QGLViewer::postDraw() {
// Reset model view matrix to world coordinates origin
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
camera()->loadModelViewMatrix();
// TODO restore model loadProjectionMatrixStereo
// Save OpenGL state
glPushAttrib(GL_ALL_ATTRIB_BITS);
// Set neutral GL state
glDisable(GL_TEXTURE_1D);
glDisable(GL_TEXTURE_2D);
#ifdef GL_TEXTURE_3D // OpenGL 1.2 Only...
glDisable(GL_TEXTURE_3D);
#endif
glDisable(GL_TEXTURE_GEN_Q);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
#ifdef GL_RESCALE_NORMAL // OpenGL 1.2 Only...
glEnable(GL_RESCALE_NORMAL);
#endif
glDisable(GL_COLOR_MATERIAL);
glColor4f(foregroundColor().redF(), foregroundColor().greenF(),
foregroundColor().blueF(), foregroundColor().alphaF());
if (cameraIsEdited())
camera()->drawAllPaths();
// Pivot point, line when camera rolls, zoom region // Pivot point, line when camera rolls, zoom region
drawVisualHints();
if (gridIsDrawn()) { if (gridIsDrawn()) {
glLineWidth(1.0); glLineWidth(1.0);
@ -375,9 +485,10 @@ void QGLViewer::postDraw() {
} }
if (axisIsDrawn()) { if (axisIsDrawn()) {
glLineWidth(2.0); glLineWidth(2.0);
drawAxis(camera()->sceneRadius()); drawAxis(1.0);
} }
drawVisualHints();
// FPS computation // FPS computation
const unsigned int maxCounter = 20; const unsigned int maxCounter = 20;
if (++fpsCounter_ == maxCounter) { if (++fpsCounter_ == maxCounter) {
@ -696,11 +807,8 @@ void QGLViewer::drawLight(GLenum light, qreal scale) const {
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)) #if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
void QGLViewer::renderText(int x, int y, const QString &str, void QGLViewer::renderText(int x, int y, const QString &str,
const QFont &font) { const QFont &font) {
// Retrieve last OpenGL color to use as a font color QColor fontColor = QColor(0, 0,
GLdouble glColor[4]; 0, 255);
glGetDoublev(GL_CURRENT_COLOR, glColor);
QColor fontColor = QColor(255 * glColor[0], 255 * glColor[1],
255 * glColor[2], 255 * glColor[3]);
// Render text // Render text
QPainter painter(this); QPainter painter(this);
@ -3298,7 +3406,65 @@ Limitation : One needs to have access to visualHint_ to overload this method.
Removed from the documentation for this reason. */ Removed from the documentation for this reason. */
void QGLViewer::drawVisualHints() { void QGLViewer::drawVisualHints() {
rendering_program.bind();
vaos[GRID].bind();
QMatrix4x4 mvpMatrix;
double mat[16];
camera()->getModelViewProjectionMatrix(mat);
for(int i=0; i < 16; i++)
{
mvpMatrix.data()[i] = (float)mat[i];
}
QMatrix4x4 mvMatrix;
for(int i=0; i < 16; i++)
{
mvMatrix.data()[i] = camera()->orientation().inverse().matrix()[i];
}
rendering_program.setUniformValue("mvp_matrix", mvpMatrix);
rendering_program.setUniformValue("color", QColor(Qt::lightGray));
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(grid_size));
vaos[GRID].release();
rendering_program.release();
rendering_program_light.bind();
vaos[GRID_AXIS].bind();
rendering_program_light.setUniformValue("mvp_matrix", mvpMatrix);
rendering_program_light.setUniformValue("mv_matrix", mvMatrix);
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(g_axis_size/9));
vaos[GRID_AXIS].release();
qglviewer::Camera::Type camera_type = camera()->type();
camera()->setType(qglviewer::Camera::ORTHOGRAPHIC);
for(int i=0; i < 16; i++)
{
mvMatrix.data()[i] = camera()->orientation().inverse().matrix()[i];
}
mvpMatrix.setToIdentity();
mvpMatrix.ortho(-1,1,-1,1,-1,1);
mvpMatrix = mvpMatrix*mvMatrix;
rendering_program_light.setUniformValue("mvp_matrix", mvpMatrix);
rendering_program_light.setUniformValue("mv_matrix", mvMatrix);
camera()->setType(camera_type);
vaos[AXIS].bind();
int viewport[4];
int scissor[4];
// The viewport and the scissor are changed to fit the upper right
// corner. Original values are saved.
glGetIntegerv(GL_VIEWPORT, viewport);
glGetIntegerv(GL_SCISSOR_BOX, scissor);
// Axis viewport size, in pixels
const int size = 100;
glViewport(width()*devicePixelRatio()-size, height()*devicePixelRatio()-size, size, size);
glScissor (width()*devicePixelRatio()-size, height()*devicePixelRatio()-size, size, size);
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(axis_size / 9));
// The viewport and the scissor are restored.
glScissor(scissor[0],scissor[1],scissor[2],scissor[3]);
glViewport(viewport[0],viewport[1],viewport[2],viewport[3]);
vaos[AXIS].release();
rendering_program_light.release();
} }
/*! Defines the mask that will be used to drawVisualHints(). The only available /*! Defines the mask that will be used to drawVisualHints(). The only available
@ -3319,56 +3485,286 @@ void QGLViewer::resetVisualHints() { visualHint_ = 0; }
// A x i s a n d G r i d d i s p l a y l i s t s // // A x i s a n d G r i d d i s p l a y l i s t s //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/*! Draws a 3D arrow along the positive Z axis. /*! Draws a 3D arrow between the 3D point \p from and the 3D point \p to.
\p data is filled with the three components of a point, then its normal, and then its color, which makes it filled like this:
[P1.x-P1.y-P1.z-N1.x-N1.y-N1.z-C1.r-C1.g-C1.b|P2.x-P2.y-P2.z-N2.x-N2.y-N2.z-C2.r-C2.g-C2.b|...]
*/
void QGLViewer::drawArrow(double r,double R, int prec, qglviewer::Vec from,
qglviewer::Vec to, qglviewer::Vec color,
std::vector<float> &data) {
qglviewer::Vec temp = to-from;
QVector3D dir = QVector3D(temp.x, temp.y, temp.z);
QMatrix4x4 mat;
mat.setToIdentity();
mat.translate(from.x, from.y, from.z);
mat.scale(dir.length());
dir.normalize();
float angle = 0.0;
if(std::sqrt((dir.x()*dir.x()+dir.y()*dir.y())) > 1)
angle = 90.0f;
else
angle =acos(dir.y()/std::sqrt(dir.x()*dir.x()+dir.y()*dir.y()+dir.z()*dir.z()))*180.0/M_PI;
\p length, \p radius and \p nbSubdivisions define its geometry. If \p radius is QVector3D axis;
negative (default), it is set to 0.05 * \p length. axis = QVector3D(dir.z(), 0, -dir.x());
mat.rotate(angle, axis);
Use drawArrow(const Vec& from, const Vec& to, qreal radius, int nbSubdivisions) //Head
or change the \c ModelView matrix to place the arrow in 3D. const float Rf = static_cast<float>(R);
for(int d = 0; d<360; d+= 360/prec)
{
float D = (float) (d * M_PI / 180.);
float a = (float) std::atan(Rf / 0.33);
QVector4D p(0., 1., 0, 1.);
QVector4D n(Rf*sin(D), sin(a), Rf*cos(D), 1.);
QVector4D pR = mat*p;
QVector4D nR = mat*n;
Uses current color and does not modify the OpenGL state. */ //point A1
void QGLViewer::drawArrow(qreal , qreal , int ) { data.push_back(pR.x());
} data.push_back(pR.y());
data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back((float)color.x);
data.push_back((float)color.y);
data.push_back((float)color.z);
/*! Draws a 3D arrow between the 3D point \p from and the 3D point \p to, both //point B1
defined in the current ModelView coordinates system. p = QVector4D(Rf*sin(D), 0.66f, Rf* cos(D), 1.f);
n = QVector4D(sin(D), sin(a), cos(D), 1.);
pR = mat*p;
nR = mat*n;
data.push_back(pR.x());
data.push_back(pR.y());
data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back((float)color.x);
data.push_back((float)color.y);
data.push_back((float)color.z);
//point C1
D = (d+360/prec)*M_PI/180.0;
p = QVector4D(Rf* sin(D), 0.66f, Rf* cos(D), 1.f);
n = QVector4D(sin(D), sin(a), cos(D), 1.0);
pR = mat*p;
nR = mat*n;
See drawArrow(qreal length, qreal radius, int nbSubdivisions) for details. */ data.push_back(pR.x());
void QGLViewer::drawArrow(const Vec &, const Vec &, qreal , data.push_back(pR.y());
int ) { data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back((float)color.x);
data.push_back((float)color.y);
data.push_back((float)color.z);
}
//cylinder
//body of the cylinder
const float rf = static_cast<float>(r);
for(int d = 0; d<360; d+= 360/prec)
{
//point A1
double D = d*M_PI/180.0;
QVector4D p(rf*sin(D), 0.66f, rf*cos(D), 1.f);
QVector4D n(sin(D), 0.f, cos(D), 1.f);
QVector4D pR = mat*p;
QVector4D nR = mat*n;
data.push_back(pR.x());
data.push_back(pR.y());
data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back(color.x);
data.push_back(color.y);
data.push_back(color.z);
//point B1
p = QVector4D(rf * sin(D),0,rf*cos(D), 1.0);
n = QVector4D(sin(D), 0, cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.push_back(pR.x());
data.push_back(pR.y());
data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back(color.x);
data.push_back(color.y);
data.push_back(color.z);
//point C1
D = (d+360/prec)*M_PI/180.0;
p = QVector4D(rf * sin(D),0,rf*cos(D), 1.0);
n = QVector4D(sin(D), 0, cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.push_back(pR.x());
data.push_back(pR.y());
data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back(color.x);
data.push_back(color.y);
data.push_back(color.z);
//point A2
D = (d+360/prec)*M_PI/180.0;
p = QVector4D(rf * sin(D),0,rf*cos(D), 1.0);
n = QVector4D(sin(D), 0, cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.push_back(pR.x());
data.push_back(pR.y());
data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back((float)color.x);
data.push_back((float)color.y);
data.push_back((float)color.z);
//point B2
p = QVector4D(rf * sin(D), 0.66f, rf*cos(D), 1.f);
n = QVector4D(sin(D), 0, cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.push_back(pR.x());
data.push_back(pR.y());
data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back((float)color.x);
data.push_back((float)color.y);
data.push_back((float)color.z);
//point C2
D = d*M_PI/180.0;
p = QVector4D(rf * sin(D), 0.66f, rf*cos(D), 1.f);
n = QVector4D(sin(D), 0.f, cos(D), 1.f);
pR = mat*p;
nR = mat*n;
data.push_back(pR.x());
data.push_back(pR.y());
data.push_back(pR.z());
data.push_back(nR.x());
data.push_back(nR.y());
data.push_back(nR.z());
data.push_back(color.x);
data.push_back(color.y);
data.push_back(color.z);
}
} }
/*! Draws an XYZ axis, with a given size (default is 1.0). /*! Draws an XYZ axis, with a given size (default is 1.0).
The axis position and orientation matches the current modelView matrix state: The axis orientation matches the current modelView matrix state:
three arrows (red, green and blue) of length \p length are drawn along the three arrows (red, green and blue) of length \p length are drawn along the
positive X, Y and Z directions. positive X, Y and Z directions in the top right corner of the screen.
X arrow is red, Y arrow is green and Z arrow is blue.*/
void QGLViewer::drawAxis(qreal length) {
std::vector<float> data;
data.resize(0);
drawArrow(0.06,0.12,10, qglviewer::Vec(0,0,0),qglviewer::Vec(length,0,0),qglviewer::Vec(1,0,0), data);
drawArrow(0.06,0.12,10, qglviewer::Vec(0,0,0),qglviewer::Vec(0,length,0),qglviewer::Vec(0,1,0), data);
drawArrow(0.06,0.12,10, qglviewer::Vec(0,0,0),qglviewer::Vec(0,0,length),qglviewer::Vec(0,0,1), data);
rendering_program_light.bind();
vaos[AXIS].bind();
vbos[Axis].bind();
vbos[Axis].allocate(data.data(), static_cast<int>(data.size()) * sizeof(float));
rendering_program_light.enableAttributeArray("vertex");
rendering_program_light.setAttributeBuffer("vertex",GL_FLOAT,0,3,
static_cast<int>(9*sizeof(float)));
Use the following code to display the current position and orientation of a rendering_program_light.enableAttributeArray("normal");
qglviewer::Frame: \code glPushMatrix(); glMultMatrixd(frame.matrix()); rendering_program_light.setAttributeBuffer("normal",GL_FLOAT,3*sizeof(float),3,
QGLViewer::drawAxis(sceneRadius() / 5.0); // Or any scale static_cast<int>(9*sizeof(float)));
glPopMatrix();
\endcode
The current color and line width are used to draw the X, Y and Z characters at rendering_program_light.enableAttributeArray("colors");
the extremities of the three arrows. The OpenGL state is not modified by this rendering_program_light.setAttributeBuffer("colors",GL_FLOAT,6*sizeof(float),3,
method. static_cast<int>(9*sizeof(float)));
vbos[Axis].release();
axisIsDrawn() uses this method to draw a representation of the world coordinate vaos[AXIS].release();
system. See also QGLViewer::drawArrow() and QGLViewer::drawGrid(). */ axis_size = data.size();
void QGLViewer::drawAxis(qreal) { rendering_program_light.release();
} }
/*! Draws a grid in the XY plane, centered on (0,0,0) (defined in the current /*! Draws a grid in the XY plane, centered on (0,0,0) (defined in the current
coordinate system). coordinate system).
\p size (OpenGL units) and \p nbSubdivisions define its geometry. Set the \c \p size (OpenGL units) and \p nbSubdivisions define its geometry.*/
GL_MODELVIEW matrix to place and orientate the grid in 3D space (see the void QGLViewer::drawGrid(qreal size, int nbSubdivisions) {
drawAxis() documentation).
The OpenGL state is not modified by this method. */ //The Grid
void QGLViewer::drawGrid(qreal , int ) { std::vector<float> v_Grid;
for (int i=0; i<=nbSubdivisions; ++i)
{
const float pos = size*(2.0*i/nbSubdivisions-1.0);
v_Grid.push_back(pos);
v_Grid.push_back(-size);
v_Grid.push_back(0.0);
v_Grid.push_back(pos);
v_Grid.push_back(+size);
v_Grid.push_back(0.0);
v_Grid.push_back(-size);
v_Grid.push_back(pos);
v_Grid.push_back(0.0);
v_Grid.push_back( size);
v_Grid.push_back( pos);
v_Grid.push_back( 0.0);
}
rendering_program.bind();
vaos[GRID].bind();
vbos[Grid].bind();
vbos[Grid].allocate(v_Grid.data(),static_cast<int>(v_Grid.size()*sizeof(float)));
rendering_program.enableAttributeArray("vertex");
rendering_program.setAttributeBuffer("vertex",GL_FLOAT,0,3);
vbos[Grid].release();
vaos[GRID].release();
rendering_program.release();
grid_size = v_Grid.size();
//The Axis
std::vector<float> d_axis;
d_axis.resize(0);
//d_axis is filled by drawArrow always this way : V.x V.y V.z N.x N.y N.z C.r C.g C.b, so it is possible
//to use a single buffer with offset and stride
drawArrow(0.005*size,0.02*size,10, qglviewer::Vec(0,0,0),qglviewer::Vec(size,0,0),qglviewer::Vec(1,0,0), d_axis);
drawArrow(0.005*size,0.02*size,10, qglviewer::Vec(0,0,0),qglviewer::Vec(0,size,0),qglviewer::Vec(0,1,0), d_axis);
rendering_program_light.bind();
vaos[GRID_AXIS].bind();
vbos[Grid_axis].bind();
vbos[Grid_axis].allocate(d_axis.data(), static_cast<int>(d_axis.size()) * sizeof(float));
rendering_program_light.enableAttributeArray("vertex");
rendering_program_light.setAttributeBuffer("vertex",GL_FLOAT,0,3,
static_cast<int>(9*sizeof(float)));
rendering_program_light.enableAttributeArray("normal");
rendering_program_light.setAttributeBuffer("normal",GL_FLOAT,3*sizeof(float),3,
static_cast<int>(9*sizeof(float)));
rendering_program_light.enableAttributeArray("colors");
rendering_program_light.setAttributeBuffer("colors",GL_FLOAT,6*sizeof(float),3,
static_cast<int>(9*sizeof(float)));
vbos[Grid_axis].release();
vaos[GRID_AXIS].release();
rendering_program_light.release();
g_axis_size = d_axis.size();
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////

526
Polyhedron/demo/Polyhedron/Viewer.cpp
View File

@ -32,11 +32,6 @@ public:
bool clipping; bool clipping;
QVector4D clipbox[6]; QVector4D clipbox[6];
QPainter *painter; QPainter *painter;
// F P S d i s p l a y
QTime fpsTime;
unsigned int fpsCounter;
QString fpsString;
float f_p_s;
// M e s s a g e s // M e s s a g e s
QString message; QString message;
bool _displayMessage; bool _displayMessage;
@ -45,14 +40,6 @@ public:
bool is_ogl_4_3; bool is_ogl_4_3;
bool is_2d_selection_mode; bool is_2d_selection_mode;
//! Holds useful data to draw the axis system
struct AxisData
{
std::vector<float> *vertices;
std::vector<float> *normals;
std::vector<float> *colors;
};
//! The buffers used to draw the axis system //! The buffers used to draw the axis system
QOpenGLBuffer buffers[8]; QOpenGLBuffer buffers[8];
//! The VAO used to draw the axis system //! The VAO used to draw the axis system
@ -62,17 +49,6 @@ public:
//! The rendering program used to draw the distance //! The rendering program used to draw the distance
QOpenGLShaderProgram rendering_program_dist; QOpenGLShaderProgram rendering_program_dist;
QList<TextItem*> distance_text; QList<TextItem*> distance_text;
//! Holds the vertices data for the axis system
std::vector<float> v_Axis;
//! Holds the normals data for the axis system
std::vector<float> n_Axis;
//! Holds the color data for the axis system
std::vector<float> c_Axis;
//! Decides if the axis system must be drawn or not
bool axis_are_displayed;
bool grid_is_displayed;
std::size_t grid_size;
std::size_t v_gaxis_size;
//! Decides if the text is displayed in the drawVisualHints function. //! Decides if the text is displayed in the drawVisualHints function.
bool has_text; bool has_text;
//! Decides if the distance between APoint and BPoint must be drawn; //! Decides if the distance between APoint and BPoint must be drawn;
@ -90,18 +66,6 @@ public:
bool extension_is_found; bool extension_is_found;
TextRenderer *textRenderer; TextRenderer *textRenderer;
/*!
* \brief makeArrow creates an arrow and stores it in a struct of vectors.
* \param R the radius of the arrow.
* \param prec the precision of the quadric. The lower this value is, the higher precision you get.
* It can be any int between 1 and 360.
* \param from the starting point of the arrow.
* \param to the destination point of the arrow (the pointed extremity).
* \param color the RGB color of the arrow.
* \param data the struct of std::vector that will contain the results.
*/
void makeArrow(double R, int prec, qglviewer::Vec from, qglviewer::Vec to, qglviewer::Vec color, AxisData &data);
void drawGrid(qreal size, int nbSubdivisions=10);
//!Clears the distance display //!Clears the distance display
void clearDistancedisplay(); void clearDistancedisplay();
void draw_aux(bool with_names, Viewer*); void draw_aux(bool with_names, Viewer*);
@ -133,14 +97,11 @@ Viewer::Viewer(QWidget* parent, bool antialiasing)
this, SLOT(printMessage(QString,int)) ); this, SLOT(printMessage(QString,int)) );
connect(&d->messageTimer, SIGNAL(timeout()), SLOT(hideMessage())); connect(&d->messageTimer, SIGNAL(timeout()), SLOT(hideMessage()));
setShortcut(EXIT_VIEWER, 0); setShortcut(EXIT_VIEWER, 0);
setShortcut(DRAW_AXIS, 0);
setKeyDescription(Qt::Key_T, setKeyDescription(Qt::Key_T,
tr("Turn the camera by 180 degrees")); tr("Turn the camera by 180 degrees"));
setKeyDescription(Qt::Key_M, setKeyDescription(Qt::Key_M,
tr("Toggle macro mode: useful to view details very near from the camera, " tr("Toggle macro mode: useful to view details very near from the camera, "
"but decrease the z-buffer precision")); "but decrease the z-buffer precision"));
setKeyDescription(Qt::Key_A,
tr("Toggle the axis system visibility."));
setKeyDescription(Qt::Key_I + Qt::CTRL, setKeyDescription(Qt::Key_I + Qt::CTRL,
tr("Toggle the primitive IDs visibility of the selected Item.")); tr("Toggle the primitive IDs visibility of the selected Item."));
setKeyDescription(Qt::Key_D, setKeyDescription(Qt::Key_D,
@ -176,19 +137,13 @@ Viewer::Viewer(QWidget* parent, bool antialiasing)
#endif // QGLVIEWER_VERSION >= 2.5.0 #endif // QGLVIEWER_VERSION >= 2.5.0
prev_radius = sceneRadius(); prev_radius = sceneRadius();
d->axis_are_displayed = true;
d->grid_is_displayed = false;
d->grid_size = 0;
d->has_text = false; d->has_text = false;
d->i_is_pressed = false; d->i_is_pressed = false;
d->z_is_pressed = false; d->z_is_pressed = false;
d->fpsTime.start();
d->fpsCounter=0;
d->f_p_s=0.0;
d->fpsString=tr("%1Hz", "Frames per seconds, in Hertz").arg("?");
d->distance_is_displayed = false; d->distance_is_displayed = false;
d->is_d_pressed = false; d->is_d_pressed = false;
d->viewer = this; d->viewer = this;
setTextIsEnabled(true);
} }
Viewer::~Viewer() Viewer::~Viewer()
@ -246,8 +201,6 @@ void Viewer::fastDraw()
void Viewer::initializeGL() void Viewer::initializeGL()
{ {
#if QGLVIEWER_VERSION >= 0x020700
QSurfaceFormat format; QSurfaceFormat format;
format.setDepthBufferSize(24); format.setDepthBufferSize(24);
format.setStencilBufferSize(8); format.setStencilBufferSize(8);
@ -271,30 +224,6 @@ void Viewer::initializeGL()
CGAL_warning_msg(created && context()->isValid(), "The openGL context initialization failed " CGAL_warning_msg(created && context()->isValid(), "The openGL context initialization failed "
"and the default context (2.0) will be used" ); "and the default context (2.0) will be used" );
makeCurrent(); makeCurrent();
#else
QGLFormat format;
format.setVersion(4,3);
format.setProfile(QGLFormat::CompatibilityProfile);
QGLContext *new_context = new QGLContext(format, this);
new_context->setFormat(format);
bool created = new_context->create();
if(!created || new_context->format().profile() != QGLFormat::CompatibilityProfile) {
// impossible to get a 4.3 compatibility profile, retry with 2.0
format.setVersion(2,1);
new_context->setFormat(format);
created = new_context->create();
d->is_ogl_4_3 = false;
}
else
{
d->is_ogl_4_3 = true;
d->_recentFunctions = new QOpenGLFunctions_4_3_Compatibility();
}
CGAL_warning_msg(created && new_context->isValid(), "The openGL context initialization failed "
"and the default context (2.0) will be used" );
this->setContext(new_context);
context()->makeCurrent();
#endif
QGLViewer::initializeGL(); QGLViewer::initializeGL();
initializeOpenGLFunctions(); initializeOpenGLFunctions();
if(isOpenGL_4_3()) if(isOpenGL_4_3())
@ -461,42 +390,6 @@ void Viewer::initializeGL()
qDebug() << d->rendering_program_dist.log(); qDebug() << d->rendering_program_dist.log();
} }
} }
Viewer_impl::AxisData data;
d->v_Axis.resize(0);
d->n_Axis.resize(0);
d->c_Axis.resize(0);
data.vertices = &d->v_Axis;
data.normals = &d->n_Axis;
data.colors = &d->c_Axis;
GLdouble l = 1.0;
d->makeArrow(0.06,10, qglviewer::Vec(0,0,0),qglviewer::Vec(l,0,0),qglviewer::Vec(1,0,0), data);
d->makeArrow(0.06,10, qglviewer::Vec(0,0,0),qglviewer::Vec(0,l,0),qglviewer::Vec(0,1,0), data);
d->makeArrow(0.06,10, qglviewer::Vec(0,0,0),qglviewer::Vec(0,0,l),qglviewer::Vec(0,0,1), data);
d->rendering_program.bind();
d->vao[0].bind();
d->buffers[0].bind();
d->buffers[0].allocate(d->v_Axis.data(), static_cast<int>(d->v_Axis.size()) * sizeof(float));
d->rendering_program.enableAttributeArray("vertex");
d->rendering_program.setAttributeBuffer("vertex",GL_FLOAT,0,3);
d->buffers[0].release();
d->buffers[1].bind();
d->buffers[1].allocate(d->n_Axis.data(), static_cast<int>(d->n_Axis.size() * sizeof(float)));
d->rendering_program.enableAttributeArray("normal");
d->rendering_program.setAttributeBuffer("normal",GL_FLOAT,0,3);
d->buffers[1].release();
d->buffers[2].bind();
d->buffers[2].allocate(d->c_Axis.data(), static_cast<int>(d->c_Axis.size() * sizeof(float)));
d->rendering_program.enableAttributeArray("colors");
d->rendering_program.setAttributeBuffer("colors",GL_FLOAT,0,3);
d->buffers[2].release();
d->vao[0].release();
d->rendering_program.release();
d->painter = new QPainter(); d->painter = new QPainter();
d->initialized = true; d->initialized = true;
} }
@ -577,14 +470,6 @@ void Viewer::keyPressEvent(QKeyEvent* e)
return; return;
} }
else if(e->key() == Qt::Key_A) {
d->axis_are_displayed = !d->axis_are_displayed;
update();
}
else if(e->key() == Qt::Key_G) {
d->grid_is_displayed = !d->grid_is_displayed;
update();
}
else if(e->key() == Qt::Key_I) { else if(e->key() == Qt::Key_I) {
d->i_is_pressed = true; d->i_is_pressed = true;
} }
@ -896,250 +781,10 @@ void Viewer::endSelection(const QPoint&)
d->draw_aux(false, this); d->draw_aux(false, this);
} }
void Viewer_impl::makeArrow(double R, int prec, qglviewer::Vec from, qglviewer::Vec to, qglviewer::Vec color, Viewer_impl::AxisData &data)
{
qglviewer::Vec temp = to-from;
QVector3D dir = QVector3D(temp.x, temp.y, temp.z);
QMatrix4x4 mat;
mat.setToIdentity();
mat.translate(from.x, from.y, from.z);
mat.scale(dir.length());
dir.normalize();
float angle = 0.0;
if(std::sqrt((dir.x()*dir.x()+dir.y()*dir.y())) > 1)
angle = 90.0f;
else
angle =acos(dir.y()/std::sqrt(dir.x()*dir.x()+dir.y()*dir.y()+dir.z()*dir.z()))*180.0/M_PI;
QVector3D axis;
axis = QVector3D(dir.z(), 0, -dir.x());
mat.rotate(angle, axis);
//Head
const float Rf = static_cast<float>(R);
for(int d = 0; d<360; d+= 360/prec)
{
float D = (float) (d * M_PI / 180.);
float a = (float) std::atan(Rf / 0.33);
QVector4D p(0., 1., 0, 1.);
QVector4D n(Rf*2.*sin(D), sin(a), Rf*2.*cos(D), 1.);
QVector4D pR = mat*p;
QVector4D nR = mat*n;
//point A1
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back((float)color.x);
data.colors->push_back((float)color.y);
data.colors->push_back((float)color.z);
//point B1
p = QVector4D(Rf*2.*sin(D), 0.66f, Rf*2.* cos(D), 1.f);
n = QVector4D(sin(D), sin(a), cos(D), 1.);
pR = mat*p;
nR = mat*n;
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back((float)color.x);
data.colors->push_back((float)color.y);
data.colors->push_back((float)color.z);
//point C1
D = (d+360/prec)*M_PI/180.0;
p = QVector4D(Rf*2.* sin(D), 0.66f, Rf *2.* cos(D), 1.f);
n = QVector4D(sin(D), sin(a), cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back((float)color.x);
data.colors->push_back((float)color.y);
data.colors->push_back((float)color.z);
}
//cylinder
//body of the cylinder
for(int d = 0; d<360; d+= 360/prec)
{
//point A1
double D = d*M_PI/180.0;
QVector4D p(Rf*sin(D), 0.66f, Rf*cos(D), 1.f);
QVector4D n(sin(D), 0.f, cos(D), 1.f);
QVector4D pR = mat*p;
QVector4D nR = mat*n;
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back(color.x);
data.colors->push_back(color.y);
data.colors->push_back(color.z);
//point B1
p = QVector4D(Rf * sin(D),0,Rf*cos(D), 1.0);
n = QVector4D(sin(D), 0, cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back(color.x);
data.colors->push_back(color.y);
data.colors->push_back(color.z);
//point C1
D = (d+360/prec)*M_PI/180.0;
p = QVector4D(Rf * sin(D),0,Rf*cos(D), 1.0);
n = QVector4D(sin(D), 0, cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back(color.x);
data.colors->push_back(color.y);
data.colors->push_back(color.z);
//point A2
D = (d+360/prec)*M_PI/180.0;
p = QVector4D(Rf * sin(D),0,Rf*cos(D), 1.0);
n = QVector4D(sin(D), 0, cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back((float)color.x);
data.colors->push_back((float)color.y);
data.colors->push_back((float)color.z);
//point B2
p = QVector4D(Rf * sin(D), 0.66f, Rf*cos(D), 1.f);
n = QVector4D(sin(D), 0, cos(D), 1.0);
pR = mat*p;
nR = mat*n;
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back((float)color.x);
data.colors->push_back((float)color.y);
data.colors->push_back((float)color.z);
//point C2
D = d*M_PI/180.0;
p = QVector4D(Rf * sin(D), 0.66f, Rf*cos(D), 1.f);
n = QVector4D(sin(D), 0.f, cos(D), 1.f);
pR = mat*p;
nR = mat*n;
data.vertices->push_back(pR.x());
data.vertices->push_back(pR.y());
data.vertices->push_back(pR.z());
data.normals->push_back(nR.x());
data.normals->push_back(nR.y());
data.normals->push_back(nR.z());
data.colors->push_back(color.x);
data.colors->push_back(color.y);
data.colors->push_back(color.z);
}
}
void Viewer::drawVisualHints() void Viewer::drawVisualHints()
{ {
QGLViewer::drawVisualHints(); QGLViewer::drawVisualHints();
if(d->axis_are_displayed)
{
d->rendering_program.bind();
qglviewer::Camera::Type camera_type = camera()->type();
camera()->setType(qglviewer::Camera::ORTHOGRAPHIC);
QMatrix4x4 mvpMatrix;
QMatrix4x4 mvMatrix;
for(int i=0; i < 16; i++)
{
mvMatrix.data()[i] = camera()->orientation().inverse().matrix()[i];
}
mvpMatrix.ortho(-1,1,-1,1,-1,1);
mvpMatrix = mvpMatrix*mvMatrix;
camera()->setType(camera_type);
QVector4D position(0.0f,0.0f,1.0f,1.0f );
// define material
QVector4D ambient;
QVector4D diffuse;
QVector4D specular;
GLfloat shininess ;
// Ambient
ambient[0] = 0.29225f;
ambient[1] = 0.29225f;
ambient[2] = 0.29225f;
ambient[3] = 1.0f;
// Diffuse
diffuse[0] = 0.50754f;
diffuse[1] = 0.50754f;
diffuse[2] = 0.50754f;
diffuse[3] = 1.0f;
// Specular
specular[0] = 0.0f;
specular[1] = 0.0f;
specular[2] = 0.0f;
specular[3] = 0.0f;
// Shininess
shininess = 51.2f;
d->rendering_program.setUniformValue("light_pos", position);
d->rendering_program.setUniformValue("mvp_matrix", mvpMatrix);
d->rendering_program.setUniformValue("mv_matrix", mvMatrix);
d->rendering_program.setUniformValue("light_diff", diffuse);
d->rendering_program.setUniformValue("light_spec", specular);
d->rendering_program.setUniformValue("light_amb", ambient);
d->rendering_program.setUniformValue("spec_power", shininess);
d->vao[0].bind();
int viewport[4];
int scissor[4];
// The viewport and the scissor are changed to fit the upper right
// corner. Original values are saved.
glGetIntegerv(GL_VIEWPORT, viewport);
glGetIntegerv(GL_SCISSOR_BOX, scissor);
// Axis viewport size, in pixels
const int size = 100;
glViewport(width()*devicePixelRatio()-size, height()*devicePixelRatio()-size, size, size);
glScissor (width()*devicePixelRatio()-size, height()*devicePixelRatio()-size, size, size);
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(d->v_Axis.size() / 3));
// The viewport and the scissor are restored.
glScissor(scissor[0],scissor[1],scissor[2],scissor[3]);
glViewport(viewport[0],viewport[1],viewport[2],viewport[3]);
d->vao[0].release();
d->rendering_program.release();
}
if(d->distance_is_displayed) if(d->distance_is_displayed)
{ {
@ -1169,82 +814,12 @@ void Viewer::drawVisualHints()
glLineWidth(1.0f); glLineWidth(1.0f);
} }
if(d->grid_is_displayed)
{
//draws the distance
QMatrix4x4 mvpMatrix;
double mat[16];
camera()->getModelViewProjectionMatrix(mat);
//nullifies the translation
for(int i=0; i < 16; i++)
{
mvpMatrix.data()[i] = (float)mat[i];
}
d->rendering_program_dist.bind();
d->rendering_program_dist.setUniformValue("mvp_matrix", mvpMatrix);
d->vao[2].bind();
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->grid_size));
d->vao[2].release();
d->rendering_program_dist.release();
d->rendering_program.bind();
QMatrix4x4 mvMatrix;
for(int i=0; i < 16; i++)
{
mvMatrix.data()[i] = camera()->orientation().inverse().matrix()[i];
}
QVector4D position(0.0f,0.0f,1.0f,1.0f );
// define material
QVector4D ambient;
QVector4D diffuse;
QVector4D specular;
GLfloat shininess ;
// Ambient
ambient[0] = 0.29225f;
ambient[1] = 0.29225f;
ambient[2] = 0.29225f;
ambient[3] = 1.0f;
// Diffuse
diffuse[0] = 0.50754f;
diffuse[1] = 0.50754f;
diffuse[2] = 0.50754f;
diffuse[3] = 1.0f;
// Specular
specular[0] = 0.0f;
specular[1] = 0.0f;
specular[2] = 0.0f;
specular[3] = 0.0f;
// Shininess
shininess = 51.2f;
d->rendering_program.setUniformValue("light_pos", position);
d->rendering_program.setUniformValue("mvp_matrix", mvpMatrix);
d->rendering_program.setUniformValue("mv_matrix", mvMatrix);
d->rendering_program.setUniformValue("light_diff", diffuse);
d->rendering_program.setUniformValue("light_spec", specular);
d->rendering_program.setUniformValue("light_amb", ambient);
d->rendering_program.setUniformValue("spec_power", shininess);
d->vao[3].bind();
// Axis viewport size, in pixels
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(d->v_gaxis_size / 3));
// The viewport and the scissor are restored.
d->vao[3].release();
d->rendering_program.release();
}
if (!d->painter->isActive()) if (!d->painter->isActive())
d->painter->begin(this); d->painter->begin(this);
//So that the text is drawn in front of everything //So that the text is drawn in front of everything
d->painter->beginNativePainting(); d->painter->beginNativePainting();
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
d->painter->endNativePainting(); d->painter->endNativePainting();
//prints FPS
TextItem *fps_text = new TextItem(20, int(1.5*((QApplication::font().pixelSize()>0)?QApplication::font().pixelSize():QApplication::font().pointSize())),0,d->fpsString,false, QFont(), Qt::gray);
if(FPSIsDisplayed())
{
d->textRenderer->addText(fps_text);
}
//Prints the displayMessage //Prints the displayMessage
QFont font = QFont(); QFont font = QFont();
QFontMetrics fm(font); QFontMetrics fm(font);
@ -1254,8 +829,7 @@ void Viewer::drawVisualHints()
d->textRenderer->addText(message_text); d->textRenderer->addText(message_text);
} }
d->textRenderer->draw(this); d->textRenderer->draw(this);
if(FPSIsDisplayed())
d->textRenderer->removeText(fps_text);
if (d->_displayMessage) if (d->_displayMessage)
d->textRenderer->removeText(message_text); d->textRenderer->removeText(message_text);
} }
@ -1414,29 +988,6 @@ void Viewer::paintGL()
doneCurrent(); doneCurrent();
} }
void Viewer::postDraw()
{
#ifdef GL_RESCALE_NORMAL // OpenGL 1.2 Only...
glEnable(GL_RESCALE_NORMAL);
#endif
if (cameraIsEdited())
camera()->drawAllPaths();
// Pivot point, line when camera rolls, zoom region
drawVisualHints();
// FPS computation
const unsigned int maxCounter = 20;
if (++d->fpsCounter == maxCounter)
{
d->f_p_s = 1000.0 * maxCounter / d->fpsTime.restart();
d->fpsString = tr("%1Hz", "Frames per seconds, in Hertz").arg(d->f_p_s, 0, 'f', ((d->f_p_s < 10.0)?1:0));
d->fpsCounter = 0;
}
}
void Viewer::displayMessage(const QString &_message, int delay) void Viewer::displayMessage(const QString &_message, int delay)
{ {
d->message = _message; d->message = _message;
@ -1759,7 +1310,6 @@ qglviewer::Vec Viewer::offset()const { return d->offset; }
void Viewer::setSceneBoundingBox(const qglviewer::Vec &min, const qglviewer::Vec &max) void Viewer::setSceneBoundingBox(const qglviewer::Vec &min, const qglviewer::Vec &max)
{ {
QGLViewer::setSceneBoundingBox(min+d->offset, max+d->offset); QGLViewer::setSceneBoundingBox(min+d->offset, max+d->offset);
d->drawGrid(camera()->sceneRadius());
} }
void Viewer::updateIds(CGAL::Three::Scene_item * item) void Viewer::updateIds(CGAL::Three::Scene_item * item)
@ -1797,79 +1347,7 @@ void Viewer::enableClippingBox(QVector4D box[6])
bool Viewer::isOpenGL_4_3() const { return d->is_ogl_4_3; } bool Viewer::isOpenGL_4_3() const { return d->is_ogl_4_3; }
void Viewer_impl::drawGrid(qreal size, int nbSubdivisions)
{
std::vector<float> v_Grid;
std::vector<float> v_gAxis;
std::vector<float> n_gAxis;
std::vector<float> c_gAxis;
for (int i=0; i<=nbSubdivisions; ++i)
{
const float pos = size*(2.0*i/nbSubdivisions-1.0);
v_Grid.push_back(pos);
v_Grid.push_back(-size);
v_Grid.push_back(0.0);
v_Grid.push_back(pos);
v_Grid.push_back(+size);
v_Grid.push_back(0.0);
v_Grid.push_back(-size);
v_Grid.push_back(pos);
v_Grid.push_back(0.0);
v_Grid.push_back( size);
v_Grid.push_back( pos);
v_Grid.push_back( 0.0);
}
rendering_program_dist.bind();
vao[2].bind();
buffers[4].bind();
buffers[4].allocate(v_Grid.data(),static_cast<int>(v_Grid.size()*sizeof(float)));
rendering_program_dist.enableAttributeArray("vertex");
rendering_program_dist.setAttributeBuffer("vertex",GL_FLOAT,0,3);
buffers[4].release();
vao[2].release();
rendering_program_dist.release();
grid_size = v_Grid.size();
Viewer_impl::AxisData data;
v_gAxis.resize(0);
n_gAxis.resize(0);
c_gAxis.resize(0);
data.vertices = &v_gAxis;
data.normals = &n_gAxis;
data.colors = &c_gAxis;
makeArrow(0.02*size,10, qglviewer::Vec(0,0,0),qglviewer::Vec(size,0,0),qglviewer::Vec(1,0,0), data);
makeArrow(0.02*size,10, qglviewer::Vec(0,0,0),qglviewer::Vec(0,size,0),qglviewer::Vec(0,1,0), data);
makeArrow(0.02*size,10, qglviewer::Vec(0,0,0),qglviewer::Vec(0,0,size),qglviewer::Vec(0,0,1), data);
rendering_program.bind();
vao[3].bind();
buffers[5].bind();
buffers[5].allocate(v_gAxis.data(), static_cast<int>(v_gAxis.size()) * sizeof(float));
rendering_program.enableAttributeArray("vertex");
rendering_program.setAttributeBuffer("vertex",GL_FLOAT,0,3);
buffers[5].release();
buffers[6].bind();
buffers[6].allocate(n_gAxis.data(), static_cast<int>(n_gAxis.size() * sizeof(float)));
rendering_program.enableAttributeArray("normal");
rendering_program.setAttributeBuffer("normal",GL_FLOAT,0,3);
buffers[6].release();
buffers[7].bind();
buffers[7].allocate(c_gAxis.data(), static_cast<int>(c_gAxis.size() * sizeof(float)));
rendering_program.enableAttributeArray("colors");
rendering_program.setAttributeBuffer("colors",GL_FLOAT,0,3);
buffers[7].release();
vao[3].release();
rendering_program.release();
v_gaxis_size = v_gAxis.size();
}
QOpenGLFunctions_4_3_Compatibility* Viewer::openGL_4_3_functions() { return d->_recentFunctions; } QOpenGLFunctions_4_3_Compatibility* Viewer::openGL_4_3_functions() { return d->_recentFunctions; }
void Viewer::set2DSelectionMode(bool b) { d->is_2d_selection_mode = b; } void Viewer::set2DSelectionMode(bool b) { d->is_2d_selection_mode = b; }

1
Polyhedron/demo/Polyhedron/Viewer.h
View File

@ -131,7 +131,6 @@ public Q_SLOTS:
} }
protected: protected:
void postDraw()Q_DECL_OVERRIDE;
void paintEvent(QPaintEvent *)Q_DECL_OVERRIDE; void paintEvent(QPaintEvent *)Q_DECL_OVERRIDE;
void paintGL()Q_DECL_OVERRIDE; void paintGL()Q_DECL_OVERRIDE;