void Scene::changed()
{
if(m_cut_plane == UNSIGNED_FACETS || m_cut_plane == UNSIGNED_EDGES)
compute_elements(_UNSIGNED);
else
compute_elements(_SIGNED);
are_buffers_initialized = false;
}
void Scene_polyhedron_selection_item::draw(Viewer_interface* viewer) const
{
if(!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
draw_points(viewer);
GLfloat offset_factor;
GLfloat offset_units;
viewer->glGetFloatv( GL_POLYGON_OFFSET_FACTOR, &offset_factor);
viewer->glGetFloatv(GL_POLYGON_OFFSET_UNITS, &offset_units);
glPolygonOffset(-1.f, 1.f);
vaos[0]->bind();
program = getShaderProgram(PROGRAM_WITH_LIGHT);
attrib_buffers(viewer,PROGRAM_WITH_LIGHT);
program->bind();
program->setAttributeValue("colors",facet_color);
viewer->glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(nb_facets/3));
program->release();
vaos[0]->release();
glPolygonOffset(offset_factor, offset_units);
draw_edges(viewer);
}
void Scene_c3t3_item::draw_points(CGAL::Three::Viewer_interface * viewer) const
{
if (!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
vaos[Edges]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors", this->color());
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(positions_lines.size() / 3));
vaos[Edges]->release();
program->release();
vaos[2]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors", this->color());
QMatrix4x4 f_mat;
for (int i = 0; i<16; i++)
f_mat.data()[i] = frame->matrix()[i];
program->setUniformValue("f_matrix", f_mat);
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(positions_grid.size() / 3));
program->release();
vaos[2]->release();
}
void Scene_polylines_item::invalidate_buffers()
{
compute_elements();
are_buffers_filled = false;
}
void Scene_polylines_item::changed()
{
compute_elements();
are_buffers_filled = false;
}
// Wireframe OpenGL drawing
void
Scene_polylines_item::draw_edges(Viewer_interface* viewer) const {
if(!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
vaos[0]->bind();
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors", this->color());
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(nb_lines/4));
program->release();
vaos[0]->release();
if(d->draw_extremities)
{
if(viewer->extension_is_found)
{
vaos[2]->bind();
attrib_buffers(viewer, PROGRAM_INSTANCED_WIRE);
program = getShaderProgram(PROGRAM_INSTANCED_WIRE);
program->bind();
viewer->glDrawArraysInstanced(GL_LINES, 0,
static_cast<GLsizei>(nb_wire/3), nbSpheres);
program->release();
vaos[2]->release();
}
}
}
void Scene_c3t3_item::draw(CGAL::Three::Viewer_interface* viewer) const {
if (!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
vaos[Facets]->bind();
program = getShaderProgram(PROGRAM_WITH_LIGHT);
attrib_buffers(viewer, PROGRAM_WITH_LIGHT);
program->bind();
//program->setAttributeValue("colors", this->color());
viewer->glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(positions_poly.size() / 3));
program->release();
vaos[Facets]->release();
if(spheres_are_shown)
{
vaos[Spheres]->bind();
program_sphere->bind();
//ModelViewMatrix used for the transformation of the camera.
QMatrix4x4 mvp_mat;
// ModelView Matrix used for the lighting system
QMatrix4x4 mv_mat;
GLdouble d_mat[16];
GLint is_both_sides = 0;
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]);
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);
viewer->glGetIntegerv(GL_LIGHT_MODEL_TWO_SIDE, &is_both_sides);
program_sphere->setUniformValue("mvp_matrix", mvp_mat);
program_sphere->setUniformValue("mv_matrix", mv_mat);
program_sphere->setUniformValue("light_pos", position);
program_sphere->setUniformValue("light_diff",diffuse);
program_sphere->setUniformValue("light_spec", specular);
program_sphere->setUniformValue("light_amb", ambient);
program_sphere->setUniformValue("spec_power", 51.8f);
program_sphere->setUniformValue("is_two_side", is_both_sides);
viewer->glDrawArraysInstanced(GL_TRIANGLES, 0,
static_cast<GLsizei>(s_vertex.size()/3),
static_cast<GLsizei>(s_radius.size()));
program_sphere->release();
vaos[Spheres]->release();
}
}
void
Viewer::sceneChanged()
{
this->camera()->setSceneBoundingBox(qglviewer::Vec(bb.xmin(),
bb.ymin(),
bb.zmin()),
qglviewer::Vec(bb.xmax(),
bb.ymax(),
bb.zmax()));
compute_elements();
are_buffers_initialized = false;
this->showEntireScene();
}
void Scene_combinatorial_map_item::draw_points(CGAL::Three::Viewer_interface* viewer) const
{
if(!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
vaos[Points]->bind();
program=getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer,PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors", this->color());
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(nb_points/3));
vaos[Points]->release();
program->release();
}
void Viewer::sceneChanged()
{
compute_elements();
this->camera()->setSceneBoundingBox(qglviewer::Vec(bb.xmin(),
bb.ymin(),
bb.zmin()),
qglviewer::Vec(bb.xmax(),
bb.ymax(),
bb.zmax()));
are_buffers_initialized = false;
if (m_previous_scene_empty)
this->showEntireScene();
else
this->updateGL();
m_previous_scene_empty = scene->lcc->is_empty(); // for the next call to sceneChanged
}
void
Scene_polylines_item::draw_points(Viewer_interface* viewer) const {
if(!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
vaos[0]->bind();
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
program->bind();
QColor temp = this->color();
program->setAttributeValue("colors", temp);
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(nb_lines/4));
// Clean-up
vaos[0]->release();
program->release();
}
void Scene_polyhedron_selection_item::draw_points(Viewer_interface* viewer) const
{
if(!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
viewer->glPointSize(5.f);
vaos[2]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer,PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors",vertex_color);
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(nb_points/3));
program->release();
vaos[2]->release();
viewer->glPointSize(1.f);
}
void Scene_polyhedron_selection_item::draw_edges(Viewer_interface* viewer) const
{
if(!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
viewer->glLineWidth(3.f);
vaos[1]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer,PROGRAM_WITHOUT_LIGHT);
program->bind();
program->setAttributeValue("colors",edge_color);
viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(nb_lines/3));
program->release();
vaos[1]->release();
viewer->glLineWidth(1.f);
}
// Shaded OpenGL drawing: only draw spheres
void
Scene_polylines_item::draw(Viewer_interface* viewer) const {
if(!are_buffers_filled)
{
compute_elements();
initialize_buffers(viewer);
}
if(d->draw_extremities)
{
if(viewer->extension_is_found)
{
vaos[1]->bind();
program = getShaderProgram(PROGRAM_INSTANCED);
attrib_buffers(viewer, PROGRAM_INSTANCED);
program->bind();
viewer->glDrawArraysInstanced(GL_TRIANGLES, 0,
static_cast<GLsizei>(nb_spheres/3), nbSpheres);
program->release();
vaos[1]->release();
}
else
{
vaos[1]->bind();
program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
attrib_buffers(viewer, PROGRAM_WITHOUT_LIGHT);
glPointSize(8.0f);
glEnable(GL_POINT_SMOOTH);
program->bind();
viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(nb_centers/3));
glDisable(GL_POINT_SMOOTH);
program->release();
vaos[1]->release();
}
}
}
void Viewer::changed()
{
compute_elements();
are_buffers_initialized = false;
}
void Scene_polyhedron_transform_item::changed()
{
compute_elements();
are_buffers_filled = false;
}
void Scene_implicit_function_item::changed()
{
compute_elements();
are_buffers_initialized = false;
}
void Scene_polyhedron_transform_item::invalidateOpenGLBuffers()
{
compute_elements();
are_buffers_filled = false;
compute_bbox();
}
void Scene_polyhedron_shortest_path_item::changed()
{
compute_elements();
are_buffers_filled = false;
}
