Skip to content

Commit

Permalink
Add CCLuaValue class, use for pass values to Lua
Browse files Browse the repository at this point in the history 
Add CCScriptEngineProtocol::pushStringToLuaStack
Add CCScriptEngineProtocol::pushCCLuaValueToLuaStack
Add CCScriptEngineProtocol::pushCCLuaTableDictToLuaStack
Add CCScriptEngineProtocol::pushCCLuaTableArrayToLuaStack
  • Loading branch information
@dualface
dualface committed Jun 6, 2012
1 parent 8aa7eab commit 791ee85
Show file tree
Hide file tree
Showing 4 changed files with 255 additions and 2 deletions.
105 changes: 104 additions & 1 deletion cocos2dx/include/CCScriptSupport.h
View file
Expand Up @@ -28,6 +28,9 @@ THE SOFTWARE.
#include "CCCommon.h"
#include "CCTouch.h"
#include "CCSet.h"
#include <string>
#include <map>
#include <list>

typedef struct lua_State lua_State;

Expand All @@ -39,6 +42,9 @@ NS_CC_BEGIN

class CCTimer;

#pragma mark -
#pragma mark CCSchedulerScriptHandlerEntry

// Lua support for CCScheduler
class CCSchedulerScriptHandlerEntry : public CCObject
{
Expand Down Expand Up @@ -79,6 +85,9 @@ class CCSchedulerScriptHandlerEntry : public CCObject
};


#pragma mark -
#pragma mark CCTouchScriptHandlerEntry

// Lua support for touch events
class CCTouchScriptHandlerEntry : public CCObject
{
Expand Down Expand Up @@ -113,6 +122,88 @@ class CCTouchScriptHandlerEntry : public CCObject
};


#pragma mark -
#pragma mark CCLuaValue

class CCLuaValue;
typedef std::map<std::string, CCLuaValue*> CCLuaTableDict;
typedef CCLuaTableDict::iterator CCLuaTableDictIterator;
typedef std::list<CCLuaValue*> CCLuaTableArray;
typedef CCLuaTableArray::iterator CCLuaTableArrayIterator;

typedef enum {
CCLuaValueTypeInt,
CCLuaValueTypeFloat,
CCLuaValueTypeBoolean,
CCLuaValueTypeString,
CCLuaValueTypeCCLuaTableDict,
CCLuaValueTypeCCLuaTableArray
} CCLuaValueType;

typedef union {
int intValue;
float floatValue;
bool booleanValue;
std::string* stringValue;
CCLuaTableDict* tableDictValue;
CCLuaTableArray* tableArrayValue;
} CCLuaValueField;

class CCLuaValue
{
public:
static CCLuaValue* valueWithInt(int intValue);
static CCLuaValue* valueWithFloat(float floatValue);
static CCLuaValue* valueWithBoolean(bool booleanValue);
static CCLuaValue* valueWithString(const char* stringValue);
static CCLuaValue* valueWithString(const std::string& stringValue);
static CCLuaValue* valueWithCCLuaTableDict(const CCLuaTableDict& tableDict);
static CCLuaValue* valueWithCCLuaTableArray(const CCLuaTableArray& tableArray);

~CCLuaValue(void);

CCLuaValueType getType(void) {
return m_type;
}

int getIntValue(void) {
return m_field.intValue;
}

float getFloatValue(void) {
return m_field.floatValue;
}

bool getBooleanValue(void) {
return m_field.booleanValue;
}

const std::string& getStringValue(void) {
return *m_field.stringValue;
}

CCLuaTableDict* getTableDictValue(void) {
return m_field.tableDictValue;
}

CCLuaTableArray* getTableArrayValue(void) {
return m_field.tableArrayValue;
}

private:
CCLuaValue(void)
: m_type(CCLuaValueTypeInt) {
memset(&m_field, 0, sizeof(m_field));
}

CCLuaValueField m_field;
CCLuaValueType m_type;
};


#pragma mark -
#pragma mark CCScriptEngineProtocol

