开发者社区> 微个日光日> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Cocos2d-x 3.0 新特性体验-触摸事件处理机制

简介: <p style="margin-top:0px; margin-bottom:0px; padding-top:0px; padding-bottom:0px; font-family:Arial; font-size:14px; line-height:26px"> <span style="font-family:'Microsoft YaHei'">在cocos2d-x 2.x版
+关注继续查看

在cocos2d-x 2.x版本中,相信大家都抱怨过其中的触摸机制;在3.0版本中,采用了全新的触摸事件处理机制。

在官方的文档中:点击打开链接  这篇文章有对新的事件分发机制的介绍。

下面,我将通过引擎中自带的sample来探索一下这个新的触摸事件处理机制。

注:例子来自Test cpp/NewEventDispatcherTest

一、例子1


(1)创建三个精灵

  1. auto sprite1 = Sprite::create("Images/CyanSquare.png");  
  2.     sprite1->setPosition(origin+Point(size.width/2, size.height/2) + Point(-80, 80));  
  3.     addChild(sprite1, 10); //其中 10 表示 zOreder  
  4.       
  5.     auto sprite2 = Sprite::create("Images/MagentaSquare.png");  
  6.     sprite2->setPosition(origin+Point(size.width/2, size.height/2));  
  7.     addChild(sprite2, 20);  
  8.       
  9.     auto sprite3 = Sprite::create("Images/YellowSquare.png");  
  10.     sprite3->setPosition(Point(0, 0));  
  11.     sprite2->addChild(sprite3, 1); //注意 sprite3 是添加到 sprite2 上的  

(2)创建一个单点触摸事件监听器,处理触摸事件逻辑

  1. // Make sprite1 touchable  
  2. auto listener1 = EventListenerTouchOneByOne::create();//创建一个触摸监听  
  3. listener1->setSwallowTouches(true); //设置是否想下传递触摸  
  4.   
  5. //通过 lambda 表达式 直接实现触摸事件的回掉方法  
  6. listener1->onTouchBegan = [](Touch* touch, Event* event){  
  7.     auto target = static_cast<Sprite*>(event->getCurrentTarget());  
  8.       
  9.     Point locationInNode = target->convertToNodeSpace(touch->getLocation());  
  10.     Size s = target->getContentSize();  
  11.     Rect rect = Rect(0, 0, s.width, s.height);  
  12.       
  13.     if (rect.containsPoint(locationInNode))  
  14.     {  
  15.         log("sprite began... x = %f, y = %f", locationInNode.x, locationInNode.y);  
  16.         target->setOpacity(180);  
  17.         return true;  
  18.     }  
  19.     return false;  
  20. };  
  21.   
  22. listener1->onTouchMoved = [](Touch* touch, Event* event){  
  23.     auto target = static_cast<Sprite*>(event->getCurrentTarget());  
  24.     target->setPosition(target->getPosition() + touch->getDelta());  
  25. };  
  26.   
  27. listener1->onTouchEnded = [=](Touch* touch, Event* event){  
  28.     auto target = static_cast<Sprite*>(event->getCurrentTarget());  
  29.     log("sprite onTouchesEnded.. ");  
  30.     target->setOpacity(255);  
  31.     if (target == sprite2)  
  32.     {  
  33.         sprite1->setZOrder(100);  
  34.     }  
  35.     else if(target == sprite1)  
  36.     {  
  37.         sprite1->setZOrder(0);  
  38.     }  
  39. };  
  40.   
  41. _eventDispatcher->addEventListenerWithSceneGraphPriority(listener1, sprite1);  
  42. _eventDispatcher->addEventListenerWithSceneGraphPriority(listener1->clone(), sprite2);  
  43. _eventDispatcher->addEventListenerWithSceneGraphPriority(listener1->clone(), sprite3);  

①其中的触摸监听类型为:EventListenerTouchOneByOne 表示的是单点触摸;而EventListenerTouchAllAtOnce 表示的就是多点触摸。

  1. class EventListenerTouchOneByOne : public EventListener  
  2. {  
  3. public:  
  4.     static const std::string LISTENER_ID;  
  5.       
  6.     static EventListenerTouchOneByOne* create();  
  7.       
  8.     virtual ~EventListenerTouchOneByOne();  
  9.       
  10.     void setSwallowTouches(bool needSwallow);  
  11.       
  12.     /// Overrides  
  13.     virtual EventListenerTouchOneByOne* clone() override;  
  14.     virtual bool checkAvailable() override;  
  15.     //  
  16.   
  17. public:  
  18.     std::function<bool(Touch*, Event*)> onTouchBegan;  
  19.     std::function<void(Touch*, Event*)> onTouchMoved;  
  20.     std::function<void(Touch*, Event*)> onTouchEnded;  
  21.     std::function<void(Touch*, Event*)> onTouchCancelled;  
  22.       
  23. private:  
  24.     EventListenerTouchOneByOne();  
  25.     bool init();  
  26.       
  27.     std::vector<Touch*> _claimedTouches;  
  28.     bool _needSwallow;  
  29.       
  30.     friend class EventDispatcher;  
  31. };  
  32.   
  33.   
  34. class EventListenerTouchAllAtOnce : public EventListener  
  35. {  
  36. public:  
  37.     static const std::string LISTENER_ID;  
  38.       
  39.     static EventListenerTouchAllAtOnce* create();  
  40.     virtual ~EventListenerTouchAllAtOnce();  
  41.       
  42.     /// Overrides  
  43.     virtual EventListenerTouchAllAtOnce* clone() override;  
  44.     virtual bool checkAvailable() override;  
  45.     //  
  46. public:  
  47.     std::function<void(const std::vector<Touch*>&, Event*)> onTouchesBegan;  
  48.     std::function<void(const std::vector<Touch*>&, Event*)> onTouchesMoved;  
  49.     std::function<void(const std::vector<Touch*>&, Event*)> onTouchesEnded;  
  50.     std::function<void(const std::vector<Touch*>&, Event*)> onTouchesCancelled;  
  51.       
  52. private:  
  53.     EventListenerTouchAllAtOnce();  
  54.     bool init();  
  55. private:  
  56.       
  57.     friend class EventDispatcher;  
  58. };  
