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

WIP

This commit is contained in:
Maxime Gimeno 2018-09-14 15:35:01 +02:00
parent 382a89eb9d
commit a05e0f5fa2
21 changed files with 608 additions and 629 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Polyhedron/demo/Polyhedron/Edge_container.cpp
View File

@ -16,6 +16,9 @@ struct Edge_d{
QVector4D plane;
QMatrix4x4 f_matrix;
GLfloat width;
QVector2D viewport;
bool is_surface;
};
Edge_container::Edge_container(int program, bool indexed)
@ -85,13 +88,13 @@ void Edge_container::initGL(Viewer_interface *viewer)
QOpenGLBuffer::VertexBuffer, GL_FLOAT, 0, 1));
getVao(viewer)->addVbo(getVbo(Radius));
}
if(viewer->getShaderProgram(getProgram())->property("hasBarycenter").toBool())
if(viewer->getShaderProgram(getProgram())->property("hasCenter").toBool())
{
if(!getVbo(Barycenters))
setVbo(Barycenters,
new Vbo("barycenter",
if(!getVbo(Centers))
setVbo(Centers,
new Vbo("Center",
Vbo::GEOMETRY));
getVao(viewer)->addVbo(getVbo(Barycenters));
getVao(viewer)->addVbo(getVbo(Centers));
}
}
@ -105,8 +108,8 @@ void Edge_container::initializeBuffers(Viewer_interface *viewer)
if(viewer->getShaderProgram(getProgram())->property("isInstanced").toBool())
{
getVao(viewer)->bind();
if(viewer->getShaderProgram(getProgram())->property("hasBarycenter").toBool())
viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("barycenter"), 1);
if(viewer->getShaderProgram(getProgram())->property("hasCenter").toBool())
viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("center"), 1);
if(viewer->getShaderProgram(getProgram())->property("hasRadius").toBool())
viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("radius"), 1);
viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("colors"), 1);
@ -141,15 +144,25 @@ void Edge_container::draw(Viewer_interface *viewer,
getVao(viewer)->program->setUniformValue("cutplane", d->plane);
if(getVao(viewer)->program->property("hasFMatrix").toBool())
getVao(viewer)->program->setUniformValue("f_matrix", getFrameMatrix());
if(getVao(viewer)->program->property("hasViewport").toBool())
{
getVao(viewer)->program->setUniformValue("viewport", getViewport());
getVao(viewer)->program->setUniformValue("near",(GLfloat)viewer->camera()->zNear());
getVao(viewer)->program->setUniformValue("far",(GLfloat)viewer->camera()->zFar());
}
if(getVao(viewer)->program->property("hasWidth").toBool())
getVao(viewer)->program->setUniformValue("width", getWidth());
if(viewer->getShaderProgram(getProgram())->property("isInstanced").toBool())
{
viewer->glDrawArraysInstanced(GL_LINES, 0,
static_cast<GLsizei>(getFlatDataSize()/3),
static_cast<GLsizei>(getFlatDataSize()/getTupleSize()),
static_cast<GLsizei>(getCenterSize()/3));
}
else
{
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(getFlatDataSize()/3));
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(getFlatDataSize()/getTupleSize()));
}
getVao(viewer)->release();
@ -158,6 +171,11 @@ void Edge_container::draw(Viewer_interface *viewer,
QVector4D Edge_container::getPlane() const { return d->plane; }
QMatrix4x4 Edge_container::getFrameMatrix() const { return d->f_matrix; }
GLfloat Edge_container::getWidth() const { return d->width; }
QVector2D Edge_container::getViewport() const { return d->viewport; }
void Edge_container::setPlane(const QVector4D& p) { d->plane = p; }
void Edge_container::setFrameMatrix(const QMatrix4x4& m) { d->f_matrix = m; }
void Edge_container::setWidth(const GLfloat & w) { d->width = w; }
void Edge_container::setViewport(const QVector2D & v) { d-> viewport = v; }
void Edge_container::setIsSurface (const bool b) { d->is_surface = b; }

2
Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp
View File

@ -69,7 +69,6 @@ Polyhedron_demo_c3t3_binary_io_plugin::load(QFileInfo fileinfo) {
if(fileinfo.suffix().toLower() == "cgal")
{
item->setName(fileinfo.baseName());
item->setScene(scene);
if(item->load_binary(in)) {
@ -102,7 +101,6 @@ Polyhedron_demo_c3t3_binary_io_plugin::load(QFileInfo fileinfo) {
Scene_c3t3_item* item = new Scene_c3t3_item();
item->setName(fileinfo.baseName());
item->setScene(scene);
item->set_valid(false);
if(CGAL::build_triangulation_from_file<C3t3::Triangulation, true>(in, item->c3t3().triangulation()))

5
Polyhedron/demo/Polyhedron/Point_container.cpp
View File

@ -15,6 +15,7 @@ struct Point_d{
QVector4D plane;
QMatrix4x4 f_matrix;
bool is_surface;
};
Point_container::Point_container(int program, bool indexed)
@ -105,7 +106,7 @@ void Point_container::draw(Viewer_interface *viewer,
getVao(viewer)->program->setAttributeValue("colors", getColor());
if(getVao(viewer)->program->property("hasFMatrix").toBool())
getVao(viewer)->program->setUniformValue("f_matrix", getFrameMatrix());
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(getFlatDataSize()/3));
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(getFlatDataSize()/getTupleSize()));
getVao(viewer)->release();
}
@ -115,3 +116,5 @@ QVector4D Point_container::getPlane() const { return d->plane; }
QMatrix4x4 Point_container::getFrameMatrix() const { return d->f_matrix; }
void Point_container::setFrameMatrix(const QMatrix4x4& m) { d->f_matrix = m; }
void Point_container::setPlane(const QVector4D& p) { d->plane = p; }
void Point_container::setIsSurface (const bool b) { d->is_surface = b; }

4
Polyhedron/demo/Polyhedron/Primitive_container.cpp
View File

@ -9,6 +9,7 @@ struct D
is_selected(false),
flat_size(0),
idx_size(0),
tuple_size(3),
color(QColor())
{}
QMap<CGAL::Three::Viewer_interface*, Vao*> VAOs;
@ -21,6 +22,7 @@ struct D
std::size_t flat_size;
std::size_t center_size;
std::size_t idx_size;
int tuple_size;
QColor color;
};
@ -179,6 +181,7 @@ void Primitive_container::setOffset(std::size_t id, int offset) {
d->VBOs[id]->offset = offset;
}
void Primitive_container::setTupleSize(int ts) { d->tuple_size = ts; }
int Primitive_container::getProgram() const { return d->program_id; }
bool Primitive_container::isDataIndexed() { return d->indexed; }
@ -201,3 +204,4 @@ std::size_t Primitive_container::getIdxSize() const { return d->idx_size; }
QColor Primitive_container::getColor()const { return d->color; }
int Primitive_container::getTupleSize() const { return d->tuple_size; }

1
Polyhedron/demo/Polyhedron/Scene.cpp
View File

@ -1593,7 +1593,6 @@ void Scene::addGroup(Scene_group_item* group)
connect(this, SIGNAL(drawFinished()), group, SLOT(resetDraw()));
connect(this, SIGNAL(indexErased(Scene_interface::Item_id)),
group, SLOT(adjustIds(Scene_interface::Item_id)));
group->setScene(this);
}
namespace scene { namespace details {

604
Polyhedron/demo/Polyhedron/Scene_c3t3_item.cpp
View File

@ -13,11 +13,16 @@
#include <QSlider>
#include <QWidgetAction>
#include <QKeyEvent>
#include <QOpenGLFramebufferObject>
#include <map>
#include <vector>
#include <CGAL/Three/Scene_interface.h>
#include <CGAL/Three/Triangle_container.h>
#include <CGAL/Three/Edge_container.h>
#include <CGAL/Three/Point_container.h>
#include <CGAL/Three/Three.h>
#include <CGAL/Real_timer.h>
#include <CGAL/Qt/manipulatedFrame.h>
@ -38,26 +43,50 @@ typedef CGAL::AABB_triangulation_3_triangle_primitive<EPICK,C3t3> Primitive;
typedef CGAL::AABB_traits<EPICK, Primitive> Traits;
typedef CGAL::AABB_tree<Traits> Tree;
typedef Tree::Point_and_primitive_id Point_and_primitive_id;
using namespace CGAL::Three;
typedef Triangle_container Tc;
typedef Edge_container Ec;
typedef Point_container Pc;
typedef Viewer_interface Vi;
// The special Scene_item only for triangles
class Scene_intersection_item : public CGAL::Three::Scene_item
class Scene_intersection_item : public CGAL::Three::Scene_item_rendering_helper
{
Q_OBJECT
public :
Scene_intersection_item(Scene_c3t3_item* parent)
:CGAL::Three::Scene_item(NumberOfBuffers,NumberOfVaos),
is_fast(false)
:is_fast(false)
{
setParent(parent);
alphaSlider = NULL;
m_alpha = 1.0f;
setTriangleContainer(0, new Tc(Vi::PROGRAM_C3T3, false));
setEdgeContainer(0, new Ec(Vi::PROGRAM_NO_SELECTION, false));
}
bool isFinite() const { return false; }
bool isFinite() const Q_DECL_OVERRIDE{ return false; }
~Scene_intersection_item()
{
if(alphaSlider)
delete alphaSlider;
}
void compute_bbox() const Q_DECL_OVERRIDE{}
void gl_initialization(Vi* viewer)
{
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
if(!getBuffersFilled())
{
computeElements();
initializeBuffers(viewer);
}
}
void init_vectors(
std::vector<float> *p_vertices,
std::vector<float> *p_normals,
@ -70,77 +99,49 @@ public :
edges = p_edges;
colors = p_colors;
barycenters = p_bary;
}
void setColor(QColor c)
void setColor(QColor c) Q_DECL_OVERRIDE
{
qobject_cast<Scene_c3t3_item*>(this->parent())->setColor(c);
Scene_item::setColor(c);
}
// Indicates if rendering mode is supported
bool supportsRenderingMode(RenderingMode m) const {
bool supportsRenderingMode(RenderingMode m) const Q_DECL_OVERRIDE{
return (m != Gouraud && m != PointsPlusNormals && m != Points && m != ShadedPoints);
}
void initialize_buffers(CGAL::Three::Viewer_interface *viewer)
void computeElements() const Q_DECL_OVERRIDE
{
//vao containing the data for the facets
return;
getTriangleContainer(0)->allocate(Tc::Flat_vertices,
vertices->data(), static_cast<int>(vertices->size()*sizeof(float)));
getTriangleContainer(0)->allocate(Tc::Flat_normals, normals->data(),
static_cast<int>(normals->size()*sizeof(float)));
getTriangleContainer(0)->allocate(Tc::FColors, colors->data(),
static_cast<int>(colors->size()*sizeof(float)));
getTriangleContainer(0)->allocate(Tc::Facet_centers, barycenters->data(),
static_cast<int>(barycenters->size()*sizeof(float)));
getEdgeContainer(0)->allocate(Ec::Vertices, edges->data(),
static_cast<int>(edges->size()*sizeof(float)));
setBuffersFilled(true);
}
void initializeBuffers(CGAL::Three::Viewer_interface *viewer)const Q_DECL_OVERRIDE
{
return;
//vao containing the data for the facets
{
program = getShaderProgram(PROGRAM_C3T3, viewer);
program->bind();
vaos[Facets]->bind();
buffers[Vertices].bind();
buffers[Vertices].allocate(vertices->data(),
static_cast<int>(vertices->size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
buffers[Vertices].release();
buffers[Normals].bind();
buffers[Normals].allocate(normals->data(),
static_cast<int>(normals->size()*sizeof(float)));
program->enableAttributeArray("normals");
program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
buffers[Normals].release();
buffers[Colors].bind();
buffers[Colors].allocate(colors->data(),
static_cast<int>(colors->size()*sizeof(float)));
program->enableAttributeArray("colors");
program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
buffers[Colors].release();
buffers[Barycenters].bind();
buffers[Barycenters].allocate(barycenters->data(),
static_cast<int>(barycenters->size()*sizeof(float)));
program->enableAttributeArray("barycenter");
program->setAttributeBuffer("barycenter", GL_FLOAT, 0, 3);
buffers[Barycenters].release();
vaos[Facets]->release();
program->release();
getTriangleContainer(0)->initializeBuffers(viewer);
getTriangleContainer(0)->setFlatDataSize(vertices->size());
}
//vao containing the data for the lines
{
getEdgeContainer(0)->initializeBuffers(viewer);
getEdgeContainer(0)->setFlatDataSize(edges->size());
}
//vao containing the data for the lines
{
program = getShaderProgram(PROGRAM_NO_SELECTION, viewer);
program->bind();
vaos[Lines]->bind();
buffers[Edges].bind();
buffers[Edges].allocate(edges->data(),
static_cast<int>(edges->size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
buffers[Edges].release();
vaos[Lines]->release();
program->release();
}
}
//Displays the item
void draw(CGAL::Three::Viewer_interface* viewer) const
void draw(CGAL::Three::Viewer_interface* viewer) const Q_DECL_OVERRIDE
{
return;
if(is_fast)
return;
if(!alphaSlider)
@ -150,47 +151,28 @@ public :
alphaSlider->setMaximum(255);
alphaSlider->setValue(255);
}
QOpenGLFramebufferObject* fbo = viewer->depthPeelingFbo();
const EPICK::Plane_3& plane = qobject_cast<Scene_c3t3_item*>(this->parent())->plane();
vaos[Facets]->bind();
program = getShaderProgram(PROGRAM_C3T3);
attribBuffers(viewer, PROGRAM_C3T3);
program->bind();
float shrink_factor = qobject_cast<Scene_c3t3_item*>(this->parent())->getShrinkFactor();
QVector4D cp(-plane.a(), -plane.b(), -plane.c(), -plane.d());
program->setUniformValue("cutplane", cp);
program->setUniformValue("shrink_factor", shrink_factor);
getTriangleContainer(0)->setPlane(cp);
getTriangleContainer(0)->setShrinkFactor(shrink_factor);
// positions_poly is also used for the faces in the cut plane
// and changes when the cut plane is moved
program->setUniformValue("comparing", viewer->currentPass() > 0);;
program->setUniformValue("width", viewer->width()*1.0f);
program->setUniformValue("height", viewer->height()*1.0f);
program->setUniformValue("near", (float)viewer->camera()->zNear());
program->setUniformValue("far", (float)viewer->camera()->zFar());
program->setUniformValue("writing", viewer->isDepthWriting());
program->setUniformValue("alpha", alpha());
if( fbo)
viewer->glBindTexture(GL_TEXTURE_2D, fbo->texture());
viewer->glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vertices->size() / 3));
program->release();
vaos[Facets]->release();
getTriangleContainer(0)->setAlpha(alpha());
getTriangleContainer(0)->draw(viewer, false);
}
void drawEdges(CGAL::Three::Viewer_interface* viewer) const
void drawEdges(CGAL::Three::Viewer_interface* viewer) const Q_DECL_OVERRIDE
{
return;
if(is_fast)
return;
vaos[Lines]->bind();
program = getShaderProgram(PROGRAM_C3T3_EDGES);
attribBuffers(viewer, PROGRAM_C3T3_EDGES);
program->bind();
const EPICK::Plane_3& plane = qobject_cast<Scene_c3t3_item*>(this->parent())->plane();
QVector4D cp(-plane.a(), -plane.b(), -plane.c(), -plane.d());
program->setUniformValue("cutplane", cp);
program->setAttributeValue("colors", QColor(Qt::black));
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(edges->size() / 3));
program->release();
vaos[Lines]->release();
getEdgeContainer(0)->setPlane(cp);
getEdgeContainer(0)->setColor(QColor(Qt::black));
getEdgeContainer(0)->draw(viewer, true);
}
void setFast(bool b)
@ -260,9 +242,9 @@ public :
}
}
Scene_item* clone() const {return 0;}
QString toolTip() const {return QString();}
QMenu* contextMenu()
Scene_item* clone() const Q_DECL_OVERRIDE{return 0;}
QString toolTip() const Q_DECL_OVERRIDE{return QString();}
QMenu* contextMenu() Q_DECL_OVERRIDE
{
QMenu* menu = Scene_item::contextMenu();
@ -288,32 +270,17 @@ public :
}
return menu;
}
float alpha() const
float alpha() const Q_DECL_OVERRIDE
{
return m_alpha ;
}
void setAlpha(int a)
void setAlpha(int a) Q_DECL_OVERRIDE
{
m_alpha = a / 255.0f;
redraw();
}
private:
enum Buffer
{
Vertices =0,
Normals,
Colors,
Edges,
Barycenters,
NumberOfBuffers
};
enum Vao
{
Facets=0,
Lines,
NumberOfVaos
};
//contains the data
mutable std::vector<float> *vertices;
@ -460,33 +427,6 @@ struct Scene_c3t3_item_priv {
computed_stats = false;
}
enum Buffer
{
Facet_vertices =0,
Facet_normals,
Facet_colors,
Facet_barycenters,
Edges_vertices,
Edges_CNC,
Grid_vertices,
iEdges_vertices,
iFacet_vertices,
iFacet_normals,
iFacet_colors,
NumberOfBuffers
};
enum Vao
{
Facets=0,
Edges,
Grid,
CNC,
iEdges,
iFacets,
NumberOfVaos
};
enum STATS {
MIN_EDGES_LENGTH = 0,
MAX_EDGES_LENGTH,
@ -583,36 +523,38 @@ struct Set_show_tetrahedra {
}
};
Scene_c3t3_item::Scene_c3t3_item(bool is_surface)
: Scene_group_item("unnamed", Scene_c3t3_item_priv::NumberOfBuffers, Scene_c3t3_item_priv::NumberOfVaos)
, d(new Scene_c3t3_item_priv(this))
void Scene_c3t3_item::common_constructor(bool is_surface)
{
compute_bbox();
connect(d->frame, SIGNAL(modified()), this, SLOT(changed()));
c3t3_changed();
setRenderingMode(FlatPlusEdges);
create_flat_and_wire_sphere(1.0f,d->s_vertex,d->s_normals, d->ws_vertex);
d->is_surface = is_surface;
d->is_grid_shown = !is_surface;
d->show_tetrahedra = !is_surface;
d->show_tetrahedra = is_surface;
setTriangleContainer(C3t3_faces, new Tc(Vi::PROGRAM_C3T3, false));
setEdgeContainer(CNC, new Ec(Vi::PROGRAM_NO_SELECTION, false));
setEdgeContainer(Grid_edges, new Ec(Vi::PROGRAM_NO_SELECTION, false));
setEdgeContainer(C3t3_edges, new Ec(Vi::PROGRAM_C3T3_EDGES, false));
setPointContainer(C3t3_points, new Pc(Vi::PROGRAM_C3T3_EDGES, false));
}
Scene_c3t3_item::Scene_c3t3_item(bool is_surface)
: Scene_group_item("unnamed")
, d(new Scene_c3t3_item_priv(this))
{
common_constructor(is_surface);
}
Scene_c3t3_item::Scene_c3t3_item(const C3t3& c3t3, bool is_surface)
: Scene_group_item("unnamed", Scene_c3t3_item_priv::NumberOfBuffers, Scene_c3t3_item_priv::NumberOfVaos)
: Scene_group_item("unnamed")
, d(new Scene_c3t3_item_priv(c3t3, this))
{
compute_bbox();
connect(d->frame, SIGNAL(modified()), this, SLOT(changed()));
d->reset_cut_plane();
d->is_surface = is_surface;
d->is_grid_shown = !is_surface;
d->show_tetrahedra = !is_surface;
c3t3_changed();
setRenderingMode(FlatPlusEdges);
create_flat_and_wire_sphere(1.0f,d->s_vertex,d->s_normals, d->ws_vertex);
d->reset_cut_plane();
common_constructor(is_surface);
}
Scene_c3t3_item::~Scene_c3t3_item()
@ -971,41 +913,36 @@ QString Scene_c3t3_item::toolTip() const {
}
void Scene_c3t3_item::draw(CGAL::Three::Viewer_interface* viewer) const {
Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
if(!visible())
return;
if (!are_buffers_filled)
Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
ncthis->d->computeElements();
ncthis->d->initializeBuffers(viewer);
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
if(!getBuffersFilled())
{
computeElements();
initializeBuffers(viewer);
}
if(renderingMode() == Flat ||
renderingMode() == FlatPlusEdges)
{
QOpenGLFramebufferObject* fbo = viewer->depthPeelingFbo();
vaos[Scene_c3t3_item_priv::Facets]->bind();
d->program = getShaderProgram(PROGRAM_C3T3);
attribBuffers(viewer, PROGRAM_C3T3);
d->program->bind();
QVector4D cp(this->plane().a(),this->plane().b(),this->plane().c(),this->plane().d());
d->program->setUniformValue("cutplane", cp);
getTriangleContainer(C3t3_faces)->setPlane(cp);
float shrink_factor = getShrinkFactor();
d->program->setUniformValue("shrink_factor", shrink_factor);
getTriangleContainer(C3t3_faces)->setShrinkFactor(shrink_factor);
// positions_poly_size is the number of total facets in the C3T3
// it is only computed once and positions_poly is emptied at the end
d->program->setUniformValue("comparing", viewer->currentPass() > 0);;
d->program->setUniformValue("width", viewer->width()*1.0f);
d->program->setUniformValue("height", viewer->height()*1.0f);
d->program->setUniformValue("near", (float)viewer->camera()->zNear());
d->program->setUniformValue("far", (float)viewer->camera()->zFar());
d->program->setUniformValue("writing", viewer->isDepthWriting());
d->program->setUniformValue("alpha", alpha());
d->program->setUniformValue("is_surface", d->is_surface);
if( fbo)
viewer->glBindTexture(GL_TEXTURE_2D, fbo->texture());
viewer->glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(d->positions_poly_size / 3));
d->program->release();
vaos[Scene_c3t3_item_priv::Facets]->release();
getTriangleContainer(C3t3_faces)->setAlpha(alpha());
getTriangleContainer(C3t3_faces)->setIsSurface(d->is_surface);
getTriangleContainer(C3t3_faces)->draw(viewer, false);
if(d->show_tetrahedra){
ncthis->show_intersection(true);
@ -1016,8 +953,11 @@ void Scene_c3t3_item::draw(CGAL::Three::Viewer_interface* viewer) const {
if(!d->frame->isManipulated() && !d->are_intersection_buffers_filled)
{
//initGL
d->intersection->gl_initialization(viewer);
ncthis->d->computeIntersections();
d->intersection->initialize_buffers(viewer);
d->intersection->initializeBuffers(viewer);
d->are_intersection_buffers_filled = true;
ncthis->show_intersection(true);
}
@ -1030,18 +970,12 @@ void Scene_c3t3_item::draw(CGAL::Three::Viewer_interface* viewer) const {
}
if(d->is_grid_shown)
{
vaos[Scene_c3t3_item_priv::Grid]->bind();
d->program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attribBuffers(viewer, PROGRAM_WITHOUT_LIGHT);
d->program->bind();
d->program->setAttributeValue("colors", QColor(Qt::black));
getEdgeContainer(Grid_edges)->setColor(QColor(Qt::black));
QMatrix4x4 f_mat;
for (int i = 0; i<16; i++)
f_mat.data()[i] = d->frame->matrix()[i];
d->program->setUniformValue("f_matrix", f_mat);
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_grid.size() / 3));
d->program->release();
vaos[Scene_c3t3_item_priv::Grid]->release();
getEdgeContainer(Grid_edges)->setFrameMatrix(f_mat);
getEdgeContainer(Grid_edges)->draw(viewer, true);
}
}
@ -1058,39 +992,34 @@ void Scene_c3t3_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const {
if(renderMode == GL_SELECT) return;
}
Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
if (!are_buffers_filled)
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
ncthis->d->computeElements();
ncthis->d->initializeBuffers(viewer);
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
if(!getBuffersFilled())
{
computeElements();
initializeBuffers(viewer);
}
if(renderingMode() == Wireframe && d->is_grid_shown)
{
vaos[Scene_c3t3_item_priv::Grid]->bind();
d->program = getShaderProgram(PROGRAM_NO_SELECTION);
attribBuffers(viewer, PROGRAM_NO_SELECTION);
d->program->bind();
d->program->setAttributeValue("colors", QColor(Qt::black));
getEdgeContainer(Grid_edges)->setColor(QColor(Qt::black));
QMatrix4x4 f_mat;
for (int i = 0; i<16; i++)
f_mat.data()[i] = d->frame->matrix()[i];
d->program->setUniformValue("f_matrix", f_mat);
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_grid.size() / 3));
d->program->release();
vaos[Scene_c3t3_item_priv::Grid]->release();
getEdgeContainer(Grid_edges)->setFrameMatrix(f_mat);
getEdgeContainer(Grid_edges)->draw(viewer, true);
}
vaos[Scene_c3t3_item_priv::Edges]->bind();
d->program = getShaderProgram(PROGRAM_C3T3_EDGES);
attribBuffers(viewer, PROGRAM_C3T3_EDGES);
d->program->bind();
QVector4D cp(this->plane().a(),this->plane().b(),this->plane().c(),this->plane().d());
d->program->setUniformValue("cutplane", cp);
d->program->setUniformValue("is_surface", d->is_surface);
d->program->setAttributeValue("colors", QColor(Qt::black));
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_lines_size / 3));
d->program->release();
vaos[Scene_c3t3_item_priv::Edges]->release();
getEdgeContainer(C3t3_edges)->setPlane(cp);
getEdgeContainer(C3t3_edges)->setIsSurface(d->is_surface);
getEdgeContainer(C3t3_edges)->setColor(QColor(Qt::black));
getEdgeContainer(C3t3_edges)->draw(viewer, true);
if(d->show_tetrahedra){
if(!d->frame->isManipulated())
@ -1099,8 +1028,9 @@ void Scene_c3t3_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const {
d->intersection->setFast(true);
if(!d->frame->isManipulated() && !d->are_intersection_buffers_filled)
{
d->intersection->gl_initialization(viewer);
ncthis->d->computeIntersections();
d->intersection->initialize_buffers(viewer);
d->intersection->initializeBuffers(viewer);
d->are_intersection_buffers_filled = true;
}
}
@ -1111,14 +1041,8 @@ void Scene_c3t3_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const {
}
if(d->cnc_are_shown)
{
vaos[Scene_c3t3_item_priv::CNC]->bind();
d->program = getShaderProgram(PROGRAM_NO_SELECTION);
attribBuffers(viewer, PROGRAM_NO_SELECTION);
d->program->bind();
d->program->setAttributeValue("colors", QColor(Qt::black));
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_lines_not_in_complex_size / 3));
d->program->release();
vaos[Scene_c3t3_item_priv::CNC]->release();
getEdgeContainer(CNC)->setColor(QColor(Qt::black));
getEdgeContainer(CNC)->draw(viewer, true);
}
}
@ -1129,37 +1053,35 @@ void Scene_c3t3_item::drawPoints(CGAL::Three::Viewer_interface * viewer) const
if(renderingMode() == Points)
{
Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
if (!are_buffers_filled)
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
ncthis->d->computeElements();
ncthis->d->initializeBuffers(viewer);
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
vaos[Scene_c3t3_item_priv::Edges]->bind();
d->program = getShaderProgram(PROGRAM_C3T3_EDGES);
attribBuffers(viewer, PROGRAM_C3T3_EDGES);
d->program->bind();
if(!getBuffersFilled())
{
computeElements();
initializeBuffers(viewer);
}
QVector4D cp(this->plane().a(),this->plane().b(),this->plane().c(),this->plane().d());
d->program->setUniformValue("cutplane", cp);
d->program->setUniformValue("is_surface", d->is_surface);
d->program->setAttributeValue("colors", this->color());
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(d->positions_lines.size() / 3));
vaos[Scene_c3t3_item_priv::Edges]->release();
d->program->release();
getPointContainer(C3t3_points)->setPlane(cp);
getPointContainer(C3t3_points)->setIsSurface(d->is_surface);
getPointContainer(C3t3_points)->setColor(this->color());
getPointContainer(C3t3_points)->draw(viewer, true);
if(d->is_grid_shown)
{
vaos[Scene_c3t3_item_priv::Grid]->bind();
d->program = getShaderProgram(PROGRAM_NO_SELECTION);
attribBuffers(viewer, PROGRAM_NO_SELECTION);
d->program->bind();
d->program->setAttributeValue("colors", this->color());
getEdgeContainer(Grid_edges)->setColor(QColor(Qt::black));
QMatrix4x4 f_mat;
for (int i = 0; i<16; i++)
f_mat.data()[i] = d->frame->matrix()[i];
d->program->setUniformValue("f_matrix", f_mat);
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_grid.size() / 3));
d->program->release();
vaos[Scene_c3t3_item_priv::Grid]->release();
getEdgeContainer(Grid_edges)->setFrameMatrix(f_mat);
getEdgeContainer(Grid_edges)->draw(viewer, true);
}
if(d->spheres_are_shown)
{
@ -1370,113 +1292,54 @@ void Scene_c3t3_item_priv::initializeBuffers(CGAL::Three::Viewer_interface *view
{
//vao containing the data for the facets
{
program = item->getShaderProgram(Scene_c3t3_item::PROGRAM_C3T3, viewer);
program->bind();
item->vaos[Facets]->bind();
item->buffers[Facet_vertices].bind();
item->buffers[Facet_vertices].allocate(positions_poly.data(),
static_cast<int>(positions_poly.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
item->buffers[Facet_vertices].release();
item->buffers[Facet_normals].bind();
item->buffers[Facet_normals].allocate(normals.data(),
static_cast<int>(normals.size()*sizeof(float)));
program->enableAttributeArray("normals");
program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
item->buffers[Facet_normals].release();
item->buffers[Facet_colors].bind();
item->buffers[Facet_colors].allocate(f_colors.data(),
static_cast<int>(f_colors.size()*sizeof(float)));
program->enableAttributeArray("colors");
program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
item->buffers[Facet_colors].release();
item->buffers[Facet_barycenters].bind();
item->buffers[Facet_barycenters].allocate(positions_barycenter.data(),
static_cast<int>(positions_barycenter.size()*sizeof(float)));
program->enableAttributeArray("barycenter");
program->setAttributeBuffer("barycenter", GL_FLOAT, 0, 3);
item->buffers[Facet_barycenters].release();
item->vaos[Facets]->release();
program->release();
positions_poly_size = positions_poly.size();
item->getTriangleContainer(Scene_c3t3_item::C3t3_faces)->initializeBuffers(viewer);
item->getTriangleContainer(Scene_c3t3_item::C3t3_faces)->setFlatDataSize(
positions_poly_size);
positions_poly.clear();
positions_poly.swap(positions_poly);
positions_poly.shrink_to_fit();
normals.clear();
normals.swap(normals);
normals.shrink_to_fit();
f_colors.clear();
f_colors.swap(f_colors);
f_colors.shrink_to_fit();
positions_barycenter.clear();
positions_barycenter.swap(positions_barycenter);
positions_barycenter.shrink_to_fit();
}
//vao containing the data for the lines
{
program = item->getShaderProgram(Scene_c3t3_item::PROGRAM_C3T3_EDGES, viewer);
program->bind();
item->vaos[Edges]->bind();
item->buffers[Edges_vertices].bind();
item->buffers[Edges_vertices].allocate(positions_lines.data(),
static_cast<int>(positions_lines.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
item->buffers[Edges_vertices].release();
item->vaos[Edges]->release();
program->release();
positions_lines_size = positions_lines.size();
item->getEdgeContainer(Scene_c3t3_item::C3t3_edges)->initializeBuffers(viewer);
item->getEdgeContainer(Scene_c3t3_item::C3t3_edges)->setFlatDataSize(
positions_lines_size);
positions_lines.clear();
positions_lines.swap(positions_lines);
positions_lines.shrink_to_fit();
}
//vao containing the data for the points
{
item->getPointContainer(Scene_c3t3_item::C3t3_points)->initializeBuffers(viewer);
item->getPointContainer(Scene_c3t3_item::C3t3_points)->setFlatDataSize(
positions_lines_size);
positions_lines.clear();
positions_lines.shrink_to_fit();
}
// vao containing the data for the cnc
{
program = item->getShaderProgram(Scene_c3t3_item::PROGRAM_NO_SELECTION, viewer);
program->bind();
item->vaos[CNC]->bind();
item->buffers[Edges_CNC].bind();
item->buffers[Edges_CNC].allocate(positions_lines_not_in_complex.data(),
static_cast<int>(positions_lines_not_in_complex.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
item->buffers[Edges_CNC].release();
item->vaos[CNC]->release();
program->release();
positions_lines_not_in_complex_size = positions_lines_not_in_complex.size();
item->getEdgeContainer(Scene_c3t3_item::CNC)->initializeBuffers(viewer);
item->getEdgeContainer(Scene_c3t3_item::CNC)->setFlatDataSize(
positions_lines_not_in_complex_size);
positions_lines_not_in_complex.clear();
positions_lines_not_in_complex.swap(positions_lines_not_in_complex);
positions_lines_not_in_complex.shrink_to_fit();
}
//vao containing the data for the grid
{
program = item->getShaderProgram(Scene_c3t3_item::PROGRAM_NO_SELECTION, viewer);
program->bind();
item->vaos[Grid]->bind();
item->buffers[Grid_vertices].bind();
item->buffers[Grid_vertices].allocate(positions_grid.data(),
static_cast<int>(positions_grid.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
item->buffers[Grid_vertices].release();
item->vaos[Grid]->release();
program->release();
item->getEdgeContainer(Scene_c3t3_item::Grid_edges)->initializeBuffers(viewer);
item->getEdgeContainer(Scene_c3t3_item::Grid_edges)->setFlatDataSize(
positions_grid.size());
}
program->release();
item->are_buffers_filled = true;
}
@ -1556,6 +1419,7 @@ void Scene_c3t3_item_priv::computeIntersections()
tree.all_intersected_primitives(plane,
boost::make_function_output_iterator(ComputeIntersection(*this)));
intersected_cells.clear();
intersection->computeElements();
}
void Scene_c3t3_item_priv::computeSpheres()
@ -1618,9 +1482,7 @@ void Scene_c3t3_item_priv::computeSpheres()
}
void Scene_c3t3_item_priv::computeElements()
{
QApplication::setOverrideCursor(Qt::WaitCursor);
{
if(!alphaSlider)
{
alphaSlider = new QSlider(::Qt::Horizontal);
@ -1722,7 +1584,6 @@ void Scene_c3t3_item_priv::computeElements()
}
}
}
QApplication::restoreOverrideCursor();
}
bool Scene_c3t3_item::load_binary(std::istream& is)
@ -2125,7 +1986,13 @@ CGAL::Three::Scene_item::Header_data Scene_c3t3_item::header() const
void Scene_c3t3_item::invalidateOpenGLBuffers()
{
are_buffers_filled = false;
setBuffersFilled(false);
getTriangleContainer(C3t3_faces)->reset_vbos(ALL);
getEdgeContainer(C3t3_edges)->reset_vbos(ALL);
getEdgeContainer(CNC)->reset_vbos(ALL);
getEdgeContainer(Grid_edges)->reset_vbos(ALL);
getPointContainer(C3t3_points)->reset_vbos(ALL);
resetCutPlane();
compute_bbox();
d->invalidate_stats();
@ -2184,4 +2051,63 @@ void Scene_c3t3_item::setAlpha(int alpha)
QSlider* Scene_c3t3_item::alphaSlider() { return d->alphaSlider; }
void Scene_c3t3_item::initializeBuffers(Viewer_interface *v) const
{
d->initializeBuffers(v);
}
void Scene_c3t3_item::computeElements()const
{
QApplication::setOverrideCursor(Qt::WaitCursor);
d->computeElements();
getTriangleContainer(C3t3_faces)->allocate(
Tc::Flat_vertices, d->positions_poly.data(),
static_cast<int>(d->positions_poly.size()*sizeof(float)));
getTriangleContainer(C3t3_faces)->allocate(
Tc::Flat_normals,
d->normals.data(),
static_cast<int>(d->normals.size()*sizeof(float)));
getTriangleContainer(C3t3_faces)->allocate(
Tc::FColors,
d->f_colors.data(),
static_cast<int>(d->f_colors.size()*sizeof(float)));
getTriangleContainer(C3t3_faces)->allocate(
Tc::Facet_centers,
d->positions_barycenter.data(),
static_cast<int>(d->positions_barycenter.size()*sizeof(float)));
d->positions_poly_size = d->positions_poly.size();
getEdgeContainer(C3t3_edges)->allocate(
Ec::Vertices,
d->positions_lines.data(),
static_cast<int>(d->positions_lines.size()*sizeof(float)));
d->positions_lines_size = d->positions_lines.size();
getEdgeContainer(CNC)->allocate(
Ec::Vertices,
d->positions_lines_not_in_complex.data(),
static_cast<int>(d->positions_lines_not_in_complex.size()*sizeof(float)));
d->positions_lines_not_in_complex_size = d->positions_lines_not_in_complex.size();
getEdgeContainer(Grid_edges)->allocate(
Ec::Vertices,
d->positions_grid.data(),
static_cast<int>(d->positions_grid.size()*sizeof(float)));
getPointContainer(C3t3_points)->allocate(
Pc::Vertices,
d->positions_lines.data(),
static_cast<int>(d->positions_lines.size()*sizeof(float)));
setBuffersFilled(true);
QApplication::restoreOverrideCursor();
}
#include "Scene_c3t3_item.moc"

15
Polyhedron/demo/Polyhedron/Scene_c3t3_item.h
View File

@ -38,6 +38,7 @@ public:
Scene_c3t3_item(const C3t3& c3t3, bool is_surface = false);
~Scene_c3t3_item();
void common_constructor(bool is_surface);
bool has_stats()const Q_DECL_OVERRIDE {return true;}
QString computeStats(int type) Q_DECL_OVERRIDE;
CGAL::Three::Scene_item::Header_data header() const Q_DECL_OVERRIDE;
@ -156,9 +157,23 @@ public:
void itemAboutToBeDestroyed(Scene_item *) Q_DECL_OVERRIDE;
void initializeBuffers(Viewer_interface *) const Q_DECL_OVERRIDE;
void computeElements() const Q_DECL_OVERRIDE;
protected:
friend struct Scene_c3t3_item_priv;
Scene_c3t3_item_priv* d;
enum Face_Containers{
C3t3_faces = 0
};
enum Edge_Containers{
C3t3_edges = 0,
Grid_edges,
CNC
};
enum Point_Container{
C3t3_points = 0
};
};

9
Polyhedron/demo/Polyhedron/Scene_group_item.cpp
View File

@ -1,15 +1,15 @@
#include <CGAL/Three/Scene_group_item.h>
#include <CGAL/Three/Viewer_interface.h>
#include <CGAL/Three/Three.h>
#include <QDebug>
using namespace CGAL::Three;
Scene_group_item::Scene_group_item(QString name, int nb_vbos, int nb_vaos )
: Scene_item(nb_vbos, nb_vaos)
, scene(NULL)
Scene_group_item::Scene_group_item(QString name)
{
this->name_ = name;
expanded = true;
already_drawn = false;
scene = Three::scene();
}
bool Scene_group_item::isFinite() const
@ -244,6 +244,3 @@ void Scene_group_item::setAlpha(int )
scene->item(id)->setAlpha(static_cast<int>(alpha()*255));
}
}
void Scene_group_item::removeViewer(CGAL::Three::Viewer_interface*)
{}

1
Polyhedron/demo/Polyhedron/Scene_plane_item.cpp
View File

@ -102,6 +102,7 @@ void Scene_plane_item::computeElements() const
static_cast<int>(positions_lines.size()
* sizeof(float)));
}
setBuffersFilled(true);
QApplication::restoreOverrideCursor();
}

164
Polyhedron/demo/Polyhedron/Scene_polylines_item.cpp
View File

@ -8,6 +8,14 @@
#include <QAction>
#include <QInputDialog>
#include <QApplication>
#include <CGAL/Three/Edge_container.h>
#include <CGAL/Three/Point_container.h>
#include <CGAL/Three/Three.h>
using namespace CGAL::Three;
typedef Edge_container Ec;
typedef Point_container Pc;
typedef Viewer_interface Vi;
struct Scene_polylines_item_private {
typedef Scene_polylines_item::K K;
@ -66,7 +74,7 @@ struct Scene_polylines_item_private {
void
Scene_polylines_item_private::initializeBuffers(CGAL::Three::Viewer_interface *viewer = 0) const
Scene_polylines_item_private::initializeBuffers(CGAL::Three::Viewer_interface *viewer) const
{
float lineWidth[2];
if(!viewer->isOpenGL_4_3())
@ -77,35 +85,18 @@ Scene_polylines_item_private::initializeBuffers(CGAL::Three::Viewer_interface *v
lineWidth[1] = 10;
}
line_Slider->setMaximum(lineWidth[1]);
QOpenGLShaderProgram *program;
//vao for the lines
{
if(viewer->isOpenGL_4_3())
program = item->getShaderProgram(Scene_polylines_item::PROGRAM_SOLID_WIREFRAME, viewer);
else
program = item->getShaderProgram(Scene_polylines_item::PROGRAM_NO_SELECTION, viewer);
program->bind();
item->vaos[Edges]->bind();
item->buffers[Edges_Vertices].bind();
item->buffers[Edges_Vertices].allocate(positions_lines.data(),
static_cast<int>(positions_lines.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex",GL_FLOAT,0,4);
item->buffers[Edges_Vertices].release();
item->vaos[Edges]->release();
program->release();
nb_lines = positions_lines.size();
positions_lines.clear();
positions_lines.swap(positions_lines);
}
item->are_buffers_filled = true;
item->getEdgeContainer(0)->initializeBuffers(viewer);
item->getEdgeContainer(0)->setFlatDataSize(nb_lines);
item->getPointContainer(0)->initializeBuffers(viewer);
item->getPointContainer(0)->setFlatDataSize(nb_lines);
}
void
Scene_polylines_item_private::computeElements() const
{
const CGAL::qglviewer::Vec offset = static_cast<CGAL::Three::Viewer_interface*>(CGAL::QGLViewer::QGLViewerPool().first())->offset();
const CGAL::qglviewer::Vec offset = static_cast<CGAL::Three::Viewer_interface*>(
CGAL::QGLViewer::QGLViewerPool().first())->offset();
QApplication::setOverrideCursor(Qt::WaitCursor);
positions_lines.resize(0);
double mean = 0;
@ -138,18 +129,28 @@ Scene_polylines_item_private::computeElements() const
positions_lines.push_back(a.x()+offset.x);
positions_lines.push_back(a.y()+offset.y);
positions_lines.push_back(a.z()+offset.z);
positions_lines.push_back(1.0);
positions_lines.push_back(b.x()+offset.x);
positions_lines.push_back(b.y()+offset.y);
positions_lines.push_back(b.z()+offset.z);
positions_lines.push_back(1.0);
}
}
if(!computed_stats)
mean_length = mean/double(nb_edges);
computed_stats = true;
item->getEdgeContainer(0)->allocate(
Ec::Vertices, positions_lines.data(),
static_cast<int>(positions_lines.size()*sizeof(float)));
item->getPointContainer(0)->allocate(
Pc::Vertices, positions_lines.data(),
static_cast<int>(positions_lines.size()*sizeof(float)));
item->setBuffersFilled(true);
nb_lines = positions_lines.size();
positions_lines.clear();
positions_lines.shrink_to_fit();
QApplication::restoreOverrideCursor();
}
@ -265,14 +266,19 @@ Scene_polylines_item_private::computeSpheres()
}
Scene_polylines_item::Scene_polylines_item()
:CGAL::Three::Scene_group_item("unnamed",Scene_polylines_item_private::NbOfVbos,Scene_polylines_item_private::NbOfVaos)
:CGAL::Three::Scene_group_item("unnamed")
,d(new Scene_polylines_item_private(this))
{
setRenderingMode(FlatPlusEdges);
d->nb_lines = 0;
d->spheres = NULL;
invalidateOpenGLBuffers();
setEdgeContainer(0,
new Ec(Three::mainViewer()->isOpenGL_4_3() ? Vi::PROGRAM_SOLID_WIREFRAME
: Vi::PROGRAM_NO_SELECTION
, false));
setPointContainer(0,
new Pc(Vi::PROGRAM_NO_SELECTION, false));
}
Scene_polylines_item::~Scene_polylines_item()
@ -317,13 +323,13 @@ Scene_polylines_item::compute_bbox() const {
bbox.xmax(),
bbox.ymax(),
bbox.zmax());
is_bbox_computed = true;
}
Scene_item::Bbox Scene_polylines_item::bbox() const
{
if(!is_bbox_computed)
compute_bbox();
is_bbox_computed = true;
compute_bbox();
return _bbox;
}
Scene_polylines_item*
@ -378,10 +384,18 @@ void
Scene_polylines_item::draw(CGAL::Three::Viewer_interface* viewer) const {
if(!visible())
return;
if(!are_buffers_filled)
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
d->computeElements();
d->initializeBuffers(viewer);
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
if(!getBuffersFilled())
{
computeElements();
initializeBuffers(viewer);
}
if(d->draw_extremities)
{
@ -394,39 +408,32 @@ void
Scene_polylines_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const {
if(!visible())
return;
if(renderingMode() == Wireframe
|| renderingMode() == FlatPlusEdges)
{
if(!are_buffers_filled)
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
d->computeElements();
d->initializeBuffers(viewer);
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
vaos[Scene_polylines_item_private::Edges]->bind();
if(!viewer->isOpenGL_4_3())
if(!getBuffersFilled())
{
attribBuffers(viewer, PROGRAM_NO_SELECTION);
computeElements();
initializeBuffers(viewer);
}
else
{
attribBuffers(viewer, PROGRAM_SOLID_WIREFRAME);
}
QOpenGLShaderProgram *program = viewer->isOpenGL_4_3() ? getShaderProgram(PROGRAM_SOLID_WIREFRAME)
: getShaderProgram(PROGRAM_NO_SELECTION);
program->bind();
if(viewer->isOpenGL_4_3())
{
QVector2D vp(viewer->width(), viewer->height());
program->setUniformValue("viewport", vp);
program->setUniformValue("near",(GLfloat)viewer->camera()->zNear());
program->setUniformValue("far",(GLfloat)viewer->camera()->zFar());
program->setUniformValue("width", GLfloat(d->line_Slider->value()));
getEdgeContainer(0)->setViewport(vp);
getEdgeContainer(0)->setWidth(GLfloat(d->line_Slider->value()));
}
program->setAttributeValue("colors", this->color());
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->nb_lines/4));
program->release();
vaos[Scene_polylines_item_private::Edges]->release();
getEdgeContainer(0)->setColor(this->color());
getEdgeContainer(0)->draw(viewer, true);
}
if(d->draw_extremities)
{
@ -440,22 +447,23 @@ Scene_polylines_item::drawPoints(CGAL::Three::Viewer_interface* viewer) const {
return;
if(renderingMode() == Points)
{
if(!are_buffers_filled)
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
d->computeElements();
d->initializeBuffers(viewer);
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
if(!getBuffersFilled())
{
computeElements();
initializeBuffers(viewer);
}
vaos[Scene_polylines_item_private::Edges]->bind();
attribBuffers(viewer, PROGRAM_NO_SELECTION);
QOpenGLShaderProgram *program = getShaderProgram(PROGRAM_NO_SELECTION);
program->bind();
QColor temp = this->color();
program->setAttributeValue("colors", temp);
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(d->nb_lines/4));
// Clean-up
vaos[Scene_polylines_item_private::Edges]->release();
program->release();
getPointContainer(0)->setColor(this->color());
getPointContainer(0)->draw(viewer, true);
}
if(d->draw_extremities)
{
@ -501,7 +509,9 @@ QMenu* Scene_polylines_item::contextMenu()
void Scene_polylines_item::invalidateOpenGLBuffers()
{
are_buffers_filled = false;
setBuffersFilled(false);
getEdgeContainer(0)->reset_vbos(ALL);
getPointContainer(0)->reset_vbos(ALL);
d->invalidate_stats();
compute_bbox();
@ -736,3 +746,13 @@ void Scene_polylines_item::setWidth( int i)
d->line_Slider->setValue(i);
redraw();
}
void Scene_polylines_item::initializeBuffers(Viewer_interface *v) const
{
d->initializeBuffers(v);
}
void Scene_polylines_item::computeElements() const
{
d->computeElements();
}

49
Polyhedron/demo/Polyhedron/Scene_polylines_item.h
View File

@ -14,7 +14,8 @@
struct Scene_polylines_item_private;
class Scene_spheres_item;
class SCENE_POLYLINES_ITEM_EXPORT Scene_polylines_item : public CGAL::Three::Scene_group_item
class SCENE_POLYLINES_ITEM_EXPORT Scene_polylines_item
: public CGAL::Three::Scene_group_item
{
Q_OBJECT
public:
@ -32,43 +33,41 @@ public:
MAX_LENGTH,
MEAN_LENGTH
};
bool has_stats()const {return true;}
QString computeStats(int type);
CGAL::Three::Scene_item::Header_data header() const;
bool has_stats()const Q_DECL_OVERRIDE {return true;}
QString computeStats(int type)Q_DECL_OVERRIDE ;
CGAL::Three::Scene_item::Header_data header() const Q_DECL_OVERRIDE ;
bool isFinite() const { return true; }
bool isEmpty() const;
void compute_bbox() const;
Bbox bbox() const;
bool isFinite() const Q_DECL_OVERRIDE { return true; }
bool isEmpty() const Q_DECL_OVERRIDE ;
void compute_bbox() const Q_DECL_OVERRIDE ;
Bbox bbox() const Q_DECL_OVERRIDE ;
Scene_polylines_item* clone() const;
Scene_polylines_item* clone() const Q_DECL_OVERRIDE ;
QString toolTip() const;
QString toolTip() const Q_DECL_OVERRIDE ;
// Indicate if rendering mode is supported
bool supportsRenderingMode(RenderingMode m) const;
bool supportsRenderingMode(RenderingMode m) const Q_DECL_OVERRIDE ;
QMenu* contextMenu();
QMenu* contextMenu() Q_DECL_OVERRIDE ;
// Flat/Gouraud OpenGL drawing
void draw() const {}
void draw(CGAL::Three::Viewer_interface*) const;
// Wireframe OpenGL drawing
void drawEdges() const{}
void drawEdges(CGAL::Three::Viewer_interface*) const;
void drawPoints() const{}
void drawPoints(CGAL::Three::Viewer_interface*) const;
void draw(CGAL::Three::Viewer_interface*) const Q_DECL_OVERRIDE ;
void drawEdges(CGAL::Three::Viewer_interface*) const Q_DECL_OVERRIDE ;
void drawPoints(CGAL::Three::Viewer_interface*) const Q_DECL_OVERRIDE ;
void smooth(std::vector<Point_3>& polyline);
//When selecting a polylineitem, we don't want to select its children, so we can still apply Operations to it
QList<Scene_interface::Item_id> getChildrenForSelection() const { return QList<Scene_interface::Item_id>(); }
//When selecting a polylineitem, we don't want to select its children, so
//we can still apply Operations to it
QList<Scene_interface::Item_id> getChildrenForSelection() const Q_DECL_OVERRIDE {
return QList<Scene_interface::Item_id>();
}
void setWidth(int i);
void computeElements() const Q_DECL_OVERRIDE;
void initializeBuffers(Viewer_interface *) const Q_DECL_OVERRIDE;
public Q_SLOTS:
virtual void invalidateOpenGLBuffers();
void invalidateOpenGLBuffers() Q_DECL_OVERRIDE;
void change_corner_radii(double);
void change_corner_radii();
void split_at_sharp_angles();

251
Polyhedron/demo/Polyhedron/Scene_spheres_item.cpp
View File

@ -1,6 +1,14 @@
#include "Scene_spheres_item.h"
#include <CGAL/Three/Triangle_container.h>
#include <CGAL/Three/Edge_container.h>
#include <QApplication>
using namespace CGAL::Three;
typedef Viewer_interface Vi;
typedef Triangle_container Tc;
typedef Edge_container Ec;
struct Scene_spheres_item_priv
{
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
@ -59,11 +67,17 @@ struct Scene_spheres_item_priv
};
Scene_spheres_item::Scene_spheres_item(Scene_group_item* parent, bool planed)
:CGAL::Three::Scene_item(Scene_spheres_item_priv::NbOfVbos,Scene_spheres_item_priv::NbOfVaos)
{
setParent(parent);
d = new Scene_spheres_item_priv(planed, this);
setTriangleContainer(0,
new Tc(planed ? Vi::PROGRAM_SPHERES
: Vi::PROGRAM_CUTPLANE_SPHERES
,false));
setEdgeContainer(0,
new Ec(planed ? Vi::PROGRAM_SPHERES
: Vi::PROGRAM_CUTPLANE_SPHERES
,false));
}
Scene_spheres_item::~Scene_spheres_item()
@ -73,164 +87,75 @@ Scene_spheres_item::~Scene_spheres_item()
void Scene_spheres_item_priv::initializeBuffers(CGAL::Three::Viewer_interface *viewer) const
{
if(has_plane)
{
program = item->getShaderProgram(Scene_spheres_item::PROGRAM_CUTPLANE_SPHERES, viewer);
item->attribBuffers(viewer, Scene_spheres_item::PROGRAM_CUTPLANE_SPHERES);
}
else
{
program = item->getShaderProgram(Scene_spheres_item::PROGRAM_SPHERES, viewer);
item->attribBuffers(viewer, Scene_spheres_item::PROGRAM_SPHERES);
}
item->getTriangleContainer(0)->initializeBuffers(viewer);
item->getTriangleContainer(0)->setFlatDataSize(vertices.size());
item->getTriangleContainer(0)->setCenterSize(static_cast<int>(centers.size()));
//vertices.clear();
//vertices.shrink_to_fit();
item->getEdgeContainer(0)->initializeBuffers(viewer);
item->getEdgeContainer(0)->setFlatDataSize(edges.size());
item->getEdgeContainer(0)->setCenterSize(static_cast<int>(centers.size()));
// edges.clear();
// edges.shrink_to_fit();
program->bind();
item->vaos[Facets]->bind();
item->buffers[Vertices].bind();
item->buffers[Vertices].allocate(vertices.data(),
static_cast<int>(vertices.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
item->buffers[Vertices].release();
item->buffers[Normals].bind();
item->buffers[Normals].allocate(normals.data(),
static_cast<int>(normals.size()*sizeof(float)));
program->enableAttributeArray("normals");
program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
item->buffers[Normals].release();
item->buffers[Color].bind();
item->buffers[Color].allocate(colors.data(),
static_cast<int>(colors.size()*sizeof(float)));
program->enableAttributeArray("colors");
program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
item->buffers[Color].release();
item->buffers[Radius].bind();
item->buffers[Radius].allocate(radius.data(),
static_cast<int>(radius.size()*sizeof(float)));
program->enableAttributeArray("radius");
program->setAttributeBuffer("radius", GL_FLOAT, 0, 1);
item->buffers[Radius].release();
item->buffers[Center].bind();
item->buffers[Center].allocate(centers.data(),
static_cast<int>(centers.size()*sizeof(float)));
program->enableAttributeArray("center");
program->setAttributeBuffer("center", GL_FLOAT, 0, 3);
item->buffers[Center].release();
viewer->glVertexAttribDivisor(program->attributeLocation("center"), 1);
viewer->glVertexAttribDivisor(program->attributeLocation("radius"), 1);
viewer->glVertexAttribDivisor(program->attributeLocation("colors"), 1);
item->vaos[Facets]->release();
item->vaos[Edges]->bind();
item->buffers[Edge_vertices].bind();
item->buffers[Edge_vertices].allocate(edges.data(),
static_cast<int>(edges.size()*sizeof(float)));
program->enableAttributeArray("vertex");
program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
item->buffers[Edge_vertices].release();
item->buffers[Normals].bind();
program->enableAttributeArray("normals");
program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
item->buffers[Normals].release();
item->buffers[Edge_color].bind();
item->buffers[Edge_color].allocate(edges_colors.data(),
static_cast<int>(edges_colors.size()*sizeof(float)));
program->enableAttributeArray("colors");
program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
item->buffers[Edge_color].release();
item->buffers[Radius].bind();
program->enableAttributeArray("radius");
program->setAttributeBuffer("radius", GL_FLOAT, 0, 1);
item->buffers[Radius].release();
item->buffers[Center].bind();
program->enableAttributeArray("center");
program->setAttributeBuffer("center", GL_FLOAT, 0, 3);
item->buffers[Center].release();
viewer->glVertexAttribDivisor(program->attributeLocation("center"), 1);
viewer->glVertexAttribDivisor(program->attributeLocation("radius"), 1);
viewer->glVertexAttribDivisor(program->attributeLocation("colors"), 1);
item->vaos[Edges]->release();
program->release();
nb_centers = static_cast<int>(centers.size());
centers.clear();
centers.swap(centers);
colors.clear();
colors.swap(colors);
radius.clear();
radius.swap(radius);
edges_colors.clear();
edges_colors.swap(edges_colors);
item->are_buffers_filled = true;
//centers.clear();
//centers.swap(centers);
//colors.clear();
//colors.swap(colors);
//radius.clear();
//radius.swap(radius);
//edges_colors.clear();
//edges_colors.swap(edges_colors);
}
void Scene_spheres_item::draw(Viewer_interface *viewer) const
{
if (!are_buffers_filled)
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
d->initializeBuffers(viewer);
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
if(!getBuffersFilled())
{
computeElements();
initializeBuffers(viewer);
}
vaos[Scene_spheres_item_priv::Facets]->bind();
if(d->has_plane)
{
d->program = getShaderProgram(PROGRAM_CUTPLANE_SPHERES, viewer);
attribBuffers(viewer, PROGRAM_CUTPLANE_SPHERES);
d->program->bind();
QVector4D cp(d->plane.a(),d->plane.b(),d->plane.c(),d->plane.d());
d->program->setUniformValue("cutplane", cp);
getTriangleContainer(0)->setPlane(cp);
}
else
{
d->program = getShaderProgram(PROGRAM_SPHERES, viewer);
attribBuffers(viewer, PROGRAM_SPHERES);
d->program->bind();
}
viewer->glDrawArraysInstanced(GL_TRIANGLES, 0,
static_cast<GLsizei>(d->vertices.size()/3),
static_cast<GLsizei>(d->nb_centers));
d->program->release();
vaos[Scene_spheres_item_priv::Facets]->release();
qDebug()<<"flat data size = "<<getTriangleContainer(0)->getFlatDataSize();
qDebug()<<"centers size = "<<getTriangleContainer(0)->getCenterSize();
getTriangleContainer(0)->draw(viewer, false);
}
void Scene_spheres_item::drawEdges(Viewer_interface *viewer) const
{
if (!are_buffers_filled)
if(!isInit())
initGL();
if ( getBuffersFilled() &&
! getBuffersInit(viewer))
{
d->initializeBuffers(viewer);
initializeBuffers(viewer);
setBuffersInit(viewer, true);
}
vaos[Scene_spheres_item_priv::Edges]->bind();
if(!getBuffersFilled())
{
computeElements();
initializeBuffers(viewer);
}
if(d->has_plane)
{
d->program = getShaderProgram(PROGRAM_CUTPLANE_SPHERES, viewer);
attribBuffers(viewer, PROGRAM_CUTPLANE_SPHERES);
d->program->bind();
QVector4D cp(d->plane.a(),d->plane.b(),d->plane.c(),d->plane.d());
d->program->setUniformValue("cutplane", cp);
getEdgeContainer(0)->setPlane(cp);
}
else
{
d->program = getShaderProgram(PROGRAM_SPHERES, viewer);
attribBuffers(viewer, PROGRAM_SPHERES);
d->program->bind();
}
viewer->glDrawArraysInstanced(GL_LINES, 0,
static_cast<GLsizei>(d->edges.size()/3),
static_cast<GLsizei>(d->nb_centers));
d->program->release();
vaos[Scene_spheres_item_priv::Edges]->release();
getEdgeContainer(0)->draw(viewer, false);
}
void Scene_spheres_item::add_sphere(const CGAL::Sphere_3<Kernel>& sphere, CGAL::Color color)
{
@ -258,7 +183,12 @@ void Scene_spheres_item::clear_spheres()
}
void Scene_spheres_item::setPrecision(int prec) { d->precision = prec; }
void Scene_spheres_item::setPlane(Kernel::Plane_3 p_plane) { d->plane = p_plane; }
void Scene_spheres_item::invalidateOpenGLBuffers(){are_buffers_filled = false;}
void Scene_spheres_item::invalidateOpenGLBuffers()
{
setBuffersFilled(false);
getTriangleContainer(0)->reset_vbos(ALL);
getEdgeContainer(0)->reset_vbos(ALL);
}
QString
Scene_spheres_item::toolTip() const {
@ -275,3 +205,42 @@ void Scene_spheres_item::setColor(QColor c)
CGAL::Three::Scene_item::setColor(c);
this->on_color_changed();
}
void Scene_spheres_item::initializeBuffers(Viewer_interface * v) const
{
d->initializeBuffers(v);
}
void Scene_spheres_item::computeElements() const
{
getTriangleContainer(0)->allocate(Tc::Flat_vertices, d->vertices.data(),
static_cast<int>(d->vertices.size()*sizeof(float)));
getTriangleContainer(0)->allocate(Tc::Flat_normals, d->normals.data(),
static_cast<int>(d->normals.size()*sizeof(float)));
getTriangleContainer(0)->allocate(Tc::FColors, d->colors.data(),
static_cast<int>(d->colors.size()*sizeof(float)));
getTriangleContainer(0)->allocate(Tc::Radius, d->radius.data(),
static_cast<int>(d->radius.size()*sizeof(float)));
getTriangleContainer(0)->allocate(Tc::Facet_centers, d->centers.data(),
static_cast<int>(d->centers.size()*sizeof(float)));
getEdgeContainer(0)->allocate(Ec::Vertices, d->edges.data(),
static_cast<int>(d->edges.size()*sizeof(float)));
getEdgeContainer(0)->allocate(Ec::Normals, d->normals.data(),
static_cast<int>(d->normals.size()*sizeof(float)));
getEdgeContainer(0)->allocate(Ec::Colors, d->edges_colors.data(),
static_cast<int>(d->edges_colors.size()*sizeof(float)));
getEdgeContainer(0)->allocate(Ec::Radius, d->radius.data(),
static_cast<int>(d->radius.size()*sizeof(float)));
getEdgeContainer(0)->allocate(Ec::Centers, d->centers.data(),
static_cast<int>(d->centers.size()*sizeof(float)));
setBuffersFilled(true);
}

9
Polyhedron/demo/Polyhedron/Scene_spheres_item.h
View File

@ -4,7 +4,7 @@
#include "create_sphere.h"
#include <CGAL/Three/Scene_group_item.h>
#include <CGAL/Three/Scene_item.h>
#include <CGAL/Three/Scene_item_rendering_helper.h>
#include <CGAL/Three/Scene_interface.h>
#include <CGAL/Three/Viewer_interface.h>
#include <CGAL/Sphere_3.h>
@ -16,7 +16,7 @@
#include <vector>
struct Scene_spheres_item_priv;
class SCENE_BASIC_OBJECTS_EXPORT Scene_spheres_item
: public CGAL::Three::Scene_item
: public CGAL::Three::Scene_item_rendering_helper
{
Q_OBJECT
public:
@ -42,12 +42,11 @@ public:
void draw(CGAL::Three::Viewer_interface* viewer) const Q_DECL_OVERRIDE;
void drawEdges(CGAL::Three::Viewer_interface* viewer) const Q_DECL_OVERRIDE;
void invalidateOpenGLBuffers() Q_DECL_OVERRIDE;
void computeElements() const ;
void setPlane(Kernel::Plane_3 p_plane);
void setToolTip(QString s);
void setColor(QColor c) Q_DECL_OVERRIDE;
void newViewer(Viewer_interface *viewer) Q_DECL_OVERRIDE{}
void removeViewer(Viewer_interface *viewer) Q_DECL_OVERRIDE{}
void initializeBuffers(Viewer_interface *) const Q_DECL_OVERRIDE;
void computeElements() const Q_DECL_OVERRIDE;
Q_SIGNALS:
void on_color_changed();
protected:

24
Polyhedron/demo/Polyhedron/Triangle_container.cpp
View File

@ -16,6 +16,7 @@ struct Tri_d{
Triangle_container* container;
float shrink_factor;
QVector4D plane;
bool is_surface;
float alpha;
QMatrix4x4 f_matrix;
};
@ -93,13 +94,13 @@ void Triangle_container::initGL( Viewer_interface* viewer)
QOpenGLBuffer::VertexBuffer, GL_FLOAT, 0, 3));
getVao(viewer)->addVbo(getVbo(FColors));
if(viewer->getShaderProgram(getProgram())->property("hasBarycenter").toBool())
if(viewer->getShaderProgram(getProgram())->property("hasCenter").toBool())
{
if(!getVbo(Facet_barycenters))
setVbo(Facet_barycenters,
new Vbo("barycenter",
if(!getVbo(Facet_centers))
setVbo(Facet_centers,
new Vbo("center",
Vbo::GEOMETRY));
getVao(viewer)->addVbo(getVbo(Facet_barycenters));
getVao(viewer)->addVbo(getVbo(Facet_centers));
}
if(viewer->getShaderProgram(getProgram())->property("hasRadius").toBool())
@ -153,6 +154,8 @@ void Triangle_container::draw(Viewer_interface* viewer,
getVao(viewer)->bind();
if(getVao(viewer)->program->property("hasCutPlane").toBool())
getVao(viewer)->program->setUniformValue("cutplane", d->plane);
if(getVao(viewer)->program->property("hasSurfaceMode").toBool())
getVao(viewer)->program->setUniformValue("is_surface", d->is_surface);
if(is_color_uniform)
getVao(viewer)->program->setAttributeValue("colors", getColor());
if(getVao(viewer)->program->property("hasFMatrix").toBool())
@ -172,13 +175,13 @@ void Triangle_container::draw(Viewer_interface* viewer,
if(getVao(viewer)->program->property("isInstanced").toBool())
{
viewer->glDrawArraysInstanced(GL_TRIANGLES, 0,
static_cast<GLsizei>(getFlatDataSize()/3),
static_cast<GLsizei>(getFlatDataSize()/getTupleSize()),
static_cast<GLsizei>(getCenterSize()/3));
}
else
{
viewer->glDrawArrays(GL_TRIANGLES,0,static_cast<GLsizei>(getFlatDataSize()/3));
viewer->glDrawArrays(GL_TRIANGLES,0,static_cast<GLsizei>(getFlatDataSize()/getTupleSize()));
}
getVao(viewer)->release();
@ -192,8 +195,9 @@ void Triangle_container::initializeBuffers(Viewer_interface *viewer)
if(getVao(viewer)->program->property("isInstanced").toBool())
{
getVao(viewer)->bind();
if(getVao(viewer)->program->property("hasBarycenter").toBool())
viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("barycenter"), 1);
if(getVao(viewer)->program->property("isInstanced").toBool() &&
getVao(viewer)->program->property("hasCenter").toBool())
viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("center"), 1);
if(getVao(viewer)->program->property("hasRadius").toBool())
viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("radius"), 1);
viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("colors"), 1);
@ -209,3 +213,5 @@ QMatrix4x4 Triangle_container::getFrameMatrix() const { return d->f_matrix; }
void Triangle_container::setShrinkFactor(const float& f) { d->shrink_factor = f; }
void Triangle_container::setAlpha (const float& f) { d->alpha = f ; }
void Triangle_container::setFrameMatrix(const QMatrix4x4& m) { d->f_matrix = m; }
void Triangle_container::setPlane(const QVector4D& p) { d->plane = p; }
void Triangle_container::setIsSurface (const bool b) { d->is_surface = b; }

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

@ -1084,6 +1084,7 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
program->setProperty("hasNormals", true);
program->setProperty("hasCutPlane", true);
program->setProperty("hasTransparency", true);
program->setProperty("hasCenter", true);
return program;
}
case PROGRAM_C3T3_EDGES:
@ -1176,7 +1177,7 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
":/cgal/Polyhedron_3/resources/compatibility_shaders/shader_without_light.f");
program->setProperty("hasLight", true);
program->setProperty("hasNormals", true);
program->setProperty("hasBarycenter", true);
program->setProperty("hasCenter", true);
program->setProperty("isInstanced", true);
return program;
}
@ -1188,7 +1189,7 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
":/cgal/Polyhedron_3/resources/compatibility_shaders/shader_c3t3.f");
program->setProperty("hasLight", true);
program->setProperty("hasNormals", true);
program->setProperty("hasBarycenter", true);
program->setProperty("hasCenter", true);
program->setProperty("hasRadius", true);
program->setProperty("isInstanced", true);
return program;
@ -1201,7 +1202,7 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
":/cgal/Polyhedron_3/resources/compatibility_shaders/shader_with_light.f");
program->setProperty("hasLight", true);
program->setProperty("hasNormals", true);
program->setProperty("hasBarycenter", true);
program->setProperty("hasCenter", true);
program->setProperty("hasRadius", true);
program->setProperty("hasTransparency", true);
program->setProperty("isInstanced", true);
@ -1231,15 +1232,19 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
return program;
}
case PROGRAM_SOLID_WIREFRAME:
{
if(!isOpenGL_4_3())
{
std::cerr<<"An OpenGL context of version 4.3 is required for the program ("<<name<<")."<<std::endl;
return 0;
}
return declare_program(name,
":/cgal/Polyhedron_3/resources/solid_wireframe_shader.v",
":/cgal/Polyhedron_3/resources/solid_wireframe_shader.f");
break;
QOpenGLShaderProgram* program = declare_program(name,
":/cgal/Polyhedron_3/resources/solid_wireframe_shader.v",
":/cgal/Polyhedron_3/resources/solid_wireframe_shader.f");
program->setProperty("hasViewport", true);
program->setProperty("hasWidth", true);
return program;
}
default:
std::cerr<<"ERROR : Program not found."<<std::endl;
return 0;

6
Polyhedron/demo/Polyhedron/resources/shader_c3t3.v
View File

@ -2,7 +2,7 @@
in vec4 vertex;
in vec3 normals;
in vec3 colors;
in vec3 barycenter;
in vec3 center;
uniform mat4 mvp_matrix;
uniform mat4 mv_matrix;
uniform vec4 cutplane;
@ -26,11 +26,11 @@ void main(void)
mat4 transOB = mat4(1, 0, 0, 0, // first column
0, 1, 0, 0, // second column
0, 0, 1, 0, // third column
barycenter.x, barycenter.y, barycenter.z, 1); // fourth column
center.x, center.y, center.z, 1); // fourth column
mat4 transBO = mat4(1, 0, 0, 0, // first column
0, 1, 0, 0, // second column
0, 0, 1, 0, // third column
-barycenter.x, -barycenter.y, -barycenter.z, 1); // fourth column
-center.x, -center.y, -center.z, 1); // fourth column
mat4 scaling = mat4(shrink_factor, 0, 0, 0,
0, shrink_factor, 0, 0,
0, 0, shrink_factor, 0,

12
Three/include/CGAL/Three/Edge_container.h
View File

@ -55,7 +55,7 @@ struct DEMO_FRAMEWORK_EXPORT Edge_container :public Primitive_container
Normals, //!< Designates the buffer that contains the normal coordinates.
Colors, //!< Designates the buffer that contains the color components.
Radius, //!< Designates the buffer that contains the radius of wire spheres.
Barycenters, //!< Designates the buffer that contains the barycenter of c3t3 facets or the center of wire spheres, for example.
Centers, //!< Designates the buffer that contains the center of c3t3 facets or the center of wire spheres, for example.
NbOfVbos //!< Designates the size of the VBOs vector for `Edge_container`s
};
@ -97,11 +97,21 @@ struct DEMO_FRAMEWORK_EXPORT Edge_container :public Primitive_container
QVector4D getPlane()const;
//! getter for the "f_matrix" parameter
QMatrix4x4 getFrameMatrix()const;
//! getter for the "viewport" parameter
QVector2D getViewport()const;
//! getter for the "width" parameter
GLfloat getWidth()const;
//! setter for the "plane" parameter
void setPlane(const QVector4D&);
//! setter for the "f_matrix" parameter
void setFrameMatrix(const QMatrix4x4&);
//! setter for the "viewport" parameter
void setViewport(const QVector2D&);
//! setter for the "width" parameter
void setWidth(const GLfloat&);
//! setter for the "is_surface" attribute. Used in PROGRAM_C3T3_EDGES
void setIsSurface (const bool);
///@}
private:

