MyGUI  3.2.2
MyGUI_RotatingSkin.cpp
Go to the documentation of this file.
1 /*
2  * This source file is part of MyGUI. For the latest info, see http://mygui.info/
3  * Distributed under the MIT License
4  * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
5  */
6 
7 #include "MyGUI_Precompiled.h"
8 #include "MyGUI_RotatingSkin.h"
9 #include "MyGUI_RenderItem.h"
10 #include "MyGUI_CommonStateInfo.h"
11 #include "MyGUI_RenderManager.h"
12 #include "MyGUI_GeometryUtility.h"
13 
14 namespace MyGUI
15 {
16 
18  mGeometryOutdated(false),
19  mAngle(0.0f),
20  mEmptyView(false),
21  mCurrentColour(0xFFFFFFFF),
22  mNode(nullptr),
23  mRenderItem(nullptr)
24  {
25  mVertexFormat = RenderManager::getInstance().getVertexFormat();
26  }
27 
29  {
30  }
31 
32  void RotatingSkin::setAngle(float _angle)
33  {
34  mAngle = _angle;
35  mGeometryOutdated = true;
36 
37  if (nullptr != mNode)
38  mNode->outOfDate(mRenderItem);
39  }
40 
41  void RotatingSkin::setCenter(const IntPoint& _center)
42  {
43  mCenterPos = _center;
44  mGeometryOutdated = true;
45 
46  if (nullptr != mNode)
47  mNode->outOfDate(mRenderItem);
48  }
49 
50  IntPoint RotatingSkin::getCenter(bool _local) const
51  {
52  return mCenterPos + (_local ? IntPoint() : mCroppedParent->getAbsolutePosition());
53  }
54 
55  void RotatingSkin::setVisible(bool _visible)
56  {
57  if (mVisible == _visible)
58  return;
59 
60  mVisible = _visible;
61  mGeometryOutdated = true;
62 
63  if (nullptr != mNode)
64  mNode->outOfDate(mRenderItem);
65  }
66 
67  void RotatingSkin::setAlpha(float _alpha)
68  {
69  uint32 alpha = ((uint8)(_alpha * 255) << 24);
70  mCurrentColour = (mCurrentColour & 0x00FFFFFF) | (alpha & 0xFF000000);
71 
72  if (nullptr != mNode)
73  mNode->outOfDate(mRenderItem);
74  }
75 
77  {
78  mGeometryOutdated = true;
79 
80  if (nullptr != mNode)
81  mNode->outOfDate(mRenderItem);
82  }
83 
84  void RotatingSkin::_setAlign(const IntSize& _oldsize)
85  {
86  // необходимо разобраться
87  bool need_update = true;
88 
89  // первоначальное выравнивание
90  if (mAlign.isHStretch())
91  {
92  // растягиваем
93  mCoord.width = mCoord.width + (mCroppedParent->getWidth() - _oldsize.width);
94  need_update = true;
95  mIsMargin = true; // при изменении размеров все пересчитывать
96  }
97  else if (mAlign.isRight())
98  {
99  // двигаем по правому краю
100  mCoord.left = mCoord.left + (mCroppedParent->getWidth() - _oldsize.width);
101  need_update = true;
102  }
103  else if (mAlign.isHCenter())
104  {
105  // выравнивание по горизонтали без растяжения
107  need_update = true;
108  }
109 
110  if (mAlign.isVStretch())
111  {
112  // растягиваем
114  need_update = true;
115  mIsMargin = true; // при изменении размеров все пересчитывать
116  }
117  else if (mAlign.isBottom())
118  {
119  // двигаем по нижнему краю
120  mCoord.top = mCoord.top + (mCroppedParent->getHeight() - _oldsize.height);
121  need_update = true;
122  }
123  else if (mAlign.isVCenter())
124  {
125  // выравнивание по вертикали без растяжения
127  need_update = true;
128  }
129 
130  if (need_update)
131  {
132  mCurrentCoord = mCoord;
133  _updateView();
134  }
135  }
136 
138  {
139  mEmptyView = ((0 >= _getViewWidth()) || (0 >= _getViewHeight()));
140 
141  mGeometryOutdated = true;
142 
143  if (nullptr != mNode)
144  mNode->outOfDate(mRenderItem);
145  }
146 
148  {
149  MYGUI_ASSERT(!mRenderItem, "mRenderItem must be nullptr");
150 
151  mNode = _node;
152  mRenderItem = mNode->addToRenderItem(_texture, true, false);
153  mRenderItem->addDrawItem(this, (GEOMETRY_VERTICIES_TOTAL_COUNT - 2) * 3);
154  }
155 
157  {
158  MYGUI_ASSERT(mRenderItem, "mRenderItem must be not nullptr");
159 
160  mNode = nullptr;
161  mRenderItem->removeDrawItem(this);
162  mRenderItem = nullptr;
163  }
164 
166  {
167  if (!mVisible || mEmptyView)
168  return;
169 
170  Vertex* verticies = mRenderItem->getCurrentVertexBuffer();
171 
172  float vertex_z = mNode->getNodeDepth();
173 
174  if (mGeometryOutdated)
175  {
177  mGeometryOutdated = false;
178  }
179 
180  for (int i = 1; i < GEOMETRY_VERTICIES_TOTAL_COUNT - 1; ++i)
181  {
182  verticies[3 * i - 3].set(mResultVerticiesPos[0].left, mResultVerticiesPos[0].top, vertex_z, mResultVerticiesUV[0].left, mResultVerticiesUV[0].top, mCurrentColour);
183  verticies[3 * i - 2].set(mResultVerticiesPos[i].left, mResultVerticiesPos[i].top, vertex_z, mResultVerticiesUV[i].left, mResultVerticiesUV[i].top, mCurrentColour);
184  verticies[3 * i - 1].set(mResultVerticiesPos[i + 1].left, mResultVerticiesPos[i + 1].top, vertex_z, mResultVerticiesUV[i + 1].left, mResultVerticiesUV[i + 1].top, mCurrentColour);
185  }
186 
187  mRenderItem->setLastVertexCount((GEOMETRY_VERTICIES_TOTAL_COUNT - 2) * 3);
188  }
189 
190  void RotatingSkin::_setColour(const Colour& _value)
191  {
192  uint32 colour = texture_utility::toColourARGB(_value);
193  texture_utility::convertColour(colour, mVertexFormat);
194  mCurrentColour = (colour & 0x00FFFFFF) | (mCurrentColour & 0xFF000000);
195 
196  if (nullptr != mNode)
197  mNode->outOfDate(mRenderItem);
198  }
199 
201  {
203 
204  setAngle(data->getAngle());
205  setCenter(data->getCenter());
206 
207  _setUVSet(data->getRect());
208  }
209 
211  {
212  mCurrentTexture = _rect;
213 
214  mGeometryOutdated = true;
215 
216  if (nullptr != mNode)
217  mNode->outOfDate(mRenderItem);
218  }
219 
220  inline float len(float x, float y)
221  {
222  return sqrt(x * x + y * y);
223  }
224 
226  {
227  /*
228  0 1
229  3 2
230  */
231 #ifndef M_PI
232  const float M_PI = 3.141593f;
233 #endif
234 
235  float width_base = (float)mCurrentCoord.width;
236  float height_base = (float)mCurrentCoord.height;
237 
238  // calculate original unrotated angles of uncropped rectangle verticies: between axis and line from center of rotation to vertex)
239  float baseAngles[RECT_VERTICIES_COUNT];
240  baseAngles[0] = atan2((float)mCenterPos.left, (float)mCenterPos.top) + M_PI / 2;
241  baseAngles[1] = atan2(- width_base + (float)mCenterPos.left, (float)mCenterPos.top) + M_PI / 2;
242  baseAngles[2] = atan2(- width_base + (float)mCenterPos.left, - height_base + (float)mCenterPos.top) + M_PI / 2;
243  baseAngles[3] = atan2((float)mCenterPos.left, - height_base + (float)mCenterPos.top) + M_PI / 2;
244 
245  // calculate original unrotated distances of uncropped rectangle verticies: between center of rotation and vertex)
246  float baseDistances[RECT_VERTICIES_COUNT];
247  baseDistances[0] = len((float)mCenterPos.left, (float)mCenterPos.top);
248  baseDistances[1] = len(- width_base + (float)mCenterPos.left, (float)mCenterPos.top);
249  baseDistances[2] = len(- width_base + (float)mCenterPos.left, - height_base + (float)mCenterPos.top);
250  baseDistances[3] = len((float)mCenterPos.left, - height_base + (float)mCenterPos.top);
251 
252 
253  // calculate rotated positions of uncropped rectangle verticies (relative to parent)
254  FloatPoint baseVerticiesPos[RECT_VERTICIES_COUNT];
255 
256  int offsetX = /*mCurrentCoord.left +*/ mCenterPos.left;
257  int offsetY = /*mCurrentCoord.top +*/ mCenterPos.top;
258 
259  for (int i = 0; i < RECT_VERTICIES_COUNT; ++i)
260  {
261  baseVerticiesPos[i].left = offsetX + cos(-mAngle + baseAngles[i]) * baseDistances[i];
262  baseVerticiesPos[i].top = offsetY - sin(-mAngle + baseAngles[i]) * baseDistances[i];
263  }
264 
265  // base texture coordinates
266  FloatPoint baseVerticiesUV[RECT_VERTICIES_COUNT] =
267  {
268  FloatPoint(mCurrentTexture.left, mCurrentTexture.top),
269  FloatPoint(mCurrentTexture.right, mCurrentTexture.top),
270  FloatPoint(mCurrentTexture.right, mCurrentTexture.bottom),
271  FloatPoint(mCurrentTexture.left, mCurrentTexture.bottom)
272  };
273 
274  // now we have rotated uncropped rectangle verticies coordinates
275 
276  // --------- here the cropping starts ---------
277 
278  // now we are going to calculate verticies of resulting figure
279 
280  // no parent - no cropping
281  size_t size = RECT_VERTICIES_COUNT;
282  if (nullptr == mCroppedParent->getCroppedParent())
283  {
284  for (int i = 0; i < RECT_VERTICIES_COUNT; ++i)
285  {
286  mResultVerticiesPos[i] = baseVerticiesPos[i];
287  mResultVerticiesUV[i] = baseVerticiesUV[i];
288  }
289  }
290  else
291  {
293 
294  VectorFloatPoint resultVerticiesPos = geometry_utility::cropPolygon(
295  baseVerticiesPos,
296  RECT_VERTICIES_COUNT,
297  IntCoord(
298  parent->_getMarginLeft() - mCroppedParent->getLeft(),
299  parent->_getMarginTop() - mCroppedParent->getTop(),
300  parent->_getViewWidth(),
301  parent->_getViewHeight()));
302 
303  for (size_t i = 0; i < resultVerticiesPos.size(); ++i)
304  {
305  mResultVerticiesPos[i] = resultVerticiesPos[i];
306  }
307 
308  size = resultVerticiesPos.size();
309 
310  // calculate texture coordinates
311  FloatPoint v0 = baseVerticiesUV[3] - baseVerticiesUV[0];
312  FloatPoint v1 = baseVerticiesUV[1] - baseVerticiesUV[0];
313  for (size_t i = 0; i < GEOMETRY_VERTICIES_TOTAL_COUNT; ++i)
314  {
315  if (i < size)
316  {
317  FloatPoint point = geometry_utility::getPositionInsideRect(mResultVerticiesPos[i], baseVerticiesPos[0], baseVerticiesPos[1], baseVerticiesPos[3]);
318  mResultVerticiesUV[i] = geometry_utility::getUVFromPositionInsideRect(point, v0, v1, baseVerticiesUV[0]);
319  }
320  else
321  {
322  // all unused verticies is equal to last used
323  mResultVerticiesUV[i] = mResultVerticiesUV[size - 1];
324  }
325  }
326  }
327 
328 
329  // now calculate widget base offset and then resulting position in screen coordinates
330  const RenderTargetInfo& info = mRenderItem->getRenderTarget()->getInfo();
331  float vertex_left_base = ((info.pixScaleX * (float)(mCroppedParent->getAbsoluteLeft()) + info.hOffset) * 2) - 1;
332  float vertex_top_base = -(((info.pixScaleY * (float)(mCroppedParent->getAbsoluteTop()) + info.vOffset) * 2) - 1);
333 
334  for (size_t i = 0; i < GEOMETRY_VERTICIES_TOTAL_COUNT; ++i)
335  {
336  if (i < size)
337  {
338  mResultVerticiesPos[i].left = vertex_left_base + mResultVerticiesPos[i].left * info.pixScaleX * 2;
339  mResultVerticiesPos[i].top = vertex_top_base + mResultVerticiesPos[i].top * info.pixScaleY * -2;
340  }
341  else
342  {
343  // all unused verticies is equal to last used
344  mResultVerticiesPos[i] = mResultVerticiesPos[size - 1];
345  }
346  }
347  }
348 
350  {
351  return mAngle;
352  }
353 
354 } // namespace MyGUI
MyGUI::Singleton< RenderManager >::getInstance
static RenderManager & getInstance()
Definition: MyGUI_Singleton.h:38
MyGUI::types::TRect::bottom
T bottom
Definition: MyGUI_TRect.h:23
MyGUI::RenderItem::setLastVertexCount
void setLastVertexCount(size_t _count)
Definition: MyGUI_RenderItem.cpp:235
MyGUI::RenderTargetInfo::vOffset
float vOffset
Definition: MyGUI_RenderTargetInfo.h:41
MyGUI::Align::isHCenter
bool isHCenter() const
Definition: MyGUI_Align.h:44
MyGUI::geometry_utility::cropPolygon
VectorFloatPoint cropPolygon(FloatPoint *_baseVerticiesPos, size_t _size, const IntCoord &_cropRectangle)
Definition: MyGUI_GeometryUtility.cpp:16
MyGUI::types::TSize::height
T height
Definition: MyGUI_TSize.h:21
MyGUI::ICroppedRectangle::_getMarginTop
int _getMarginTop() const
Definition: MyGUI_ICroppedRectangle.h:175
MyGUI::IntCoord
types::TCoord< int > IntCoord
Definition: MyGUI_Types.h:35
MyGUI::types::TCoord::left
T left
Definition: MyGUI_TCoord.h:22
MyGUI::ICroppedRectangle::mIsMargin
bool mIsMargin
Definition: MyGUI_ICroppedRectangle.h:248
MyGUI::ICroppedRectangle::getAbsolutePosition
const IntPoint & getAbsolutePosition() const
Definition: MyGUI_ICroppedRectangle.h:67
MyGUI::types::TPoint::top
T top
Definition: MyGUI_TPoint.h:21
MyGUI::RotatingSkin::createDrawItem
virtual void createDrawItem(ITexture *_texture, ILayerNode *_node)
Definition: MyGUI_RotatingSkin.cpp:147
MyGUI::ICroppedRectangle::_getViewHeight
int _getViewHeight() const
Definition: MyGUI_ICroppedRectangle.h:153
MyGUI::types::TCoord::top
T top
Definition: MyGUI_TCoord.h:23
MyGUI::RotatingSkin::getAngle
float getAngle() const
Definition: MyGUI_RotatingSkin.cpp:349
MyGUI::len
float len(float x, float y)
Definition: MyGUI_PolygonalSkin.cpp:35
MyGUI::ICroppedRectangle::getAbsoluteTop
int getAbsoluteTop() const
Definition: MyGUI_ICroppedRectangle.h:88
MyGUI::types::TRect< float >
MyGUI::RotatingSkin::RotatingSkin
RotatingSkin()
Definition: MyGUI_RotatingSkin.cpp:17
MyGUI::ILayerNode::addToRenderItem
virtual RenderItem * addToRenderItem(ITexture *_texture, bool _firstQueue, bool _separate)=0
MyGUI::M_PI
const float M_PI
Definition: MyGUI_ControllerEdgeHide.cpp:18
MyGUI::ILayerNode::outOfDate
virtual void outOfDate(RenderItem *_item)=0
MyGUI::types::TRect::right
T right
Definition: MyGUI_TRect.h:22
MyGUI::ILayerNode
Definition: MyGUI_ILayerNode.h:29
MyGUI::RotatingSkin::_correctView
virtual void _correctView()
Definition: MyGUI_RotatingSkin.cpp:76
MyGUI::RotatingSkin::getCenter
IntPoint getCenter(bool _local=true) const
Definition: MyGUI_RotatingSkin.cpp:50
MyGUI::ICroppedRectangle::getAbsoluteLeft
int getAbsoluteLeft() const
Definition: MyGUI_ICroppedRectangle.h:83
MyGUI::Align::isVCenter
bool isVCenter() const
Definition: MyGUI_Align.h:49
MyGUI::types::TPoint< int >
MyGUI_CommonStateInfo.h
MyGUI::RotatingSkin::_setAlign
virtual void _setAlign(const IntSize &_oldsize)
Definition: MyGUI_RotatingSkin.cpp:84
MyGUI::RenderTargetInfo::hOffset
float hOffset
Definition: MyGUI_RenderTargetInfo.h:40
MyGUI::RotatingSkinStateInfo::getRect
const FloatRect & getRect() const
Definition: MyGUI_CommonStateInfo.h:142
MyGUI::types::TSize::width
T width
Definition: MyGUI_TSize.h:20
MyGUI::RotatingSkin::destroyDrawItem
virtual void destroyDrawItem()
Definition: MyGUI_RotatingSkin.cpp:156
MyGUI::types::TRect::left
T left
Definition: MyGUI_TRect.h:20
MyGUI::ISubWidget::mVisible
bool mVisible
Definition: MyGUI_ISubWidget.h:61
MyGUI::uint32
unsigned int uint32
Definition: MyGUI_Types.h:48
MyGUI::ILayerNode::getNodeDepth
virtual float getNodeDepth()=0
MyGUI::IStateInfo
Definition: MyGUI_IStateInfo.h:18
MyGUI_Precompiled.h
MyGUI::RotatingSkin::doRender
virtual void doRender()
Definition: MyGUI_RotatingSkin.cpp:165
MyGUI::RotatingSkin::_rebuildGeometry
void _rebuildGeometry()
Definition: MyGUI_RotatingSkin.cpp:225
MyGUI::RotatingSkinStateInfo::getAngle
float getAngle() const
Definition: MyGUI_CommonStateInfo.h:132
MyGUI::RotatingSkin::setAngle
void setAngle(float _angle)
Definition: MyGUI_RotatingSkin.cpp:32
MyGUI::ICroppedRectangle::mCroppedParent
ICroppedRectangle * mCroppedParent
Definition: MyGUI_ICroppedRectangle.h:249
MyGUI::ICroppedRectangle::mCoord
IntCoord mCoord
Definition: MyGUI_ICroppedRectangle.h:245
MyGUI::IntPoint
types::TPoint< int > IntPoint
Definition: MyGUI_Types.h:26
MyGUI::RotatingSkin::setStateData
virtual void setStateData(IStateInfo *_data)
Definition: MyGUI_RotatingSkin.cpp:200
MyGUI::geometry_utility::getPositionInsideRect
FloatPoint getPositionInsideRect(const FloatPoint &_point, const FloatPoint &_corner0, const FloatPoint &_corner1, const FloatPoint &_corner2)
Definition: MyGUI_GeometryUtility.cpp:89
MyGUI::geometry_utility::getUVFromPositionInsideRect
FloatPoint getUVFromPositionInsideRect(const FloatPoint &_point, const FloatPoint &_v0, const FloatPoint &_v1, const FloatPoint &_baseUV)
Definition: MyGUI_GeometryUtility.cpp:105
MyGUI::types::TPoint::left
T left
Definition: MyGUI_TPoint.h:20
MyGUI::RotatingSkin::_setUVSet
virtual void _setUVSet(const FloatRect &_rect)
Definition: MyGUI_RotatingSkin.cpp:210
MyGUI::RotatingSkin::_setColour
virtual void _setColour(const Colour &_value)
Definition: MyGUI_RotatingSkin.cpp:190
MyGUI::RenderTargetInfo::pixScaleX
float pixScaleX
Definition: MyGUI_RenderTargetInfo.h:38
MyGUI::IRenderTarget::getInfo
virtual const RenderTargetInfo & getInfo()=0
MYGUI_ASSERT
#define MYGUI_ASSERT(exp, dest)
Definition: MyGUI_Diagnostic.h:42
MyGUI::IObject::castType
Type * castType(bool _throw=true)
Definition: MyGUI_IObject.h:18
MyGUI::texture_utility::convertColour
__inline void convertColour(uint32 &_colour, VertexColourType _format)
Definition: MyGUI_TextureUtility.h:23
MyGUI::Align::isVStretch
bool isVStretch() const
Definition: MyGUI_Align.h:84
MyGUI::RenderItem::getRenderTarget
IRenderTarget * getRenderTarget()
Definition: MyGUI_RenderItem.cpp:240
MyGUI::RenderTargetInfo::pixScaleY
float pixScaleY
Definition: MyGUI_RenderTargetInfo.h:39
MyGUI::uint8
unsigned char uint8
Definition: MyGUI_Types.h:46
MyGUI::RotatingSkin::setCenter
void setCenter(const IntPoint &_center)
Definition: MyGUI_RotatingSkin.cpp:41
MyGUI::types::TSize< int >
nullptr
#define nullptr
Definition: MyGUI_Prerequest.h:29
MyGUI::ICroppedRectangle
Definition: MyGUI_ICroppedRectangle.h:17
MyGUI_RenderItem.h
MyGUI::VectorFloatPoint
std::vector< FloatPoint > VectorFloatPoint
Definition: MyGUI_GeometryUtility.h:15
MyGUI::ISubWidget::mAlign
Align mAlign
Definition: MyGUI_ISubWidget.h:60
MyGUI::Align::isRight
bool isRight() const
Definition: MyGUI_Align.h:64
MyGUI::ITexture
Definition: MyGUI_ITexture.h:27
MyGUI::Colour
Definition: MyGUI_Colour.h:17
MyGUI::types::TRect::top
T top
Definition: MyGUI_TRect.h:21
MyGUI::RenderTargetInfo
Definition: MyGUI_RenderTargetInfo.h:16
MyGUI_RenderManager.h
MyGUI::Align::isBottom
bool isBottom() const
Definition: MyGUI_Align.h:79
MyGUI::types::TCoord::width
T width
Definition: MyGUI_TCoord.h:24
MyGUI::RenderItem::removeDrawItem
void removeDrawItem(ISubWidget *_item)
Definition: MyGUI_RenderItem.cpp:100
MyGUI::ICroppedRectangle::_getMarginLeft
int _getMarginLeft() const
Definition: MyGUI_ICroppedRectangle.h:167
MyGUI::ICroppedRectangle::getTop
int getTop() const
Definition: MyGUI_ICroppedRectangle.h:104
MyGUI::ICroppedRectangle::_getViewWidth
int _getViewWidth() const
Definition: MyGUI_ICroppedRectangle.h:149
MyGUI::RenderManager::getVertexFormat
virtual VertexColourType getVertexFormat()=0
MyGUI::ICroppedRectangle::getHeight
int getHeight() const
Definition: MyGUI_ICroppedRectangle.h:119
MyGUI_GeometryUtility.h
MyGUI::RotatingSkin::_updateView
virtual void _updateView()
Definition: MyGUI_RotatingSkin.cpp:137
MyGUI::RenderItem::addDrawItem
void addDrawItem(ISubWidget *_item, size_t _count)
Definition: MyGUI_RenderItem.cpp:125
MyGUI::RotatingSkinStateInfo::getCenter
const IntPoint & getCenter() const
Definition: MyGUI_CommonStateInfo.h:137
MyGUI::Vertex
Definition: MyGUI_VertexData.h:17
MyGUI::RenderItem::getCurrentVertexBuffer
Vertex * getCurrentVertexBuffer() const
Definition: MyGUI_RenderItem.cpp:230
MyGUI::RotatingSkin::setAlpha
virtual void setAlpha(float _alpha)
Definition: MyGUI_RotatingSkin.cpp:67
MyGUI::ICroppedRectangle::getWidth
int getWidth() const
Definition: MyGUI_ICroppedRectangle.h:114
MyGUI::ICroppedRectangle::getLeft
int getLeft() const
Definition: MyGUI_ICroppedRectangle.h:94
MyGUI::RotatingSkin::~RotatingSkin
virtual ~RotatingSkin()
Definition: MyGUI_RotatingSkin.cpp:28
MyGUI::Vertex::set
void set(float _x, float _y, float _z, float _u, float _v, uint32 _colour)
Definition: MyGUI_VertexData.h:18
MyGUI::RotatingSkinStateInfo
Definition: MyGUI_CommonStateInfo.h:121
MyGUI::types::TCoord::height
T height
Definition: MyGUI_TCoord.h:25
MyGUI
Definition: MyGUI_ActionController.h:15
MyGUI::Align::isHStretch
bool isHStretch() const
Definition: MyGUI_Align.h:69
MyGUI::texture_utility::toColourARGB
uint32 toColourARGB(const Colour &_colour)
Definition: MyGUI_TextureUtility.cpp:69
MyGUI::FloatPoint
types::TPoint< float > FloatPoint
Definition: MyGUI_Types.h:27
MyGUI::ICroppedRectangle::getCroppedParent
ICroppedRectangle * getCroppedParent()
Definition: MyGUI_ICroppedRectangle.h:27
MyGUI_RotatingSkin.h
MyGUI::RotatingSkin::setVisible
virtual void setVisible(bool _visible)
Definition: MyGUI_RotatingSkin.cpp:55