【Cocos2d-x 3.x】 事件处理机制源码分析

在游戏中,触摸是最基本的,必不可少的。Cocos2d-x 3.x中定义了一系列事件,同时也定义了负责监听这些事件的监听器,另外,cocos定义了事件分发类,用来将事件派发出去以便可以实现相应的事件。

触摸事件

Event

Cocos2d-x 3.x定义了事件基类Event,基于Event,引擎派生出几种事件:

    enum class Type
{
TOUCH, // 触摸事件
KEYBOARD, // 键盘事件
ACCELERATION, // 加速度事件
MOUSE,// 鼠标事件
FOCUS,// 焦点事件
CUSTOM // 自定义事件
};

EventTouch

EventTouch是触摸事件中非常重要的一类事件,它定义了四种touch操作:

enum class EventCode
{
BEGAN,
MOVED,
ENDED,
CANCELLED
};

它还定义了一个 static int值,表示最大的触摸点数为15点:

static const int MAX_TOUCHES = 15;

事件监听器

EventListener

EventListener是事件监听器的基类,派生出的监听器对应各种触摸事件:

enum class Type
{
UNKNOWN,
TOUCH_ONE_BY_ONE,
TOUCH_ALL_AT_ONCE,
KEYBOARD,
MOUSE,
ACCELERATION,
FOCUS,
CUSTOM
};
 重要的成员变量:
1.onEvent,是绑定于该Listener的callback function,该func的声明使用了c++11
2.type与Event类似,增加一个Unknown的属性。
3.isRegistered变量非常重要,如果他没有被注册,则他的事件不会触发。
4.优先级代表了响应一个事件时的顺序,该值越低,越先响应。
5.node 代表了与该listener相关的node,用于 scene graph类的事件响应,具体的在Dispatcher里面有进行介绍。
6.ListenerID,这是该类型事件的标识符。除了EventCustomListener的ListerID是与name相关的,其余的ListenerID都是固定的,用于标识该类EventListener。

另外:

1.一个Listener想接收事件必须是enabled true 并且 paused false。

2.值得注意的是,pause的变量专门是为了scenGraph类的事件存在的(后续有说明),而且一个Node的onEnter和onExit 事件会影响到与Node相关的该类事件的pause状态。

EventListenerTouchOneByOne

单点触摸方式,实现它时需要重写父类的四种触摸方式的函数:

    /// Overrides
virtual EventListenerTouchOneByOne* clone() override;
virtual bool checkAvailable() override;
// public:
std::function<bool(Touch*, Event*)> onTouchBegan;
std::function<void(Touch*, Event*)> onTouchMoved;
std::function<void(Touch*, Event*)> onTouchEnded;
std::function<void(Touch*, Event*)> onTouchCancelled;

另外, 单点触摸当onTouchBegan函数不是nullptr时,它就是可用的:

bool EventListenerTouchOneByOne::checkAvailable()
{
// EventDispatcher will use the return value of 'onTouchBegan' to determine whether to pass following 'move', 'end'
// message to 'EventListenerTouchOneByOne' or not. So 'onTouchBegan' needs to be set.
if (onTouchBegan == nullptr)
{
CCASSERT(false, "Invalid EventListenerTouchOneByOne!");
return false;
} return true;
}

还有,EventListenerTouchOneByOne可以设置吞噬。

EventListenerAllAtOnce

多点触摸,当四种触摸方式函数都不为nullptr时,EventListenerAllAtOnce时可用的:

bool EventListenerTouchAllAtOnce::checkAvailable()
{
if (onTouchesBegan == nullptr && onTouchesMoved == nullptr
&& onTouchesEnded == nullptr && onTouchesCancelled == nullptr)
{
CCASSERT(false, "Invalid EventListenerTouchAllAtOnce!");
return false;
} return true;
}

EventListenerCustom

EventListenerID是根据独特的Name进行命名的,值得注意的是请确保你的name是具有唯一性的,否在在DispatchCustomEvent时会有问题。

事件分发器EventDispatcher

首先,先看一个内嵌类EventListenerVector:

class EventListenerVector
{
public:
EventListenerVector();
~EventListenerVector();
size_t size() const;
bool empty() const; void push_back(EventListener* item);
void clearSceneGraphListeners();
void clearFixedListeners();
void clear(); inline std::vector<EventListener*>* getFixedPriorityListeners() const { return _fixedListeners; };
inline std::vector<EventListener*>* getSceneGraphPriorityListeners() const { return _sceneGraphListeners; };
inline ssize_t getGt0Index() const { return _gt0Index; };
inline void setGt0Index(ssize_t index) { _gt0Index = index; };
private:
std::vector<EventListener*>* _fixedListeners;
std::vector<EventListener*>* _sceneGraphListeners;
ssize_t _gt0Index;
};
fixedListeners和sceneGraphListeners是两个非常非常重要的变量,这是两个截然不同的Listener列表。
        1. sceneGraph类型的事件,是与当前正在运行的scene下node相关的事件,也就是说一个事件(比如说触摸事件),需要按照一定的响应序列,依次对这些Node进行事件响应,所以该类型的事件都会绑定一个与此相关联的node,并且响应顺序是与node在scene下的zorder相关的。该类型下的事件优先级统一为0.
        2. fixed类型的事件相对就比较简单了,但是有一个限制就是其优先级不能为0.

