Main MRPT website > C++ reference for MRPT 1.5.6
CRenderizable.h
Go to the documentation of this file.
1 /* +---------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +---------------------------------------------------------------------------+ */
9 #ifndef opengl_CRenderizable_H
10 #define opengl_CRenderizable_H
11 
13 #include <mrpt/utils/TColor.h>
14 #include <mrpt/math/math_frwds.h>
15 #include <mrpt/poses/CPose3D.h>
19 #include <deque>
20 
21 namespace mrpt
22 {
23  namespace opengl
24  {
25  class COpenGLViewport;
26  class CSetOfObjects;
27 
28 
29  // This must be added to any CSerializable derived class:
31 
32  /** A list of objects pointers, automatically managing memory free at destructor, and managing copies correctly. */
33  typedef std::deque<CRenderizablePtr> CListOpenGLObjects;
34 
35  /** The base class of 3D objects that can be directly rendered through OpenGL.
36  * In this class there are a set of common properties to all 3D objects, mainly:
37  * - A name (m_name): A name that can be optionally asigned to objects for easing its reference.
38  * - 6D coordinates (x,y,z,yaw,pitch,roll), relative to the "current" reference framework. By default, any object is referenced to global scene coordinates.
39  * - A RGB color: This field will be used in simple elements (points, lines, text,...) but is ignored in more complex objects that carry their own color information (triangle sets,...)
40  * See the main class opengl::COpenGLScene
41  * \sa opengl::COpenGLScene, mrpt::opengl
42  * \ingroup mrpt_opengl_grp
43  */
44  class OPENGL_IMPEXP CRenderizable : public mrpt::utils::CSerializable
45  {
47 
48  friend class mrpt::opengl::COpenGLViewport;
49  friend class mrpt::opengl::CSetOfObjects;
50 
51  protected:
52  std::string m_name;
53  bool m_show_name;
54  mrpt::utils::TColor m_color; //!< Color components in the range [0,255]
55  mrpt::poses::CPose3D m_pose; //!< 6D pose wrt the parent coordinate reference. This class automatically holds the cached 3x3 rotation matrix for quick load into opengl stack.
56  float m_scale_x, m_scale_y, m_scale_z; //!< Scale components to apply to the object (default=1)
57  bool m_visible; //!< Is the object visible? (default=true)
58 
59  public:
60  /** @name Changes the appearance of the object to render
61  @{ */
62 
63  void setName(const std::string &n) { m_name=n; } //!< Changes the name of the object
64  const std::string &getName() const { return m_name; } //!< Returns the name of the object
65 
66  inline bool isVisible() const /** Is the object visible? \sa setVisibility */ { return m_visible; }
67  inline void setVisibility(bool visible=true) /** Set object visibility (default=true) \sa isVisible */ { m_visible=visible; }
68 
69  inline void enableShowName(bool showName=true) { m_show_name=showName; } //!< Enables or disables showing the name of the object as a label when rendering
70  inline bool isShowNameEnabled() const { return m_show_name; } //!< \sa enableShowName
71 
72  CRenderizable& setPose( const mrpt::poses::CPose3D &o ); //!< Set the 3D pose from a mrpt::poses::CPose3D object (return a ref to this)
73  CRenderizable& setPose( const mrpt::poses::CPose2D &o ); //!< Set the 3D pose from a mrpt::poses::CPose3D object (return a ref to this)
74  CRenderizable& setPose( const mrpt::math::TPose3D &o ); //!< Set the 3D pose from a mrpt::math::TPose3D object (return a ref to this)
75  CRenderizable& setPose( const mrpt::math::TPose2D &o ); //!< Set the 3D pose from a mrpt::math::TPose3D object (return a ref to this)
76  CRenderizable& setPose( const mrpt::poses::CPoint3D &o ); //!< Set the 3D pose from a mrpt::poses::CPose3D object (return a ref to this)
77  CRenderizable& setPose( const mrpt::poses::CPoint2D &o ); //!< Set the 3D pose from a mrpt::poses::CPose3D object (return a ref to this)
78 
79  mrpt::math::TPose3D getPose() const; //!< Returns the 3D pose of the object as TPose3D
80  /** Returns a const ref to the 3D pose of the object as mrpt::poses::CPose3D (which explicitly contains the 3x3 rotation matrix) */
81  inline const mrpt::poses::CPose3D & getPoseRef() const { return m_pose; }
82 
83  /** Changes the location of the object, keeping untouched the orientation \return a ref to this */
84  inline CRenderizable& setLocation(double x,double y,double z) { m_pose.x(x); m_pose.y(y); m_pose.z(z); return *this; }
85 
86  /** Changes the location of the object, keeping untouched the orientation \return a ref to this */
87  inline CRenderizable& setLocation(const mrpt::math::TPoint3D &p ) { m_pose.x(p.x); m_pose.y(p.y); m_pose.z(p.z); return *this; }
88 
89  inline double getPoseX() const { return m_pose.x(); } //!< Translation relative to parent coordinate origin.
90  inline double getPoseY() const { return m_pose.y(); } //!< Translation relative to parent coordinate origin.
91  inline double getPoseZ() const { return m_pose.z(); } //!< Translation relative to parent coordinate origin.
92  inline double getPoseYaw() const { return mrpt::utils::RAD2DEG(m_pose.yaw()); } //!< Rotation relative to parent coordinate origin, in **DEGREES**.
93  inline double getPosePitch() const { return mrpt::utils::RAD2DEG(m_pose.pitch()); } //!< Rotation relative to parent coordinate origin, in **DEGREES**.
94  inline double getPoseRoll() const { return mrpt::utils::RAD2DEG(m_pose.roll()); } //!< Rotation relative to parent coordinate origin, in **DEGREES**.
95  inline double getPoseYawRad() const { return m_pose.yaw(); } //!< Rotation relative to parent coordinate origin, in radians.
96  inline double getPosePitchRad() const { return m_pose.pitch(); } //!< Rotation relative to parent coordinate origin, in radians.
97  inline double getPoseRollRad() const { return m_pose.roll(); } //!< Rotation relative to parent coordinate origin, in radians.
98 
99  inline double getColorR() const { return m_color.R/255.; } //!< Color components in the range [0,1]
100  inline double getColorG() const { return m_color.G/255.; } //!< Color components in the range [0,1]
101  inline double getColorB() const { return m_color.B/255.; } //!< Color components in the range [0,1]
102  inline double getColorA() const { return m_color.A/255.; } //!< Color components in the range [0,1]
103 
104  inline uint8_t getColorR_u8() const { return m_color.R; } //!< Color components in the range [0,255]
105  inline uint8_t getColorG_u8() const { return m_color.G; } //!< Color components in the range [0,255]
106  inline uint8_t getColorB_u8() const { return m_color.B; } //!< Color components in the range [0,255]
107  inline uint8_t getColorA_u8() const { return m_color.A; } //!< Color components in the range [0,255]
108 
109  CRenderizable& setColorR(const double r) {return setColorR_u8(static_cast<uint8_t>(255*r));} //!<Color components in the range [0,1] \return a ref to this
110  CRenderizable& setColorG(const double g) {return setColorG_u8(static_cast<uint8_t>(255*g));} //!<Color components in the range [0,1] \return a ref to this
111  CRenderizable& setColorB(const double b) {return setColorB_u8(static_cast<uint8_t>(255*b));} //!<Color components in the range [0,1] \return a ref to this
112  CRenderizable& setColorA(const double a) {return setColorA_u8(static_cast<uint8_t>(255*a));} //!<Color components in the range [0,1] \return a ref to this
113 
114  virtual CRenderizable& setColorR_u8(const uint8_t r) {m_color.R=r; return *this;} //!<Color components in the range [0,255] \return a ref to this
115  virtual CRenderizable& setColorG_u8(const uint8_t g) {m_color.G=g; return *this;} //!<Color components in the range [0,255] \return a ref to this
116  virtual CRenderizable& setColorB_u8(const uint8_t b) {m_color.B=b; return *this;} //!<Color components in the range [0,255] \return a ref to this
117  virtual CRenderizable& setColorA_u8(const uint8_t a) {m_color.A=a; return *this;} //!<Color components in the range [0,255] \return a ref to this
118 
119  inline CRenderizable& setScale(float s) { m_scale_x=m_scale_y=m_scale_z = s; return *this; } //!< Scale to apply to the object, in all three axes (default=1) \return a ref to this
120  inline CRenderizable& setScale(float sx,float sy,float sz) { m_scale_x=sx; m_scale_y=sy; m_scale_z = sz; return *this; } //!< Scale to apply to the object in each axis (default=1) \return a ref to this
121  inline float getScaleX() const { return m_scale_x; } //!< Get the current scaling factor in one axis
122  inline float getScaleY() const { return m_scale_y; } //!< Get the current scaling factor in one axis
123  inline float getScaleZ() const { return m_scale_z; } //!< Get the current scaling factor in one axis
124 
125 
126  inline mrpt::utils::TColorf getColor() const { return mrpt::utils::TColorf(m_color); } //!< Returns the object color property as a TColorf
127  CRenderizable& setColor( const mrpt::utils::TColorf &c) //!< Changes the default object color \return a ref to this
128  {
129  return setColor_u8(mrpt::utils::TColor(c.R*255.f,c.G*255.f,c.B*255.f,c.A*255.f));
130  }
131 
132  /** Set the color components of this object (R,G,B,Alpha, in the range 0-1) \return a ref to this */
133  inline CRenderizable& setColor( double R, double G, double B, double A=1) { return setColor_u8(R*255,G*255,B*255,A*255); }
134 
135  inline const mrpt::utils::TColor &getColor_u8() const { return m_color; } //!< Returns the object color property as a TColor
136  /*** Changes the default object color \return a ref to this */
137  virtual CRenderizable& setColor_u8( const mrpt::utils::TColor &c);
138 
139  /** Set the color components of this object (R,G,B,Alpha, in the range 0-255) \return a ref to this */
141 
142  /** @} */
143 
144 
145  /** Default constructor: */
146  CRenderizable();
147  virtual ~CRenderizable();
148 
149  /** Interface for the stlplus smart pointer class. */
150  inline CRenderizable * clone() const
151  {
152  return static_cast<CRenderizable*>( this->duplicate() );
153  }
154 
155  /** Implements the rendering of 3D objects in each class derived from CRenderizable.
156  */
157  virtual void render() const = 0;
158 
159  /** Simulation of ray-trace, given a pose. Returns true if the ray effectively collisions with the object (returning the distance to the origin of the ray in "dist"), or false in other case. "dist" variable yields undefined behaviour when false is returned
160  */
161  virtual bool traceRay(const mrpt::poses::CPose3D &o,double &dist) const;
162 
163 
164  /** This method is safe for calling from within ::render() methods \sa renderTextBitmap, mrpt::opengl::gl_utils */
165  static void renderTextBitmap( const char *str, void *fontStyle );
166 
167  /** Return the exact width in pixels for a given string, as will be rendered by renderTextBitmap().
168  * \sa renderTextBitmap, mrpt::opengl::gl_utils
169  */
170  static int textBitmapWidth(
171  const std::string &str,
173 
174  /** Render a text message in the current rendering context, creating a glViewport in the way (do not call within ::render() methods)
175  * - Coordinates (x,y) are 2D pixels, starting at bottom-left of the viewport. Negative numbers will wrap to the opposite side of the viewport (e.g. x=-10 means 10px fromt the right).
176  * - The text color is defined by (color_r,color_g,color_b), each float numbers in the range [0,1].
177  * \sa renderTextBitmap, textBitmapWidth, mrpt::opengl::gl_utils
178  */
179  static void renderTextBitmap(
180  int screen_x,
181  int screen_y,
182  const std::string &str,
183  float color_r=1,
184  float color_g=1,
185  float color_b=1,
187  );
188 
189  /** Evaluates the bounding box of this object (including possible children) in the coordinate frame of the object parent. */
190  virtual void getBoundingBox(mrpt::math::TPoint3D &bb_min, mrpt::math::TPoint3D &bb_max) const = 0;
191 
192  protected:
193  /** Checks glGetError and throws an exception if an error situation is found */
194  static void checkOpenGLError();
195 
196  void writeToStreamRender(utils::CStream &out) const;
197  void readFromStreamRender(utils::CStream &in);
198 
199  /** Returns the lowest next free texture name (avoid using OpenGL's own function since we may call them from different threads and seem it's not cool). */
200  static unsigned int getNewTextureNumber();
201  static void releaseTextureName(unsigned int i);
202 
203  };
205 
206  /** Applies a mrpt::poses::CPose3D transformation to the object. Note that this method doesn't <i>set</i> the pose to the given value, but <i>combines</i> it with the existing one.
207  * \sa setPose */
208  OPENGL_IMPEXP CRenderizablePtr & operator<<(CRenderizablePtr &r,const mrpt::poses::CPose3D &p);
209 
210  } // end namespace
211 
212 } // End of namespace
213 
214 // This header goes here so there we can use "CRenderizablePtr"
215 //#include <mrpt/opengl/gl_utils.h>
216 
217 
218 #endif
void OPENGL_IMPEXP renderTextBitmap(const char *str, void *fontStyle)
This method is safe for calling from within ::render() methods.
Definition: gl_utils.cpp:238
GLboolean GLboolean GLboolean GLboolean a
Definition: glew.h:5406
GLint GLint GLint GLint GLint GLint y
Definition: glew.h:1166
double getColorG() const
Color components in the range [0,1].
CRenderizable & setColorB(const double b)
Color components in the range [0,1].
A set of object, which are referenced to the coordinates framework established in this object...
Definition: CSetOfObjects.h:32
GLboolean GLboolean g
Definition: glew.h:5406
The virtual base class which provides a unified interface for all persistent objects in MRPT...
Definition: CSerializable.h:39
virtual CRenderizable & setColorA_u8(const uint8_t a)
Color components in the range [0,255].
double getPoseRollRad() const
Rotation relative to parent coordinate origin, in radians.
Definition: CRenderizable.h:97
bool BASE_IMPEXP traceRay(const std::vector< TPolygonWithPlane > &vec, const mrpt::poses::CPose3D &pose, double &dist)
Fast ray tracing method using polygons' properties.
Definition: geometry.cpp:1996
CRenderizable & setLocation(const mrpt::math::TPoint3D &p)
Changes the location of the object, keeping untouched the orientation.
Definition: CRenderizable.h:87
const GLfloat * c
Definition: glew.h:10088
The base class of 3D objects that can be directly rendered through OpenGL.
Definition: CRenderizable.h:44
double getPoseX() const
Translation relative to parent coordinate origin.
Definition: CRenderizable.h:89
bool isShowNameEnabled() const
Definition: CRenderizable.h:70
CRenderizable & setLocation(double x, double y, double z)
Changes the location of the object, keeping untouched the orientation.
Definition: CRenderizable.h:84
std::deque< CRenderizablePtr > CListOpenGLObjects
A list of objects pointers, automatically managing memory free at destructor, and managing copies cor...
Definition: CRenderizable.h:33
virtual CRenderizable & setColorR_u8(const uint8_t r)
Color components in the range [0,255].
CRenderizable & setColor(const mrpt::utils::TColorf &c)
void enableShowName(bool showName=true)
Enables or disables showing the name of the object as a label when rendering.
Definition: CRenderizable.h:69
double getPoseRoll() const
Rotation relative to parent coordinate origin, in DEGREES.
Definition: CRenderizable.h:94
double z
X,Y,Z coordinates.
CRenderizable & setColorA(const double a)
Color components in the range [0,1].
double getPoseYawRad() const
Rotation relative to parent coordinate origin, in radians.
Definition: CRenderizable.h:95
A viewport within a COpenGLScene, containing a set of OpenGL objects to render.
GLuint in
Definition: glew.h:7146
CRenderizable & setColorR(const double r)
Color components in the range [0,1].
mrpt::utils::TColorf getColor() const
Returns the object color property as a TColorf.
#define DEFINE_VIRTUAL_SERIALIZABLE(class_name)
This declaration must be inserted in virtual CSerializable classes definition:
unsigned char uint8_t
Definition: rptypes.h:43
GLdouble s
Definition: glew.h:1295
This base class is used to provide a unified interface to files,memory buffers,..Please see the deriv...
Definition: CStream.h:38
virtual CRenderizable & setColorB_u8(const uint8_t b)
Color components in the range [0,255].
#define DEFINE_SERIALIZABLE_PRE_CUSTOM_BASE_LINKAGE(class_name, base_name, _LINKAGE_)
This declaration must be inserted in all CSerializable classes definition, before the class declarati...
double RAD2DEG(const double x)
Radians to degrees.
TOpenGLFont
Existing fonts for 2D texts in mrpt::opengl methods.
Definition: opengl_fonts.h:26
GLsizei n
Definition: glew.h:5051
CRenderizable & setColor_u8(uint8_t R, uint8_t G, uint8_t B, uint8_t A=255)
Set the color components of this object (R,G,B,Alpha, in the range 0-255)
virtual CRenderizable & setColorG_u8(const uint8_t g)
Color components in the range [0,255].
bool isVisible() const
Is the object visible?
Definition: CRenderizable.h:66
double getColorB() const
Color components in the range [0,1].
CRenderizable & setScale(float sx, float sy, float sz)
Scale to apply to the object in each axis (default=1)
GLint GLint GLint GLint GLint x
Definition: glew.h:1166
A RGB color - 8bit.
Definition: TColor.h:26
CRenderizable & setScale(float s)
Scale to apply to the object, in all three axes (default=1)
CRenderizable & setColor(double R, double G, double B, double A=1)
Set the color components of this object (R,G,B,Alpha, in the range 0-1)
float getScaleZ() const
Get the current scaling factor in one axis.
GLfloat GLfloat p
Definition: glew.h:10113
double getPoseYaw() const
Rotation relative to parent coordinate origin, in DEGREES.
Definition: CRenderizable.h:92
A class used to store a 2D point.
Definition: CPoint2D.h:36
A class used to store a 3D point.
Definition: CPoint3D.h:32
const mrpt::utils::TColor & getColor_u8() const
Returns the object color property as a TColor.
double getPosePitch() const
Rotation relative to parent coordinate origin, in DEGREES.
Definition: CRenderizable.h:93
double getColorA() const
Color components in the range [0,1].
double getPosePitchRad() const
Rotation relative to parent coordinate origin, in radians.
Definition: CRenderizable.h:96
GLdouble GLdouble z
Definition: glew.h:1464
GLsizei const GLcharARB ** string
Definition: glew.h:3293
void setVisibility(bool visible=true)
Set object visibility (default=true)
Definition: CRenderizable.h:67
double getPoseY() const
Translation relative to parent coordinate origin.
Definition: CRenderizable.h:90
const std::string & getName() const
Returns the name of the object.
Definition: CRenderizable.h:64
A class used to store a 2D pose, including the 2D coordinate point and a heading (phi) angle...
Definition: CPose2D.h:36
const float R
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
Definition: CPose3D.h:72
int OPENGL_IMPEXP textBitmapWidth(const std::string &str, mrpt::opengl::TOpenGLFont font=mrpt::opengl::MRPT_GLUT_BITMAP_TIMES_ROMAN_24)
Return the exact width in pixels for a given string, as will be rendered by renderTextBitmap().
Definition: gl_utils.cpp:270
double getColorR() const
Color components in the range [0,1].
Definition: CRenderizable.h:99
const mrpt::poses::CPose3D & getPoseRef() const
Returns a const ref to the 3D pose of the object as mrpt::poses::CPose3D (which explicitly contains t...
Definition: CRenderizable.h:81
void OPENGL_IMPEXP checkOpenGLError()
Checks glGetError and throws an exception if an error situation is found.
Definition: gl_utils.cpp:134
Lightweight 3D pose (three spatial coordinates, plus three angular coordinates).
Lightweight 2D pose.
CRenderizable & setColorG(const double g)
Color components in the range [0,1].
GLdouble GLdouble GLdouble r
Definition: glew.h:1311
A RGB color - floats in the range [0,1].
Definition: TColor.h:80
uint8_t getColorG_u8() const
Color components in the range [0,255].
uint8_t getColorA_u8() const
Color components in the range [0,255].
float getScaleX() const
Get the current scaling factor in one axis.
GLdouble GLdouble GLdouble b
Definition: glew.h:5092
Lightweight 3D point.
#define DEFINE_SERIALIZABLE_POST_CUSTOM_BASE_LINKAGE(class_name, base_name, _LINKAGE_)
float getScaleY() const
Get the current scaling factor in one axis.
CRenderizable * clone() const
Interface for the stlplus smart pointer class.
uint8_t getColorB_u8() const
Color components in the range [0,255].
uint8_t getColorR_u8() const
Color components in the range [0,255].
double getPoseZ() const
Translation relative to parent coordinate origin.
Definition: CRenderizable.h:91



Page generated by Doxygen 1.8.6 for MRPT 1.5.6 Git: 4c65e84 Tue Apr 24 08:18:17 2018 +0200 at mar abr 24 08:26:17 CEST 2018