void vHavokAiModule::RegisterLua()
{
IVScriptManager* pSM = Vision::GetScriptManager();
if (pSM != NULL)
{
lua_State* pLuaState = static_cast<VScriptResourceManager*>(pSM)->GetMasterState();
if (pLuaState)
{
luaopen_HavokAi(pLuaState);
int iRetParams = LUA_CallStaticFunction(pLuaState, "HavokAi", "vHavokAiModule", "Cast", "v>v", vHavokAiModule::GetInstance());
if (iRetParams==1)
{
if(lua_isnil(pLuaState, -1))
{
lua_pop(pLuaState, iRetParams);
}
else
{
lua_setglobal(pLuaState, "AI");
}
}
}
else
{
hkvLog::Warning("Unable to register Lua Ai Module, lua_State is NULL.");
}
}
else
{
hkvLog::Warning("Unable to register Lua Ai module, Script Manager is NULL.");
}
}
//helper method
static void EnsureScaleformScriptRegistration()
{
if (Vision::IsInitialized() || Vision::IsInitializing())
{
IVScriptManager* pScriptManager = Vision::GetScriptManager();
if(pScriptManager!=NULL)
{
lua_State* pLuaState = ((VScriptResourceManager*)pScriptManager)->GetMasterState();
if(pLuaState!=NULL)
{
lua_getglobal(pLuaState, "Scaleform");
int iType = lua_type(pLuaState, -1);
lua_pop(pLuaState, 1);
if(iType!=LUA_TUSERDATA)
{
luaopen_GFx(pLuaState);
int iRetParams = LUA_CallStaticFunction(pLuaState,"GFx","VScaleformManager","Cast","v>v",
&VScaleformManager::GlobalManager());
if (iRetParams>0)
{
if(lua_isnil(pLuaState, -1))
{
lua_pop(pLuaState, iRetParams);
}
else
{
lua_setglobal(pLuaState, "Scaleform");
return;
}
}
}
else
{
return; //already loaded
}
}
hkvLog::Warning("Unable to create Lua Scaleform Module, lua_State is NULL or cast failed!");
}
}
}
//Handle the callback
virtual void OnHandleCallback(IVisCallbackDataObject_cl *pData)
{
IVisAppPtr spApp = Vision::GetApplication();
if (pData->m_pSender == &Vision::Callbacks.OnEngineInit)
{
// Register physics module
VSmartPtr<vHavokPhysicsModule> spPhysMod = new vHavokPhysicsModule();
// spPhysMod->SetPhysicsTickCount(50); // since we are throwing objects, we need a high simulation framerate
bool bSuceeded = spApp->SetPhysicsModule(spPhysMod);
VASSERT_ALWAYS_MSG(bSuceeded, "Couldn't register Havok Physics plugin.");
return;
}
if(pData->m_pSender==&IVScriptManager::OnRegisterScriptFunctions)
{
EnsureHavokScriptRegistration();
return;
}
if (pData->m_pSender==&IVScriptManager::OnScriptProxyCreation)
{
VScriptCreateStackProxyObject * pScriptData = (VScriptCreateStackProxyObject *)pData;
//process data only as far as not handled until now
if(!pScriptData->m_bProcessed)
{
int iRetParams = 0;
if(pScriptData->m_pInstance->IsOfType(V_RUNTIME_CLASS(vHavokCharacterController)))
{
//call lua cast function for vHavokCharacterController which will push the result on the stack top
iRetParams = LUA_CallStaticFunction(pScriptData->m_pLuaState, "Physics",
"vHavokCharacterController", "Cast", "C>C", pScriptData->m_pInstance);
}
else if(pScriptData->m_pInstance->IsOfType(V_RUNTIME_CLASS(vHavokRigidBody)))
{
//call lua cast function for vHavokRigidBody which will push the result on the stack top
iRetParams = LUA_CallStaticFunction(pScriptData->m_pLuaState, "Physics",
"vHavokRigidBody", "Cast", "C>C", pScriptData->m_pInstance);
}
else if (pScriptData->m_pInstance->IsOfType(V_RUNTIME_CLASS(vHavokRagdoll)))
{
//call lua cast function for vHavokRagdoll which will push the result on the stack top
iRetParams = LUA_CallStaticFunction(pScriptData->m_pLuaState, "Physics",
"vHavokRagdoll", "Cast", "C>C", pScriptData->m_pInstance);
}
if(iRetParams>0)
{
if(lua_isnil(pScriptData->m_pLuaState, -1)) lua_pop(pScriptData->m_pLuaState, iRetParams);
else pScriptData->m_bProcessed = true;
}
}
return;
}
else
{
if (pData->m_pSender == &Vision::Callbacks.OnEngineDeInit)
{
spApp->SetPhysicsModule(NULL);
}
}
}
// implements IVisCallbackHandler_cl
void vHavokBehaviorModule::OnHandleCallback(IVisCallbackDataObject_cl *pData)
{
// Setup
// Register vision callbacks
if( pData->m_pSender == &Vision::Callbacks.OnUpdateSceneBegin )
{
checkEditorModeChanged();
stepModule();
}
else if( pData->m_pSender == &Vision::Callbacks.OnAfterSceneLoaded )
{
// Set physics module
vHavokPhysicsModule* physicsModule = vHavokPhysicsModule::GetInstance();
if( physicsModule != HK_NULL )
{
hkpWorld* physicsWorld = physicsModule->GetPhysicsWorld();
// Set world gravity
physicsWorld->markForRead();
{
hkVector4 up;
up.setNeg3( physicsWorld->getGravity() );
up.normalize3();
m_behaviorWorld->setUp( up );
}
physicsWorld->unmarkForRead();
}
else
{
hkVector4 up; vHavokConversionUtils::VisVecToPhysVec_noscale( m_visionCharacters[0]->getEntityOwner()->GetObjDir_Up(), up );
m_behaviorWorld->setUp( up );
}
}
else if( pData->m_pSender == &Vision::Callbacks.OnAfterSceneUnloaded )
{
/*#if defined(HAVOK_SDK_VERSION_MAJOR) && (HAVOK_SDK_VERSION_MAJOR >= 2012)
// destroy all unreferenced navmesh instances
m_projectAssetManager->clearAssets();
hkbOnHeapAssetLoader* assetLoader = static_cast<hkbOnHeapAssetLoader*>( m_assetLoader );
assetLoader->unloadAllAssets();
HK_ASSERT(0x21e79cc1, m_visionCharacters.getSize() == 0 );
// unload all unused resources
vHavokBehaviorResourceManager::GetInstance()->PurgeUnusedResources();
HK_ASSERT(0xc5b3c4e, vHavokBehaviorResourceManager::GetInstance()->GetResourceCount() == 0 );
#endif*/
}
else if( pData->m_pSender == &vHavokPhysicsModule::OnBeforeInitializePhysics )
{
vHavokPhysicsModuleCallbackData *pHavokData = (vHavokPhysicsModuleCallbackData*)pData;
VISION_HAVOK_SYNC_STATICS();
VISION_HAVOK_SYNC_PER_THREAD_STATICS( pHavokData->GetHavokModule() );
// Register Behavior classes
{
hkDefaultClassNameRegistry& dcnReg = hkDefaultClassNameRegistry::getInstance();
hkTypeInfoRegistry& tyReg = hkTypeInfoRegistry::getInstance();
hkVtableClassRegistry& vtcReg = hkVtableClassRegistry::getInstance();
#ifndef VBASE_LIB // DLL, so have a full set
dcnReg.registerList(hkBuiltinTypeRegistry::StaticLinkedClasses);
tyReg.registerList(hkBuiltinTypeRegistry::StaticLinkedTypeInfos);
vtcReg.registerList(hkBuiltinTypeRegistry::StaticLinkedTypeInfos, hkBuiltinTypeRegistry::StaticLinkedClasses);
#else // Static lib, just need to add Behavior ones and reg the Behavior patches which would not have been done yet
dcnReg.registerList(hkBuiltinBehaviorTypeRegistry::StaticLinkedClasses);
tyReg.registerList(hkBuiltinBehaviorTypeRegistry::StaticLinkedTypeInfos);
vtcReg.registerList(hkBuiltinBehaviorTypeRegistry::StaticLinkedTypeInfos, hkBuiltinBehaviorTypeRegistry::StaticLinkedClasses);
#endif
}
registerAnimationBehaviorPatches();
hkVersionPatchManager::getInstance().recomputePatchDependencies();
OneTimeInit();
}
else if( pData->m_pSender == &vHavokPhysicsModule::OnAfterInitializePhysics )
{
vHavokPhysicsModuleCallbackData *pHavokData = (vHavokPhysicsModuleCallbackData*)pData;
vHavokPhysicsModule* physicsModule = pHavokData->GetHavokModule();
InitWorld( physicsModule );
}
else if( pData->m_pSender == &vHavokPhysicsModule::OnBeforeDeInitializePhysics )
{
DeInitWorld();
}
else if( pData->m_pSender == &vHavokPhysicsModule::OnAfterDeInitializePhysics )
{
// Unload everything, the scene gets deleted!
OneTimeDeInit();
}
else if( pData->m_pSender == &vHavokPhysicsModule::OnUnsyncHavokStatics )
{
vHavokPhysicsModuleCallbackData *pHavokData = (vHavokPhysicsModuleCallbackData*)pData;
VISION_HAVOK_UNSYNC_STATICS();
VISION_HAVOK_UNSYNC_PER_THREAD_STATICS( pHavokData->GetHavokModule() );
}
else if( pData->m_pSender == &vHavokPhysicsModule::OnBeforeWorldCreated )
{
vHavokBeforeWorldCreateDataObject_cl *pEventData = (vHavokBeforeWorldCreateDataObject_cl *)pData;
hkJobQueue* jobQueue = pEventData->GetHavokModule()->GetJobQueue();
if( jobQueue != HK_NULL )
{
hkbBehaviorJobQueueUtils::registerWithJobQueue( jobQueue );
}
}
else if( pData->m_pSender == &vHavokVisualDebugger::OnCreatingContexts )
{
hkbBehaviorContext::registerAllBehaviorViewers();
vHavokVisualDebuggerCallbackData_cl *pEventData = (vHavokVisualDebuggerCallbackData_cl *)pData;
pEventData->m_contexts->pushBack( m_behaviorContext );
}
else if( pData->m_pSender == &vHavokVisualDebugger::OnAddingDefaultViewers )
{
vHavokVisualDebuggerCallbackData_cl *pEventData = (vHavokVisualDebuggerCallbackData_cl *)pData;
if( pEventData->m_pVisualDebugger != HK_NULL )
{
hkbBehaviorContext::addDefaultViewers( pEventData->m_pVisualDebugger );
}
}
#ifdef VLUA_USE_SWIG_BINDING
else if( pData->m_pSender == &IVScriptManager::OnRegisterScriptFunctions )
{
EnsureHavokBehaviorScriptRegistration();
}
else if (pData->m_pSender==&IVScriptManager::OnScriptProxyCreation)
{
VScriptCreateStackProxyObject * pScriptData = (VScriptCreateStackProxyObject *)pData;
// process data only if no other callback did that
if(!pScriptData->m_bProcessed)
{
int iRetParams = 0;
// call appropriate LUA cast function
if(pScriptData->m_pInstance->IsOfType(V_RUNTIME_CLASS(vHavokBehaviorComponent)))
{
iRetParams = LUA_CallStaticFunction( pScriptData->m_pLuaState, "Behavior", "vHavokBehaviorComponent", "Cast", "E>E", pScriptData->m_pInstance );
}
// could we handle the object?
if(iRetParams>0)
{
// the cast failed if the result is a nil value
if(lua_isnil(pScriptData->m_pLuaState, -1))
lua_pop(pScriptData->m_pLuaState, iRetParams); //in case of a nil value we drop the params from the lua stack
else
pScriptData->m_bProcessed = true; //avoid further processing
}
}
}
#endif
}
// -------------------------------------------------------------------------- //
// Misc
// -------------------------------------------------------------------------- //
void VFmodManager::OnHandleCallback(IVisCallbackDataObject_cl *pData)
{
if (pData->m_pSender==&Vision::Callbacks.OnEngineInit)
{
InitFmodSystem();
return;
}
if(pData->m_pSender == &Vision::Callbacks.OnEngineDeInit)
{
// release all resources before the engine deinitializes
m_soundInstances.Clear();
m_events.Clear();
m_collisionMeshes.Clear();
m_reverbs.Clear();
m_bAnyStopped = false;
DeInitFmodSystem();
return;
}
if (pData->m_pSender==&Vision::Callbacks.OnUpdateSceneFinished)
{
RunTick(Vision::GetTimer()->GetTimeDifference());
#ifdef _DEBUG_OUTPUT
SoundInstances().DebugOutput();
Events().DebugOutput();
#endif
return;
}
if (pData->m_pSender==&Vision::Callbacks.OnWorldInit)
{
if (!IsInitialized())
return;
VASSERT(m_pSystem!=NULL);
// notify the sound engine about the world extents
float fRadius = 32000.0f;
hkvAlignedBBox bbox;
Vision::GetSceneManager()->GetSceneExtents(bbox);
if (bbox.isValid())
fRadius = bbox.getBoundingSphere().m_fRadius;
FMOD_ERRORCHECK(m_pSystem->setGeometrySettings(fRadius));
return;
}
if (pData->m_pSender==&Vision::Callbacks.OnWorldDeInit)
{
// stop all instances and dispose them if possible (i.e VFMOD_FLAG_NODISPOSE flag not set)
SoundInstances().StopAll(true);
Events().StopAll(true);
// remove all collision meshes
CollisionMeshes().Clear();
// remove all reverbs
Reverbs().Clear();
m_bAnyStopped = false;
return;
}
if (pData->m_pSender==&IVScriptManager::OnScriptProxyCreation)
{
VScriptCreateStackProxyObject * pScriptData = (VScriptCreateStackProxyObject *)pData;
//process data only as far as not handled until now
if (!pScriptData->m_bProcessed)
{
int iRetParams = 0;
if (pScriptData->m_pInstance->IsOfType(V_RUNTIME_CLASS(VFmodSoundObject)))
iRetParams = LUA_CallStaticFunction(pScriptData->m_pLuaState,"FireLight","VFmodSoundObject","Cast","O>O",pScriptData->m_pInstance);
else if (pScriptData->m_pInstance->IsOfType(V_RUNTIME_CLASS(VFmodEvent)))
iRetParams = LUA_CallStaticFunction(pScriptData->m_pLuaState,"FireLight","VFmodEvent","Cast","O>O",pScriptData->m_pInstance);
if (iRetParams>0)
{
if(lua_isnil(pScriptData->m_pLuaState, -1))
lua_pop(pScriptData->m_pLuaState, iRetParams);
else
pScriptData->m_bProcessed = true;
}
}
return;
}
if(pData->m_pSender==&IVScriptManager::OnRegisterScriptFunctions)
{
IVScriptManager* pSM = Vision::GetScriptManager();
if (pSM)
{
lua_State* pLuaState = ((VScriptResourceManager*)pSM)->GetMasterState();
if(pLuaState)
{
lua_getglobal(pLuaState, "Fmod");
int iType = lua_type(pLuaState, -1);
lua_pop(pLuaState, 1);
if(iType!=LUA_TUSERDATA)
{
luaopen_FireLight(pLuaState);
int iRetParams = LUA_CallStaticFunction(pLuaState,"FireLight","VFmodManager","Cast","v>v", &VFmodManager::GlobalManager());
if (iRetParams==1)
{
if(lua_isnil(pLuaState, -1))
{
lua_pop(pLuaState, iRetParams);
}
else
{
lua_setglobal(pLuaState, "Fmod");
return;
}
}
}
else
{
return; //already loaded
}
}
Vision::Error.Warning("Unable to create Lua Fmod Module, lua_State is NULL or cast failed!");
}
return;
}
#if defined(_VISION_MOBILE)
// Pause Sound when in background
if (pData->m_pSender == &Vision::Callbacks.OnLeaveForeground)
{
if (IsInitialized())
{
// From the FMOD Ex documentation:
// "Channels will not have their per channel pause state overwritten,
// so that when a channelgroup is unpaused, the paused state of the channels will
// correct as they were set on a per channel basis."
m_pMasterGroup->getPaused(&m_bMasterGroupPausedInForeground);
m_pMusicGroup->getPaused(&m_bMusicGroupPausedInForeground);
m_pMasterGroup->setPaused(true);
m_pMusicGroup->setPaused(true);
// Get master event category and pause it as well
FMOD::EventCategory *pEventCategory = NULL;
FMOD_ERRORCHECK(m_pEventSystem->getCategoryByIndex(-1, &pEventCategory));
pEventCategory->getPaused(&m_bMasterEventCategoryPausedInForeground);
pEventCategory->setPaused(true);
}
return;
}
if (pData->m_pSender == &Vision::Callbacks.OnEnterForeground)
{
if (IsInitialized())
{
m_pMasterGroup->setPaused(m_bMasterGroupPausedInForeground);
m_pMusicGroup->setPaused(m_bMusicGroupPausedInForeground);
FMOD::EventCategory *pEventCategory = NULL;
FMOD_ERRORCHECK(m_pEventSystem->getCategoryByIndex(-1, &pEventCategory));
pEventCategory->setPaused(m_bMasterEventCategoryPausedInForeground);
}
return;
}
#endif
}
