//--------------------------------------------------------------------------------
bool App::HandleEvent( EventPtr pEvent )
{
eEVENT e = pEvent->GetEventType();
if ( e == SYSTEM_KEYBOARD_KEYDOWN )
{
EvtKeyDownPtr pKeyDown = std::static_pointer_cast<EvtKeyDown>( pEvent );
unsigned int key = pKeyDown->GetCharacterCode();
}
else if ( e == SYSTEM_KEYBOARD_KEYUP )
{
EvtKeyUpPtr pKeyUp = std::static_pointer_cast<EvtKeyUp>( pEvent );
unsigned int key = pKeyUp->GetCharacterCode();
if ( 'A' == key ) // 'A' Key - restart animations
{
m_pDisplacedActor->PlayAllAnimations();
m_pSkinnedActor->PlayAllAnimations();
return( true );
}
}
// Call the parent class's event handler if we haven't handled the event.
return( RenderApplication::HandleEvent( pEvent ) );
}
//--------------------------------------------------------------------------------
bool RenderApplication::HandleEvent( EventPtr pEvent )
{
// This method body is included here for future use, to allow the
// RenderApplication to handle some events if needed.
eEVENT e = pEvent->GetEventType();
if ( e == WINDOW_RESIZE )
{
EvtWindowResizePtr pResize = std::static_pointer_cast<EvtWindowResize>( pEvent );
this->HandleWindowResize( pResize->GetWindowHandle(), pResize->NewWidth(), pResize->NewHeight() );
return( true );
}
else if ( e == SYSTEM_KEYBOARD_KEYUP )
{
EvtKeyUpPtr pKeyUp = std::static_pointer_cast<EvtKeyUp>( pEvent );
unsigned int key = pKeyUp->GetCharacterCode();
if ( key == VK_F1 ) // 'F1' Key - Toggle the multithreading state
{
ToggleMultiThreadedMode();
return true;
}
else if ( key == '\t' ) // TAB Key - Toggle the console on and off.
{
if ( m_InputMode == InputMode::Camera )
{
m_InputMode = InputMode::Console;
m_pScene->GetRoot()->AttachChild( m_pConsole->GetNode() );
}
else
{
m_InputMode = InputMode::Camera;
m_pScene->GetRoot()->DetachChild( m_pConsole->GetNode() );
}
return true;
}
}
if ( m_InputMode == InputMode::Camera ) {
if ( CameraEventHub.ProcessEvent( pEvent ) ) {
return true;
}
}
if ( m_InputMode == InputMode::Console ) {
if ( ConsoleEventHub.ProcessEvent( pEvent ) ) {
return true;
}
}
// Call the parent class's event handler if we haven't handled the event.
return( Application::HandleEvent( pEvent ) );
}
//--------------------------------------------------------------------------------
bool App::HandleEvent( EventPtr pEvent )
{
eEVENT e = pEvent->GetEventType();
if ( e == SYSTEM_KEYBOARD_KEYDOWN )
{
EvtKeyDownPtr pKeyDown = std::static_pointer_cast<EvtKeyDown>( pEvent );
unsigned int key = pKeyDown->GetCharacterCode();
}
else if ( e == SYSTEM_KEYBOARD_KEYUP )
{
EvtKeyUpPtr pKeyUp = std::static_pointer_cast<EvtKeyUp>( pEvent );
unsigned int key = pKeyUp->GetCharacterCode();
if ( 'W' == key )
{
// Toggle Wireframe
m_bSolidRender = !m_bSolidRender;
m_pTerrainEffect->m_iRasterizerState = m_bSolidRender ? m_rsSolid : m_rsWireframe;
}
else if ( 'D' == key )
{
// Debug colours - show LOD or N-dot-L shading
switch( m_smCurrentShading )
{
case SolidColour:
m_smCurrentShading = SimpleShading;
break;
case SimpleShading:
m_smCurrentShading = LodDebugView;
break;
case LodDebugView:
m_smCurrentShading = SolidColour;
break;
}
m_pTerrainEffect->SetDomainShader( m_TerrainDomainShaders[ m_smCurrentShading ] );
}
else if ( 'L' == key )
{
// Toggle between simple and CS-based LOD
m_bSimpleComplexity = !m_bSimpleComplexity;
m_pTerrainEffect->SetHullShader( m_bSimpleComplexity ? m_iSimpleHullShader : m_iComplexHullShader );
}
else if ( 'A' == key )
{
// Toggle automated camera
m_bViewPointInAutoMode = !m_bViewPointInAutoMode;
}
}
// Call the parent class's event handler if we haven't handled the event.
return( Application::HandleEvent( pEvent ) );
}
bool EventManagerImpl::VProcessEvents(long p_time)
{
//TODO ThreadSafeQueue
std::cout << "HAHAHA" << std::endl;
int queueToProcess = m_activeQueue;
m_activeQueue = (m_activeQueue + 1) % EVENTMANAGER_NUM_QUEUES;
m_queues[m_activeQueue].clear();
while (!m_queues[queueToProcess].empty())
{
EventPtr pEvent = m_queues[queueToProcess].front();
m_queues[queueToProcess].pop_front();
//TODO Log Processing Event ...
const EventType& eventType = pEvent->GetEventType();
auto findIt = m_eventListeners.find(eventType);
if (findIt != m_eventListeners.end())
{
const EventListenerList& eventListeners = findIt->second;
for (auto itListener = eventListeners.begin(); itListener != eventListeners.end(); ++itListener)
{
EventListenerPtr listener = (*itListener);
listener->VprocessEvent(pEvent);
}
}
// Time check
}
//If we couldn't process allEvents, we push them to the front of the new active queue
bool queueFlushed = (m_queues[queueToProcess].empty());
if (!queueFlushed)
{
while (!m_queues[queueToProcess].empty())
{
EventPtr pEvent = m_queues[queueToProcess].back();
m_queues[queueToProcess].pop_back();
m_queues[m_activeQueue].push_front(pEvent);
}
}
return queueFlushed;
}
bool EventManagerImpl::VTriggerEvent(EventPtr& p_event)
{
//TODO log
bool processed = false;
auto findIt = m_eventListeners.find(p_event->GetEventType());
if (findIt != m_eventListeners.end())
{
const EventListenerList& eventListenerList = findIt->second;
for (EventListenerList::const_iterator itListener = eventListenerList.begin(); itListener != eventListenerList.end(); ++itListener)
{
EventListenerPtr listener = (*itListener);
listener->VprocessEvent(p_event);
processed = true;
}
}
return processed;
}
//--------------------------------------------------------------------------------
bool App::HandleEvent( EventPtr pEvent )
{
eEVENT e = pEvent->GetEventType();
if ( e == SYSTEM_KEYBOARD_KEYUP )
{
EvtKeyUpPtr pKeyUp = std::static_pointer_cast<EvtKeyUp>( pEvent );
unsigned int key = pKeyUp->GetCharacterCode();
if ( key == 0x31 ) // Pressing the '1' key will pass events to the main application
{
m_uiInputTarget = 1;
return( true );
}
else if ( key == 0x32 ) // Pressing the '2' key will pass events to the first glyphlet
{
m_uiInputTarget = 2;
return( true );
}
else if ( key == 0x33 ) // Pressing the '3' key will pass events to the first glyphlet
{
m_uiInputTarget = 3;
return( true );
}
}
// All other key up events will be forwarded appropriately:
bool bHandled = false;
if ( m_uiInputTarget == 2 ) {
bHandled = m_pActor1->m_pGlyphlet->EvtManager.ProcessEvent( pEvent );
}
else if ( m_uiInputTarget == 3 ) {
bHandled = m_pActor2->m_pGlyphlet->EvtManager.ProcessEvent( pEvent );
}
// Call the parent class's event handler if we haven't handled the event.
if ( bHandled )
return( true );
else
return( RenderApplication::HandleEvent( pEvent ) );
}
bool Application::HandleEvent(EventPtr event)
{
EventType eventType = event->GetEventType();
if (eventType == EventType::INFO_MESSAGE)
{
// 若是信息，弹窗提醒
EventInfoMessagePtr infoMessageEvent = std::static_pointer_cast<EventInfoMessage>(event);
MessageBox(0, infoMessageEvent->GetInfoMessage().c_str(), L"Info Message", MB_ICONINFORMATION | MB_SYSTEMMODAL);
}
else if (eventType == EventType::ERROR_MESSAGE)
{
// 若是错误信息,弹窗提醒并结束运行
EventErrorMessagePtr errorMessageEvent = std::static_pointer_cast<EventErrorMessage>(event);
MessageBox(0, errorMessageEvent->GetErrorMessage().c_str(), L"Error Message", MB_ICONERROR | MB_SYSTEMMODAL);
RequestTermination();
}
else if (eventType == EventType::SYSTEM_KEYBOARD_KEYUP)
{
EventKeyUpPtr keyUevent = std::static_pointer_cast<EventKeyUp>(event);
//Attention mark：实际上这里应该提供一个可以配置的按键映射，考虑到这个handleEvent是可以自行重载的故，可以在这里暂时不用考虑
// 判断按下的是哪个键
UINT key = keyUevent->GetCharacterCode();
if (key == VK_ESCAPE)
{
// 按下的是Esc, 该键用于结束程序运行
RequestTermination();
return true;
}
else if (key == VK_SPACE)
{
// 按下空格，保存当前帧图像
mSaveScreenShot = true;
return true;
}
}
return true;
}
//--------------------------------------------------------------------------------
bool App::HandleEvent( EventPtr pEvent )
{
eEVENT e = pEvent->GetEventType();
if ( e == SYSTEM_KEYBOARD_KEYDOWN )
{
EvtKeyDownPtr pKeyDown = std::static_pointer_cast<EvtKeyDown>( pEvent );
unsigned int key = pKeyDown->GetCharacterCode();
}
else if ( e == SYSTEM_KEYBOARD_KEYUP )
{
EvtKeyUpPtr pKeyUp = std::static_pointer_cast<EvtKeyUp>( pEvent );
unsigned int key = pKeyUp->GetCharacterCode();
}
// Call the parent class's event handler if we haven't handled the event.
return( RenderApplication::HandleEvent( pEvent ) );
}
bool EventManagerImpl::VQueueEvent(EventPtr& p_event) {
if (m_activeQueue < 0 || m_activeQueue > EVENTMANAGER_NUM_QUEUES)
return false; //BIG ERROR
//std::cout << "Neues Event: " << EventTypeValueNames[p_event->GetEventType()] << std::endl;
if (!p_event)
{
return false;
}
auto findIt = m_eventListeners.find(p_event->GetEventType());
if (findIt != m_eventListeners.end())
{
m_queues[m_activeQueue].push_back(p_event);
return true;
}
else
{
return false;
}
}
