cocos2dx封裝一個具有Layout功能的Point類 (提供原始碼)

峻峰飛陽發表於2018-01-11

(原創文章，轉載請註明原文出處：http://blog.csdn.net/while0/article/details/79032004）

基於cocos2dx開發遊戲，免不了設定節點或精靈的位置，這些位置座標常常不是一個絕對座標值，而是相對於其它節點的相對座標。例如：精靈A與精靈B左對齊，精靈A與精靈B中心對齊等等。

計算這些相對座標值，每次都需要進行計算，計算時要考慮到精靈的anchorPoint, scale等，比較繁瑣，一不留神就搞錯了，除錯來除錯去浪費時間。本文封裝了一個很方便的工具類，幫助你計算這些相對座標。

直接上原始碼:

GmbsPoint.h (無cpp檔案）

#ifndef __GMBSPOINT_H__
#define __GMBSPOINT_H__

#include "cocos2d.h"
#include "GmbsGrid.h"

NS_CC_BEGIN

class GmbsPoint : public Point
{
public:
    Node *m_targetNode;

    GmbsPoint(Node* targetNode = NULL)
    {
        m_targetNode = targetNode;
        if (targetNode)
        {
            Point pt = targetNode->getPosition();
            x = pt.x;
            y = pt.y;
        }
    }

    GmbsPoint(Node* targetNode, float xx, float yy)
    {
        m_targetNode = targetNode;
        x = xx;
        y = yy;
    }

    GmbsPoint& reset(Node* targetNode, float xx = 0, float yy = 0)
    {
        m_targetNode = targetNode;
        x = xx;
        y = yy;
        return *this;
    }

public:
    GmbsPoint& leftAlign(Node* baseNode, float leftPadding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.x -= baseNode->getContentSize().width * baseAnchorPoint.x * getScaleX(baseNode);

        Point point(basePoint.x + leftPadding, basePoint.y);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.x += m_targetNode->getContentSize().width * anchorPoint.x * getScaleX(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        x = point.x;
        return *this;
    }

    GmbsPoint& leftAlign(GmbsGrid& baseGrid, float leftPadding = 0)
    {
        return leftAlign(baseGrid.m_ownerNode, leftPadding + baseGrid.origin.x);
    }

    GmbsPoint& rightAlign(Node* baseNode, float rightPadding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.x += baseNode->getContentSize().width * (1 - baseAnchorPoint.x) * getScaleX(baseNode);

        Point point(basePoint.x - rightPadding, basePoint.y);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.x -= m_targetNode->getContentSize().width * (1 - anchorPoint.x) * getScaleX(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        x = point.x;
        return *this;
    }

    GmbsPoint& rightAlign(GmbsGrid& baseGrid, float rightPadding = 0)
    {
        Node* baseNode = baseGrid.m_ownerNode;
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.x += baseGrid.origin.x + baseGrid.size.width - baseNode->getContentSize().width * baseAnchorPoint.x * getScaleX(baseNode);

        Point point(basePoint.x - rightPadding, basePoint.y);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.x -= m_targetNode->getContentSize().width * (1 - anchorPoint.x) * getScaleX(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        x = point.x;
        return *this;
    }

    GmbsPoint& topAlign(Node* baseNode, float topPadding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.y += baseNode->getContentSize().height * (1 - baseAnchorPoint.y) * getScaleY(baseNode);

        Point point(basePoint.x, basePoint.y - topPadding);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.y -= m_targetNode->getContentSize().height * (1 - anchorPoint.y) * getScaleY(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        y = point.y;
        return *this;
    }

    GmbsPoint& topAlign(GmbsGrid& baseGrid, float topPadding = 0)
    {
        Node* baseNode = baseGrid.m_ownerNode;
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.y += baseGrid.origin.y + baseGrid.size.height - baseNode->getContentSize().height * baseAnchorPoint.y * getScaleY(baseNode);

        Point point(basePoint.x, basePoint.y - topPadding);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.y -= m_targetNode->getContentSize().height * (1 - anchorPoint.y) * getScaleY(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        y = point.y;
        return *this;
    }

    GmbsPoint& bottomAlign(Node* baseNode, float bottomPadding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.y -= baseNode->getContentSize().height * baseAnchorPoint.y * getScaleY(baseNode);

        Point point(basePoint.x, basePoint.y + bottomPadding);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.y += m_targetNode->getContentSize().height * anchorPoint.y * getScaleY(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        y = point.y;
        return *this;
    }

    GmbsPoint& bottomAlign(GmbsGrid& baseGrid, float bottomPadding = 0)
    {
        return bottomAlign(baseGrid.m_ownerNode, bottomPadding + baseGrid.origin.y);
    }

    GmbsPoint& xMiddleAlign(Node* baseNode, float padding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.x += baseNode->getContentSize().width * (0.5 - baseAnchorPoint.x) * getScaleX(baseNode);

        Point point(basePoint.x + padding, basePoint.y);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.x -= m_targetNode->getContentSize().width * (0.5 - anchorPoint.x) * getScaleX(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        x = point.x;
        return *this;
    }

    GmbsPoint& xMiddleAlign(GmbsGrid& baseGrid, float padding = 0)
    {
        Node* baseNode = baseGrid.m_ownerNode;
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.x += baseGrid.origin.x + baseGrid.size.width/2 - baseNode->getContentSize().width * baseAnchorPoint.x * getScaleX(baseNode);
        
        Point point(basePoint.x + padding, basePoint.y);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.x -= m_targetNode->getContentSize().width * (0.5 - anchorPoint.x) * getScaleX(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        x = point.x;
        return *this;
    }

    GmbsPoint& yMiddleAlign(Node* baseNode, float padding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.y += baseNode->getContentSize().height * (0.5 - baseAnchorPoint.y) * getScaleY(baseNode);

        Point point(basePoint.x, basePoint.y + padding);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.y -= m_targetNode->getContentSize().height * (0.5 - anchorPoint.y) * getScaleY(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        y = point.y;
        return *this;
    }

    GmbsPoint& yMiddleAlign(GmbsGrid& baseGrid, float padding = 0)
    {
        Node* baseNode = baseGrid.m_ownerNode;
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.y += baseGrid.origin.y + baseGrid.size.height/2 - baseNode->getContentSize().height * baseAnchorPoint.y * getScaleY(baseNode);

        Point point(basePoint.x, basePoint.y + padding);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.y -= m_targetNode->getContentSize().height * (0.5 - anchorPoint.y) * getScaleY(m_targetNode);
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        y = point.y;
        return *this;
    }

    GmbsPoint& rightTo(Node* baseNode, float rightPadding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.x -= baseNode->getContentSize().width * baseAnchorPoint.x * getScaleX(baseNode);

        Point point(basePoint.x - rightPadding, basePoint.y);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.x -= m_targetNode->getContentSize().width * (1 - anchorPoint.x) * getScaleX(m_targetNode);;
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        x = point.x;
        return *this;
    }

    GmbsPoint& leftTo(Node* baseNode, float leftPadding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.x += baseNode->getContentSize().width * (1 - baseAnchorPoint.x) * getScaleX(baseNode);

        Point point(basePoint.x + leftPadding, basePoint.y);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.x += m_targetNode->getContentSize().width * anchorPoint.x * getScaleX(m_targetNode);;
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        x = point.x;
        return *this;
    }

    GmbsPoint& bottomTo(Node* baseNode, float bottomPadding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.y += baseNode->getContentSize().height * (1 - baseAnchorPoint.y) * getScaleY(baseNode);

        Point point(basePoint.x, basePoint.y + bottomPadding);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.y += m_targetNode->getContentSize().height * anchorPoint.y * getScaleY(m_targetNode);;
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        y = point.y;
        return *this;
    }

    GmbsPoint& topTo(Node* baseNode, float topPadding = 0)
    {
        Point baseAnchorPoint(0, 0);
        Point basePoint = baseNode->getPosition();
        Node* baseParent = baseNode->getParent();
        if (baseParent != NULL)
            basePoint = baseParent->convertToWorldSpace(basePoint);
        if (!baseNode->isIgnoreAnchorPointForPosition())
            baseAnchorPoint = baseNode->getAnchorPoint();
        basePoint.y -= baseNode->getContentSize().height * baseAnchorPoint.y * getScaleY(baseNode);;

        Point point(basePoint.x, basePoint.y - topPadding);
        Point anchorPoint(0, 0);
        if (!m_targetNode->isIgnoreAnchorPointForPosition())
            anchorPoint = m_targetNode->getAnchorPoint();
        point.y -= m_targetNode->getContentSize().height * (1 - anchorPoint.y) * getScaleY(m_targetNode);;;
        point = m_targetNode->getParent()->convertToNodeSpace(point);
        y = point.y;
        return *this;
    }

    static float getScaleX(Node* node)
    {
        float scale = node->getScaleX();
        Node* parent = node->getParent();
        while (parent != NULL)
        {
            scale *= parent->getScaleX();
            parent = parent->getParent();
        }
        return scale;
    }

    static float getScaleY(Node* node)
    {
        float scale = node->getScaleY();
        Node* parent = node->getParent();
        while (parent != NULL)
        {
            scale *= parent->getScaleY();
            parent = parent->getParent();
        }
        return scale;
    }
};

NS_CC_END

#endif

GmbsGrid.h (無cpp檔案）

#ifndef __GMBSGRID_H__
#define __GMBSGRID_H__

#include "cocos2d.h"

NS_CC_BEGIN

class GmbsGrid : public Rect
{
protected:
    int m_xNum;
    int m_yNum;
    GmbsGrid** m_children;

public:
    Node *m_ownerNode;

    GmbsGrid(Node* ownerNode, int xNum, int yNum)
    {
        m_ownerNode = ownerNode;
    	origin = Point(0, 0);
    	size = ownerNode->getContentSize();
    	m_xNum = xNum;
    	m_yNum = yNum;
    	m_children = (GmbsGrid**)malloc(xNum*yNum*sizeof(GmbsGrid*));
    	memset(m_children, 0, xNum*yNum*sizeof(GmbsGrid*));
    }

    GmbsGrid(Node* ownerNode, Rect& rect, int xNum, int yNum)
    {
    	m_ownerNode = ownerNode;
    	origin = rect.origin;
    	size = rect.size;
    	m_xNum = xNum;
    	m_yNum = yNum;
    	m_children = (GmbsGrid**)malloc(xNum*yNum*sizeof(GmbsGrid*));
    	memset(m_children, 0, xNum*yNum*sizeof(GmbsGrid*));
    }

    GmbsGrid(Rect& rect, int xNum, int yNum)
    {
    	m_ownerNode = NULL;
    	origin = rect.origin;
    	size = rect.size;
    	m_xNum = xNum;
    	m_yNum = yNum;
    	m_children = (GmbsGrid**)malloc(xNum*yNum*sizeof(GmbsGrid*));
    	memset(m_children, 0, xNum*yNum*sizeof(GmbsGrid*));
    }

    virtual ~GmbsGrid()
    {
    	release();
    }

    void release()
    {
		for (int j = 0; j < m_yNum; j++)
		{
			for (int i = 0; i < m_xNum; i++)
			{
				if (m_children[j*m_xNum + i] != NULL)
				{
				    delete m_children[j*m_xNum + i];
				    m_children[j*m_xNum + i] = NULL;
				}
			}
		}
	}

    GmbsGrid& child(int x, int y)
    {
    	if (m_children[y*m_xNum + x] == NULL)
    	{
    		Rect rect;
    		rect.size.setSize(size.width/m_xNum, size.height/m_yNum);
    		rect.origin.setPoint(origin.x + rect.size.width*x, origin.y + rect.size.height*y);
    		m_children[y*m_xNum + x] = new GmbsGrid(m_ownerNode, rect, 1, 1);
    	}
    	return *m_children[y*m_xNum + x];
    }

    //counting from up to down
    GmbsGrid& childUtd(int x, int y)
    {
        int yNew = m_yNum - 1 - y;
    	if (m_children[yNew*m_xNum + x] == NULL)
    	{
    		Rect rect;
    		rect.size.setSize(size.width/m_xNum, size.height/m_yNum);
    		rect.origin.setPoint(origin.x + rect.size.width*x, origin.y + rect.size.height*yNew);
    		m_children[yNew*m_xNum + x] = new GmbsGrid(m_ownerNode, rect, 1, 1);
    	}
    	return *m_children[yNew*m_xNum + x];
    }

    void setOwnerNode(Node* ownerNode)
    {
    	m_ownerNode = ownerNode;
    }
};

NS_CC_END

#endif

舉例：

1) spriteA與spriteB中心對齊：

GmbsPoint pt(spriteA);
pt.xMiddleAlign(spriteB).yMiddleAlign(spriteB);
spriteA->setPosition(pt);

2) spriteA與spriteB左對齊且底對齊：

GmbsPoint pt(spriteA);  
pt.leftAlign(spriteB).bottomAlign(spriteB);  
spriteA->setPosition(pt);

3) spriteA在spriteB左側，且相距間隔為10，它們底部對齊：

GmbsPoint pt(spriteA);  
pt.leftTo(spriteB, 10).bottomAlign(spriteB);  
spriteA->setPosition(pt);

cocos2dx原始碼：背景層封裝類
2016-08-03
原始碼封裝
一個C#封裝的加密解密類程式碼
2009-01-13
C#封裝加密解密
一個最簡單的類JQuery封裝
2017-02-09
jQuery封裝
【JavaScript框架封裝】實現一個類似於JQuery的動畫框架的封裝
2018-07-19
JavaScript框架封裝jQuery動畫
PHP封裝的一個單例模式Mysql操作類
2017-05-17
PHP封裝單例模式MySql
【JavaScript框架封裝】實現一個類似於JQuery的CSS樣式框架的封裝
2018-07-19
JavaScript框架封裝jQueryCSS
驗證碼生成二三例（一般處理程式，封裝一個類）
2009-10-22
封裝
實現一個具有百度文庫文件轉換功能的工具類
2012-02-07
如何封裝一個自動歸、解檔類
2016-05-17
封裝
【Android初級】如何實現一個具有選擇功能的對話方塊效果（附原始碼）
2021-01-31
Android原始碼
Element原始碼分析系列1一Layout(佈局)
2018-08-15
原始碼
Swift-定位,編碼/反編碼功能的封裝
2018-07-30
Swift封裝
封裝一個通用的PopupWindow
2021-09-09
封裝
JS功能封裝
2020-08-17
JS封裝
Flutter Dio原始碼分析(四)--封裝
2021-08-30
Flutter原始碼封裝
將建立程式的API-posix_spawn封裝成一個程式類
2015-12-14
API封裝
【菜鳥學Java】3：封裝一個分頁類PageBean
2015-11-08
Java封裝Bean
android view layout原始碼分析
2014-03-19
AndroidView原始碼
java輔助開發的兩個封裝類
2016-08-31
Java封裝
php的curl封裝類
2017-01-05
PHP封裝
封裝一個自己的js庫
2021-09-09
封裝JS
一個簡單的 Amqp 封裝
2018-11-24
MQ封裝
JavaFx 生成二維碼工具類封裝
2023-04-28
Java封裝
封裝xunsearch類
2016-09-21
封裝
JS 封裝類
2014-08-26
JS封裝
cocos2dx原始碼：相框PhotoFrame
2016-08-03
原始碼
旅遊交友原始碼旅行結伴原始碼原始碼完全開源一同打包封裝APP
2022-01-15
原始碼封裝APP
爬蟲驗證碼的幾種處理方式，已封裝成類，文章末尾有原始碼！
2020-10-24
爬蟲封裝原始碼
php用curl封裝一個http請求類(鏈式呼叫)
2019-02-16
PHP封裝HTTP
一次Android動畫工具類的封裝
2019-04-15
Android動畫封裝
Weex-iOS原始碼-CSS Layout 分析
2019-02-19
iOS原始碼CSS
AFN3.0封裝一層工具類
2016-07-28
封裝
程式碼改變世界 | 如何封裝一個簡單的 Koa
2018-10-26
封裝
一個基礎功能的視訊播放器(XXVideoPlayer)-AVPlayer封裝
2016-10-22
播放器IDE封裝
封裝JDBC—非框架開發必備的封裝類
2017-06-07
封裝JDBC框架
短視訊平臺原始碼，取驗證碼封裝全部封裝好直接呼叫
2021-10-28
原始碼封裝
8.7 一個模組的封裝過程
2020-10-28
封裝
Android 封裝一個通用的PopupWindow
2017-12-15
Android封裝

cocos2dx封裝一個具有Layout功能的Point類 (提供原始碼)

相關文章