在EventDispatcher的成员变量中有一个map :std::unordered_map<EventListener::ListenerID, EventListenerVector*> _listenerMap;  一种ListenerID对应了一个Vector。

EventDispatcher有三种添加事件的方式:addEventListenerWithSceneGraphPriority、addEventListenerWithFixedPriority和addCustomEventListener

void EventDispatcher::addEventListenerWithSceneGraphPriority(EventListener* listener, Node* node)
{
CCASSERT(listener && node, "Invalid parameters.");
CCASSERT(!listener->isRegistered(), "The listener has been registered."); //检查Listener可用性
if (!listener->checkAvailable())
return;
//设置listener相关属性
listener->setAssociatedNode(node);
listener->setFixedPriority(0);
listener->setRegistered(true); addEventListener(listener);
}

addEventListenerWithSceneGraphPriority将监听器和node节点关联起来,addEventListenerWithSceneGraphPriority不需要手动移除监听器,因为在node的析构函数中会自动移除的,还有,addEventListenerWithSceneGraphPriority设置监听器的优先权为0。优先权值越小,越先派发。

void EventDispatcher::addEventListenerWithFixedPriority(EventListener* listener, int fixedPriority)
{
CCASSERT(listener, "Invalid parameters.");
//一个事件只能被注册一次
CCASSERT(!listener->isRegistered(), "The listener has been registered.");
//Fixed类型的事件优先级不能是0
CCASSERT(fixedPriority != 0, "0 priority is forbidden for fixed priority since it's used for scene graph based priority."); //检查可用性
if (!listener->checkAvailable())
return; //设置关联属性
listener->setAssociatedNode(nullptr);
listener->setFixedPriority(fixedPriority);
listener->setRegistered(true);
listener->setPaused(false); addEventListener(listener);
}

addEventListenerWithFixedPriority不能将监听器的优先权设置为0。

EventListenerCustom* EventDispatcher::addCustomEventListener(const std::string &eventName, const std::function<void(EventCustom*)>& callback)
{
//custom类的事件添加是通过eventName 和 eventcallBack来进行添加的
EventListenerCustom *listener = EventListenerCustom::create(eventName, callback); //custom的事件优先级被默认为1
addEventListenerWithFixedPriority(listener, 1); return listener;
}

addCustomEventListener通过eventName和eventcallBack来添加的,自定以监听器优先权默认为1.。

这三种方法都使用了addEventListener函数来进行实际操作:

void EventDispatcher::addEventListener(EventListener* listener)
{
//如果当前Dispatcher正在进行事件Dispatch,则放到toAddList中。
if (_inDispatch == 0)
{
forceAddEventListener(listener);
}
else
{
// std::vector
_toAddedListeners.push_back(listener);
} listener->retain();
}

如果当前派发器没有进行事件的派发,则强制进行,并添加该事件监听器,该操作由forceAddEventListener来完成:

void EventDispatcher::forceAddEventListener(EventListener* listener)
{
EventListenerVector* listeners = nullptr;
EventListener::ListenerID listenerID = listener->getListenerID(); //找到该类eventlistener的vector,此处的vector是EventVector
auto itr = _listenerMap.find(listenerID);
//如果没有找到,则需要向map中添加一个pair
if (itr == _listenerMap.end())
{ listeners = new EventListenerVector();
_listenerMap.insert(std::make_pair(listenerID, listeners));
}
else
{
listeners = itr->second;
}
//将该类别listenerpush_back进去(这个函数调用的是EventVector的pushback哦)
listeners->push_back(listener); //如果优先级是0,则设置为graph。
if (listener->getFixedPriority() == 0)
{
//设置该listenerID的DirtyFlag
//(setDirty函数可以这样理解,每个ListenerID都有特定的dirtyFlag,每次进行add操作后,都要更新该ID的flag)
setDirty(listenerID, DirtyFlag::SCENE_GRAPH_PRIORITY); //如果是sceneGraph类的事件,则需要处理两个方面:
//1.将node 与event 关联
//2.如果该node是运行中的,则需要恢复其事件(因为默认的sceneGraph listener的状态时pause)
//增加该listener与node的关联
auto node = listener->getAssociatedNode();
CCASSERT(node != nullptr, "Invalid scene graph priority!"); associateNodeAndEventListener(node, listener); //恢复node的运行状态
if (node->isRunning())
{
resumeEventListenersForTarget(node);
}
}
else
{
setDirty(listenerID, DirtyFlag::FIXED_PRIORITY);
}
}

