void KisChangePrimarySettingAction::mouseMoved(const QPointF &lastPos, const QPointF &pos)
{
Q_UNUSED(lastPos);
QMouseEvent targetEvent(QEvent::MouseButtonRelease, pos.toPoint(), Qt::NoButton, Qt::LeftButton, Qt::ShiftModifier);
inputManager()->toolProxy()->mouseMoveEvent(&targetEvent, inputManager()->widgetToPixel(pos));
}
void KisChangePrimarySettingAction::begin(int shortcut, QEvent *event)
{
KisAbstractInputAction::begin(shortcut, event);
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(QEvent::MouseButtonPress, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ShiftModifier);
inputManager()->toolProxy()->mousePressEvent(&targetEvent, inputManager()->widgetToPixel(mouseEvent->posF()));
}
void KisChangePrimarySettingAction::end(QEvent *event)
{
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(QEvent::MouseButtonRelease, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ShiftModifier);
inputManager()->toolProxy()->mouseReleaseEvent(&targetEvent, inputManager()->widgetToPixel(mouseEvent->posF()));
KisAbstractInputAction::end(event);
}
void KisGammaExposureAction::begin(int shortcut, QEvent *event)
{
KisAbstractInputAction::begin(shortcut, event);
KisExposureGammaCorrectionInterface *interface =
inputManager()->canvas()->exposureGammaCorrectionInterface();
switch(shortcut) {
case ExposureShortcut:
d->baseExposure = interface->currentExposure();
d->mode = (Shortcuts)shortcut;
break;
case GammaShortcut:
d->baseGamma = interface->currentGamma();
d->mode = (Shortcuts)shortcut;
break;
case AddExposure05Shortcut:
d->addExposure(0.5);
break;
case RemoveExposure05Shortcut:
d->addExposure(-0.5);
break;
case AddGamma05Shortcut:
d->addGamma(0.5);
break;
case RemoveGamma05Shortcut:
d->addGamma(-0.5);
break;
case AddExposure02Shortcut:
d->addExposure(0.2);
break;
case RemoveExposure02Shortcut:
d->addExposure(-0.2);
break;
case AddGamma02Shortcut:
d->addGamma(0.2);
break;
case RemoveGamma02Shortcut:
d->addGamma(-0.2);
break;
case ResetExposureAndGammaShortcut: {
KisExposureGammaCorrectionInterface *interface =
inputManager()->canvas()->exposureGammaCorrectionInterface();
if (!interface->canChangeExposureAndGamma()) break;
interface->setCurrentGamma(1.0);
interface->setCurrentExposure(0.0);
break;
}
}
}
void ConnectKeyDown(bp::object func)
{
try
{
CL_Slot temp = inputManager().getKeyboard().sig_key_down().connect(&KeyDownWrapper, func);
inputManager().getSlots().push_back(temp);
}
catch(boost::python::error_already_set &e)
{
LOG("ConnectKeyDown failed...");
PyErr_Print();
}
}
void KisShowPaletteAction::begin(int, QEvent *event)
{
QPoint pos;
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
if (mouseEvent) {
pos = mouseEvent->pos();
} else {
pos = inputManager()->canvas()->canvasWidget()->mapFromGlobal(QCursor::pos());
}
inputManager()->canvas()->slotShowPopupPalette(pos);
}
/******************************************************************************
* This is called by the system after the input handler is no longer the active handler.
******************************************************************************/
void PickParticlePlaneInputMode::deactivated(bool temporary)
{
if(!temporary)
_pickedParticles.clear();
inputManager()->mainWindow()->statusBar()->clearMessage();
ViewportInputMode::deactivated(temporary);
}
void KisRotateCanvasAction::begin(int shortcut, QEvent *event)
{
KisAbstractInputAction::begin(shortcut, event);
KisCanvasController *canvasController =
dynamic_cast<KisCanvasController*>(inputManager()->canvas()->canvasController());
switch(shortcut) {
case RotateModeShortcut:
d->mode = (Shortcut)shortcut;
break;
case DiscreteRotateModeShortcut:
d->mode = (Shortcut)shortcut;
d->angleDrift = 0;
break;
case RotateLeftShortcut:
canvasController->rotateCanvasLeft15();
break;
case RotateRightShortcut:
canvasController->rotateCanvasRight15();
break;
case RotateResetShortcut:
canvasController->resetCanvasRotation();
break;
}
}
void KisAlternateInvocationAction::begin(int shortcut, QEvent *event)
{
if (!event) return;
KisAbstractInputAction::begin(shortcut, event);
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(QEvent::MouseButtonPress, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);;
m_d->savedAction = shortcutToToolAction(shortcut);
inputManager()->toolProxy()->forwardEvent(
KisToolProxy::BEGIN, m_d->savedAction, &targetEvent, event,
inputManager()->lastTabletEvent(),
inputManager()->canvas()->canvasWidget()->mapToGlobal(QPoint(0, 0)));
}
task main()
{
initializeRobot();
waitForStart();
startTask(Drive);
inputManager();
}
void KisAlternateInvocationAction::mouseMoved(const QPointF &lastPos, const QPointF &pos)
{
Q_UNUSED(lastPos);
QMouseEvent targetEvent(QEvent::MouseMove, pos.toPoint(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);
switch (m_savedShortcut) {
case PrimaryAlternateToggleShortcut:
targetEvent = QMouseEvent(QEvent::MouseMove, pos.toPoint(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);
break;
case SecondaryAlternateToggleShortcut:
targetEvent = QMouseEvent(QEvent::MouseMove, pos.toPoint(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier | Qt::AltModifier);
break;
}
inputManager()->toolProxy()->mouseMoveEvent(&targetEvent, inputManager()->widgetToPixel(pos));
}
task main()
{
initializeRobot();
StartTask(drive);
StartTask(moveArm);
inputManager();
}
void KisAlternateInvocationAction::end(QEvent *event)
{
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(*mouseEvent);
switch (m_savedShortcut) {
case PrimaryAlternateToggleShortcut:
targetEvent = QMouseEvent(QEvent::MouseButtonRelease, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);
break;
case SecondaryAlternateToggleShortcut:
targetEvent = QMouseEvent(QEvent::MouseButtonRelease, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier | Qt::AltModifier);
break;
}
inputManager()->toolProxy()->mouseReleaseEvent(&targetEvent, inputManager()->widgetToPixel(mouseEvent->posF()));
KisAbstractInputAction::end(event);
}
void CRenderFrm::OnStopFullScreen()
{
// turn off the input manager
CHashString inputManager(_T("CInputManager"));
static DWORD msgHash_Stop = CHashString(_T("Stop")).GetUniqueID();
m_ToolBox->SendMessage(msgHash_Stop, 0, 0, NULL, &inputManager);
static DWORD msgHash_End = CHashString(_T("End")).GetUniqueID();
m_ToolBox->SendMessage(msgHash_End, 0, 0, NULL, &inputManager);
CRenderViewer *pViewer = (CRenderViewer*)GetDLLInterface();
pViewer->ViewFullScreen(0, 0);
}
void KisAlternateInvocationAction::begin(int shortcut, QEvent *event)
{
if (!event) return;
KisAbstractInputAction::begin(shortcut, event);
QMouseEvent targetEvent(QEvent::MouseButtonPress, eventPosF(event), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier); // There must be a better way
m_d->savedAction = shortcutToToolAction(shortcut);
inputManager()->toolProxy()->forwardEvent(KisToolProxy::BEGIN, m_d->savedAction, &targetEvent, event);
}
void KisPanAction::begin(int shortcut, QEvent *event)
{
KisAbstractInputAction::begin(shortcut, event);
switch (shortcut) {
case PanToggleShortcut:
break;
case PanLeftShortcut:
inputManager()->canvas()->canvasController()->pan(QPoint(d->panDistance, 0));
break;
case PanRightShortcut:
inputManager()->canvas()->canvasController()->pan(QPoint(-d->panDistance, 0));
break;
case PanUpShortcut:
inputManager()->canvas()->canvasController()->pan(QPoint(0, d->panDistance));
break;
case PanDownShortcut:
inputManager()->canvas()->canvasController()->pan(QPoint(0, -d->panDistance));
break;
}
}
void KisAlternateInvocationAction::inputEvent(QEvent* event)
{
if (event && event->type() == QEvent::MouseMove) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(QEvent::MouseMove, mouseEvent->pos(), Qt::NoButton, Qt::LeftButton, Qt::ShiftModifier);
switch (m_d->savedAction) {
case KisTool::AlternatePickFgNode:
targetEvent = QMouseEvent(QEvent::MouseMove, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);
break;
case KisTool::AlternateThird:
targetEvent = QMouseEvent(QEvent::MouseMove, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier | Qt::AltModifier);
break;
}
inputManager()->toolProxy()->forwardEvent(
KisToolProxy::CONTINUE, m_d->savedAction, &targetEvent, event,
inputManager()->lastTabletEvent(),
inputManager()->canvas()->canvasWidget()->mapToGlobal(QPoint(0, 0)));
}
}
void KisRotateCanvasAction::cursorMoved(const QPointF &lastPos, const QPointF &pos)
{
const KisCoordinatesConverter *converter = inputManager()->canvas()->coordinatesConverter();
QPointF centerPoint = converter->flakeToWidget(converter->flakeCenterPoint());
QPointF oldPoint = lastPos - centerPoint;
QPointF newPoint = pos - centerPoint;
qreal oldAngle = atan2(oldPoint.y(), oldPoint.x());
qreal newAngle = atan2(newPoint.y(), newPoint.x());
qreal angle = (180 / M_PI) * (newAngle - oldAngle);
if (d->mode == DiscreteRotateModeShortcut) {
const qreal angleStep = 15;
qreal initialAngle = inputManager()->canvas()->rotationAngle();
qreal roundedAngle = qRound((initialAngle + angle + d->angleDrift) / angleStep) * angleStep - initialAngle;
d->angleDrift += angle - roundedAngle;
angle = roundedAngle;
}
KisCanvasController *canvasController =
dynamic_cast<KisCanvasController*>(inputManager()->canvas()->canvasController());
canvasController->rotateCanvas(angle);
}
void KisAlternateInvocationAction::end(QEvent *event)
{
if (!event) return;
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(*mouseEvent);
switch (m_d->savedAction) {
case KisTool::AlternatePickFgNode:
targetEvent = QMouseEvent(QEvent::MouseButtonRelease, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);
break;
case KisTool::AlternateThird:
targetEvent = QMouseEvent(QEvent::MouseButtonRelease, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier | Qt::AltModifier);
break;
}
inputManager()->toolProxy()->forwardEvent(
KisToolProxy::END, m_d->savedAction, &targetEvent, event,
inputManager()->lastTabletEvent(),
inputManager()->canvas()->canvasWidget()->mapToGlobal(QPoint(0, 0)));
KisAbstractInputAction::end(event);
}
task main(){
initializeRobot();
nMotorEncoder[hookMotor] = 0;
//waitForStart(); // wait for start of tele-op phase
startTask(display);
startTask(findHeading);
startTask(superDrive);
startTask(Collection);
startTask(Winch);
startTask(PrintServo);
startTask(GoalGrabber);
// startTask(Display);
inputManager();
while (true)
{
wait1Msec(10000);
}
}
void KisAlternateInvocationAction::inputEvent(QEvent* event)
{
if (event && ((event->type() == QEvent::MouseMove) || (event->type() == QEvent::TabletMove))) {
Qt::KeyboardModifiers modifiers;
switch (m_d->savedAction) {
case KisTool::AlternatePickFgNode:
modifiers = Qt::ControlModifier;
break;
case KisTool::AlternateThird:
modifiers = Qt::ControlModifier | Qt::AltModifier;
break;
default:
modifiers = Qt::ShiftModifier;
}
QMouseEvent targetEvent(QEvent::MouseMove, eventPosF(event), Qt::LeftButton, Qt::LeftButton, modifiers);
inputManager()->toolProxy()->forwardEvent(KisToolProxy::CONTINUE, m_d->savedAction, &targetEvent, event);
}
}
void KisGammaExposureAction::cursorMoved(const QPointF &lastPos, const QPointF &pos)
{
QPointF diff = -(pos - lastPos);
const int step = 200;
KisExposureGammaCorrectionInterface *interface =
inputManager()->canvas()->exposureGammaCorrectionInterface();
if (!interface->canChangeExposureAndGamma()) return;
if (d->mode == ExposureShortcut) {
d->baseExposure += qreal(diff.y()) / step;
interface->setCurrentExposure(d->baseExposure);
} else if (d->mode == GammaShortcut) {
d->baseGamma += qreal(diff.y()) / step;
interface->setCurrentGamma(d->baseGamma);
}
}
void KisAlternateInvocationAction::end(QEvent *event)
{
if (!event) return;
Qt::KeyboardModifiers modifiers;
switch (m_d->savedAction) {
case KisTool::AlternatePickFgNode:
modifiers = Qt::ControlModifier;
break;
case KisTool::AlternateThird:
modifiers = Qt::ControlModifier | Qt::AltModifier;
break;
default:
;
}
QMouseEvent targetEvent = QMouseEvent(QEvent::MouseButtonRelease, eventPosF(event), Qt::LeftButton, Qt::LeftButton, modifiers);
inputManager()->toolProxy()->forwardEvent(KisToolProxy::END, m_d->savedAction, &targetEvent, event);
KisAbstractInputAction::end(event);
}
bool GameEngine::run() {
std::vector<std::string> *serverInput;
InputManager inputManager(_managers, _map);
_eventManager = new EventManager(_map, _managers);
while (_managers->getApp()->IsOpened()) {
serverInput = _managers->getNetwork()->Select();
for (size_t i = 0; i != serverInput->size(); ++i)
_eventManager->eventHandler((*serverInput)[i]);
inputManager.getEvent();
_managers->getApp()->Clear();
draw();
_managers->getApp()->Display();
if (gameEnded == true)
_managers->getApp()->Close();
}
return (true);
}
/******************************************************************************
* This is called by the system after the input handler has become the active handler.
******************************************************************************/
void PickParticlePlaneInputMode::activated(bool temporary)
{
ViewportInputMode::activated(temporary);
inputManager()->mainWindow()->statusBar()->showMessage(tr("Pick three particles to define a new slicing plane."));
}
//-----------------------------------------------------------------------
// WinMain
//-----------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE _hInstance, HINSTANCE _hPrevInstance, LPSTR _lpCmdLine, int _nCmdShow)
{
// Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, APPLICATION_NAME, NULL };
RegisterClassEx(&wc);
// Calcular el tamano de nuestra ventana
RECT rc = {
0, 0, 800, 600
};
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
// Create the application's window
HWND hWnd = CreateWindow(APPLICATION_NAME, APPLICATION_NAME, WS_OVERLAPPEDWINDOW, 100, 100, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, wc.hInstance, NULL);
// Añadir aquí el Init de la applicacioón
s_Context.CreateContext(hWnd, 800, 600);
ShowWindow(hWnd, SW_SHOWDEFAULT);
s_Context.CreateBackBuffer(hWnd, 800, 600);
s_Context.InitStates();
{
CDebugRender debugRender(s_Context.GetDevice());
CInputManagerImplementation inputManager(hWnd);
CInputManager::SetCurrentInputManager(&inputManager);
inputManager.LoadCommandsFromFile("Data\\input.xml");
CDebugHelperImplementation debugHelper(s_Context.GetDevice());
CDebugHelper::SetCurrentDebugHelper(&debugHelper);
CApplication application(&debugRender, &s_Context);
UpdateWindow(hWnd);
MSG msg;
ZeroMemory(&msg, sizeof(msg));
// Añadir en el while la condición de salida del programa de la aplicación
DWORD m_PreviousTime = timeGetTime();
bool hasFocus = true;
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
if (!debugHelper.Update(msg.hwnd, msg.message, msg.wParam, msg.lParam))
{
bool WasDown = false, IsDown = false, Alt = false;
switch (msg.message)
{
case WM_SETFOCUS:
hasFocus = true;
inputManager.SetFocus(true);
break;
case WM_KILLFOCUS:
hasFocus = false;
inputManager.SetFocus(false);
break;
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP:
WasDown = ((msg.lParam & (1 << 30)) != 0);
IsDown = ((msg.lParam & (1 << 31)) == 0);
Alt = ((msg.lParam & (1 << 29)) != 0);
if (WasDown != IsDown)
{
if (IsDown)
{
bool consumed = false;
switch (msg.wParam)
{
case VK_RETURN:
if (Alt)
{
WINDOWPLACEMENT windowPosition = { sizeof(WINDOWPLACEMENT) };
GetWindowPlacement(msg.hwnd, &windowPosition);
ToggleFullscreen(msg.hwnd, windowPosition);
consumed = true;
}
break;
case VK_ESCAPE:
PostQuitMessage(0);
consumed = true;
break;
case VK_F4:
if (Alt)
{
PostQuitMessage(0);
consumed = true;
}
break;
}
if (consumed)
{
break;
}
}
}
if (!hasFocus || !inputManager.KeyEventReceived(msg.wParam, msg.lParam))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
break;
case WM_MOUSEMOVE:
if (hasFocus)
{
int xPosAbsolute = GET_X_LPARAM(msg.lParam);
int yPosAbsolute = GET_Y_LPARAM(msg.lParam);
inputManager.UpdateCursor(xPosAbsolute, yPosAbsolute);
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
break;
default:
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
else
{
inputManager.BeginFrame();
DWORD l_CurrentTime = timeGetTime();
float m_ElapsedTime = (float)(l_CurrentTime - m_PreviousTime)*0.001f;
m_PreviousTime = l_CurrentTime;
application.Update(m_ElapsedTime);
application.Render();
inputManager.EndFrame();
}
}
UnregisterClass(APPLICATION_NAME, wc.hInstance);
}
// Añadir una llamada a la alicación para finalizar/liberar memoria de todos sus datos
s_Context.Dispose();
return 0;
}
void KisAlternateInvocationAction::deactivate(int shortcut)
{
KisTool::ToolAction action = shortcutToToolAction(shortcut);
inputManager()->toolProxy()->deactivateToolAction(action);
}
void KisPanAction::mouseMoved(const QPointF &lastPos, const QPointF &pos)
{
QPointF relMovement = -(pos - lastPos);
inputManager()->canvas()->canvasController()->pan(relMovement.toPoint());
}
//-----------------------------------------------------------------------
// WinMain
//-----------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE _hInstance, HINSTANCE _hPrevInstance, LPSTR _lpCmdLine, int _nCmdShow)
{
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
//_CrtSetBreakAlloc(143430);
new CEngine();
CEngine& engine = CEngine::GetSingleton();
//*/
// Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, APPLICATION_NAME, NULL };
RegisterClassEx(&wc);
// Calcular el tamano de nuestra ventana
RECT rc = {
0, 0, WIDTH, HEIGHT
};
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
// Create the application's window
HWND hWnd = CreateWindow(APPLICATION_NAME, APPLICATION_NAME, WS_OVERLAPPEDWINDOW, 100, 100, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, wc.hInstance, NULL);
// Añadir aquí el Init de la applicacioón
engine.Init();
engine.getPhysXManager()->InitPhysx();
CContextManager& context = *(CEngine::GetSingleton().getContextManager());
context.CreateContext(hWnd, WIDTH, HEIGHT);
ShowWindow(hWnd, SW_SHOWDEFAULT);
context.CreateBackBuffer(hWnd, WIDTH, HEIGHT);
#ifndef _DEBUG
ToggleFullscreen( hWnd );
#endif
CPlayer *videoPlayer = NULL;
// Initialize the player object.
HRESULT hr = CPlayer::CreateInstance(hWnd, hWnd, &videoPlayer);
CEngine::GetSingleton().setPlayerManager(videoPlayer);
engine.getTextureManager()->Init();
engine.getDebugRender()->Init();
engine.getEffectsManager()->load("Data\\effects.xml");
engine.getRenderableObjectTechniqueManager()->Load("Data\\pool_renderable_objects.xml");
engine.getMaterialManager()->load("Data\\materials.xml");
engine.getCookedMeshManager()->SetCookedMeshPath("Cache\\Cooked\\");
engine.getStaticMeshManager()->Load("Data\\static_meshes.xml");
engine.getAnimatedMeshManager()->Load("Data\\animated_models.xml");
engine.getParticleManager()->Load("Data\\particle_classes.xml");
engine.getLightManager()->Load("Data\\lights.xml");
engine.getSceneRendererCommandManager()->Load("Data\\scene_renderer_commands.xml");
engine.getSceneManager()->Initialize("Data\\Scenes\\");
engine.getSoundManager()->InitAll("Data\\Sound\\Soundbanks\\SoundbanksInfo.xml", "Data\\Sound\\speakers.xml");
{
CInputManagerImplementation inputManager(hWnd);
CInputManager::SetCurrentInputManager(&inputManager);
inputManager.LoadCommandsFromFile("Data\\input.xml");
engine.getCinematicManager()->LoadFilesInDir("Data\\Animations\\");
//#ifdef _DEBUG
CDebugHelperImplementation debugHelper(context.GetDevice());
CDebugHelper::SetCurrentDebugHelper(&debugHelper);
//#endif
CApplication application(&context);
engine.setApplication( &application );
engine.getScriptManager()->Initialize("Data\\scripting.xml");
engine.getComponentManager()->FirstInitialization();
UpdateWindow(hWnd);
MSG msg;
ZeroMemory(&msg, sizeof(msg));
HCURSOR cursor = LoadCursor( NULL, IDC_ARROW );
SetCursor( cursor );
// Añadir en el while la condición de salida del programa de la aplicación
auto previousTime = std::chrono::high_resolution_clock::now();
bool hasFocus = true;
bool first = true;
while (msg.message != WM_QUIT && !application.ShouldQuit())
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
if (!debugHelper.Update(msg.hwnd, msg.message, msg.wParam, msg.lParam))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else
{
if (! CEngine::GetSingleton().getPlayerManager()->IsVideoPlaying())
{
inputManager.BeginFrame();
auto now = std::chrono::high_resolution_clock::now();
double l_ElapsedTime = std::chrono::duration_cast<std::chrono::microseconds>( ( now - previousTime ) ).count() * 0.000001;
CEngine::GetSingleton().getTimerManager()->m_elapsedTime = l_ElapsedTime;
previousTime = now;
application.Update(l_ElapsedTime);
application.Render();
application.PostRender( l_ElapsedTime );
inputManager.EndFrame();
}
else
{
inputManager.BeginFrame();
if (inputManager.IsActionActive("MOUSE_RELEASED"))
{
CEngine::GetSingleton().getPlayerManager()->Stop();
}
inputManager.EndFrame();
}
}
}
}
CEngine::ReleaseSingleton();
UnregisterClass(APPLICATION_NAME, wc.hInstance);
return 0;
}
void CFullScreenFrame::SetupInput()
{
INPUTENGPARAMS inputParams;
KEYBIND binding;
CHashString kbName(_T("GDS_kb"));
CHashString inputManager(_T("CInputManager"));
CHashString StopMessage(_T("StopPlaying"));
CHashString MoveForward(_T("CamMoveForward"));
CHashString MoveBackward(_T("CamMoveBackward"));
CHashString StrafeLeft(_T("CamStrafeLeft"));
CHashString StrafeRight(_T("CamStrafeRight"));
// create the input manager
m_ToolBox->CreateComponent(&CHashString(_T("CInputManager")), 0);
// start the input manager
HMODULE mod = GetModuleHandle(NULL);
inputParams.hMod = mod;
inputParams.hWnd = GetSafeHwnd();
inputParams.mouseImmediate = true;
inputParams.mouseExclusive = false;
inputParams.mouseFG = true;
inputParams.kbImmediate = true;
inputParams.kbExclusive = false;
inputParams.kbFG = true;
static DWORD msgHash_Begin = CHashString(_T("Begin")).GetUniqueID();
m_ToolBox->SendMessage(msgHash_Begin, sizeof(INPUTENGPARAMS), &inputParams, NULL, &inputManager);
static DWORD msgHash_Start = CHashString(_T("Start")).GetUniqueID();
m_ToolBox->SendMessage(msgHash_Start, 0, NULL, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_ESC;//0x1;
binding.m_MessageID = StopMessage.GetUniqueID();
binding.m_bHitOnce = true;
static DWORD msgHash_SetKeyBinding = CHashString(_T("SetKeyBinding")).GetUniqueID();
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_LEFT;
binding.m_MessageID = StrafeLeft.GetUniqueID();
binding.m_bHitOnce = false;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_RIGHT;
binding.m_MessageID = StrafeRight.GetUniqueID();
binding.m_bHitOnce = false;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_UP;
binding.m_MessageID = MoveForward.GetUniqueID();
binding.m_bHitOnce = false;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_DOWN;
binding.m_MessageID = MoveBackward.GetUniqueID();
binding.m_bHitOnce = false;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_A;
binding.m_MessageID = StrafeLeft.GetUniqueID();
binding.m_bHitOnce = false;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_D;
binding.m_MessageID = StrafeRight.GetUniqueID();
binding.m_bHitOnce = false;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_W;
binding.m_MessageID = MoveForward.GetUniqueID();
binding.m_bHitOnce = false;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
CHashString reloadshaders(_T("ReloadAllShaders"));
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_S;
binding.m_MessageID = MoveBackward.GetUniqueID();
binding.m_bHitOnce = false;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
binding.m_kbNameID = kbName.GetUniqueID();
binding.m_KeyID = EEK_Q;
binding.m_MessageID = reloadshaders.GetUniqueID();
binding.m_bHitOnce = true;
m_ToolBox->SendMessage(msgHash_SetKeyBinding, sizeof(KEYBIND), &binding, NULL, &inputManager);
static DWORD msgHash_SetActiveKeyBinding = CHashString(_T("SetActiveKeyBinding")).GetUniqueID();
m_ToolBox->SendMessage(msgHash_SetActiveKeyBinding, sizeof(DWORD*), &binding.m_kbNameID, &inputManager);
}
