MyGUI: MyGUI_RotatingSkin.cpp Source File

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
17 RotatingSkin::RotatingSkin() :
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 RotatingSkin::~RotatingSkin()
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
76 void RotatingSkin::_correctView()
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 // выравнивание по горизонтали без растяжения
106 mCoord.left = (mCroppedParent->getWidth() - mCoord.width) / 2;
107 need_update = true;
108 }
109
110 if (mAlign.isVStretch())
111 {
112 // растягиваем
113 mCoord.height = mCoord.height + (mCroppedParent->getHeight() - _oldsize.height);
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 // выравнивание по вертикали без растяжения
126 mCoord.top = (mCroppedParent->getHeight() - mCoord.height) / 2;
127 need_update = true;
128 }
129
130 if (need_update)
131 {
132 mCurrentCoord = mCoord;
133 _updateView();
134 }
135 }
136
137 void RotatingSkin::_updateView()
138 {
139 mEmptyView = ((0 >= _getViewWidth()) || (0 >= _getViewHeight()));
140
141 mGeometryOutdated = true;
142
143 if (nullptr != mNode)
144 mNode->outOfDate(mRenderItem);
145 }
146
147 void RotatingSkin::createDrawItem(ITexture* _texture, ILayerNode* _node)
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
156 void RotatingSkin::destroyDrawItem()
157 {
158 MYGUI_ASSERT(mRenderItem, "mRenderItem must be not nullptr");
159
160 mNode = nullptr;
161 mRenderItem->removeDrawItem(this);
162 mRenderItem = nullptr;
163 }
164
165 void RotatingSkin::doRender()
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 {
176 _rebuildGeometry();
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
200 void RotatingSkin::setStateData(IStateInfo* _data)
201 {
202 RotatingSkinStateInfo* data = _data->castType<RotatingSkinStateInfo>();
203
204 setAngle(data->getAngle());
205 setCenter(data->getCenter());
206
207 _setUVSet(data->getRect());
208 }
209
210 void RotatingSkin::_setUVSet(const FloatRect& _rect)
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
225 void RotatingSkin::_rebuildGeometry()
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 {
292 ICroppedRectangle* parent = mCroppedParent->getCroppedParent();
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
349 float RotatingSkin::getAngle() const
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:27
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:16
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:16
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:26
MyGUI::Colour
Definition: MyGUI_Colour.h:16
MyGUI::types::TRect::top
T top
Definition: MyGUI_TRect.h:21
MyGUI::RenderTargetInfo
Definition: MyGUI_RenderTargetInfo.h:15
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:16
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:119
MyGUI::types::TCoord::height
T height
Definition: MyGUI_TCoord.h:25
MyGUI
Definition: MyGUI_ActionController.h:14
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