Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Accelerometer stuff

This commit is contained in:
Giovanni Zito 2011-12-08 10:48:03 +01:00
parent e077107575
commit 7b0cb1bc8b
4 changed files with 39 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
cocos2dx/platform/airplay/CCAccelerometer_airplay.cpp
View File

@ -26,48 +26,57 @@
namespace cocos2d
{
CCAccelerometer* CCAccelerometer::m_spCCAccelerometer = NULL;
//------------------------------------------------------------------
//
// CCAccelerometer
//
//------------------------------------------------------------------
CCAccelerometer* CCAccelerometer::m_spCCAccelerometer = NULL;
CCAccelerometer::CCAccelerometer() : m_pAccelDelegate(NULL)
{
if (s3eAccelerometerStart() != S3E_RESULT_SUCCESS)
{
CCLog("s3eAccelerometerStart() - ERROR\n");
}
}
CCAccelerometer::~CCAccelerometer()
{
m_spCCAccelerometer = NULL;
s3eAccelerometerStop();
}
CCAccelerometer* CCAccelerometer::sharedAccelerometer()
CCAccelerometer::~CCAccelerometer()
{
if( m_spCCAccelerometer ) {
delete m_spCCAccelerometer ;
m_spCCAccelerometer = NULL;
}
}
CCAccelerometer* CCAccelerometer::sharedAccelerometer()
{
if (m_spCCAccelerometer == NULL)
{
m_spCCAccelerometer = new CCAccelerometer();
}
return m_spCCAccelerometer;
}
void CCAccelerometer::setDelegate(CCAccelerometerDelegate* pDelegate)
{
m_pAccelDelegate = pDelegate;
if (pDelegate)
{
s3eAccelerometerStart();
}
else
{
s3eAccelerometerStop();
}
}
void CCAccelerometer::didAccelerate(CCAcceleration* pAccelerationValue)
void CCAccelerometer::update(float x, float y, float z, uint64 sensorTimeStamp)
{
if (m_pAccelDelegate)
{
m_pAccelDelegate->didAccelerate(pAccelerationValue);
}
if (m_pAccelDelegate)
{
m_obAccelerationValue.x = ((double)x)/S3E_ACCELEROMETER_1G ;
m_obAccelerationValue.y = ((double)y)/S3E_ACCELEROMETER_1G ;
m_obAccelerationValue.z = ((double)z)/S3E_ACCELEROMETER_1G ;
m_obAccelerationValue.timestamp = (double)(sensorTimeStamp / 1000.0);
m_pAccelDelegate->didAccelerate(&m_obAccelerationValue);
}
}
} // end of namespace cococs2d

11
cocos2dx/platform/airplay/CCAccelerometer_airplay.h
View File

@ -27,6 +27,7 @@
#include "CCMutableArray.h"
#include "ccCommon.h"
namespace cocos2d {
/**
@ -45,14 +46,10 @@ public:
*/
static CCAccelerometer* sharedAccelerometer();
/**
@brief call delegates' didAccelerate function
*/
void didAccelerate(CCAcceleration* pAccelerationValue);
void setDelegate(CCAccelerometerDelegate* pDelegate);
void update(float x, float y, float z, uint64 sensorTimeStamp);
void setDelegate(CCAccelerometerDelegate* pDelegate);
protected:
private:
static CCAccelerometer* m_spCCAccelerometer;
CCAccelerometerDelegate* m_pAccelDelegate;
CCAcceleration m_obAccelerationValue;

9
cocos2dx/platform/airplay/CCApplication_airplay.cpp
View File

@ -111,14 +111,7 @@ void CCApplication::statusBarFrame(CCRect * rect)
}
void CCApplication::ccAccelerationUpdate()
{
CCAcceleration AccValue;
AccValue.x = (double)s3eAccelerometerGetX()/200;
AccValue.y = (double)s3eAccelerometerGetY()/200;
AccValue.z = (double)s3eAccelerometerGetZ()/200;
AccValue.timestamp = (double) 50/ 100;
// call delegates' didAccelerate function
CCAccelerometer::sharedAccelerometer()->didAccelerate(&AccValue);
CCAccelerometer::sharedAccelerometer()->update(s3eAccelerometerGetX(),s3eAccelerometerGetY(),s3eAccelerometerGetZ(),s3eTimerGetMs());
}
//////////////////////////////////////////////////////////////////////////

