Example #1
0
static LuaPlus::LuaObject Wrap(Vec3 vector){
	LuaPlus::LuaObject vecObj;
	vecObj.AssignNewTable(LuaManager::Get()->GetState());

	vecObj.SetNumber("x", vector.x);
	vecObj.SetNumber("y", vector.y);
	vecObj.SetNumber("z", vector.z);

	return vecObj;
}
// apply torque to an object from lua
void LuaInternalScriptExports::ApplyTorque(LuaPlus::LuaObject axisLua, float force, int gameObjectId)
{
	if (axisLua.IsTable())
	{
		Vec3 axis(axisLua["x"].GetFloat(), axisLua["y"].GetFloat(), axisLua["z"].GetFloat());
		g_pApp->m_pGame->GetGamePhysics()->ApplyTorque(axis, force, gameObjectId);
		return;
	}
	CB_ERROR("Invalid object passed to ApplyForce(). Type = " + std::string(axisLua.TypeName()));
}
Example #3
0
void LuaScriptExports::registerScripts( void )
{
	LuaPlus::LuaObject globals = LuaStateManager::instance()->getGlobalVars();

	// Init
	InternalLuaScriptExports::init();

	// Resource loading
	globals.RegisterDirect("loadAndExecuteScriptResource",InternalLuaScriptExports::loadAndExecutreScriptResource);	

	// Process manager
	globals.RegisterDirect("attachProcess",&InternalLuaScriptExports::attachScriptProcess);

	// Event system
	globals.RegisterDirect("registerEventListener", &InternalLuaScriptExports::registerEventListener);
	globals.RegisterDirect("removeEventListener", &InternalLuaScriptExports::removeEventListener);
	globals.RegisterDirect("queueEvent", &InternalLuaScriptExports::queueEvent);
	globals.RegisterDirect("triggerEvent", &InternalLuaScriptExports::triggerEvent);

	// Actors
	globals.RegisterDirect("createActor", &InternalLuaScriptExports::createActor);

	// Lua log
	globals.RegisterDirect("log",&InternalLuaScriptExports::lualog);
}
Example #4
0
static LuaPlus::LuaObject Wrap(Quat quat){
	LuaPlus::LuaObject quatObj;
	quatObj.AssignNewTable(LuaManager::Get()->GetState());

	quatObj.SetNumber("w", quat.w);
	quatObj.SetNumber("x", quat.x);
	quatObj.SetNumber("y", quat.y);
	quatObj.SetNumber("z", quat.z);

	return quatObj;
}
// write to the log from lua script
void LuaInternalScriptExports::LuaLog(LuaPlus::LuaObject text)
{
	if (text.IsConvertibleToString())
	{
		CB_LOG("Lua", text.ToString());
	}
	else
	{
		CB_LOG("Lua", "<" + std::string(text.TypeName()) + ">");
	}
}
Example #6
0
void ant::InternalLuaScriptExports::lualog( LuaPlus::LuaObject text )
{
	if (text.IsConvertibleToString())
	{
		GCC_LOG("Lua",text.ToString());
	}
	else
	{
		GCC_LOG("Lua","<" + std::string(text.TypeName()) + ">");
	}
}
LuaPlus::LuaObject BaseScriptComponent::GetLookAt(void) const
{
    LuaPlus::LuaObject ret;

    shared_ptr<TransformComponent> pTransformComponent = MakeStrongPtr(m_pOwner->GetComponent<TransformComponent>(TransformComponent::g_Name));
    if (pTransformComponent)
        LuaStateManager::Get()->ConvertVec3ToTable(pTransformComponent->GetLookAt(), ret);
    else
        ret.AssignNil(LuaStateManager::Get()->GetLuaState());

    return ret;
}
Example #8
0
void InternalScriptExports::AttachScriptProcess(LuaPlus::LuaObject scriptProcess)
{
	LuaPlus::LuaObject temp = scriptProcess.Lookup("__object");
	if (!temp.IsNil())
	{
		shared_ptr<Process> pProcess(static_cast<Process*>(temp.GetLightUserData()));
        g_pApp->m_pGame->AttachProcess(pProcess);
	}
	else
	{
		GCC_ERROR("Couldn't find __object in script process");
	}
}
// get the y rotation in radians from a lua vec3
float LuaInternalScriptExports::GetYRotationFromVector(LuaPlus::LuaObject vec3)
{
	// make sure vec3 is a table
	if (vec3.IsTable())
	{
		Vec3 lookAt(vec3["x"].GetFloat(), vec3["y"].GetFloat(), vec3["z"].GetFloat());
		// use the GetYRotationFromVector from math.h
		return ::GetYRotationFromVector(lookAt);
	}

	CB_ERROR("Invalid object passed to GetYRotationFromVector(); type = " + std::string(vec3.TypeName()));
	return 0;
}
Example #10
0
void ant::InternalLuaScriptExports::attachScriptProcess( LuaPlus::LuaObject scriptProcess )
{
	LuaPlus::LuaObject temp = scriptProcess.Lookup("__object");
	if (!temp.IsNil())
	{
		IProcessStrongPtr pProcess(static_cast<IProcess*>(temp.GetLightUserData()));
		ProcessManagerSingleton::instance()->getProcessManager()->attachProcess(pProcess);
	}
	else
	{
		GCC_ERROR("Could not find __object in script proces");
	}
}
LuaPlus::LuaObject LuaScriptComponent::GetPos()
{
	// return the objects position to lua
	LuaPlus::LuaObject ret;

	shared_ptr<TransformComponent> pTransformComponent = MakeStrongPtr(m_pOwner->GetComponent<TransformComponent>(TransformComponent::g_Name));
	if (pTransformComponent)
		LuaStateManager::Get()->ConvertVec3ToTable(pTransformComponent->GetPosition(), ret);
	else
		ret.AssignNil(LuaStateManager::Get()->GetLuaState());

	return ret;
}
Example #12
0
//---------------------------------------------------------------------------------------------------------------------
// This function is called to register an event type with the script to link them.  The simplest way to do this is 
// with the REGISTER_SCRIPT_EVENT() macro, which calls this function.
//---------------------------------------------------------------------------------------------------------------------
void ScriptEvent::RegisterEventTypeWithScript(const char* key, EventType type)
{
	// get or create the EventType table
	LuaPlus::LuaObject eventTypeTable = LuaStateManager::Get()->GetGlobalVars().GetByName("EventType");
	if (eventTypeTable.IsNil())
		eventTypeTable = LuaStateManager::Get()->GetGlobalVars().CreateTable("EventType");

	// error checking
	GCC_ASSERT(eventTypeTable.IsTable());
	GCC_ASSERT(eventTypeTable[key].IsNil());
	
	// add the entry
	eventTypeTable.SetNumber(key, (double)type);
}
// create a lua vec3 table from an angle in radians
LuaPlus::LuaObject LuaInternalScriptExports::GetVectorFromRotation(float angleRadians)
{
	// use the GetVectorFromYRotation from math.h
	Vec3 result = ::GetVectorFromYRotation(angleRadians);

	// create a lua vec3 table from the result
	LuaPlus::LuaObject luaResult;
	luaResult.AssignNewTable(LuaStateManager::Get()->GetLuaState());
	luaResult.SetNumber("x", result.x);
	luaResult.SetNumber("y", result.y);
	luaResult.SetNumber("z", result.z);

	return luaResult;
}
void BaseScriptComponent::CreateScriptObject(void)
{
    LuaStateManager* pStateMgr = LuaStateManager::Get();
    AC_ASSERT(pStateMgr);
	AC_ASSERT(!m_scriptObject.IsNil());
	
	LuaPlus::LuaObject metaTableObj = pStateMgr->GetGlobalVars().Lookup(METATABLE_NAME);
	AC_ASSERT(!metaTableObj.IsNil());
	
	LuaPlus::LuaObject boxedPtr = pStateMgr->GetLuaState()->BoxPointer(this);
	boxedPtr.SetMetaTable(metaTableObj);
	m_scriptObject.SetLightUserData("__object", this);
	m_scriptObject.SetMetaTable(metaTableObj);
}
Example #15
0
        void LuaScriptEventManager::RegisterEventTransformer(LuaScriptEventTransformation transformer, EventType type, LPCSTR name)
        {
            LuaScript* luas = (LuaScript*)chimera::g_pApp->GetScript();
            LuaPlus::LuaObject table = luas->GetState()->GetGlobals().GetByName("EventType");

            if(table.IsNil())
            {
                table = luas->GetState()->GetGlobals().CreateTable("EventType");
            }

            table.SetNumber(name, type);

            m_transformMap[type] = transformer;
        }
