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

move attrib_buffers and getShaderProgram to Viewer

This commit is contained in:
Laurent Rineau 2015-10-29 18:43:31 +01:00
parent 34e469bbdc
commit b73d1662e0
5 changed files with 312 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

285
Polyhedron/demo/Polyhedron/Scene_item.cpp
View File

@ -116,276 +116,33 @@ void Scene_item::select(double /*orig_x*/,
}
// set-up the uniform attributes of the shader programs.
void Scene_item::attrib_buffers(CGAL::Three::Viewer_interface* viewer, int program_name) const
void Scene_item::attrib_buffers(CGAL::Three::Viewer_interface* viewer,
int program_name) const
{
GLint is_both_sides = 0;
//ModelViewMatrix used for the transformation of the camera.
QMatrix4x4 mvp_mat;
// ModelView Matrix used for the lighting system
QMatrix4x4 mv_mat;
// transformation of the manipulated frame
QMatrix4x4 f_mat;
// used for the picking. Is Identity except while selecting an item.
QMatrix4x4 pick_mat;
f_mat.setToIdentity();
//fills the MVP and MV matrices.
GLdouble d_mat[16];
viewer->camera()->getModelViewProjectionMatrix(d_mat);
//Convert the GLdoubles matrices in GLfloats
for (int i=0; i<16; ++i){
mvp_mat.data()[i] = GLfloat(d_mat[i]);
}
viewer->camera()->getModelViewMatrix(d_mat);
for (int i=0; i<16; ++i)
mv_mat.data()[i] = GLfloat(d_mat[i]);
for (int i=0; i<16; ++i)
pick_mat.data()[i] = viewer->pickMatrix_[i];
mvp_mat = pick_mat * mvp_mat;
viewer->glGetIntegerv(GL_LIGHT_MODEL_TWO_SIDE, &is_both_sides);
QVector4D position(0.0f,0.0f,1.0f, 1.0f );
QVector4D ambient(0.4f, 0.4f, 0.4f, 0.4f);
// Diffuse
QVector4D diffuse(1.0f, 1.0f, 1.0f, 1.0f);
// Specular
QVector4D specular(0.0f, 0.0f, 0.0f, 1.0f);
QColor temp = this->color();
switch(program_name)
viewer->attrib_buffers(program_name);
QColor c = this->color();
if(program_name == Scene_item::PROGRAM_WITH_TEXTURE)
{
case PROGRAM_WITH_LIGHT:
shader_programs[PROGRAM_WITH_LIGHT]->bind();
shader_programs[PROGRAM_WITH_LIGHT]->setUniformValue("mvp_matrix", mvp_mat);
shader_programs[PROGRAM_WITH_LIGHT]->setUniformValue("mv_matrix", mv_mat);
shader_programs[PROGRAM_WITH_LIGHT]->setUniformValue("light_pos", position);
shader_programs[PROGRAM_WITH_LIGHT]->setUniformValue("light_diff",diffuse);
shader_programs[PROGRAM_WITH_LIGHT]->setUniformValue("light_spec", specular);
shader_programs[PROGRAM_WITH_LIGHT]->setUniformValue("light_amb", ambient);
shader_programs[PROGRAM_WITH_LIGHT]->setUniformValue("spec_power", 51.8f);
shader_programs[PROGRAM_WITH_LIGHT]->setUniformValue("is_two_side", is_both_sides);
shader_programs[PROGRAM_WITH_LIGHT]->release();
break;
case PROGRAM_WITHOUT_LIGHT:
shader_programs[PROGRAM_WITHOUT_LIGHT]->bind();
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("mvp_matrix", mvp_mat);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("mv_matrix", mv_mat);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("light_pos", position);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("light_diff", diffuse);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("light_spec", specular);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("light_amb", ambient);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("spec_power", 51.8f);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("is_two_side", is_both_sides);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setAttributeValue("normals", 0.0,0.0,0.0);
shader_programs[PROGRAM_WITHOUT_LIGHT]->setUniformValue("f_matrix",f_mat);
shader_programs[PROGRAM_WITHOUT_LIGHT]->release();
break;
case PROGRAM_WITH_TEXTURE:
if(is_selected)
{
shader_programs[PROGRAM_WITH_TEXTURE]->setAttributeValue("color_facets", temp.lighter(120).redF(),temp.lighter(120).greenF(), temp.lighter(120).blueF());
}
else
{
shader_programs[PROGRAM_WITH_TEXTURE]->setAttributeValue("color_facets", temp.redF(),temp.greenF(), temp.blueF());
}
shader_programs[PROGRAM_WITH_TEXTURE]->bind();
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("mvp_matrix", mvp_mat);
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("mv_matrix", mv_mat);
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("light_pos", position);
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("light_diff",diffuse);
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("light_spec", specular);
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("light_amb", ambient);
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("spec_power", 51.8f);
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("s_texture",0);
shader_programs[PROGRAM_WITH_TEXTURE]->setUniformValue("f_matrix",f_mat);
shader_programs[PROGRAM_WITH_TEXTURE]->release();
break;
case PROGRAM_WITH_TEXTURED_EDGES:
shader_programs[PROGRAM_WITH_TEXTURED_EDGES]->bind();
if(is_selected)
{
shader_programs[PROGRAM_WITH_TEXTURED_EDGES]->setUniformValue("color_lines",QVector3D(0.0,0.0,0.0));
}
else
{
shader_programs[PROGRAM_WITH_TEXTURED_EDGES]->setUniformValue("color_lines", QVector3D(temp.lighter(50).redF(), temp.lighter(50).greenF(), temp.lighter(50).blueF()));
}
shader_programs[PROGRAM_WITH_TEXTURED_EDGES]->setUniformValue("mvp_matrix", mvp_mat);
shader_programs[PROGRAM_WITH_TEXTURED_EDGES]->setUniformValue("s_texture",0);
shader_programs[PROGRAM_WITH_TEXTURED_EDGES]->release();
break;
case PROGRAM_INSTANCED:
shader_programs[PROGRAM_INSTANCED]->bind();
shader_programs[PROGRAM_INSTANCED]->setUniformValue("mvp_matrix", mvp_mat);
shader_programs[PROGRAM_INSTANCED]->setUniformValue("mv_matrix", mv_mat);
shader_programs[PROGRAM_INSTANCED]->setUniformValue("light_pos", position);
shader_programs[PROGRAM_INSTANCED]->setUniformValue("light_diff",diffuse);
shader_programs[PROGRAM_INSTANCED]->setUniformValue("light_spec", specular);
shader_programs[PROGRAM_INSTANCED]->setUniformValue("light_amb", ambient);
shader_programs[PROGRAM_INSTANCED]->setUniformValue("spec_power", 51.8f);
shader_programs[PROGRAM_INSTANCED]->setUniformValue("is_two_side", is_both_sides);
shader_programs[PROGRAM_INSTANCED]->release();
break;
case PROGRAM_INSTANCED_WIRE:
shader_programs[PROGRAM_INSTANCED_WIRE]->bind();
shader_programs[PROGRAM_INSTANCED_WIRE]->setUniformValue("mvp_matrix", mvp_mat);
shader_programs[PROGRAM_INSTANCED_WIRE]->release();
break;
if(is_selected) c = c.lighter(120);
viewer->getShaderProgram(program_name)->setAttributeValue
("color_facets",
c.redF(),
c.greenF(),
c.blueF());
}
else if(program_name == PROGRAM_WITH_TEXTURED_EDGES)
{
if(is_selected) c = c.lighter(50);
viewer->getShaderProgram(program_name)->setUniformValue
("color_lines",
QVector3D(c.redF(), c.greenF(), c.blueF()));
}
}
QOpenGLShaderProgram* Scene_item::getShaderProgram(int name, CGAL::Three::Viewer_interface * viewer) const
{
switch(name)
{
case PROGRAM_WITH_LIGHT:
if(shader_programs[PROGRAM_WITH_LIGHT])
{
return shader_programs[PROGRAM_WITH_LIGHT];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_with_light.v"))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_with_light.f"))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
shader_programs[PROGRAM_WITH_LIGHT] = program;
return program;
}
break;
case PROGRAM_WITHOUT_LIGHT:
if( shader_programs[PROGRAM_WITHOUT_LIGHT])
{
return shader_programs[PROGRAM_WITHOUT_LIGHT];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_without_light.v"))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_without_light.f"))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
shader_programs[PROGRAM_WITHOUT_LIGHT] = program;
return program;
}
break;
case PROGRAM_WITH_TEXTURE:
if( shader_programs[PROGRAM_WITH_TEXTURE])
{
return shader_programs[PROGRAM_WITH_TEXTURE];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_with_texture.v"))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_with_texture.f"))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
shader_programs[PROGRAM_WITH_TEXTURE] = program;
return program;
}
break;
case PROGRAM_WITH_TEXTURED_EDGES:
if( shader_programs[PROGRAM_WITH_TEXTURED_EDGES])
{
return shader_programs[PROGRAM_WITH_TEXTURED_EDGES];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_with_textured_edges.v" ))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_with_textured_edges.f" ))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
shader_programs[PROGRAM_WITH_TEXTURED_EDGES] = program;
return program;
}
break;
case PROGRAM_INSTANCED:
if( shader_programs[PROGRAM_INSTANCED])
{
return shader_programs[PROGRAM_INSTANCED];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_instanced.v" ))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_with_light.f" ))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
shader_programs[PROGRAM_INSTANCED] = program;
return program;
}
break;
case PROGRAM_INSTANCED_WIRE:
if( shader_programs[PROGRAM_INSTANCED_WIRE])
{
return shader_programs[PROGRAM_INSTANCED_WIRE];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_instanced.v" ))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_without_light.f" ))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
shader_programs[PROGRAM_INSTANCED_WIRE] = program;
return program;
}
break;
default:
std::cerr<<"ERROR : Program not found."<<std::endl;
return 0;
}
if(viewer == 0)
viewer = dynamic_cast<CGAL::Three::Viewer_interface*>(*QGLViewer::QGLViewerPool().begin());
return viewer->getShaderProgram(name);
}