4
Three/include/CGAL/Three/Point_container.h
View File

@ -95,6 +95,10 @@ struct DEMO_FRAMEWORK_EXPORT Point_container :public Primitive_container
QMatrix4x4 getFrameMatrix()const;
//! setter for the "f_matrix" parameter
void setFrameMatrix(const QMatrix4x4&);
//! setter for the "plane" parameter
void setPlane(const QVector4D&);
//! setter for the "is_surface" attribute. Used in PROGRAM_C3T3_EDGES
void setIsSurface (const bool);
///@}
private:

6
Three/include/CGAL/Three/Primitive_container.h
View File

@ -150,6 +150,8 @@ public:
void setStride(std::size_t id, int stride);
//!Setter for the "offset" parameter.
void setOffset(std::size_t id, int offset);
//!setter for the tuple size: the number of coordinates of one vertex.
void setTupleSize(int ts);
//!@}
//!
@ -202,9 +204,13 @@ public:
//! \brief getIdxSize returns the number of indexed
//! vertices.
std::size_t getIdxSize()const;
//! \brief getTupleSize returns the number of coordinates in one vertex.
//! Default is 3.
int getTupleSize()const;
//! \brief getCenterSize returns the number of instances of
//! the item in this container.
std::size_t getCenterSize()const;
//! \name Getters for the shaders parameters.
//!@{

