CCSPXFileData* CCSPXLoader::load(const char* spxPath) { unsigned long len; string mappedPath = CCUtils::mapLocalPath(spxPath); char* data = (char*)CCFileUtils::sharedFileUtils()->getFileData(mappedPath.c_str(), "rb", &len); CCSPXFileData* spx = load(data, (size_t)len, 1 / CC_CONTENT_SCALE_FACTOR()); spx->m_path = spxPath; free(data); return spx; }
void ccDrawPoint(const CCPoint& point) { ccVertex2F p = {point.x * CC_CONTENT_SCALE_FACTOR(), point.y * CC_CONTENT_SCALE_FACTOR() }; // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY // Needed states: GL_VERTEX_ARRAY, // Unneeded states: GL_TEXTURE_2D, GL_TEXTURE_COORD_ARRAY, GL_COLOR_ARRAY glDisable(GL_TEXTURE_2D); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glVertexPointer(2, GL_FLOAT, 0, &p); glDrawArrays(GL_POINTS, 0, 1); // restore default state glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_2D); }
void CCDirector::setProjection(ccDirectorProjection kProjection) { CCSize size = m_obWinSizeInPixels; switch (kProjection) { case kCCDirectorProjection2D: // glViewport((GLsizei)0, (GLsizei)0, (GLsizei)size.width, (GLsizei)size.height); CCDirector::sharedDirector()->getOpenGLView()->setViewPortInPoints(0, 0, size.width, size.height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); ccglOrtho(0, size.width, 0, size.height, -1024 * CC_CONTENT_SCALE_FACTOR(), 1024 * CC_CONTENT_SCALE_FACTOR()); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); break; case kCCDirectorProjection3D: // glViewport(0, 0, (GLsizei)size.width, (GLsizei)size.height); CCDirector::sharedDirector()->getOpenGLView()->setViewPortInPoints(0, 0, size.width, size.height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(60, (GLfloat)size.width/size.height, 0.5f, 1500.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt( size.width/2, size.height/2, getZEye(), size.width/2, size.height/2, 0, 0.0f, 1.0f, 0.0f); break; case kCCDirectorProjectionCustom: if (m_pProjectionDelegate) { m_pProjectionDelegate->updateProjection(); } break; default: CCLOG("cocos2d: Director: unrecognized projecgtion"); break; } m_eProjection = kProjection; }
void CCNode::setPositionInPixels(CCPoint newPosition) { m_tPositionInPixels = newPosition; if ( CC_CONTENT_SCALE_FACTOR() == 1) { m_tPosition = m_tPositionInPixels; } else { m_tPosition = ccpMult(newPosition, 1/CC_CONTENT_SCALE_FACTOR()); } m_bIsTransformDirty = m_bIsInverseDirty = true; #if CC_NODE_TRANSFORM_USING_AFFINE_MATRIX m_bIsTransformGLDirty = true; #endif // CC_NODE_TRANSFORM_USING_AFFINE_MATRIX }
void CCCamera::setCenterXYZ(float fCenterX, float fCenterY, float fCenterZ) { float scale = CC_CONTENT_SCALE_FACTOR(); m_fCenterX = fCenterX * scale; m_fCenterY = fCenterY * scale; m_fCenterZ = fCenterZ * scale; m_bDirty = true; }
//------------------------------------------------------------------ // // Rookie Guide Layer // //------------------------------------------------------------------ void CommonRookieGuide::onEnter() { CommonDemo::onEnter(); CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize(); CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin(); CCSprite* g1 = CCSprite::create("Images/grossini.png"); g1->setPosition(ccp(origin.x + visibleSize.width / 4, origin.y + visibleSize.height / 2)); addChild(g1); CCSprite* g2 = CCSprite::create("Images/grossini.png"); g2->setPosition(ccp(origin.x + visibleSize.width * 3 / 4, origin.y + visibleSize.height / 2)); addChild(g2); // create rookie guide CCSimpleRookieGuide* rg = CCSimpleRookieGuide::create(); // set bg rg->setBgColor(ccc4(0xff, 0, 0, 0x4f)); // add region rg->addRegion(g2, CCCallFunc::create(this, callfunc_selector(CommonRookieGuide::onGuideClicked))); // set arrow rg->setArrow(CCSprite::create("Images/f1.png")); rg->pointToRegionCenter(0, 100 / CC_CONTENT_SCALE_FACTOR(), 200); // set hint CCRichLabelTTF* hint = CCRichLabelTTF::create("[color=0xff0000ff]This is rookie guide, you MUST click it![/color]", "Helvetica", 24 / CC_CONTENT_SCALE_FACTOR(), CCSizeMake(150 / CC_CONTENT_SCALE_FACTOR(), 0), kCCTextAlignmentLeft); rg->setHint(hint); rg->shiftHint(-80 / CC_CONTENT_SCALE_FACTOR(), -20 / CC_CONTENT_SCALE_FACTOR()); // add guide layer, must add it after set addChild(rg); }
bool CCLabelAtlas::initWithString(const char *theString, const char *fntFile) { std::string pathStr = CCFileUtils::sharedFileUtils()->fullPathForFilename(fntFile); std::string relPathStr = pathStr.substr(0, pathStr.find_last_of("/"))+"/"; CCDictionary *dict = CCDictionary::createWithContentsOfFile(pathStr.c_str()); CCAssert(((CCString*)dict->objectForKey("version"))->intValue() == 1, "Unsupported version. Upgrade cocos2d version"); std::string texturePathStr = relPathStr + ((CCString*)dict->objectForKey("textureFilename"))->getCString(); CCString *textureFilename = CCString::create(texturePathStr); unsigned int width = ((CCString*)dict->objectForKey("itemWidth"))->intValue() / CC_CONTENT_SCALE_FACTOR(); unsigned int height = ((CCString*)dict->objectForKey("itemHeight"))->intValue() / CC_CONTENT_SCALE_FACTOR(); unsigned int startChar = ((CCString*)dict->objectForKey("firstChar"))->intValue(); this->initWithString(theString, textureFilename->getCString(), width, height, startChar); return true; }
void CCEGLView::setScissorInPoints(float x, float y, float w, float h) { //TODO if (bIsInit) { float factor = m_fScreenScaleFactor / CC_CONTENT_SCALE_FACTOR(); glScissor((GLint)(x * factor) + m_rcViewPort.origin.x, (GLint)(y * factor) + m_rcViewPort.origin.y, (GLint)(w * factor), (GLint)(h * factor)); } }
void CCCamera::setEyeXYZ(float fEyeX, float fEyeY, float fEyeZ) { float scale = CC_CONTENT_SCALE_FACTOR(); m_fEyeX = fEyeX * scale; m_fEyeY = fEyeY * scale; m_fEyeZ = fEyeZ * scale; m_bDirty = true; }
void CCBlade::push(CCPoint v) { if (isReset) { return; } if (CC_CONTENT_SCALE_FACTOR() != 1.0f) { v = ccpMult(v, CC_CONTENT_SCALE_FACTOR()); } #if USE_LAGRANGE if (path.size() == 0) { path.insert(path.begin(),v); return; } CCPoint first = path[0]; if (ccpDistance(v, first) < DISTANCE_TO_INTERPOLATE) { path.insert(path.begin(),v); if (path.size() > pointLimit) { path.pop_back(); } }else{ int num = ccpDistance(v, first) / DISTANCE_TO_INTERPOLATE; CCPoint iv = ccpMult(ccpSub(v, first), (float)1./(num + 1)); for (int i = 1; i <= num + 1; i++) { path.insert(path.begin(),ccpAdd(first, ccpMult(iv, i))); } while (path.size() > pointLimit) { path.pop_back(); } } #else // !USE_LAGRANGE path.push_front(v); if (path.size() > pointLimit) { path.pop_back(); } #endif // !USE_LAGRANGE this->populateVertices(); }
void CCGridBase::set2DProjection() { CCDirector *director = CCDirector::sharedDirector(); CCSize size = director->getWinSizeInPixels(); glViewport(0, 0, (GLsizei)(size.width * CC_CONTENT_SCALE_FACTOR()), (GLsizei)(size.height * CC_CONTENT_SCALE_FACTOR()) ); kmGLMatrixMode(KM_GL_PROJECTION); kmGLLoadIdentity(); kmMat4 orthoMatrix; kmMat4OrthographicProjection(&orthoMatrix, 0, size.width * CC_CONTENT_SCALE_FACTOR(), 0, size.height * CC_CONTENT_SCALE_FACTOR(), -1, 1); kmGLMultMatrix( &orthoMatrix ); kmGLMatrixMode(KM_GL_MODELVIEW); kmGLLoadIdentity(); ccSetProjectionMatrixDirty(); }
void Label::updateBMFontScale() { auto font = _fontAtlas->getFont(); if (_currentLabelType == LabelType::BMFONT) { FontFNT *bmFont = (FontFNT*)font; float originalFontSize = bmFont->getOriginalFontSize(); _bmfontScale = _bmFontSize * CC_CONTENT_SCALE_FACTOR() / originalFontSize; }else{ _bmfontScale = 1.0f; } }
bool CCLabelTTF::initWithString(const char *label, const CCSize& dimensions, CCTextAlignment alignment, const char *fontName, float fontSize) { CCAssert(label != NULL, ""); if (CCSprite::init()) { // shader program setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(SHADER_PROGRAM)); m_tDimensions = CCSizeMake( dimensions.width * CC_CONTENT_SCALE_FACTOR(), dimensions.height * CC_CONTENT_SCALE_FACTOR() ); m_eAlignment = alignment; CC_SAFE_DELETE(m_pFontName); m_pFontName = new std::string(fontName); m_fFontSize = fontSize * CC_CONTENT_SCALE_FACTOR(); this->setString(label); return true; } return false; }
void CCEGLView::setViewPortInPoints(float x, float y, float w, float h) { if (m_pEGL) { float factor = m_fScreenScaleFactor / CC_CONTENT_SCALE_FACTOR(); glViewport((GLint)(x * factor) + m_rcViewPort.X(), (GLint)(y * factor) + m_rcViewPort.Y(), (GLint)(w * factor), (GLint)(h * factor)); } }
/// override contentSize void CCLayerColor::setContentSize(const CCSize& size) { float scale = CC_CONTENT_SCALE_FACTOR(); m_pSquareVertices[1].x = size.width * scale; m_pSquareVertices[2].y = size.height * scale; m_pSquareVertices[3].x = size.width * scale; m_pSquareVertices[3].y = size.height * scale; CCLayer::setContentSize(size); }
void CCRenderTexture::end() { glBindFramebuffer(GL_FRAMEBUFFER, m_nOldFBO); kmGLPopMatrix(); CCDirector *director = CCDirector::sharedDirector(); CCSize size = director->getWinSizeInPixels(); // restore viewport glViewport(0, 0, GLsizei(size.width * CC_CONTENT_SCALE_FACTOR()), GLsizei(size.height * CC_CONTENT_SCALE_FACTOR())); // special viewport for 3d projection + retina display if ( director->getProjection() == kCCDirectorProjection3D && CC_CONTENT_SCALE_FACTOR() != 1 ) { glViewport((GLsizei)(-size.width/2), (GLsizei)(-size.height/2), (GLsizei)(size.width * CC_CONTENT_SCALE_FACTOR()), (GLsizei)(size.height * CC_CONTENT_SCALE_FACTOR())); } director->setProjection(director->getProjection()); }
bool LabelAtlas::initWithString(const std::string& theString, const std::string& fntFile) { std::string pathStr = FileUtils::getInstance()->fullPathForFilename(fntFile); std::string relPathStr = pathStr.substr(0, pathStr.find_last_of("/"))+"/"; ValueMap dict = FileUtils::getInstance()->getValueMapFromFile(pathStr.c_str()); CCASSERT(dict["version"].asInt() == 1, "Unsupported version. Upgrade cocos2d version"); std::string textureFilename = relPathStr + dict["textureFilename"].asString(); unsigned int width = dict["itemWidth"].asInt() / CC_CONTENT_SCALE_FACTOR(); unsigned int height = dict["itemHeight"].asInt() / CC_CONTENT_SCALE_FACTOR(); unsigned int startChar = dict["firstChar"].asInt(); this->initWithString(theString, textureFilename.c_str(), width, height, startChar); return true; }
void Label::enableShadow(const Color4B& shadowColor /* = Color4B::BLACK */,const Size &offset /* = Size(2 ,-2)*/, int blurRadius /* = 0 */) { _shadowEnabled = true; _shadowDirty = true; auto contentScaleFactor = CC_CONTENT_SCALE_FACTOR(); _shadowOffset.width = offset.width * contentScaleFactor; _shadowOffset.height = offset.height * contentScaleFactor; //TODO: support blur for shadow _shadowColor3B.r = shadowColor.r; _shadowColor3B.g = shadowColor.g; _shadowColor3B.b = shadowColor.b; _shadowOpacity = shadowColor.a; if (!_systemFontDirty && !_contentDirty && _textSprite) { auto fontDef = _getFontDefinition(); if (_shadowNode) { if (shadowColor != _shadowColor4F) { _shadowNode->release(); _shadowNode = nullptr; createShadowSpriteForSystemFont(fontDef); } else { _shadowNode->setPosition(_shadowOffset.width, _shadowOffset.height); } } else { createShadowSpriteForSystemFont(fontDef); } } _shadowColor4F.r = shadowColor.r / 255.0f; _shadowColor4F.g = shadowColor.g / 255.0f; _shadowColor4F.b = shadowColor.b / 255.0f; _shadowColor4F.a = shadowColor.a / 255.0f; if (_currentLabelType == LabelType::BMFONT || _currentLabelType == LabelType::CHARMAP) { if (_shadowEnabled) { setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR)); } else { setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR_NO_MVP)); } } }
void CCEGLView::setScissorInPoints(float x, float y, float w, float h) { if (m_pEGL) { float factor = m_fScreenScaleFactor / CC_CONTENT_SCALE_FACTOR(); glScissor((GLint)(x * factor) + m_rcViewPort.left, (GLint)(y * factor) + m_rcViewPort.top, (GLint)(w * factor), (GLint)(h * factor)); } }
EnergyContainer::EnergyContainer() : _winSize(CCDirector::sharedDirector()->getWinSize()), _manager(GameManager::sharedGameManager()) { _energyX = _winSize.width * 0.1f; _energyY = _winSize.height * 0.03f; glLineWidth(ENERGY_DRAW * CC_CONTENT_SCALE_FACTOR()); }
TimerSprite::TimerSprite(const float seconds) : seconds(seconds), secondsLeft(seconds), on(true), penalty(false) { const float scale = CC_CONTENT_SCALE_FACTOR(); const CCSize screenSize = CCDirector::sharedDirector()->getWinSize(); width = screenSize.width*3/5; const LineParams backgroundParams = { .start = vec2(-width/2*scale, 0), .end = vec2(width/2*scale, 0), .edgeCenterDistances = makeVector((float[]){scale, 3*scale + 1}), .edgeColors = makeVector((vec4[]){vec4(1,1,1,0), vec4(1,1,1,0.2f)}) };
void CCEGLView::setViewPortInPoints(float x, float y, float w, float h) { // TODO CCLOG("%s(%d):%s called", __FILE__, __LINE__, __FUNCTION__); // if (bIsInit) { float factor = m_fScreenScaleFactor / CC_CONTENT_SCALE_FACTOR(); glViewport((GLint)(x * factor) + m_rcViewPort.origin.x, (GLint)(y * factor) + m_rcViewPort.origin.y, (GLint)(w * factor), (GLint)(h * factor)); } }
bool CCLabelTTF::initWithString(const char *label, const CCSize& dimensions, CCTextAlignment alignment, const char *fontName, float fontSize) { CCAssert(label != NULL, ""); if (CCSprite::init()) { m_tDimensions = CCSizeMake( dimensions.width * CC_CONTENT_SCALE_FACTOR(), dimensions.height * CC_CONTENT_SCALE_FACTOR() ); m_eAlignment = alignment; if (m_pFontName) { delete m_pFontName; m_pFontName = NULL; } m_pFontName = new std::string(fontName); m_fFontSize = fontSize * CC_CONTENT_SCALE_FACTOR(); this->setString(label); return true; } return false; }
void LabelTTFLoader::onHandlePropTypePosition(cocos2d::Node * pNode,cocos2d:: Node * pParent, const char* pPropertyName, cocos2d::Point pPosition, CCBReader * ccbReader) { if(strcmp(pPropertyName, PROPERTY_SHADOWOFFSET) == 0) { auto contentScaleFactor = CC_CONTENT_SCALE_FACTOR(); this->_shadowOffset = Size(pPosition.x / contentScaleFactor, pPosition.y / contentScaleFactor); ((Label *)pNode)->enableShadow(this->_shadowColor, this->_shadowOffset, this->_shadowBlurRadius); } else { NodeLoader::onHandlePropTypePosition(pNode, pParent, pPropertyName, pPosition, ccbReader); } }
void CCTransitionRadialCCW::onEnter() { CCTransitionScene::onEnter(); // create a transparent color layer // in which we are going to add our rendertextures CCSize size = CCDirector::sharedDirector()->getWinSize(); // create the second render texture for outScene m_OutRT = CCRenderTexture::renderTextureWithWidthAndHeight((int)size.width, (int)size.height); if (NULL == m_OutRT) return; m_OutRT->retain(); m_OutRT->getSprite()->setAnchorPoint(ccp(0.5f,0.5f)); m_OutRT->setPosition(ccp(size.width/2, size.height/2)); m_OutRT->setAnchorPoint(ccp(0.5f,0.5f)); // We need the texture in RenderTexture. CCProgressTimer *outNode = CCProgressTimer::progressWithTexture(m_OutRT->getSprite()->getTexture()); // but it's flipped upside down so we flip the sprite outNode->getSprite()->setFlipY(true); // fix content scale factor for radial texture CCRect rect = CCRectZero; rect.size = m_OutRT->getSprite()->getTexture()->getContentSize(); outNode->getSprite()->setTextureRect(rect, false); float scale = 1.0f / CC_CONTENT_SCALE_FACTOR(); rect.size.width *= scale; rect.size.height *= scale; outNode->setContentSize(rect.size); // Return the radial type that we want to use outNode->setType(radialType()); outNode->setPercentage(100.f); outNode->setPosition(ccp(size.width/2, size.height/2)); outNode->setAnchorPoint(ccp(0.5f,0.5f)); // create the blend action CCAction * layerAction = CCSequence::actions ( CCProgressFromTo::actionWithDuration(m_fDuration, 100.0f, 0.0f), CCEventCall::actionWithTarget(NULL, createEventHandler(this, &CCTransitionScene::_finish)), NULL ); // run the blend action outNode->runAction(layerAction); // add the layer (which contains our two rendertextures) to the scene this->addChild(outNode, 2, kSceneRadial); }
bool CCLabelTTF::initWithString(const char *label, const char *fontName, float fontSize) { assert(label != NULL); if (CCSprite::init()) { m_tDimensions = CGSizeZero; m_sFontName = fontName; m_fFontSize = fontSize * CC_CONTENT_SCALE_FACTOR(); this->setString(label); return true; } return false; }
void CCNode::setContentSize(CCSize size) { if( ! CCSize::CCSizeEqualToSize(size, m_tContentSize) ) { m_tContentSize = size; if( CC_CONTENT_SCALE_FACTOR() == 1 ) { m_tContentSizeInPixels = m_tContentSize; } else { m_tContentSizeInPixels = CCSizeMake( size.width * CC_CONTENT_SCALE_FACTOR(), size.height * CC_CONTENT_SCALE_FACTOR() ); } m_tAnchorPointInPixels = ccp( m_tContentSizeInPixels.width * m_tAnchorPoint.x, m_tContentSizeInPixels.height * m_tAnchorPoint.y ); m_bIsTransformDirty = m_bIsInverseDirty = true; #ifdef CC_NODE_TRANSFORM_USING_AFFINE_MATRIX m_bIsTransformGLDirty = true; #endif } }
void ccDrawLine(const CCPoint& origin, const CCPoint& destination) { ccVertex2F vertices[2] = { {origin.x * CC_CONTENT_SCALE_FACTOR(), origin.y * CC_CONTENT_SCALE_FACTOR()}, {destination.x * CC_CONTENT_SCALE_FACTOR(), destination.y * CC_CONTENT_SCALE_FACTOR()}, }; // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY // Needed states: GL_VERTEX_ARRAY, // Unneeded states: GL_TEXTURE_2D, GL_TEXTURE_COORD_ARRAY, GL_COLOR_ARRAY glDisable(GL_TEXTURE_2D); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glVertexPointer(2, GL_FLOAT, 0, vertices); glDrawArrays(GL_LINES, 0, 2); // restore default state glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_2D); }
const std::string LHSettings::imagePath(const std::string& image){ std::string computedFile = image; if(isIpad()) { // CCLog("IS IPAD"); if(device != 1 && device != 3)//if ipad only then we dont need to apply transformations { if(CC_CONTENT_SCALE_FACTOR() == 2) { //we have ipad retina size_t found; found=computedFile.find_last_of("."); #if COCOS2D_VERSION < 0x00020000 computedFile.insert(found, hd2xSuffix); #endif } else { //we have normal ipad - lets use the HD image size_t found; found=computedFile.find_last_of("."); #if COCOS2D_VERSION < 0x00020000 computedFile.insert(found, hdSuffix); #endif } } #if COCOS2D_VERSION >= 0x00020100 const char* fullpath = CCFileUtils::sharedFileUtils()->fullPathForFilename(computedFile.c_str()).c_str(); #elif COCOS2D_VERSION >= 0x00020000 const char* fullpath = CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(computedFile.c_str()); #else const char* fullpath = CCFileUtils::fullPathFromRelativePath(computedFile.c_str()); #endif std::ifstream infile; infile.open (fullpath); if(true == infile.is_open()){ //IF THIS FAILS IT MEANS WE HAVE NO -hd file infile.close(); return std::string(fullpath); } } // CCLog("RETURNING %s", image.c_str()); return image; }
void CCProgressHUD::draw() { CCLayerColor::draw(); // draw panel const CCSize& contentSize = getContentSize(); CCPoint size = ccp(m_panelSize.width, m_panelSize.height); if(m_forceSquare) { size.x = size.y = MAX(size.x, size.y); } CCPoint origin = ccp(contentSize.width / 2 - size.x / 2, contentSize.height / 2 - size.y / 2); CCPoint dest = ccpAdd(origin, size); ccDrawSolidRoundRect(origin, dest, 15 / CC_CONTENT_SCALE_FACTOR(), m_panelColor); }