23
Polyhedron/demo/Polyhedron/Scene_item.h
View File

@ -56,8 +56,7 @@ public:
defaultContextMenu(0),
buffersSize(20),
vaosSize(10),
vaos(10),
shader_programs(NB_OF_PROGRAMS)
vaos(10)
{
is_monochrome = true;
for(int i=0; i<vaosSize; i++)
@ -88,8 +87,7 @@ public:
defaultContextMenu(0),
buffersSize(buffers_size),
vaosSize(vaos_size),
vaos(vaos_size),
shader_programs(NB_OF_PROGRAMS)
vaos(vaos_size)
{
is_monochrome = true;
for(int i=0; i<vaosSize; i++)
@ -339,19 +337,6 @@ protected:
vaos[i] = n_vao;
}
//! Contains all the programs for the item rendering.
mutable std::vector<QOpenGLShaderProgram*> shader_programs;
/*! Returns a program according to name.
* If the program does not exist yet, it is created and stored in #shader_programs.
* name cans be :
* - PROGRAM_WITH_LIGHT : used for the facets
* - PROGRAM_WITHOUT_LIGHT : used for the points and lines
* - PROGRAM_WITH_TEXTURE : used for textured facets
* - PROGRAM_WITH_TEXTURED_EDGES : use dfor textured edges
* - PROGRAM_INSTANCED : used for items that have to be rendered numerous times(spheres)
* - PROGRAM_INSTANCED_WIRE : used for the wireframe mode of PROGRAM_INSTANCED
* @returns a pointer to the corresponding program.*/
QOpenGLShaderProgram* getShaderProgram(int name , CGAL::Three::Viewer_interface *viewer = 0) const;
//! Used pass data to the shader.
int vertexLoc;
//! Used pass data to the shader.
@ -372,8 +357,8 @@ protected:
*/
virtual void attrib_buffers(CGAL::Three::Viewer_interface*, int program_name) const;
/*! Compatibility function. Calls `viewer->getShaderProgram()`. */
virtual QOpenGLShaderProgram* getShaderProgram(int name , CGAL::Three::Viewer_interface *viewer = 0) const;
}; // end class Scene_item

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