看起来很是熟悉吧,和cocos2dx 2.x 版本中的 target touch 和 standard touch 差不多吧!只是使用的形式不太一样罢了。还有在3.0版本中,不需要注册触摸事件代理delegate了。


 _eventDispatcher

事件监听器包含以下几种:

  • 触摸事件 (EventListenerTouch)
  • 键盘响应事件 (EventListenerKeyboard)
  • 加速记录事件 (EventListenerAcceleration)
  • 鼠标响应事件 (EventListenerMouse)
  • 自定义事件 (EventListenerCustom)

以上事件监听器统一由 _eventDispatcher 来进行管理。

_eventDispatcher 是 Node 的属性,通过它管理当前节点(如 场景 、层、精灵等 )的所有事件分发情况。但是它本身是一个单例模式值的引用,在 Node 构造函数中,通过 "Director::getInstance()->getEventDispatcher();" 获取,有了这个属性,我们能更为方便的调用。

有两种方式将 事件监听器 listener1 添加到 事件调度器_eventDispatcher 中:

  1. void EventDispatcher::addEventListenerWithSceneGraphPriority(EventListener* listener, Node* node)  
  2. void EventDispatcher::addEventListenerWithFixedPriority(EventListener* listener, int fixedPriority)  
看看这两种方式的实现代码:

  1. void EventDispatcher::addEventListenerWithSceneGraphPriority(EventListener* listener, Node* node)  
  2. {  
  3.     CCASSERT(listener && node, "Invalid parameters.");  
  4.     CCASSERT(!listener->isRegistered(), "The listener has been registered.");  
  5.       
  6.     if (!listener->checkAvailable())  
  7.         return;  
  8.       
  9.     listener->setSceneGraphPriority(node);  
  10.     listener->setFixedPriority(0);  
  11.     listener->setRegistered(true);  
  12.       
  13.     addEventListener(listener);  
  14. }  
  15.   
  16. void EventDispatcher::addEventListenerWithFixedPriority(EventListener* listener, int fixedPriority)  
  17. {  
  18.     CCASSERT(listener, "Invalid parameters.");  
  19.     CCASSERT(!listener->isRegistered(), "The listener has been registered.");  
  20.     CCASSERT(fixedPriority != 0, "0 priority is forbidden for fixed priority since it's used for scene graph based priority.");  
  21.       
  22.     if (!listener->checkAvailable())  
  23.         return;  
  24.       
  25.     listener->setSceneGraphPriority(nullptr);  
  26.     listener->setFixedPriority(fixedPriority);  
  27.     listener->setRegistered(true);  
  28.     listener->setPaused(false);  
  29.   
  30.     addEventListener(listener);  
  31. }  

从中我们可以知道: 其中的 addEventListenerWithSceneGraphPriority 的事件监听器优先级是 0 ;而且在 addEventListenerWithFixedPriority 中的事件监听器的优先级不可以设置为 0,因为这个是保留给 SceneGraphPriority 使用的。

注意:(1) 这里当我们再次使用 listener1 的时候,需要使用 clone() 方法创建一个新的克隆,因为在使用 addEventListenerWithSceneGraphPriority 或者 addEventListenerWithFixedPriority 方法时,会对当前使用的事件监听器添加一个已注册的标记,这使得它不能够被添加多次。

看看clone()方法的代码:

  1. EventListenerTouchOneByOne* EventListenerTouchOneByOne::clone()  
  2. {  
  3.     auto ret = new EventListenerTouchOneByOne();  
  4.     if (ret && ret->init())  
  5.     {  
  6.         ret->autorelease();  
  7.           
  8.         ret->onTouchBegan = onTouchBegan;  
  9.         ret->onTouchMoved = onTouchMoved;  
  10.         ret->onTouchEnded = onTouchEnded;  
  11.         ret->onTouchCancelled = onTouchCancelled;  
  12.           
  13.         ret->_claimedTouches = _claimedTouches;  
  14.         ret->_needSwallow = _needSwallow;  
  15.     }  
  16.     else  
  17.     {  
  18.         CC_SAFE_DELETE(ret);  
  19.     }  
  20.     return ret;  
  21. }  

