mirror of https://github.com/axmolengine/axmol.git
997 lines
22 KiB
C++
997 lines
22 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2010 cocos2d-x.org
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
|
|
#include "platform/CCNS.h"
|
|
#include "CCDirector.h"
|
|
#include "CCScene.h"
|
|
#include "NSMutableArray.h"
|
|
#include "CCScheduler.h"
|
|
#include "ccMacros.h"
|
|
#include "CCXCocos2dDefine.h"
|
|
#include "CCTouchDispatcher.h"
|
|
#include "support/opengl_support/glu.h"
|
|
#include "CGPointExtension.h"
|
|
#include "CCTransition.h"
|
|
#include "CCTextureCache.h"
|
|
#include "CCTransition.h"
|
|
#include "CCSpriteFrameCache.h"
|
|
#include "NSAutoreleasePool.h"
|
|
#include "platform/platform.h"
|
|
#include "CCXApplication.h"
|
|
#include "CCLabelBMFont.h"
|
|
#include "CCActionManager.h"
|
|
#include "CCLabelTTF.h"
|
|
#include "CCConfiguration.h"
|
|
#include "CCKeypadDispatcher.h"
|
|
#include "CCGL.h"
|
|
#include "CCAnimationCache.h"
|
|
#include "NSEvent.h"
|
|
|
|
#if CC_ENABLE_PROFILERS
|
|
#include "support/CCProfiling.h"
|
|
#endif // CC_ENABLE_PROFILERS
|
|
|
|
#include <string>
|
|
|
|
using namespace std;
|
|
using namespace cocos2d;
|
|
namespace cocos2d
|
|
{
|
|
|
|
// singleton stuff
|
|
static CCDisplayLinkDirector s_sharedDirector;
|
|
static bool s_bFirstRun = true;
|
|
|
|
#define kDefaultFPS 60 // 60 frames per second
|
|
extern const char* cocos2dVersion(void);
|
|
|
|
CCDirector* CCDirector::sharedDirector(void)
|
|
{
|
|
if (s_bFirstRun)
|
|
{
|
|
s_sharedDirector.init();
|
|
s_bFirstRun = false;
|
|
}
|
|
|
|
return &s_sharedDirector;
|
|
}
|
|
|
|
bool CCDirector::init(void)
|
|
{
|
|
CCLOG("cocos2d: %s", cocos2dVersion());
|
|
|
|
CCLOG("cocos2d: Using Director Type: CCDirectorDisplayLink");
|
|
|
|
// scenes
|
|
m_pRunningScene = NULL;
|
|
m_pNextScene = NULL;
|
|
|
|
m_pNotificationNode = NULL;
|
|
|
|
m_dOldAnimationInterval = m_dAnimationInterval = 1.0 / kDefaultFPS;
|
|
m_pobScenesStack = new NSMutableArray<CCScene*>();
|
|
|
|
// Set default projection (3D)
|
|
m_eProjection = kCCDirectorProjectionDefault;
|
|
|
|
// projection delegate if "Custom" projection is used
|
|
m_pProjectionDelegate = NULL;
|
|
|
|
// FPS
|
|
m_bDisplayFPS = false;
|
|
m_nFrames = 0;
|
|
m_pszFPS = new char[10];
|
|
m_fExpectedFrameRate = (ccTime)(1 / m_dAnimationInterval);
|
|
m_fComputeFrameRateDeltaTime = 0;
|
|
m_pLastComputeFrameRate = new struct cc_timeval();
|
|
m_pLastUpdate = new struct cc_timeval();
|
|
|
|
// paused ?
|
|
m_bPaused = false;
|
|
|
|
m_obWinSizeInPixels = m_obWinSizeInPoints = CGSizeZero;
|
|
|
|
// default values
|
|
m_ePixelFormat = kCCPixelFormatDefault;
|
|
m_eDepthBufferFormat = kCCDepthBufferNone; // 0
|
|
|
|
// portrait mode default
|
|
m_eDeviceOrientation = CCDeviceOrientationPortrait;
|
|
|
|
m_pobOpenGLView = NULL;
|
|
|
|
m_fContentScaleFactor = 1;
|
|
m_bIsContentScaleSupported = false;
|
|
|
|
// create autorelease pool
|
|
NSPoolManager::getInstance()->push();
|
|
|
|
return true;
|
|
}
|
|
|
|
CCDirector::~CCDirector(void)
|
|
{
|
|
CCLOGINFO("cocos2d: deallocing %p", this);
|
|
|
|
#if CC_DIRECTOR_FAST_FPS
|
|
CCX_SAFE_RELEASE(m_pFPSLabel);
|
|
#endif
|
|
|
|
CCX_SAFE_RELEASE(m_pRunningScene);
|
|
CCX_SAFE_RELEASE(m_pNotificationNode);
|
|
CCX_SAFE_RELEASE(m_pobScenesStack);
|
|
|
|
// pop the autorelease pool
|
|
NSPoolManager::getInstance()->pop();
|
|
|
|
// delete m_pLastUpdate
|
|
CCX_SAFE_DELETE(m_pLastUpdate);
|
|
|
|
// delete last compute time
|
|
CCX_SAFE_DELETE(m_pLastComputeFrameRate);
|
|
|
|
CCKeypadDispatcher::purgeSharedDispatcher();
|
|
|
|
// delete fps string
|
|
delete []m_pszFPS;
|
|
}
|
|
|
|
void CCDirector::setGLDefaultValues(void)
|
|
{
|
|
// This method SHOULD be called only after openGLView_ was initialized
|
|
assert(m_pobOpenGLView);
|
|
|
|
setAlphaBlending(true);
|
|
setDepthTest(true);
|
|
setProjection(m_eProjection);
|
|
|
|
// set other opengl default values
|
|
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
|
|
|
#if CC_DIRECTOR_FAST_FPS
|
|
if (! m_pFPSLabel)
|
|
{
|
|
m_pFPSLabel = CCLabelTTF::labelWithString("00.0", "XXX", 24);
|
|
m_pFPSLabel->retain();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Draw the SCene
|
|
void CCDirector::drawScene(void)
|
|
{
|
|
// calculate "global" dt
|
|
calculateDeltaTime();
|
|
|
|
//tick before glClear: issue #533
|
|
if (! m_bPaused)
|
|
{
|
|
CCScheduler::sharedScheduler()->tick(m_fDeltaTime);
|
|
}
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
/* to avoid flickr, nextScene MUST be here: after tick and before draw.
|
|
XXX: Which bug is this one. It seems that it can't be reproduced with v0.9 */
|
|
if (m_pNextScene)
|
|
{
|
|
setNextScene();
|
|
}
|
|
|
|
glPushMatrix();
|
|
|
|
applyOrientation();
|
|
|
|
// By default enable VertexArray, ColorArray, TextureCoordArray and Texture2D
|
|
CC_ENABLE_DEFAULT_GL_STATES();
|
|
|
|
// draw the scene
|
|
if (m_pRunningScene)
|
|
{
|
|
m_pRunningScene->visit();
|
|
}
|
|
|
|
// draw the notifications node
|
|
if (m_pNotificationNode)
|
|
{
|
|
m_pNotificationNode->visit();
|
|
}
|
|
|
|
if (m_bDisplayFPS)
|
|
{
|
|
showFPS();
|
|
}
|
|
|
|
#if CC_ENABLE_PROFILERS
|
|
showProfilers();
|
|
#endif
|
|
|
|
CC_DISABLE_DEFAULT_GL_STATES();
|
|
|
|
glPopMatrix();
|
|
|
|
// swap buffers
|
|
if (m_pobOpenGLView)
|
|
{
|
|
m_pobOpenGLView->swapBuffers();
|
|
}
|
|
}
|
|
|
|
void CCDirector::calculateDeltaTime(void)
|
|
{
|
|
struct cc_timeval now;
|
|
|
|
if (CCTime::gettimeofdayCocos2d(&now, NULL) != 0)
|
|
{
|
|
CCLOG("error in gettimeofday");
|
|
m_fDeltaTime = 0;
|
|
return;
|
|
}
|
|
|
|
// new delta time
|
|
if (m_bNextDeltaTimeZero)
|
|
{
|
|
m_fDeltaTime = 0;
|
|
m_bNextDeltaTimeZero = false;
|
|
}
|
|
else
|
|
{
|
|
m_fDeltaTime = (now.tv_sec - m_pLastUpdate->tv_sec) + (now.tv_usec - m_pLastUpdate->tv_usec) / 1000000.0f;
|
|
m_fDeltaTime = MAX(0, m_fDeltaTime);
|
|
}
|
|
|
|
*m_pLastUpdate = now;
|
|
}
|
|
|
|
|
|
// m_dAnimationInterval
|
|
void CCDirector::setAnimationInterval(double dValue)
|
|
{
|
|
CCLOG("cocos2d: Director#setAnimationInterval. Overrride me");
|
|
assert(0);
|
|
}
|
|
|
|
|
|
// m_pobOpenGLView
|
|
|
|
void CCDirector::setOpenGLView(CC_GLVIEW *pobOpenGLView)
|
|
{
|
|
assert(pobOpenGLView);
|
|
|
|
if (m_pobOpenGLView != pobOpenGLView)
|
|
{
|
|
// because EAGLView is not kind of NSObject
|
|
delete m_pobOpenGLView; // [openGLView_ release]
|
|
m_pobOpenGLView = pobOpenGLView;
|
|
|
|
// set size
|
|
m_obWinSizeInPoints = CCNSSizeToCGSize(m_pobOpenGLView->getSize());
|
|
m_obWinSizeInPixels = CGSizeMake(m_obWinSizeInPoints.width * m_fContentScaleFactor, m_obWinSizeInPoints.height * m_fContentScaleFactor);
|
|
setGLDefaultValues();
|
|
|
|
if (m_fContentScaleFactor != 1)
|
|
{
|
|
updateContentScaleFactor();
|
|
}
|
|
|
|
CCTouchDispatcher *pTouchDispatcher = CCTouchDispatcher::sharedDispatcher();
|
|
m_pobOpenGLView->setTouchDelegate(pTouchDispatcher);
|
|
pTouchDispatcher->setDispatchEvents(true);
|
|
}
|
|
}
|
|
|
|
void CCDirector::setNextDeltaTimeZero(bool bNextDeltaTimeZero)
|
|
{
|
|
m_bNextDeltaTimeZero = bNextDeltaTimeZero;
|
|
}
|
|
|
|
void CCDirector::setProjection(ccDirectorProjection kProjection)
|
|
{
|
|
CGSize size = m_obWinSizeInPixels;
|
|
switch (kProjection)
|
|
{
|
|
case kCCDirectorProjection2D:
|
|
glViewport((GLsizei)0, (GLsizei)0, (GLsizei)size.width, (GLsizei)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);
|
|
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 CCDirector::purgeCachedData(void)
|
|
{
|
|
CCLabelBMFont::purgeCachedData();
|
|
CCTextureCache::purgeSharedTextureCache();
|
|
}
|
|
|
|
float CCDirector::getZEye(void)
|
|
{
|
|
return (m_obWinSizeInPixels.height / 1.1566f);
|
|
}
|
|
|
|
void CCDirector::setAlphaBlending(bool bOn)
|
|
{
|
|
if (bOn)
|
|
{
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(CC_BLEND_SRC, CC_BLEND_DST);
|
|
}
|
|
else
|
|
{
|
|
glDisable(GL_BLEND);
|
|
}
|
|
}
|
|
|
|
void CCDirector::setDepthTest(bool bOn)
|
|
{
|
|
if (bOn)
|
|
{
|
|
ccglClearDepth(1.0f);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glDepthFunc(GL_LEQUAL);
|
|
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
|
|
}
|
|
else
|
|
{
|
|
glDisable(GL_DEPTH_TEST);
|
|
}
|
|
}
|
|
|
|
CGPoint CCDirector::convertToGL(CGPoint obPoint)
|
|
{
|
|
CGSize s = m_obWinSizeInPoints;
|
|
float newY = s.height - obPoint.y;
|
|
float newX = s.width - obPoint.x;
|
|
|
|
CGPoint ret = CGPointZero;
|
|
switch (m_eDeviceOrientation)
|
|
{
|
|
case CCDeviceOrientationPortrait:
|
|
ret = ccp(obPoint.x, newY);
|
|
break;
|
|
case CCDeviceOrientationPortraitUpsideDown:
|
|
ret = ccp(newX, obPoint.y);
|
|
break;
|
|
case CCDeviceOrientationLandscapeLeft:
|
|
ret.x = obPoint.y;
|
|
ret.y = obPoint.x;
|
|
break;
|
|
case CCDeviceOrientationLandscapeRight:
|
|
ret.x = newY;
|
|
ret.y = newX;
|
|
break;
|
|
}
|
|
|
|
// if (m_fContentScaleFactor != 1 && m_bIsContentScaleSupported)
|
|
// {
|
|
// ret = ccpMult(ret, m_fContentScaleFactor);
|
|
// }
|
|
|
|
return ret;
|
|
}
|
|
|
|
CGPoint CCDirector::convertToUI(CGPoint obPoint)
|
|
{
|
|
CGSize winSize = m_obWinSizeInPoints;
|
|
float oppositeX = winSize.width - obPoint.x;
|
|
float oppositeY = winSize.height - obPoint.y;
|
|
CGPoint uiPoint = CGPointZero;
|
|
|
|
switch (m_eDeviceOrientation)
|
|
{
|
|
case CCDeviceOrientationPortrait:
|
|
uiPoint = ccp(obPoint.x, oppositeY);
|
|
break;
|
|
case CCDeviceOrientationPortraitUpsideDown:
|
|
uiPoint = ccp(oppositeX, obPoint.y);
|
|
break;
|
|
case CCDeviceOrientationLandscapeLeft:
|
|
uiPoint = ccp(obPoint.y, obPoint.x);
|
|
break;
|
|
case CCDeviceOrientationLandscapeRight:
|
|
// Can't use oppositeX/Y because x/y are flipped
|
|
uiPoint = ccp(winSize.width - obPoint.y, winSize.height - obPoint.x);
|
|
break;
|
|
}
|
|
|
|
uiPoint = ccpMult(uiPoint, 1/m_fContentScaleFactor);
|
|
return uiPoint;
|
|
}
|
|
|
|
CGSize CCDirector::getWinSize(void)
|
|
{
|
|
CGSize s = m_obWinSizeInPoints;
|
|
|
|
if (m_eDeviceOrientation == CCDeviceOrientationLandscapeLeft
|
|
|| m_eDeviceOrientation == CCDeviceOrientationLandscapeRight)
|
|
{
|
|
// swap x,y in landspace mode
|
|
CGSize tmp = s;
|
|
s.width = tmp.height;
|
|
s.height = tmp.width;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
CGSize CCDirector::getWinSizeInPixels()
|
|
{
|
|
CGSize s = getWinSize();
|
|
|
|
s.width *= CC_CONTENT_SCALE_FACTOR();
|
|
s.height *= CC_CONTENT_SCALE_FACTOR();
|
|
|
|
return s;
|
|
}
|
|
|
|
// return the current frame size
|
|
CGSize CCDirector::getDisplaySizeInPixels(void)
|
|
{
|
|
return m_obWinSizeInPixels;
|
|
}
|
|
|
|
void CCDirector::reshapeProjection(CGSize newWindowSize)
|
|
{
|
|
m_obWinSizeInPoints = m_pobOpenGLView->getSize();
|
|
m_obWinSizeInPixels = CGSizeMake(m_obWinSizeInPoints.width * m_fContentScaleFactor,
|
|
m_obWinSizeInPoints.height * m_fContentScaleFactor);
|
|
|
|
setProjection(m_eProjection);
|
|
}
|
|
|
|
// scene management
|
|
|
|
void CCDirector::runWithScene(CCScene *pScene)
|
|
{
|
|
assert(pScene != NULL);
|
|
assert(m_pRunningScene == NULL);
|
|
|
|
pushScene(pScene);
|
|
startAnimation();
|
|
}
|
|
|
|
void CCDirector::replaceScene(CCScene *pScene)
|
|
{
|
|
assert(pScene != NULL);
|
|
|
|
unsigned int index = m_pobScenesStack->count();
|
|
|
|
m_bSendCleanupToScene = true;
|
|
m_pobScenesStack->replaceObjectAtIndex(index - 1, pScene);
|
|
|
|
m_pNextScene = pScene;
|
|
}
|
|
|
|
void CCDirector::pushScene(CCScene *pScene)
|
|
{
|
|
assert(pScene);
|
|
|
|
m_bSendCleanupToScene = false;
|
|
|
|
m_pobScenesStack->addObject(pScene);
|
|
m_pNextScene = pScene;
|
|
}
|
|
|
|
void CCDirector::popScene(void)
|
|
{
|
|
assert(m_pRunningScene != NULL);
|
|
|
|
m_pobScenesStack->removeLastObject();
|
|
unsigned int c = m_pobScenesStack->count();
|
|
|
|
if (c == 0)
|
|
{
|
|
end();
|
|
}
|
|
else
|
|
{
|
|
m_bSendCleanupToScene = true;
|
|
m_pNextScene = m_pobScenesStack->getObjectAtIndex(c - 1);
|
|
}
|
|
}
|
|
|
|
void CCDirector::end(void)
|
|
{
|
|
// don't release the event handlers
|
|
// They are needed in case the director is run again
|
|
CCTouchDispatcher::sharedDispatcher()->removeAllDelegates();
|
|
|
|
m_pRunningScene->onExit();
|
|
m_pRunningScene->cleanup();
|
|
m_pRunningScene->release();
|
|
|
|
m_pRunningScene = NULL;
|
|
m_pNextScene = NULL;
|
|
|
|
// remove all objects, but don't release it.
|
|
// runWithScene might be executed after 'end'.
|
|
m_pobScenesStack->removeAllObjects();
|
|
|
|
stopAnimation();
|
|
|
|
#if CC_DIRECTOR_FAST_FPS
|
|
CCX_SAFE_RELEASE_NULL(m_pFPSLabel);
|
|
#endif
|
|
|
|
CCX_SAFE_RELEASE_NULL(m_pProjectionDelegate);
|
|
|
|
// purge bitmap cache
|
|
CCLabelBMFont::purgeCachedData();
|
|
|
|
// purge all managers
|
|
CCAnimationCache::purgeSharedAnimationCache();
|
|
CCSpriteFrameCache::purgeSharedSpriteFrameCache();
|
|
CCActionManager::sharedManager()->purgeSharedManager();
|
|
CCScheduler::purgeSharedScheduler();
|
|
CCTextureCache::purgeSharedTextureCache();
|
|
|
|
// OpenGL view
|
|
m_pobOpenGLView->release();
|
|
m_pobOpenGLView = NULL;
|
|
}
|
|
|
|
void CCDirector::setNextScene(void)
|
|
{
|
|
ccSceneFlag runningSceneType = ccNormalScene;
|
|
ccSceneFlag newSceneType = m_pNextScene->getSceneType();
|
|
|
|
if (m_pRunningScene)
|
|
{
|
|
runningSceneType = m_pRunningScene->getSceneType();
|
|
}
|
|
|
|
// If it is not a transition, call onExit/cleanup
|
|
/*if (! newIsTransition)*/
|
|
if (! (newSceneType & ccTransitionScene))
|
|
{
|
|
if (m_pRunningScene)
|
|
{
|
|
m_pRunningScene->onExit();
|
|
}
|
|
|
|
// issue #709. the root node (scene) should receive the cleanup message too
|
|
// otherwise it might be leaked.
|
|
if (m_bSendCleanupToScene && m_pRunningScene)
|
|
{
|
|
m_pRunningScene->cleanup();
|
|
}
|
|
}
|
|
|
|
if (m_pRunningScene)
|
|
{
|
|
m_pRunningScene->release();
|
|
}
|
|
m_pRunningScene = m_pNextScene;
|
|
m_pNextScene->retain();
|
|
m_pNextScene = NULL;
|
|
|
|
if (! (runningSceneType & ccTransitionScene) && m_pRunningScene)
|
|
{
|
|
m_pRunningScene->onEnter();
|
|
m_pRunningScene->onEnterTransitionDidFinish();
|
|
}
|
|
}
|
|
|
|
void CCDirector::pause(void)
|
|
{
|
|
if (m_bPaused)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_dOldAnimationInterval = m_dAnimationInterval;
|
|
|
|
// when paused, don't consume CPU
|
|
setAnimationInterval(1 / 4.0);
|
|
m_bPaused = true;
|
|
}
|
|
|
|
void CCDirector::resume(void)
|
|
{
|
|
if (! m_bPaused)
|
|
{
|
|
return;
|
|
}
|
|
|
|
setAnimationInterval(m_dOldAnimationInterval);
|
|
|
|
if (CCTime::gettimeofdayCocos2d(m_pLastUpdate, NULL) != 0)
|
|
{
|
|
CCLOG("cocos2d: Director: Error in gettimeofday");
|
|
}
|
|
|
|
m_bPaused = false;
|
|
m_fDeltaTime = 0;
|
|
}
|
|
|
|
void CCDirector::startAnimation(void)
|
|
{
|
|
CCLOG("cocos2d: Director#startAnimation. Overrride me");
|
|
assert(0);
|
|
}
|
|
|
|
void CCDirector::stopAnimation(void)
|
|
{
|
|
CCLOG("cocos2d: Director#stopAnimation. Overrride me");
|
|
assert(0);
|
|
}
|
|
|
|
void CCDirector::mainLoop(void)
|
|
{
|
|
CCLOG("cocos2d: Director#preMainLoop. Overrride me");
|
|
assert(0);
|
|
}
|
|
|
|
#if CC_DIRECTOR_FAST_FPS
|
|
// display the FPS using a LabelAtlas
|
|
// updates the FPS every frame
|
|
void CCDirector::showFPS(void)
|
|
{
|
|
sprintf(m_pszFPS, "%.1f", m_fFrameRate);
|
|
m_pFPSLabel->setString(m_pszFPS);
|
|
|
|
m_pFPSLabel->draw();
|
|
}
|
|
#endif // CC_DIRECTOR_FAST_FPS
|
|
|
|
void CCDirector::calculateFramerateDeltaTime(void)
|
|
{
|
|
struct cc_timeval now;
|
|
|
|
if (CCTime::gettimeofdayCocos2d(&now, NULL) != 0)
|
|
{
|
|
CCLOG("error in gettimeofday");
|
|
m_fComputeFrameRateDeltaTime = 0;
|
|
return;
|
|
}
|
|
|
|
m_fComputeFrameRateDeltaTime = (now.tv_sec - m_pLastComputeFrameRate->tv_sec) + (now.tv_usec - m_pLastComputeFrameRate->tv_usec) / 1000000.0f;
|
|
m_fComputeFrameRateDeltaTime = MAX(0, m_fComputeFrameRateDeltaTime);
|
|
|
|
*m_pLastComputeFrameRate = now;
|
|
}
|
|
|
|
void CCDirector::computeFrameRate()
|
|
{
|
|
static bool bInvoked = true;
|
|
|
|
// compute delta time
|
|
calculateFramerateDeltaTime();
|
|
|
|
// only add frames if the director really draw the scene
|
|
if (bInvoked)
|
|
{
|
|
m_nFrames++;
|
|
}
|
|
|
|
m_fAccumDt += m_fComputeFrameRateDeltaTime;
|
|
|
|
if (m_fAccumDt > CC_DIRECTOR_FPS_INTERVAL)
|
|
{
|
|
m_fFrameRate = m_nFrames / m_fAccumDt;
|
|
|
|
if (m_fFrameRate > m_fExpectedFrameRate)
|
|
{
|
|
bInvoked = false;
|
|
}
|
|
else
|
|
{
|
|
m_nFrames = 0;
|
|
m_fAccumDt = 0;
|
|
bInvoked = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CCDirector::showProfilers()
|
|
{
|
|
#if CC_ENABLE_PROFILERS
|
|
m_fAccumDtForProfiler += m_fDeltaTime;
|
|
if (m_fAccumDtForProfiler > 1.0f)
|
|
{
|
|
m_fAccumDtForProfiler = 0;
|
|
CCProfiler::sharedProfiler()->displayTimers();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/***************************************************
|
|
* mobile platforms specific functions
|
|
**************************************************/
|
|
|
|
// is the view currently attached
|
|
bool CCDirector::isOpenGLAttached(void)
|
|
{
|
|
return m_pobOpenGLView->isOpenGLReady();
|
|
}
|
|
|
|
void CCDirector::updateContentScaleFactor()
|
|
{
|
|
// [openGLView responseToSelector:@selector(setContentScaleFactor)]
|
|
if (m_pobOpenGLView->canSetContentScaleFactor())
|
|
{
|
|
m_pobOpenGLView->setContentScaleFactor(m_fContentScaleFactor);
|
|
m_bIsContentScaleSupported = true;
|
|
}
|
|
else
|
|
{
|
|
CCLOG("cocos2d: setContentScaleFactor:'is not supported on this device");
|
|
}
|
|
}
|
|
|
|
// detach or attach to a view or a window
|
|
bool CCDirector::detach(void)
|
|
{
|
|
assert(isOpenGLAttached());
|
|
|
|
CCX_SAFE_DELETE(m_pobOpenGLView);
|
|
return true;
|
|
}
|
|
|
|
void CCDirector::setDepthBufferFormat(tDepthBufferFormat kDepthBufferFormat)
|
|
{
|
|
assert(! isOpenGLAttached());
|
|
m_eDepthBufferFormat = kDepthBufferFormat;
|
|
}
|
|
|
|
void CCDirector::setPixelFormat(tPixelFormat kPixelFormat)
|
|
{
|
|
m_ePixelFormat = kPixelFormat;
|
|
}
|
|
|
|
tPixelFormat CCDirector::getPiexFormat(void)
|
|
{
|
|
return m_ePixelFormat;
|
|
}
|
|
|
|
bool CCDirector::setDirectorType(ccDirectorType obDirectorType)
|
|
{
|
|
// we only support CCDisplayLinkDirector
|
|
CCDirector::sharedDirector();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CCDirector::enableRetinaDisplay(bool enabled)
|
|
{
|
|
// Already enabled?
|
|
if (enabled && m_fContentScaleFactor == 2)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Already diabled?
|
|
if (!enabled && m_fContentScaleFactor == 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// setContentScaleFactor is not supported
|
|
if (! m_pobOpenGLView->canSetContentScaleFactor())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
///@todo SD device iphone specific
|
|
// if ([[UIScreen mainScreen] scale] == 1.0)
|
|
// return NO;
|
|
|
|
float newScale = enabled ? 2 : 1;
|
|
setContentScaleFactor(newScale);
|
|
|
|
return true;
|
|
}
|
|
|
|
CGFloat CCDirector::getContentScaleFactor(void)
|
|
{
|
|
return m_fContentScaleFactor;
|
|
}
|
|
|
|
void CCDirector::setContentScaleFactor(CGFloat scaleFactor)
|
|
{
|
|
if (scaleFactor != m_fContentScaleFactor)
|
|
{
|
|
m_fContentScaleFactor = scaleFactor;
|
|
m_obWinSizeInPixels = CGSizeMake(m_obWinSizeInPoints.width * scaleFactor, m_obWinSizeInPoints.height * scaleFactor);
|
|
|
|
if (m_pobOpenGLView)
|
|
{
|
|
updateContentScaleFactor();
|
|
}
|
|
|
|
// update projection
|
|
setProjection(m_eProjection);
|
|
}
|
|
}
|
|
|
|
void CCDirector::applyOrientation(void)
|
|
{
|
|
CGSize s = m_obWinSizeInPixels;
|
|
float w = s.width / 2;
|
|
float h = s.height / 2;
|
|
|
|
// XXX it's using hardcoded values.
|
|
// What if the the screen size changes in the future?
|
|
switch (m_eDeviceOrientation)
|
|
{
|
|
case CCDeviceOrientationPortrait:
|
|
// nothing
|
|
break;
|
|
case CCDeviceOrientationPortraitUpsideDown:
|
|
// upside down
|
|
glTranslatef(w,h,0);
|
|
glRotatef(180,0,0,1);
|
|
glTranslatef(-w,-h,0);
|
|
break;
|
|
case CCDeviceOrientationLandscapeRight:
|
|
glTranslatef(w,h,0);
|
|
glRotatef(90,0,0,1);
|
|
glTranslatef(-h,-w,0);
|
|
break;
|
|
case CCDeviceOrientationLandscapeLeft:
|
|
glTranslatef(w,h,0);
|
|
glRotatef(-90,0,0,1);
|
|
glTranslatef(-h,-w,0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ccDeviceOrientation CCDirector::getDeviceOrientation(void)
|
|
{
|
|
return m_eDeviceOrientation;
|
|
}
|
|
|
|
void CCDirector::setDeviceOrientation(ccDeviceOrientation kDeviceOrientation)
|
|
{
|
|
ccDeviceOrientation eNewOrientation;
|
|
eNewOrientation = CCXApplication::sharedApplication()->setDeviceOrientation(kDeviceOrientation);
|
|
if (m_eDeviceOrientation != eNewOrientation)
|
|
{
|
|
m_eDeviceOrientation = kDeviceOrientation;
|
|
}
|
|
}
|
|
|
|
/***************************************************
|
|
* PC platforms specific functions, such as mac
|
|
**************************************************/
|
|
|
|
CGPoint CCDirector::convertEventToGL(NSEvent *event)
|
|
{
|
|
assert(false);
|
|
return CGPointZero;
|
|
}
|
|
|
|
bool CCDirector::isFullScreen(void)
|
|
{
|
|
assert(false);
|
|
return false;
|
|
}
|
|
|
|
void CCDirector::setResizeMode(int resizeMode)
|
|
{
|
|
assert(false);
|
|
}
|
|
|
|
int CCDirector::getResizeMode(void)
|
|
{
|
|
assert(false);
|
|
return -1;
|
|
}
|
|
|
|
void CCDirector::setFullScreen(bool fullscreen)
|
|
{
|
|
assert(false);
|
|
}
|
|
|
|
CGPoint CCDirector::convertToLogicalCoordinates(CGPoint coordinates)
|
|
{
|
|
assert(false);
|
|
return CGPointZero;
|
|
}
|
|
|
|
|
|
/***************************************************
|
|
* implementation of DisplayLinkDirector
|
|
**************************************************/
|
|
|
|
// should we afford 4 types of director ??
|
|
// I think DisplayLinkDirector is enough
|
|
// so we now only support DisplayLinkDirector
|
|
void CCDisplayLinkDirector::startAnimation(void)
|
|
{
|
|
if (CCTime::gettimeofdayCocos2d(m_pLastUpdate, NULL) != 0)
|
|
{
|
|
CCLOG("cocos2d: DisplayLinkDirector: Error on gettimeofday");
|
|
}
|
|
|
|
m_bInvalid = false;
|
|
}
|
|
|
|
void CCDisplayLinkDirector::mainLoop(void)
|
|
{
|
|
if (! m_bInvalid)
|
|
{
|
|
// compute frame rate
|
|
computeFrameRate();
|
|
|
|
// control frame rate
|
|
if (m_fFrameRate <= m_fExpectedFrameRate)
|
|
{
|
|
drawScene();
|
|
|
|
// release the objects
|
|
NSPoolManager::getInstance()->pop();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CCDisplayLinkDirector::stopAnimation(void)
|
|
{
|
|
m_bInvalid = true;
|
|
}
|
|
|
|
void CCDisplayLinkDirector::setAnimationInterval(double dValue)
|
|
{
|
|
m_dAnimationInterval = dValue;
|
|
m_fExpectedFrameRate = (ccTime)(1 / m_dAnimationInterval);
|
|
if (! m_bInvalid)
|
|
{
|
|
stopAnimation();
|
|
startAnimation();
|
|
}
|
|
}
|
|
|
|
} //namespace cocos2d
|