【cocos2d-x 3D游戏开发】1: 2D基础回顾---触摸事件(2.x)
前言
本文回顾了cocos2d-x 2.x中触摸事件的使用方法和注意事项，侧重于单点触摸事件。
一个非常简单的触摸事件响应示例
在cocos2d-x中Layer是直接继承了触摸代理的类，也就是说它“天生”就带有响应触摸事件的功能. 要想启动Layer的触摸响应功能，仅需要一句代码：setTouchEnabled(true)
下面以hello world示例为基础，添加一下触摸的功能, 非常的简单, 请看代码：
// HelloWorldScene.h
class HelloWorld : public cocos2d::CCLayer
{
public:
virtual bool init();
static cocos2d::CCScene* scene();
CREATE_FUNC(HelloWorld);
};
// HelloWorldScene.cpp
CCScene* HelloWorld::scene()
{
CCScene *scene = CCScene::create();
HelloWorld *layer = HelloWorld::create();
layer->setTouchEnabled(true); // 开启触摸事件响应
scene->addChild(layer);
return scene;
}
bool HelloWorld::init()
{
return CCLayer::init();
}编译运行代码，并且在CCLayer::ccTouchesBegan, CCLayer::ccTouchesMoved, CCLayer::ccTouchesEnded等函数内添加断点，当用鼠标点击或在Layer上面做拖拽的时候，断点就会触发。
重写ccTouchesBegan等函数，实现自定义触摸事件响应逻辑
调用Layer的setTouchEnabled(true)之后，Layer默认开启了标准触摸（多点触摸）模式，触摸事件发生时，它的ccTouchesXXX()系列方法会被调用；
还有第二种模式，叫TargetedTouch（单点触摸）模式，通过调用layer->setTouchMode(kCCTouchesOneByOne)来切换为单点触摸，触摸发生时，Layer的ccTouchXXX()系列方法会被调用, 注意这里跟多点触摸的区别是没有复数的es.
我们对触摸事件感兴趣无非就是为了在发生触摸事件的时候，要自己做一些事情，这些事情就是写在响应函数里的。那么如何实现自定义的响应逻辑呢？
在Layer的ccTouchBegan函数里已经提示我们了，看下面:
bool CCLayer::ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent)
{
if (kScriptTypeNone != m_eScriptType)
{
return excuteScriptTouchHandler(CCTOUCHBEGAN, pTouch) == 0 ? false : true;
}
CC_UNUSED_PARAM(pTouch);
CC_UNUSED_PARAM(pEvent);
CCAssert(false, "Layer#ccTouchBegan override me"); // 重写我！！
return true;
}相信大家自己也能想到，在HelloWorld的Layer里通过重写ccTouchBegan系列函数就能实现自定义触摸事件的响应逻辑了。
我不是Layer，能接收触摸事件吗？
能! 你只需要让自己成为可触摸的(Touchable).
Layer为什么能够响应触摸事件？
触摸事件发生后，为什么是ccTouchesBegan, ccTouchesMoved等函数被调用, 而不是其它函数？
触摸事件的调度过程是典型的观察者模式，和常见的消息分发系统一样，你要是对某个事件感兴趣，那么你就注册为该事件的观察者，待该事件发生，事件分发中心会通知你。你要遵循事件中心的规定，准备好接口，方便事件中心将事件分发给你。
在触摸事件分发过程中，事件中心是CCTouchDispatcher, 你是类似Layer这种观察者（我们姑且命名它为Touchable）， 要准备好的接口由CCTouchDelegate来定义。
第一步，你要接收触摸事件，首先要让自己成为Touchable，这可以通过继承CCTouchDelegate来实现
第二步, 你要成为触摸事件的观察者，需要把自己注册到事件中心，可通过
CCTouchDispatcher::addStandardDelegate或者CCTouchDispatcher::addTargetedDelegate来实现注册过程. 这两个接口只接收Touchable类型的东西，这也是第一步的原因第三步, 重写CCTouchDelegate里的接口，加入自己的触摸响应逻辑代码，准备好接收触摸事件. 使用完及时把自己从事件中心移除掉.
可以通过下面的示例代码来说明这一过程：
// 定义一个Touchable
class Touchable : public cocos2d::CCTouchDelegate //, 其他类... { public: // ..... create()方法等 // 下面八个接口均是从CCTouchDelegate里继承得到，按需要来选择重写. // 可选实现 bool ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent) override {return true;} void ccTouchMoved(CCTouch *pTouch, CCEvent *pEvent) override {} void ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent) override {} void ccTouchCancelled(CCTouch *pTouch, CCEvent *pEvent) override {} // 可选实现 void ccTouchesBegan(CCSet *pTouches, CCEvent *pEvent) override {} void ccTouchesMoved(CCSet *pTouches, CCEvent *pEvent) override {} void ccTouchesEnded(CCSet *pTouches, CCEvent *pEvent) override {} void ccTouchesCancelled(CCSet *pTouches, CCEvent *pEvent) override {} }; // 注册到事件中心CCTouchDispatcher void registerTouchable() { auto touchDispatcher = CCDirector::sharedDirector()->getTouchDispatcher(); // 单点触摸, 第一个参数是Touchable， 第二个整数代表优先级(数字越小优先级越高)， 第三个参数表示是否吞噬触摸事件 touchDispatcher->addTargetedDelegate(Touchable::create(), 0, true); // 多点触摸, 第一个参数是Touchable， 第二个参数是优先级 touchDispatcher->addStandardDelegate(Touchable::create(), 0); } // 移除监听 void removeTouchable() { auto touchDispatcher = CCDirector::sharedDirector()->getTouchDispatcher(); auto touchable = getTouchable(); // 单点触摸 多点触摸都是通过此接口来移除 touchDispatcher->removeDelegate(touchable); }回答上面那两个问题：
Layer为什么能够响应触摸事件？ ： 因为它继承了CCTouchDelegate, 它是Touchable, 并且通过调用setTouchEnabled(true)把自己注册到了事件中心CCTouchDispatcher.(setTouchEnabled只是打开了一个开关，真正的注册过程发生在Layer成为running状态的时候，请查看Layer::onEnter和Layer::registerWithTouchDispatcher).
为什么是ccTouchesBegan等函数得到调用？ 因为它们是事件中心CCTouchDispatcher规定的事件接收接口(查看CCTouchDispatcher::touches方法可以看到对Touchable的回调过程)，它通过CCTouchDelegate来实现这一约束。
后面会有自己实现的Touchable类型例子，这里就不贴示例代码了。
触摸事件分发系统类图
在刚才描述的触摸事件分发过程中，开发者可见的类有：事件分发中心CCTouchDispatcher, 触摸响应代理CCTouchDelegate
要响应触摸事件就继承CCTouchDelegate, 并且在CCTouchDispatcher中注册自己即可。
其实，在触摸事件分发过程中还有一个类很关键，它对逻辑开发者是透明的，它负责触摸事件优先级和是否吞噬事件的控制。它就是CCTouchHandler. 它有两个子类，分别是负责处理标准多点触摸的handler：CCStandardTouchHandler和单点触摸handler：CCTargetedTouchHandler.
CCTouchHandler就像一个适配器，它内部含有一个Touchable, 同时添加了优先级和触摸吞噬控制的功能。
下面的类图给出了触摸事件分发过程中三个主要类之间的关系:
这个过程的重点是CCTouchDispatcher, 它的内部保存两个触摸处理器队列，一个m_pStandardHandlers保存所有注册来的标准触摸处理器；另一个m_pTargetedHandlers保存单点触摸处理器。
CCTouchDispatcher通过遍历两个处理器队列来实现触摸事件分发，通过每个处理器的handler->getDelegate()来取得Touchable(CCTouchDelegate)对象，进而调用ccTouchesBegan等函数。
分发机制
在cocos2d-x 2.x版本中，触摸事件的分发机制是这样的：
1. 优先级不同的情况下，优先级高的代理会最先得到调度，优先级是一个整数，越小意味着优先级越高
2. 优先级相同的情况下，后注册的代理会先得到调度，与元素的显示层级没有关系
这两点可以从CCTouchDispatcher的添加代理函数里得到证明：
来看一下触摸代理的分发过程：
void CCTouchDispatcher::touches(CCSet *pTouches, CCEvent *pEvent, unsigned int uIndex)
{
// ... 此处省略一些代码
// 以单点触摸事件的分发为例
CCTargetedTouchHandler *pHandler = NULL;
CCObject* pObj = NULL;
// 线性顺序遍历代理队列
CCARRAY_FOREACH(m_pTargetedHandlers, pObj)
{
pHandler = (CCTargetedTouchHandler *)(pObj);
if (! pHandler)
{
break;
}
bool bClaimed = false;
if (uIndex == CCTOUCHBEGAN)
{
bClaimed = pHandler->getDelegate()->ccTouchBegan(pTouch, pEvent);
if (bClaimed)
{
pHandler->getClaimedTouches()->addObject(pTouch);
}
} else
if (pHandler->getClaimedTouches()->containsObject(pTouch)) { // moved ended canceled bClaimed = true; switch (sHelper.m_type) { case CCTOUCHMOVED: pHandler->getDelegate()->ccTouchMoved(pTouch, pEvent);
break;
case CCTOUCHENDED:
pHandler->getDelegate()->ccTouchEnded(pTouch, pEvent);
pHandler->getClaimedTouches()->removeObject(pTouch);
break;
case CCTOUCHCANCELLED:
pHandler->getDelegate()->ccTouchCancelled(pTouch, pEvent);
pHandler->getClaimedTouches()->removeObject(pTouch);
break;
}
}
}
// ... 此处省略一些代码
}从上面这段代码可以看到，对于TargetedTouch单点触摸是按照线性顺序来遍历分发的，那么排在队列前面的自然就会先分发
再看一下处理器是怎么排队的：
// pHandler: 要插入到队列里的代理；
// pArray： 现存代理队列；
void CCTouchDispatcher::forceAddHandler(CCTouchHandler *pHandler, CCArray *pArray)
{
// 要插入到代理队列里的下标
unsigned int u = 0;
CCObject* pObj = NULL;
// 遍历队列里现存的代理, 比较优先级
CCARRAY_FOREACH(pArray, pObj)
{
CCTouchHandler *h = (CCTouchHandler *)pObj;
if (h)
{
// 如果新代理的优先级数值比现存的大，那么插入的下标会往后递增.
// (数值越大优先级越低, 也就是说优先级越低，那么下标越往后递增)
// 这里是 <, 而不是 <=, 因此碰到相同优先级的代理，小标不在递增，所以说相同优先级的，后来者，插在前面.
if (h->getPriority() < pHandler->getPriority())
{
++u;
}
if (h->getDelegate() == pHandler->getDelegate())
{
CCAssert(0, "");
return;
}
}
}
// 把新代理插入到下标u处.
pArray->insertObject(pHandler, u);
}可以看到优先级高的会排在前面，优先级相同的，后来者会排在前面。因此，不难总结出上面提到的两条结论。
陷阱！！你以为你小我就摸不到你？
请看下面一个小例子，看看它的结果会让你吃惊吗？
HelloWorldScene.h:
#ifndef __HELLOWORLD_SCENE_H__
#define __HELLOWORLD_SCENE_H__
#include "cocos2d.h"
class HelloWorld : public cocos2d::CCLayer
{
public:
virtual bool init();
static cocos2d::CCScene* scene();
CREATE_FUNC(HelloWorld);
};
// 定义一个Touchable类型，它继承了彩色layer类，方便演示效果。彩色layer是Layer的子类，因此彩色layer本身也是Touchable的
class TouchableLayer : public cocos2d::CCLayerColor
{
public:
static TouchableLayer* create();
bool init();
bool ccTouchBegan(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent) override ;
void ccTouchMoved(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent) override {}
void ccTouchEnded(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent) override {}
void ccTouchCancelled(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent) override {}
};
#endif // __HELLOWORLD_SCENE_H__头文件很简单，在HelloWorldScene下面加了一个TouchableLayer类，用来接收触摸事件. 下面是实现文件：
HelloWorldScene.cpp:
#include "HelloWorldScene.h"
USING_NS_CC;
CCScene* HelloWorld::scene()
{
CCScene *scene = CCScene::create();
HelloWorld *layer = HelloWorld::create();
scene->addChild(layer);
return scene;
}
bool HelloWorld::init()
{
if (!CCLayer::init())
{
return false;
}
// 添加TouchableLayer对象到父Layer。注意：这里仅开启了子layer的touch响应，父Layer并没有开启触摸.
TouchableLayer *layer = TouchableLayer::create();
layer->setTouchEnabled(true);
layer->setTouchMode(kCCTouchesOneByOne); // 单点触摸
addChild(layer);
return true;
}
TouchableLayer* TouchableLayer::create()
{
auto self = new TouchableLayer();
if (self && self->init())
{
self->autorelease();
return self;
}
return nullptr;
}
bool TouchableLayer::init()
{
// 初始化为一个大小为: 100 x 100 的红色不透明layer.
return (CCLayerColor::initWithColor(ccc4(255, 0, 0, 255), 100, 100));
}
// 为了演示简单，仅重写了touchBegan方法，让红色方块原地旋转360度
bool TouchableLayer::ccTouchBegan(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
auto rotate = CCRotateBy::create(0.5, 360);
runAction(rotate);
return false;
}接下来运行代码， 效果如下图所示：
现在请考虑:
点击红色方块，它会旋转吗？
点击屏幕右半部分的黑色区域，红色方块会旋转吗?
第一个问题，相信大家都能答对，它会旋转，因为开启了触摸。
第二个问题呢，我们知道TouchableLayer的contentSize是100 x 100, 那么点击右半部分，肯定已经超出了contentSize, 也就是点击在了TouchableLayer的外面，它还会响应吗？
看效果图，答案是还会旋转！这可能有些出乎我们的预料，因为刚接触触摸事件，很容易把这个小红方块看成一个GUI概念里的按钮，我点在它的外面，它怎么还会响应呢？我刚接触这个地方的时候也很差异，但是你要知道，cocos是个游戏引擎，并不是GUI框架，它主要关心图形的绘制渲染，比GUI框架更加“底层化”，如果要实现一个GUI按钮的效果，那也需要你自己来处理触摸事件，判断点击范围，就是需要自己包装出来一个按钮出来。看看CCMenu对触摸事件的处理你就会明白这一过程了。
总结一下，这个例子要说的就是:
触摸事件的响应是和Touchable对象的大小没关系的，哪怕你只是一个像素点，只要你注册了触摸事件，那么我点击屏幕的任何位置你都会收到响应。(前提是这个触摸事件没有被高优先级处理器吞噬掉)
触摸综合实例
下面的小实例，演示了如何自定义响应触摸事件的类、触摸事件的分发顺序、单点触摸事件的吞噬.
如图所示，一个父Layer中包含了1个小的彩色方块layer，和3只狗狗。(上面两个按钮分别是回测试主页和退出)
Layer和三只狗都注册了触摸事件，注册的时间先后顺序是dog1, dog2, dog3, Layer. 其中dog1, dog2, dog3是从左至右的顺序编号的。
这四个触摸代理注册的优先级只有dog1是-1，拥有最高优先级，dog2, dog3, Layer都是0. 4个代理都指定了swallow为true, 也就是说如果有一个代理处理了一个触摸事件，那么其它优先级低的代理就不会收到这个触摸事件
按照上文所述的事件分发机制(优先级高的在前，相同优先级后注册的在前)可以知道, 它们4个的触摸响应顺序会是： dog1 > Layer > dog3 > dog2
例子中的触摸代码逻辑是，如果触摸点在对应物体内部那么就处理该事件，否则不处理，即在ccTouchBegan()里面返回false.
彩色方块：
点击在内部，并拖拽，会跟随鼠标移动, 且ccTouchBegan中返回true，吞噬掉该事件。
点击在外部，没反应。不吞噬
3只狗：
点击在其内部，会旋转90度，并在ccTouchBegan中返回true，代表处理了该事件，吞噬掉。
否则，点击在外部, 收到touchBegan的消息时，会进行抖动，并在ccTouchBegan里返回false，代表不处理该事件，也不会吞噬。
操作1：触摸空白处
没有点在任何一只狗内，也没有触摸在彩色方块内，因此事件一直向下转发，三只狗均触发touch，发生抖动.
操作2：触摸dog1
触摸在dog1， dog1旋转并吞噬事件，其它2只狗没触发touch.
操作3：触摸彩色方块
根据优先级，dog1先触发事件发生抖动且不吞噬，接着彩色方块触发触摸可以拖动，同时吞噬触摸，dog2, dog3没有触发touch
操作4：触摸dog3
dog1优先级最高总是被触发发生抖动且不吞噬，dog3触发在内部，旋转且吞噬触摸, dog2没有触发touch
操作5：触摸dog2
dog1优先级最高总是被触发发生抖动且不吞噬，dog3触发并抖动不吞噬，dog2触发touch, 旋转，吞噬。
操作6：把彩色方块放在dog1下面，并拖拽
因为触摸点在dog1内部，所以被dog1优先截获触摸并吞噬。彩色方块无法拖拽。dog2, dog3也不会触发touch.
操作6：把彩色方块放在dog2和dog3下面，并拖拽
彩色方块的优先级 > dog3 > dog2, 所以虽然彩色方块显示在dog2和dog3的下面，但是触摸响应是优先于2只狗的，因此可以实现拖拽，且吞噬了触摸事件，dog2和dog3既不会旋转也不会抖动。同时能看到dog1还是能够触发touch，因为它的优先级是最高的
触摸代理的优先级，是可以通过CCTouchDispatcher的setPriority(int nPriority, CCTouchDelegate *pDelegate)接口来动态改变的, 在CCMenu::setHandlerPriority(int newPriority)函数里能看到setPriority使用.
下面是代码的实现
TouchTestPage.h:
#ifndef CPP_DEMO_PAGES_MENU_PAGE_H
#define CPP_DEMO_PAGES_MENU_PAGE_H
// 忽略不认识的包含文件, 是Demo框架里的东西
#include "cocos2d.h"
#include "pages/SuperPage.h"
#include "pages/RootPage.h"
#include "util/StateMachine.h"
#include "LogicDirector.h"
#include "message/Message.h"
// 父Layer
class TouchTestPage
: public SuperPage
, public State<RootPage>
, public cocos2d::CCTouchDelegate
{
public:
CREATE_FUNC(TouchTestPage);
void loadUI() override;
void unloadUI() override;
void onEnterState() override;
void onExecuteState() override;
void onExitState() override;
virtual bool ccTouchBegan(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent);
virtual void ccTouchMoved(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent);
virtual void ccTouchEnded(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent);
virtual void ccTouchCancelled(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent);
protected:
TouchTestPage();
~TouchTestPage();
private:
bool isTouchingColorLayer_;
cocos2d::CCPoint touchBeginPoint_;
};
// 狗狗类，它是Touchable, 同时也是精灵
class Dog : public cocos2d::CCTouchDelegate, public cocos2d::CCSprite
{
public:
static Dog* create(const char *name);
bool initWithString(const char *name);
cocos2d::CCRect rect() const;
virtual bool ccTouchBegan(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent);
virtual void ccTouchMoved(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent);
virtual void ccTouchEnded(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent);
virtual void ccTouchCancelled(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent);
protected:
Dog();
~Dog();
};
#endifTouchTestPage.cpp:
#include "pages/TouchTestPage.h"
#include "PageManager.h"
#include "util/StringUtil.h"
USING_NS_CC;
bool touchTestPageRegistered = PageManager::getInstance()->registerPage(
"TouchTestPage", TouchTestPage::create());
void TouchTestPage::loadUI()
{
// 父Layer开启touch，它注册到CCTouchDispatcher是在loadUI执行完毕，因此父Layer的注册顺序是最后一个.
setTouchEnabled(true);
setTouchMode(kCCTouchesOneByOne);
auto winSize = CocosWindow::size();
auto origin = CocosWindow::origin();
CCSize colorLayerSize(winSize.width / 4, winSize.height / 4);
auto colorLayer = CCLayerColor::create(CocosUtil::randomC4b());
colorLayer->setContentSize(colorLayerSize);
colorLayer->setPosition(CocosWindow::center() -
CCPoint(colorLayerSize.width / 2, colorLayerSize.height / 2));
ADD_CHILD(colorLayer);
// 从左到右，三只狗
for ( int i = 1; i < 4; ++i )
{
auto dog = Dog::create("DemoIcon/dog_160.png");
CCAssert(dog, "");
dog->setTag(i);
auto dogSize = dog->getContentSize();
dog->setPosition(origin +
CCPoint(dogSize.width / 2 + ( i - 1 ) * dogSize.width, dogSize.height / 2));
CocosUtil::markCorners(dog);
// dog1, dog2, dog3.
addChild(dog, "dog" + StringUtil::toString(i));
}
// 注册三只狗狗的触摸事件，注意，三者均响应单点触摸，优先级分别为为-1, 0, 0, 均吞噬触摸
auto touchDispatcher = CCDirector::sharedDirector()->getTouchDispatcher();
touchDispatcher->addTargetedDelegate(getChild<Dog>("dog1"), -1, true);
touchDispatcher->addTargetedDelegate(getChild<Dog>("dog2"), 0, true);
touchDispatcher->addTargetedDelegate(getChild<Dog>("dog3"), 0, true);
}
void TouchTestPage::unloadUI()
{
// 移除触摸监听
auto touchDispatcher = CCDirector::sharedDirector()->getTouchDispatcher();
touchDispatcher->removeDelegate(getChild<Dog>("dog1"));
touchDispatcher->removeDelegate(getChild<Dog>("dog2"));
touchDispatcher->removeDelegate(getChild<Dog>("dog3"));
removeAllChildren();
}
void TouchTestPage::onEnterState()
{
loadUI();
}
void TouchTestPage::onExecuteState()
{}
void TouchTestPage::onExitState()
{
unloadUI();
}
TouchTestPage::TouchTestPage()
: isTouchingColorLayer_(false)
, touchBeginPoint_(CCPointZero)
{}
TouchTestPage::~TouchTestPage()
{}
// 父Layer的触摸响应函数
bool TouchTestPage::ccTouchBegan(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
auto pos = pTouch->getLocation();
CCLOG("(%.2f, %.2f)", pos.x, pos.y);
auto colorLayer = getChild<CCLayerColor>("colorLayer");
if ( colorLayer )
{
auto posInLayer = colorLayer->convertToNodeSpace(pos) * colorLayer->getScale();
CCLOG("in color layer: (%.2f, %.2f)", posInLayer.x, posInLayer.y);
// 判断是否点击在彩色方块内部，如果在内部就吞噬触摸
CCRect rect;
rect.origin = CCPointZero;
rect.size = colorLayer->getContentSize();
if ( rect.containsPoint(posInLayer) )
{
touchBeginPoint_ = pTouch->getLocation();
isTouchingColorLayer_ = true;
CCLOG("touch swallowed by color layer");
return true; // 吞噬掉触摸事件，比父Layer优先级低的dog3， dog2将不会触发此次触摸
}
}
return false;
}
void TouchTestPage::ccTouchMoved(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
if ( isTouchingColorLayer_ )
{
auto colorLayer = getChild<CCLayerColor>("colorLayer");
if ( colorLayer )
{
auto posDiff = pTouch->getLocation() - pTouch->getPreviousLocation();
colorLayer->setPosition(colorLayer->getPosition() + posDiff);
}
}
}
void TouchTestPage::ccTouchEnded(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
isTouchingColorLayer_ = false;
}
void TouchTestPage::ccTouchCancelled(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
isTouchingColorLayer_ = false;
}
//----------------------------------- Dog Imp ---------------------------------
Dog::~Dog()
{}
Dog::Dog()
{}
Dog* Dog::create(const char *name)
{
auto self = new Dog();
if ( self && self->initWithString(name) )
{
self->autorelease();
return self;
}
CC_SAFE_DELETE(self);
return nullptr;
}
bool Dog::initWithString(const char *name)
{
if ( CCSprite::initWithFile(name) )
{
return true;
}
return false;
}
cocos2d::CCRect Dog::rect() const
{
CCRect rect;
rect.origin = CCPointZero;
rect.size = getContentSize();
return rect;
}
// 狗狗的触摸响应函数
bool Dog::ccTouchBegan(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
auto pos = pTouch->getLocation();
CCLOG("(%.2f, %.2f)", pos.x, pos.y);
CCLOG("in dog%d: (%.2f, %.2f)\n", getTag(),
convertToNodeSpace(pos).x * getScaleX(), getScaleY()*convertToNodeSpace(pos).y);
// 判断是否点在狗狗内部, 是，则旋转狗狗，同时吞噬本次触摸
if ( rect().containsPoint(convertToNodeSpace(pos)) )
{
auto act = CCRotateBy::create(0.5, 90);
runAction(act);
CCLOG("touch swallowed by dog%d\n", getTag());
return true;
}
else
{
// 不是点在内部，仅仅旋转狗狗
auto shake = CCShaky3D::create(0.5, CCSize(20, 20), 5, false);
runAction(shake);
}
return false;
}
void Dog::ccTouchMoved(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{}
void Dog::ccTouchEnded(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{}
void Dog::ccTouchCancelled(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{}注意：
对某一个代理来说，比如dog1：
ccTouchBegan() { return true;} 表示dog1对此次触摸感兴趣，会继续监听touchMoved, touchEnded等，即会继续回调到ccTouchMoved等.
ccTouchBegan() {return false;} 表示dog1对此次触摸不感兴趣， 不会继续回调到ccTouchMoved等函数。
对不同代理之间来说，比如dog1和dog3：
如果dog1在CCTouchDispatcher::addTargetedDelegate(…)里面指定了，swallow为true，且在dog1的ccTouchBegan返回了true，那么这个触摸事件就会被dog1吞噬掉，dog3及比dog3更低优先级的代理都不会收到触摸事件。
否则，如果dog1在addTargetedDelegate()没有指定swallow为true， 或者在ccTouchBegan里返回了false，那么触摸事件就会继续像下分发到dog3.
点击会变大的菜单按钮
点击缩放功能的菜单按钮放在下一篇说吧，这一篇已经很长了。
ccTouchCancelled什么时候会被调用？
在win32上没有试验出来，网上说是在非正常的触摸结束情况下会触发，比如在触摸过程中突然来电话。通常情况下，ccTouchCancelled函数里的处理方式和ccTouchEnded(正常触摸结束)保持一致就好。
总结
本文回顾了cocos中单点触摸的用法和触摸事件分发机制、优先级控制等内容. 关于多点触摸没怎么用，后面用了再总结。
在触摸事件当中，还有一些其他常见问题，比如如何定制自己的Menu实现点击缩放节省美术资源、点击穿透问题、如何在拖拽Scrollview上的按钮时候也能让Scrollview滚动等。这些问题将会在后面的文章中总结。
source codes
源代码仓库地址: cocos2d-x-cpp-demos-2.x, 是本人写的一个小型Demo框架，方便添加测试代码或者用来开发游戏，如果觉得有用请帮忙点个Star，谢谢
作者水平有限，对相关知识的理解和总结难免有错误，还望给予指正，非常感谢！
欢迎访问github博客，与本站同步更新