cocos2dx封装一个具有Layout功能的Point类 (提供源码)

最新推荐文章于 2020-10-09 12:47:08 发布
最新推荐文章于 2020-10-09 12:47:08 发布
阅读量489 收藏
点赞数
分类专栏： cocos2d-x Cocos2dx 文章标签： cocos2dx 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/while0/article/details/79032004
版权

(原创文章，转载请注明原文出处：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);



峻峰飞阳
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
CocosCreator实现不规则的点击区域监听
zzlwei的博客
04-18 2903
CocosCreator实现不规则的点击区域监听 开发一个农场小游戏，用常规的点击区域，会产生点击区域重叠问题。（展示的图片是已经调整为cc.PolygonCollider方法之后） 查询网上的方法，大部分是把节点变为3d就可以调节点击区域，但不知道为什么，区域已经如图所示，但是我所点击的土地会偏移到上面那块土地，这个问题由于项目时间紧张就没有去深究。还有农场常见的是可以拖动土地背景的，用普通的挂载办法，button会遮挡住背景的监听，所以又找到了这个办法，使用cocos自带的碰撞组件：cc.Polygo
cocos基础教程(6)坐标与锚点讲解
09-15 266
坐标系详解 Cocos2d-x坐标系和OpenGL坐标系相同，都是起源于笛卡尔坐标系。原点为屏幕左下角，x向右，y向上。 世界坐标系(World Coordinate) VS 本地坐标系（Node Local） 世界坐标系也叫做绝对坐标系，本地坐标系也叫相对坐标系，是和节点相关联的坐标系。每个节点都有独立的坐标系，当节点移动或改变方向时，和该节点关联的坐标系将随之移动或改变方向...
cocos2dx Layout使用方法
weixin_30666943的博客
03-31 349
1、 Text* alert = Text::create("Layout", "fonts/Marker Felt.ttf", 30 ); alert->setColor(Color3B(159, 168, 176)); alert->setPosition(Point(widgetSize.width / 2.0f, ...
cocos2dx layout:clone()
qq_27905767的博客
10-09 2384
记录cocos2dx layout使用clone()遇到的坑 在layout类对象调用clone()方法时，得到的新的对象的子节点不包含改layout类对象的Node类子节点。 测试示例中，self.uiNode.PL_Item_Mode是一个layout类的对象,而node是通过self.uiNode.PL_Item_Mode调用clone()得到的一个姓的对象，打印两个对象的子节点类名，结果如下: 通过打印结果看到，通过clone方法得到的新对象少了一个Node类子节点 ...
Cocos2d-x 3.0 开发（十五）使用UILayout布局，制作对话界面
12-17
编辑器中能设计静态展示的UIScrollView，而通常我们都需要在程序中动态增加信息。插入元素的位置怎么确定？在3.0中UILayout已经实现了基本的布局，这个例子则是一个简单的实现。相关博客地址：http://blog.csdn.net/fansongy/article/details/17382049
新手Cocos2dx跳一跳资源加源码初学
05-04
在这个"新手Cocos2dx跳一跳资源加源码初学"的压缩包中，包含了学习如何用Cocos2d-x制作类似"跳一跳"游戏的基础资源和源代码。 资源部分（Resources）： 资源文件通常包括游戏中的图片、音频、字体、配置文件等。在...
cocos2dx-3.0功能强大的richText控件源码
09-11
在Cocos2dx 3.0版本中，引入了名为RichText的控件，这是一个非常强大的文本渲染工具，尤其适合需要展示复杂格式化文本的场景，比如聊天应用、游戏内的提示信息或者菜单界面。 RichText控件的核心特性在于它能够支持...
cocos2dx骨骼动画Armature源码剖析(一)
11-22
【cocos2dx骨骼动画Armature源码剖析】 在cocos2dx中，骨骼动画是一种高效的游戏动画表现形式，它允许开发者使用骨骼和皮肤来构建角色的动态模型，从而实现复杂的动作和表情。骨骼动画的核心在于它能通过一组骨骼...
cocos2dx+lua实现橡皮擦功能
10-17
本文将详细介绍如何使用Cocos2d-x和Lua语言来实现这一功能，即创建一个橡皮擦工具。 Cocos2d-x是一个跨平台的游戏开发框架，它允许开发者用C++、Lua或JavaScript编写游戏逻辑。在这里，我们将主要关注使用Lua来实现...
cocos2d-x 2.0.4 封装组合框 ComboBox（转）
hhy018的专栏
11-12 775
转自：http://www.360doc.com/content/13/1112/15/14604925_328646858.shtml cocos2d-x 2.0.4尚未包含组合框组件，在很多需要选择时间、道具等应用场合非常不方便，故而自己封装了一个。基本上跟android标准组件的组合框功能和体验都一模一样了，而且功能更加强大， 完全可以自定义组合框的按钮图片，字体大小，背景图片
cocos2d-x已实现的功能或函数
R0CK Y0U的博客
03-24 879
原文链接（http://www.cnblogs.com/buaashine/archive/2012/11/12/2765691.html）   1.数学类 cocos2d-x 里使用最多的数学类型是CCPoint，一个点，本质上也是一个向量，对于向量和向量之间有很多的数学操作要做，oh我知道要干什么，也许我知道怎么求一个值但是不知道怎么求得高效（或者不知道），怎么办我能偷懒吗？
Cocostudio(1) 容器层的使用- ScrollView ListView PageView
yuan2053的博客
06-02 1488
转：http://www.cocos2d-x.org/docs/manual/framework/native/gui/container/zhGUI 容器层的使用-UIScrollView 滚动视图 除了布局容器，我们常用的还有滚动层容器，它可以扩大我们的显示控件，当内容元素很多时，尤为有用。可以设置为两个方向，横向或者是竖向。 UIScrollView* scroll
cocos2dx cocos2dx 3.x 公告栏 通知栏 滚动字幕 区域弹幕 区域显示 实现
kangli的专栏
12-10 1823
http://www.jianshu.com/p/ca0c6920e1b1 本文介绍游戏中常见的滚动播放的公告栏实现 要点 文字内容横向或者纵向滚动文字只在区域内显示，超出区域部分不显示 相关头文件 "2d/CCClippingNode.h" 注意：在cocos2dx 3.x版本中，方法名中的CC命名方式已经弃用，但是文件名中的CC依然有，所以此处的头文件名中的CC打头无法去
【Cocos2d-x】源码分析之 2d/ui/UILayout
yhhwatl的专栏
05-21 2955
cocostudio源码浅析之UILayout
cocos2dx之CocosWidget项目介绍
青子的专栏
06-12 2446
The Project Name：CocosWidget google.code svn checkout：  google.code：https://code.google.com/p/cocoswidget/ github：https://github.com/csdn-viva/CocosWidget/ qq group：261286285 author：Viv
cocos2dx-lua中实现面向对象的封装继承
hanxiaoqiag的专栏
11-27 1201
class函数是在"cocos2d-x-3.2/cocos/scripting/lua-bindings/script/extern.lua"中定义的。 -- Create an class. function class(classname, super)     local superType = type(super)     local 
Cocos2d-x 布局Layout , VBox,HBox可以互相嵌套
01-28 1989
 Size winSize = Director::getInstance()->getVisibleSize();  Layout* _verticalLayout = cocos2d::ui::VBox::create();//水平布局  _verticalLayout->setPosition(Vec2(winSize.width / 2 - 80,winSize.height -
cocos2dx游戏源码
最新发布
07-15
您好！如果您正在寻找Cocos2d-x游戏的源代码，您可以在Cocos官方网站的论坛或GitHub上找到各种开源项目。Cocos2d-x是一个开源的游戏开发框架，许多开发者都会分享他们的项目代码供其他人学习和使用。 您可以在Cocos官方论坛（https://discuss.cocos2d-x.org/）上找到各种游戏的源代码分享帖子。在论坛中的“Showcase”板块，您可以找到其他开发者分享的游戏项目以及他们的源代码。 此外，GitHub上也有许多Cocos2d-x游戏的开源项目。您可以在GitHub上搜索相关关键词，如"cocos2d-x game"，"cocos2d-x sample"等，来查找开发者分享的项目。 请注意，这些源代码是由其他开发者提供的，所以请务必遵循每个项目的许可证和使用条款。希望这能帮到您！如果还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

峻峰飞阳

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值