void LuaScriptComponent::CreateScriptObject()
{
	LuaStateManager* pStateManager = LuaStateManager::Get();
	CB_ASSERT(pStateManager);
	CB_ASSERT(!m_ScriptObject.IsNil());

	LuaPlus::LuaObject metaTableObj = pStateManager->GetGlobalVars().Lookup(LUA_METATABLE_NAME);
	CB_ASSERT(!metaTableObj.IsNil());

	// bind the __object field in lua to this object
	LuaPlus::LuaObject boxedPtr = pStateManager->GetLuaState()->BoxPointer(this);
	boxedPtr.SetMetaTable(metaTableObj);
	m_ScriptObject.SetLightUserData("__object", this);
	m_ScriptObject.SetMetaTable(metaTableObj);
}
Example #17
0
void LuaPlusGCFunction(void* s)
{
	lua_State* L = (lua_State*)s;
	LuaPlus::LuaState* state = lua_State_To_LuaState(L);
	if (!state)
		return;

    global_State* g = G(L);

	LuaPlus::LuaObject* curObj = (LuaPlus::LuaObject*)G(L)->gchead_next;
	while (curObj != (LuaPlus::LuaObject*)&G(L)->gctail_next)
	{
		markvalue(g, curObj->GetTObject());
		curObj = *(LuaPlus::LuaObject**)curObj;
	}
}
LuaPlus::LuaObject BaseScriptComponent::GetActorId(void)
{
	//GCC_LOG("ObjectSystem", "BaseScriptComponent::GetEntityId() return 0x" + ToStr(m_pOwner->GetId(), 16) + " on C++ side");

	// [rez] Wtf??  Returning an unsigned int here will produce really odd results in Release mode (debug is 
	// fine).  The number will sometimes get truncated, so 0xb1437643 might become 0xb1437600.  Even though the 
	// C++ side is getting the right number, it gets mangled on the way out to Lua.  The somewhat hacky fix here 
	// is to return a LuaPlus::LuaObject, which seems to work just fine.  I'm not sure if this will cause any 
    // efficiency issues, but I'm guessing the LuaPlus internals do something like this anyway to marshal the 
    // data back to Lua land, so it's probably okay.
	LuaPlus::LuaObject ret;
	ret.AssignInteger(LuaStateManager::Get()->GetLuaState(), m_pOwner->GetId());
	return ret;

	//return m_pOwner->GetId();
}
    // /////////////////////////////////////////////////////////////////
    //
    // /////////////////////////////////////////////////////////////////
    LuaStateManager::LuaStateManager(void) : m_GlobalState(true)
    {
        //Create our metatable...
        m_MetaTable = m_GlobalState->GetGlobals().CreateTable("LuaStateManagerMetaTable");
        m_MetaTable.SetObject("__index", m_MetaTable);

        // Here we register two functions to make them accessible to script.
        m_MetaTable.RegisterObjectDirect("DoFile", (LuaStateManager *)0, &LuaStateManager::DoFile);
        m_MetaTable.RegisterObjectDirect("DoResourceFile", (LuaStateManager *)0, &LuaStateManager::DoResourceFile);
        m_MetaTable.RegisterObjectDirect("PrintDebugMessage", (LuaStateManager *)0, &LuaStateManager::PrintDebugMessage);

        LuaPlus::LuaObject luaStateManObj = m_GlobalState->BoxPointer(this);
        luaStateManObj.SetMetaTable(m_MetaTable);

        // And here we expose the metatable as a named entity.
        m_GlobalState->GetGlobals().SetObject("LuaStateManager", luaStateManObj);
    }
