MyGUI 3.2.0

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

- File List
- Globals

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