void RawStencilBufferTest::draw() { auto winPoint = Point(Director::getInstance()->getWinSize()); auto planeSize = winPoint * (1.0 / _planeCount); Renderer *renderer = Director::getInstance()->getRenderer(); size_t neededCmdSize = _planeCount * 2 + 2; if(_renderCmds.size() != neededCmdSize) { _renderCmds.resize(neededCmdSize); } auto iter = _renderCmds.begin(); iter->init(_globalZOrder); iter->func = CC_CALLBACK_0(RawStencilBufferTest::onEnableStencil, this); renderer->addCommand(&(*iter)); ++iter; for (int i = 0; i < _planeCount; i++) { auto stencilPoint = planeSize * (_planeCount - i); stencilPoint.x = winPoint.x; auto spritePoint = planeSize * i; spritePoint.x += planeSize.x / 2; spritePoint.y = 0; _sprites.at(i)->setPosition( spritePoint ); iter->init(_globalZOrder); iter->func = CC_CALLBACK_0(RawStencilBufferTest::onBeforeDrawClip, this, i, stencilPoint); renderer->addCommand(&(*iter)); ++iter; kmGLPushMatrix(); this->transform(); _sprites.at(i)->visit(); kmGLPopMatrix(); iter->init(_globalZOrder); iter->func = CC_CALLBACK_0(RawStencilBufferTest::onBeforeDrawSprite, this, i, winPoint); renderer->addCommand(&(*iter)); ++iter; kmGLPushMatrix(); this->transform(); _sprites.at(i)->visit(); kmGLPopMatrix(); } iter->init(_globalZOrder); iter->func = CC_CALLBACK_0(RawStencilBufferTest::onDisableStencil, this); renderer->addCommand(&(*iter)); }
void RenderTexture::end() { Director *director = Director::getInstance(); glBindFramebuffer(GL_FRAMEBUFFER, _oldFBO); // restore viewport director->setViewport(); kmGLMatrixMode(KM_GL_PROJECTION); kmGLPopMatrix(); kmGLMatrixMode(KM_GL_MODELVIEW); kmGLPopMatrix(); }
void CCRenderTexture::end() { CCDirector *director = CCDirector::sharedDirector(); glBindFramebuffer(GL_FRAMEBUFFER, m_nOldFBO); // restore viewport director->setViewport(); kmGLMatrixMode(KM_GL_PROJECTION); kmGLPopMatrix(); kmGLMatrixMode(KM_GL_MODELVIEW); kmGLPopMatrix(); }
// override visit. // Don't call visit on it's children void ParticleBatchNode::visit(Renderer *renderer, const kmMat4 &parentTransform, bool parentTransformUpdated) { // CAREFUL: // This visit is almost identical to Node#visit // with the exception that it doesn't call visit on it's children // // The alternative is to have a void Sprite#visit, but // although this is less maintainable, is faster // 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 kmGL stack, // but it is deprecated and your code should not rely on it kmGLPushMatrix(); kmGLLoadMatrix(&_modelViewTransform); draw(renderer, _modelViewTransform, dirty); kmGLPopMatrix(); }
// override visit // don't call visit on it's children void SpriteBatchNode::visit(void) { CC_PROFILER_START_CATEGORY(kProfilerCategoryBatchSprite, "CCSpriteBatchNode - visit"); // CAREFUL: // This visit is almost identical to CocosNode#visit // with the exception that it doesn't call visit on it's children // // The alternative is to have a void Sprite#visit, but // although this is less maintainable, is faster // if (! _visible) { return; } kmGLPushMatrix(); sortAllChildren(); transform(); draw(); kmGLPopMatrix(); setOrderOfArrival(0); CC_PROFILER_STOP_CATEGORY(kProfilerCategoryBatchSprite, "CCSpriteBatchNode - visit"); }
void LiquidScene::draw() { Layer::draw(); glEnableVertexAttribArray(0); kmGLPushMatrix(); world->DrawDebugData(); kmGLPopMatrix(); }
void CCBatchNode::visit() { m_drawOrder = ++g_drawOrder; // quick return if not visible. children won't be drawn. if (!m_bVisible) { return; } kmGLPushMatrix(); if (m_pGrid && m_pGrid->isActive()) { m_pGrid->beforeDraw(); } transform(); sortAllChildren(); draw(); // reset for next frame m_uOrderOfArrival = 0; if (m_pGrid && m_pGrid->isActive()) { m_pGrid->afterDraw(this); } kmGLPopMatrix(); }
void RenderTexture::visit() { // override visit. // Don't call visit on its children if (!_visible) { return; } kmGLPushMatrix(); if (_grid && _grid->isActive()) { _grid->beforeDraw(); transformAncestors(); } transform(); _sprite->visit(); draw(); updateEventPriorityIndex(); if (_grid && _grid->isActive()) { _grid->afterDraw(this); } kmGLPopMatrix(); _orderOfArrival = 0; }
void B2DLayer::draw(){ CCLayer::draw(); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); kmGLPushMatrix(); world->DrawDebugData(); kmGLPopMatrix(); }
void BatchNode::visit(Renderer *renderer, const kmMat4 &parentTransform, bool parentTransformUpdated) { // quick return if not visible. children won't be drawn. 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 kmGL stack, // but it is deprecated and your code should not rely on it kmGLPushMatrix(); kmGLLoadMatrix(&_modelViewTransform); sortAllChildren(); draw(renderer, _modelViewTransform, dirty); // reset for next frame _orderOfArrival = 0; kmGLPopMatrix(); }
void RenderTexture::end() { _endCommand.init(_globalZOrder); _endCommand.func = CC_CALLBACK_0(RenderTexture::onEnd, this); Renderer *renderer = Director::getInstance()->getRenderer(); renderer->addCommand(&_endCommand); renderer->popGroup(); kmGLMatrixMode(KM_GL_PROJECTION); kmGLPopMatrix(); kmGLMatrixMode(KM_GL_MODELVIEW); kmGLPopMatrix(); }
void CCRenderTexture::visit() { // override visit. // Don't call visit on its children if (!m_bVisible) { return; } kmGLPushMatrix(); if (m_pGrid && m_pGrid->isActive()) { m_pGrid->beforeDraw(); transformAncestors(); } transform(); m_pSprite->visit(); draw(); if (m_pGrid && m_pGrid->isActive()) { m_pGrid->afterDraw(this); } kmGLPopMatrix(); m_uOrderOfArrival = 0; }
// override visit. // Don't call visit on it's children void CCParticleBatchNode::visit() { // CAREFUL: // This visit is almost identical to CCNode#visit // with the exception that it doesn't call visit on it's children // // The alternative is to have a void CCSprite#visit, but // although this is less maintainable, is faster // if (!m_bVisible) { return; } kmGLPushMatrix(); if ( m_pGrid && m_pGrid->isActive()) { m_pGrid->beforeDraw(); transformAncestors(); } transform(); draw(); if ( m_pGrid && m_pGrid->isActive()) { m_pGrid->afterDraw(this); } kmGLPopMatrix(); }
void RenderTexture::visit(Renderer *renderer, const kmMat4 &parentTransform, bool parentTransformUpdated) { // override visit. // Don't call visit on its children 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 kmGL stack, // but it is deprecated and your code should not rely on it kmGLPushMatrix(); kmGLLoadMatrix(&_modelViewTransform); _sprite->visit(renderer, _modelViewTransform, dirty); draw(renderer, _modelViewTransform, dirty); kmGLPopMatrix(); _orderOfArrival = 0; }
void TestColliderDetector::draw() { ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); kmGLPushMatrix(); world->DrawDebugData(); kmGLPopMatrix(); }
void ClippingNode::drawFullScreenQuadClearStencil() { kmGLMatrixMode(KM_GL_MODELVIEW); kmGLPushMatrix(); kmGLLoadIdentity(); kmGLMatrixMode(KM_GL_PROJECTION); kmGLPushMatrix(); kmGLLoadIdentity(); DrawPrimitives::drawSolidRect(Point(-1,-1), Point(1,1), Color4F(1, 1, 1, 1)); kmGLMatrixMode(KM_GL_PROJECTION); kmGLPopMatrix(); kmGLMatrixMode(KM_GL_MODELVIEW); kmGLPopMatrix(); }
void Box2DLayer::draw() { GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION); kmGLPushMatrix(); world_.DrawDebugData(); kmGLPopMatrix(); }
void BuoyancyScene::draw() { CCLayer::draw(); ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position ); kmGLPushMatrix(); physics->drawDebugData(); kmGLPopMatrix(); CHECK_GL_ERROR_DEBUG(); }
void Label::visit(Renderer *renderer, const kmMat4 &parentTransform, bool parentTransformUpdated) { if (! _visible || _originalUTF8String.empty()) { return; } if (_fontDirty) { updateFont(); } if (_contentDirty) { updateContent(); } bool dirty = parentTransformUpdated || _transformUpdated; if (_shadowEnabled && _shadowBlurRadius <= 0 && (_shadowDirty || dirty)) { _position.x += _shadowOffset.width; _position.y += _shadowOffset.height; _transformDirty = _inverseDirty = true; _shadowTransform = transform(parentTransform); _position.x -= _shadowOffset.width; _position.y -= _shadowOffset.height; _transformDirty = _inverseDirty = true; _shadowDirty = false; } if(dirty) { _modelViewTransform = transform(parentTransform); } _transformUpdated = false; // IMPORTANT: // To ease the migration to v3.0, we still support the kmGL stack, // but it is deprecated and your code should not rely on it kmGLPushMatrix(); kmGLLoadMatrix(&_modelViewTransform); if (_textSprite) { drawTextSprite(renderer,dirty); } else { draw(renderer, _modelViewTransform, dirty); } kmGLPopMatrix(); setOrderOfArrival(0); }
void RawStencilBufferTest::draw() { auto winPoint = Point(Director::getInstance()->getWinSize()); auto planeSize = winPoint * (1.0 / _planeCount); glEnable(GL_STENCIL_TEST); CHECK_GL_ERROR_DEBUG(); for (int i = 0; i < _planeCount; i++) { auto stencilPoint = planeSize * (_planeCount - i); stencilPoint.x = winPoint.x; auto spritePoint = planeSize * i; spritePoint.x += planeSize.x / 2; spritePoint.y = 0; _sprite->setPosition( spritePoint ); this->setupStencilForClippingOnPlane(i); CHECK_GL_ERROR_DEBUG(); DrawPrimitives::drawSolidRect(Point::ZERO, stencilPoint, Color4F(1, 1, 1, 1)); kmGLPushMatrix(); this->transform(); _sprite->visit(); kmGLPopMatrix(); this->setupStencilForDrawingOnPlane(i); CHECK_GL_ERROR_DEBUG(); GL::blendFunc(BlendFunc::ALPHA_NON_PREMULTIPLIED.src, BlendFunc::ALPHA_NON_PREMULTIPLIED.dst); DrawPrimitives::drawSolidRect(Point::ZERO, winPoint, _planeColor[i]); kmGLPushMatrix(); this->transform(); _sprite->visit(); kmGLPopMatrix(); } glDisable(GL_STENCIL_TEST); CHECK_GL_ERROR_DEBUG(); }
void HelloWorld::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags) { Layer::draw(renderer, transform, flags); // Draw debug for Box2D. ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position); kmGLPushMatrix(); m_world->DrawDebugData(); kmGLPopMatrix(); }
void RawStencilBufferTest::draw() { CCPoint winPoint = ccpFromSize(CCDirector::sharedDirector()->getWinSize()); CCPoint planeSize = ccpMult(winPoint, 1.0 / _planeCount); glEnable(GL_STENCIL_TEST); CHECK_GL_ERROR_DEBUG(); for (int i = 0; i < _planeCount; i++) { CCPoint stencilPoint = ccpMult(planeSize, _planeCount - i); stencilPoint.x = winPoint.x; CCPoint spritePoint = ccpMult(planeSize, i); spritePoint.x += planeSize.x / 2; spritePoint.y = 0; m_pSprite->setPosition( spritePoint ); this->setupStencilForClippingOnPlane(i); CHECK_GL_ERROR_DEBUG(); ccDrawSolidRect(CCPointZero, stencilPoint, ccc4f(1, 1, 1, 1)); kmGLPushMatrix(); this->transform(); m_pSprite->visit(); kmGLPopMatrix(); this->setupStencilForDrawingOnPlane(i); CHECK_GL_ERROR_DEBUG(); ccDrawSolidRect(CCPointZero, winPoint, _planeColor[i]); kmGLPushMatrix(); this->transform(); m_pSprite->visit(); kmGLPopMatrix(); } glDisable(GL_STENCIL_TEST); CHECK_GL_ERROR_DEBUG(); }
void HelloWorld::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags) { Layer::draw(renderer, transform, flags); GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION); kmGLPushMatrix(); _world->DrawDebugData(); kmGLPopMatrix(); }
void HelloWorld::onDraw(const kmMat4 &transform, bool transformUpdated) { kmGLPushMatrix(); kmGLLoadMatrix(&transform); GL::enableVertexAttribs( cocos2d::GL::VERTEX_ATTRIB_FLAG_POSITION ); world->DrawDebugData(); CHECK_GL_ERROR_DEBUG(); kmGLPopMatrix(); }
void Box2DView::onDraw(const kmMat4 &transform, bool transformUpdated) { kmGLPushMatrix(); kmGLLoadMatrix(&transform); GL::enableVertexAttribs( cocos2d::GL::VERTEX_ATTRIB_FLAG_POSITION ); m_test->Step(&settings); m_test->m_world->DrawDebugData(); CHECK_GL_ERROR_DEBUG(); kmGLPopMatrix(); }
void GiftListView::visit() { kmGLPushMatrix(); glEnable(GL_SCISSOR_TEST); CCSprite* marksp = (CCSprite*)mPageMarkers.objectAtIndex(0); CCPoint lbPoint = this->convertToWorldSpace(ccp(0,-marksp->getContentSize().height*2+mMarkPosOffset.y-mItemIntervalV)); CCPoint trPoint = this->convertToWorldSpace(ccp(getContentSize().width+mItemIntervalH, getContentSize().height+20+mItemIntervalV ) ); CCEGLView::sharedOpenGLView()->setScissorInPoints(lbPoint.x, lbPoint.y, abs(trPoint.x-lbPoint.x), abs(trPoint.y-lbPoint.y)); CCNode::visit(); glDisable(GL_SCISSOR_TEST); kmGLPopMatrix(); }
void CC3DSprite::visit( void ) { m_drawOrder = ++g_drawOrder; // quick return if not visible. children won't be drawn. if (!m_bVisible) return; kmGLPushMatrix(); this->transform(); CCNode* pNode = NULL; unsigned int i = 0; if(m_pChildren && m_pChildren->count() > 0) { sortAllChildren(); // draw children zOrder < 0 ccArray *arrayData = m_pChildren->data; for( ; i < arrayData->num; i++ ) { pNode = (CCNode*) arrayData->arr[i]; if ( pNode && pNode->getZOrder() < 0 ) { pNode->visit(); } else { break; } } // self draw this->draw(); for( ; i < arrayData->num; i++ ) { pNode = (CCNode*) arrayData->arr[i]; if (pNode) { pNode->visit(); } } } else { this->draw(); } // reset for next frame m_uOrderOfArrival = 0; kmGLPopMatrix(); }
void Node::visit(Renderer* renderer, const kmMat4 &parentTransform, bool parentTransformUpdated) { // quick return if not visible. children won't be drawn. if (!_visible) { return; } bool dirty = _transformUpdated || parentTransformUpdated; if(dirty) _modelViewTransform = this->transform(parentTransform); _transformUpdated = false; // IMPORTANT: // To ease the migration to v3.0, we still support the kmGL stack, // but it is deprecated and your code should not rely on it kmGLPushMatrix(); kmGLLoadMatrix(&_modelViewTransform); int i = 0; if(!_children.empty()) { sortAllChildren(); // draw children zOrder < 0 for( ; i < _children.size(); i++ ) { auto node = _children.at(i); if ( node && node->_localZOrder < 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); } // reset for next frame _orderOfArrival = 0; kmGLPopMatrix(); }
void ScrollView::visit() { // quick return if not visible if (!isVisible()) { return; } kmGLPushMatrix(); this->transform(); this->beforeDraw(); if (!_children.empty()) { int i=0; // draw children zOrder < 0 for( ; i < _children.size(); i++ ) { Node *child = _children.at(i); if ( child->getZOrder() < 0 ) { child->visit(); } else { break; } } // this draw this->draw(); // draw children zOrder >= 0 for( ; i < _children.size(); i++ ) { Node *child = _children.at(i); child->visit(); } } else { this->draw(); } this->afterDraw(); kmGLPopMatrix(); }
void CARenderImage::end() { GLubyte *pBuffer = pBuffer = new GLubyte[m_uPixelsWide * m_uPixelsHigh * 4]; GLubyte *pTempData = new GLubyte[m_uPixelsWide * m_uPixelsHigh * 4]; glPixelStorei(GL_PACK_ALIGNMENT, 1); glReadPixels(0, 0, m_uPixelsWide, m_uPixelsHigh, GL_RGBA, GL_UNSIGNED_BYTE, pTempData); glBindFramebuffer(GL_FRAMEBUFFER, m_nOldFBO); CAApplication::getApplication()->setViewport(); kmGLMatrixMode(KM_GL_PROJECTION); kmGLPopMatrix(); kmGLMatrixMode(KM_GL_MODELVIEW); kmGLPopMatrix(); m_pImage = new CAImage(); m_pImage->initWithRawData(pTempData, CAImage::PixelFormat_RGBA8888, m_uPixelsWide, m_uPixelsHigh); m_pImageView->setImage(m_pImage); CC_SAFE_DELETE_ARRAY(pBuffer); CC_SAFE_DELETE_ARRAY(pTempData); }