(2)另外,有一点非常重要,FixedPriority listener添加完之后需要手动remove,而SceneGraphPriority listener是跟node绑定的,在node的析构函数中会被移除。

  1. _eventDispatcher->cleanTarget(this);  
  2.    CC_SAFE_RELEASE(_eventDispatcher);  


二、例子2

在上面的例子中,使用的是 addEventListenerWithSceneGraphPriority 添加触摸监听器,也就是单点触摸。其结点的触摸优先级都是相同的 0 。那么上层的结点 是比 下层的结点 先处理触摸事件的。

下面看看如何使用 addEventListenerWithFixedPriority 自定义结点的触摸优先级。


(1)首先自定义精灵,其中可以设置精灵接受触摸的优先级。

  1. class TouchableSpriteWithFixedPriority : public Sprite  
  2. {  
  3. public:  
  4.   
  5.     CREATE_FUNC(TouchableSpriteWithFixedPriority);  
  6.       
  7.     TouchableSpriteWithFixedPriority()  
  8.     : _listener(nullptr)  
  9.     , _fixedPriority(0)  
  10.     , _useNodePriority(false)  
  11.     {  
  12.     }  
  13.       
  14.     void setPriority(int fixedPriority) { _fixedPriority = fixedPriority; _useNodePriority = false; };  
  15.     void setPriorityWithThis(bool useNodePriority) { _useNodePriority = useNodePriority; _fixedPriority = true; }  
  16.       
  17.     void onEnter() override  
  18.     {  
  19.         Sprite::onEnter();  
  20.           
  21.         auto listener = EventListenerTouchOneByOne::create();  
  22.         listener->setSwallowTouches(true);  
  23.           
  24.         listener->onTouchBegan = [=](Touch* touch, Event* event){  
  25.               
  26.             Point locationInNode = this->convertToNodeSpace(touch->getLocation());  
  27.             Size s = this->getContentSize();  
  28.             Rect rect = Rect(0, 0, s.width, s.height);  
  29.               
  30.             if (rect.containsPoint(locationInNode))  
  31.             {  
  32.                 this->setColor(Color3B::RED);  
  33.                 return true;  
  34.             }  
  35.             return false;  
  36.         };  
  37.           
  38.         listener->onTouchMoved = [=](Touch* touch, Event* event){  
  39.             //this->setPosition(this->getPosition() + touch->getDelta());  
  40.         };  
  41.           
  42.         listener->onTouchEnded = [=](Touch* touch, Event* event){  
  43.             this->setColor(Color3B::WHITE);  
  44.         };  
  45.           
  46.         if (_useNodePriority)  
  47.         {  
  48.             _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);  
  49.         }  
  50.         else  
  51.         {  
  52.             _eventDispatcher->addEventListenerWithFixedPriority(listener, _fixedPriority);  
  53.         }  
  54.         _listener = listener;  
  55.     }  
  56.       
  57.     void onExit() override  
  58.     {  
  59.         _eventDispatcher->removeEventListener(_listener);  
  60.           
  61.         Sprite::onExit();  
  62.     }  
  63.   
  64. private:  
  65.     EventListener* _listener;  
  66.     int _fixedPriority;  
  67.     bool _useNodePriority;  
  68. };  

(2)分别创建三个精灵,可以自定义设置每一个精灵的触摸优先级。注意:优先级值小的,接受触摸优先。

  1. auto sprite1 = TouchableSpriteWithFixedPriority::create();  
  2.     sprite1->setTexture("Images/CyanSquare.png");  
  3.     sprite1->setPriority(30);  
  4.     sprite1->setPosition(origin+Point(size.width/2, size.height/2) + Point(-80, 40));  
  5.     addChild(sprite1, 10);  
  6.       
  7.     auto sprite2 = TouchableSpriteWithFixedPriority::create();  
  8.     sprite2->setTexture("Images/MagentaSquare.png");  
  9.     sprite2->setPriority(20);  
  10.     sprite2->setPosition(origin+Point(size.width/2, size.height/2));  
  11.     addChild(sprite2, 20);  
  12.       
  13.     auto sprite3 = TouchableSpriteWithFixedPriority::create();  
  14.     sprite3->setTexture("Images/YellowSquare.png");  
  15.     sprite3->setPriority(10);  
  16.     sprite3->setPosition(Point(0, 0));  
  17.     sprite2->addChild(sprite3, 1);  


三、删除触摸监听器的方法:
  1. /** Remove a listener 
  2.   *  @param listener The specified event listener which needs to be removed. 
  3.   */  
  4.  void removeEventListener(EventListener* listener);  
  5.   
  6.  /** Removes all listeners with the same event listener type */  
  7.  void removeEventListeners(EventListener::Type listenerType);  

前者只是删除某一个事件监听器,而后者是删除某一类事件监听器(使用了 clone 克隆)

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
文章
问答
文章排行榜
最热
最新
相关电子书
更多
React-Native 在iOS上的性能优化方案
立即下载
H5动画在移动平台上的性能优化实践
立即下载
360°全景视频播放器的实现原理
立即下载