@ -6,7 +6,9 @@
#include <QGLViewer/manipulatedCameraFrame.h>
#include <QDebug>
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <cmath>
class Viewer_impl {
public:
CGAL::Three::Scene_draw_interface* scene;
@ -16,6 +18,9 @@ public:
bool inFastDrawing;
void draw_aux(bool with_names, Viewer*);
//! Contains all the programs for the item rendering.
mutable std::vector<QOpenGLShaderProgram*> shader_programs;
};
Viewer::Viewer(QWidget* parent, bool antialiasing)
: CGAL::Three::Viewer_interface(parent)
@ -25,6 +30,7 @@ Viewer::Viewer(QWidget* parent, bool antialiasing)
d->antialiasing = antialiasing;
d->twosides = false;
d->macro_mode = false;
d->shader_programs.resize(NB_OF_PROGRAMS);
setShortcut(EXIT_VIEWER, 0);
setShortcut(DRAW_AXIS, 0);
setKeyDescription(Qt::Key_T,
@ -404,6 +410,110 @@ QString Viewer::dumpCameraCoordinates()
}
}
void Viewer::attrib_buffers(int program_name) const {
GLint is_both_sides = 0;
//ModelViewMatrix used for the transformation of the camera.
QMatrix4x4 mvp_mat;
// ModelView Matrix used for the lighting system
QMatrix4x4 mv_mat;
// transformation of the manipulated frame
QMatrix4x4 f_mat;
// used for the picking. Is Identity except while selecting an item.
QMatrix4x4 pick_mat;
f_mat.setToIdentity();
//fills the MVP and MV matrices.
GLdouble d_mat[16];
this->camera()->getModelViewProjectionMatrix(d_mat);
//Convert the GLdoubles matrices in GLfloats
for (int i=0; i<16; ++i){
mvp_mat.data()[i] = GLfloat(d_mat[i]);
}
this->camera()->getModelViewMatrix(d_mat);
for (int i=0; i<16; ++i)
mv_mat.data()[i] = GLfloat(d_mat[i]);
for (int i=0; i<16; ++i)
pick_mat.data()[i] = this->pickMatrix_[i];
mvp_mat = pick_mat * mvp_mat;
const_cast<Viewer*>(this)->glGetIntegerv(GL_LIGHT_MODEL_TWO_SIDE,
&is_both_sides);
QVector4D position(0.0f,0.0f,1.0f, 1.0f );
QVector4D ambient(0.4f, 0.4f, 0.4f, 0.4f);
// Diffuse
QVector4D diffuse(1.0f, 1.0f, 1.0f, 1.0f);
// Specular
QVector4D specular(0.0f, 0.0f, 0.0f, 1.0f);
QOpenGLShaderProgram* program = getShaderProgram(program_name);
program->bind();
switch(program_name)
{
/// @TODO: factorize that implementation!
case PROGRAM_WITH_LIGHT:
program->setUniformValue("mvp_matrix", mvp_mat);
program->setUniformValue("mv_matrix", mv_mat);
program->setUniformValue("light_pos", position);
program->setUniformValue("light_diff",diffuse);
program->setUniformValue("light_spec", specular);
program->setUniformValue("light_amb", ambient);
program->setUniformValue("spec_power", 51.8f);
program->setUniformValue("is_two_side", is_both_sides);
break;
case PROGRAM_WITHOUT_LIGHT:
program->setUniformValue("mvp_matrix", mvp_mat);
program->setUniformValue("mv_matrix", mv_mat);
program->setUniformValue("light_pos", position);
program->setUniformValue("light_diff", diffuse);
program->setUniformValue("light_spec", specular);
program->setUniformValue("light_amb", ambient);
program->setUniformValue("spec_power", 51.8f);
program->setUniformValue("is_two_side", is_both_sides);
program->setAttributeValue("normals", 0.0,0.0,0.0);
program->setUniformValue("f_matrix",f_mat);
break;
case PROGRAM_WITH_TEXTURE:
program->setUniformValue("mvp_matrix", mvp_mat);
program->setUniformValue("mv_matrix", mv_mat);
program->setUniformValue("light_pos", position);
program->setUniformValue("light_diff",diffuse);
program->setUniformValue("light_spec", specular);
program->setUniformValue("light_amb", ambient);
program->setUniformValue("spec_power", 51.8f);
program->setUniformValue("s_texture",0);
program->setUniformValue("f_matrix",f_mat);
break;
case PROGRAM_WITH_TEXTURED_EDGES:
program->setUniformValue("mvp_matrix", mvp_mat);
program->setUniformValue("s_texture",0);
break;
case PROGRAM_INSTANCED:
program->setUniformValue("mvp_matrix", mvp_mat);
program->setUniformValue("mv_matrix", mv_mat);
program->setUniformValue("light_pos", position);
program->setUniformValue("light_diff",diffuse);
program->setUniformValue("light_spec", specular);
program->setUniformValue("light_amb", ambient);
program->setUniformValue("spec_power", 51.8f);
program->setUniformValue("is_two_side", is_both_sides);
break;
case PROGRAM_INSTANCED_WIRE:
program->setUniformValue("mvp_matrix", mvp_mat);
break;
}
program->release();
}
void Viewer::pickMatrix(GLdouble x, GLdouble y, GLdouble width, GLdouble height,
GLint viewport[4])
@ -761,3 +871,148 @@ void Viewer::resizeGL(int w, int h)
rendering_program.release();
}
QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
{
// workaround constness issues in Qt
Viewer* viewer = const_cast<Viewer*>(this);
switch(name)
{
/// @TODO: factorize this code
case PROGRAM_WITH_LIGHT:
if(d->shader_programs[PROGRAM_WITH_LIGHT])
{
return d->shader_programs[PROGRAM_WITH_LIGHT];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_with_light.v"))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_with_light.f"))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
d->shader_programs[PROGRAM_WITH_LIGHT] = program;
return program;
}
break;
case PROGRAM_WITHOUT_LIGHT:
if( d->shader_programs[PROGRAM_WITHOUT_LIGHT])
{
return d->shader_programs[PROGRAM_WITHOUT_LIGHT];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_without_light.v"))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_without_light.f"))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
d->shader_programs[PROGRAM_WITHOUT_LIGHT] = program;
return program;
}
break;
case PROGRAM_WITH_TEXTURE:
if( d->shader_programs[PROGRAM_WITH_TEXTURE])
{
return d->shader_programs[PROGRAM_WITH_TEXTURE];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_with_texture.v"))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_with_texture.f"))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
d->shader_programs[PROGRAM_WITH_TEXTURE] = program;
return program;
}
break;
case PROGRAM_WITH_TEXTURED_EDGES:
if( d->shader_programs[PROGRAM_WITH_TEXTURED_EDGES])
{
return d->shader_programs[PROGRAM_WITH_TEXTURED_EDGES];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_with_textured_edges.v" ))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_with_textured_edges.f" ))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
d->shader_programs[PROGRAM_WITH_TEXTURED_EDGES] = program;
return program;
}
break;
case PROGRAM_INSTANCED:
if( d->shader_programs[PROGRAM_INSTANCED])
{
return d->shader_programs[PROGRAM_INSTANCED];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_instanced.v" ))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_with_light.f" ))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
d->shader_programs[PROGRAM_INSTANCED] = program;
return program;
}
break;
case PROGRAM_INSTANCED_WIRE:
if( d->shader_programs[PROGRAM_INSTANCED_WIRE])
{
return d->shader_programs[PROGRAM_INSTANCED_WIRE];
}
else
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer);
if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,":/cgal/Polyhedron_3/resources/shader_instanced.v" ))
{
std::cerr<<"adding vertex shader FAILED"<<std::endl;
}
if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,":/cgal/Polyhedron_3/resources/shader_without_light.f" ))
{
std::cerr<<"adding fragment shader FAILED"<<std::endl;
}
program->link();
d->shader_programs[PROGRAM_INSTANCED_WIRE] = program;
return program;
}
break;
default:
std::cerr<<"ERROR : Program not found."<<std::endl;
return 0;
}
}

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

