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