API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 25th, 2019
76
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 22.56 KB | None | 0 0
raw download clone embed print report
  1. /****************************************************
  2.     Virtual Collaborative Teams - The base program
  3.         The main module
  4. ****************************************************/
  5.  
  6. bool if_prediction_test = false;
  7. bool if_delays = false;
  8. bool if_shadow = true;
  9. // Scenariusz testu predykcji - tzw. benchmark - dzięki temu można porównać różne algorytmy predykcji na tym samym scenariuszu:
  10. // {czas [s], siła [N], prędkość skręcania kół [rad/s], stopień hamowania} -> przez jaki czas obiekt ma sie poruszać z podaną prędkością i kątem skrętu kół
  11. float test_scenario[][4] = { { 9.5, 100, 0, 0 }, { 5, 20, -0.25 / 8, 0 }, { 0.5, 0, 0, 1.0 }, { 5, 60, 0.25 / 8, 0 }, { 15, 100, 0, 0 } };
  12. //float test_scenario[][4] = { { 9.5, 500, 0, 0 }, { 10, -200, -0.25 / 2, 0 } };  // scenariusz ekstremalny
  13.  
  14.  
  15. #include <windows.h>
  16. #include <math.h>
  17. #include <time.h>
  18. #include <gl\gl.h>
  19. #include <gl\glu.h>
  20. #include <iterator>
  21. #include <map>
  22.  
  23. #include "objects.h"
  24. #include "graphics.h"
  25. #include "net.h"
  26. using namespace std;
  27.  
  28. FILE *f = fopen("wzr_log.txt", "a"); // plik do zapisu informacji testowych
  29.  
  30.  
  31. MovableObject *my_vehicle;               // obiekt przypisany do tej aplikacji
  32. Terrain terrain;
  33.  
  34.  
  35. map<int, MovableObject*> other_vehicles;
  36.  
  37. float avg_cycle_time;                // sredni czas pomiedzy dwoma kolejnymi cyklami symulacji i wyswietlania
  38. long time_of_cycle, number_of_cyc=0;   // zmienne pomocnicze potrzebne do obliczania avg_cycle_time
  39. long time_start = clock();           // moment uruchomienia aplikacji
  40. long time_last_send = 0;             // moment wysłania ostatniej ramki  
  41.  
  42. multicast_net *multi_reciv;          // wsk do obiektu zajmujacego sie odbiorem komunikatow
  43. multicast_net *multi_send;           //   -||-  wysylaniem komunikatow
  44.  
  45. HANDLE threadReciv;                  // uchwyt wątku odbioru komunikatów
  46. HWND window_handle;                    // uchwyt do głównego okna programu
  47. CRITICAL_SECTION m_cs;               // do synchronizacji wątków
  48.  
  49. bool if_SHIFT_pressed = false;
  50. bool if_ID_visible = true;           // czy rysowac nr ID przy każdym obiekcie
  51. bool if_mouse_control = false;       // sterowanie za pomocą klawisza myszki
  52. int mouse_cursor_x = 0, mouse_cursor_y = 0;     // położenie kursora myszy
  53.  
  54. extern ViewParams view_parameters;           // ustawienia widoku zdefiniowane w grafice
  55.  
  56. long time_of_day = 1000;         // czas trwania dnia w [s]
  57.  
  58. // zmienne związane z nawigacją obliczeniową:
  59. long number_of_send_trials = 0;        // liczba prób wysylania ramki ze stanem  
  60. float sum_differences_of_pos = 0;             // sumaryczna odległość pomiędzy położeniem rzeczywistym (symulowanym) a ekstrapolowanym
  61. float sum_of_angle_differences = 0;             // sumaryczna różnica kątowa -||-
  62.  
  63.  
  64. struct Frame                                      // główna struktura służąca do przesyłania informacji
  65. {  
  66.     int iID;                                      // identyfikator obiektu, którego
  67.     int type;                                     // typ ramki: informacja o stateie, informacja o zamknięciu, komunikat tekstowy, ...
  68.     ObjectState state;                            // położenie, prędkość: środka masy + kątowe, ...
  69.  
  70.     long sending_time;                            // tzw. znacznik czasu potrzebny np. do obliczenia opóźnienia
  71.     int iID_receiver;                             // nr ID odbiorcy wiadomości, jeśli skierowana jest tylko do niego
  72. };
  73.  
  74.  
  75. //******************************************
  76. // Funkcja obsługi wątku odbioru komunikatów
  77. // UWAGA!  Odbierane są też komunikaty z własnej aplikacji by porównać obraz ekstrapolowany do rzeczywistego.
  78. DWORD WINAPI ReceiveThreadFun(void *ptr)
  79. {
  80.     multicast_net *pmt_net = (multicast_net*)ptr;  // wskaźnik do obiektu klasy multicast_net
  81.     Frame frame;
  82.  
  83.     while (1)
  84.     {
  85.         int frame_size = pmt_net->reciv((char*)&frame, sizeof(Frame));   // oczekiwanie na nadejście ramki
  86.         ObjectState state = frame.state;
  87.  
  88.         //fprintf(f, "odebrano stan iID = %d, ID dla mojego obiektu = %d\n", frame.iID, my_vehicle->iID);
  89.  
  90.         // Lock the Critical section
  91.         EnterCriticalSection(&m_cs);               // wejście na ścieżkę krytyczną - by inne wątki (np. główny) nie współdzielił
  92.                                                                                                  // tablicy other_vehicles
  93.  
  94.         if ((if_shadow) || (frame.iID != my_vehicle->iID))          // jeśli to nie mój własny obiekt
  95.         {
  96.            
  97.             if ((other_vehicles.size() == 0) || (other_vehicles[frame.iID] == NULL))        // nie ma jeszcze takiego obiektu w tablicy -> trzeba go
  98.                 // stworzyć
  99.             {
  100.                 MovableObject *ob = new MovableObject();
  101.                 ob->iID = frame.iID;
  102.                 other_vehicles[frame.iID] = ob;    
  103.                 //fprintf(f, "zarejestrowano %d obcy obiekt o ID = %d\n", iLiczbaCudzychOb - 1, CudzeObiekty[iLiczbaCudzychOb]->iID);
  104.             }
  105.             other_vehicles[frame.iID]->ChangeState(state);   // aktualizacja stateu obiektu obcego  
  106.            
  107.         }  
  108.         //Release the Critical section
  109.         LeaveCriticalSection(&m_cs);               // wyjście ze ścieżki krytycznej
  110.     }  // while(1)
  111.     return 1;
  112. }
  113.  
  114. // *****************************************************************
  115. // ****    Wszystko co trzeba zrobić podczas uruchamiania aplikacji
  116. // ****    poza grafiką  
  117. void InteractionInitialization()
  118. {
  119.     DWORD dwThreadId;
  120.  
  121.     my_vehicle = new MovableObject();    // tworzenie wlasnego obiektu
  122.  
  123.     time_of_cycle = clock();             // pomiar aktualnego czasu
  124.  
  125.     // obiekty sieciowe typu multicast (z podaniem adresu WZR oraz numeru portu)
  126.     multi_reciv = new multicast_net("224.12.13.178", 10001);      // obiekt do odbioru ramek sieciowych
  127.     multi_send = new multicast_net("224.12.13.178", 10001);       // obiekt do wysyłania ramek
  128.  
  129.  
  130.     // uruchomienie wątku obsługującego odbiór komunikatów:
  131.     threadReciv = CreateThread(
  132.         NULL,                        // no security attributes
  133.         0,                           // use default stack size
  134.         ReceiveThreadFun,                // thread function
  135.         (void *)multi_reciv,               // argument to thread function
  136.         NULL,                        // use default creation flags
  137.         &dwThreadId);                // returns the thread identifier
  138.     SetThreadPriority(threadReciv, THREAD_PRIORITY_HIGHEST);
  139.  
  140.  
  141.  
  142.     fprintf(f,"poczatek interakcji\n");
  143. }
  144.  
  145.  
  146. // *****************************************************************
  147. // ****    Wszystko co trzeba zrobić w każdym cyklu działania
  148. // ****    aplikacji poza grafiką
  149. void VirtualWorldCycle()
  150. {
  151.     number_of_cyc++;
  152.     float time_from_start_in_s = (float)(clock() - time_start) / CLOCKS_PER_SEC;  // czas w sek. jaki upłynął od uruchomienia programu
  153.  
  154.     if (number_of_cyc % 50 == 0)          // jeśli licznik cykli przekroczył pewną wartość, to
  155.     {                              // należy na nowo obliczyć średni czas cyklu avg_cycle_time
  156.         char text[256];
  157.         long prev_time = time_of_cycle;
  158.         time_of_cycle = clock();
  159.         float fFps = (50 * CLOCKS_PER_SEC) / (float)(time_of_cycle - prev_time);
  160.         if (fFps != 0) avg_cycle_time = 1.0 / fFps; else avg_cycle_time = 1;
  161.    
  162.         sprintf(text, "WZR 2019, tem.2, wer.f, częstość pr.wys. = %0.2f[r/s]  śr.odl = %0.3f[m]  śr.rożn.kąt. = %0.3f[st]",
  163.             (float)number_of_send_trials / time_from_start_in_s, sum_differences_of_pos / number_of_cyc,
  164.             sum_of_angle_differences / number_of_cyc*180.0 / 3.14159);
  165.         //sprintf(text, "WWC-lab 2018/19 temat 2, wersja a (%0.0f fps  %0.2fms) ", fFps, 1000.0 / fFps);
  166.         if (time_from_start_in_s > 5)
  167.             SetWindowText(window_handle, text); // wyświetlenie aktualnych odchyłek                      
  168.     }
  169.  
  170.     // obliczenie średniej odległości i średniej różnicy kątowej pomiędzy pojazdem a cieniem:
  171.     EnterCriticalSection(&m_cs);
  172.     MovableObject *car = (other_vehicles.size() > 0 ? other_vehicles[my_vehicle->iID] : NULL);      
  173.     if (car != NULL)
  174.     {
  175.         sum_differences_of_pos += DistanceBetweenPointsOnTetraMap(my_vehicle->state.vPos, car->state.vPos);
  176.         sum_of_angle_differences += AngleBetweenQuats(my_vehicle->state.qOrient, car->state.qOrient);
  177.     }
  178.     else {
  179.         sum_differences_of_pos += DistanceBetweenPointsOnTetraMap(my_vehicle->state.vPos, Vector3(0,0,0));  
  180.         sum_of_angle_differences += AngleBetweenQuats(my_vehicle->state.qOrient, quaternion(0, 0, 0, 1));
  181.     }
  182.     LeaveCriticalSection(&m_cs);
  183.    
  184.     // test predykcji:
  185.     if (if_prediction_test)
  186.     {
  187.         int number_of_actions = sizeof(test_scenario) / (4 * sizeof(float));
  188.         bool test_finished = test_scenario_step(my_vehicle, test_scenario, number_of_actions, time_from_start_in_s);
  189.  
  190.         if (test_finished) // czas dobiegl konca -> koniec testu
  191.         {
  192.             if_prediction_test = false;
  193.             char text[200];
  194.             sprintf(text, "Po czasie %3.2f[s]  śr.częstość = %0.2f[r/s]  śr.odl = %0.3f[m]  śr.różn.kąt. = %0.3f[st]",
  195.                 time_from_start_in_s, (float)number_of_send_trials / time_from_start_in_s,
  196.                 sum_differences_of_pos / number_of_cyc, sum_of_angle_differences / number_of_cyc*180.0 / 3.14159);
  197.             fprintf(f, "%s\n", text);
  198.             MessageBox(window_handle, text, "Test predykcji", MB_OK);
  199.         }
  200.     }
  201.  
  202.     auto stan_tmp = my_vehicle->State();
  203.  
  204.     my_vehicle->Simulation(avg_cycle_time);                    // symulacja własnego obiektu
  205.  
  206.     time_from_start_in_s = (float)(clock() - time_start) / CLOCKS_PER_SEC;
  207.    
  208.    
  209.     bool ifSendFrame = false;
  210.  
  211.  
  212.     ifSendFrame = (stan_tmp.wheel_angle < my_vehicle->State().wheel_angle * 0.9 || stan_tmp.wheel_angle > my_vehicle->State().wheel_angle * 1.1) ? true : false;
  213.  
  214.  
  215.     if (ifSendFrame || (float)(clock() - time_last_send) / CLOCKS_PER_SEC >= 1.0)
  216.     {
  217.         Frame frame;
  218.         frame.state = my_vehicle->State();                   // stan własnego obiektu
  219.         frame.iID = my_vehicle->iID;
  220.        
  221.  
  222.         multi_send->send((char*)&frame, sizeof(Frame));  // wysłanie komunikatu do pozostałych aplikacji co pewien czas
  223.         time_last_send = clock();
  224.         number_of_send_trials++;
  225.     }
  226.  
  227.     //       ----------------------------------
  228.     //    -------------------------------------
  229.     // ----------------------------------------
  230.     // ------------  Miejsce na predykcję stanu:
  231.     // Lock the Critical section
  232.     EnterCriticalSection(&m_cs);
  233.     for (map<int, MovableObject*>::iterator it = other_vehicles.begin(); it != other_vehicles.end(); ++it)
  234.     {
  235.         MovableObject *veh = it->second;
  236.  
  237.                     // sredni czas pomiedzy dwoma kolejnymi cyklami symulacji i wyswietlania
  238.         auto time = avg_cycle_time;
  239.         veh->state.vPos += veh->state.vV * avg_cycle_time;
  240.         veh->state.vV += veh->state.vA * avg_cycle_time;
  241.         //veh->state.qOrient = ....
  242.  
  243.         Vector3 obrot = veh->state.vV_ang * avg_cycle_time;
  244.  
  245.         quaternion qobrot = AsixToQuat(obrot.znorm(), obrot.length());
  246.  
  247.         veh->state.qOrient = qobrot * veh->state.qOrient ;
  248.        
  249.        
  250.         //veh->state.vV_ang = qobrot.AsixAngle();
  251.    
  252.     }
  253.     //Release the Critical section
  254.     LeaveCriticalSection(&m_cs);
  255. }
  256.  
  257. // *****************************************************************
  258. // ****    Wszystko co trzeba zrobić podczas zamykania aplikacji
  259. // ****    poza grafiką
  260. void EndOfInteraction()
  261. {
  262.     fprintf(f, "Koniec interakcji\n");
  263.     fclose(f);
  264. }
  265.  
  266. //deklaracja funkcji obslugi okna
  267. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  268.  
  269. HDC g_context = NULL;        // uchwyt contextu graficznego
  270.  
  271.  
  272.  
  273. //funkcja Main - dla Windows
  274. int WINAPI WinMain(HINSTANCE hInstance,
  275.     HINSTANCE hPrevInstance,
  276.     LPSTR     lpCmdLine,
  277.     int       nCmdShow)
  278. {
  279.    
  280.     //Initilize the critical section
  281.     InitializeCriticalSection(&m_cs);
  282.  
  283.     MSG message;          //innymi slowy "komunikat"
  284.     WNDCLASS main_class; //klasa głównego okna aplikacji
  285.  
  286.     static char class_name[] = "Klasa_Podstawowa";
  287.  
  288.     //Definiujemy klase głównego okna aplikacji
  289.     //Okreslamy tu wlasciwosci okna, szczegoly wygladu oraz
  290.     //adres funkcji przetwarzajacej komunikaty
  291.     main_class.style = CS_HREDRAW | CS_VREDRAW;
  292.     main_class.lpfnWndProc = WndProc; //adres funkcji realizującej przetwarzanie meldunków
  293.     main_class.cbClsExtra = 0;
  294.     main_class.cbWndExtra = 0;
  295.     main_class.hInstance = hInstance; //identyfikator procesu przekazany przez MS Windows podczas uruchamiania programu
  296.     main_class.hIcon = 0;
  297.     main_class.hCursor = LoadCursor(0, IDC_ARROW);
  298.     main_class.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
  299.     main_class.lpszMenuName = "Menu";
  300.     main_class.lpszClassName = class_name;
  301.  
  302.     //teraz rejestracja klasy okna głównego
  303.     RegisterClass(&main_class);
  304.  
  305.     window_handle = CreateWindow(class_name, "WZR-lab 2018/19 temat 2 - Nawigacja obliczeniowa, wersja f", WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
  306.         500, 50, 750, 650, NULL, NULL, hInstance, NULL);
  307.  
  308.     ShowWindow(window_handle, nCmdShow);
  309.  
  310.     //odswiezamy zawartosc okna
  311.     UpdateWindow(window_handle);
  312.  
  313.     // pobranie komunikatu z kolejki jeśli funkcja PeekMessage zwraca wartość inną niż FALSE,
  314.     // w przeciwnym wypadku symulacja wirtualnego świata wraz z wizualizacją
  315.     ZeroMemory(&message, sizeof(message));
  316.     while (message.message != WM_QUIT)
  317.     {
  318.         if (PeekMessage(&message, NULL, 0U, 0U, PM_REMOVE))
  319.         {
  320.             TranslateMessage(&message);
  321.             DispatchMessage(&message);
  322.         }
  323.         else
  324.         {
  325.             VirtualWorldCycle();    // Cykl wirtualnego świata
  326.             InvalidateRect(window_handle, NULL, FALSE);
  327.         }
  328.     }
  329.  
  330.     return (int)message.wParam;
  331. }
  332.  
  333. /********************************************************************
  334. FUNKCJA OKNA realizujaca przetwarzanie meldunków kierowanych do okna aplikacji*/
  335. LRESULT CALLBACK WndProc(HWND window_handle, UINT message_code, WPARAM wParam, LPARAM lParam)
  336. {
  337.  
  338.     switch (message_code)
  339.     {
  340.     case WM_CREATE:  //message wysyłany w momencie tworzenia okna
  341.     {
  342.  
  343.         g_context = GetDC(window_handle);
  344.  
  345.         srand((unsigned)time(NULL));
  346.         int result = GraphicsInitialization(g_context);
  347.         if (result == 0)
  348.         {
  349.             printf("nie udalo sie otworzyc okna graficznego\n");
  350.             //exit(1);
  351.         }
  352.  
  353.         InteractionInitialization();
  354.  
  355.         SetTimer(window_handle, 1, 10, NULL);
  356.  
  357.         time_start = clock();      // by czas liczyć po utworzeniu okna i inicjalizacji
  358.  
  359.         return 0;
  360.     }
  361.  
  362.  
  363.     case WM_PAINT:
  364.     {
  365.         PAINTSTRUCT paint;
  366.         HDC context;
  367.         context = BeginPaint(window_handle, &paint);
  368.  
  369.         DrawScene();
  370.         SwapBuffers(context);
  371.  
  372.         EndPaint(window_handle, &paint);
  373.  
  374.         return 0;
  375.     }
  376.  
  377.     case WM_TIMER:
  378.  
  379.         return 0;
  380.  
  381.     case WM_SIZE:
  382.     {
  383.         int cx = LOWORD(lParam);
  384.         int cy = HIWORD(lParam);
  385.  
  386.         WindowResize(cx, cy);
  387.  
  388.         return 0;
  389.     }
  390.  
  391.     case WM_DESTROY: //obowiązkowa obsługa meldunku o zamknięciu okna
  392.  
  393.         EndOfInteraction();
  394.         EndOfGraphics();
  395.  
  396.         ReleaseDC(window_handle, g_context);
  397.         KillTimer(window_handle, 1);
  398.  
  399.         //LPDWORD lpExitCode;
  400.         DWORD ExitCode;
  401.         GetExitCodeThread(threadReciv, &ExitCode);
  402.         TerminateThread(threadReciv,ExitCode);
  403.         //ExitThread(ExitCode);
  404.  
  405.         //Sleep(1000);
  406.  
  407.         other_vehicles.clear();
  408.        
  409.  
  410.         PostQuitMessage(0);
  411.         return 0;
  412.  
  413.     case WM_LBUTTONDOWN: //reakcja na lewy przycisk myszki
  414.     {
  415.         int x = LOWORD(lParam);
  416.         int y = HIWORD(lParam);
  417.         if (if_mouse_control)
  418.             my_vehicle->F = 30.0;        // siła pchająca do przodu
  419.         break;
  420.     }
  421.     case WM_RBUTTONDOWN: //reakcja na prawy przycisk myszki
  422.     {
  423.         int x = LOWORD(lParam);
  424.         int y = HIWORD(lParam);
  425.         if (if_mouse_control)
  426.             my_vehicle->F = -5.0;        // siła pchająca do tylu
  427.         break;
  428.     }
  429.     case WM_MBUTTONDOWN: //reakcja na środkowy przycisk myszki : uaktywnienie/dezaktywacja sterwania myszkowego
  430.     {
  431.         if_mouse_control = 1 - if_mouse_control;
  432.         if (if_mouse_control) my_vehicle->if_keep_steer_wheel = true;
  433.         else my_vehicle->if_keep_steer_wheel = false;
  434.  
  435.         mouse_cursor_x = LOWORD(lParam);
  436.         mouse_cursor_y = HIWORD(lParam);
  437.         break;
  438.     }
  439.     case WM_LBUTTONUP: //reakcja na puszczenie lewego przycisku myszki
  440.     {
  441.         if (if_mouse_control)
  442.             my_vehicle->F = 0.0;        // siła pchająca do przodu
  443.         break;
  444.     }
  445.     case WM_RBUTTONUP: //reakcja na puszczenie lewy przycisk myszki
  446.     {
  447.         if (if_mouse_control)
  448.             my_vehicle->F = 0.0;        // siła pchająca do przodu
  449.         break;
  450.     }
  451.     case WM_MOUSEMOVE:
  452.     {
  453.         int x = LOWORD(lParam);
  454.         int y = HIWORD(lParam);
  455.         if (if_mouse_control)
  456.         {
  457.             float wheel_angle = (float)(mouse_cursor_x - x) / 200;
  458.             if (wheel_angle > my_vehicle->wheel_angle_max) wheel_angle = my_vehicle->wheel_angle_max;
  459.             if (wheel_angle < -my_vehicle->wheel_angle_max) wheel_angle = -my_vehicle->wheel_angle_max;
  460.             my_vehicle->state.wheel_angle = wheel_angle;
  461.             //my_vehicle->steer_wheel_speed = (float)(mouse_cursor_x - x) / 20;
  462.         }
  463.         break;
  464.     }
  465.     case WM_KEYDOWN:
  466.     {
  467.  
  468.         switch (LOWORD(wParam))
  469.         {
  470.         case VK_SHIFT:
  471.         {
  472.             if_SHIFT_pressed = 1;
  473.             break;
  474.         }
  475.         case VK_SPACE:
  476.         {
  477.             my_vehicle->breaking_factor = 1.0;       // stopień hamowania (reszta zależy od siły docisku i wsp. tarcia)
  478.             break;                       // 1.0 to maksymalny stopień (np. zablokowanie kół)
  479.         }
  480.         case VK_UP:
  481.         {
  482.             my_vehicle->F = 100.0;        // siła pchająca do przodu
  483.             break;
  484.         }
  485.         case VK_DOWN:
  486.         {
  487.             my_vehicle->F = -70.0;
  488.             break;
  489.         }
  490.         case VK_LEFT:
  491.         {
  492.             if (my_vehicle->steer_wheel_speed < 0){
  493.                 my_vehicle->steer_wheel_speed = 0;
  494.                 my_vehicle->if_keep_steer_wheel = true;
  495.             }
  496.             else{
  497.                 if (if_SHIFT_pressed) my_vehicle->steer_wheel_speed = 0.5;
  498.                 else my_vehicle->steer_wheel_speed = 0.25 / 8;
  499.             }
  500.  
  501.             break;
  502.         }
  503.         case VK_RIGHT:
  504.         {
  505.             if (my_vehicle->steer_wheel_speed > 0){
  506.                 my_vehicle->steer_wheel_speed = 0;
  507.                 my_vehicle->if_keep_steer_wheel = true;
  508.             }
  509.             else{
  510.                 if (if_SHIFT_pressed) my_vehicle->steer_wheel_speed = -0.5;
  511.                 else my_vehicle->steer_wheel_speed = -0.25 / 8;
  512.             }
  513.             break;
  514.         }
  515.         case 'I':   // wypisywanie nr ID
  516.         {
  517.             if_ID_visible = 1 - if_ID_visible;
  518.             break;
  519.         }
  520.         case 'W':   // cam_distance widoku
  521.         {
  522.             //cam_pos = cam_pos - cam_direct*0.3;
  523.             if (view_parameters.cam_distance > 0.5) view_parameters.cam_distance /= 1.2;
  524.             else view_parameters.cam_distance = 0;
  525.             break;
  526.         }
  527.         case 'S':   // przybliżenie widoku
  528.         {
  529.             //cam_pos = cam_pos + cam_direct*0.3;
  530.             if (view_parameters.cam_distance > 0) view_parameters.cam_distance *= 1.2;
  531.             else view_parameters.cam_distance = 0.5;
  532.             break;
  533.         }
  534.         case 'Q':   // widok z góry
  535.         {
  536.             if (view_parameters.tracking) break;
  537.             view_parameters.top_view = 1 - view_parameters.top_view;
  538.             if (view_parameters.top_view)
  539.             {
  540.                 view_parameters.cam_pos_1 = view_parameters.cam_pos; view_parameters.cam_direct_1 = view_parameters.cam_direct; view_parameters.cam_vertical_1 = view_parameters.cam_vertical;
  541.                 view_parameters.cam_distance_1 = view_parameters.cam_distance; view_parameters.cam_angle_1 = view_parameters.cam_angle;
  542.                 view_parameters.cam_pos = view_parameters.cam_pos_2; view_parameters.cam_direct = view_parameters.cam_direct_2; view_parameters.cam_vertical = view_parameters.cam_vertical_2;
  543.                 view_parameters.cam_distance = view_parameters.cam_distance_2; view_parameters.cam_angle = view_parameters.cam_angle_2;
  544.             }
  545.             else
  546.             {
  547.                 view_parameters.cam_pos_2 = view_parameters.cam_pos; view_parameters.cam_direct_2 = view_parameters.cam_direct; view_parameters.cam_vertical_2 = view_parameters.cam_vertical;
  548.                 view_parameters.cam_distance_2 = view_parameters.cam_distance; view_parameters.cam_angle_2 = view_parameters.cam_angle;
  549.                 view_parameters.cam_pos = view_parameters.cam_pos_1; view_parameters.cam_direct = view_parameters.cam_direct_1; view_parameters.cam_vertical = view_parameters.cam_vertical_1;
  550.                 view_parameters.cam_distance = view_parameters.cam_distance_1; view_parameters.cam_angle = view_parameters.cam_angle_1;
  551.             }
  552.             break;
  553.         }
  554.         case 'E':   // obrót kamery ku górze (względem lokalnej osi z)
  555.         {
  556.             view_parameters.cam_angle += PI * 5 / 180;
  557.             break;
  558.         }
  559.         case 'D':   // obrót kamery ku dołowi (względem lokalnej osi z)
  560.         {
  561.             view_parameters.cam_angle -= PI * 5 / 180;
  562.             break;
  563.         }
  564.         case 'A':   // włączanie, wyłączanie trybu śledzenia obiektu
  565.         {
  566.             view_parameters.tracking = 1 - view_parameters.tracking;
  567.             if (view_parameters.tracking)
  568.             {
  569.                 view_parameters.cam_distance = view_parameters.cam_distance_3; view_parameters.cam_angle = view_parameters.cam_angle_3;
  570.             }
  571.             else
  572.             {
  573.                 view_parameters.cam_distance_3 = view_parameters.cam_distance; view_parameters.cam_angle_3 = view_parameters.cam_angle;
  574.                 view_parameters.top_view = 0;
  575.                 view_parameters.cam_pos = view_parameters.cam_pos_1; view_parameters.cam_direct = view_parameters.cam_direct_1; view_parameters.cam_vertical = view_parameters.cam_vertical_1;
  576.                 view_parameters.cam_distance = view_parameters.cam_distance_1; view_parameters.cam_angle = view_parameters.cam_angle_1;
  577.             }
  578.             break;
  579.         }
  580.         case 'Z':   // zoom - zmniejszenie kąta widzenia
  581.         {
  582.             view_parameters.zoom /= 1.1;
  583.             RECT rc;
  584.             GetClientRect(window_handle, &rc);
  585.             WindowResize(rc.right - rc.left, rc.bottom - rc.top);
  586.             break;
  587.         }
  588.         case 'X':   // zoom - zwiększenie kąta widzenia
  589.         {
  590.             view_parameters.zoom *= 1.1;
  591.             RECT rc;
  592.             GetClientRect(window_handle, &rc);
  593.             WindowResize(rc.right - rc.left, rc.bottom - rc.top);
  594.             break;
  595.         }
  596.         case VK_F1:  // wywolanie systemu pomocy
  597.         {
  598.             char lan[1024], lan_bie[1024];
  599.             //GetSystemDirectory(lan_sys,1024);
  600.             GetCurrentDirectory(1024, lan_bie);
  601.             strcpy(lan, "C:\\Program Files\\Internet Explorer\\iexplore ");
  602.             strcat(lan, lan_bie);
  603.             strcat(lan, "\\pomoc.htm");
  604.             int wyni = WinExec(lan, SW_NORMAL);
  605.             if (wyni < 32)  // proba uruchominia pomocy nie powiodla sie
  606.             {
  607.                 strcpy(lan, "C:\\Program Files\\Mozilla Firefox\\firefox ");
  608.                 strcat(lan, lan_bie);
  609.                 strcat(lan, "\\pomoc.htm");
  610.                 wyni = WinExec(lan, SW_NORMAL);
  611.                 if (wyni < 32)
  612.                 {
  613.                     char lan_win[1024];
  614.                     GetWindowsDirectory(lan_win, 1024);
  615.                     strcat(lan_win, "\\notepad pomoc.txt ");
  616.                     wyni = WinExec(lan_win, SW_NORMAL);
  617.                 }
  618.             }
  619.             break;
  620.         }
  621.         case VK_ESCAPE:
  622.         {
  623.             SendMessage(window_handle, WM_DESTROY, 0, 0);
  624.             break;
  625.         }
  626.         } // switch po klawiszach
  627.  
  628.         break;
  629.     }
  630.     case WM_KEYUP:
  631.     {
  632.         switch (LOWORD(wParam))
  633.         {
  634.         case VK_SHIFT:
  635.         {
  636.             if_SHIFT_pressed = 0;
  637.             break;
  638.         }
  639.         case VK_SPACE:
  640.         {
  641.             my_vehicle->breaking_factor = 0.0;
  642.             break;
  643.         }
  644.         case VK_UP:
  645.         {
  646.             my_vehicle->F = 0.0;
  647.             break;
  648.         }
  649.         case VK_DOWN:
  650.         {
  651.             my_vehicle->F = 0.0;
  652.             break;
  653.         }
  654.         case VK_LEFT:
  655.         {
  656.             my_vehicle->Fb = 0.00;
  657.             //my_vehicle->state.wheel_angle = 0;
  658.             if (my_vehicle->if_keep_steer_wheel) my_vehicle->steer_wheel_speed = -0.25/8;
  659.             else my_vehicle->steer_wheel_speed = 0;
  660.             my_vehicle->if_keep_steer_wheel = false;
  661.             break;
  662.         }
  663.         case VK_RIGHT:
  664.         {
  665.             my_vehicle->Fb = 0.00;
  666.             //my_vehicle->state.wheel_angle = 0;
  667.             if (my_vehicle->if_keep_steer_wheel) my_vehicle->steer_wheel_speed = 0.25 / 8;
  668.             else my_vehicle->steer_wheel_speed = 0;
  669.             my_vehicle->if_keep_steer_wheel = false;
  670.             break;
  671.         }
  672.  
  673.         }
  674.  
  675.         break;
  676.     }
  677.  
  678.     default: //statedardowa obsługa pozostałych meldunków
  679.         return DefWindowProc(window_handle, message_code, wParam, lParam);
  680.     }
  681.  
  682.  
  683. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!