CCActionInterval* CCAnimate::reverse(void)
{
CCArray *pOldArray = m_pAnimation->getFrames();
CCArray *pNewArray = new CCArray(pOldArray->count());
if (pOldArray->count() > 0)
{
CCSpriteFrame *pElement;
//CCArray::CCMutableArrayRevIterator iter;
//for (iter = pOldArray->rbegin(); iter != pOldArray->rend(); iter++)
//{
// pElement = *iter;
// if (! pElement)
// {
// break;
// }
// pNewArray->addObject((CCSpriteFrame*)(pElement->copy()->autorelease()));
//}
CCObject* pObj = NULL;
CCARRAY_FOREACH(pOldArray, pObj)
{
pElement = (CCSpriteFrame *)pObj;
if (! pElement)
{
break;
}
pNewArray->addObject((CCSpriteFrame*)(pElement->copy()->autorelease()));
}
void HFHeadImgNode::onMyHeadImgLoaded(CCObject* object)
{
// 本地上传的头像
CCString* image = dynamic_cast<CCString*>(object);
if (image == NULL) {
return;
}
CCSpriteFrame* pFrame = getSpriteFrame(image->getCString());
if (pFrame == NULL)
{
int removeState = remove(image->getCString());
if (removeState==0 && m_retry<6)//重试5次
{
autoDefaultEnable tmp;
m_retry++;
HFUrlImageCache::shared()->loadImageAsync(m_headImgUrl, CCCallFuncO::create(this, callfuncO_selector(HFHeadImgNode::onMyheadImgBack), NULL));
}
return;
}
m_retry = 0;
CCSize ccsz = pFrame->getOriginalSizeInPixels();
m_myPortrait->setDisplayFrame(pFrame);
m_myPortrait->setScale(m_scale * (90.0f/ccsz.width));
m_headImgUrl.clear();
}
Skeleton2D_BoneDisplay* Skeleton2D_BoneDisplay::createWithSpriteFrameName(const char *pszSpriteFrameName,float anchorX,float anchorY)
{
CCSpriteFrame *pSpriteFrame = CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(pszSpriteFrameName);
#if COCOS2D_DEBUG > 0
char msg[256] = {0};
sprintf(msg, "Invalid spriteFrameName: %s", pszSpriteFrameName);
CCAssert(pSpriteFrame != NULL, msg);
#endif
Skeleton2D_BoneDisplay *pobSprite = new Skeleton2D_BoneDisplay();
if (pSpriteFrame && pobSprite && pobSprite->initWithSpriteFrame(pSpriteFrame))
{
pobSprite->setFlipY(true);
pobSprite->autorelease();
CCPoint poffset(anchorX,anchorY);
CCSize psize=pSpriteFrame->getOriginalSize();
float _anchorPointX = poffset.x / psize.width;
float _anchorPointY = (poffset.y) / psize.height;
pobSprite->setAnchorPoint(ccp(_anchorPointX, _anchorPointY));
return pobSprite;
}
CC_SAFE_DELETE(pobSprite);
return NULL;
}
CCActionInterval* CCAnimate::reverse(void)
{
CCMutableArray<CCSpriteFrame*> *pOldArray = m_pAnimation->getFrames();
CCMutableArray<CCSpriteFrame*> *pNewArray = new CCMutableArray<CCSpriteFrame*>(pOldArray->count());
if (pOldArray->count() > 0)
{
CCSpriteFrame *pElement;
CCMutableArray<CCSpriteFrame*>::CCMutableArrayRevIterator iter;
for (iter = pOldArray->rbegin(); iter != pOldArray->rend(); iter++)
{
pElement = *iter;
if (! pElement)
{
break;
}
pNewArray->addObject((CCSpriteFrame*)(pElement->copy()->autorelease()));
}
}
CCAnimation *pNewAnim = CCAnimation::animationWithFrames(pNewArray, m_pAnimation->getDelay());
pNewArray->release();
return CCAnimate::actionWithDuration(m_fDuration, pNewAnim, m_bRestoreOriginalFrame);
}
CCSpriteFrame * CCSpriteFrame::createWithTexture(CCTexture2D* pobTexture, const CCRect& rect)
{
CCSpriteFrame* pRet = new CCSpriteFrame();
pRet->_externalPointer = GAF::GAFMarmaladeGFX::createSpriteFrame(pobTexture->getExternalPointer(), rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
pRet->autorelease();
return pRet;
}
CCSpriteFrame* CCSpriteFrame::frameWithTexture(CCTexture2D* pobTexture, CCRect rect, bool rotated, CCPoint offset, CCSize originalSize)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTexture(pobTexture, rect, rotated, offset, originalSize);
pSpriteFrame->autorelease();
return pSpriteFrame;
}
CCSpriteFrame* CCSpriteFrame::create(const char* filename, const CCRect& rect, bool rotated, const CCPoint& offset, const CCSize& originalSize)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTextureFilename(filename, rect, rotated, offset, originalSize);
CC_SAFE_AUTORELEASE(pSpriteFrame);
return pSpriteFrame;
}
CCSpriteFrame* CCSpriteFrame::createWithTexture(CCTexture2D *pobTexture, const CCRect& rect)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTexture(pobTexture, rect);
CC_SAFE_AUTORELEASE(pSpriteFrame);
return pSpriteFrame;
}
CCObject* CCSpriteFrame::copyWithZone(CCZone *pZone)
{
CCSpriteFrame *pCopy = new CCSpriteFrame();
pCopy->initWithTexture(m_pobTexture, m_obRectInPixels, m_bRotated, m_obOffsetInPixels, m_obOriginalSizeInPixels);
return pCopy;
}
CCSpriteFrame* CCSpriteFrame::frameWithTexture(CCTexture2D *pobTexture, CCRect rect)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTexture(pobTexture, rect);
pSpriteFrame->autorelease();
return pSpriteFrame;
}
CCSpriteFrame* CCSpriteFrame::create(CCTexture2D* pobTexture, const CCRect& rect, bool rotated, const CCPoint& offset, const CCSize& originalSize)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTexture(pobTexture, rect, rotated, offset, originalSize);
pSpriteFrame->autorelease();
return pSpriteFrame;
}
CCSpriteFrame* CCSpriteFrame::create(const char* filename, const CCRect& rect)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTextureFilename(filename, rect);
pSpriteFrame->autorelease();
return pSpriteFrame;
}
CCSpriteFrame* CCSpriteFrame::create(CCTexture2D *pobTexture, const CCRect& rect)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTexture(pobTexture, rect);
pSpriteFrame->autorelease();
return pSpriteFrame;
}
CCSpriteFrame* CCSpriteFrame::createWithTexture(CCTexture2D* pobTexture, const CCRect& rect, bool rotated, const CCPoint& offset, const CCSize& originalSize)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTexture(pobTexture, rect, rotated, offset, originalSize);
CC_SAFE_AUTORELEASE(pSpriteFrame);
return pSpriteFrame;
}
CCObject* CCSpriteFrame::copyWithZone(CCZone *pZone)
{
CC_UNUSED_PARAM(pZone);
CCSpriteFrame *pCopy = new CCSpriteFrame();
CC_SAFE_AUTORELEASE(pCopy);
pCopy->initWithTextureFilename(m_strTextureFilename.c_str(), m_obRectInPixels, m_bRotated, m_obOffsetInPixels, m_obOriginalSizeInPixels);
pCopy->setTexture(m_pobTexture);
return pCopy;
}
void HFHeadImgNode::onMyheadImgBack2(cocos2d::CCObject *pObj)
{
CCString* image = dynamic_cast<CCString*>(pObj);
if (image == NULL) {
return;
}
CCSpriteFrame* pFrame = getSpriteFrame(image->getCString());
if (pFrame == NULL)
{
int removeState = remove(image->getCString());
if (removeState==0 && m_retry<6)//重试5次
{
autoDefaultEnable tmp;
m_retry++;
HFUrlImageCache::shared()->loadImageAsync(m_headImgUrl, CCCallFuncO::create(this, callfuncO_selector(HFHeadImgNode::onMyheadImgBack2), NULL));
}
return;
}
autoDefaultEnable tmp;
m_retry = 0;
CCSize ccsz = pFrame->getOriginalSizeInPixels();
CCSprite* head = CCSprite::createWithSpriteFrame(pFrame);
head->setAnchorPoint(ccp(0.5, 0.5));
if (m_size > 1E-6)
{
CCCommonUtils::setSpriteMaxSize(head, m_size, true);
}
else
{
head->setScale(m_scale);
}
m_myRenderTexture = CCRenderTexture::create(m_cSize.width, m_cSize.height);
m_myRenderTexture->setAnchorPoint(ccp(0.5, 0.5));
ccBlendFunc cbf = {GL_ZERO,GL_ONE_MINUS_SRC_ALPHA};
auto spr = CCLoadSprite::createSprite(m_backImg.c_str());
auto bgCircle = CCLoadSprite::createSprite(m_renderImg.c_str());
spr->setScale(1);
spr->setPosition(ccp(m_cSize.width / 2, m_cSize.height / 2));
if (!m_imgPoint.equals(CCPointZero))
{
head->setPosition(m_imgPoint);
}
bgCircle->setPosition(ccp(m_cSize.width / 2, m_cSize.height / 2));
bgCircle->setBlendFunc(cbf);
m_myRenderTexture->begin();
spr->visit();
head->visit();
bgCircle->visit();
m_myRenderTexture->end();
if (m_clearNode) {
m_myParentNode->removeAllChildrenWithCleanup(true);
}
m_myParentNode->addChild(m_myRenderTexture);
m_headImgUrl.clear();
}
CCObject* CCSpriteFrame::copyWithZone(CCZone *pZone)
{
CC_UNUSED_PARAM(pZone);
CCSpriteFrame *pCopy = new CCSpriteFrame();
pCopy->initWithTexture(m_pobTexture, m_obRect, m_bRotated, m_obOffset, m_obOriginalSize);
return pCopy;
}
NS_CC_BEGIN
// implementation of CCSpriteFrame
CCSpriteFrame* CCSpriteFrame::create(const char* filename, const CCRect& rect)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTextureFilename(filename, rect);
pSpriteFrame->autorelease();
return pSpriteFrame;
}
NS_CC_BEGIN
// implementation of CCSpriteFrame
CCSpriteFrame* CCSpriteFrame::create(const char* filename, const CCRect& rect)
{
CCSpriteFrame *pSpriteFrame = new CCSpriteFrame();;
pSpriteFrame->initWithTextureFilename(filename, rect);
CC_SAFE_AUTORELEASE(pSpriteFrame);
return pSpriteFrame;
}
CCNode *APSSprite::createNode() {
CCNode *node = APSGraphic::createNode();
APSImageHolder *ih = this->getImageHolder();
CCSize contentSize;
CCSize targetSize = APSPlatform::sharedPlatform()->convertSizeToPixels(this->getSize());
if (ih) {
this->m_spriteNode = new CCSprite;
if (this->getIsAnimatable()) {
// Create animation sprite
APSSpriteSheetHolder *sh = (APSSpriteSheetHolder *)ih;
CCSpriteFrame *spriteFrame = sh->getCCSpriteFrameAtIndex(((APSGraphicGroup *)this->getParent())->getDisplayedFrameIndex());
#if COCOS2D_VERSION >= 0x00020000
CCSpriteBatchNode *spriteSheet = CCSpriteBatchNode::createWithTexture(ih->getTexture(), sh->getCount());
#else
CCSpriteBatchNode *spriteSheet = CCSpriteBatchNode::batchNodeWithTexture(ih->getTexture(), sh->getCount());
#endif//APS_SKIP
this->m_node->addChild(spriteSheet);
this->m_spriteNode->initWithSpriteFrame(spriteFrame);
spriteSheet->addChild(this->m_spriteNode);
CCSize size = this->m_spriteNode->getContentSize();
contentSize = APSPlatform::sharedPlatform()->convertSizeToPixels(size);
} else {
// Check if there is a sprite frame in sprite frame cache.
CCSpriteFrame *frame = CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(this->getImageHolder()->getRuntimeFilename().c_str());
if (frame) {
// Use the sprite frame
this->m_spriteNode->initWithSpriteFrame(frame);
contentSize = frame->getOriginalSizeInPixels();
node->addChild(this->m_spriteNode);
} else {
// Normal sprite
this->m_spriteNode->initWithTexture(ih->getTexture());
contentSize = ih->getTexture()->getContentSizeInPixels();
node->addChild(this->m_spriteNode);
}
}
// scale the sprite to match the sizes of texture and sprite
this->m_spriteNode->setScaleX(targetSize.width/contentSize.width);
this->m_spriteNode->setScaleY(targetSize.height/contentSize.height);
}
return node;
}
void CCSpriteFrameCache::removeUnusedSpriteFrames(void)
{
m_pSpriteFrames->begin();
std::string key = "";
CCSpriteFrame *spriteFrame = NULL;
while( (spriteFrame = m_pSpriteFrames->next(&key)) )
{
if( spriteFrame->retainCount() == 1 )
{
CCLOG("cocos2d: CCSpriteFrameCache: removing unused frame: %s", key.c_str());
m_pSpriteFrames->removeObjectForKey(key);
}
}
m_pSpriteFrames->end();
}
// Starts playing a given animation (or nothing if this animation is already playing)
void CocosSpriteActorView::playAnimation(const std::string &name)
{
if (name != _currentAnimation)
{
SpriteActorView::playAnimation(name);
if (_currentAnimation != "")
{
// Sprite wasn't created yet. Create and set parameters
if (!_ccSprite)
{
_ccSprite = CCSprite::spriteWithSpriteFrame(((CocosAnimation *)_animations[_currentAnimation].get())->getFirstFrame());
if (_ccSprite)
{
setPosition(getPosition());
setAngle(getAngle());
setScale(getScale());
setZOrder(getZOrder());
setVisible(isVisible());
setAlpha(getAlpha());
}
}
// The sprite was created, change texture
if (_ccSprite)
{
bool isAnimation = _animations[_currentAnimation]->getFrameCount() > 1;
CCSpriteFrame *frame = ((CocosAnimation *)_animations[_currentAnimation].get())->getFirstFrame();
_ccSprite->setTexture(frame->getTexture());
CCRect frameRect = frame->getRectInPixels();
if (isAnimation)
{
frameRect.origin = frame->getOffsetInPixels();
}
_ccSprite->setTextureRect(frameRect);
_ccSprite->setDisplayFrame(frame);
// If this animation contains more than one frame, play the animation
if (isAnimation)
{
_ccSprite->runAction(((CocosAnimation *)_animations[_currentAnimation].get())->getAnimationAction());
}
}
}
}
}
void HFHeadImgNode::onFBImageLoaded(CCObject* object)
{
//FaceBook头像
CCString* image = dynamic_cast<CCString*>(object);
if (image == NULL) {
return;
}
CCSpriteFrame* spFrame = getSpriteFrame(image->getCString());
if (spFrame == NULL)
{
return;
}
CCSize ccsz = spFrame->getOriginalSizeInPixels();
m_myPortrait->setDisplayFrame(spFrame);
m_myPortrait->setScale(1.7f * (50.0f/ccsz.width)*m_scale);
m_headImgUrl.clear();
}
NS_CC_BEGIN
void TFFrameInfo::getFrames(std::vector<CCSpriteFrame*> &frames)
{
frames.clear();
for ( std::vector<std::string>::iterator iter = pngs.begin(); iter != pngs.end();++iter)
{
std::string &pngName = *iter;
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(pngName.c_str());
CCSpriteFrame *frame = CCSpriteFrame::frameWithTexture(texture,CCRectMake(0,0,texture->getContentSize().width,texture->getContentSize().height));
if (frame)
{
frames.push_back(frame);
frame->retain();
frame->setOffset(ccp(0,0));
}
}
}
void HFHeadImgNode::onMyheadImgBack(cocos2d::CCObject *pObj)
{
CCString* image = dynamic_cast<CCString*>(pObj);
if (image == NULL) {
return;
}
CCSpriteFrame* pFrame = getSpriteFrame(image->getCString());
if (pFrame == NULL)
{
int removeState = remove(image->getCString());
if (removeState==0 && m_retry<6)//重试5次
{
m_retry++;
autoDefaultEnable tmp;
HFUrlImageCache::shared()->loadImageAsync(m_headImgUrl, CCCallFuncO::create(this, callfuncO_selector(HFHeadImgNode::onMyheadImgBack), NULL));
}
return;
}
m_retry = 0;
CCSize ccsz = pFrame->getOriginalSizeInPixels();
autoDefaultEnable tmp;
CCSprite* head = CCSprite::createWithSpriteFrame(pFrame);
if (m_clearNode)
{
m_myParentNode->removeAllChildren();
}
m_myParentNode->addChild(head);
if (m_size > 1E-6)
{
CCCommonUtils::setSpriteMaxSize(head, m_size, true);
}
else
{
head->setScale(m_scale);
}
if (!m_imgPoint.equals(CCPointZero))
{
head->setPosition(m_imgPoint);
}
m_headImgUrl.clear();
}
CCTexture2D* getTexture(std::string theImageFullPath, CCRect& theTextureRect){
// try to load from sprite sheet
std::string anImageFileName;
int aLastSlashIndex = MAX((int)theImageFullPath.find_last_of('/'), (int)theImageFullPath.find_last_of('\\'));
if (aLastSlashIndex != std::string::npos) {
anImageFileName = theImageFullPath.substr(aLastSlashIndex + 1);
} else {
anImageFileName = theImageFullPath;
}
CCSpriteFrame *aSpriteFrame = CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(anImageFileName.c_str());
if (aSpriteFrame) {
theTextureRect = aSpriteFrame->getRect();
return aSpriteFrame->getTexture();
}
CCTexture2D* aTexture = CCTextureCache::sharedTextureCache()->addImage(theImageFullPath.c_str());
theTextureRect.origin = CCPointZero;
theTextureRect.size = aTexture->getContentSize();
return aTexture;
}
// Sets the tile's texture according to the given ID. If this is the first time the tile is set, also create the cocos sprite
void CocosTile::setID(std::string tileID)
{
Tile::setID(tileID);
// Load texture according to given ID
CCSpriteFrame *frame = loadSpriteFrame(_tileName + "_" + tileID + "." + _tileExt);
if (frame)
{
// Set texture to sprite
if (_sprite)
{
_sprite->setTexture(frame->getTexture());
_sprite->setTextureRect(frame->getRect());
}
else
{
// Sprite not created yet, create it using this texture
_sprite = CCSprite::spriteWithSpriteFrame(frame);
}
}
}
void SkeletonCocos2D::Load(const char* skelFilename, const char* texFilenameDesc, const char* texFilename, const char* useSkeletonName)
{
//////////////////////////////////////////////////////////////////////////
unsigned long _size=0;
char *_pFileContent = (char*)CCFileUtils::sharedFileUtils()->getFileData(CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(skelFilename) , "r", &_size);
TiXmlDocument _document;
_document.Parse(_pFileContent, 0, TIXML_ENCODING_UTF8);
m_resource=new Skeleton2DResourceAvatar;
m_resource->LoadAll(_document.RootElement());
m_skeleton->AttachResource(m_resource->GetSkeleton(useSkeletonName));
//////////////////////////////////////////////////////////////////////////
char *texDescContent = (char*)CCFileUtils::sharedFileUtils()->getFileData(CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(texFilenameDesc) , "r", &_size);
TiXmlDocument xmlTexDesc;
xmlTexDesc.Parse(texDescContent, 0, TIXML_ENCODING_UTF8);
m_textureDesc = m_resource->AddTextureResource(xmlTexDesc.RootElement());
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(texFilename));
for (Skeleton2DResourceTexture::Name2SubTexture::iterator it = m_textureDesc->m_subTexs.begin()
;it != m_textureDesc->m_subTexs.end();++it)
{
const RString& subTexName=it->first;
Skeleton2DResourceSubTexture& subData=it->second;
CCSpriteFrame* spriteFrame = new CCSpriteFrame();
spriteFrame->initWithTexture(texture,
CCRectMake(subData.x, subData.y, subData.width, subData.height),
false,
//CCPointMake(subData.pivotX,subData.pivotY),
CCPointMake(0,0),
CCSizeMake((float)subData.width, (float)subData.height)
);
CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFrame(spriteFrame,subTexName.c_str());
}
m_batchSprite = CCSpriteBatchNode::create(texFilename);
addChild(m_batchSprite);
UpdateBoneImages();
this->scheduleUpdate();
}
bool CScale9SpriteObject::createScale9Sprite(const string& name)
{
string _name = name;
string::size_type pos = name.find(".png", 0);
if (pos != string::npos)
{
_name = name.substr(0, pos);
}
CCSpriteFrame *pFrame = CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(_name.c_str());
if (NULL == pFrame)
{
return false;
}
// OrigBarSize_ = pFrame->getRect().size;
m_pSprite = CCScale9Sprite::createWithSpriteFrameName(_name.c_str(), pFrame->getRect());
if (NULL == m_pSprite)
{
return false;
}
return true;
}
void CCSpriteFrameCache::removeSpriteFramesFromTexture(CCTexture2D* texture)
{
vector<string> keysToRemove;
m_pSpriteFrames->begin();
std::string key = "";
CCDictionary<std::string, CCObject*> *frameDict = NULL;
while( (frameDict = (CCDictionary<std::string, CCObject*>*)m_pSpriteFrames->next(&key)) )
{
CCSpriteFrame *frame = m_pSpriteFrames->objectForKey(key);
if (frame && (frame->getTexture() == texture))
{
keysToRemove.push_back(key);
}
}
m_pSpriteFrames->end();
vector<string>::iterator iter;
for (iter = keysToRemove.begin(); iter != keysToRemove.end(); ++iter)
{
m_pSpriteFrames->removeObjectForKey(*iter);
}
}
