// Moves/alters the camera positions based on user input
void Camera::movement(GLFWwindow *window)
{
if (keys[GLFW_KEY_ESCAPE] )
glfwSetWindowShouldClose(window, GL_TRUE);
// Camera controls
if(keys[GLFW_KEY_W])
ProcessKeyboard(FORWARD, deltaTime);
if(keys[GLFW_KEY_S])
ProcessKeyboard(BACKWARD, deltaTime);
if(keys[GLFW_KEY_A])
ProcessKeyboard(LEFT, deltaTime);
if(keys[GLFW_KEY_D])
ProcessKeyboard(RIGHT, deltaTime);
if (keys[GLFW_KEY_C])
{
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
ctr = false;
}
if (keys[GLFW_KEY_X])
{
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
ctr = true;
}
}
void WinRawInput::ProcessRawInput(MSG& msg)
{
UINT dwSize;
GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));
if(dwSize > m_inputBufferBytes)
{
m_inputBufferBytes = dwSize;
mem_free(m_inputBuffer);
m_inputBuffer = (uint8*)mem_alloc(dwSize);
}
if (GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, m_inputBuffer, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize )
{
logger() << "GetRawInputData does not return correct size !\n";
return;
}
RAWINPUT* raw = (RAWINPUT*)m_inputBuffer;
if (raw->header.dwType == RIM_TYPEKEYBOARD)
{
ProcessKeyboard(raw);
}
else if (raw->header.dwType == RIM_TYPEMOUSE)
{
ProcessMouse(raw);
}
}
LRESULT Process(HWND hWnd, WPARAM wParam, LPARAM lParam) {
UINT dwSize;
GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));
if (!rawInputBuffer) {
rawInputBuffer = malloc(dwSize);
rawInputBufferSize = dwSize;
}
if (dwSize > rawInputBufferSize) {
rawInputBuffer = realloc(rawInputBuffer, dwSize);
}
GetRawInputData((HRAWINPUT)lParam, RID_INPUT, rawInputBuffer, &dwSize, sizeof(RAWINPUTHEADER));
RAWINPUT *raw = (RAWINPUT *)rawInputBuffer;
bool foreground = GET_RAWINPUT_CODE_WPARAM(wParam) == RIM_INPUT;
switch (raw->header.dwType) {
case RIM_TYPEKEYBOARD:
ProcessKeyboard(raw, foreground);
break;
case RIM_TYPEMOUSE:
ProcessMouse(raw, foreground);
break;
case RIM_TYPEHID:
ProcessHID(raw, foreground);
break;
}
// Docs say to call DefWindowProc to perform necessary cleanup.
return DefWindowProc(hWnd, WM_INPUT, wParam, lParam);
}
int WINAPI WinMain( HINSTANCE hInstance, // Instance
HINSTANCE hPrevInstance, // Previous Instance
LPSTR lpCmdLine, // Command Line Parameters
int nCmdShow) // Window Show State
{
MSG msg; // Windows Message Structure
BOOL done=FALSE; // Bool Variable To Exit Loop
// Ask The User Which Screen Mode They Prefer
if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
{
fullscreen=FALSE; // Windowed Mode
}
// Create Our OpenGL Window
if (!CreateGLWindow("Banu Octavian & NeHe's Stencil & Reflection Tutorial", 640, 480, 32, fullscreen))
{
return 0; // Quit If Window Was Not Created
}
while(!done) // Loop That Runs While done=FALSE
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
{
if (msg.message==WM_QUIT) // Have We Received A Quit Message?
{
done=TRUE; // If So done=TRUE
}
else // If Not, Deal With Window Messages
{
TranslateMessage(&msg); // Translate The Message
DispatchMessage(&msg); // Dispatch The Message
}
}
else // If There Are No Messages
{
// Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene()
if (active) // Program Active?
{
if (keys[VK_ESCAPE]) // Was Escape Pressed?
{
done=TRUE; // ESC Signalled A Quit
}
else // Not Time To Quit, Update Screen
{
DrawGLScene(); // Draw The Scene
SwapBuffers(hDC); // Swap Buffers (Double Buffering)
ProcessKeyboard(); // Processed Keyboard Presses
}
}
}
}
// Shutdown
KillGLWindow(); // Kill The Window
return (msg.wParam); // Exit The Program
}
void EditorBodyControl::Input(DAVA::UIEvent *event)
{
bool inputDone = LandscapeEditorInput(event);
if(!inputDone)
{
inputDone = RulerToolInput(event);
}
if(!inputDone)
{
ProcessKeyboard(event);
ProcessMouse(event);
}
UIControl::Input(event);
}
void scene::MainLoop()
{
current_time = (GetTickCount() - startup_time);
ProcessKeyboard();
if(TERMINATE_IICHAN)
{
delete iichan;
iichan = NULL;
}
if(iichan)
iichan->Move();
if(gui)
gui->Process();
CountFPS();
}
void ApplicationClass::Run (void)
{
//Run the main loop until the exit message is sent
MSG msg = {0};
while( WM_QUIT != msg.message )
{
if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
else
{
ProcessKeyboard();
ProcessMouse();
ProcessJoystick();
Update();
Display();
}
Idle();
}
}
int _tmain(int argc, _TCHAR* argv[])
{
npc1.m_x = 0;
npc1.m_y = 0;
npc1.m_width = 5;
npc1.m_height = 4;
npc2.m_x = 8;
npc2.m_y = 7;
npc2.m_width = 1;
npc2.m_height = 1;
npc3.m_x = 0;
npc3.m_y = 0;
npc3.m_width = 2;
npc3.m_height = 2;
myrect.m_x = 5;
myrect.m_y = 5;
myrect.m_width = 3;
myrect.m_height = 3;
while (true)
{
ProcessKeyboard();
ProcessData();
Draw();
Sleep(100);
}
return 0;
}
// Проверка наличия событий нажатия/отжатия клавиш. В случае обнаружения
// таких событий скан-коды клавиш передаются обработчику ProcessKeyboard
// Необработанные эвенты передаются функции HandleEvent
void CheckKeys()
{
unsigned char cScanCode;
SDL_Event event;
while(SDL_PollEvent(&event))
{
if (event.type==SDL_KEYDOWN || event.type==SDL_KEYUP)
{
cScanCode=event.key.keysym.scancode;
#ifdef linux
// в новой версии SDL бит 7 установлен?
cScanCode-=0x80;
#endif
ProcessKeyboard(event.type==SDL_KEYDOWN?cScanCode&0x7f:cScanCode|0x80);
}
/* else if (event.type==SDL_ACTIVEEVENT)
{
if (bFullScreen && event.active.state==SDL_APPACTIVE &&
event.active.gain==1)
SetPalette();
}*/
HandleEvent(&event);
}
}
int WINAPI WinMain( HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow )
{
WNDCLASSEX winClass;
MSG uMsg;
memset(&uMsg,0,sizeof(uMsg));
winClass.lpszClassName = "MY_WINDOWS_CLASS";
winClass.cbSize = sizeof(WNDCLASSEX);
winClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
winClass.lpfnWndProc = WindowProc;
winClass.hInstance = hInstance;
winClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
winClass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
winClass.hCursor = LoadCursor(NULL, IDC_ARROW);
winClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
winClass.lpszMenuName = NULL;
winClass.cbClsExtra = 0;
winClass.cbWndExtra = 0;
if( !RegisterClassEx(&winClass) )
return E_FAIL;
hWnd = CreateWindowEx( 0,
"MY_WINDOWS_CLASS",
"D1_C3",
WS_OVERLAPPEDWINDOW,
0,
0,
(DWORD)viewWidth,
(DWORD)viewHeight,
0,
0,
hInstance,
0 );//<<<----fullscreen //---WS_OVERLAPPEDWINDOW,//---WS_POPUP,
if( hWnd == NULL )
return E_FAIL;
ShowWindow( hWnd, nCmdShow );
UpdateWindow( hWnd );
InitGL();
while( uMsg.message != WM_QUIT )
{
if( PeekMessage( &uMsg, NULL, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &uMsg );
DispatchMessage( &uMsg );
}
if(keys[VK_ESCAPE])
{
break;
}
else
{
ProcessKeyboard();
RenderGL();
}
}
shutDownGL();
UnregisterClass( "MY_WINDOWS_CLASS", hInstance );
return uMsg.wParam;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
#if defined _DEBUG
_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
#endif
MSG msg = {0};
WNDCLASSEX wcl = {0};
wcl.cbSize = sizeof(wcl);
wcl.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
wcl.lpfnWndProc = WindowProc;
wcl.cbClsExtra = 0;
wcl.cbWndExtra = 0;
wcl.hInstance = g_hInstance = hInstance;
wcl.hIcon = LoadIcon(0, IDI_APPLICATION);
wcl.hCursor = LoadCursor(0, IDC_ARROW);
wcl.hbrBackground = 0;
wcl.lpszMenuName = 0;
wcl.lpszClassName = "GLWindowClass";
wcl.hIconSm = 0;
if (!RegisterClassEx(&wcl))
return 0;
g_hWnd = CreateAppWindow(wcl, 0);
if (g_hWnd)
{
InitGL();
ToggleFullScreen();
glDisable(GL_MULTISAMPLE_ARB);
ShowWindow(g_hWnd, nShowCmd);
UpdateWindow(g_hWnd);
while (true)
{
while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (msg.message == WM_QUIT)
break;
if (keys[VK_ESCAPE])
{
msg.message = WM_QUIT ;
}
if (g_hasFocus)
{
RenderGL();
SwapBuffers(g_hDC);
ProcessKeyboard();
}
else
{
WaitMessage();
}
}
Cleanup();
UnregisterClass(wcl.lpszClassName, hInstance);
}
return static_cast<int>(msg.wParam);
}
