自学教程：C++ CC_CALLBACK_0函数代码示例

// Worker threadvoid HttpClient::networkThread(){        HttpRequest *request = nullptr;        auto scheduler = Director::getInstance()->getScheduler();        while (true)     {        if (s_need_quit)        {            break;        }                // step 1: send http request if the requestQueue isn't empty        request = nullptr;                s_requestQueueMutex.lock();                //Get request task from queue                if (!s_requestQueue->empty())        {            request = s_requestQueue->at(0);            s_requestQueue->erase(0);        }                s_requestQueueMutex.unlock();                if (nullptr == request)        {            // Wait for http request tasks from main thread            std::unique_lock<std::mutex> lk(s_SleepMutex);             s_SleepCondition.wait(lk);            continue;        }                // step 2: libcurl sync access                // Create a HttpResponse object, the default setting is http access failed        HttpResponse *response = new HttpResponse(request);                processResponse(response, s_errorBuffer);                // add response packet into queue        s_responseQueueMutex.lock();        s_responseQueue->pushBack(response);        s_responseQueueMutex.unlock();                if (nullptr != s_pHttpClient) {            scheduler->performFunctionInCocosThread(CC_CALLBACK_0(HttpClient::dispatchResponseCallbacks, this));        }    }        // cleanup: if worker thread received quit signal, clean up un-completed request queue    s_requestQueueMutex.lock();    s_requestQueue->clear();    s_requestQueueMutex.unlock();            if (s_requestQueue != nullptr) {        delete s_requestQueue;        s_requestQueue = nullptr;        delete s_responseQueue;        s_responseQueue = nullptr;    }    }

void Label::draw(){    _customCommand.init(_globalZOrder);    _customCommand.func = CC_CALLBACK_0(Label::onDraw, this);    Director::getInstance()->getRenderer()->addCommand(&_customCommand);}

