863 lines
22 KiB
C++
863 lines
22 KiB
C++
/****************************************************************************
|
||
Copyright (c) 2007,Radon Labs GmbH
|
||
Copyright (c) 2011-2013,WebJet Business Division,CYOU
|
||
|
||
http://www.genesis-3d.com.cn
|
||
|
||
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 "stdneb.h"
|
||
#include "profiletool.h"
|
||
#include "gameapplication.h"
|
||
#include "gameserver.h"
|
||
|
||
#include "io/logfileconsolehandler.h"
|
||
#include "io/assignregistry.h"
|
||
|
||
#include "inputfeature/inputfeature.h"
|
||
#include "basegamefeature/basegamefeature.h"
|
||
#include "graphicfeature/graphicsfeature.h"
|
||
#include "particlefeature/particlefeature.h"
|
||
#include "vegetationfeature/vegetationfeature.h"
|
||
#include "resourcefeature/ResourceFeature.h"
|
||
#include "physXfeature/PhysicsFeature.h"
|
||
#include "animationfeature/AnimationFeature.h"
|
||
#include "scriptfeature/inc/script_feature.h"
|
||
#include "soundfeature/SoundFeature.h"
|
||
#include "guifeature/FontFeature.h"
|
||
#include "guifeature/guiserver.h"
|
||
#include "guifeature/guiinputhandler.h"
|
||
#include "appframework/scene.h"
|
||
#include "graphicsystem/Projector/CollisionModelServer.h"
|
||
#include "ALSystemFeature/ALSystemFeature.h"
|
||
|
||
#include "app/scriptfeature/script_root_instance.h"
|
||
#include "input/inputsource.h"
|
||
|
||
|
||
#ifdef __WIN32__
|
||
#include <windowsx.h>
|
||
#endif
|
||
|
||
#if __NEBULA3_HTTP__
|
||
#include "core/debug/corepagehandler.h"
|
||
#include "threading/debug/threadpagehandler.h"
|
||
#include "memory/debug/memorypagehandler.h"
|
||
#include "io/debug/consolepagehandler.h"
|
||
#include "io/debug/iopagehandler.h"
|
||
#endif
|
||
|
||
#include "shadercompiler/ShaderFactory.h"
|
||
|
||
namespace App
|
||
{
|
||
|
||
__ImplementThreadSingleton(App::GameApplication);
|
||
|
||
using namespace Util;
|
||
using namespace Core;
|
||
using namespace IO;
|
||
using namespace Debug;
|
||
|
||
static void pack_system_waning(const char* msg)
|
||
{
|
||
n_warning(msg);
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
*/
|
||
GameApplication::GameApplication()
|
||
: mGameWidth( 0 )
|
||
, mGameHeight( 0 )
|
||
, mResourceBaseDir()
|
||
//, mAssetName()
|
||
, mResDownloadUrl()
|
||
, mPipeName()
|
||
//, mUseLocalRes( false )
|
||
, mDebugScript( false )
|
||
, mInitGui( true )
|
||
, mbUseFileService( false )
|
||
, mUseWeb( false )
|
||
, mWinHandle( NULL )
|
||
, mAssignRegistry(NULL)
|
||
, mQuit(false)
|
||
, mDeviceState(DS_Normal)
|
||
, m_pShaderFactory(NULL)
|
||
, mOpenSceneDirty(false)
|
||
, mCloseSceneDirty(false)
|
||
{
|
||
__ConstructThreadSingleton;
|
||
_RegisterDynamicClass();
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
*/
|
||
GameApplication::~GameApplication()
|
||
{
|
||
n_assert(!this->IsOpen());
|
||
__DestructThreadSingleton;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
*/
|
||
bool
|
||
GameApplication::Open()
|
||
{
|
||
Super::Open();
|
||
mQuit = false;
|
||
n_assert(NULL == this->mAssignRegistry);
|
||
this->mAssignRegistry = n_new(IO::AssignRegistry);
|
||
this->mAssignRegistry->Setup();
|
||
setupProjectAssigns();
|
||
|
||
// setup from cmd line args
|
||
this->setupAppFromCmdLineArgs();
|
||
|
||
// setup basic Nebula3 runtime system
|
||
this->mCoreServer = CoreServer::Create();
|
||
this->mCoreServer->SetCompanyName(Application::Instance()->GetCompanyName());
|
||
this->mCoreServer->SetAppName(Application::Instance()->GetAppTitle());
|
||
this->mCoreServer->Open();
|
||
|
||
// setup the job system
|
||
#if __WIN32__
|
||
this->mJobSystem = Jobs::JobSystem::Create();
|
||
this->mJobSystem->Setup();
|
||
#endif
|
||
|
||
|
||
// setup io subsystem
|
||
this->mIoServer = IoServer::Create();//<2F><><EFBFBD>߳<EFBFBD>io<69><6F>
|
||
this->mIoServer->MountStandardArchives();
|
||
|
||
this->mIoInterface = IoInterface::Create();
|
||
this->mIoInterface->Open();
|
||
GPtr<UseFileService> msg = UseFileService::Create();
|
||
|
||
|
||
if (this->mbUseFileService)
|
||
{
|
||
msg->SetUseFileService(true);
|
||
msg->SetFileServiceDir(mFileServicePath);
|
||
msg->SetServerAddress(mResDownloadUrl);
|
||
msg->SetCacheDir(mResourceBaseDir);
|
||
}
|
||
else
|
||
{
|
||
msg->SetUseFileService(false);
|
||
}
|
||
|
||
IO::IoInterface::Instance()->SendWait( msg.upcast<Messaging::Message>() );
|
||
n_assert(msg->GetResult() == true);
|
||
Pack::PackageSystem::SetWarningCallBack(pack_system_waning);
|
||
//this->mIoServer->MountArchive("D:\\TLRun.zip");
|
||
#if __ANDROID__
|
||
if(mbNeedReadApk)
|
||
{
|
||
//Pack::PackageSystem::OpenPackageInAPK( mApkPath.AsCharPtr() );
|
||
this->mIoServer->MountArchive(mApkPath);
|
||
}
|
||
else
|
||
{
|
||
Pack::PackageSystem::OpenPackage();
|
||
}
|
||
#else
|
||
Pack::PackageSystem::OpenPackage();
|
||
#endif
|
||
|
||
displayLOGO();
|
||
// attach a log file console handler
|
||
#if __WIN32__
|
||
GPtr<LogFileConsoleHandler> logFileHandler = LogFileConsoleHandler::Create();
|
||
Console::Instance()->AttachHandler(logFileHandler.upcast<ConsoleHandler>());
|
||
#endif
|
||
|
||
#if __NEBULA3_HTTP__
|
||
// setup http subsystem
|
||
this->mHttpInterface = Http::HttpInterface::Create();
|
||
this->mHttpInterface->Open();
|
||
this->mHttpServerProxy = Http::HttpServerProxy::Create();
|
||
this->mHttpServerProxy->Open();
|
||
this->mHttpServerProxy->AttachRequestHandler(Debug::CorePageHandler::Create());
|
||
this->mHttpServerProxy->AttachRequestHandler(Debug::ThreadPageHandler::Create());
|
||
this->mHttpServerProxy->AttachRequestHandler(Debug::MemoryPageHandler::Create());
|
||
this->mHttpServerProxy->AttachRequestHandler(Debug::ConsolePageHandler::Create());
|
||
this->mHttpServerProxy->AttachRequestHandler(Debug::IoPageHandler::Create());
|
||
|
||
// setup debug subsystem
|
||
this->mDebugInterface = DebugInterface::Create();
|
||
this->mDebugInterface->Open();
|
||
|
||
#endif
|
||
|
||
m_pShaderFactory = ShaderProgramCompiler::ShaderFactory::Create();
|
||
|
||
// create our game server and open it
|
||
this->mGameServer = App::GameServer::Create();
|
||
this->mGameServer->Open();
|
||
|
||
// create and add new game features
|
||
this->setupGameFeatures();
|
||
this->mGraphicObjectManager = App::GraphicObjectManager::Create();
|
||
this->mGraphicObjectManager->OnActivate();
|
||
|
||
// create collision server
|
||
mCollisonServer = Graphic::CollisionModelServer::Create();
|
||
|
||
return true;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
*/
|
||
bool GameApplication::Start()
|
||
{
|
||
Super::Start();
|
||
// setup the game
|
||
// start game world
|
||
this->mGameServer->Start();
|
||
if ( mInitGui )
|
||
{
|
||
initGui();
|
||
}
|
||
// - execute root's load method
|
||
scriptRootLoad();
|
||
if ( mInitGui )
|
||
{
|
||
initGuiScript();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
*/
|
||
void
|
||
GameApplication::Close()
|
||
{
|
||
Super::Close();
|
||
mQuit = true;
|
||
|
||
this->mGameServer->Stop();
|
||
|
||
//[2012/11/15 zhongdaohuan]
|
||
//<2F><><EFBFBD>˳<EFBFBD><CBB3>ű<EFBFBD>ϵͳ,
|
||
//<2F><><EFBFBD>˳<EFBFBD>guiϵͳ<CFB5><CDB3>
|
||
//Ȼ<><C8BB><EFBFBD>ٹص<D9B9> GameServer
|
||
if (mInitGui)
|
||
{
|
||
exitGuiScript();
|
||
}
|
||
|
||
|
||
#ifndef __SCRIPT_COMMIT__
|
||
App::Utility_ScriptRootExit();
|
||
App::ShutDownScriptSystem();
|
||
#endif
|
||
|
||
exitGui();
|
||
this->cleanupGameFeatures();
|
||
this->mGameServer->Close();
|
||
|
||
this->mGameServer = 0;
|
||
|
||
this->mGuiInputHandler = NULL;
|
||
this->mInputSource = NULL;
|
||
this->mGraphicObjectManager->OnDeactivate();
|
||
this->mGraphicObjectManager = 0;
|
||
|
||
this->mIoInterface->Close();
|
||
this->mIoInterface = 0;
|
||
|
||
this->mIoServer = 0;
|
||
|
||
this->mCollisonServer = NULL;
|
||
|
||
//this->mPackageServer = NULL;
|
||
|
||
#if __WIN32__
|
||
this->mJobSystem->Discard();
|
||
this->mJobSystem = 0;
|
||
#endif
|
||
|
||
|
||
#if __NEBULA3_HTTP__
|
||
this->mDebugInterface->Close();
|
||
this->mDebugInterface = 0;
|
||
|
||
this->mHttpServerProxy->Close();
|
||
this->mHttpServerProxy = 0;
|
||
this->mHttpInterface->Close();
|
||
this->mHttpInterface = 0;
|
||
|
||
#endif
|
||
|
||
this->mCoreServer->Close();
|
||
this->mCoreServer = 0;
|
||
n_delete(this->mAssignRegistry);
|
||
this->mAssignRegistry = NULL;
|
||
Pack::PackageSystem::Close();
|
||
|
||
n_delete(m_pShaderFactory);
|
||
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
void
|
||
GameApplication::Exit()
|
||
{
|
||
CloseAllScenes();
|
||
if (IsOpen())
|
||
{
|
||
Close();
|
||
}
|
||
|
||
eventExit(*this);
|
||
Super::Exit();
|
||
|
||
}
|
||
|
||
void GameApplication::Quit()
|
||
{
|
||
mQuit = true;
|
||
}
|
||
|
||
bool GameApplication::IsQuit()
|
||
{
|
||
return mQuit;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
Run the application. This method will return when the application wishes
|
||
to exist.
|
||
*/
|
||
void
|
||
GameApplication::Run()
|
||
{
|
||
#if __NEBULA3_HTTP__
|
||
this->mHttpServerProxy->HandlePendingRequests();
|
||
#endif
|
||
|
||
if (mOpenSceneDirty)
|
||
{
|
||
openScene(mOpenSceneName);
|
||
ActorManager::Instance()->ForceGC();
|
||
mOpenSceneDirty = false;
|
||
}
|
||
switch (mDeviceState)
|
||
{
|
||
case DS_Lost:
|
||
{
|
||
mGraphicsFeature->OnDeviceLost();
|
||
mDeviceState = DS_Losted;
|
||
}
|
||
break;
|
||
case DS_Losted:
|
||
{
|
||
if (mGraphicsFeature->CheckReset())
|
||
{
|
||
mDeviceState = DS_Reset;
|
||
}
|
||
this->mCoreServer->Trigger();
|
||
mGameServer->OnFrameWithoutGraphics();
|
||
}
|
||
break;
|
||
case DS_Reset:
|
||
{
|
||
mGraphicsFeature->OnDeviceReset();
|
||
mDeviceState = DS_Normal;
|
||
}
|
||
break;
|
||
case DS_Normal:
|
||
{
|
||
this->mCoreServer->Trigger();
|
||
mGameServer->OnFrame();
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
if (mCloseSceneDirty)
|
||
{
|
||
closeScene(mCloseSceneName);
|
||
ActorManager::Instance()->ForceGC();
|
||
mCloseSceneDirty = false;
|
||
}
|
||
PROFILE_PRESENT();
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
bool GameApplication::OpenScene(const Util::String& sceneName, bool force)
|
||
{
|
||
n_assert(IsOpen());
|
||
if (force)
|
||
{
|
||
return openScene(sceneName);
|
||
}
|
||
else
|
||
{
|
||
mOpenSceneName = sceneName;
|
||
mOpenSceneDirty = true;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
bool GameApplication::openScene(const Util::String& sceneName)
|
||
{
|
||
App::SceneScheduleManager* pSceneSchedule = App::SceneScheduleManager::Instance();
|
||
return pSceneSchedule->OpenScene(sceneName, false);
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
void GameApplication::OnStopped()
|
||
{
|
||
if(this->mScriptFeature)
|
||
{
|
||
this->mScriptFeature->OnStopped();
|
||
}
|
||
#if __USE_AUDIO__
|
||
#if __ANDROID__
|
||
// on mobile device, when press home button, stop music
|
||
if ( mSoundFeature )
|
||
{
|
||
mSoundFeature->OnStopped();
|
||
}
|
||
#endif
|
||
#endif
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
void GameApplication::OnResumed()
|
||
{
|
||
if(this->mScriptFeature)
|
||
{
|
||
this->mScriptFeature->OnResumed();
|
||
}
|
||
#if __USE_AUDIO__
|
||
#if __ANDROID__
|
||
// on mobile device, when press home button, resume music
|
||
if ( mSoundFeature )
|
||
{
|
||
mSoundFeature->OnResumed();
|
||
}
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
void GameApplication::OnExited()
|
||
{
|
||
App::ScriptRootInstance::Instance()->OnExited();
|
||
}
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
const GPtr<Scene>& GameApplication::GetCurrentScene() const
|
||
{
|
||
n_assert(IsOpen());
|
||
App::SceneScheduleManager* pSceneSchedule = App::SceneScheduleManager::Instance();
|
||
return pSceneSchedule->GetMainScene();
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
bool GameApplication::closeScene(const Util::String& sceneName)
|
||
{
|
||
App::SceneScheduleManager* pSceneSchedule = App::SceneScheduleManager::Instance();
|
||
return pSceneSchedule->CloseScene(sceneName);
|
||
}
|
||
|
||
bool GameApplication::CloseScene( const Util::String& sceneName, bool force )
|
||
{
|
||
n_assert(IsOpen());
|
||
if (force)
|
||
{
|
||
return closeScene(sceneName);
|
||
}
|
||
else
|
||
{
|
||
mCloseSceneName = sceneName;
|
||
mCloseSceneDirty = true;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
//------------------------------------------------------------------------
|
||
void GameApplication::CloseAllScenes()
|
||
{
|
||
n_assert(IsOpen());
|
||
App::SceneScheduleManager* pSceneSchedule = App::SceneScheduleManager::Instance();
|
||
pSceneSchedule->CloseAllScenes();
|
||
}
|
||
//------------------------------------------------------------------------
|
||
void GameApplication::SetInput(const GPtr<Input::InputSource>& input)
|
||
{
|
||
mInputSource = input;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
Setup new game features which should be used by this application.
|
||
Overwrite for all features which have to be used.
|
||
*/
|
||
void
|
||
GameApplication::setupGameFeatures()
|
||
{
|
||
this->mBaseGameFeature = App::BaseGameFeature::Create();
|
||
#if __WIN32__
|
||
this->mBaseGameFeature->SetCmdLineArgs(this->GetCmdLineArgs());
|
||
#endif
|
||
|
||
this->mGraphicsFeature = App::GraphicsFeature::Create();
|
||
this->mGraphicsFeature->SetWebVersion(mUseWeb);
|
||
this->mGraphicsFeature->SetMainWindow(mWinHandle);
|
||
this->mGraphicsFeature->SetWindowSize(mGameWidth, mGameHeight);
|
||
|
||
this->mGameServer->AttachGameFeature(this->mGraphicsFeature.upcast<App::Feature>());
|
||
this->mGraphicsFeature->SetDeviceLostCallBack(&_renderDeviceLost);
|
||
|
||
this->mGameServer->AttachGameFeature(this->mBaseGameFeature.cast<App::Feature>());
|
||
|
||
// input features
|
||
this->mInputFeature = App::InputFeature::Create();
|
||
#if __USE_AUDIO__ || __GENESIS_EDITOR__
|
||
this->mSoundFeature = App::SoundFeature::Create();
|
||
#endif // __USE_AUDIO__ || __GENESIS_EDITOR__
|
||
|
||
#if __WIN32__
|
||
//this->mNetworkFeature = App::NetworkFeature::Create();
|
||
#endif
|
||
|
||
this->mParticleFeature = App::ParticleFeature::Create();
|
||
this->mVegeFeature = App::VegetationFeature::Create();
|
||
this->mResourceFeature = App::ResourceFeature::Create();
|
||
#if __USE_PHYSX__ || __GENESIS_EDITOR__
|
||
this->mPhysicsFeature = App::PhysicsFeature::Create();
|
||
#endif
|
||
this->mAnimationFeature = App::AnimationFeature::Create();
|
||
#ifndef __SCRIPT_COMMIT__
|
||
this->mScriptFeature = App::ScriptFeature::Create();
|
||
#endif
|
||
|
||
#if __OSX__
|
||
// this->mFontFeature = App::FontFeature::Create();
|
||
this->mALSystemFeature = App::ALSystemFeature::Create();
|
||
#endif
|
||
|
||
|
||
#ifdef __GENESIS_EDITOR__
|
||
mFontFeature = App::FontFeature::Create();
|
||
mFontFeature->SetFontPath("editor:Font/msyh.ttf");
|
||
mFontFeature->SetShaderPath("editor:Shader/UI.shader");
|
||
|
||
mGameServer->AttachGameFeature( this->mFontFeature.upcast<App::Feature>() );
|
||
#else
|
||
# ifdef __PROFILER__
|
||
Util::String fontName = "profile:font.ttf";
|
||
Util::String shaderName = "profile:font.shader";
|
||
if (IO::IoServer::Instance()->FileExists(IO::URI(fontName)) && IO::IoServer::Instance()->FileExists(IO::URI(shaderName)))
|
||
{
|
||
mFontFeature = App::FontFeature::Create();
|
||
mFontFeature->SetFontPath(fontName);
|
||
mFontFeature->SetShaderPath(shaderName);
|
||
mGameServer->AttachGameFeature( this->mFontFeature.upcast<App::Feature>() );
|
||
}
|
||
# endif
|
||
#endif
|
||
|
||
|
||
//// DInput <20><>IO<49><4F><EFBFBD><EFBFBD>,<2C><>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4>룬<EFBFBD><EBA3AC><EFBFBD><EFBFBD>ע<EFBFBD><D7A2>ò<EFBFBD><C3B2>Ҳ<EFBFBD><D2B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
//GPtr< Input::InputHardwareSource > hardwareSource = Input::InputHardwareSource::Create();
|
||
//inputsourceList.Append( hardwareSource.upcast<Input::InputSource>() );
|
||
App::InputSourceList inputsourceList;
|
||
inputsourceList.Append(mInputSource);
|
||
mInputFeature->InitSource(inputsourceList);
|
||
|
||
// - setup ScriptSystem here
|
||
#ifndef __SCRIPT_COMMIT__
|
||
setupSciptSystem();
|
||
#endif
|
||
// - attach game feature
|
||
mGameServer->AttachGameFeature(this->mInputFeature.upcast<App::Feature>());
|
||
#if __USE_AUDIO__ || __GENESIS_EDITOR__
|
||
mGameServer->AttachGameFeature(this->mSoundFeature.upcast<App::Feature>());
|
||
#endif // __USE_AUDIO__ || __GENESIS_EDITOR__
|
||
mGameServer->AttachGameFeature(this->mParticleFeature.upcast<App::Feature>());
|
||
mGameServer->AttachGameFeature(this->mVegeFeature.upcast<App::Feature>());
|
||
mGameServer->AttachGameFeature(this->mResourceFeature.upcast<App::Feature>());
|
||
#if __USE_PHYSX__ || __GENESIS_EDITOR__
|
||
mGameServer->AttachGameFeature(this->mPhysicsFeature.upcast<App::Feature>());
|
||
#endif
|
||
mGameServer->AttachGameFeature(this->mAnimationFeature.upcast<App::Feature>());
|
||
#ifndef __SCRIPT_COMMIT__
|
||
mGameServer->AttachGameFeature(this->mScriptFeature.upcast<App::Feature>());
|
||
#endif
|
||
// #if __WIN32__
|
||
// mGameServer->AttachGameFeature(this->mNetworkFeature.upcast<App::Feature>());
|
||
// #endif
|
||
|
||
#if __OSX__
|
||
// mGameServer->AttachGameFeature(this->mFontFeature.upcast<App::Feature>());
|
||
mGameServer->AttachGameFeature(this->mALSystemFeature.upcast<App::Feature>());
|
||
#endif
|
||
//this->mBaseGameFeature->SetRenderDebug(true);
|
||
|
||
// call this function when the baseGameFeature is attach
|
||
//this->mBaseGameFeature->LoadActorTemplate();//"atp:ScriptActor.atp");
|
||
|
||
|
||
}
|
||
|
||
void
|
||
GameApplication::initGui()
|
||
{
|
||
|
||
mGuiServer = App::GUIServer::Create();
|
||
if (!mGuiServer->IsOpen())
|
||
{
|
||
mGuiServer->SetCoreFile(GUI_ROOT_CONFIG);
|
||
mGuiServer->SetEngineDir(mEngineDir);
|
||
mGuiServer->Open();
|
||
}
|
||
if (mGuiServer->IsOpen())
|
||
{
|
||
mGuiInputHandler = Input::GuiInputHandler::Create();
|
||
n_assert(mGuiInputHandler);
|
||
mInputFeature->GetInputServer()->AttachInputHandler(Input::InputPriority::Gui, mGuiInputHandler.upcast<Input::InputHandler>());
|
||
}
|
||
|
||
}
|
||
|
||
void
|
||
GameApplication::scriptRootLoad()
|
||
{
|
||
#ifndef __SCRIPT_COMMIT__
|
||
App::Utility_ScriptRootLoad();
|
||
#endif
|
||
}
|
||
|
||
void
|
||
GameApplication::initGuiScript()
|
||
{
|
||
if (mGuiServer->IsOpen())
|
||
{
|
||
mGuiServer->InitGuiRootScript();
|
||
}
|
||
}
|
||
void GameApplication::exitGuiScript()
|
||
{
|
||
if (this->mGuiServer && this->mGuiServer->IsOpen())
|
||
{
|
||
mInputFeature->GetInputServer()->RemoveInputHandler(mGuiInputHandler.upcast<Input::InputHandler>());
|
||
mGuiInputHandler = NULL;
|
||
this->mGuiServer->ExitGuiScript();
|
||
}
|
||
}
|
||
|
||
void GameApplication::exitGui()
|
||
{
|
||
if (this->mGuiServer)
|
||
{
|
||
this->mGuiServer->Close();
|
||
this->mGuiServer = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
Cleanup all added game features
|
||
*/
|
||
void
|
||
GameApplication::cleanupGameFeatures()
|
||
{
|
||
mFontFeature = NULL;
|
||
#ifndef __SCRIPT_COMMIT__
|
||
this->mScriptFeature = 0;
|
||
#endif
|
||
this->mInputFeature = 0;
|
||
this->mBaseGameFeature = 0;
|
||
#if __USE_AUDIO__ || __GENESIS_EDITOR__
|
||
this->mSoundFeature = 0;
|
||
#endif // __USE_AUDIO__ || __GENESIS_EDITOR__
|
||
#if __WIN32__
|
||
//this->mNetworkFeature = 0;
|
||
#endif
|
||
|
||
this->mParticleFeature = 0;
|
||
this->mVegeFeature = 0;
|
||
this->mResourceFeature = 0;
|
||
#if __USE_PHYSX__ || __GENESIS_EDITOR__
|
||
this->mPhysicsFeature = 0;
|
||
#endif
|
||
this->mAnimationFeature = 0;
|
||
this->mGraphicsFeature = 0;
|
||
#if __ANDROID__ || __OSX__
|
||
// this->mFontFeature = 0;
|
||
this->mALSystemFeature = 0;
|
||
#endif
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
*/
|
||
void
|
||
GameApplication::setupAppFromCmdLineArgs()
|
||
{
|
||
// allow rename of application
|
||
const Util::CommandLineArgs& args = this->GetCmdLineArgs();
|
||
if (args.HasArg("-appname"))
|
||
{
|
||
this->SetAppTitle(args.GetString("-appname"));
|
||
}
|
||
}
|
||
//------------------------------------------------------------------------
|
||
void
|
||
GameApplication::setupProjectAssigns()
|
||
{
|
||
IO::AssignRegistry* pAssignRegistry = IO::AssignRegistry::Instance();
|
||
|
||
if ( !mResDownloadUrl.IsEmpty() )
|
||
{
|
||
mbUseFileService = true;
|
||
|
||
// - resource server path of FileService
|
||
pAssignRegistry->SetAssign(IO::Assign("fsSrvPath", mResDownloadUrl));
|
||
}
|
||
|
||
pAssignRegistry->SetAssign(IO::Assign("project",mResourceBaseDir ));
|
||
pAssignRegistry->SetAssign(IO::Assign("home",mResourceBaseDir ));
|
||
|
||
pAssignRegistry->SetAssign(IO::Assign("asset", "project:Asset") ); //assetname:Asset
|
||
pAssignRegistry->SetAssign(IO::Assign("cmpileshd", "asset:compiledshaders"));
|
||
pAssignRegistry->SetAssign(IO::Assign("sys", "project:System"));
|
||
pAssignRegistry->SetAssign(IO::Assign("shd", "project:Shader"));
|
||
pAssignRegistry->SetAssign(IO::Assign("script", "project:Script"));
|
||
#ifdef __PROFILER__
|
||
pAssignRegistry->SetAssign(IO::Assign("profile", "project:Profile"));
|
||
#endif
|
||
}
|
||
|
||
void
|
||
GameApplication::setupSciptSystem()
|
||
{
|
||
Util::String binPath = IO::AssignRegistry::Instance()->ResolveAssignsInString( App::s_csScriptBinaryAssign );
|
||
Util::String emptyStr;
|
||
Util::String monoDllPath = IO::AssignRegistry::Instance()->ResolveAssignsInString( App::s_csMonoDllAssign );
|
||
GPtr<IO::Stream> pStream = IO::MemoryStream::Create();
|
||
n_assert( pStream );
|
||
// GPtr<IO::ReadStream> readStreamMsg = IO::ReadStream::Create();
|
||
// n_assert( readStreamMsg );
|
||
// readStreamMsg->SetURI( App::s_csMonoDllAssign );
|
||
// readStreamMsg->SetStream( pStream );
|
||
// IO::IoInterface::Instance()->SendWait( readStreamMsg.upcast<Messaging::Message>() );
|
||
//
|
||
// if ( !readStreamMsg->GetResult() )
|
||
// {
|
||
// n_warning( "ScriptGeneralManager::LoadAssemblies: can not open %s", App::s_csMonoDllAssign.AsCharPtr() );
|
||
// }
|
||
#if __ANDROID__
|
||
if(!mbNeedReadApk)
|
||
{
|
||
App::StartupSciptSystem( binPath, emptyStr, "/data/data/" + mPackageName+"/lib/libmono.so", mDebugScript );
|
||
}
|
||
else
|
||
{
|
||
App::StartupSciptSystem( "/data/data/"+mPackageName+"/Script", emptyStr, "/data/data/" + mPackageName+"/lib/libmono.so", mDebugScript );
|
||
}
|
||
#else
|
||
App::StartupSciptSystem( binPath, emptyStr, monoDllPath, mDebugScript );
|
||
#endif
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
/**
|
||
*/
|
||
void
|
||
GameApplication::displayLOGO()
|
||
{
|
||
#ifdef __WIN32__
|
||
Util::String filepath = "sys:logo.bmp";
|
||
if(!IO::IoServer::Instance()->FileExists(IO::URI(filepath)))
|
||
{
|
||
n_warning("\n Logo file does not exist: %s\n",filepath.AsCharPtr());
|
||
return;
|
||
}
|
||
BITMAP bmp;
|
||
HANDLE hBmp = LoadImageA(GetWindowInstance((HWND)mWinHandle),filepath.AsCharPtr(),IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
|
||
if (!hBmp)
|
||
{
|
||
n_warning("\n Loading Logo file fail!\nPlease check it: %s\n",filepath.AsCharPtr());
|
||
return;
|
||
}
|
||
HDC hDC = ::GetDC((HWND)mWinHandle);
|
||
HDC hMemDC = ::CreateCompatibleDC(hDC);
|
||
HBITMAP hBmpOld = (HBITMAP)::SelectObject(hMemDC,hBmp);
|
||
::GetObjectW(hBmp,sizeof(BITMAP),&bmp);
|
||
::StretchBlt(hDC,0,0,mGameWidth,mGameHeight,hMemDC,0,0,bmp.bmWidth,bmp.bmHeight,SRCCOPY);
|
||
::SelectObject(hMemDC,hBmpOld);
|
||
::DeleteObject(hBmp);
|
||
::DeleteObject(hBmpOld);
|
||
::ReleaseDC((HWND)mWinHandle,hDC);
|
||
#endif
|
||
}
|
||
|
||
void GameApplication::_renderDeviceLost()
|
||
{
|
||
GameApplication::Instance()->mDeviceState = DS_Lost;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
#ifdef __GENESIS_EDITOR__
|
||
void GameApplication::BuildEditorVersion(void)
|
||
{
|
||
return;
|
||
}
|
||
#endif
|
||
//------------------------------------------------------------------------------
|
||
|
||
void GameApplication::SetDeviceLost()
|
||
{
|
||
//mGraphicsFeature->SetDeviceLost();
|
||
mDeviceState = DS_Lost;
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
#if __ANDROID__
|
||
//------------------------------------------------------------------------------
|
||
Util::String GameApplication::GetAppDicOnMobile()
|
||
{
|
||
Util::String dic = "data/data/"+mPackageName;
|
||
return dic;
|
||
}
|
||
#endif
|
||
//------------------------------------------------------------------------------
|
||
#if __OSX__
|
||
Util::String GameApplication::GetAppDicOnMobile()
|
||
{
|
||
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
|
||
|
||
} // namespace App
|