PSDash::_void CLoginDlg::OnCreateSessionResult( _dword dwCode )
{
if(GetFramework()->GetLocalPSUID().IDType() == PSUID_GameServer)
{
return;
}
if(dwCode != E_SP_SUCCESS)
{
AtlMessageBox(m_hWnd,(LPCTSTR)GetFramework()->GetError(dwCode));
}
else
{
BSTR Username = NULL, Password = NULL;
GetDlgItemText(IDC_USERNAME, Username);
GetDlgItemText(IDC_PASSWORD, Password);
if(Username == NULL) Username = L"";
if(Password == NULL) Password = L"";
m_cfg.Set(L"Config", L"UserName",Username);
m_cfg.Set(L"Config", L"Password",Password);
GetLogWindow().SetParent(NULL);
DestroyWindow();
AtlTrace(L"[LOGINDLG] Post Quit MSG 1\n");
::PostQuitMessage(1);
}
}
void EC_Terrain::Destroy()
{
assert(GetFramework());
if (!GetFramework())
return;
boost::shared_ptr<OgreRenderer::Renderer> renderer = GetFramework()->GetServiceManager()->GetService<OgreRenderer::Renderer>().lock();
if (!renderer) // Oops! Inconvenient dtor order - can't delete our own stuff since we can't get an instance to the owner.
return;
Ogre::SceneManager *sceneMgr = renderer->GetSceneManager();
if (!sceneMgr) // Oops! Same as above.
return;
for(int y = 0; y < cNumPatchesPerEdge; ++y)
for(int x = 0; x < cNumPatchesPerEdge; ++x)
{
Ogre::SceneNode *node = GetPatch(x, y).node;
if (!node)
continue;
sceneMgr->getRootSceneNode()->removeChild(node);
// sceneMgr->destroyManualObject(dynamic_cast<Ogre::ManualObject*>(node->getAttachedObject(0)));
node->detachAllObjects();
sceneMgr->destroySceneNode(node);
}
}
void UiModule::Initialize()
{
ui_view_ = framework_->GetUIView();
if (ui_view_)
{
ui_state_machine_ = new CoreUi::UiStateMachine(ui_view_);
ui_state_machine_->RegisterScene("Inworld", ui_view_->scene());
UiAction *ether_action = new UiAction(ui_state_machine_);
QObject::connect(ether_action, SIGNAL(triggered()), ui_state_machine_, SLOT(SwitchToEtherScene()));
LogDebug("State Machine STARTED");
inworld_scene_controller_ = new InworldSceneController(GetFramework(), ui_view_);
inworld_scene_controller_->GetControlPanelManager()->SetHandler(UiDefines::Ether, ether_action);
LogDebug("Scene Manager service READY");
inworld_notification_manager_ = new NotificationManager(inworld_scene_controller_);
LogDebug("Notification Manager service READY");
ui_console_manager_ = new CoreUi::UiConsoleManager(GetFramework(), ui_view_);
LogDebug("Console UI READY");
service_getter_ = new CoreUi::ServiceGetter(GetFramework());
inworld_scene_controller_->GetControlPanelManager()->SetServiceGetter(service_getter_);
ui_state_machine_->SetServiceGetter(service_getter_);
LogDebug("Service getter READY");
}
else
LogWarning("Could not accuire QGraphicsView shared pointer from framework, UiServices are disabled");
}
void BookMarkManager::ActivateBookMark(UserMarkCopy * pCopy)
{
m_pCurBookMarkCopy.reset(pCopy);
if (pCopy)
GetFramework()->ActivateUserMark(pCopy->GetUserMark());
else
GetFramework()->ActivateUserMark(0);
}
PSDash::_void CLoginDlg::OnRegisterResult( _dword Callback, const RegisterResult & Result )
{
BOOL bShowSelectUserName = FALSE, bCanceled = FALSE;
if(Result.ErrorNum == 0)
{
MessageBox(GetFramework()->GetError(AP_E_Info_Succ), L"", MB_OK|MB_ICONEXCLAMATION);
GetDlgItem(IDC_USERNAME).SetWindowText(m_RegInfo.UserName);
GetDlgItem(IDC_PASSWORD).SetFocus();
}
else
{
CString OutMsg;
for(_dword a=0; a<Result.ErrorNum; a++)
{
CString tmp;
tmp.Format(L"%d. %s\r\n", a+1,
GetFramework()->GetError(Result.ErrorCode[a]));
OutMsg +=tmp;
if(Result.ErrorCode[a] == AP_E_Info_UserNameOccupied)
{
bShowSelectUserName = TRUE;
}
}
if(!OutMsg.IsEmpty())
{
MessageBox(OutMsg, L"Error", MB_OK | MB_ICONEXCLAMATION);
}
if(bShowSelectUserName)
{
CSelUserNameDlg dlg;
dlg.m_Result = Result;
int ret = dlg.DoModal(m_hWnd);
if(ret == IDOK)
{
STRCPYS(m_RegInfo.UserName, (LPCTSTR)dlg.m_SeledUserName);
}
else if(ret == IDCANCEL)
{
bCanceled = TRUE;
}
}
if(!bCanceled)
this->SendMessage(WM_COMMAND,
MAKEWPARAM(IDC_REGISTER, BN_CLICKED),
(LPARAM)GetDlgItem(IDC_REGISTER).m_hWnd);
}
}
double GetAzimuth(UserMark const * pUserMark, double north)
{
if (!pUserMark)
return 0;
double lat, lon;
GetFramework()->GetCurrentPosition(lat, lon);
string dist;
double azimut;
m2::PointD const pt = pUserMark->GetOrg();
GetFramework()->GetDistanceAndAzimut(pt, lat, lon, north, dist, azimut);
return azimut;
}
Tizen::Base::String GetDistance(UserMark const * pUserMark)
{
if (!pUserMark)
return "";
double lat, lon;
GetFramework()->GetCurrentPosition(lat, lon);
double north = 0;
string dist;
double azimut;
m2::PointD pt = pUserMark->GetOrg();
GetFramework()->GetDistanceAndAzimut(pt, lat, lon, north, dist, azimut);
return dist.c_str();
}
void EnvironmentModule::CreateSky()
{
sky_ = SkyPtr(new Sky(this));
Scene::ScenePtr scene = GetFramework()->GetDefaultWorldScene();
Scene::EntityPtr sky_entity = scene->CreateEntity(GetFramework()->GetDefaultWorldScene()->GetNextFreeId());
sky_entity->AddComponent(GetFramework()->GetComponentManager()->CreateComponent("EC_OgreSky"));
scene->EmitEntityCreated(sky_entity);
sky_->FindCurrentlyActiveSky();
if (!GetEnvironmentHandler()->IsCaelum())
sky_->CreateDefaultSky();
if ( environment_editor_ != 0 )
environment_editor_->InitSkyTabWindow();
}
size_t BookMarkManager::GetCategorySize(int index)
{
Framework * pFW = GetFramework();
if (index >= pFW->GetBmCategoriesCount())
return 0;
return pFW->GetBmCategory(index)->GetBookmarksCount();
}
bool BookMarkManager::IsCategoryVisible(int index)
{
Framework * pFW = GetFramework();
if (index >= pFW->GetBmCategoriesCount())
return false;
return pFW->GetBmCategory(index)->IsVisible();
}
void BookMarkManager::ShowBookMark(size_t category, size_t index)
{
::Framework * pFramework = GetFramework();
BookmarkCategory * pCategory = pFramework->GetBmCategory(category);
ActivateBookMark(pCategory->GetBookmark(index)->Copy());
pFramework->ShowBookmark(BookmarkAndCategory(category, index));
}
search::AddressInfo const GetAdressInfo(UserMark const * pUserMark)
{
if (pUserMark)
{
switch (pUserMark->GetMarkType())
{
case UserMark::POI:
{
PoiMarkPoint const * pPOI = static_cast<PoiMarkPoint const *>(pUserMark);
return pPOI->GetInfo();
}
break;
case UserMark::SEARCH:
{
SearchMarkPoint const * pSearch = static_cast<SearchMarkPoint const *>(pUserMark);
return pSearch->GetInfo();
}
break;
case UserMark::BOOKMARK:
{
search::AddressInfo addressInfo;
GetFramework()->GetAddressInfoForGlobalPoint(pUserMark->GetOrg(), addressInfo);
return addressInfo;
}
break;
default:
break;
}
}
return search::AddressInfo();
}
void WBCompEldEndgameCounter::SetHUDHidden( const bool Hidden ) const
{
UIManager* const pUIManager = GetFramework()->GetUIManager();
ASSERT( pUIManager );
STATIC_HASHED_STRING( HUD );
STATIC_HASHED_STRING( EndgameImg );
STATIC_HASHED_STRING( EndgameCounter );
{
WB_MAKE_EVENT( SetWidgetHidden, GetEntity() );
WB_SET_AUTO( SetWidgetHidden, Hash, Screen, sHUD );
WB_SET_AUTO( SetWidgetHidden, Hash, Widget, sEndgameImg );
WB_SET_AUTO( SetWidgetHidden, Bool, Hidden, Hidden );
WB_DISPATCH_EVENT( GetEventManager(), SetWidgetHidden, pUIManager );
}
{
WB_MAKE_EVENT( SetWidgetHidden, GetEntity() );
WB_SET_AUTO( SetWidgetHidden, Hash, Screen, sHUD );
WB_SET_AUTO( SetWidgetHidden, Hash, Widget, sEndgameCounter );
WB_SET_AUTO( SetWidgetHidden, Bool, Hidden, Hidden );
WB_DISPATCH_EVENT( GetEventManager(), SetWidgetHidden, pUIManager );
}
}
PSDash::_void CLoginDlg::OnDispatchGame( _dword GameID, _word MaxUserNum )
{
SessionAddress saddr;
saddr.mAddress = GetFramework()->GetPublicIP();
saddr.mSessionID = 10;
GetProcessor()->HandleDispatchGame(E_MP_DISPATCH_SUCCESS, GameID, MaxUserNum, (_dword *)this, saddr );
}
PSDash::_void CLoginDlg::OnValidateResult( _dword byCode )
{
if(byCode != AP_E_ValidateSucc)
{
AtlMessageBox(m_hWnd,(LPCTSTR)GetFramework()->GetError(byCode));
}
}
Tizen::Base::String BookMarkManager::GetSMSTextMyPosition(double lat, double lon)
{
Framework * pFW = GetFramework();
String s = pFW->CodeGe0url(lat, lon, pFW->GetDrawScale(), "").c_str();
String r = GetString(IDS_MY_POSITION_SHARE_SMS);
return detail::FormatSMSString(r, s);
}
/*virtual*/ void WBCompEldMesh::Render() {
XTRACE_FUNCTION;
ASSERT(m_Mesh);
if (m_Hidden) {
return;
}
if (m_CullDistanceSq > 0.0f) {
const Vector ViewLocation = EldritchGame::GetPlayerViewLocation();
const Vector ViewOffset = m_Mesh->m_Location - ViewLocation;
const float DistanceSq = ViewOffset.LengthSquared();
if (DistanceSq > m_CullDistanceSq) {
return;
}
}
if (m_Mesh->IsAnimated()) {
m_Mesh->UpdateBones();
}
if (!m_Mesh->GetTexture(1)) {
ITexture* const pFogTexture = GetGame()->GetFogTexture();
m_Mesh->SetTexture(1, pFogTexture);
}
GetFramework()->GetRenderer()->AddMesh(m_Mesh);
}
void Sky::OnMaterialAssetFailed(IAssetTransfer* /*transfer*/, String /*reason*/)
{
if (!GetFramework()->HasCommandLineParameter("--useErrorAsset") || !urhoNode_)
return;
/// \todo The error asset is not directly usable for skybox, as the depth is not fixed in the shader suitably
urhoNode_->GetComponent<Urho3D::Skybox>()->SetMaterial(GetSubsystem<Urho3D::ResourceCache>()->GetResource<Urho3D::Material>("Materials/AssetLoadError.xml"));
}
void WBCompEldFrobbable::SetHUDHidden(const bool Hidden) const {
UIManager* const pUIManager = GetFramework()->GetUIManager();
ASSERT(pUIManager);
STATIC_HASHED_STRING(HUD);
STATIC_HASHED_STRING(FrobName);
STATIC_HASHED_STRING(FrobVerb);
STATIC_HASHED_STRING(FrobHold);
{
WB_MAKE_EVENT(SetWidgetHidden, GetEntity());
WB_SET_AUTO(SetWidgetHidden, Hash, Screen, sHUD);
WB_SET_AUTO(SetWidgetHidden, Hash, Widget, sFrobName);
WB_SET_AUTO(SetWidgetHidden, Bool, Hidden, Hidden);
WB_DISPATCH_EVENT(GetEventManager(), SetWidgetHidden, pUIManager);
}
{
WB_MAKE_EVENT(SetWidgetHidden, GetEntity());
WB_SET_AUTO(SetWidgetHidden, Hash, Screen, sHUD);
WB_SET_AUTO(SetWidgetHidden, Hash, Widget, sFrobVerb);
WB_SET_AUTO(SetWidgetHidden, Bool, Hidden, Hidden);
WB_DISPATCH_EVENT(GetEventManager(), SetWidgetHidden, pUIManager);
}
{
WB_MAKE_EVENT(SetWidgetHidden, GetEntity());
WB_SET_AUTO(SetWidgetHidden, Hash, Screen, sHUD);
WB_SET_AUTO(SetWidgetHidden, Hash, Widget, sFrobHold);
WB_SET_AUTO(SetWidgetHidden, Bool, Hidden, Hidden || !m_HoldReleaseMode);
WB_DISPATCH_EVENT(GetEventManager(), SetWidgetHidden, pUIManager);
}
}
// virtual
void WorldInputModule::Initialize()
{
Foundation::EventManagerPtr eventmgr = GetFramework()-> GetEventManager();
event_category_id_t eid = eventmgr-> RegisterEventCategory ("Input");
eventmgr-> RegisterEvent (eid, Input::Events::MOVE_FORWARD_PRESSED, "MoveForwardPressed");
eventmgr-> RegisterEvent (eid, Input::Events::MOVE_FORWARD_RELEASED, "MoveForwardReleased");
eventmgr-> RegisterEvent (eid, Input::Events::PY_RESTART, "PyRestart");
eventmgr-> RegisterEvent (eid, Input::Events::PY_DUPLICATE_DRAG, "PyDuplicateDrag");
eventmgr-> RegisterEvent (eid, Input::Events::PY_RUN_COMMAND, "PyRunCommand");
eventmgr-> RegisterEvent (eid, Input::Events::PY_OBJECTEDIT_TOGGLE_MOVE, "PyObjectEditToggleMove");
eventmgr-> RegisterEvent (eid, Input::Events::PY_OBJECTEDIT_TOGGLE_SCALE, "PyObjectEditToggleScale");
eventmgr-> RegisterEvent (eid, Input::Events::NAALI_DELETE, "Delete");
eventmgr-> RegisterEvent (eid, Input::Events::NAALI_UNDO, "Undo");
eventmgr-> RegisterEvent (eid, Input::Events::NAALI_OBJECTLINK, "ObjectLink");
eventmgr-> RegisterEvent (eid, Input::Events::NAALI_OBJECTUNLINK, "ObjectUnlink");
eventmgr-> RegisterEvent (eid, Input::Events::KEY_PRESSED, "KeyPressed");
eventmgr-> RegisterEvent (eid, Input::Events::KEY_RELEASED, "KeyReleased");
eventmgr-> RegisterEvent (eid, Input::Events::INWORLD_CLICK, "InWorldClick");
eventmgr-> RegisterEvent (eid, Input::Events::INWORLD_CLICK_REL, "InWorldClickReleased");
eventmgr-> RegisterEvent (eid, Input::Events::LEFT_MOUSECLICK_PRESSED, "LeftMouseClickPressed");
eventmgr-> RegisterEvent (eid, Input::Events::LEFT_MOUSECLICK_RELEASED, "LeftMouseClickReleased");
eventmgr-> RegisterEvent (eid, Input::Events::RIGHT_MOUSECLICK_PRESSED, "RightMouseClickPressed");
eventmgr-> RegisterEvent (eid, Input::Events::RIGHT_MOUSECLICK_RELEASED, "RightMouseClickReleased");
eventmgr-> RegisterEvent (eid, Input::Events::INWORLD_CLICK_BUILD, "InWorldClickBuild");
eventmgr-> RegisterEvent (eid, Input::Events::INWORLD_CLICK_BUILD_REL, "InWorldClickBuildReleased");
eventmgr-> RegisterEvent (eid, Input::Events::MOUSEMOVE, "MouseMove");
eventmgr-> RegisterEvent (eid, Input::Events::MOUSEDRAG, "MouseDrag");
eventmgr-> RegisterEvent (eid, Input::Events::MOUSEDRAG_STOPPED, "MouseDragStopped");
// Listen for QEvents generated by the UIView, and generate "Input" category events
state_machine_ = StateMachinePtr (new WorldInputLogic (GetFramework()));
GetFramework()-> GetServiceManager()->
RegisterService (Foundation::Service::ST_Input, state_machine_);
state_machine_-> start();
}
void EC_VideoSource::UpdateSignals()
{
if (!GetParentEntity())
{
LogError("Couldn't update singals cause component dont have parent entity set.");
return;
}
Scene::SceneManager *scene = GetParentEntity()->GetScene();
if(!scene)
{
LogError("Fail to update signals cause parent entity's scene is null.");
return;
}
// hack hack: seems phonon is more unstable to if we login to a world and instantiate many
// players ~at the same time, so here we do a random timer to instantiate the objects so the QThreads are not
// started ~at the same time and we minimize risk or crashing. Yes i know its stupid, blame phonon!
int rand_time = qrand();
while(rand_time > 3000)
rand_time /= 2;
if (rand_time < 500)
rand_time = 500;
// The magic number of instances before certain unstability is two,
// lets not let instantiate more phonon players than that for now
Scene::EntityList list = GetFramework()->Scene()->GetDefaultScene()->GetEntitiesWithComponent(TypeNameStatic());
if (list.size() < 2)
{
LogDebug(QString("Launching video ec in %1 ms").arg(rand_time).toStdString());
QTimer::singleShot(rand_time, this, SLOT(InitializePhonon()));
}
else
{
LogDebug("Will not instantiate Phonon objects, world already has 2 EC_VideoSources. Limit hit.");
canvas_ = Get3DCanvas();
if (!canvas_)
{
LogError("Could not get 3D Canvas component");
return;
}
// Tell in the 3D scene that the video cannot be displayed as two videos are already instantiated
error_label_ = new QLabel("Maximum of inworld videos already in use");
error_label_->setFont(QFont("Arial", 14));
error_label_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
error_label_->setAlignment(Qt::AlignCenter);
QSize size = error_label_->size();
size.setHeight(size.height()+10);
size.setWidth(size.width()+10);
error_label_->resize(size);
canvas_->SetWidget(error_label_);
canvas_->SetRefreshRate(0);
canvas_->SetSubmesh(0);
QTimer::singleShot(100, canvas_, SLOT(Update()));
}
RegisterActions();
}
void EnvironmentModule::CreateTerrain()
{
terrain_ = TerrainPtr(new Terrain(this));
Scene::ScenePtr scene = GetFramework()->GetDefaultWorldScene();
Scene::EntityPtr entity = scene->CreateEntity(GetFramework()->GetDefaultWorldScene()->GetNextFreeId());
entity->AddComponent(GetFramework()->GetComponentManager()->CreateComponent("EC_Terrain"));
scene->EmitEntityCreated(entity);
terrain_->FindCurrentlyActiveTerrain();
if ( environment_editor_ != 0 )
{
environment_editor_->InitTerrainTabWindow();
environment_editor_->InitTerrainTextureTabWindow();
}
}
void BookMarkManager::DeleteCategory(int index)
{
Framework * pFW = GetFramework();
if (index >= pFW->GetBmCategoriesCount())
return;
pFW->DeleteBmCategory(index);
pFW->Invalidate();
}
LRESULT CLoginDlg::OnBnLobbyServer( WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/ )
{
CLobbyServerdlg dlg;
dlg.m_servers = GetFramework()->GetLobbyServers();
dlg.DoModal(m_hWnd);
return 0;
}
Tizen::Base::String BookMarkManager::GetCategoryName(int const index) const
{
if (index > GetCategoriesCount())
return "";
if (index < 0)
return "";
BookmarkCategory * pCategory = GetFramework()->GetBmCategory(index);
return pCategory->GetName().c_str();
}
/*virtual*/ void WBCompEldSensorVision::DebugRender() const
{
WBCompEldTransform* const pTransform = GetEntity()->GetTransformComponent<WBCompEldTransform>();
DEVASSERT( pTransform );
const Vector EyeLocation = pTransform->GetLocation() + Vector( 0.0f, 0.0f, m_EyeOffsetZ );
GetFramework()->GetRenderer()->DEBUGDrawCross( EyeLocation, 0.5f, ARGB_TO_COLOR( 255, 255, 0, 0 ) );
}
void BookMarkManager::SetCategoryVisible(int index, bool bVisible)
{
Framework * pFW = GetFramework();
if (index >= pFW->GetBmCategoriesCount())
return;
pFW->GetBmCategory(index)->SetVisible(bVisible);
pFW->GetBmCategory(index)->SaveToKMLFile();
pFW->Invalidate();
}
void UiModule::PostInitialize()
{
SubscribeToEventCategories();
ui_console_manager_->SendInitializationReadyEvent();
ether_logic_ = new Ether::Logic::EtherLogic(GetFramework(), ui_view_);
ui_state_machine_->RegisterScene("Ether", ether_logic_->GetScene());
ether_logic_->Start();
ui_state_machine_->SwitchToEtherScene();
LogDebug("Ether Logic STARTED");
}
void WorldBuildingModule::PostInitialize()
{
// Get all category id's that we are interested in
SubscribeToEventCategories();
// Register building key context
input_context_ = GetFramework()->Input().RegisterInputContext("WorldBuildingContext", 90);
connect(input_context_.get(), SIGNAL(KeyPressed(KeyEvent*)), build_scene_manager_.get(), SLOT(KeyPressed(KeyEvent*)));
connect(input_context_.get(), SIGNAL(KeyReleased(KeyEvent*)), build_scene_manager_.get(), SLOT(KeyReleased(KeyEvent*)));
}
/*virtual*/ void WBCompEldFrobbable::DebugRender() const {
WBCompEldTransform* const pTransform =
GetEntity()->GetTransformComponent<WBCompEldTransform>();
DEVASSERT(pTransform);
const Vector Location = pTransform->GetLocation() + m_BoundOffset;
GetFramework()->GetRenderer()->DEBUGDrawBox(Location - m_BoundExtents,
Location + m_BoundExtents,
ARGB_TO_COLOR(255, 255, 128, 0));
}
