// on "init" you need to initialize your instance
bool HelloWorld::init()
{
//////////////////////////////
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
this->setTouchEnabled(true);
CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
CCImage *image = new CCImage();
image->initWithImageFile("example.png");
texture = new CCTexture2DMutable();
texture->initWithImage(image);
sprite = CCSprite::create();
sprite->initWithTexture(texture);
sprite->setPosition(ccp(origin.x + visibleSize.width/2, origin.y + visibleSize.height/2));
this->addChild(sprite);
CCLabelTTF *label = CCLabelTTF::create("", "Verdana-BoldItalic", 15);
label->setColor(ccWHITE);
label->setTag(1);
label->setPosition(ccp(origin.x + visibleSize.width/2, origin.y + visibleSize.height/2 - 75));
label->setString("Touch sprite");
this->addChild(label);
return true;
}
ToyBrick* ToyLayer::CreateBrick_Circle()
{
int num = CommonHelper::GetRandomNum(1, 30);
//image && texture
char path[255];
sprintf(path, "Images/ToyBrick/Circle/%d.png", num);
CCImage *img = new CCImage();
img->autorelease();
if (!img->initWithImageFile(path, cocos2d::CCImage::kFmtPng))
{
return NULL;
}
CCTexture2D *texture = new CCTexture2D();
texture->autorelease();
if (!texture->initWithImage(img))
{
return NULL;
}
//
ToyBrick *brick = ToyBrick::create();
CCSize size = texture->getContentSize();
brick->Init(texture, CCRectMake(0, 0, size.width, size.height));
brick->SetAsCircle(64);
return brick;
}
void VolatileTexture::reloadAllTextures()
{
isReloading = true;
CCLOG("reload all texture");
std::list<VolatileTexture *>::iterator i = textures.begin();
while( i != textures.end() )
{
VolatileTexture *vt = *i++;
if (vt->m_bIsString)
{
vt->texture->initWithString(vt->m_strText.c_str(),
vt->m_size,
vt->m_alignment,
vt->m_strFontName.c_str(),
vt->m_fFontSize);
}
else
{
CCImage image;
CCFileData data(vt->m_strFileName.c_str(), "rb");
unsigned long nSize = data.getSize();
unsigned char* pBuffer = data.getBuffer();
if (image.initWithImageData((void*)pBuffer, nSize, vt->m_FmtImage))
{
vt->texture->initWithImage(&image);
}
}
}
isReloading = false;
}
bool CCRenderTexture::saveBuffer(const char *fileName, int format)
{
bool bRet = false;
CCAssert(format == kCCImageFormatJPG || format == kCCImageFormatPNG,
"the image can only be saved as JPG or PNG format");
CCImage *pImage = new CCImage();
if (pImage != NULL && getUIImageFromBuffer(pImage))
{
std::string fullpath = CCFileUtils::getWriteablePath() + fileName;
if (kCCImageFormatPNG == format)
{
fullpath += ".png";
}
else
{
fullpath += ".jpg";
}
bRet = pImage->saveToFile(fullpath.c_str());
}
CC_SAFE_DELETE(pImage);
return bRet;
}
void CCSpriteEx::setTexture(CCTexture2D *texture) {
// If batchnode, then texture id should be the same
CCAssert(! m_pobBatchNode || texture->getName() == m_pobBatchNode->getTexture()->getName(), "CCSprite: Batched sprites should use the same texture as the batchnode");
// accept texture==nil as argument
CCAssert( !texture || dynamic_cast<CCTexture2D*>(texture), "setTexture expects a CCTexture2D. Invalid argument");
if (NULL == texture)
{
// Gets the texture by key firstly.
texture = CCTextureCache::sharedTextureCache()->textureForKey(CC_2x2_WHITE_IMAGE_KEY);
// If texture wasn't in cache, create it from RAW data.
if (NULL == texture)
{
CCImage* image = new CCImage();
bool isOK = image->initWithImageData(cc_2x2_white_image, sizeof(cc_2x2_white_image), CCImage::kFmtRawData, 2, 2, 8);
CCAssert(isOK, "The 2x2 empty texture was created unsuccessfully.");
texture = CCTextureCache::sharedTextureCache()->addUIImage(image, CC_2x2_WHITE_IMAGE_KEY);
CC_SAFE_RELEASE(image);
}
}
if (!m_pobBatchNode && m_pobTexture != texture)
{
CC_SAFE_RETAIN(texture);
CC_SAFE_RELEASE(m_pobTexture);
m_pobTexture = texture;
if(m_shouldUpdateBlendFunc)
updateBlendFunc();
}
}
NS_CC_BEGIN
//
// ParticleFire
//
static CCTexture2D* getDefaultTexture()
{
CCTexture2D* pTexture = NULL;
CCImage* pImage = NULL;
do
{
bool bRet = false;
const char* key = "__firePngData";
pTexture = CCTextureCache::sharedTextureCache()->textureForKey(key);
CC_BREAK_IF(pTexture != NULL);
pImage = new CCImage();
CC_BREAK_IF(NULL == pImage);
bRet = pImage->initWithImageData((void*)__firePngData, sizeof(__firePngData), kFmtPng);
CC_BREAK_IF(!bRet);
pTexture = CCTextureCache::sharedTextureCache()->addUIImage(pImage, key);
} while (0);
CC_SAFE_RELEASE(pImage);
return pTexture;
}
bool
MCFaceBox::init(const char *aFaceFilepath, const char *aBoxFilepath)
{
do {
CCImage *aFaceImage = new CCImage;
CC_BREAK_IF(! aFaceImage);
CCImage *aBoxImage = new CCImage;
CC_BREAK_IF(! aBoxImage);
CCTexture2D *aFaceTexture = new CCTexture2D;
CC_BREAK_IF(! aFaceTexture);
CCTexture2D *aBoxTexture = new CCTexture2D;
CC_BREAK_IF(! aBoxTexture);
CC_BREAK_IF(! aFaceImage->initWithImageFile(aFaceFilepath));
CC_BREAK_IF(! aBoxImage->initWithImageFile(aBoxFilepath));
CC_BREAK_IF(! aFaceTexture->initWithImage(aFaceImage));
CC_BREAK_IF(! aBoxTexture->initWithImage(aBoxImage));
return init(aFaceTexture, aBoxTexture);
} while (0);
return false;
}
NS_CC_BEGIN
static CCTexture2D* getDefaultTexture ( KDvoid )
{
CCTexture2D* pTexture = KD_NULL;
do
{
const KDchar* szKey = "__firePngData";
pTexture = CCTextureCache::sharedTextureCache ( )->textureForKey ( szKey );
CC_BREAK_IF ( pTexture != KD_NULL );
CCImage* pImage = new CCImage ( );
if ( pImage && pImage->initWithData ( (KDvoid*) __firePngData, sizeof ( __firePngData ) ) )
{
pImage->autorelease ( );
pTexture = CCTextureCache::sharedTextureCache ( )->addCCImage ( pImage, szKey );
}
else
{
CC_SAFE_DELETE ( pImage );
}
} while ( 0 );
return pTexture;
}
bool ScreenHelper::AddOBBSpriteToCache(const char *name, const char *plistName)
{
unsigned long pSize;
unsigned char * pData = 0;
//#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) && !defined KINDLE__
// std::vector<std::string> paths;
// paths.push_back("/mnt/sdcard/Android/obb");
// CCFileUtils::sharedFileUtils()->setSearchPaths(paths);
//#endif
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
std::string fullPath = CCFileUtils::sharedFileUtils()->fullPathForFilename("main.1.com.LudicrousGames.MonkeyDroid.zip");
//CCLOG(fullPath.c_str());
pData = CCFileUtils::sharedFileUtils()->getFileDataFromZip(fullPath.c_str(), name, &pSize);
//CCLOG("%d",pData);
if(pData)
{
CCImage* img = new CCImage();
img->initWithImageData(pData, pSize);
CCTextureCache::sharedTextureCache()->addUIImage(img, CCFileUtils::sharedFileUtils()->fullPathFromRelativeFile(name, plistName));
CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile(plistName);
return true;
}
return false;
#else
CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFramesWithFile(plistName,name);
#endif
}
AnimatedCell::AnimatedCell(int cellX, int cellY, int spacing, const char* pngFileName) {
this->setSpace(spacing);
this->setPngFileName(pngFileName);
animation_ = CCAnimation::create();
CCImage* image = new CCImage();
image->initWithImageFile(pngFileName);
CCTexture2D* texture = new CCTexture2D();
texture->initWithImage(image);
oneWidth_ = texture->getPixelsWide() / spacing;
oneHeight_ = texture->getPixelsHigh();
for (int i=0; i<spacing; i++) {
animation_->addSpriteFrameWithTexture(texture,
CCRectMake(i*oneWidth_, 0, oneWidth_, oneHeight_));
}
CCSpriteFrame* frm = ((CCAnimationFrame*)(animation_->getFrames()->objectAtIndex(0)))->getSpriteFrame();
this->initWithSpriteFrame(frm);
animation_->setDelayPerUnit(0.5f);
animate_ = CCRepeatForever::create(CCAnimate::create(animation_));
setCell(cellX, cellY);
}
static void loadImageData(AsyncStruct *pAsyncStruct)
{
const char *filename = pAsyncStruct->filename.c_str();
// compute image type
CCImage::EImageFormat imageType = computeImageFormatType(pAsyncStruct->filename);
if (imageType == CCImage::kFmtUnKnown)
{
CCLOG("unsupported format %s",filename);
delete pAsyncStruct;
return;
}
// generate image
CCImage *pImage = new CCImage();
if (pImage && !pImage->initWithImageFileThreadSafe(filename, imageType))
{
CC_SAFE_RELEASE(pImage);
CCLOG("can not load %s", filename);
return;
}
// generate image info
ImageInfo *pImageInfo = new ImageInfo();
pImageInfo->asyncStruct = pAsyncStruct;
pImageInfo->image = pImage;
pImageInfo->imageType = imageType;
// put the image info into the queue
pthread_mutex_lock(&s_ImageInfoMutex);
s_pImageQueue->push(pImageInfo);
pthread_mutex_unlock(&s_ImageInfoMutex);
}
void CCIDefineBitsJPEG3::loadImageData(UI8 * imageData){
this->decodeInfo(imageData);
int start = this->findJpegStart(imageData);
imageData +=start;
CCImage::EImageFormat eImageFormat = CCImage::kFmtUnKnown;
CCImage image;
image.initWithImageData((void*)imageData, imageSize-start, eImageFormat);
if (tagLength-6-this->alphaDataOffset>0) {
int length = this->width*this->height;
UI8 * data = new UI8[length];
int count = 0;
count = ZipUtils::ccInflateMemoryWithHint(this->bitmapAlphaData, tagLength-6-this->alphaDataOffset, &data,length);
UI8 * alphaData = new UI8[count];
memcpy(alphaData,data,count);
delete [] data;
this->createTextureWithImageAndAlpha(&image,alphaData);
delete[] alphaData;
}
}
void ChatWidget::setRecHead(std::string *head)
{
float bw = 70;
float bh = 70;
if(head == 0 || head->size() == 0)
return;
if(m_toLabel)
m_toLabel->setVisible(false);
if(m_toHead && m_toHead->getParent()){
m_toHead->removeFromParentAndCleanup(true);
m_toHead = 0;
}
CCImage *img = new CCImage;
img->initWithImageData((void*)head->c_str(),head->size(),
CCImage::kFmtUnKnown);
CCTexture2D *texture = new CCTexture2D;
texture->initWithImage(img);
delete img;
m_toHead = CCSprite::create();
m_toHead->initWithTexture(texture);
CCSize headSize = m_toHead->getContentSize();
m_toHead->setScaleX(60 / headSize.width);
m_toHead->setScaleY(60 / headSize.height);
m_toButton->CCNode::addChild(m_toHead);
m_toHead->setAnchorPoint(ccp(0.5,0.5));
m_toHead->setPosition(ccp(bw/2,bh/2));
}
JNIEXPORT void JNICALL Java_game_mobile_infinity_FacebookManager_jniCallbackPicture(JNIEnv* env, jobject thiz, jstring jid , jbyteArray jimage)
{
const char *id = env->GetStringUTFChars( jid, 0);
CCString* cfbID = CCString::createWithFormat("%s",id);
int len = env->GetArrayLength(jimage);
char* byteData = (char*)malloc(len);
env->GetByteArrayRegion(jimage,0,len,(jbyte*)byteData);
CCImage* imf = new CCImage();
imf->initWithImageData(byteData,len);
imf->autorelease();
CCTexture2D* pTexture = new CCTexture2D();
pTexture->initWithImage(imf);
pTexture->autorelease();
CCSprite *sprit = CCSprite::createWithTexture(pTexture);
Facebook_Manager::sharedInstance()->Callback_Picture(cfbID, sprit);
env->ReleaseStringUTFChars( jid, id);
}
ToyBrick* DancingBoneLayer::CreateArm()
{
//image && texture
char path[255];
sprintf(path, "Images/DancingBone/arm.png");
CCImage *img = new CCImage();
img->autorelease();
if (!img->initWithImageFile(path, CCImage::kFmtPng))
{
return NULL;
}
CCTexture2D *texture = new CCTexture2D();
texture->autorelease();
if (!texture->initWithImage(img))
{
return NULL;
}
//
ToyBrick *brick = ToyBrick::create();
CCSize size = texture->getContentSize();
brick->Init(texture, CCRectMake(0, 0, size.width, size.height));
//vector (24, 102)
CCPointArray *vector = CCPointArray::create(4);
vector->addControlPoint(ccp(-12, -50));
vector->addControlPoint(ccp(12, -50));
vector->addControlPoint(ccp(12, 50));
vector->addControlPoint(ccp(-12, 50));
brick->SetAsPolygon(vector);
return brick;
}
cocos2d::CCSprite* CreateOBBSprite(const char *name)
{
//#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) && !defined KINDLE__
// std::vector<std::string> paths;
// paths.push_back("/mnt/sdcard/Android/obb");
// CCFileUtils::sharedFileUtils()->setSearchPaths(paths);
//#endif
std::string fullPath = CCFileUtils::sharedFileUtils()->fullPathForFilename("main.1.com.LudicrousGames.MonkeyDroid.zip");
unsigned long pSize;
unsigned char * pData = 0;
pData = CCFileUtils::sharedFileUtils()->getFileDataFromZip(fullPath.c_str(), name, &pSize);
if(pData)
{
CCImage* img = new CCImage();
img->initWithImageData(pData, pSize);
CCTexture2D* texture = CCTextureCache::sharedTextureCache()->addUIImage(img, name);
CCSprite* sprite = CCSprite::createWithTexture(texture);
return sprite;
}
else
{
return NULL;
}
}
CCTexture2D* MapTexturePool::addImage(const char* path, bool keep)
{
NDAsssert(path != NULL);
CCTexture2D* pkTexture = NULL;
// MUTEX:
// Needed since addImageAsync calls this method from a different thread
pkTexture = (CCTexture2D*)m_pkDict->objectForKey(path);
if (!pkTexture)
{
CCImage image;
if (image.initWithImageFile(path))
{
//todo
//tex = [ [CCTexture2D alloc] initWithImage:image keepData:keep];
}
if (pkTexture)
{
m_pkDict->setObject(pkTexture, path);
pkTexture->release();
}
}
return pkTexture;
}
CCTexture2D* Util::getGrayTexture(const char* filename){
typedef enum {
RED = 0,
GREEN = 1,
BLUE = 2,
ALPHA = 3
} PIXELS;
CCImage *image = new CCImage();
image->initWithImageFile(filename);
unsigned char* pixels = image->getData();
int len = image->getDataLen();
uint32_t *p = (uint32_t *)pixels;
for(int i=0;i<len;i++){
uint8_t *rgbaPixel = (uint8_t *) &p[i];
//uint32_t gray = 0.3 * rgbaPixel[RED] + 0.59 * rgbaPixel[GREEN] + 0.11 * rgbaPixel[BLUE];
uint32_t gray = 1.2*rgbaPixel[RED] + 1.0*rgbaPixel[GREEN] + 0.0*rgbaPixel[BLUE];
// set the pixels to gray
rgbaPixel[RED] = gray;
rgbaPixel[GREEN] = gray;
rgbaPixel[BLUE] = gray;
}
CCTexture2D* texture = new CCTexture2D();
texture->autorelease();
texture->initWithImage(image);
image->release();
return texture;
}
void AskAsFriendDialog::finish()
{
LangDef *lang = ResourceMgr::getInstance()->getLangDef();
BasButton *okButton = new BasButton;
okButton->setButtonInfo(lang->getStringById(StringEnum::Ok).data(),"fonts/uifont24.fnt","default","buttonbg",
CCSizeMake(0,0));
okButton->setClickCB(m_okListener,m_okFunc);
this->addChild(okButton);
okButton->setBottomMargin(m_edgeSize);
okButton->setBottom("parent",uilib::Bottom);
okButton->setHorizontal("parent",0.75);
BasButton *rejectButton = new BasButton;
rejectButton->setButtonInfo(lang->getStringById(StringEnum::Reject).data(),"fonts/uifont24.fnt","default","buttonbg",
CCSizeMake(0,0));
rejectButton->setClickCB(m_rejectListener,m_rejectFunc);
this->addChild(rejectButton);
rejectButton->setBottomMargin(m_edgeSize);
rejectButton->setBottom("parent",uilib::Bottom);
rejectButton->setHorizontal("parent",0.25);
BasWidget *headWidget;
if(!m_askHead.empty()){
CCImage *img = new CCImage;
img->initWithImageData((void*)m_askHead.c_str(),m_askHead.size(),
CCImage::kFmtUnKnown);
CCTexture2D *texture = new CCTexture2D;
texture->initWithImage(img);
delete img;
CCSprite *sprite = CCSprite::create();
sprite->initWithTexture(texture);
headWidget = new BasNodeDelegateWidget(sprite);
this->addChild(headWidget);
headWidget->setHorizontal("parent",0.5);
headWidget->setVertical("parent",0.3);
}else{
CCSprite *sprite = CCSprite::createWithSpriteFrameName("headdefault.png");
headWidget = new BasNodeDelegateWidget(sprite);
this->addChild(headWidget);
headWidget->setHorizontal("parent",0.5);
headWidget->setVertical("parent",0.3);
}
m_askWord.insert(0," ");
TextScrollArea *area = new TextScrollArea;
area->setTheme("","");
area->setTextInfo(m_askWord,getSystemFont(),40,ccWHITE);
this->addChild(area);
area->setLeft("parent",uilib::Left);
area->setRight("parent",uilib::Right);
area->setLeftMargin(10);
area->setRightMargin(10);
area->setTop(headWidget->getName(),uilib::Bottom);
area->setBottom(rejectButton->getName(),uilib::Top);
}
// 주어진 파일로부터 RGBA를 가져온다.
void HelloWorld::GetPaletteFromFile(char *filename, unsigned char *pPalette, int nNumColors)
{
CCImage *pImage = new CCImage();
CCTexture2D *pTex = new CCTexture2D();
pImage->initWithImageFile(filename, CCImage::kFmtPng);
memcpy(pPalette, pImage->getData(), nNumColors * 4); // RGBA = 4 bytes
}
/* get buffer as CCImage */
CCImage* CCRenderTexture::newCCImage()
{
CCAssert(m_ePixelFormat == kCCTexture2DPixelFormat_RGBA8888, "only RGBA8888 can be saved as image");
if (NULL == m_pTexture)
{
return NULL;
}
const CCSize& s = m_pTexture->getContentSizeInPixels();
// to get the image size to save
// if the saving image domain exeeds the buffer texture domain,
// it should be cut
int nSavedBufferWidth = (int)s.width;
int nSavedBufferHeight = (int)s.height;
GLubyte *pBuffer = NULL;
GLubyte *pTempData = NULL;
CCImage *pImage = new CCImage();
do
{
CC_BREAK_IF(! (pBuffer = new GLubyte[nSavedBufferWidth * nSavedBufferHeight * 4]));
if(! (pTempData = new GLubyte[nSavedBufferWidth * nSavedBufferHeight * 4]))
{
delete[] pBuffer;
pBuffer = NULL;
break;
}
this->begin();
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(0,0,nSavedBufferWidth, nSavedBufferHeight,GL_RGBA,GL_UNSIGNED_BYTE, pTempData);
this->end();
// to get the actual texture data
// #640 the image read from rendertexture is upseted
for (int i = 0; i < nSavedBufferHeight; ++i)
{
memcpy(&pBuffer[i * nSavedBufferWidth * 4],
&pTempData[(nSavedBufferHeight - i - 1) * nSavedBufferWidth * 4],
nSavedBufferWidth * 4);
}
pImage->initWithImageData(pBuffer, nSavedBufferWidth * nSavedBufferHeight * 4, CCImage::kFmtRawData, nSavedBufferWidth, nSavedBufferHeight, 8);
} while (0);
CC_SAFE_DELETE_ARRAY(pBuffer);
CC_SAFE_DELETE_ARRAY(pTempData);
return pImage;
}
void download(void* pCurl)
{
RawTile* pTile = ((curl_data*)pCurl)->pRawTile;
TileResolver* pTileResolver = ((curl_data*)pCurl)->pTileResolver;
//try
{
CCString strUrl = MapStrategyFactory::getStrategy(pTileResolver->getMapSourceId())->getUrl(pTile->x,pTile->y,pTile->z);
std::string strResponse;
CURLcode res;
CURL* curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, strUrl.getCString());
curl_easy_setopt(curl, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.64 Safari/537.31");
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteData);
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 30);
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30);
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&strResponse);
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
res = curl_easy_perform(curl);
int retcode = 0;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE , &retcode);
double length;
res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD , &length);
if (res==CURLE_OK && retcode == 200 && ((int)length)>0 && strResponse.size()>0)
{
CCImage* pImage = new CCImage;
pImage->initWithImageData((void*)strResponse.c_str(),(int)length);
if(((TileResolver*)(pTileResolver))->put2Cache(pTile,pImage))
{
((PhysicMap* )(((TileResolver*)(pTileResolver))->m_pPhysicMap))->m_pHandler->addEvent(pTile,pImage);
}
curl_easy_cleanup(curl);
delete (curl_data*)pCurl;
pCurl = NULL;
}
}
return ;
}
void CAApplication::createStatsLabel()
{
CAImage* texture = NULL;
CAImageCache *ImageCache = CAImageCache::sharedImageCache();
if( m_pFPSLabel && m_pSPFLabel )
{
CC_SAFE_RELEASE_NULL(m_pFPSLabel);
CC_SAFE_RELEASE_NULL(m_pSPFLabel);
CC_SAFE_RELEASE_NULL(m_pDrawsLabel);
ImageCache->removeImageForKey("cc_fps_images");
CCFileUtils::sharedFileUtils()->purgeCachedEntries();
}
CAImagePixelFormat currentFormat = CAImage::defaultAlphaPixelFormat();
CAImage::setDefaultAlphaPixelFormat(kCAImagePixelFormat_RGBA4444);
unsigned char *data = NULL;
unsigned int data_len = 0;
getFPSImageData(&data, &data_len);
CCImage* image = new CCImage();
bool isOK = image->initWithImageData(data, data_len);
if (!isOK) {
CCLOGERROR("%s", "Fails: init fps_images");
return;
}
texture = ImageCache->addUIImage(image, "cc_fps_images");
CC_SAFE_RELEASE(image);
float factor = CCEGLView::sharedOpenGLView()->getDesignResolutionSize().height / 640.0f;
m_pFPSLabel = CALabel::createWithFrame(CCRect(0, 0, 100, 32));
m_pFPSLabel->retain();
m_pFPSLabel->setScale(factor);
m_pFPSLabel->setColor(CAColor_blue);
m_pSPFLabel = CALabel::createWithFrame(CCRect(0, 0, 100, 32));
m_pSPFLabel->retain();
m_pSPFLabel->setScale(factor);
m_pSPFLabel->setColor(CAColor_yellow);
m_pDrawsLabel = CALabel::createWithFrame(CCRect(0, 0, 100, 32));
m_pDrawsLabel->retain();
m_pDrawsLabel->setScale(factor);
m_pDrawsLabel->setColor(CAColor_green);
m_pDrawsLabel->setFrameOrigin(ccpAdd(ccp(0, 64*factor), CC_DIRECTOR_STATS_POSITION));
m_pSPFLabel->setFrameOrigin(ccpAdd(ccp(0, 32*factor), CC_DIRECTOR_STATS_POSITION));
m_pFPSLabel->setFrameOrigin(CC_DIRECTOR_STATS_POSITION);
CAImage::setDefaultAlphaPixelFormat(currentFormat);
}
bool CCRenderTexture::saveToFile(const char *szFilePath)
{
bool bRet = false;
CCImage *pImage = newCCImage();
if (pImage)
{
bRet = pImage->saveToFile(szFilePath, kCCImageFormatJPEG);
}
CC_SAFE_DELETE(pImage);
return bRet;
}
bool CCRenderTexture::saveBuffer(const char *szFilePath, int x, int y, int nWidth, int nHeight)
{
bool bRet = false;
CCImage *pImage = new CCImage();
if (pImage != NULL && getUIImageFromBuffer(pImage, x, y, nWidth, nHeight))
{
bRet = pImage->saveToFile(szFilePath);
}
CC_SAFE_DELETE(pImage);
return bRet;
}
static void loadImageData(AsyncStruct *pAsyncStruct)
{
const char *filename = pAsyncStruct->filename.c_str();
// compute image type
CCImage::EImageFormat imageType = computeImageFormatType(pAsyncStruct->filename);
if (imageType == CCImage::kFmtUnKnown)
{
CCLOG("unsupported format %s",filename);
delete pAsyncStruct;
return;
}
// generate image
CCImage *pImage = new CCImage();
if( pImage )
{
bool bRet = pImage->initWithImageFileThreadSafe(filename, imageType);
if ( !bRet )
{
std::string strFileName = filename;
if( imageType == CCImage::kFmtPng )
{
size_t pos = strFileName.length();
string strOld = ".png";
if((pos = strFileName.rfind(strOld, pos)) != string::npos)
{
strFileName = strFileName.replace(pos, strOld.length(), ".fkp");
imageType = CCImage::kFmtFKP;
bRet = pImage->initWithImageFileThreadSafe(strFileName.c_str(), imageType);
}
}
if( !bRet )
{
CC_SAFE_RELEASE(pImage);
CCLOG("can not load %s", filename);
return;
}
}
}
// generate image info
ImageInfo *pImageInfo = new ImageInfo();
pImageInfo->asyncStruct = pAsyncStruct;
pImageInfo->image = pImage;
pImageInfo->imageType = imageType;
// put the image info into the queue
pthread_mutex_lock(&s_ImageInfoMutex);
s_pImageQueue->push(pImageInfo);
pthread_mutex_unlock(&s_ImageInfoMutex);
}
CCSprite * NewsScene::getImageFromURL(const char* url)
{
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
if(curl)
{
string out = string(url);
struct BufferStruct output;
output.buffer = NULL;
output.size = 0;
curl_easy_setopt(curl, CURLOPT_URL, out.c_str());
string response;
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &output);
res = curl_easy_perform(curl);
if(res != CURLE_OK)
{
fprintf(stderr, "curl_easy_perform() failed: %s\n",curl_easy_strerror(res));
return NULL;
} else {
// FILE * fp;
// fp = fopen( "loucura.png","w");
// if( fp )
// fprintf(fp, output.buffer );
// fclose( fp );
CCImage* img = new CCImage();
img->initWithImageData((void*)output.buffer, (long)output.size, CCImage::kFmtPng);
cocos2d::CCTexture2D* texture = new cocos2d::CCTexture2D(); //TODO:: leak
texture->initWithImage(img);
CCSprite* sprBackground = CCSprite::create(texture);
return sprBackground;
// sprBackground->setAnchorPoint(ccp(0,0));
// sprBackground->setScale(1);
// sprBackground->setPosition(ccp(0,0));
//
// this->addChild(sprBackground);
//
//
// cout << "Variable response : " << &output.buffer;
}
curl_easy_cleanup(curl);
}
curl_global_cleanup();
}
void CMainCityUI::imageLoadSuccessCallBack(string sTag, vector<char>* pBuffer)
{
CCImage* img = new CCImage;
img->initWithImageData((unsigned char*)pBuffer->data(), pBuffer->size());
CCTexture2D* texture = new CCTexture2D();
texture->initWithImage(img);
CLayout* headPart = (CLayout*)m_ui->findWidgetById("head_part");
CCSprite* head = (CCSprite*)headPart->getChildByTag(15);
// head->removeFromParent();
//head->setTexture(texture);
string path = HttpLoadImage::getInstance()->getStoragePath("download/fbImg",sTag.c_str())+".jpg";
string buff(pBuffer->begin(), pBuffer->end());
CCLOG("path: %s", path.c_str());
FILE *fp = fopen(path.c_str(), "wb+");
fwrite(buff.c_str(), 1, pBuffer->size(), fp);
fclose(fp);
// CCSprite *headbg = (CCSprite*)(m_ui->findWidgetById("headbg"));
// CCClippingNode *clip = CCClippingNode::create();
// CCSprite *fbimg = CCSprite::createWithTexture(texture);
// clip->addChild(fbimg);
//
// clip->setPosition(headbg->getPosition());
// clip->setContentSize(CCSizeMake(110,110));
//
// static ccColor4F red ={1,0,1};
// float radius = 106;
// const int nCount = 200;
// const float angle = 2.0f* (float)M_PI/nCount;
// CCPoint circle[nCount];
// for(int i=0; i<nCount; i++)
// {
// float radian = i*angle;
// circle[i].x = radius * cosf(radian);
// circle[i].y = radius * sinf(radian);
// }
// CCDrawNode *stencil= CCDrawNode::create();
// stencil->drawPolygon(circle,nCount,red,0,red);
// clip->setStencil(stencil);
// m_ui->addChild(clip);
CCSprite *headBg = (CCSprite *)(headPart->findWidgetById("headbg"));
CCSprite *headSpr = MakeFaceBookHeadToCircle(CCSprite::createWithTexture(texture));
headSpr->setTag(15);
headSpr->setPosition(headBg->getPosition());
headPart->addChild(headSpr);
head->removeFromParent();
img->release();
}
static CCSprite* createMaskSprite(CCLayerColor* base,
const std::vector<CCRect>& cutoutList)
{
CCSize winSize = CCDirector::sharedDirector()->getWinSize();
// CCRenderTexture* rt = CCRenderTexture::create(winSize.width, winSize.height);
// use a low-precision format
CCRenderTexture* rt = CCRenderTexture::create(winSize.width,
winSize.height,
kTexture2DPixelFormat_RGBA8888);
rt->setAnchorPoint(ccp(0, 0));
rt->setPosition(ccp(0, 0));
ccBlendFunc cutoutBlend = {GL_DST_ALPHA, GL_ZERO};
// render to texture
rt->begin();
base->visit();
CCSprite* s = CCSprite::create("ui/1x1_b.png");
s->setAnchorPoint(ccp(0, 0));
s->setOpacity(0);
for(const CCRect& cutout : cutoutList)
{
s->setPosition(cutout.origin);
s->setScaleX(cutout.size.width * contentScale());
s->setScaleY(cutout.size.height * contentScale());
s->setBlendFunc(cutoutBlend);
s->visit();
}
rt->end();
// render to texture done
std::string randName = std::string("mask_image_") + boost::lexical_cast<std::string>(rand());
CCImage* img = rt->newCCImage(false);
img->autorelease();
CCTexture2D* tex = CCTextureCache::sharedTextureCache()->addUIImage(img,
randName.c_str());
CCSprite *mask = CCSprite::createWithTexture(tex);
mask->setFlipY(true);
mask->setAnchorPoint(ccp(0, 0));
mask->setPosition(ccp(0, 0));
return mask;
}
bool EraserSprite::getEraserOk()
{
m_bEraserOk = false;
CCImage* image = new CCImage();
image = m_pRTex->newCCImage(true);
int m = 3;
if (image->hasAlpha())
{
m = 4;
}
unsigned char *data_= image->getData();
int x = 0, y = 0;
/// 这里要一点，即Opengl下，其中心点坐标在左上角
for (x = 0; x < spriteSize.width; ++x)
{
for (y = 0 ; y < spriteSize.height; ++y)
{
unsigned char *pixel = data_ + (x + y * image->getWidth()) * m;
// You can see/change pixels' RGBA value(0-255) here !
unsigned int r = (unsigned int)*pixel;
unsigned int g = (unsigned int)*(pixel + 1);
unsigned int b = (unsigned int)*(pixel + 2) ;
unsigned int a = (unsigned int)*(pixel + 3);
if (r != 0 && g != 0 && b != 0 && a != 0)
{
m_bEraserOk = false;
break;
}
}
if (spriteSize.height != y)
{
break;
}
}
if (x == spriteSize.width && y == spriteSize.height)
{
m_bEraserOk = true;
}
delete image;
return this->m_bEraserOk;
}
