大佬教程收集整理的这篇文章主要介绍了【深入了解cocos2d-x 3.x】定时器(scheduler)的使用和原理探究(2),大佬教程大佬觉得挺不错的,现在分享给大家,也给大家做个参考。
上篇说到定时器的使用方法,这篇主要分析它的实现原理。
typedef struct UT_hash_handle { struct UT_hash_table *tbl; void *prev; /* prev element in app order */ void *next; /* next element in app order */ struct UT_hash_handle *hh_prev; /* previous hh in bucket order */ struct UT_hash_handle *hh_next; /* next hh in bucket order */ void *key; /* ptr to enclosing struct's key */ unsigned keylen; /* enclosing struct's key len */ unsigned hashv; /* result of hash-fcn(key) */ } UT_hash_handle;
typedef struct UT_hash_table { UT_hash_bucket *buckets; unsigned num_buckets,log2_num_buckets; unsigned num_items; struct UT_hash_handle *tail; /* tail hh in app order,for fast append */ ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */ /* in an ideal situation (all buckets used equally),no bucket would have * more than ceil(#items/#buckets) items. that's the ideal chain length. */ unsigned ideal_chain_maxlen; /* nonideal_items is the number of items in the hash whose chain position * exceeds the ideal chain maxlen. these items pay the penalty for an uneven * hash diStribution; reaching them in a chain traversal takes >ideal steps */ unsigned nonideal_items; /* ineffective expands occur when a bucket doubling was performed,but * afterWARD,more than half the items in the hash had nonideal chain * positions. If this happens on two consecutive expansions we inhibit any * further expansion,as it's not Helping; this happens when the hash * function isn't a good fit for the key domain. When expansion is inhibited * the hash will still work,albeit no longer in constant time. */ unsigned ineff_expands,noexpand; uint32_t signature; /* used only to find hash tables in external analysis */ #ifdef HASH_BLOOM uint32_t bloom_sig; /* used only to test bloom exists in external analysis */ uint8_t *bloom_bv; char bloom_nbits; #endif } UT_hash_table;
/** * 查找元素 * head:哈希链表的头指针 * findptr:要查找的元素指针 * out:查找结果 */ HASH_FIND_PTR(head,findptr,out) /** * 添加元素 * head:哈希链表的头指针 * ptrfield:要添加的元素指针 * add:要添加的哈希链表元素 */ HASH_ADD_PTR(head,ptrfield,add) /** * 替换元素 * head:哈希链表的头指针 * ptrfield:要替换的元素指针 * add:要替换的哈希链表元素 */ HASH_replaCE_PTR(head,add) /** * 删除 * head:哈希链表的头指针 * delptr:要删除的元素指针 */ HASH_DEL(head,delptr)
// 不同优先级的update定时器的双向链表 typedef struct _listEntry { struct _listEntry *prev,*next; ccschedulerFunc callBACk; void *target; int priority; bool paused; bool markedFordeletion; // SELEctor will no longer be called and entry will be removed at end of the next tick } tListEntry; //内置的update定时器 typedef struct _hashupdateEntry { tListEntry **list; // Which list does it belong to ? tListEntry *entry; // entry in the list void *target; ccschedulerFunc callBACk; UT_hash_handle hh; } tHashupdateEntry; // 自定义定时器 typedef struct _hashSELEctorEntry { ccArray *timers; void *target; int timerIndex; Timer *currentTimer; bool currentTimerSalvaged; bool paused; UT_hash_handle hh; } tHashTimerEntry;
/** * 定义一个自定义的定时器 * SELEctor:回调函数 * interval:重复间隔时间,重复执行间隔的时间,如果传入0,则表示每帧调用 * repeat:重复运行次数,如果传入CC_REPEAT_FOREVER则表示无限循环 * delay:延时秒数,延迟delay秒开始执行第一次回调 */ void schedule(SEL_scheDULE SELEctor,float interval,unsigned int repeat,float delay); /** * 使用lambda函数定义一个自定义定时器 * callBACk:lambda函数 * interval:重复间隔时间,重复执行间隔的时间,如果传入0,则表示每帧调用 * repeat:重复运行次数,如果传入CC_REPEAT_FOREVER则表示无限循环 * delay:延时秒数,延迟delay秒开始执行第一次回调 * key:lambda函数的Key,用于取消定时器 * @lua NA */ void schedule(const std::function<void(float)>& callBACk,float delay,const std::string &key);
void Node::schedule(SEL_scheDULE SELEctor,float delay) { CCassERT( SELEctor,"Argument must be non-nil"); CCassERT( interval >=0,"Argument must be positive"); _scheduler->schedule(SELEctor,this,interval,repeat,delay,!_running); }
scheduler *_scheduler; ///< scheduler used to schedule timers and updates查看定义可以知道是一个scheduler 的指针,但是这个指针从哪里来?在构造函数中有真相
Node::Node(void) { // set default scheduler and actionManager _director = Director::geTinstance(); _scheduler = _director->getscheduler(); _scheduler->retain(); }
void scheduler::schedule(SEL_scheDULE SELEctor,Ref *target,bool paused) { CCassERT(target,"Argument target must be non-nullptr"); //定义并且查找链表元素 tHashTimerEntry *element = nullptr; HASH_FIND_PTR(_hashForTimers,&target,element); //没找到 if (! element) { //创建一个链表元素 element = (tHashTimerEntry *)calloc(sizeof(*element),1); element->target = target; //添加到哈希链表中 HASH_ADD_PTR(_hashForTimers,target,element); // Is this the 1st element ? Then set the pause level to all the SELEctors of this target element->paused = paused; } else { CCassERT(element->paused == paused,""); } //检查这个元素的定时器数组,如果数组为空 则new 10个数组出来备用 if (element->timers == nullptr) { element->timers = ccArrayNew(10); } else { //循环查找定时器数组,看看是不是曾经定义过相同的定时器,如果定义过,则只需要修改定时器的间隔时间 for (int i = 0; i < element->timers->num; ++i) { TimerTargetSELEctor *timer = dynamic_cast<TimerTargetSELEctor*>(element->timers->arr[i]); if (timer && SELEctor == timer->getSELEctor()) { CCLOG("CCscheduler#scheduleSELEctor. SELEctor already scheduled. updating interval from: %.4f to %.4f",timer->geTinterval(),interval); timer->seTinterval(interval); return; } } //扩展1个定时器数组 ccArrayEnsureExtraCapacity(element->timers,1); } //创建一个定时器,并且将定时器加入到当前链表指针的定时器数组中 TimerTargetSELEctor *timer = new (std::nothrow) TimerTargetSELEctor(); timer->initWithSELEctor(this,SELEctor,delay); ccArrayAppendObject(element->timers,timer); timer->release(); }
/** * 开启自带的update方法,这个方法会每帧执行一次,默认优先级为0,并且在所有自定义方法执行之前执行 */ void scheduleupdate(void); /** * 开启自带的update方法,这个方法会每帧执行一次,设定的优先级越小,越优先执行 */ void scheduleupdateWithPriority(int priority);第一个方法实际上是直接调用第二个方法,并且把优先级设置为0,我们直接看第二个方法就可以了。
void Node::scheduleupdateWithPriority(int priority) { _scheduler->scheduleupdate(this,priority,!_running); }具体调用还是要进入到_scheduler->scheduleupdate。
/** schedules the 'update' SELEctor for a given target with a given priority. The 'update' SELEctor will be called every frame. The lower the priority,the earlier it is called. @since v3.0 @lua NA */ template <class T> void scheduleupdate(T *target,int priority,bool paused) { this->schedulePerFrame([target](float dt){ target->update(dt); },paused); }
void scheduler::schedulePerFrame(const ccschedulerFunc& callBACk,void *target,bool paused) { //定义并且查找链表元素 tHashupdateEntry *hasHelement = nullptr; HASH_FIND_PTR(_hashForupdates,hasHelement); //如果找到,就直接改优先级 if (hasHelement) { // 检查优先级是否改变 if ((*hasHelement->list)->priority != priority) { //检查是否被锁定 if (_updateHashLocked) { CCLOG("warning: you CAnnOT change update priority in scheduled function"); hasHelement->entry->markedFordeletion = false; hasHelement->entry->paused = paused; return; } else { // 在这里先停止到update,后面会加回来 unscheduleupdate(target); } } else { hasHelement->entry->markedFordeletion = false; hasHelement->entry->paused = paused; return; } } // 优先级为0,加入到_updates0List链表中,并且加入到_hashForupdates表中 if (priority == 0) { appendIn(&_updates0List,callBACk,paused); } // 优先级小于0,加入到_updatesNegList链表中,并且加入到_hashForupdates表中 else if (priority < 0) { priorityIn(&_updatesNegList,paused); } // 优先级大于0,加入到_updatesPosList链表中,并且加入到_hashForupdates表中 else { // priority > 0 priorityIn(&_updatesPosList,paused); } }在这里看上去逻辑还是很清晰的,有两个函数要重点分析一下,分别是
void scheduler::appendIn(_listEntry **list,const ccschedulerFunc& callBACk,bool paused) void scheduler::priorityIn(tListEntry **list,bool paused)
void scheduler::appendIn(_listEntry **list,bool paused) { //创建一个链表元素 tListEntry *listElement = new tListEntry(); listElement->callBACk = callBACk; listElement->target = target; listElement->paused = paused; listElement->priority = 0; listElement->markedFordeletion = false; //添加到双向链表中 DL_APPEND(*list,listElement); //创建一个哈希链表元素 tHashupdateEntry *hasHelement = (tHashupdateEntry *)calloc(sizeof(*hasHelement),1); hasHelement->target = target; hasHelement->list = list; hasHelement->entry = listElement; //添加到哈希链表中 HASH_ADD_PTR(_hashForupdates,hasHelement); }
void scheduler::priorityIn(tListEntry **list,bool paused) { //同上一个函数 tListEntry *listElement = new tListEntry(); listElement->callBACk = callBACk; listElement->target = target; listElement->priority = priority; listElement->paused = paused; listElement->next = listElement->prev = nullptr; listElement->markedFordeletion = false; //如果链表为空 if (! *list) { DL_APPEND(*list,listElement); } else { bool added = false; //保证链表有序 for (tListEntry *element = *list; element; element = element->next) { // 如果优先级小于当前元素的优先级,就在这个元素前面插入 if (priority < element->priority) { if (element == *list) { DL_PREPEND(*list,listElement); } else { listElement->next = element; listElement->prev = element->prev; element->prev->next = listElement; element->prev = listElement; } added = true; break; } } //如果新加入的优先级最低,则加入到链表的最后 if (! added) { DL_APPEND(*list,listElement); } } //同上一个函数 tHashupdateEntry *hasHelement = (tHashupdateEntry *)calloc(sizeof(*hasHelement),1); hasHelement->target = target; hasHelement->list = list; hasHelement->entry = listElement; HASH_ADD_PTR(_hashForupdates,hasHelement); }本文简单的分析了哈希链表以及定时器的存储和添加,下一篇文章将分析定时器是如何运转起来的。
以上是大佬教程为你收集整理的【深入了解cocos2d-x 3.x】定时器(scheduler)的使用和原理探究(2)全部内容,希望文章能够帮你解决【深入了解cocos2d-x 3.x】定时器(scheduler)的使用和原理探究(2)所遇到的程序开发问题。
如果觉得大佬教程网站内容还不错,欢迎将大佬教程推荐给程序员好友。
本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。