283
cocos2dx/platform/airplay/CCFileUtils_airplay.cpp
View File

@ -22,244 +22,14 @@
****************************************************************************/
#include "CCFileUtils.h"
#include "CCDirector.h"
#include "string.h"
#include <stack>
#include "stack"
#include "CCString.h"
#include "CCSAXParser.h"
using namespace std;
#include "CCApplication.h"
NS_CC_BEGIN;
typedef enum
{
SAX_NONE = 0,
SAX_KEY,
SAX_DICT,
SAX_INT,
SAX_REAL,
SAX_STRING,
SAX_ARRAY
}CCSAXState;
class CCDictMaker : public CCSAXDelegator
{
public:
CCDictionary<std::string, CCObject*> *m_pRootDict;
CCDictionary<std::string, CCObject*> *m_pCurDict;
std::stack<CCDictionary<std::string, CCObject*>*> m_tDictStack;
std::string m_sCurKey;///< parsed key
CCSAXState m_tState;
CCMutableArray<CCObject*> *m_pArray;
std::stack<CCMutableArray<CCObject*>*> m_tArrayStack;
std::stack<CCSAXState> m_tStateStack;
public:
CCDictMaker()
{
m_pRootDict = NULL;
m_pCurDict = NULL;
m_tState = SAX_NONE;
m_pArray = NULL;
}
~CCDictMaker()
{
}
CCDictionary<std::string, CCObject*> *dictionaryWithContentsOfFile(const char *pFileName)
{
CCSAXParser parser;
if (false == parser.init("UTF-8"))
{
return NULL;
}
parser.setDelegator(this);
parser.parse(pFileName);
return m_pRootDict;
}
void startElement(void *ctx, const char *name, const char **atts)
{
CC_UNUSED_PARAM(ctx);
CC_UNUSED_PARAM(atts);
std::string sName((char*)name);
if( sName == "dict" )
{
m_pCurDict = new CCDictionary<std::string, CCObject*>();
if(! m_pRootDict)
{
// Because it will call m_pCurDict->release() later, so retain here.
m_pRootDict = m_pCurDict;
m_pRootDict->retain();
}
m_tState = SAX_DICT;
CCSAXState preState = SAX_NONE;
if (! m_tStateStack.empty())
{
preState = m_tStateStack.top();
}
if (SAX_ARRAY == preState)
{
// add the dictionary into the array
m_pArray->addObject(m_pCurDict);
}
else if (SAX_DICT == preState)
{
// add the dictionary into the pre dictionary
CCAssert(! m_tDictStack.empty(), "The state is wrong!");
CCDictionary<std::string, CCObject*>* pPreDict = m_tDictStack.top();
pPreDict->setObject(m_pCurDict, m_sCurKey);
}
m_pCurDict->release();
// record the dict state
m_tStateStack.push(m_tState);
m_tDictStack.push(m_pCurDict);
}
else if(sName == "key")
{
m_tState = SAX_KEY;
}
else if(sName == "integer")
{
m_tState = SAX_INT;
}
else if(sName == "real")
{
m_tState = SAX_REAL;
}
else if(sName == "string")
{
m_tState = SAX_STRING;
}
else if (sName == "array")
{
m_tState = SAX_ARRAY;
m_pArray = new CCMutableArray<CCObject*>();
CCSAXState preState = m_tStateStack.empty() ? SAX_DICT : m_tStateStack.top();
if (preState == SAX_DICT)
{
m_pCurDict->setObject(m_pArray, m_sCurKey);
}
else if (preState == SAX_ARRAY)
{
CCAssert(! m_tArrayStack.empty(), "The state is worng!");
CCMutableArray<CCObject*>* pPreArray = m_tArrayStack.top();
pPreArray->addObject(m_pArray);
}
m_pArray->release();
// record the array state
m_tStateStack.push(m_tState);
m_tArrayStack.push(m_pArray);
}
else
{
m_tState = SAX_NONE;
}
}
void endElement(void *ctx, const char *name)
{
CC_UNUSED_PARAM(ctx);
CCSAXState curState = m_tStateStack.empty() ? SAX_DICT : m_tStateStack.top();
std::string sName((char*)name);
if( sName == "dict" )
{
m_tStateStack.pop();
m_tDictStack.pop();
if ( !m_tDictStack.empty())
{
m_pCurDict = m_tDictStack.top();
}
}
else if (sName == "array")
{
m_tStateStack.pop();
m_tArrayStack.pop();
if (! m_tArrayStack.empty())
{
m_pArray = m_tArrayStack.top();
}
}
else if (sName == "true")
{
CCString *str = new CCString("1");
if (SAX_ARRAY == curState)
{
m_pArray->addObject(str);
}
else if (SAX_DICT == curState)
{
m_pCurDict->setObject(str, m_sCurKey);
}
str->release();
}
else if (sName == "false")
{
CCString *str = new CCString("0");
if (SAX_ARRAY == curState)
{
m_pArray->addObject(str);
}
else if (SAX_DICT == curState)
{
m_pCurDict->setObject(str, m_sCurKey);
}
str->release();
}
m_tState = SAX_NONE;
}
void textHandler(void *ctx, const char *ch, int len)
{
CC_UNUSED_PARAM(ctx);
if (m_tState == SAX_NONE)
{
return;
}
CCSAXState curState = m_tStateStack.empty() ? SAX_DICT : m_tStateStack.top();
CCString *pText = new CCString();
pText->m_sString = std::string((char*)ch,0,len);
switch(m_tState)
{
case SAX_KEY:
m_sCurKey = pText->m_sString;
break;
case SAX_INT:
case SAX_REAL:
case SAX_STRING:
{
CCAssert(!m_sCurKey.empty(), "not found key : <integet/real>");
if (SAX_ARRAY == curState)
{
m_pArray->addObject(pText);
}
else if (SAX_DICT == curState)
{
m_pCurDict->setObject(pText, m_sCurKey);
}
break;
}
default:
break;
}
pText->release();
}
};
static char s_pszResourcePath[S3E_FILE_MAX_PATH] = {0};
const char* CCFileUtils::fullPathFromRelativePath(const char *pszRelativePath)
@ -301,12 +71,6 @@ const char *CCFileUtils::fullPathFromRelativeFile(const char *pszFilename, const
return pRet->m_sString.c_str();
}
CCDictionary<std::string, CCObject*> *CCFileUtils::dictionaryWithContentsOfFile(const char *pFileName)
{
CCDictMaker tMaker;
return tMaker.dictionaryWithContentsOfFile(pFileName);
}
unsigned char* CCFileUtils::getFileData(const char* pszFileName, const char* pszMode, unsigned long * pSize)
{
IW_CALLSTACK("CCFileUtils::getFileData");
@ -335,49 +99,6 @@ unsigned char* CCFileUtils::getFileData(const char* pszFileName, const char* psz
return (unsigned char*)pDataToBeReadBinary;
}
std::string& CCFileUtils::ccRemoveHDSuffixFromFile(std::string& path)
{
#if CC_IS_RETINA_DISPLAY_SUPPORTED
if( CC_CONTENT_SCALE_FACTOR() == 2 )
{
std::string::size_type pos = path.rfind("/") + 1; // the begin index of last part of path
std::string::size_type suffixPos = path.rfind(CC_RETINA_DISPLAY_FILENAME_SUFFIX);
if (std::string::npos != suffixPos && suffixPos > pos)
{
CCLog("cocos2d: FilePath(%s) contains suffix(%s), remove it.", path.c_str(),
CC_RETINA_DISPLAY_FILENAME_SUFFIX);
path.replace(suffixPos, strlen(CC_RETINA_DISPLAY_FILENAME_SUFFIX), "");
}
}
#endif // CC_IS_RETINA_DISPLAY_SUPPORTED
return path;
}
CCDictionary<std::string, CCObject*> *CCFileUtils::dictionaryWithContentsOfFileThreadSafe(const char *pFileName)
{
CCDictMaker tMaker;
return tMaker.dictionaryWithContentsOfFile(pFileName);
}
//////////////////////////////////////////////////////////////////////////
// Notification support when getFileData from invalid file path.
//////////////////////////////////////////////////////////////////////////
static bool s_bPopupNotify = true;
void CCFileUtils::setIsPopupNotify(bool bNotify)
{
s_bPopupNotify = bNotify;
}
bool CCFileUtils::getIsPopupNotify()
{
return s_bPopupNotify;
}
std::string CCFileUtils::getWriteablePath()
{
// fixed me, what path can airplay can write