void BaseScriptComponent::RegisterScriptFunctions(void)
{
	// create the metatable
	LuaPlus::LuaObject metaTableObj = LuaStateManager::Get()->GetGlobalVars().CreateTable(METATABLE_NAME);
	metaTableObj.SetObject("__index", metaTableObj);

	// transform component functions
	metaTableObj.RegisterObjectDirect("GetActorId",		        (BaseScriptComponent*)0, &BaseScriptComponent::GetActorId);
	metaTableObj.RegisterObjectDirect("GetPos",				    (BaseScriptComponent*)0, &BaseScriptComponent::GetPos);
    metaTableObj.RegisterObjectDirect("SetPos",				    (BaseScriptComponent*)0, &BaseScriptComponent::SetPos);
	metaTableObj.RegisterObjectDirect("GetLookAt",	            (BaseScriptComponent*)0, &BaseScriptComponent::GetLookAt);
	metaTableObj.RegisterObjectDirect("GetYOrientationRadians", (BaseScriptComponent*)0, &BaseScriptComponent::GetYOrientationRadians);
	metaTableObj.RegisterObjectDirect("RotateY",	            (BaseScriptComponent*)0, &BaseScriptComponent::RotateY);
    metaTableObj.RegisterObjectDirect("Stop",	                (BaseScriptComponent*)0, &BaseScriptComponent::Stop);

	metaTableObj.RegisterObjectDirect("SetPosition",	        (BaseScriptComponent*)0, &BaseScriptComponent::SetPosition);
}
Example #21
0
bool LoadScene(const std::string &sceneName)
{
	std::string fullPath;
	fullPath = "Scenes/";
	fullPath += sceneName;
	fullPath += ".lua";

	LuaPlus::LuaStateAuto state;
	state = LuaPlus::LuaState::Create();
	
	int retVal = state->DoFile(fullPath.c_str());
	_ASSERT(retVal==0);

	LuaPlus::LuaObject meshList = state->GetGlobals()["MeshList"];
	_ASSERT(meshList.IsTable());

	int numMeshes = meshList.GetCount();
	for(int meshIndex=1;meshIndex <= meshList.GetCount(); meshIndex++)
	{
		LuaPlus::LuaObject meshObj = meshList[meshIndex];
		LuaPlus::LuaObject nameObj = meshObj["Name"];
		_ASSERT(nameObj.IsString());

		std::string meshName = nameObj.GetString();

		MeshManager::GetInstance().Load(meshName,meshObj);
		Instance *inst = InstanceManager::GetInstance().CreateInstance(meshName);
		inst->SetMeshName(meshName);

	}

	return true;
}
    // /////////////////////////////////////////////////////////////////
    //
    // /////////////////////////////////////////////////////////////////
    void LuaStateManager::PrintDebugMessage(LuaPlus::LuaObject debugObject)
    {
        LuaPlus::LuaObject stringObj;
        const char * pFinalStr = debugObject.ToString();

        // Generate an event.
        const EvtData_Debug_String debugEvent((NULL == pFinalStr) ? "INVALID!" : pFinalStr, EvtData_Debug_String::kDST_ScriptMsg);
        safeTriggerEvent(debugEvent);
    }
