Tulip 5.7.1
Large graphs analysis and drawing
Loading...
Searching...
No Matches
GlLayer.h
1/*
2 *
3 * This file is part of Tulip (https://tulip.labri.fr)
4 *
5 * Authors: David Auber and the Tulip development Team
6 * from LaBRI, University of Bordeaux
7 *
8 * Tulip is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation, either version 3
11 * of the License, or (at your option) any later version.
12 *
13 * Tulip is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 * See the GNU General Public License for more details.
17 *
18 */
19
20#ifndef Tulip_GLLAYER_H
21#define Tulip_GLLAYER_H
22
23#include <tulip/tulipconf.h>
24#include <tulip/GlComposite.h>
25
26namespace tlp {
27
28class Graph;
29class GlScene;
30class GlSceneVisitor;
31class GlGraphComposite;
32
33/**
34 * @ingroup OpenGL
35 * @brief A GlLayer is like an 2D drawing software layer system
36 *
37 * A layer is an entity with a Camera and a GlComposite to store GlEntity
38 * Layers are used with GlScene : you can add a layer to a scene and a scene can have many layers
39 * @see Camera
40 * @see GlComposite
41 * @see GlSimpleEntity
42 * @see GlScene
43 *
44 *
45 * You have two constructor for GlLayer : one with a camera pointer and one without
46 * The constructor without camera pointer create a layer with a new camera and delete this camera at
47 * the destruction
48 * The constructor with camera pointer create a layer and use the camera pointer but you have the
49 * responsibility of camera destruction
50 *
51 * After you have created a layer, you can populate the layer with GlEntity and addGlEntity()
52 * functions
53 */
54class TLP_GL_SCOPE GlLayer {
55
56public:
57 /**
58 * @brief Layer constructor : construct a layer with his name
59 * A new camera is created for this layer and this camera will be deleted in the GlLayer
60 * destructor
61 * @param name layer name
62 * @param workingLayer a working layer is not displayed on overview
63 */
64 GlLayer(const std::string &name, bool workingLayer = false);
65
66 /**
67 * @brief Layer constructor : construct a layer with his name and use the camera : camera
68 * You have the responsibility of camera destruction
69 * @param name layer name
70 * @param camera camera to use in this layer
71 * @param workingLayer a working layer is not displayed on overview
72 */
73 GlLayer(const std::string &name, Camera *camera, bool workingLayer = false);
74
75 /**
76 * @brief Destructor
77 */
79
80 /**
81 * @brief Return the scene where the layer is
82 */
84 return scene;
85 }
86
87 /**
88 * @brief Return the layer's name
89 */
90 std::string getName() {
91 return name;
92 }
93
94 /**
95 * @brief Set the layer's camera
96 * GlLayer now use a copy of the camera parameters
97 */
98 void setCamera(Camera *camera);
99
100 /**
101 * Set the layer's camera
102 * GlLayer now use camera parameters and you have the responsibility of camera destruction
103 */
104 void setSharedCamera(Camera *camera);
105
106 /**
107 * @brief Replace the layer's camera with a new 2D one
108 */
109 void set2DMode();
110
111 /**
112 * @brief Return the layer's camera
113 */
115 return *camera;
116 }
117
118 /**
119 * @brief Set if the layer is visible
120 */
121 void setVisible(bool visible);
122
123 /**
124 * @brief Return if the layer is visible
125 */
126 bool isVisible() {
127 return composite.isVisible();
128 }
129
130 /**
131 * @brief Add an entity to GlComposite of the layer
132 */
133 void addGlEntity(GlSimpleEntity *entity, const std::string &name);
134
135 /**
136 * @brief A convenient function that adds a graph to the layer
137 *
138 * This method will automatically create a GlGraphComposite entity and add it to the layer.
139 */
140 void addGraph(tlp::Graph *graph, const std::string &name);
141
142 /**
143 * @brief Remove entity with name : key
144 * This entity is not deleted
145 */
146 void deleteGlEntity(const std::string &key);
147
148 /**
149 * @brief Remove entity
150 * This entity is not deleted
151 */
153
154 /**
155 * @brief Return entity with name : key
156 */
157 GlSimpleEntity *findGlEntity(const std::string &key);
158
159 /**
160 * @brief Return the map of layer's entities
161 */
162 const std::map<std::string, GlSimpleEntity *> &getGlEntities() const;
163
164 /**
165 * @brief Return the GlComposite used by the layer
166 * A GlLayer is only a container of a camera and a composite, so to manipulate GlEntity on this
167 * layer you can get the GlComposite and add/remove entities on this composite
168 */
170 return &composite;
171 }
172
173 /**
174 * @brief Remove all entities of the layer
175 * Entities are not deleted so before call this function you have to get the entities list and you
176 * have the responsibility of entities destruction
177 */
178 void clear() {
179 composite.reset(false);
180 }
181
182 /**
183 * @brief Return if this layer is a working layer
184 * A working layer is not displayed on overview
185 */
187 return workingLayer;
188 }
189
190 /**
191 * @brief Return if this layer use a shared camera
192 * A shared camera is a camera used by more than one Layer, so if this layer use a shared camera
193 * we don't have to delete it when the layer is destroyed
194 */
196 return sharedCamera;
197 }
198
199 /**
200 * Get XML description of the layer and children and store it in out string
201 */
202 void getXML(std::string &outString);
203
204 /**
205 * @brief Get XML description of cameras of the layer and store it in out string
206 */
207 void getXMLOnlyForCameras(std::string &outString);
208
209 /**
210 * @brief Function to set data with inString (in XML format)
211 */
212 void setWithXML(const std::string &inString, unsigned int &currentPosition);
213
214 ///@cond DOXYGEN_HIDDEN
215
216 /**
217 * This function is automatically called when a GlGraphComposite is added in this layer
218 * You don't have to call this function
219 */
220 void glGraphCompositeAdded(GlGraphComposite *composite);
221
222 /**
223 * This function is automatically called when a GlGraphComposite is removed in this layer
224 * You don't have to call this function
225 */
226 void glGraphCompositeRemoved(GlGraphComposite *composite);
227
228 /**
229 * function used by visitors to visit this layer
230 */
231 void acceptVisitor(GlSceneVisitor *visitor);
232
233 ///@endcond
234
235protected:
236 /**
237 * Set the scene where the layer is
238 */
239 void setScene(GlScene *scene);
240
241private:
242 std::string name;
243
244 GlComposite composite;
245 GlScene *scene;
246
247 Camera *camera;
248 bool sharedCamera;
249
250 bool workingLayer;
251
252 friend class GlScene;
253};
254} // namespace tlp
255
256#endif // Tulip_GLLAYER_H
Tulip OpenGL camera object.
Definition: Camera.h:47
GlSimpleEntity used to aggregate other GlEntity.
Definition: GlComposite.h:39
Class use to visualize graph in OpenGL Tulip engine.
A GlLayer is like an 2D drawing software layer system.
Definition: GlLayer.h:54
void getXML(std::string &outString)
void getXMLOnlyForCameras(std::string &outString)
Get XML description of cameras of the layer and store it in out string.
bool isAWorkingLayer()
Return if this layer is a working layer A working layer is not displayed on overview.
Definition: GlLayer.h:186
Camera & getCamera()
Return the layer's camera.
Definition: GlLayer.h:114
GlComposite * getComposite()
Return the GlComposite used by the layer A GlLayer is only a container of a camera and a composite,...
Definition: GlLayer.h:169
const std::map< std::string, GlSimpleEntity * > & getGlEntities() const
Return the map of layer's entities.
bool useSharedCamera()
Return if this layer use a shared camera A shared camera is a camera used by more than one Layer,...
Definition: GlLayer.h:195
GlScene * getScene()
Return the scene where the layer is.
Definition: GlLayer.h:83
GlSimpleEntity * findGlEntity(const std::string &key)
Return entity with name : key.
GlLayer(const std::string &name, Camera *camera, bool workingLayer=false)
Layer constructor : construct a layer with his name and use the camera : camera You have the responsi...
void addGlEntity(GlSimpleEntity *entity, const std::string &name)
Add an entity to GlComposite of the layer.
void deleteGlEntity(const std::string &key)
Remove entity with name : key This entity is not deleted.
void set2DMode()
Replace the layer's camera with a new 2D one.
void setVisible(bool visible)
Set if the layer is visible.
void deleteGlEntity(GlSimpleEntity *entity)
Remove entity This entity is not deleted.
GlLayer(const std::string &name, bool workingLayer=false)
Layer constructor : construct a layer with his name A new camera is created for this layer and this c...
void setScene(GlScene *scene)
std::string getName()
Return the layer's name.
Definition: GlLayer.h:90
void setSharedCamera(Camera *camera)
bool isVisible()
Return if the layer is visible.
Definition: GlLayer.h:126
void addGraph(tlp::Graph *graph, const std::string &name)
A convenient function that adds a graph to the layer.
void setCamera(Camera *camera)
Set the layer's camera GlLayer now use a copy of the camera parameters.
void clear()
Remove all entities of the layer Entities are not deleted so before call this function you have to ge...
Definition: GlLayer.h:178
~GlLayer()
Destructor.
void setWithXML(const std::string &inString, unsigned int &currentPosition)
Function to set data with inString (in XML format)
Tulip scene class.
Definition: GlScene.h:144
Base class for all Tulip OpenGL entities.