class CC_DLL CCScriptEngineProtocol : public CCObject
{
public:
Expand Down Expand Up @@ -171,11 +262,19 @@ class CC_DLL CCScriptEngineProtocol : public CCObject
virtual int executeFunctionWithIntegerData(int nHandler, int data) = 0;
virtual int executeFunctionWithFloatData(int nHandler, float data) = 0;
virtual int executeFunctionWithBooleanData(int nHandler, bool data) = 0;
virtual int executeFunctionWithCCObject(int nHandler, CCObject* pObject, const char* typeName) = 0;
virtual int executeFunctionWithCCObject(int nHandler, CCObject* pObject, const char* typeName) = 0;

/**
@brief Push value to Lua stack, return number of values in Lua stack
*/
virtual int pushIntegerToLuaStack(int data) = 0;
virtual int pushFloatToLuaStack(int data) = 0;
virtual int pushBooleanToLuaStack(int data) = 0;
virtual int pushStringToLuaStack(const char* data) = 0;
virtual int pushCCObjectToLuaStack(CCObject* pObject, const char* typeName) = 0;
virtual int pushCCLuaValueToLuaStack(CCLuaValue* pValue) = 0;
virtual int pushCCLuaTableDictToLuaStack(CCLuaTableDict* pDict) = 0;
virtual int pushCCLuaTableArrayToLuaStack(CCLuaTableArray* pArray) = 0;

// functions for excute touch event
virtual int executeTouchEvent(int nHandler, int eventType, CCTouch *pTouch) = 0;
Expand All @@ -185,6 +284,10 @@ class CC_DLL CCScriptEngineProtocol : public CCObject
virtual int executeSchedule(int nHandler, ccTime dt) = 0;
};


#pragma mark -
#pragma mark CCScriptEngineManager

/**
CCScriptEngineManager is a singleton which holds an object instance of CCScriptEngineProtocl
It helps cocos2d-x and the user code to find back LuaEngine object
Expand Down
75 changes: 75 additions & 0 deletions cocos2dx/script_support/CCScriptSupport.cpp
View file
Expand Up @@ -102,6 +102,81 @@ bool CCTouchScriptHandlerEntry::initWithHandler(int nHandler, bool bIsMultiTouch
// ----------------------------


CCLuaValue* CCLuaValue::valueWithInt(int intValue)
{
CCLuaValue* value = new CCLuaValue();
value->m_field.intValue = intValue;
value->m_type = CCLuaValueTypeInt;
return value;
}

CCLuaValue* CCLuaValue::valueWithFloat(float floatValue)
{
CCLuaValue* value = new CCLuaValue();
value->m_field.floatValue = floatValue;
value->m_type = CCLuaValueTypeFloat;
return value;
}

CCLuaValue* CCLuaValue::valueWithBoolean(bool booleanValue)
{
CCLuaValue* value = new CCLuaValue();
value->m_field.booleanValue = booleanValue;
value->m_type = CCLuaValueTypeBoolean;
return value;
}

CCLuaValue* CCLuaValue::valueWithString(const char* stringValue)
{
CCLuaValue* value = new CCLuaValue();
value->m_field.stringValue = new std::string(stringValue ? stringValue : "");
value->m_type = CCLuaValueTypeString;
return value;
}

CCLuaValue* CCLuaValue::valueWithString(const std::string& stringValue)
{
CCLuaValue* value = new CCLuaValue();
value->m_field.stringValue = new std::string(stringValue);
value->m_type = CCLuaValueTypeString;
return value;
}

CCLuaValue* CCLuaValue::valueWithCCLuaTableDict(const CCLuaTableDict& tableDict)
{
CCLuaValue* value = new CCLuaValue();
value->m_field.tableDictValue = new CCLuaTableDict(tableDict);
value->m_type = CCLuaValueTypeCCLuaTableDict;
return value;
}

CCLuaValue* CCLuaValue::valueWithCCLuaTableArray(const CCLuaTableArray& tableArray)
{
CCLuaValue* value = new CCLuaValue();
value->m_field.tableArrayValue = new CCLuaTableArray(tableArray);
value->m_type = CCLuaValueTypeCCLuaTableArray;
return value;
}

CCLuaValue::~CCLuaValue(void)
{
if (m_type == CCLuaValueTypeString)
{
delete m_field.stringValue;
}
else if (m_type == CCLuaValueTypeCCLuaTableDict)
{
delete m_field.tableDictValue;
}
else if (m_type == CCLuaValueTypeCCLuaTableArray)
{
delete m_field.tableArrayValue;
}
}

// ----------------------------


static CCScriptEngineManager* s_pSharedScriptEngineManager = NULL;


Expand Down
70 changes: 69 additions & 1 deletion lua/cocos2dx_support/CCLuaEngine.cpp
View file
Expand Up @@ -23,12 +23,16 @@
****************************************************************************/