如果优先级是0,则还有将监听器与node关联起来的操作:

void EventDispatcher::associateNodeAndEventListener(Node* node, EventListener* listener)
{
//将listener与node关联,先从map中找到与该node相关的listener vector
std::vector<EventListener*>* listeners = nullptr;
auto found = _nodeListenersMap.find(node);
if (found != _nodeListenersMap.end())
{
listeners = found->second;
}
else
{
listeners = new std::vector<EventListener*>();
_nodeListenersMap.insert(std::make_pair(node, listeners));
}
//vector内添加该listener,这里的vector 是std::vector
listeners->push_back(listener);
}

DispatchEvent(核心)

touch事件和其他事件的分发是不同的:

void EventDispatcher::dispatchEvent(Event* event)
{
if (!_isEnabled)
return; //为dirtyNodesVector中的dirtyNode更新Scene Flag。
updateDirtyFlagForSceneGraph(); DispatchGuard guard(_inDispatch); //特殊touch事件,转到特殊的touch事件处理
if (event->getType() == Event::Type::TOUCH)
{
dispatchTouchEvent(static_cast<EventTouch*>(event));
return;
} //根据事件的类型,获取事件的ID
auto listenerID = __getListenerID(event); //根据事件ID,将该类事件进行排序(先响应谁)
sortEventListeners(listenerID); auto iter = _listenerMap.find(listenerID);
if (iter != _listenerMap.end())
{
auto listeners = iter->second;
//该类事件的lambda函数
auto onEvent = [&event](EventListener* listener) -> bool{
//设置event的target
event->setCurrentTarget(listener->getAssociatedNode());
//调用响应函数
listener->_onEvent(event);
//返回是否已经停止
return event->isStopped();
}; //将该类事件的listeners 和 该类事件的 lambda函数传给该函数
dispatchEventToListeners(listeners, onEvent);
} //更新该事件相关的listener
updateListeners(event);
}

先看看touch事件的分发机制:

