Main MRPT website > C++ reference for MRPT 1.9.9
CMesh3D.cpp
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 
10 #include "opengl-precomp.h" // Precompiled header
11 
12 #include <mrpt/opengl/CMesh3D.h>
13 #include <mrpt/utils/color_maps.h>
14 #include <mrpt/utils/CStream.h>
15 
16 #include "opengl_internals.h"
17 
18 using namespace mrpt;
19 using namespace mrpt::opengl;
20 using namespace mrpt::utils;
21 using namespace mrpt::poses;
22 using namespace mrpt::math;
23 using namespace std;
24 
25 IMPLEMENTS_SERIALIZABLE(CMesh3D, CRenderizableDisplayList, mrpt::opengl)
26 
27 CMesh3D::CMesh3D(
28  bool enableTransparency, bool antiAliasing, bool enableShowEdges,
29  bool enableShowFaces, bool enableShowVertices)
30  : m_enableTransparency(enableTransparency),
31  m_antiAliasing(antiAliasing),
32  m_showEdges(enableShowEdges),
33  m_showFaces(enableShowFaces),
34  m_showVertices(enableShowVertices),
35  m_computeNormals(true),
36  m_lineWidth(2.f),
37  m_pointSize(6.f),
38  m_colorMap(mrpt::utils::cmHOT)
39 {
40  m_color.R = 1.f;
41  m_color.G = 0.f;
42  m_color.B = 0.f;
43  m_color.A = 1.f;
44  edge_color[0] = 0.9f;
45  edge_color[1] = 0.9f;
46  edge_color[2] = 0.9f;
47  edge_color[3] = 1.f;
48  face_color[0] = 0.7f;
49  face_color[1] = 0.7f;
50  face_color[2] = 0.8f;
51  face_color[3] = 1.f;
52  vert_color[0] = 0.3f;
53  vert_color[1] = 0.3f;
54  vert_color[2] = 0.3f;
55  vert_color[3] = 1.f;
56  m_num_faces = 0;
57  m_num_verts = 0;
58 }
59 
60 CMesh3D::~CMesh3D() {}
61 void CMesh3D::loadMesh(
62  unsigned int num_verts, unsigned int num_faces, int* verts_per_face,
63  int* face_verts, float* vert_coords)
64 {
65  m_num_verts = num_verts;
66  m_num_faces = num_faces;
67 
68  // Fill number of vertices for each face
69  m_is_quad = new bool[num_faces];
70  for (unsigned int i = 0; i < num_faces; i++)
71  {
72  if (verts_per_face[i] == 3)
73  m_is_quad[i] = false;
74  else if (verts_per_face[i] == 4)
75  m_is_quad[i] = true;
76  else
77  {
78  printf(
79  "\n Incorrect mesh format. It can only be composed of "
80  "triangles and/or quads.");
81  return;
82  }
83  }
84 
85  // Fill the vertices of each face
86  m_face_verts = new f_verts[num_faces];
87  unsigned int count = 0;
88  for (unsigned int f = 0; f < num_faces; f++)
89  {
90  m_face_verts[f][0] = face_verts[count++];
91  m_face_verts[f][1] = face_verts[count++];
92  m_face_verts[f][2] = face_verts[count++];
93  if (m_is_quad[f])
94  m_face_verts[f][3] = face_verts[count++];
95  else
96  m_face_verts[f][3] = -1; // Meaning it is a triangle
97  }
98 
99  // Fill the 3D coordinates of the vertex
100  m_vert_coords = new coord3D[num_verts];
101  for (unsigned int i = 0; i < num_verts; i++)
102  {
103  m_vert_coords[i][0] = vert_coords[3 * i];
104  m_vert_coords[i][1] = vert_coords[3 * i + 1];
105  m_vert_coords[i][2] = vert_coords[3 * i + 2];
106  }
107 
108  // Compute the mesh normals (if on)
109  if (m_computeNormals)
110  {
111  m_normals = new coord3D[num_faces];
112 
113  for (unsigned int f = 0; f < num_faces; f++)
114  {
115  const unsigned int v1 = m_face_verts[f][0];
116  const unsigned int v2 = m_face_verts[f][1];
117  const unsigned int v3 = m_face_verts[f][2];
118  const unsigned int v4 = m_face_verts[f][3];
119 
120  if (m_is_quad[f])
121  {
122  const float vec1[3] = {
123  m_vert_coords[v3][0] - m_vert_coords[v1][0],
124  m_vert_coords[v3][1] - m_vert_coords[v1][1],
125  m_vert_coords[v3][2] - m_vert_coords[v1][2]};
126  const float vec2[3] = {
127  m_vert_coords[v4][0] - m_vert_coords[v2][0],
128  m_vert_coords[v4][1] - m_vert_coords[v2][1],
129  m_vert_coords[v4][2] - m_vert_coords[v2][2]};
130  m_normals[f][0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
131  m_normals[f][1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
132  m_normals[f][2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
133  }
134  else
135  {
136  const float vec1[3] = {
137  m_vert_coords[v2][0] - m_vert_coords[v1][0],
138  m_vert_coords[v2][1] - m_vert_coords[v1][1],
139  m_vert_coords[v2][2] - m_vert_coords[v1][2]};
140  const float vec2[3] = {
141  m_vert_coords[v3][0] - m_vert_coords[v1][0],
142  m_vert_coords[v3][1] - m_vert_coords[v1][1],
143  m_vert_coords[v3][2] - m_vert_coords[v1][2]};
144  m_normals[f][0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
145  m_normals[f][1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
146  m_normals[f][2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
147  }
148  }
149  }
150 
151  CRenderizableDisplayList::notifyChange();
152 }
153 
154 void CMesh3D::loadMesh(
155  unsigned int num_verts, unsigned int num_faces,
156  const Array<bool, 1, Dynamic>& is_quad,
157  const Array<int, 4, Dynamic>& face_verts,
158  const Array<float, 3, Dynamic>& vert_coords)
159 {
160  m_num_verts = num_verts;
161  m_num_faces = num_faces;
162 
163  // Fill number of vertices for each face
164  m_is_quad = new bool[num_faces];
165  for (unsigned int i = 0; i < num_faces; i++) m_is_quad[i] = is_quad(i);
166 
167  // Fill the vertices of each face
168  m_face_verts = new f_verts[num_faces];
169  for (unsigned int f = 0; f < num_faces; f++)
170  {
171  m_face_verts[f][0] = face_verts(0, f);
172  m_face_verts[f][1] = face_verts(1, f);
173  m_face_verts[f][2] = face_verts(2, f);
174  if (m_is_quad[f])
175  m_face_verts[f][3] = face_verts(3, f);
176  else
177  m_face_verts[f][3] = -1; // Meaning it is a triangle
178  }
179 
180  // Fill the 3D coordinates of the vertex
181  m_vert_coords = new coord3D[num_verts];
182  for (unsigned int i = 0; i < num_verts; i++)
183  {
184  m_vert_coords[i][0] = vert_coords(0, i);
185  m_vert_coords[i][1] = vert_coords(1, i);
186  m_vert_coords[i][2] = vert_coords(2, i);
187  }
188 
189  // Compute the mesh normals (if on)
190  m_normals = new coord3D[num_faces];
191  if (m_computeNormals)
192  for (unsigned int f = 0; f < num_faces; f++)
193  {
194  const unsigned int v1 = m_face_verts[f][0];
195  const unsigned int v2 = m_face_verts[f][1];
196  const unsigned int v3 = m_face_verts[f][2];
197  const unsigned int v4 = m_face_verts[f][3];
198 
199  if (m_is_quad[f])
200  {
201  const float vec1[3] = {
202  m_vert_coords[v3][0] - m_vert_coords[v1][0],
203  m_vert_coords[v3][1] - m_vert_coords[v1][1],
204  m_vert_coords[v3][2] - m_vert_coords[v1][2]};
205  const float vec2[3] = {
206  m_vert_coords[v4][0] - m_vert_coords[v2][0],
207  m_vert_coords[v4][1] - m_vert_coords[v2][1],
208  m_vert_coords[v4][2] - m_vert_coords[v2][2]};
209  m_normals[f][0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
210  m_normals[f][1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
211  m_normals[f][2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
212  }
213  else
214  {
215  const float vec1[3] = {
216  m_vert_coords[v2][0] - m_vert_coords[v1][0],
217  m_vert_coords[v2][1] - m_vert_coords[v1][1],
218  m_vert_coords[v2][2] - m_vert_coords[v1][2]};
219  const float vec2[3] = {
220  m_vert_coords[v3][0] - m_vert_coords[v1][0],
221  m_vert_coords[v3][1] - m_vert_coords[v1][1],
222  m_vert_coords[v3][2] - m_vert_coords[v1][2]};
223  m_normals[f][0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
224  m_normals[f][1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
225  m_normals[f][2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
226  }
227  }
228 
229  CRenderizableDisplayList::notifyChange();
230 }
231 
232 /*---------------------------------------------------------------
233  render
234  ---------------------------------------------------------------*/
235 void CMesh3D::render_dl() const
236 {
237 #if MRPT_HAS_OPENGL_GLUT
238 
239  if (m_enableTransparency || m_antiAliasing)
240  {
241  glEnable(GL_BLEND);
242  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
243  }
244  else
245  {
246  glEnable(GL_DEPTH_TEST);
247  glDisable(GL_BLEND);
248  }
249 
250  glEnable(GL_NORMALIZE); // So the GPU normalizes the normals instead of
251  // doing it in the CPU
252  glEnable(GL_COLOR_MATERIAL);
253  glShadeModel(GL_SMOOTH);
254 
255  if (m_num_verts == 0) return;
256 
257  //---------------------------------------------------------------------------------------------------------
258  // Rendering - Test whether changing the rendering mode
259  // continuously
260  // is
261  // very slow (or not)
262  //---------------------------------------------------------------------------------------------------------
263 
264  // Render the faces
265  if (m_showFaces)
266  {
267  glColor4f(face_color[0], face_color[1], face_color[2], face_color[3]);
268 
269  for (unsigned int f = 0; f < m_num_faces; f++)
270  {
271  // Assign normals to faces (if on)
272  if (m_computeNormals)
273  glNormal3f(m_normals[f][0], m_normals[f][1], m_normals[f][2]);
274 
275  // Render Quads
276  if (m_is_quad[f])
277  {
278  glBegin(GL_QUADS);
279  for (int i = 0; i < 4; i++)
280  {
281  const unsigned int vert_ind = m_face_verts[f][i];
282  glVertex3f(
283  m_vert_coords[vert_ind][0], m_vert_coords[vert_ind][1],
284  m_vert_coords[vert_ind][2]);
285  }
286  glEnd();
287  }
288  // Render Triangles
289  else
290  {
291  glBegin(GL_TRIANGLES);
292  for (int i = 0; i < 3; i++)
293  {
294  const unsigned int vert_ind = m_face_verts[f][i];
295  glVertex3f(
296  m_vert_coords[vert_ind][0], m_vert_coords[vert_ind][1],
297  m_vert_coords[vert_ind][2]);
298  }
299  glEnd();
300  }
301  }
302  }
303 
304  // Render the edges - They are rendered twice, which is redundant but simple
305  if (m_showEdges)
306  {
307  glColor4f(edge_color[0], edge_color[1], edge_color[2], edge_color[3]);
308  glDisable(GL_LIGHTING); //??
309  glLineWidth(m_lineWidth);
310  glEnable(GL_LINE_SMOOTH);
311  glBegin(GL_LINES);
312  for (unsigned int f = 0; f < m_num_faces; f++)
313  {
314  const unsigned char num_vert = 3 + m_is_quad[f];
315  for (int i = 0; i < num_vert - 1; i++)
316  {
317  const unsigned int v_0 = m_face_verts[f][i];
318  const unsigned int v_1 = m_face_verts[f][i + 1];
319 
320  glVertex3f(
321  m_vert_coords[v_0][0], m_vert_coords[v_0][1],
322  m_vert_coords[v_0][2]);
323  glVertex3f(
324  m_vert_coords[v_1][0], m_vert_coords[v_1][1],
325  m_vert_coords[v_1][2]);
326  }
327 
328  // The last vertex of the face needs to be connected to the first as
329  // well
330  const int v_0 = m_face_verts[f][num_vert - 1];
331  const int v_1 = m_face_verts[f][0];
332 
333  glVertex3f(
334  m_vert_coords[v_0][0], m_vert_coords[v_0][1],
335  m_vert_coords[v_0][2]);
336  glVertex3f(
337  m_vert_coords[v_1][0], m_vert_coords[v_1][1],
338  m_vert_coords[v_1][2]);
339  }
340  glEnd();
341  glEnable(GL_LIGHTING);
342  glDisable(GL_LINE_SMOOTH);
343  }
344 
345  // Render the vertices
346  if (m_showVertices)
347  {
348  glColor4f(vert_color[0], vert_color[1], vert_color[2], vert_color[3]);
349  glDisable(GL_LIGHTING);
350  glPointSize(m_pointSize);
351  glEnable(GL_POINT_SMOOTH);
352  glBegin(GL_POINTS);
353  for (unsigned int v = 0; v < m_num_verts; v++)
354  glVertex3f(
355  m_vert_coords[v][0], m_vert_coords[v][1], m_vert_coords[v][2]);
356 
357  glEnd();
358  glEnable(GL_LIGHTING);
359  glDisable(GL_POINT_SMOOTH);
360  }
361 
362  glDisable(GL_BLEND);
363  glDisable(GL_NORMALIZE);
364 
365 #endif
366 }
367 
368 /*---------------------------------------------------------------
369  Implements the writing to a CStream capability of
370  CSerializable objects
371  ---------------------------------------------------------------*/
372 void CMesh3D::writeToStream(mrpt::utils::CStream& out, int* version) const
373 {
374  //********** To do **********
375  THROW_EXCEPTION("not implemented yet!")
376 
377  // if (version)
378  // *version = 0;
379  // else
380  //{
381  // writeToStreamRender(out);
382 
383  // // Version 0:
384  // out << m_enableTransparency;
385  // out << m_showEdges;
386  // out << m_showFaces;
387  // out << m_showVertices;
388  // out << m_computeNormals;
389  // out << m_num_verts;
390  // out << m_num_faces;
391 
392  // bool *m_is_quad;
393  // f_verts *m_face_verts;
394  // coord3D *m_vert_coords;
395  // coord3D *m_normals;
396  //}
397 }
398 
399 /*---------------------------------------------------------------
400  Implements the reading from a CStream capability of
401  CSerializable objects
402  ---------------------------------------------------------------*/
403 void CMesh3D::readFromStream(mrpt::utils::CStream& in, int version)
404 {
405  //********** To do ************
406 
407  // switch(version)
408  //{
409  // case 0:
410  // {
411  // readFromStreamRender(in);
412 
413  // in >> m_enableTransparency;
414  // in >> m_showEdges;
415  // in >> m_showFaces;
416  // in >> m_showVertices;
417  // in >> m_computeNormals;
418  // in >> m_num_verts;
419  // in >> m_num_faces;
420 
421  // bool *m_is_quad;
422  // f_verts *m_face_verts;
423  // coord3D *m_vert_coords;
424  // coord3D *m_normals;
425  // }
426  // break;
427  // default:
428  // MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
429 
430  //};
431  // CRenderizableDisplayList::notifyChange();
432 }
433 
434 void CMesh3D::getBoundingBox(
435  mrpt::math::TPoint3D& bb_min, mrpt::math::TPoint3D& bb_max) const
436 {
437  // Extreme initialization
438  bb_min.x = 10000.f;
439  bb_min.y = 10000.f;
440  bb_min.z = 10000.f;
441  bb_max.x = -10000.f;
442  bb_max.y = -10000.f;
443  bb_max.z = -10000.f;
444 
445  if (m_num_verts == 0)
446  printf(
447  "\n The mesh is empty and has no size. The returned information "
448  "has no meaning.");
449  else
450  {
451  for (unsigned int i = 0; i < m_num_verts; i++)
452  {
453  // Max
454  if (m_vert_coords[i][0] > bb_max.x) bb_max.x = m_vert_coords[i][0];
455  if (m_vert_coords[i][1] > bb_max.y) bb_max.y = m_vert_coords[i][1];
456  if (m_vert_coords[i][2] > bb_max.z) bb_max.z = m_vert_coords[i][2];
457 
458  // Min
459  if (m_vert_coords[i][0] < bb_min.x) bb_min.x = m_vert_coords[i][0];
460  if (m_vert_coords[i][1] < bb_min.y) bb_min.y = m_vert_coords[i][1];
461  if (m_vert_coords[i][2] < bb_min.z) bb_min.z = m_vert_coords[i][2];
462  }
463  }
464 
465  // Convert to coordinates of my parent:
466  m_pose.composePoint(bb_min, bb_min);
467  m_pose.composePoint(bb_max, bb_max);
468 }
469 
470 void CMesh3D::setEdgeColor(float r, float g, float b, float a)
471 {
472  edge_color[0] = r;
473  edge_color[1] = g;
474  edge_color[2] = b;
475  edge_color[3] = a;
476 }
477 
478 void CMesh3D::setFaceColor(float r, float g, float b, float a)
479 {
480  face_color[0] = r;
481  face_color[1] = g;
482  face_color[2] = b;
483  face_color[3] = a;
484 }
485 
486 void CMesh3D::setVertColor(float r, float g, float b, float a)
487 {
488  vert_color[0] = r;
489  vert_color[1] = g;
490  vert_color[2] = b;
491  vert_color[3] = a;
492 }
mrpt::opengl::CMesh3D::readFromStream
void readFromStream(mrpt::utils::CStream &in, int version) override
Introduces a pure virtual method responsible for loading from a CStream This can not be used directly...
Definition: CMesh3D.cpp:403
count
GLuint GLuint GLsizei count
Definition: glext.h:3528
mrpt::utils
Classes for serialization, sockets, ini-file manipulation, streams, list of properties-values, timewatch, extensions to STL.
Definition: CParticleFilter.h:223
glEnable
GLAPI void GLAPIENTRY glEnable(GLenum cap)
glPointSize
GLAPI void GLAPIENTRY glPointSize(GLfloat size)
mrpt::opengl::CMesh3D::render_dl
void render_dl() const override
Render.
Definition: CMesh3D.cpp:235
mrpt::utils::cmHOT
[New in MRPT 1.5.0]
Definition: color_maps.h:36
IMPLEMENTS_SERIALIZABLE
#define IMPLEMENTS_SERIALIZABLE(class_name, base, NameSpace)
This must be inserted in all CSerializable classes implementation files.
Definition: CSerializable.h:169
THROW_EXCEPTION
#define THROW_EXCEPTION(msg)
Definition: CColouredPointsMap.h:112
glNormal3f
GLAPI void GLAPIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
GL_TRIANGLES
#define GL_TRIANGLES
Definition: glew.h:276
mrpt::opengl::CRenderizableDisplayList::notifyChange
EIGEN_STRONG_INLINE void notifyChange() const
Must be called to notify that the object has changed (so, the display list must be updated) ...
Definition: CRenderizableDisplayList.h:57
std
STL namespace.
GL_NORMALIZE
#define GL_NORMALIZE
Definition: glew.h:416
GL_ONE_MINUS_SRC_ALPHA
#define GL_ONE_MINUS_SRC_ALPHA
Definition: glew.h:287
GL_COLOR_MATERIAL
#define GL_COLOR_MATERIAL
Definition: glew.h:392
GL_DEPTH_TEST
#define GL_DEPTH_TEST
Definition: glew.h:401
GL_SMOOTH
#define GL_SMOOTH
Definition: glew.h:635
mrpt::opengl::CMesh3D
A 3D mesh composed of Triangles and/or Quads.
Definition: CMesh3D.h:38
glShadeModel
GLAPI void GLAPIENTRY glShadeModel(GLenum mode)
GL_LIGHTING
#define GL_LIGHTING
Definition: glew.h:385
glLineWidth
GLAPI void GLAPIENTRY glLineWidth(GLfloat width)
glBlendFunc
GLAPI void GLAPIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)
CStream.h
mrpt::opengl::CRenderizableDisplayList
A renderizable object suitable for rendering with OpenGL&#39;s display lists.
Definition: CRenderizableDisplayList.h:39
mrpt::utils::CStream
This base class is used to provide a unified interface to files,memory buffers,..Please see the deriv...
Definition: CStream.h:41
mrpt::opengl::CMesh3D::setVertColor
void setVertColor(float r, float g, float b, float a=1.f)
Definition: CMesh3D.cpp:486
mrpt::math
This base provides a set of functions for maths stuff.
Definition: CArrayNumeric.h:19
mrpt::opengl::CMesh3D::writeToStream
void writeToStream(mrpt::utils::CStream &out, int *getVersion) const override
Introduces a pure virtual method responsible for writing to a CStream.
Definition: CMesh3D.cpp:372
GL_LINE_SMOOTH
#define GL_LINE_SMOOTH
Definition: glew.h:367
GL_QUADS
#define GL_QUADS
Definition: glew.h:279
color_maps.h
v3
GLfloat GLfloat GLfloat GLfloat v3
Definition: glext.h:4109
g
GLubyte g
Definition: glext.h:6279
b
GLubyte GLubyte b
Definition: glext.h:6279
CMesh3D.h
mrpt::math::TPoint3D::x
double x
X,Y,Z coordinates.
Definition: lightweight_geom_data.h:388
GL_POINT_SMOOTH
#define GL_POINT_SMOOTH
Definition: glew.h:363
glBegin
GLAPI void GLAPIENTRY glBegin(GLenum mode)
mrpt::opengl::CMesh3D::loadMesh
void loadMesh(unsigned int num_verts, unsigned int num_faces, int *verts_per_face, int *face_verts, float *vert_coords)
Load a 3D mesh.
Definition: CMesh3D.cpp:61
GL_BLEND
#define GL_BLEND
Definition: glew.h:432
GL_POINTS
#define GL_POINTS
Definition: glew.h:272
mrpt::poses
Classes for 2D/3D geometry representation, both of single values and probability density distribution...
Definition: CPoint.h:17
glVertex3f
GLAPI void GLAPIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z)
mrpt::opengl::CMesh3D::setFaceColor
void setFaceColor(float r, float g, float b, float a=1.f)
Definition: CMesh3D.cpp:478
GL_SRC_ALPHA
#define GL_SRC_ALPHA
Definition: glew.h:286
v
const GLdouble * v
Definition: glext.h:3678
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: CParticleFilter.h:17
r
GLdouble GLdouble GLdouble r
Definition: glext.h:3705
v1
GLfloat GLfloat v1
Definition: glext.h:4105
mrpt::opengl::CMesh3D::~CMesh3D
virtual ~CMesh3D()
Private, virtual destructor: only can be deleted from smart pointers.
Definition: CMesh3D.cpp:60
in
GLuint in
Definition: glext.h:7274
mrpt::opengl
The namespace for 3D scene representation and rendering.
Definition: CGlCanvasBase.h:15
glEnd
GLAPI void GLAPIENTRY glEnd(void)
opengl_internals.h
v2
GLfloat GLfloat GLfloat v2
Definition: glext.h:4107
GL_LINES
#define GL_LINES
Definition: glew.h:273
glColor4f
GLAPI void GLAPIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
mrpt::math::TPoint3D
Lightweight 3D point.
Definition: lightweight_geom_data.h:381
mrpt::opengl::CMesh3D::setEdgeColor
void setEdgeColor(float r, float g, float b, float a=1.f)
Definition: CMesh3D.cpp:470
glDisable
GLAPI void GLAPIENTRY glDisable(GLenum cap)
mrpt::opengl::CMesh3D::getBoundingBox
void getBoundingBox(mrpt::math::TPoint3D &bb_min, mrpt::math::TPoint3D &bb_max) const override
Evaluates the bounding box of this object (including possible children) in the coordinate frame of th...
Definition: CMesh3D.cpp:434
a
GLubyte GLubyte GLubyte a
Definition: glext.h:6279


Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: ae4571287 Thu Nov 23 00:06:53 2017 +0100 at dom oct 27 23:51:55 CET 2019