#include "CCLuaEngine.h"
#include "tolua++.h"

#include <string>
#include <map>
#include <list>

extern "C" {
#include "lualib.h"
#include "lauxlib.h"
#include "tolua_fix.h"
#include "tolua++.h"
}

#include "cocos2d.h"
Expand Down Expand Up @@ -244,12 +248,76 @@ int CCLuaEngine::pushBooleanToLuaStack(int data)
return lua_gettop(m_state);
}

int CCLuaEngine::pushStringToLuaStack(const char* data)
{
lua_pushstring(m_state, data);
return lua_gettop(m_state);
}

int CCLuaEngine::pushCCObjectToLuaStack(CCObject* pObject, const char* typeName)
{
toluafix_pushusertype_ccobject(m_state, pObject->m_uID, &pObject->m_nLuaID, pObject, typeName);
return lua_gettop(m_state);
}

int CCLuaEngine::pushCCLuaValueToLuaStack(CCLuaValue* pValue)
{
CCLuaValueType type = pValue->getType();
if (type == CCLuaValueTypeInt)
{
return pushIntegerToLuaStack(pValue->getIntValue());
}
else if (type == CCLuaValueTypeFloat)
{
return pushFloatToLuaStack(pValue->getFloatValue());
}
else if (type == CCLuaValueTypeBoolean)
{
return pushBooleanToLuaStack(pValue->getBooleanValue());
}
else if (type == CCLuaValueTypeString)
{
return pushStringToLuaStack(pValue->getStringValue().c_str());
}
else if (type == CCLuaValueTypeCCLuaTableDict)
{
pushCCLuaTableDictToLuaStack(pValue->getTableDictValue());
}
else if (type == CCLuaValueTypeCCLuaTableArray)
{
pushCCLuaTableArrayToLuaStack(pValue->getTableArrayValue());
}

return lua_gettop(m_state);
}

int CCLuaEngine::pushCCLuaTableDictToLuaStack(CCLuaTableDict* pDict)
{
lua_newtable(m_state); /* stack: table */
for (CCLuaTableDictIterator it = pDict->begin(); it != pDict->end(); ++it)
{
lua_pushstring(m_state, it->first.c_str()); /* stack: table key */
pushCCLuaValueToLuaStack(it->second); /* stack: table key value */
lua_rawset(m_state, -3); /* table.key = value, stack: table */
}

return lua_gettop(m_state);
}

int CCLuaEngine::pushCCLuaTableArrayToLuaStack(CCLuaTableArray* pArray)
{
lua_newtable(m_state); /* stack: table */
int index = 1;
for (CCLuaTableArrayIterator it = pArray->begin(); it != pArray->end(); ++it)
{
pushCCLuaValueToLuaStack(*it); /* stack: table value */
lua_rawseti(m_state, -2, index); /* table[index] = value, stack: table */
++index;
}

return lua_gettop(m_state);
}

// functions for excute touch event
int CCLuaEngine::executeTouchEvent(LUA_HANDLE nHandler, int eventType, CCTouch *pTouch)
{
Expand Down
7 changes: 7 additions & 0 deletions lua/cocos2dx_support/CCLuaEngine.h
View file
Expand Up @@ -38,6 +38,9 @@ extern "C" {

NS_CC_BEGIN

#pragma mark -
#pragma mark CCLuaEngine

// Lua support for cocos2d-x
class CCLuaEngine : public CCScriptEngineProtocol
{
Expand Down Expand Up @@ -105,7 +108,11 @@ class CCLuaEngine : public CCScriptEngineProtocol
virtual int pushIntegerToLuaStack(int data);
virtual int pushFloatToLuaStack(int data);
virtual int pushBooleanToLuaStack(int data);
virtual int pushStringToLuaStack(const char* data);
virtual int pushCCObjectToLuaStack(CCObject* pObject, const char* typeName);
virtual int pushCCLuaValueToLuaStack(CCLuaValue* pValue);
virtual int pushCCLuaTableDictToLuaStack(CCLuaTableDict* pDict);
virtual int pushCCLuaTableArrayToLuaStack(CCLuaTableArray* pArray);

// functions for excute touch event
virtual int executeTouchEvent(LUA_HANDLE nHandler, int eventType, cocos2d::CCTouch *pTouch);
Expand Down

0 comments on commit 791ee85

Please sign in to comment.