MyGUI: MyGUI_RotatingSkin.cpp Source File

MyGUI 3.4.2

- Main Page
- Related Pages
- Namespaces
- Data Structures
- Files
- Examples

- File List
- Globals

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