mirror of https://github.com/axmolengine/axmol.git
1304 lines
41 KiB
C++
1304 lines
41 KiB
C++
//
|
||
//
|
||
// Copyright (c) 2014-2020 Simdsoft Limited - All Rights Reserved
|
||
//
|
||
#include "LayoutHelper.h"
|
||
|
||
namespace LayoutHelper {
|
||
cocos2d::Rect ScreenVisibleRect::s_ScreenVisibleRect;
|
||
|
||
/// x-studio365: when design resolution changed, should call this func.
|
||
void ScreenVisibleRect::refresh(void)
|
||
{
|
||
auto director = Director::getInstance();
|
||
s_ScreenVisibleRect.origin = Director::getInstance()->getVisibleOrigin();
|
||
s_ScreenVisibleRect.size = Director::getInstance()->getVisibleSize();
|
||
}
|
||
|
||
void ScreenVisibleRect::lazyInit()
|
||
{
|
||
if (s_ScreenVisibleRect.size.width == 0.0f && s_ScreenVisibleRect.size.height == 0.0f)
|
||
{
|
||
auto director = Director::getInstance();
|
||
auto glview = director->getOpenGLView();
|
||
|
||
if (glview->getResolutionPolicy() == ResolutionPolicy::NO_BORDER) {
|
||
s_ScreenVisibleRect.origin = director->getVisibleOrigin();
|
||
s_ScreenVisibleRect.size = director->getVisibleSize();
|
||
}
|
||
else {
|
||
s_ScreenVisibleRect.origin = nodes_layout::getVisibleOrigin();
|
||
s_ScreenVisibleRect.size = nodes_layout::getVisibleSize();
|
||
}
|
||
}
|
||
}
|
||
|
||
cocos2d::Rect ScreenVisibleRect::getScreenVisibleRect()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Rect(s_ScreenVisibleRect.origin.x, s_ScreenVisibleRect.origin.y, s_ScreenVisibleRect.size.width, s_ScreenVisibleRect.size.height);
|
||
}
|
||
|
||
cocos2d::Size ScreenVisibleRect::size()
|
||
{
|
||
lazyInit();
|
||
return s_ScreenVisibleRect.size;
|
||
}
|
||
|
||
Point ScreenVisibleRect::left()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Point(s_ScreenVisibleRect.origin.x, s_ScreenVisibleRect.origin.y + s_ScreenVisibleRect.size.height / 2);
|
||
}
|
||
|
||
Point ScreenVisibleRect::right()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Point(s_ScreenVisibleRect.origin.x + s_ScreenVisibleRect.size.width, s_ScreenVisibleRect.origin.y + s_ScreenVisibleRect.size.height / 2);
|
||
}
|
||
|
||
Point ScreenVisibleRect::top()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Point(s_ScreenVisibleRect.origin.x + s_ScreenVisibleRect.size.width / 2, s_ScreenVisibleRect.origin.y + s_ScreenVisibleRect.size.height);
|
||
}
|
||
|
||
Point ScreenVisibleRect::bottom()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Point(s_ScreenVisibleRect.origin.x + s_ScreenVisibleRect.size.width / 2, s_ScreenVisibleRect.origin.y);
|
||
}
|
||
|
||
Point ScreenVisibleRect::center()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Point(s_ScreenVisibleRect.origin.x + s_ScreenVisibleRect.size.width / 2, s_ScreenVisibleRect.origin.y + s_ScreenVisibleRect.size.height / 2);
|
||
}
|
||
|
||
Point ScreenVisibleRect::leftTop()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Point(s_ScreenVisibleRect.origin.x, s_ScreenVisibleRect.origin.y + s_ScreenVisibleRect.size.height);
|
||
}
|
||
|
||
Point ScreenVisibleRect::rightTop()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Point(s_ScreenVisibleRect.origin.x + s_ScreenVisibleRect.size.width, s_ScreenVisibleRect.origin.y + s_ScreenVisibleRect.size.height);
|
||
}
|
||
|
||
Point ScreenVisibleRect::leftBottom()
|
||
{
|
||
lazyInit();
|
||
return s_ScreenVisibleRect.origin;
|
||
}
|
||
|
||
Point ScreenVisibleRect::rightBottom()
|
||
{
|
||
lazyInit();
|
||
return cocos2d::Point(s_ScreenVisibleRect.origin.x + s_ScreenVisibleRect.size.width, s_ScreenVisibleRect.origin.y);
|
||
}
|
||
|
||
const cocos2d::Point nodes_layout::ANCHOR_CENTER = cocos2d::Point(0.5, 0.5); // center
|
||
const cocos2d::Point nodes_layout::ANCHOR_LB = cocos2d::Point(0.0f, 0.0f); // left bottom,
|
||
const cocos2d::Point nodes_layout::ANCHOR_LT = cocos2d::Point(0.0f, 1.0f); // left top
|
||
const cocos2d::Point nodes_layout::ANCHOR_RB = cocos2d::Point(1.0f, 0.0f); // rigth bottom
|
||
const cocos2d::Point nodes_layout::ANCHOR_RT = cocos2d::Point(1.0f, 1.0f); // rigth top
|
||
|
||
float nodes_layout::adjustedScale = 1.0f;
|
||
cocos2d::Size nodes_layout::designSize;
|
||
|
||
//cocos2d::Size nodes_layout::getScreenSize(void)
|
||
//{
|
||
// return nodes_layout::designSize * nodes_layout::adjustedScale;
|
||
//}
|
||
//
|
||
//cocos2d::Vec2 nodes_layout::getSceenOffset(cocos2d::Point anchor)
|
||
//{
|
||
// float offsetX = anchor.x * (nodes_layout::getScreenSize().width - nodes_layout::designSize.width);
|
||
// float offsetY = anchor.y * (nodes_layout::getScreenSize().height - nodes_layout::designSize.height);
|
||
// return cocos2d::Vec2(offsetX, offsetY);
|
||
//}
|
||
|
||
void nodes_layout::setDesignSizeNoBorder(const cocos2d::Size& designSize)
|
||
{
|
||
// save smart size
|
||
nodes_layout::designSize = designSize;
|
||
|
||
// Set the design resolution//<2F>ֱ<EFBFBD><D6B1>ʵĴ<CAB5>С
|
||
GLView* pEGLView = Director::getInstance()->getOpenGLView();
|
||
const cocos2d::Size& frameSize = pEGLView->getFrameSize();
|
||
|
||
// Size lsSize = lsaSize;
|
||
|
||
float scaleX = (float)frameSize.width / nodes_layout::designSize.width;
|
||
float scaleY = (float)frameSize.height / nodes_layout::designSize.height;
|
||
|
||
adjustedScale = 0.0f; // MAX(scaleX, scaleY);
|
||
if (scaleX > scaleY) {
|
||
adjustedScale = scaleX / (frameSize.height / nodes_layout::designSize.height);
|
||
}
|
||
else {
|
||
adjustedScale = scaleY / (frameSize.width / nodes_layout::designSize.width);
|
||
}
|
||
|
||
cocos2d::log("x: %f; y: %f; scale: %f", scaleX, scaleY, adjustedScale);
|
||
|
||
pEGLView->setDesignResolutionSize(nodes_layout::designSize.width * adjustedScale,
|
||
nodes_layout::designSize.height * adjustedScale, ResolutionPolicy::NO_BORDER);
|
||
}
|
||
|
||
void nodes_layout::setDesignSizeFixedEdge(const Size& designSize)
|
||
{
|
||
nodes_layout::designSize = designSize;
|
||
|
||
// Set the design resolution//<2F>ֱ<EFBFBD><D6B1>ʵĴ<CAB5>С
|
||
GLView* pEGLView = Director::getInstance()->getOpenGLView();
|
||
const Size& frameSize = pEGLView->getFrameSize();
|
||
|
||
// Size lsSize = lsaSize;
|
||
|
||
float scaleX = (float)frameSize.width / designSize.width;
|
||
float scaleY = (float)frameSize.height / designSize.height;
|
||
|
||
// adjustedScale = 0.0f; // MAX(scaleX, scaleY);
|
||
if (scaleX < scaleY) {
|
||
pEGLView->setDesignResolutionSize(designSize.width,
|
||
designSize.height, ResolutionPolicy::FIXED_WIDTH);
|
||
}
|
||
else {
|
||
pEGLView->setDesignResolutionSize(designSize.width,
|
||
designSize.height, ResolutionPolicy::FIXED_HEIGHT);
|
||
}
|
||
}
|
||
|
||
cocos2d::Vec2 nodes_layout::getVisibleOrigin(void)
|
||
{
|
||
const auto& adjustedDesignSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
return cocos2d::Vec2((adjustedDesignSize.width - nodes_layout::designSize.width) * .5f,
|
||
(adjustedDesignSize.height - nodes_layout::designSize.height) * .5f);
|
||
}
|
||
|
||
cocos2d::Size nodes_layout::getVisibleSize(void)
|
||
{
|
||
return nodes_layout::designSize;
|
||
}
|
||
|
||
/// Get node group size
|
||
Size nodes_layout::getNodeGroupSize(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.empty())
|
||
{
|
||
return Size::ZERO;
|
||
}
|
||
|
||
// group nodes locators
|
||
float minX = getNodeLeft(nodes[0]), maxX = getNodeLeft(nodes[0]) + nodes[0]->getContentSize().width/* * nodes[0]->getScaleX()*/;
|
||
float minY = getNodeTop(nodes[0]), maxY = getNodeTop(nodes[0]) + nodes[0]->getContentSize().height/* * nodes[0]->getScaleY()*/;
|
||
float x = 0.0f, y = 0.0f;
|
||
// float width = 0.0f, height = 0.f;
|
||
for (size_t index = 1; index < nodes.size(); ++index) {
|
||
Node* child = nodes[index];
|
||
if (minX >(x = getNodeLeft(child)))
|
||
{
|
||
minX = x;
|
||
}
|
||
if (maxX < x + child->getContentSize().width/* * child->getScaleX()*/)
|
||
{
|
||
maxX = x + child->getContentSize().width/* * child->getScaleX()*/;
|
||
}
|
||
|
||
if (minY >(y = getNodeTop(child)))
|
||
{
|
||
minY = y;
|
||
}
|
||
if (maxY < y + child->getContentSize().height/* + child->getScaleY()*/)
|
||
{
|
||
maxY = y + child->getContentSize().height/* + child->getScaleY()*/;
|
||
}
|
||
}
|
||
|
||
float groupWidth = maxX - minX;
|
||
float groupHeight = maxY - minY;
|
||
|
||
return Size(groupWidth, groupHeight);
|
||
}
|
||
|
||
/// Set nodes group size
|
||
void nodes_layout::setNodeGroupSize(const std::vector<Node*>& nodes, const cocos2d::Size& newSize)
|
||
{
|
||
cocos2d::Size groupSize = getNodeGroupScaledSize(nodes);
|
||
if (groupSize.height == 0 || groupSize.width == 0 || newSize.width == 0 || newSize.height == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
float scaleX = newSize.width / groupSize.width;
|
||
float scaleY = newSize.height / groupSize.height;
|
||
|
||
for (auto iter = nodes.begin(); iter != nodes.end(); ++iter)
|
||
{
|
||
auto detail = dynamic_cast<cocos2d::Sprite*>(*iter);
|
||
if (detail != nullptr)
|
||
{
|
||
/*auto scaledWidth = (detail->getContentWidth() * detail->getScaleX());
|
||
auto scaledHeight = (detail->getContentHeight() * detail->getScaleY());
|
||
scaledWidth *= scaleX;
|
||
scaledHeight *= scaleY;*/
|
||
detail->setScale(detail->getScaleX() * scaleX, detail->getScaleY() * scaleY);
|
||
}
|
||
else {
|
||
(*iter)->setContentSize(
|
||
Size(
|
||
(*iter)->getContentSize().width * scaleX,
|
||
(*iter)->getContentSize().height * scaleY));
|
||
}
|
||
}
|
||
}
|
||
|
||
Size nodes_layout::getNodeGroupScaledSize(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.empty())
|
||
{
|
||
return Size::ZERO;
|
||
}
|
||
|
||
auto scale = getScale2D(nodes[0]);
|
||
|
||
// group nodes locators
|
||
float minX = nodes_layout::getNodeLeft(nodes[0]), maxX = nodes_layout::getNodeLeft(nodes[0]) + nodes[0]->getContentSize().width * scale.x;
|
||
float minY = nodes_layout::getNodeTop(nodes[0]), maxY = nodes_layout::getNodeTop(nodes[0]) + nodes[0]->getContentSize().height * scale.y;
|
||
float x = 0.0f, y = 0.0f;
|
||
// float width = 0.0f, height = 0.f;
|
||
for (size_t index = 1; index < nodes.size(); ++index) {
|
||
Node* child = nodes[index];
|
||
|
||
scale = getScale2D(child);
|
||
|
||
if (minX >(x = nodes_layout::getNodeLeft(child)))
|
||
{
|
||
minX = x;
|
||
}
|
||
if (maxX < x + child->getContentSize().width * scale.x)
|
||
{
|
||
maxX = x + child->getContentSize().width * scale.x;
|
||
}
|
||
|
||
if (minY >(y = nodes_layout::getNodeTop(child)))
|
||
{
|
||
minY = y;
|
||
}
|
||
if (maxY < y + child->getContentSize().height * scale.y)
|
||
{
|
||
maxY = y + child->getContentSize().height * scale.y;
|
||
}
|
||
}
|
||
|
||
float groupWidth = maxX - minX;
|
||
float groupHeight = maxY - minY;
|
||
|
||
return cocos2d::Size(groupWidth, groupHeight);
|
||
}
|
||
|
||
/// Get Node group left
|
||
float nodes_layout::getNodeGroupLeft(const std::vector<Node*>& nodes)
|
||
{
|
||
size_t index = 0;
|
||
float minLeft = getNodeLeft(nodes[index]);
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (minLeft > getNodeLeft(nodes[index]))
|
||
{
|
||
minLeft = getNodeLeft(nodes[index]);
|
||
}
|
||
}
|
||
return minLeft;
|
||
}
|
||
|
||
/// Get node group top
|
||
float nodes_layout::getNodeGroupTop(const std::vector<Node*>& nodes)
|
||
{
|
||
size_t index = 0;
|
||
float minTop = getNodeTop(nodes[index]);
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (minTop > getNodeTop(nodes[index]))
|
||
{
|
||
minTop = getNodeTop(nodes[index]);
|
||
}
|
||
}
|
||
return minTop;
|
||
}
|
||
|
||
/// Get node group right
|
||
float nodes_layout::getNodeGroupRight(const std::vector<Node*>& nodes)
|
||
{
|
||
size_t index = 0;
|
||
float minRight = getNodeRight(nodes[index]);
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (minRight > getNodeRight(nodes[index]))
|
||
{
|
||
minRight = getNodeRight(nodes[index]);
|
||
}
|
||
}
|
||
return minRight;
|
||
}
|
||
|
||
/// Get node group bottom
|
||
float nodes_layout::getNodeGroupBottom(const std::vector<Node*>& nodes)
|
||
{
|
||
size_t index = 0;
|
||
float minBottom = getNodeBottom(nodes[index]);
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (minBottom > getNodeBottom(nodes[index]))
|
||
{
|
||
minBottom = getNodeBottom(nodes[index]);
|
||
}
|
||
}
|
||
return minBottom;
|
||
}
|
||
|
||
/*
|
||
** setNodeGroupLeft
|
||
**
|
||
*/
|
||
void nodes_layout::setNodeGroupLeft(const std::vector<Node*>& nodes, float left)
|
||
{
|
||
float delta = left - getNodeGroupLeft(nodes);
|
||
|
||
for (auto iter = nodes.begin(); iter != nodes.end(); ++iter)
|
||
{
|
||
setNodeLeft((*iter), getNodeLeft((*iter)) + delta);
|
||
}
|
||
}
|
||
|
||
/*
|
||
** setNodeGroupLeft
|
||
**
|
||
*/
|
||
void nodes_layout::setNodeGroupTop(const std::vector<Node*>& nodes, float top)
|
||
{
|
||
float delta = top - getNodeGroupTop(nodes);
|
||
|
||
for (auto iter = nodes.begin(); iter != nodes.end(); ++iter)
|
||
{
|
||
setNodeTop((*iter), getNodeTop((*iter)) + delta);
|
||
}
|
||
}
|
||
|
||
void nodes_layout::setNodeGroupLT(const std::vector<Node*>& nodes, const cocos2d::Vec2& p)
|
||
{
|
||
float deltaL = p.x - getNodeGroupLeft(nodes);
|
||
float deltaT = p.y - getNodeGroupTop(nodes);
|
||
|
||
for (auto iter = nodes.begin(); iter != nodes.end(); ++iter)
|
||
{
|
||
setNodeLT((*iter), cocos2d::Vec2(getNodeLeft((*iter)) + deltaL, getNodeTop((*iter)) + deltaT));
|
||
}
|
||
}
|
||
|
||
/*
|
||
** setNodeGroupRight
|
||
**
|
||
*/
|
||
void nodes_layout::setNodeGroupRight(const std::vector<Node*>& nodes, float right)
|
||
{
|
||
float delta = right - getNodeGroupRight(nodes);
|
||
|
||
for (auto iter = nodes.begin(); iter != nodes.end(); ++iter)
|
||
{
|
||
setNodeRight((*iter), getNodeRight((*iter)) + delta);
|
||
}
|
||
}
|
||
|
||
/*
|
||
** setNodeGroupRight
|
||
**
|
||
*/
|
||
void nodes_layout::setNodeGroupBottom(const std::vector<Node*>& nodes, float bottom)
|
||
{
|
||
float delta = bottom - getNodeGroupBottom(nodes);
|
||
|
||
for (auto iter = nodes.begin(); iter != nodes.end(); ++iter)
|
||
{
|
||
setNodeBottom((*iter), getNodeBottom((*iter)) + delta);
|
||
}
|
||
}
|
||
|
||
void nodes_layout::moveNodeGroupHorizontally(const std::vector<Node*>& nodes, float delta)
|
||
{
|
||
for (auto node : nodes)
|
||
{
|
||
node->setPositionX(node->getPositionX() + delta);
|
||
}
|
||
}
|
||
|
||
void nodes_layout::moveNodeGroupVertically(const std::vector<Node*>& nodes, float delta)
|
||
{
|
||
for (auto node : nodes)
|
||
{
|
||
node->setPositionY(node->getPositionY() - delta);
|
||
}
|
||
}
|
||
|
||
/* @brief: group layout and alignment
|
||
** @remark:
|
||
*/
|
||
/// <summary>
|
||
/// ˮƽ<CBAE><C6BD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::centerHorizontally(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.empty())
|
||
{
|
||
return;
|
||
}
|
||
else if (nodes.size() == 1)
|
||
{
|
||
centerNodeX(nodes[0]);
|
||
return;
|
||
}
|
||
|
||
// group nodes locators
|
||
float minX = getNodeLeft(nodes[0]), maxX = getNodeLeft(nodes[0]) + nodes[0]->getContentSize().width;
|
||
float x = 0.0f;
|
||
float width = 0.0f;
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin() + 1, nodes.end(), [&](Node* child)->void{
|
||
if (minX > (x = getNodeLeft(child)))
|
||
{
|
||
minX = x;
|
||
}
|
||
if (maxX < x + child->getContentSize().width)
|
||
{
|
||
maxX = x + child->getContentSize().width;
|
||
}
|
||
});
|
||
#else
|
||
for (size_t index = 1; index < nodes.size(); ++index) {
|
||
Node* child = nodes[index];
|
||
if (minX >(x = getNodeLeft(child)))
|
||
{
|
||
minX = x;
|
||
}
|
||
if (maxX < x + child->getContentSize().width)
|
||
{
|
||
maxX = x + child->getContentSize().width;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
float groupWidth = maxX - minX;
|
||
float dist = ((nodes[0]->getParent()->getContentSize().width - groupWidth) / 2.0f) - minX;
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin(), nodes.end(), [dist](Node* child)->void{
|
||
setNodeLeft(child, getNodeLeft(child) + dist);
|
||
});
|
||
#else
|
||
for (size_t index = 0; index < nodes.size(); ++index) {
|
||
Node* child = nodes[index];
|
||
setNodeLeft(child, getNodeLeft(child) + dist, 0);
|
||
}
|
||
#endif
|
||
}
|
||
/// <summary>
|
||
/// <20><>ֱ<EFBFBD><D6B1><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::centerVertically(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.empty())
|
||
{
|
||
return;
|
||
}
|
||
else if (nodes.size() == 1)
|
||
{
|
||
centerNodeY(nodes[0]);
|
||
return;
|
||
}
|
||
|
||
// group nodes locators
|
||
float minY = getNodeTop(nodes[0]), maxY = getNodeTop(nodes[0]) + nodes[0]->getContentSize().height;
|
||
float y = 0.0f;
|
||
float height = 0.0f;
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin() + 1, nodes.end(), [&](Node* child)->void{
|
||
if (minY > (y = getNodeTop(child)))
|
||
{
|
||
minY = y;
|
||
}
|
||
if (maxY < y + child->getContentSize().height)
|
||
{
|
||
maxY = y + child->getContentSize().height;
|
||
}
|
||
});
|
||
#else
|
||
#endif
|
||
|
||
float groupHeight = maxY - minY;
|
||
float dist = ((nodes[0]->getParent()->getContentSize().height - groupHeight) / 2.0f) - minY;
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin(), nodes.end(), [dist](Node* child)->void{
|
||
setNodeTop(child, getNodeTop(child) + dist);
|
||
});
|
||
#else
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// <20><><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::centerHoriVerti(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.empty())
|
||
{
|
||
return;
|
||
}
|
||
else if (nodes.size() == 1)
|
||
{
|
||
centerNode(nodes[0]);
|
||
return;
|
||
}
|
||
|
||
// group nodes locators
|
||
float minX = getNodeLeft(nodes[0]), maxX = getNodeLeft(nodes[0]) + nodes[0]->getContentSize().width;
|
||
float x = 0.0f;
|
||
float width = 0.0f;
|
||
|
||
float minY = getNodeTop(nodes[0]), maxY = getNodeTop(nodes[0]) + nodes[0]->getContentSize().height;
|
||
float y = 0.0f;
|
||
float height = 0.0f;
|
||
|
||
std::for_each(nodes.begin() + 1, nodes.end(), [&](Node* child)->void{
|
||
if (minX > (x = getNodeLeft(child)))
|
||
{
|
||
minX = x;
|
||
}
|
||
if (maxX < x + child->getContentSize().width)
|
||
{
|
||
maxX = x + child->getContentSize().width;
|
||
}
|
||
if (minY > (y = getNodeTop(child)))
|
||
{
|
||
minY = y;
|
||
}
|
||
if (maxY < y + child->getContentSize().height)
|
||
{
|
||
maxY = y + child->getContentSize().height;
|
||
}
|
||
});
|
||
|
||
float groupWidth = maxX - minX;
|
||
float groupHeight = maxY - minY;
|
||
|
||
float distX = ((nodes[0]->getParent()->getContentSize().width - groupWidth) / 2.0f) - minX;
|
||
float distY = ((nodes[0]->getParent()->getContentSize().height - groupHeight) / 2.0f) - minY;
|
||
|
||
std::for_each(nodes.begin(), nodes.end(), [distX, distY](Node* child)->void{
|
||
setNodeLT(child, cocos2d::Point(getNodeLeft(child) + distX, getNodeTop(child) + distY));
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::alignLefts(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
size_t index = 0;
|
||
float minLeft = getNodeLeft(nodes[index]);
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (minLeft > getNodeLeft(nodes[index]))
|
||
{
|
||
minLeft = getNodeLeft(nodes[index]);
|
||
}
|
||
}
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin(), nodes.end(), [minLeft](Node* child)->void{
|
||
setNodeLeft(child, minLeft);
|
||
});
|
||
#else
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// <20>Ҷ<EFBFBD><D2B6><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::alignRights(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
size_t index = 0;
|
||
float maxRight = getNodeLeft(nodes[index]) + nodes[index]->getContentSize().width;
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (maxRight < (getNodeLeft(nodes[index]) + nodes[index]->getContentSize().width))
|
||
{
|
||
maxRight = getNodeLeft(nodes[index]) + nodes[index]->getContentSize().width;
|
||
}
|
||
}
|
||
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin(), nodes.end(), [maxRight](Node* child)->void{
|
||
setNodeLeft(child, maxRight - child->getContentSize().width);
|
||
});
|
||
#else
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// <20><><EFBFBD>˶<EFBFBD><CBB6><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::alignTops(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
size_t index = 0;
|
||
float minTop = getNodeTop(nodes[index]);
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (minTop > getNodeTop(nodes[index]))
|
||
{
|
||
minTop = getNodeTop(nodes[index]);
|
||
}
|
||
}
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin(), nodes.end(), [minTop](Node* child)->void{
|
||
setNodeTop(child, minTop);
|
||
});
|
||
#else
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// <20>˶<D7B6><CBB6><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::alignBottoms(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
size_t index = 0;
|
||
float maxBottom = getNodeTop(nodes[index]) + nodes[index]->getContentSize().height;
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (maxBottom < (getNodeTop(nodes[index]) + nodes[index]->getContentSize().height))
|
||
{
|
||
maxBottom = getNodeTop(nodes[index]) + nodes[index]->getContentSize().height;
|
||
}
|
||
}
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin(), nodes.end(), [maxBottom](Node* child)->void{
|
||
setNodeTop(child, maxBottom - child->getContentSize().height);
|
||
});
|
||
#else
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// ˮƽ<CBAE><C6BD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::alignHorizontals(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
size_t index = 0;
|
||
float minCenterY, maxCenterY, centerY;
|
||
Node* child = nodes[index];
|
||
minCenterY = maxCenterY = getNodeBottom(child, 0.5f); // child.GetX(0.5f);
|
||
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
child = nodes[index];
|
||
centerY = getNodeBottom(child, 0.5f); // child.GetX(0.5f);
|
||
if (minCenterY > centerY)
|
||
{
|
||
minCenterY = centerY;
|
||
}
|
||
if (maxCenterY < centerY)
|
||
{
|
||
maxCenterY = centerY;
|
||
}
|
||
}
|
||
|
||
std::for_each(nodes.begin(), nodes.end(), [minCenterY, maxCenterY](Node* child)->void{
|
||
setNodeBottom(child, (minCenterY + maxCenterY) * 0.5f, 0.5f); // child.SetX((minCenterX + maxCenterX) * 0.5f, 0.5f);
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// <20><>ֱ<EFBFBD><D6B1><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::alignVerticals(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
size_t index = 0;
|
||
float minCenterX, maxCenterX, centerX;
|
||
Node* child = nodes[index];
|
||
minCenterX = maxCenterX = getNodeLeft(child, 0.5f); // child.GetX(0.5f);
|
||
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
child = nodes[index];
|
||
centerX = getNodeLeft(child, 0.5f); // child.GetX(0.5f);
|
||
if (minCenterX > centerX)
|
||
{
|
||
minCenterX = centerX;
|
||
}
|
||
if (maxCenterX < centerX)
|
||
{
|
||
maxCenterX = centerX;
|
||
}
|
||
}
|
||
|
||
std::for_each(nodes.begin(), nodes.end(), [minCenterX, maxCenterX](Node* child)->void{
|
||
setNodeLeft(child, (minCenterX + maxCenterX) * 0.5f, 0.5f); // child.SetX((minCenterX + maxCenterX) * 0.5f, 0.5f);
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// <20><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::alignCenters(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
alignHorizontals(nodes);
|
||
alignVerticals(nodes);
|
||
}
|
||
|
||
/// <summary>
|
||
/// ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::makeSameWidth(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
size_t index = 0;
|
||
float maxWidth = nodes[index]->getContentSize().width;
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (maxWidth < nodes[index]->getContentSize().width)
|
||
{
|
||
maxWidth = nodes[index]->getContentSize().width;
|
||
}
|
||
}
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin(), nodes.end(), [maxWidth](Node* child)->void{
|
||
child->setContentSize(Size(maxWidth, child->getContentSize().height));
|
||
});
|
||
#else
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// ʹ<>߶<EFBFBD><DFB6><EFBFBD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::makeSameHeight(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
size_t index = 0;
|
||
float minHeight = nodes[index]->getContentSize().height;
|
||
for (index = 1; index < nodes.size(); ++index)
|
||
{
|
||
if (minHeight > nodes[index]->getContentSize().height)
|
||
{
|
||
minHeight = nodes[index]->getContentSize().height;
|
||
}
|
||
}
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
std::for_each(nodes.begin(), nodes.end(), [minHeight](Node* child)->void{
|
||
child->setContentSize(Size(child->getContentSize().width, minHeight));
|
||
});
|
||
#else
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// ʹ<>ô<EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::makeSameSize(const std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
makeSameHeight(nodes);
|
||
makeSameWidth(nodes);
|
||
}
|
||
|
||
/// <summary>
|
||
/// ʹˮƽ<CBAE><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::makeHorizontalSpacingEqual(std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 3)
|
||
return;
|
||
|
||
float avgHSpacing = 0;
|
||
Node* child, *childNext;
|
||
if (nodes.size() < 3) return;
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
// sort by x firstly
|
||
std::sort(nodes.begin(), nodes.end(), [](Node* const left, Node* const right){
|
||
return getNodeLeft(left) < getNodeLeft(right);
|
||
});
|
||
#else
|
||
#endif
|
||
|
||
for (size_t index = 0; index < nodes.size() - 1; ++index)
|
||
{
|
||
child = nodes[index];
|
||
childNext = nodes[index + 1];
|
||
avgHSpacing += (getNodeLeft(childNext) - getNodeLeft(child) - child->getContentSize().width);
|
||
}
|
||
|
||
avgHSpacing /= (nodes.size() - 1);
|
||
|
||
if (avgHSpacing < 0.0f) avgHSpacing = 0.0f;
|
||
|
||
nodes_layout::makeHorizontalSpacingEqual(nodes, avgHSpacing);
|
||
}
|
||
|
||
/// <summary>
|
||
/// ʹˮƽ<CBAE><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::makeHorizontalSpacingEqual(const std::vector<Node*>& nodes, float theSpacing)
|
||
{
|
||
Node* child, *childNext;
|
||
for (size_t index = 0; index < nodes.size() - 1; ++index)
|
||
{
|
||
child = nodes[index];
|
||
childNext = nodes[index + 1];
|
||
setNodeLeft(childNext, theSpacing + getNodeLeft(child) + child->getContentSize().width);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ʹ<><CAB9>ֱ<EFBFBD><D6B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::makeVerticalSpacingEqual(std::vector<Node*>& nodes)
|
||
{
|
||
if (nodes.size() < 3)
|
||
return;
|
||
|
||
float avgVSpacing = 0;
|
||
Node* child, *childNext;
|
||
if (nodes.size() < 3) return;
|
||
#if (defined(_WIN32) && _MSC_VER >= 1700) || !defined(_WIN32)
|
||
// sort by y firstly
|
||
std::sort(nodes.begin(), nodes.end(), [](Node* const left, Node* const right)->bool{
|
||
return getNodeTop(left) < getNodeTop(right);
|
||
});
|
||
#else
|
||
#endif
|
||
for (size_t index = 0; index < nodes.size() - 1; ++index)
|
||
{
|
||
child = nodes[index];
|
||
childNext = nodes[index + 1];
|
||
avgVSpacing += (getNodeTop(childNext) - getNodeTop(child) - child->getContentSize().height);
|
||
}
|
||
|
||
avgVSpacing /= (nodes.size() - 1);
|
||
|
||
if (avgVSpacing < 0.0f) avgVSpacing = 0.0f;
|
||
|
||
nodes_layout::makeVerticalSpacingEqual(nodes, avgVSpacing);
|
||
}
|
||
|
||
void nodes_layout::increaseHorizontalSpacing(std::vector<Node*>& nodes, float theSpacing)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
std::sort(nodes.begin(), nodes.end(), [](Node* const left, Node* const right)->bool{
|
||
return getNodeLeft(left) < getNodeLeft(right);
|
||
});
|
||
|
||
for (size_t idx = 1; idx < nodes.size(); ++idx)
|
||
{
|
||
nodes[idx]->setPositionX(nodes[idx]->getPositionX() + theSpacing * idx);
|
||
}
|
||
}
|
||
|
||
void nodes_layout::increaseVerticalSpacing(std::vector<Node*>& nodes, float theSpacing)
|
||
{
|
||
if (nodes.size() < 2)
|
||
return;
|
||
|
||
std::sort(nodes.begin(), nodes.end(), [](Node* const left, Node* const right)->bool{
|
||
return getNodeTop(left) < getNodeTop(right);
|
||
});
|
||
|
||
for (size_t idx = 1; idx < nodes.size(); ++idx)
|
||
{
|
||
nodes[idx]->setPositionY(nodes[idx]->getPositionY() - theSpacing * idx);
|
||
}
|
||
}
|
||
|
||
|
||
void nodes_layout::decreaseHorizontalSpacing(std::vector<Node*>& nodes, float theSpacing)
|
||
{
|
||
increaseHorizontalSpacing(nodes, -theSpacing);
|
||
}
|
||
|
||
|
||
void nodes_layout::decreaseVerticalSpacing(std::vector<Node*>& nodes, float theSpacing)
|
||
{
|
||
increaseVerticalSpacing(nodes, -theSpacing);
|
||
}
|
||
|
||
|
||
void nodes_layout::removeHorizontalSpacing(const std::vector<Node*>& nodes)
|
||
{
|
||
nodes_layout::makeHorizontalSpacingEqual(nodes, 0);
|
||
}
|
||
|
||
void nodes_layout::removeVerticalSpacing(const std::vector<Node*>& nodes)
|
||
{
|
||
nodes_layout::makeVerticalSpacingEqual(nodes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// ʹ<><CAB9>ֱ<EFBFBD><D6B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
/// </summary>
|
||
/// <param name="nodes"></param>
|
||
void nodes_layout::makeVerticalSpacingEqual(const std::vector<Node*>& nodes, float theSpacing)
|
||
{
|
||
Node* child, *childNext;
|
||
for (size_t index = 0; index < nodes.size() - 1; ++index)
|
||
{
|
||
child = nodes[index];
|
||
childNext = nodes[index + 1];
|
||
setNodeTop(childNext, theSpacing + getNodeTop(child) + child->getContentSize().height);
|
||
}
|
||
}
|
||
|
||
/// visual screen
|
||
float nodes_layout::scr::getNodeLeft(Node* pNode)
|
||
{
|
||
cocos2d::Point ptLocal(nodes_layout::getNodeLeft(pNode), 0);
|
||
auto ptWorld = pNode->getParent()->convertToWorldSpace(ptLocal);
|
||
return ptWorld.x;
|
||
}
|
||
float nodes_layout::scr::getNodeBottom(Node* pNode)
|
||
{
|
||
cocos2d::Point ptLocal(0, nodes_layout::getNodeBottom(pNode));
|
||
auto ptWorld = pNode->getParent()->convertToWorldSpace(ptLocal);
|
||
|
||
return ptWorld.y;
|
||
}
|
||
float nodes_layout::scr::getNodeRight(Node* pNode)
|
||
{
|
||
cocos2d::Point ptLocal(nodes_layout::getNodeLeft(pNode) + pNode->getContentSize().width/* * pNode->getScaleX()*/, 0);
|
||
auto ptWorld = pNode->getParent()->convertToWorldSpace(ptLocal);
|
||
|
||
auto ScreenVisibleRect = ScreenVisibleRect::getScreenVisibleRect();
|
||
return ScreenVisibleRect.size.width - ptWorld.x;
|
||
}
|
||
float nodes_layout::scr::getNodeTop(Node* pNode)
|
||
{
|
||
cocos2d::Point ptLocal(0, nodes_layout::getNodeBottom(pNode) + pNode->getContentSize().height/* * pNode->getScaleY()*/);
|
||
auto ptWorld = pNode->getParent()->convertToWorldSpace(ptLocal);
|
||
auto ScreenVisibleRect = ScreenVisibleRect::getScreenVisibleRect();
|
||
|
||
return ScreenVisibleRect.size.height - ptWorld.y;
|
||
}
|
||
|
||
void nodes_layout::scr::setNodeLeft(Node* pNode, float left)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(0, scrSize.height) - ScreenVisibleRect::leftTop();
|
||
Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
cocos2d::Point ptWorld(adjust_coord(size.width, achorPoint.x, left)/* - delta.x*/, 0);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPositionX(ptLocal.x);
|
||
|
||
}
|
||
void nodes_layout::scr::setNodeTop(Node* pNode, float top)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(0, scrSize.height) - ScreenVisibleRect::leftTop();
|
||
Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
cocos2d::Point ptWorld(0,
|
||
adjust_coord_neg(scrSize.height, size.height, achorPoint.y, top) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPositionY(ptLocal.y);
|
||
|
||
}
|
||
void nodes_layout::scr::setNodeRight(Node* pNode, float right)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(scrSize.width, 0) - ScreenVisibleRect::rightBottom();
|
||
Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
cocos2d::Point ptWorld(adjust_coord_neg(scrSize.width, size.width, achorPoint.x, right)/* - delta.x*/,
|
||
0);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPositionX(ptLocal.x);
|
||
}
|
||
void nodes_layout::scr::setNodeBottom(Node* pNode, float bottom)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(scrSize.width, 0) - ScreenVisibleRect::rightBottom();
|
||
Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
cocos2d::Point ptWorld(0,
|
||
adjust_coord(size.height, achorPoint.y, bottom) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPositionY(ptLocal.y);
|
||
|
||
}
|
||
|
||
void nodes_layout::scr::setNodeLT(Node* pNode, const cocos2d::Point& p)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(0, scrSize.height) - ScreenVisibleRect::leftTop();
|
||
Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
|
||
cocos2d::Point ptWorld(adjust_coord(size.width, achorPoint.x, p.x),
|
||
adjust_coord_neg(scrSize.height, size.height, achorPoint.y, p.y) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
void nodes_layout::scr::setNodeRT(Node* pNode, const cocos2d::Point& p)
|
||
{ // right top
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(scrSize.width, scrSize.height) - ScreenVisibleRect::rightTop();
|
||
Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
cocos2d::Point ptWorld(adjust_coord_neg(scrSize.width, size.width, achorPoint.x, p.x)/* - delta.x*/,
|
||
adjust_coord_neg(scrSize.height, size.height, achorPoint.y, p.y)/* - delta.y*/);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
void nodes_layout::scr::setNodeLB(Node* pNode, const cocos2d::Point& p)
|
||
{ // left bottom
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(0, 0) - ScreenVisibleRect::leftBottom();
|
||
Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
cocos2d::Point ptWorld(adjust_coord(size.width, achorPoint.x, p.x) - delta.x,
|
||
adjust_coord(size.height, achorPoint.y, p.y) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
void nodes_layout::scr::setNodeRB(Node* pNode, const cocos2d::Point& p)
|
||
{ // right bottom
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(scrSize.width, 0) - ScreenVisibleRect::rightBottom();
|
||
cocos2d::Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
|
||
cocos2d::Point ptWorld(adjust_coord_neg(scrSize.width, size.width, achorPoint.x, p.x)/* - delta.x*/,
|
||
adjust_coord(size.height, achorPoint.y, p.y) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
|
||
/// ratio position
|
||
void nodes_layout::scr::setNodeNormalizedLT(Node* pNode, const cocos2d::Point& ratio)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(0, scrSize.height) - ScreenVisibleRect::leftTop();
|
||
|
||
cocos2d::Size vscrSize = ScreenVisibleRect::size();
|
||
cocos2d::Point p = cocos2d::Vec2(vscrSize.width * ratio.x, vscrSize.height * ratio.y);
|
||
|
||
cocos2d::Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
|
||
cocos2d::Point ptWorld(adjust_coord(size.width, achorPoint.x, p.x) - delta.x,
|
||
adjust_coord_neg(scrSize.height, size.height, achorPoint.y, p.y) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
void nodes_layout::scr::setNodeNormalizedRT(Node* pNode, const cocos2d::Point& ratio)
|
||
{ // right top
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(scrSize.width, scrSize.height) - ScreenVisibleRect::rightTop();
|
||
|
||
cocos2d::Size vscrSize = ScreenVisibleRect::size();
|
||
cocos2d::Point p = cocos2d::Vec2(vscrSize.width * ratio.x, vscrSize.height * ratio.y);
|
||
|
||
cocos2d::Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
|
||
cocos2d::Point ptWorld(adjust_coord_neg(scrSize.width, size.width, achorPoint.x, p.x) - delta.x, adjust_coord_neg(scrSize.height, size.height, achorPoint.y, p.y) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
void nodes_layout::scr::setNodeNormalizedLB(Node* pNode, const cocos2d::Point& ratio)
|
||
{ // left bottom
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(0, 0) - ScreenVisibleRect::leftBottom();
|
||
|
||
cocos2d::Size vscrSize = ScreenVisibleRect::size();
|
||
cocos2d::Point p = cocos2d::Vec2(vscrSize.width * ratio.x, vscrSize.height * ratio.y);
|
||
|
||
cocos2d::Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
|
||
cocos2d::Point ptWorld(adjust_coord(size.width, achorPoint.x, p.x) - delta.x, adjust_coord(size.height, achorPoint.y, p.y) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
void nodes_layout::scr::setNodeNormalizedRB(Node* pNode, const cocos2d::Point& ratio)
|
||
{ // right bottom
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(scrSize.width, 0) - ScreenVisibleRect::rightBottom();
|
||
|
||
cocos2d::Size vscrSize = ScreenVisibleRect::size();
|
||
cocos2d::Point p = cocos2d::Vec2(vscrSize.width * ratio.x, vscrSize.height * ratio.y);
|
||
|
||
cocos2d::Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
|
||
cocos2d::Point ptWorld(adjust_coord_neg(scrSize.width, size.width, achorPoint.x, p.x) - delta.x, adjust_coord(size.height, achorPoint.y, p.y) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
|
||
void nodes_layout::scr::setNodeNormalizedTop(Node* pNode, const float ratioTop)
|
||
{ // right top
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Size scrSize = Director::getInstance()->getOpenGLView()->getDesignResolutionSize();
|
||
cocos2d::Point delta = cocos2d::Vec2(scrSize.width, scrSize.height) - ScreenVisibleRect::rightTop();
|
||
|
||
cocos2d::Size vscrSize = ScreenVisibleRect::size();
|
||
float top = vscrSize.width * ratioTop;
|
||
|
||
cocos2d::Size size = pNode->getContentSize() * getScale2D(pNode);
|
||
cocos2d::Point achorPoint = Vec2::ZERO;
|
||
if (!pNode->isIgnoreAnchorPointForPosition())
|
||
{
|
||
achorPoint = pNode->getAnchorPoint();
|
||
}
|
||
cocos2d::Point ptWorld(0, adjust_coord_neg(scrSize.height, size.height, achorPoint.y, top) - delta.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPositionY(ptWorld.y);
|
||
}
|
||
|
||
void nodes_layout::scr::setNodeNormalizedPositionX(cocos2d::Node* pNode, float ratio)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Rect ScreenVisibleRect = LayoutHelper::ScreenVisibleRect::getScreenVisibleRect();
|
||
cocos2d::Point ptWorld(ScreenVisibleRect.size.width * ratio + ScreenVisibleRect.origin.x, 0);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPositionX(ptLocal.x);
|
||
}
|
||
|
||
void nodes_layout::scr::setNodeNormalizedPositionY(cocos2d::Node* pNode, float ratio)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
cocos2d::Rect ScreenVisibleRect = LayoutHelper::ScreenVisibleRect::getScreenVisibleRect();
|
||
|
||
cocos2d::Point ptWorld(0, ScreenVisibleRect.size.height * ratio + ScreenVisibleRect.origin.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPositionY(ptLocal.y);
|
||
}
|
||
void nodes_layout::scr::setNodeNormalizedPosition(Node* pNode, const cocos2d::Point& ratio)
|
||
{
|
||
CC_ASSERT(pNode);
|
||
pNode->setIgnoreAnchorPointForPosition(false);
|
||
pNode->setAnchorPoint(cocos2d::Vec2(.5f, .5f));
|
||
cocos2d::Rect ScreenVisibleRect = LayoutHelper::ScreenVisibleRect::getScreenVisibleRect();
|
||
cocos2d::Point ptWorld(ScreenVisibleRect.size.width * ratio.x + ScreenVisibleRect.origin.x, ScreenVisibleRect.size.height * ratio.y + ScreenVisibleRect.origin.y);
|
||
auto ptLocal = pNode->getParent()->convertToNodeSpace(ptWorld);
|
||
pNode->setPosition(ptLocal);
|
||
}
|
||
|
||
}
|