12
Three/include/CGAL/Three/Scene_group_item.h
View File

@ -26,7 +26,7 @@
#include <CGAL/license/Three.h>
#include <CGAL/Three/Scene_item.h>
#include <CGAL/Three/Scene_item_rendering_helper.h>
#include <CGAL/Three/Scene_interface.h>
using namespace CGAL::Three;
@ -43,14 +43,12 @@ namespace Three {
//! user to apply several actions to multiple items at the same time.
//! A custom Scene_item can derive from it to have children. They appear
//! hierarchically in the Geometric Objects list.
class DEMO_FRAMEWORK_EXPORT Scene_group_item : public Scene_item
class DEMO_FRAMEWORK_EXPORT Scene_group_item : public Scene_item_rendering_helper
{
Q_OBJECT
public :
Scene_group_item(QString name = QString("New group"), int nb_vbos = 0, int nb_vaos = 0);
Scene_group_item(QString name = QString("New group"));
~Scene_group_item() {}
//!Sets the scene;
void setScene(Scene_interface* s) { scene = s; }
//!Returns false to avoid disturbing the BBox of the scene.
bool isFinite() const Q_DECL_OVERRIDE;
//!Returns true to avoid disturbing the BBox of the scene.
@ -237,8 +235,8 @@ public :
void moveUp(int);
//!Moves a child down in the list.
void moveDown(int);
void removeViewer(CGAL::Three::Viewer_interface* )Q_DECL_OVERRIDE;
void newViewer(CGAL::Three::Viewer_interface* )Q_DECL_OVERRIDE{};
void compute_bbox() const Q_DECL_OVERRIDE{};
public Q_SLOTS:
//!\brief Redraws children.
//!

4
Three/include/CGAL/Three/Triangle_container.h
View File

@ -52,7 +52,7 @@ struct DEMO_FRAMEWORK_EXPORT Triangle_container :public Primitive_container
Vertex_indices, //!< Designates the buffer that contains the indices for the smooth vertices.
Flat_normals, //!< Designates the buffer that contains the normals for the flat vertices.
Smooth_normals, //!< Designates the buffer that contains the normals for the smooth vertices.
Facet_barycenters, //!< Designates the buffer that contains the barycenters of the c3t3 facets or the center of the spheres.
Facet_centers, //!< Designates the buffer that contains the barycenters of the c3t3 facets or the center of the spheres.
Radius, //!< Designates the buffer that contains the radius of the spheres.
VColors, //!< Designates the buffer that contains the colors of the smooth vertices.
FColors, //!< Designates the buffer that contains the colors of the flat vertices.
@ -105,6 +105,8 @@ struct DEMO_FRAMEWORK_EXPORT Triangle_container :public Primitive_container
void setAlpha (const float&);
//! setter for the "f_matrix" parameter
void setFrameMatrix(const QMatrix4x4&);
//! setter for the "is_surface" attribute. Used in PROGRAM_C3T3
void setIsSurface (const bool);
///@}
//drawing variables