void ClippingNode::visit(Renderer *renderer, const Mat4 &parentTransform, bool parentTransformUpdated){    if(!_visible)        return;        bool dirty = parentTransformUpdated || _transformUpdated;    if(dirty)        _modelViewTransform = transform(parentTransform);    _transformUpdated = false;    // IMPORTANT:    // To ease the migration to v3.0, we still support the Mat4 stack,    // but it is deprecated and your code should not rely on it    Director* director = Director::getInstance();    CCASSERT(nullptr != director, "Director is null when seting matrix stack");    director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);    director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW, _modelViewTransform);    //Add group command            _groupCommand.init(_globalZOrder);    renderer->addCommand(&_groupCommand);    renderer->pushGroup(_groupCommand.getRenderQueueID());    _beforeVisitCmd.init(_globalZOrder);    _beforeVisitCmd.func = CC_CALLBACK_0(ClippingNode::onBeforeVisit, this);    renderer->addCommand(&_beforeVisitCmd);    if (_alphaThreshold < 1)    {#if (CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WINDOWS || CC_TARGET_PLATFORM == CC_PLATFORM_LINUX)#else        // since glAlphaTest do not exists in OES, use a shader that writes        // pixel only if greater than an alpha threshold        GLProgram *program = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_ALPHA_TEST_NO_MV);        GLint alphaValueLocation = glGetUniformLocation(program->getProgram(), GLProgram::UNIFORM_NAME_ALPHA_TEST_VALUE);        // set our alphaThreshold        program->use();        program->setUniformLocationWith1f(alphaValueLocation, _alphaThreshold);        // we need to recursively apply this shader to all the nodes in the stencil node        // XXX: we should have a way to apply shader to all nodes without having to do this        setProgram(_stencil, program);        #endif    }    _stencil->visit(renderer, _modelViewTransform, dirty);    _afterDrawStencilCmd.init(_globalZOrder);    _afterDrawStencilCmd.func = CC_CALLBACK_0(ClippingNode::onAfterDrawStencil, this);    renderer->addCommand(&_afterDrawStencilCmd);    int i = 0;        if(!_children.empty())    {        sortAllChildren();        // draw children zOrder < 0        for( ; i < _children.size(); i++ )        {            auto node = _children.at(i);                        if ( node && node->getLocalZOrder() < 0 )                node->visit(renderer, _modelViewTransform, dirty);            else                break;        }        // self draw        this->draw(renderer, _modelViewTransform, dirty);                for(auto it=_children.cbegin()+i; it != _children.cend(); ++it)            (*it)->visit(renderer, _modelViewTransform, dirty);    }    else    {        this->draw(renderer, _modelViewTransform, dirty);    }    _afterVisitCmd.init(_globalZOrder);    _afterVisitCmd.func = CC_CALLBACK_0(ClippingNode::onAfterVisit, this);    renderer->addCommand(&_afterVisitCmd);    renderer->popGroup();        director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);}

void GamePromptCenter::popPromptText(){	if ( m_promptText.empty() )	{		return ;	}	RichTextEx* pText = m_promptText[0].first;	if ( pText )	{		float deltaX = 0.0f;		float deltaY = 100.0f;		pText->runAction(FadeOut::create(0.5f));		pText->runAction(Sequence::create(MoveBy::create(0.5f,Point(deltaX,deltaY)),CallFunc::create( CC_CALLBACK_0(GamePromptCenter::onPromptTextPoped,this,pText)),NULL));	}	m_promptText.erase(m_promptText.begin()); 	// 所有提示信息往上顶 	for ( size_t i = 0; i<m_promptText.size(); ++i ) 	{		RichTextEx* pTextReady = m_promptText[i].first;		if ( pTextReady )		{			ActionInterval* pAction = MoveBy::create(0.2f,Point(0,pText->getSize().height+3));			pTextReady->runAction(pAction);		} 	}}

/** * Draw node. * * @param renderer Renderer object * @param transform Transform matrix * @param flags Flags to draw */void ShaderNode::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags){	_customCommand.init(_globalZOrder);	_customCommand.func = CC_CALLBACK_0(ShaderNode::onDraw, this, transform, flags);	renderer->addCommand(&_customCommand);}

void SkillItem::onSkillStarted(){    this->setEnabled(false);        ProgressTo *to1 = ProgressTo::create(getSkillCDTime(), 100);    ProgressTimer *sprite = ProgressTimer::create(Sprite::create(this->getDisableIcon().c_str()));    sprite->setType(ProgressTimer::Type::RADIAL);        auto tint = Sequence::create(TintTo::create(getSkillCDTime(), 60, 255, 180),                                 NULL);        sprite->setPosition(Point(getContentSize().width / 2, getContentSize().height / 2));    sprite->setBarChangeRate(Point(0, 1));    addChild(sprite, 0, SKILL_ITEM_CHILD_TAG);    sprite->runAction(Sequence::create(Spawn::create(to1, tint, NULL),CallFunc::create( CC_CALLBACK_0( SkillItem::onSkillCDFinished, this)) ,NULL) );}

    void Gameboard::afterSwap(Node* _Node) {        if (firstArrived_ == nullptr) {            CCLOG("checkSwapValid: First arrived, proceed further.");            firstArrived_ = _Node;            return;        }        firstArrived_ = nullptr;        CCLOG("checkSwapValid: Second arrived, finally can check.");        std::set<IPiece*> removal;        score_->newSequence(checkResults_.size());        for (auto vec : checkResults_) {            uint32_t size = vec.size();            CCLOG("Found %d pieces in row", size);            uint32_t scoreValue = score_->addGroup(vec.size());            for (IPiece* piece : vec) {                board_->remove(piece->getCoords());                Vec2 pos = coord2world(piece->getCoords());                Sprite* sprite = piece->sprite();                addScoreLabel(scoreValue, sprite->getPosition());                addSomeEffects(sprite->getPosition());                dissapear(piece);            }            removal.insert(vec.begin(), vec.end());            CocosDenshion::SimpleAudioEngine::getInstance()->playEffect("remove.wav");        }        for (auto it = removal.begin(); it != removal.end(); ++it) {            delete *it;        }        float longestAnimationTime = refill() * FalldownSpeed;        float waitFalldownToComplete = longestAnimationTime + FastSpeed;        if (!check()) {            auto waitToUnlock = Sequence::create(                    DelayTime::create(waitFalldownToComplete),                    CallFunc::create(CC_CALLBACK_0(Gameboard::unlock, this)),                    nullptr);            runAction(waitToUnlock);        } else {            std::function<void(Node*)> cb;            cb = CC_CALLBACK_1(Gameboard::afterSwap, this);            // Hack - need to call it twice to make it do the job            auto waitToRecheck = Sequence::create(                    DelayTime::create(waitFalldownToComplete),                    CallFuncN::create(cb),                    CallFuncN::create(cb),                    nullptr);            runAction(waitToRecheck);        }    }

//================================================================================// シ
C++ CC_CALLBACK_1函数代码示例
C++ CC_BREAK_IF函数代码示例