@ -59,6 +59,10 @@ public:
bool antiAliasing() const;
//! @returns the fastDrawing state.
bool inFastDrawing() const;
//! Implementation of `Viewer_interface::attrib_buffers()`
void attrib_buffers(int program_name) const;
//! Implementation of `Viewer_interface::getShaderProgram()`
QOpenGLShaderProgram* getShaderProgram(int name) const;
public Q_SLOTS:
//! Sets the antialiasing to true or false.

28
Three/include/CGAL/Three/Viewer_interface.h
View File

@ -30,6 +30,8 @@
class QWidget;
class QMouseEvent;
class QKeyEvent;
class QOpenGLShaderProgram;
//! \file Viewer_interface.h
#include "../Viewer_config.h" // for VIEWER_EXPORT
namespace CGAL{
@ -41,6 +43,14 @@ class VIEWER_EXPORT Viewer_interface : public QGLViewer, public QOpenGLFunctions
Q_OBJECT
public:
enum OpenGL_program_IDs { PROGRAM_WITH_LIGHT,
PROGRAM_WITHOUT_LIGHT,
PROGRAM_WITH_TEXTURE,
PROGRAM_WITH_TEXTURED_EDGES,
PROGRAM_INSTANCED,
PROGRAM_INSTANCED_WIRE,
NB_OF_PROGRAMS };
Viewer_interface(QWidget* parent) : QGLViewer(CGAL::Qt::createOpenGLContext(), parent) {}
virtual ~Viewer_interface() {}
@ -57,6 +67,24 @@ public:
static QString dumpFrame(const qglviewer::Frame&);
//! @returns the fastDrawing state.
virtual bool inFastDrawing() const = 0;
/*! Passes all the uniform data to the shaders.
* According to program_name, this data may change.
*/
virtual void attrib_buffers(int program_name) const = 0;
/*! Returns a program according to name.
* If the program does not exist yet, it is created and stored in #shader_programs.
* name cans be :
* - PROGRAM_WITH_LIGHT : used for the facets
* - PROGRAM_WITHOUT_LIGHT : used for the points and lines
* - PROGRAM_WITH_TEXTURE : used for textured facets
* - PROGRAM_WITH_TEXTURED_EDGES : use dfor textured edges
* - PROGRAM_INSTANCED : used for items that have to be rendered numerous times(spheres)
* - PROGRAM_INSTANCED_WIRE : used for the wireframe mode of PROGRAM_INSTANCED
* @returns a pointer to the corresponding program.*/
virtual QOpenGLShaderProgram* getShaderProgram(int name) const = 0;
//!Allows OpenGL 2.1 context to get access to glDrawArraysInstanced.
typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDARBPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
//!Allows OpenGL 2.1 context to get access to glVertexAttribDivisor.