自学教程：C++ CC_CONTENT_SCALE_FACTOR函数代码示例

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 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 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 contentSizevoid 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);}