movable_text.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2008, Willow Garage, Inc.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *
8  * * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * * Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * * Neither the name of the Willow Garage, Inc. nor the names of its
14  * contributors may be used to endorse or promote products derived from
15  * this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27  * POSSIBILITY OF SUCH DAMAGE.
28  */
29 
30 // Adapted from: http://www.ogre3d.org/wiki/index.php/MovableText
31 // now: http://www.ogre3d.org/tikiwiki/tiki-index.php?page=MovableText
32 // Original authors:
33 /*
34  * File: MovableText.cpp
35  *
36  * description: This create create a billboarding object that display a text.
37  *
38  * @author 2003 by cTh see gavocanov@rambler.ru
39  * @update 2006 by barraq see nospam@barraquand.com
40  */
41 
42 #include "movable_text.h"
44 
46 #include <OgreQuaternion.h>
47 #include <OgreRoot.h>
48 #include <OgreCamera.h>
49 #include <OgreSceneNode.h>
50 #include <OgreMaterialManager.h>
51 #include <OgreHardwareBufferManager.h>
52 #include <Overlay/OgreFontManager.h>
53 #include <Overlay/OgreFont.h>
54 #if (OGRE_VERSION < OGRE_VERSION_CHECK(13, 0, 0))
55 #include <OgreUTFString.h>
56 #endif
57 
58 #include <sstream>
59 
60 using namespace Ogre;
61 
62 #define POS_TEX_BINDING 0
63 #define COLOUR_BINDING 1
64 
65 namespace rviz
66 {
67 MovableText::MovableText(const String& caption,
68  const String& fontName,
69  Real charHeight,
70  const ColourValue& color)
71  : mFontName(fontName)
72  , mType("MovableText")
73  , mCaption(caption)
74  , mHorizontalAlignment(H_LEFT)
75  , mVerticalAlignment(V_BELOW)
76  , mColor(color)
77  , mCharHeight(charHeight)
78  , mLineSpacing(0.01)
79  , mSpaceWidth(0)
80  , mUpdateColors(true)
81  , mOnTop(false)
82  , mTimeUntilNextToggle(0)
83  , mGlobalTranslation(0.0)
84  , mLocalTranslation(0.0)
85  , mpCam(nullptr)
86  , mpWin(nullptr)
87  , mpFont(nullptr)
88 {
89  static int count = 0;
90  std::stringstream ss;
91  ss << "MovableText" << count++;
92  mName = ss.str();
93 
94  mRenderOp.vertexData = nullptr;
95  this->setFontName(mFontName);
96  this->_setupGeometry();
97 }
98 
100 {
101  if (mRenderOp.vertexData)
102  delete mRenderOp.vertexData;
103  MaterialManager::getSingletonPtr()->remove(mpMaterial->getName());
104 }
105 
106 void MovableText::setFontName(const String& fontName)
107 {
108  if (mFontName != fontName || mpMaterial.isNull() || !mpFont)
109  {
110  mFontName = fontName;
111  mpFont = static_cast<Font*>(
112  FontManager::getSingleton()
113  .getByName(mFontName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)
114  .get());
115  if (!mpFont)
116  throw Exception(Exception::ERR_ITEM_NOT_FOUND, "Could not find font " + fontName,
117  "MovableText::setFontName");
118 
119  // to support non-ascii letters, setup the codepoint range before loading
120  mpFont->addCodePointRange(std::make_pair<Ogre::Font::CodePoint>(0, 999));
121  mpFont->load();
122 
123  if (mpMaterial.get())
124  MaterialManager::getSingletonPtr()->remove(mpMaterial->getName());
125  mpMaterial = mpFont->getMaterial()->clone(mName + "Material");
126  if (!mpMaterial->isLoaded())
127  mpMaterial->load();
128 
129  mpMaterial->setDepthCheckEnabled(!mOnTop);
130  mpMaterial->setDepthBias(1.0, 1.0);
131  mpMaterial->setDepthWriteEnabled(mOnTop);
132  mpMaterial->setLightingEnabled(false);
133  mNeedUpdate = true;
134  }
135 }
136 
137 void MovableText::setCaption(const String& caption)
138 {
139  if (caption != mCaption)
140  {
141  mCaption = caption;
142  mNeedUpdate = true;
143  }
144 }
145 
146 void MovableText::setColor(const ColourValue& color)
147 {
148  if (color != mColor)
149  {
150  mColor = color;
151  mUpdateColors = true;
152  }
153 }
154 
156 {
157  if (height != mCharHeight)
158  {
159  mCharHeight = height;
160  mNeedUpdate = true;
161  }
162 }
163 
165 {
166  if (height != mLineSpacing)
167  {
168  mLineSpacing = height;
169  mNeedUpdate = true;
170  }
171 }
172 
174 {
175  if (width != mSpaceWidth)
176  {
177  mSpaceWidth = width;
178  mNeedUpdate = true;
179  }
180 }
181 
182 void MovableText::setTextAlignment(const HorizontalAlignment& horizontalAlignment,
183  const VerticalAlignment& verticalAlignment)
184 {
185  if (mHorizontalAlignment != horizontalAlignment)
186  {
187  mHorizontalAlignment = horizontalAlignment;
188  mNeedUpdate = true;
189  }
190  if (mVerticalAlignment != verticalAlignment)
191  {
192  mVerticalAlignment = verticalAlignment;
193  mNeedUpdate = true;
194  }
195 }
196 
198 {
199  mGlobalTranslation = trans;
200 }
201 
203 {
204  mLocalTranslation = trans;
205 }
206 
207 void MovableText::showOnTop(bool show)
208 {
209  if (mOnTop != show && !mpMaterial.isNull())
210  {
211  mOnTop = show;
212  mpMaterial->setDepthBias(1.0, 1.0);
213  mpMaterial->setDepthCheckEnabled(!mOnTop);
214  mpMaterial->setDepthWriteEnabled(mOnTop);
215  }
216 }
217 
219 {
220 #if (OGRE_VERSION >= OGRE_VERSION_CHECK(13, 0, 0))
221  Ogre::String utfCaption(mCaption);
222 #else
223  Ogre::UTFString::utf32string utfCaption(Ogre::UTFString(mCaption).asUTF32());
224 #endif
225 
226  assert(mpFont);
227  assert(!mpMaterial.isNull());
228 
229  unsigned int vertexCount = 0;
230 
231  // count letters to determine how many vertices are needed
232  for (auto ch : utfCaption)
233  {
234  if ((ch != ' ') && (ch != '\n'))
235  {
236  vertexCount += 6;
237  }
238  }
239 
240  if (mRenderOp.vertexData)
241  {
242  delete mRenderOp.vertexData;
243  mRenderOp.vertexData = nullptr;
244  mUpdateColors = true;
245  }
246 
247  if (vertexCount == 0)
248  {
249  return;
250  }
251 
252  if (!mRenderOp.vertexData)
253  mRenderOp.vertexData = new VertexData();
254 
255  mRenderOp.indexData = nullptr;
256  mRenderOp.vertexData->vertexStart = 0;
257  mRenderOp.vertexData->vertexCount = vertexCount;
258  mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST;
259  mRenderOp.useIndexes = false;
260 
261  VertexDeclaration* decl = mRenderOp.vertexData->vertexDeclaration;
262  VertexBufferBinding* bind = mRenderOp.vertexData->vertexBufferBinding;
263  size_t offset = 0;
264 
265  // create/bind positions/tex.ccord. buffer
266  if (!decl->findElementBySemantic(VES_POSITION))
267  decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT3, VES_POSITION);
268 
269  offset += VertexElement::getTypeSize(VET_FLOAT3);
270 
271  if (!decl->findElementBySemantic(VES_TEXTURE_COORDINATES))
272  decl->addElement(POS_TEX_BINDING, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, 0);
273 
274  HardwareVertexBufferSharedPtr ptbuf =
275  HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(POS_TEX_BINDING),
276  mRenderOp.vertexData->vertexCount,
277  HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
278  bind->setBinding(POS_TEX_BINDING, ptbuf);
279 
280  // Colours - store these in a separate buffer because they change less often
281  if (!decl->findElementBySemantic(VES_DIFFUSE))
282  decl->addElement(COLOUR_BINDING, 0, VET_COLOUR, VES_DIFFUSE);
283 
284  HardwareVertexBufferSharedPtr cbuf =
285  HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(COLOUR_BINDING),
286  mRenderOp.vertexData->vertexCount,
287  HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
288  bind->setBinding(COLOUR_BINDING, cbuf);
289 
290  float* pPCBuff = static_cast<float*>(ptbuf->lock(HardwareBuffer::HBL_DISCARD));
291 
292  Real spaceWidth = mSpaceWidth;
293  // Derive space width from a capital A
294  if (spaceWidth == 0)
295  spaceWidth = mpFont->getGlyphAspectRatio('A') * mCharHeight;
296 
297  float total_height = mCharHeight;
298  float total_width = 0.0f;
299  float current_width = 0.0f;
300  for (auto ch : utfCaption)
301  {
302  if (ch == '\n')
303  {
304  total_height += mCharHeight + mLineSpacing;
305 
306  if (current_width > total_width)
307  {
308  total_width = current_width;
309  }
310  current_width = 0.0;
311  }
312  else if (ch == ' ')
313  {
314  current_width += spaceWidth;
315  }
316  else
317  {
318  current_width += mpFont->getGlyphAspectRatio(ch) * mCharHeight;
319  }
320  }
321 
322  if (current_width > total_width)
323  {
324  total_width = current_width;
325  }
326 
327  float top = 0.0f;
328  switch (mVerticalAlignment)
329  {
331  top = total_height;
332  break;
334  top = 0.5 * total_height;
335  break;
337  top = 0.0f;
338  break;
339  }
340 
341  float starting_left = 0.0f;
342  switch (mHorizontalAlignment)
343  {
344  case MovableText::H_LEFT:
345  starting_left = 0.0f;
346  break;
348  starting_left = -total_width / 2.0f;
349  break;
350  }
351 
352  float left = starting_left;
353 
354  // for calculation of AABB
355  Ogre::Vector3 currPos(0.0f);
356  Ogre::Vector3 min(starting_left, top - total_height, 0.0f);
357  Ogre::Vector3 max(starting_left + total_width, top, 0.0f);
358  auto iend = utfCaption.end();
359  for (auto i = utfCaption.begin(); i != iend; ++i)
360  {
361  if (*i == '\n')
362  {
363  left = starting_left;
364  top -= mCharHeight + mLineSpacing;
365  continue;
366  }
367 
368  if (*i == ' ')
369  {
370  // Just leave a gap, no tris
371  left += spaceWidth;
372  continue;
373  }
374 
375  Real char_width = mpFont->getGlyphAspectRatio(*i) * mCharHeight;
376  Real u1, u2, v1, v2;
377  Ogre::Font::UVRect utmp;
378  utmp = mpFont->getGlyphTexCoords(*i);
379  u1 = utmp.left;
380  u2 = utmp.right;
381  v1 = utmp.top;
382  v2 = utmp.bottom;
383 
384  // each vert is (x, y, z, u, v)
385  //-------------------------------------------------------------------------------------
386  // First tri
387  //
388  // Upper left
389  currPos = Ogre::Vector3(left, top, 0.0);
390 
391  *pPCBuff++ = currPos.x;
392  *pPCBuff++ = currPos.y;
393  *pPCBuff++ = currPos.z;
394  *pPCBuff++ = u1;
395  *pPCBuff++ = v1;
396 
397  top -= mCharHeight;
398 
399  // Bottom left
400  currPos = Ogre::Vector3(left, top, 0.0);
401  *pPCBuff++ = currPos.x;
402  *pPCBuff++ = currPos.y;
403  *pPCBuff++ = currPos.z;
404  *pPCBuff++ = u1;
405  *pPCBuff++ = v2;
406 
407  top += mCharHeight;
408  left += char_width;
409 
410  // Top right
411  currPos = Ogre::Vector3(left, top, 0.0);
412  *pPCBuff++ = currPos.x;
413  *pPCBuff++ = currPos.y;
414  *pPCBuff++ = currPos.z;
415  *pPCBuff++ = u2;
416  *pPCBuff++ = v1;
417 
418  //-------------------------------------------------------------------------------------
419  // Second tri
420  //
421  // Top right (again)
422  currPos = Ogre::Vector3(left, top, 0.0);
423  *pPCBuff++ = currPos.x;
424  *pPCBuff++ = currPos.y;
425  *pPCBuff++ = currPos.z;
426  *pPCBuff++ = u2;
427  *pPCBuff++ = v1;
428 
429  top -= mCharHeight;
430  left -= char_width;
431 
432  // Bottom left (again)
433  currPos = Ogre::Vector3(left, top, 0.0);
434  *pPCBuff++ = currPos.x;
435  *pPCBuff++ = currPos.y;
436  *pPCBuff++ = currPos.z;
437  *pPCBuff++ = u1;
438  *pPCBuff++ = v2;
439 
440  left += char_width;
441 
442  // Bottom right
443  currPos = Ogre::Vector3(left, top, 0.0);
444  *pPCBuff++ = currPos.x;
445  *pPCBuff++ = currPos.y;
446  *pPCBuff++ = currPos.z;
447  *pPCBuff++ = u2;
448  *pPCBuff++ = v2;
449  //-------------------------------------------------------------------------------------
450 
451  // Go back up with top
452  top += mCharHeight;
453  }
454  ptbuf->unlock();
455 
456  // update AABB/Sphere radius
457  mAABB = mCamFacingAABB = Ogre::AxisAlignedBox(min, max);
458  mRadius =
459  Ogre::Math::Sqrt(std::max(mAABB.getMinimum().squaredLength(), mAABB.getMaximum().squaredLength()));
460 
461  if (mUpdateColors)
462  this->_updateColors();
463 
464  mNeedUpdate = false;
465 }
466 
468 {
469  assert(mpFont);
470  assert(!mpMaterial.isNull());
471  assert(mRenderOp.vertexData);
472 
473  // Convert to system-specific
474  RGBA color;
475  Root::getSingleton().convertColourValue(mColor, &color);
476  HardwareVertexBufferSharedPtr vbuf =
477  mRenderOp.vertexData->vertexBufferBinding->getBuffer(COLOUR_BINDING);
478  RGBA* pDest = static_cast<RGBA*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));
479  for (int i = 0; i < (int)mRenderOp.vertexData->vertexCount; ++i)
480  *pDest++ = color;
481  vbuf->unlock();
482  mUpdateColors = false;
483 }
484 
485 const Quaternion& MovableText::getWorldOrientation() const
486 {
487  assert(mpCam);
488  return const_cast<Quaternion&>(mpCam->getDerivedOrientation());
489 }
490 
491 void MovableText::visitRenderables(Ogre::Renderable::Visitor* visitor, bool /*debugRenderables*/)
492 {
493  visitor->visit(this, 0, false);
494 }
495 
497 {
498  assert(mParentNode);
499  return mParentNode->_getDerivedPosition();
500 }
501 
502 void MovableText::getWorldTransforms(Matrix4* xform) const
503 {
504  if (this->isVisible() && mpCam)
505  {
506  Matrix3 rot3x3, scale3x3 = Matrix3::IDENTITY;
507 
508  // store rotation in a matrix
509  mpCam->getDerivedOrientation().ToRotationMatrix(rot3x3);
510 
511  // parent node position
512  Vector3 ppos = mParentNode->_getDerivedPosition() + mGlobalTranslation;
513  ppos += rot3x3 * mLocalTranslation;
514 
515  // apply scale
516  scale3x3[0][0] = mParentNode->_getDerivedScale().x;
517  scale3x3[1][1] = mParentNode->_getDerivedScale().y;
518  scale3x3[2][2] = mParentNode->_getDerivedScale().z;
519 
520  // apply all transforms to xform
521  *xform = (rot3x3 * scale3x3);
522  xform->setTrans(ppos);
523  }
524 }
525 
526 void MovableText::getRenderOperation(RenderOperation& op)
527 {
528  if (this->isVisible())
529  {
530  if (mNeedUpdate)
531  this->_setupGeometry();
532  if (mUpdateColors)
533  this->_updateColors();
534  op = mRenderOp;
535  }
536 }
537 
539 {
540  mpCam = cam;
541 
542  // update camera-facing bounding box
544 #if OGRE_VERSION < OGRE_VERSION_CHECK(1, 11, 0)
545  Ogre::Matrix4 m;
546  m.makeTransform(Ogre::Vector3::ZERO, Ogre::Vector3::UNIT_SCALE, mpCam->getDerivedOrientation());
547  mCamFacingAABB.transformAffine(m);
548 #else
549  Ogre::Affine3 m;
550  m.makeTransform(Ogre::Vector3::ZERO, Ogre::Vector3::UNIT_SCALE, mpCam->getDerivedOrientation());
551  mCamFacingAABB.transform(m);
552 #endif
553 }
554 
555 void MovableText::_updateRenderQueue(RenderQueue* queue)
556 {
557  if (this->isVisible())
558  {
559  if (mNeedUpdate)
560  this->_setupGeometry();
561  if (mUpdateColors)
562  this->_updateColors();
563 
564  queue->addRenderable(this, mRenderQueueID, OGRE_RENDERABLE_DEFAULT_PRIORITY);
565  // queue->addRenderable(this, mRenderQueueID, RENDER_QUEUE_SKIES_LATE);
566  }
567 }
568 
569 } // namespace rviz
rviz::MovableText::V_CENTER
@ V_CENTER
Definition: movable_text.h:72
rviz::MovableText::setTextAlignment
void setTextAlignment(const HorizontalAlignment &horizontalAlignment, const VerticalAlignment &verticalAlignment)
Definition: movable_text.cpp:182
rviz::MovableText::_updateColors
void _updateColors()
Definition: movable_text.cpp:467
rviz::MovableText::mpFont
Ogre::Font * mpFont
Definition: movable_text.h:105
min
int min(int a, int b)
rviz::MovableText::mLineSpacing
Ogre::Real mLineSpacing
Definition: movable_text.h:90
Ogre
Definition: axes_display.h:35
rviz::MovableText::setFontName
void setFontName(const Ogre::String &fontName)
Definition: movable_text.cpp:106
rviz::MovableText::mSpaceWidth
Ogre::Real mSpaceWidth
Definition: movable_text.h:91
rviz::MovableText::getRenderOperation
void getRenderOperation(Ogre::RenderOperation &op) override
Definition: movable_text.cpp:526
rviz::MovableText::mNeedUpdate
bool mNeedUpdate
Definition: movable_text.h:93
version_check.h
rviz::MovableText::setCaption
void setCaption(const Ogre::String &caption)
Definition: movable_text.cpp:137
POS_TEX_BINDING
#define POS_TEX_BINDING
Definition: movable_text.cpp:62
rviz::MovableText::~MovableText
~MovableText() override
Definition: movable_text.cpp:99
rviz::MovableText::setCharacterHeight
void setCharacterHeight(Ogre::Real height)
Definition: movable_text.cpp:155
rviz::MovableText::getWorldTransforms
void getWorldTransforms(Ogre::Matrix4 *xform) const override
Definition: movable_text.cpp:502
rviz::MovableText::mLocalTranslation
Ogre::Vector3 mLocalTranslation
Definition: movable_text.h:101
rviz::MovableText::showOnTop
void showOnTop(bool show=true)
Definition: movable_text.cpp:207
rviz::MovableText::V_BELOW
@ V_BELOW
Definition: movable_text.h:70
COLOUR_BINDING
#define COLOUR_BINDING
Definition: movable_text.cpp:63
f
f
rviz::MovableText::H_CENTER
@ H_CENTER
Definition: movable_text.h:66
rviz::MovableText::getWorldOrientation
const Ogre::Quaternion & getWorldOrientation() const
Definition: movable_text.cpp:485
rviz::MovableText::_updateRenderQueue
void _updateRenderQueue(Ogre::RenderQueue *queue) override
Definition: movable_text.cpp:555
rviz::MovableText::setLineSpacing
void setLineSpacing(Ogre::Real height)
Definition: movable_text.cpp:164
rviz::MovableText::mRenderOp
Ogre::RenderOperation mRenderOp
Definition: movable_text.h:84
rviz::MovableText::mName
Ogre::String mName
Definition: movable_text.h:78
rviz
Definition: add_display_dialog.cpp:54
rviz::MovableText::mCamFacingAABB
Ogre::AxisAlignedBox mCamFacingAABB
Definition: movable_text.h:86
Vector3
ogre_vector.h
rviz::MovableText::mColor
Ogre::ColourValue mColor
Definition: movable_text.h:83
rviz::MovableText::_setupGeometry
void _setupGeometry()
Definition: movable_text.cpp:218
rviz::MovableText::setGlobalTranslation
void setGlobalTranslation(Ogre::Vector3 trans)
Definition: movable_text.cpp:197
rviz::MovableText::_notifyCurrentCamera
void _notifyCurrentCamera(Ogre::Camera *cam) override
Definition: movable_text.cpp:538
rviz::MovableText::mHorizontalAlignment
HorizontalAlignment mHorizontalAlignment
Definition: movable_text.h:80
rviz::MovableText::mAABB
Ogre::AxisAlignedBox mAABB
Definition: movable_text.h:85
rviz::MovableText::visitRenderables
void visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables=false) override
Definition: movable_text.cpp:491
rviz::MovableText::mRadius
Ogre::Real mRadius
Definition: movable_text.h:98
movable_text.h
rviz::MovableText::mOnTop
bool mOnTop
Definition: movable_text.h:95
rviz::MovableText::mCharHeight
Ogre::Real mCharHeight
Definition: movable_text.h:89
rviz::MovableText::VerticalAlignment
VerticalAlignment
Definition: movable_text.h:68
rviz::MovableText::setLocalTranslation
void setLocalTranslation(Ogre::Vector3 trans)
Definition: movable_text.cpp:202
rviz::MovableText::mpCam
Ogre::Camera * mpCam
Definition: movable_text.h:103
rviz::MovableText::mFontName
Ogre::String mFontName
Definition: movable_text.h:76
rviz::MovableText::setSpaceWidth
void setSpaceWidth(Ogre::Real width)
Definition: movable_text.cpp:173
rviz::MovableText::mpMaterial
Ogre::MaterialPtr mpMaterial
Definition: movable_text.h:106
rviz::MovableText::HorizontalAlignment
HorizontalAlignment
Definition: movable_text.h:63
rviz::MovableText::setColor
void setColor(const Ogre::ColourValue &color)
Definition: movable_text.cpp:146
rviz::MovableText::mVerticalAlignment
VerticalAlignment mVerticalAlignment
Definition: movable_text.h:81
rviz::MovableText::H_LEFT
@ H_LEFT
Definition: movable_text.h:65
rviz::RGBA
Definition: depth_cloud_mld.cpp:81
rviz::MovableText::V_ABOVE
@ V_ABOVE
Definition: movable_text.h:71
rviz::MovableText::mUpdateColors
bool mUpdateColors
Definition: movable_text.h:94
rviz::MovableText::mGlobalTranslation
Ogre::Vector3 mGlobalTranslation
Definition: movable_text.h:100
rviz::MovableText::mCaption
Ogre::String mCaption
Definition: movable_text.h:79
rviz::MovableText::getWorldPosition
const Ogre::Vector3 & getWorldPosition() const
Definition: movable_text.cpp:496


rviz
Author(s): Dave Hershberger, David Gossow, Josh Faust, William Woodall
autogenerated on Fri Aug 2 2024 08:43:09