Material* Material::createWithFilename(const std::string& filepath) { auto validfilename = FileUtils::getInstance()->fullPathForFilename(filepath); if (validfilename.size() > 0) { auto mat = new (std::nothrow) Material(); if (mat && mat->initWithFile(validfilename)) { mat->autorelease(); return mat; } } return nullptr; }
SpriteRenderTextureBug::SimpleSprite* SpriteRenderTextureBug::SimpleSprite::create(const char* filename, const Rect &rect) { auto sprite = new (std::nothrow) SimpleSprite(); if (sprite && sprite->initWithFile(filename, rect)) { sprite->autorelease(); } else { CC_SAFE_DELETE(sprite); } return sprite; }
Status *Status::create() { auto ref = new Status(); if (ref->init()) { ref->autorelease(); return ref; } else { CC_SAFE_DELETE(ref); return nullptr; } }
EffectSprite3D* EffectSprite3D::create(const std::string &path) { if (path.length() < 4) CCASSERT(false, "improper name specified when creating Sprite3D"); auto sprite = new (std::nothrow) EffectSprite3D(); if (sprite && sprite->initWithFile(path)) { sprite->autorelease(); return sprite; } CC_SAFE_DELETE(sprite); return nullptr; }
StoreSelectLayer * StoreSelectLayer::create(int money) { auto storeSelectLayer = new StoreSelectLayer(); if (storeSelectLayer && storeSelectLayer->init(money)) { storeSelectLayer->autorelease(); return storeSelectLayer; } else { CC_SAFE_DELETE(storeSelectLayer); return nullptr; } }
ComponentLua* ComponentLua::create(const std::string& scriptFileName) { CC_ASSERT(!scriptFileName.empty()); initClass(); auto componentLua = new(std::nothrow) ComponentLua(scriptFileName); if (componentLua) { componentLua->autorelease(); } return componentLua; }
Sprite3D* Sprite3D::create(const std::string& modelPath) { CCASSERT(modelPath.length() >= 4, "invalid filename for Sprite3D"); auto sprite = new (std::nothrow) Sprite3D(); if (sprite && sprite->initWithFile(modelPath)) { sprite->_contentSize = sprite->getBoundingBox().size; sprite->autorelease(); return sprite; } CC_SAFE_DELETE(sprite); return nullptr; }
PerfectMenu *PerfectMenu::createWithArray(const Vector<MenuItem*>& arrayOfItems) { auto ret = new PerfectMenu(); if (ret && ret->initWithArray(arrayOfItems)) { ret->autorelease(); } else { CC_SAFE_DELETE(ret); } return ret; }
fireBullet * fireBullet::create(){ auto obj = new fireBullet(); if(obj->initWithFile("bullet.png")){ auto cirle = PhysicsBody::createCircle(obj->getContentSize().width,PhysicsMaterial(0,1,0)); obj->setPhysicsBody(cirle); cirle->setContactTestBitmask(true); obj->autorelease(); //obj->addChild(sp); } return obj; }
CrushNode* CrushNode::createByType(int pType,int x ,int y) { auto t_node = new CrushNode(); if (t_node && t_node->init(pType,x,y)) { t_node->autorelease(); return t_node; } else { CC_SAFE_DELETE(t_node); return nullptr; } }
NS_CC_BEGIN Primitive* Primitive::create(VertexData* verts, IndexBuffer* indices, int type) { auto result = new (std::nothrow) Primitive(); if( result && result->init(verts, indices, type)) { result->autorelease(); return result; } CC_SAFE_DELETE(result); return nullptr; }
FrameSprite *FrameSprite::create(const std::string& strImgFile, unsigned uXFrames, unsigned uYFrames, unsigned uFrameIdx) { auto pRet = new FrameSprite; if (pRet->init(strImgFile, uXFrames, uYFrames, uFrameIdx)) { pRet->autorelease(); } else { delete pRet; pRet = nullptr; } return pRet; }
MenuItemScale9Sprite *MenuItemScale9Sprite::create(unsigned index,cocos2d::Size contentSize,const cocos2d::ccMenuCallback& callback) { auto pRet = new MenuItemScale9Sprite(); if (pRet->init(sButtonPath[index][0],sButtonPath[index][1], sButtonPath[index][2],sBtRect[index][0],sBtRect[index][1],contentSize,callback)) { pRet->autorelease(); } else { delete pRet; pRet = nullptr; } return pRet; }
TableViewCell* CombineView::tableCellAtIndex(TableView *table, ssize_t idx) { auto cell = table->dequeueCell(); auto cellSize = this->tableCellSizeForIndex(table, idx); auto tag = table->getTag(); if (!cell) { cell = new TableViewCell(); cell->autorelease(); Sprite * pCellBg = NULL; Label * pNum = NULL; Sprite * pIcon = NULL; switch (tag) { case Table_Left: { pCellBg = Sprite::create("cell.png"); pNum = Label::createWithSystemFont("1","Arial",20); pIcon = Sprite::create("book.png"); } break; case Table_Center: { pCellBg = Sprite::create("cell2.png"); pNum = Label::createWithSystemFont("2","Arial",20); pIcon = Sprite::create("plane.png"); } break; case Table_Right: { pCellBg = Sprite::create("cell3.png"); pNum = Label::createWithSystemFont("3","Arial",20); pIcon = Sprite::create("setting.png"); } default: break; } pCellBg->setPosition(Vec2(cellSize.width / 2,cellSize.height / 2)); cell->addChild(pCellBg); pNum->setColor(Color3B(255,0,0)); pNum->setPosition(Vec2(cellSize.width * 0.1,cellSize.height / 2)); cell->addChild(pNum); pIcon->setPosition(Vec2(cellSize.width * 0.85,cellSize.height / 2)); pIcon->setScale(0.2); cell->addChild(pIcon); } return cell; }
void GameScene_02::creatBricks() { bricks = new Vector<Brick*>; auto brick = Brick::create(); float b_w = brick->getContentSize().width; float b_h = brick->getContentSize().height; int num_line = visibleSize.width / b_w; float offset = (visibleSize.width - num_line * b_w) / 2; int num_row = visibleSize.height / b_h / 2; int brickBf = random<int>(1, 6); for ( int i=0; i<num_line; i++) { for ( int j=0; j<num_row; j++) { brick->setPosition(offset + i*b_w + b_w/2, visibleSize.height - j*b_h - b_h/2 - 80 ); int brickBf = random<int>(1, 5); switch (brickBf) { case 1: brick->setBrickBuff(NORMAL); break; case 2: brick->setBrickBuff(UP_SPEED); break; case 3: brick->setBrickBuff(DOWN_SPEED); break; case 4: brick->setBrickBuff(ADD_LENGTH); break; case 5: brick->setBrickBuff(SUB_LENGTH); break; case 6: brick->setBrickBuff(ADD_BALL); default: break; } bricks->pushBack(brick); brick->autorelease(); brick = Brick::create(); } } for (auto iter = bricks->begin(); iter!= bricks->end(); iter++) { this->addChild(*iter); } }
CallFunc * CallFunc::clone() const { // no copy constructor auto a = new (std::nothrow) CallFunc(); if( _selectorTarget) { a->initWithTarget(_selectorTarget); a->_callFunc = _callFunc; } else if( _function ){ a->initWithFunction(_function); } a->autorelease(); return a; }
CallFuncN * CallFuncN::clone() const { // no copy constructor auto a = new (std::nothrow) CallFuncN(); if( _selectorTarget) { a->initWithTarget(_selectorTarget, _callFuncN); } else if( _functionN ){ a->initWithFunction(_functionN); } a->autorelease(); return a; }
RenderTargetDepthStencil* RenderTargetDepthStencil::create(unsigned int width, unsigned int height) { auto result = new (std::nothrow) RenderTargetDepthStencil(); if(result && result->init(width, height)) { result->autorelease(); return result; } else { CC_SAFE_DELETE(result); return nullptr; } }
NS_CC_BEGIN AnimationFrame* AnimationFrame::create(SpriteFrame* spriteFrame, float delayUnits, const ValueMap& userInfo) { auto ret = new (std::nothrow) AnimationFrame(); if (ret && ret->initWithSpriteFrame(spriteFrame, delayUnits, userInfo)) { ret->autorelease(); } else { CC_SAFE_DELETE(ret); } return ret; }
Physics3D6DofConstraint* Physics3D6DofConstraint::create(Physics3DRigidBody* rbA, Physics3DRigidBody* rbB, const cocos2d::Mat4& frameInA, const cocos2d::Mat4& frameInB, bool useLinearReferenceFrameA) { auto ret = new Physics3D6DofConstraint(); ret->_bodyA = rbA; ret->_bodyB = rbB; rbA->retain(); rbB->retain(); auto frameA = convertMat4TobtTransform(frameInA); auto frameB = convertMat4TobtTransform(frameInB); ret->_constraint = new btGeneric6DofConstraint(*rbA->getRigidBody(), *rbB->getRigidBody(), frameA, frameB, useLinearReferenceFrameA); ret->autorelease(); return ret; }
PlayNoteRenderer::PlayNoteRenderer(const PlayChannelPlayer* player, Sprite* baseSprite): mChannelPlayer(player), mBaseSprite(baseSprite) { scheduleUpdate(); autorelease(); auto dispatcher = Director::getInstance()->getEventDispatcher(); dispatcher->addCustomEventListener(Event::BpmEvent::CHANGED, std::bind(&PlayNoteRenderer::onBpmChanged, this, std::placeholders::_1)); dispatcher->addCustomEventListener(Event::JudgeEvent::JUDGE, std::bind(&PlayNoteRenderer::onJudge, this, std::placeholders::_1)); dispatcher->addCustomEventListener(Event::SpeedEvent::CHANGED, std::bind(&PlayNoteRenderer::onSpeedChanged, this, std::placeholders::_1)); mBaseSprite->retain(); setContentSize(Size(mBaseSprite->getContentSize().width, 0)); }
Panda *Panda::create() { auto panda = new Panda(); if(panda&&panda->initWithSpriteFrameName("taopaoxiongmao00000.png")) { panda->autorelease(); panda->setAnchorPoint(Point::ANCHOR_MIDDLE_BOTTOM); panda->initAnimations(); panda->runAction(RepeatForever::create(Animate::create(AnimationCache::getInstance()->getAnimation("taopaoxiongmao")))); panda->setDisplayFrameWithAnimationName("taopaoxiongmao", 1); return panda; } CC_SAFE_FREE(panda); return nullptr; }
GameOverLayer* GameOverLayer::create(bool win, int stage, int time, int kill, int loss, int newFlight) { auto pRet = new GameOverLayer(); if (pRet && pRet->init(win, stage, time, kill, loss, newFlight)) { pRet->autorelease(); return pRet; } else { delete pRet; pRet = NULL; return NULL; } }
EventListenerAcceleration* EventListenerAcceleration::clone() { auto ret = new (std::nothrow) EventListenerAcceleration(); if (ret && ret->init(onAccelerationEvent)) { ret->autorelease(); } else { CC_SAFE_DELETE(ret); } return ret; }
Block* Block::create( TYPE type ,int x,int y) { auto b = new Block(); if (b&&b->init(type,x,y)) { b->autorelease(); return b; } else { delete b; b=nullptr; return nullptr; } }
UpgradeUILayer* UpgradeUILayer::create(BasePanel basePanel, int index) { auto pRet = new UpgradeUILayer(); if (pRet && pRet->init(basePanel, index)) { pRet->autorelease(); return pRet; } else { delete pRet; pRet = NULL; return NULL; } }
NS_CC_BEGIN Technique* Technique::createWithGLProgramState(Material* parent, GLProgramState* state) { auto technique = new (std::nothrow) Technique(); if (technique && technique->init(parent)) { auto pass = Pass::createWithGLProgramState(technique, state); technique->addPass(pass); technique->autorelease(); return technique; } return nullptr; }
SpriteButton* SpriteButton::create(const char* pImage , std::function<void(Ref*)> selector ,bool SwallowTouch , bool selectedStastus ) { auto pRet = new SpriteButton(); if(pRet->init(pImage,selector,SwallowTouch,selectedStastus)) { pRet->autorelease(); return pRet; } else { delete pRet; pRet = nullptr; return nullptr; } }
Monster* Monster::create(int ID) { auto monster = new Monster(); if(monster && monster->init(ID)) { monster->autorelease(); } else { CC_SAFE_DELETE(monster); } return monster; }
EventStageScene::Listener* EventStageScene::Listener::clone() { auto ret = new EventStageScene::Listener; if (ret && ret->init()) { ret->autorelease(); ret->onLostFocus = onLostFocus; ret->onGainFocus = onGainFocus; } else { CC_SAFE_DELETE(ret); } return ret; }