void TransformationComponent::RegisterScriptFunction()
{
	LuaPlus::LuaObject metaTable = LuaManager::GetSingleton().GetGlobalVars().CreateTable("TransformationComponentMetatable");
	metaTable.SetObject("__index", metaTable); 

	//TODO -> Studente MGD	
	
	//Esempio: metaTable.RegisterObjectDirect("NomeFunzioneInLua", (NomeClass*)0, Puntatore a funzione);

	// Esporre SetPosition
	// Esporre GetPosition
	// Esporre Translate
	// Esporre LookAt
	// Esporre Rotate
	// Esporre GetRotateX
	// Esporre GetRotateY
	// Esporre GetRotateZ
}
Example #24
0
void ScriptEventListener::ScriptEventDelegate(IEventDataPtr pEvent)
{
    GCC_ASSERT(m_scriptCallbackFunction.IsFunction());  // this should never happen since it's validated before even creating this object

    // call the Lua function
	shared_ptr<ScriptEvent> pScriptEvent = static_pointer_cast<ScriptEvent>(pEvent);
	LuaPlus::LuaFunction<void> Callback = m_scriptCallbackFunction;
	Callback(pScriptEvent->GetEventData());
}
void LuaScriptComponent::RegisterScriptFunctions()
{
	// create the meta table
	LuaPlus::LuaObject metaTableObj = LuaStateManager::Get()->GetGlobalVars().CreateTable(LUA_METATABLE_NAME);
	metaTableObj.SetObject("__index", metaTableObj);

	// bind functions to lua object
	metaTableObj.RegisterObjectDirect("GetObjectId", (LuaScriptComponent*)0, &LuaScriptComponent::GetObjectId);
	metaTableObj.RegisterObjectDirect("GetPos", (LuaScriptComponent*)0, &LuaScriptComponent::GetPos);
	metaTableObj.RegisterObjectDirect("SetPos", (LuaScriptComponent*)0, &LuaScriptComponent::SetPos);
	metaTableObj.RegisterObjectDirect("GetLookAt", (LuaScriptComponent*)0, &LuaScriptComponent::GetLookAt);
	metaTableObj.RegisterObjectDirect("GetYOrientationRadians", (LuaScriptComponent*)0, &LuaScriptComponent::GetYOrientationRadians);
	metaTableObj.RegisterObjectDirect("RotateY", (LuaScriptComponent*)0, &LuaScriptComponent::RotateY);
	metaTableObj.RegisterObjectDirect("Stop", (LuaScriptComponent*)0, &LuaScriptComponent::Stop);
	metaTableObj.RegisterObjectDirect("SetPosition", (LuaScriptComponent*)0, &LuaScriptComponent::SetPosition);
}
Example #26
0
void AEngineFramework::Desc::deserialize(lua::State* luaState, const LuaPlus::LuaObject& src){
	// Logging
	LuaObject loggingTable = src.Get("logging");
	if(loggingTable.IsTable()){
		luaConv(loggingTable.Get("filePath"), logging.filePath);
		luaConv(loggingTable.Get("enabled"), logging.enabled);
	}

	// Layout
	LuaObject windowTable = src.Get("window");
	window.deserialize(luaState, windowTable);

	// File system
	LuaObject fileSysTable = src.Get("file_system");
	fileSystem.deserialize(luaState, fileSysTable);

	// Misc
	luaConv(src.Get("home_dir"), homeDir);
	luaConv(src.Get("main_loop_step"), mainLoopStep);
}
Example #27
0
float InternalScriptExports::GetYRotationFromVector(LuaPlus::LuaObject vec3)
{
    if (vec3.IsTable())
    {
        Vec3 lookAt(vec3["x"].GetFloat(), vec3["y"].GetFloat(), vec3["z"].GetFloat());
        return ::GetYRotationFromVector(lookAt);
    }

    GCC_ERROR("Invalid object passed to GetYRotationFromVector(); type = " + std::string(vec3.TypeName()));
    return 0;
}
Example #28
0
bool EvtData_EndAccelerating::buildEventFromScript(void)
{
	if (m_eventData.IsTable())
	{
		// ID
		LuaPlus::LuaObject temp = m_eventData.GetByName("id");
		if (temp.IsInteger())
		{
			m_id = temp.GetInteger();
		}
		else
		{
			GCC_ERROR("Invalid id sent to EvtData_EndAccelerating; type = " + std::string(temp.TypeName()));
			return false;
		}

		return true;
	}

	return false;
}
    // /////////////////////////////////////////////////////////////////
    //
    // /////////////////////////////////////////////////////////////////
    bool SetVector3FromLua(const LuaPlus::LuaObject &dirData, Vector3 &direction)
    {
        if(!dirData.IsTable()) {
            return (false);
        }

        LuaPlus::LuaObject xData = dirData["x"];
        LuaPlus::LuaObject yData = dirData["y"];
        LuaPlus::LuaObject zData = dirData["z"];

        if(!xData.IsNumber() || !yData.IsNumber() || !zData.IsNumber()) {
            return (false);
        }

        F32 x = static_cast<F32>(xData.GetNumber());
        F32 y = static_cast<F32>(yData.GetNumber());
        F32 z = static_cast<F32>(zData.GetNumber());
        direction.Set(x, y, z);

        return (true);
    }
    // /////////////////////////////////////////////////////////////////
    //
    // /////////////////////////////////////////////////////////////////
    bool SetPoint3FromLua(const LuaPlus::LuaObject &posData, Point3 &position)
    {
        if(!posData.IsTable()) {
            return (false);
        }

        LuaPlus::LuaObject xData = posData["x"];
        LuaPlus::LuaObject yData = posData["y"];
        LuaPlus::LuaObject zData = posData["z"];

        if(!xData.IsNumber() || !yData.IsNumber() || !zData.IsNumber()) {
            return (false);
        }

        F32 x = static_cast<F32>(xData.GetNumber());
        F32 y = static_cast<F32>(yData.GetNumber());
        F32 z = static_cast<F32>(zData.GetNumber());
        position.Set(x, y, z);

        return (true);
    }