- An item that wants to print its primitives must inherit from CGAL::Three::Scene_item_print_interface,
that contains the two print function. That way, to test if an item is able to print, one just has to check
if a cast to CGAL::Three::Scene_item_print_interface works.
- It seems that overloading the paintEvent was sufficient to get rid of
the "black screen" bug, and initializing targeted_id to NULL fixed the
segfault occuring when loading an item.
- The textItems containing the ids are only computed when ctrl+I are
pressed. There could be an optimization here, so that it is computed
only once, and not every time the ids are displayed.
- Uses the aabb_tree to find the selected facet
- iterate its vertices and halfedges and compute the distances between the Id spots and the selected point
- only prints the spot with the smallest distance.
- Ids are all displayed where they should
- WIP : only print the ones that are not hidden by another item or facet
- TO DO: Change the API so that the destructor of an item can remove the textItems from the renderer.
- Created a Scene_spheres_item
- Made the Scene_c3t3_item a group_item
- Changed the spheres management in the c3t3_item
- Fixed the has_group maintanance in group_items
New feature: an object of class `Scene_group_item`, or derived, is
responsible for drawing its children items. That is the first
approximation of a scene graph.
For that goal, several steps were needed.
- Remove the overload of `Scene::draw()` and `Scene::drawWithNames()`
that does not have the viewer as parameter. Remove then from
`Scene_draw_interface` as well.
- Add `Viewer::inDrawWithNames()` so that items, including the
`Scene_group_item`, can now if a draw function is called for the
picking or not.
- Add the draw function in `Scene_group_item`:
```
virtual void draw(CGAL::Three::Viewer_interface*) const;
virtual void draw_edges(CGAL::Three::Viewer_interface*) const;
virtual void draw_points(CGAL::Three::Viewer_interface*) const;
virtual void draw_splats(CGAL::Three::Viewer_interface*) const;
```
Those draw functions actually call the draw functions of all the
visible children, depending on their rendering mode. If
`viewer->inDrawWithNames()`, draw nothing, and let the children be
drawn with their own names. Another solution could be that the draw
functions of `Scene_group_item` use `glPushName/glPopName`. That API
seems to be usable with a scene graph.
- Add in `Scene_item` two functions:
```
void moveToGroup(Scene_group_item* group);
Scene_group_item* parentGroup() const;
```
That is one first step to allow the `has_group` data member to become
a private member, instead a public one (ugly!!).
Then the big change is in the scene:
- The scene will not call the draw function of items with a parent
group, if the group itself is visible. If the group is not visible but
the children are set to visible, then they are drawn anyway. That
means that a group can "steal" the drawing of its children when it is
visible. That behavior is really convenient for the use case I have in
mind, but it may be strange.
- In the picking, in `drawWithName()`, the draw function of all items
are called, even if they have a parent group.
Cosmetic:
- Move the definition of the constructor `Scene_item::Scene_item` in
the cpp file.
Sébastien Loriot
Maxime Gimeno
Sebastien Loriot
Maxime GIMENO
Laurent Rineau