void EventDispatcher::dispatchTouchEvent(EventTouch* event)
{
//先将EventListeners排序
sortEventListeners(EventListenerTouchOneByOne::LISTENER_ID);
sortEventListeners(EventListenerTouchAllAtOnce::LISTENER_ID); auto oneByOneListeners = getListeners(EventListenerTouchOneByOne::LISTENER_ID);
auto allAtOnceListeners = getListeners(EventListenerTouchAllAtOnce::LISTENER_ID); // If there aren't any touch listeners, return directly.
if (nullptr == oneByOneListeners && nullptr == allAtOnceListeners)
return; //mutableTouches是用来处理allAtOnce的
bool isNeedsMutableSet = (oneByOneListeners && allAtOnceListeners); //这些touch都来自该事件
const std::vector<Touch*>& originalTouches = event->getTouches();
std::vector<Touch*> mutableTouches(originalTouches.size());
std::copy(originalTouches.begin(), originalTouches.end(), mutableTouches.begin()); //
// process the target handlers 1st
//
if (oneByOneListeners)
{
auto mutableTouchesIter = mutableTouches.begin();
auto touchesIter = originalTouches.begin();
//遍历touches,每一个touch都来自于同一个事件
for (; touchesIter != originalTouches.end(); ++touchesIter)
{
bool isSwallowed = false; //事件处理的lambda函数
auto onTouchEvent = [&](EventListener* l) -> bool { // Return true to break
EventListenerTouchOneByOne* listener = static_cast<EventListenerTouchOneByOne*>(l); // Skip if the listener was removed.
if (!listener->_isRegistered)
return false; event->setCurrentTarget(listener->_node);
//claimed代表该listener是否接收了该touch(Began返回true or false)
bool isClaimed = false;
std::vector<Touch*>::iterator removedIter; //根据eventNode的不同,会调用不同的callBack函数
EventTouch::EventCode eventCode = event->getEventCode(); if (eventCode == EventTouch::EventCode::BEGAN)
{
//调用began
if (listener->onTouchBegan)
{
isClaimed = listener->onTouchBegan(*touchesIter, event);
if (isClaimed && listener->_isRegistered)
{
//返回true后 将该touch放入该listener的claimedTouches
listener->_claimedTouches.push_back(*touchesIter);
}
}
}
//如果是后三个move end cancel
else if (listener->_claimedTouches.size() > 0
&& ((removedIter = std::find(listener->_claimedTouches.begin(), listener->_claimedTouches.end(), *touchesIter)) != listener->_claimedTouches.end()))
{
isClaimed = true;
//调用相应的callBack
switch (eventCode)
{
case EventTouch::EventCode::MOVED:
if (listener->onTouchMoved)
{
listener->onTouchMoved(*touchesIter, event);
}
break;
case EventTouch::EventCode::ENDED:
if (listener->onTouchEnded)
{
listener->onTouchEnded(*touchesIter, event);
}
if (listener->_isRegistered)
{
listener->_claimedTouches.erase(removedIter);
}
break;
case EventTouch::EventCode::CANCELLED:
if (listener->onTouchCancelled)
{
listener->onTouchCancelled(*touchesIter, event);
}
if (listener->_isRegistered)
{
listener->_claimedTouches.erase(removedIter);
}
break;
default:
CCASSERT(false, "The eventcode is invalid.");
break;
}
} // If the event was stopped, return directly.
if (event->isStopped())
{
updateListeners(event);
return true;
} CCASSERT((*touchesIter)->getID() == (*mutableTouchesIter)->getID(), ""); //如果接收该touch并且需要吞噬该touch,会有两个影响
//1.Touches(standard 触摸机制)的触摸操作都接收不到该touch了
//2.因为返回值是true,在调用dispatchEventToListeners时,在该node之后的node将会不再接收该touch
if (isClaimed && listener->_isRegistered && listener->_needSwallow)
{
if (isNeedsMutableSet)
{
mutableTouchesIter = mutableTouches.erase(mutableTouchesIter);
isSwallowed = true;
}
return true;
} return false;
}; //结合上面的dispatchEventToListeners的源码分析,可以看出新版本的OneByOne touch机制是这样的:
//1.listener根据Node的优先级排序后,依次响应。值得注意的是,新版本的优先级是根据Node的global Zorder来的,而不是2.x的触摸优先级。
//2.当TouchEvent Began来了之后,所有的listener会依次影响Touch Began。然后再依次响应Touch Move...而不是一个listener响应完
//began move end之后 轮到下一个listener响应的顺序。
//3.吞噬操作只有发生在began return true后才可以发生
dispatchEventToListeners(oneByOneListeners, onTouchEvent);
if (event->isStopped())
{
return;
} if (!isSwallowed)
++mutableTouchesIter;
}
} //
// process standard handlers 2nd
//
//相比于OneByOne,AllAtOnce要简单许多。值得注意的是被吞噬的touch也不会被AllAtOnce响应到
if (allAtOnceListeners && mutableTouches.size() > 0)
{ auto onTouchesEvent = [&](EventListener* l) -> bool{
EventListenerTouchAllAtOnce* listener = static_cast<EventListenerTouchAllAtOnce*>(l);
// Skip if the listener was removed.
if (!listener->_isRegistered)
return false; event->setCurrentTarget(listener->_node); switch (event->getEventCode())
{
case EventTouch::EventCode::BEGAN:
if (listener->onTouchesBegan)
{
listener->onTouchesBegan(mutableTouches, event);
}
break;
case EventTouch::EventCode::MOVED:
if (listener->onTouchesMoved)
{
listener->onTouchesMoved(mutableTouches, event);
}
break;
case EventTouch::EventCode::ENDED:
if (listener->onTouchesEnded)
{
listener->onTouchesEnded(mutableTouches, event);
}
break;
case EventTouch::EventCode::CANCELLED:
if (listener->onTouchesCancelled)
{
listener->onTouchesCancelled(mutableTouches, event);
}
break;
default:
CCASSERT(false, "The eventcode is invalid.");
break;
} // If the event was stopped, return directly.
if (event->isStopped())
{
updateListeners(event);
return true;
} return false;
}; dispatchEventToListeners(allAtOnceListeners, onTouchesEvent);
if (event->isStopped())
{
return;
}
} updateListeners(event);
}

在第34行代码开始可以看到,如果单点触摸的onTouchBegan函数返回值不是true,那么后面的onTouchMoved、onTouchEnded和onTouchCancelled也就不会触发了。

3.x中的OneByOne机制:

          1.listener根据Node的优先级排序后,依次响应。值得注意的是,新版本的优先级是根据Node的global Zorder来的,而不是2.x的触摸优先级。

2.当TouchEvent Began来了之后,所有的listener会依次影响Touch Began。然后再依次响应Touch Move...而不是一个listener响应完  began move end之后 轮到下一个listener响应的顺序。

3.吞噬操作只有发生在began return true后才可以发生

个人总结,肯定会有很多不足之处,希望路过的旁友们指出。。。

上一篇:【Git之旅】2.Git对象


下一篇:AutoMySQLBackup 3.0 Bug:"du: WARNING: use --si, not -H"