fixed libscpy for mingw32, changed special cleaning bug
[physics.git] / src / main.cpp
1 /*
2  *  Copyright (C) 2008 Patrik Gornicz, Gornicz_P (at) hotmail (dot) com.
3  *
4  *  This program is free software: you can redistribute it and/or modify
5  *  it under the terms of the GNU General Public License as published by
6  *  the Free Software Foundation, either version 3 of the License, or
7  *  (at your option) any later version.
8  *
9  *  This program is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU General Public License for more details.
13  *
14  *  You should have received a copy of the GNU General Public License
15  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17
18 #include <GL/gl.h>
19 #include <GL/glu.h>
20 #include <SDL/SDL.h>
21
22 #include "debug.h"
23 #include "handleSignal.h"
24
25 #include "game.h"
26 #include "ticks.h"
27
28 #include "graphics/graphics.h"
29 #include "input/inputManager.h"
30 #include "config/config.h"
31
32 /// ***** Private Method Headers *****
33
34 static void mainInit();
35 static void mainClean();
36
37 static void updatesInit();
38 static void updatesClean();
39
40 static void drawInit();
41 static void drawClean();
42
43 static void run();
44
45 static void updateFPSCounters();
46
47 static void handleInput();
48 static void update(float);
49 static void draw();
50
51 static int startUpdateThread(void*);
52 static int startDrawThread(void*);
53
54 /// ***** Private Variables *****
55
56 // variable used to determine if it is time to shutdown
57 static bool s_bIsRunning;
58
59 // Minimum possible wait times by used library
60 static const int s_iMinWaitMilli = 20;
61 static const int s_iMinWaitMicro = s_iMinWaitMilli * 1000;
62
63 /* Values for the main game loop
64  *
65  * s_iTargetUPS     := the amount of updates that is wanted in one second
66  * s_fAccUpdateWait := the accumulated wait time for the update sleeps
67  *
68  * s_iUPS           := updates per second for the last second
69  * s_iFPS           := frames per second for the last second
70  * s_iUpdateCount   := counts this seconds updates
71  * s_iDrawCount     := counts this seconds draws
72  * s_micLastSecond  := stores the time of the last second, used for ups and fps
73  */
74 static int      s_iTargetUPS     = 100;
75 static float    s_fAccUpdateWait = 0;
76
77 static int      s_iTargetFPS     = 100;
78 static float    s_fAccDrawWait   = 0;
79
80 static int s_iUPS, s_iFPS;
81 static int s_iUpdateCount, s_iDrawCount;
82 static MICRO s_micLastSecond;
83
84 static const float s_fGameStep    = 10;
85
86 static bool s_bUpdateInitialized  = false;
87 static bool s_bDrawInitialized    = false;
88
89 /// ***** MAIN Method *****
90 int main(int argc, char** args)
91 {
92     mainInit();
93     run();
94     mainClean();
95
96     return 0;
97 }
98
99 /// ***** Initializers/Cleaners *****
100
101 void mainInit()
102 {
103     installSignal();
104
105     debug::init();
106 }
107 void mainClean()
108 {
109     debug::clean();
110 }
111
112 void updatesInit()
113 {
114     while(!s_bDrawInitialized)
115         SDL_Delay(100);
116
117     game::init();
118     DPF(0, "Game initialized");
119
120     input::init();
121     DPF(0, "Input initialized");
122
123     cfg::init();
124     DPF(0, "Configs initialized");
125
126     DPF(0, "Initialization Complete");
127
128     s_bUpdateInitialized = true;
129 }
130 void updatesClean()
131 {
132     DPF(0, "Update Thread Cleaning");
133
134     cfg::clean();
135
136     input::clean();
137
138     game::clean();
139 }
140
141 void drawInit()
142 {
143     graphics::init();
144     DPF(0, "Graphics initialized");
145
146     s_bDrawInitialized = true;
147
148     while(!s_bUpdateInitialized)
149         SDL_Delay(100);
150 }
151 void drawClean()
152 {
153     DPF(0, "Draw Thread Cleaning");
154
155     graphics::clean();
156 }
157
158 /// ***** Private Methods *****
159
160 void run()
161 {
162     s_bIsRunning = true;
163
164     SDL_Thread* s_pUpdatesThread   = SDL_CreateThread(startUpdateThread,   NULL);
165     SDL_Thread* s_pDrawThread      = SDL_CreateThread(startDrawThread,     NULL);
166
167     SDL_WaitThread(s_pUpdatesThread,   NULL);
168     SDL_WaitThread(s_pDrawThread,      NULL);
169 }
170
171 void updateFPSCounters()
172 {
173     // Check if a second has passed to recalculate UPS and FPS
174     if (tickCountMicro() - s_micLastSecond >= 1000000)
175     {
176         s_iUPS = s_iUpdateCount;
177         s_iFPS = s_iDrawCount;
178
179         // NOT thread safe, but they're estimates anyways
180         s_iUpdateCount -= s_iUPS;
181         s_iDrawCount -= s_iFPS;
182
183         s_micLastSecond = tickCountMicro();
184
185         if(cfg::showFPS())
186         {
187             cout << "fps:\t" << s_iFPS << endl;
188         }
189         if(cfg::showUPS())
190         {
191             cout << "ups:\t" << s_iUPS << endl;
192         }
193     }
194 }
195
196 void handleInput()
197 {
198     input::update();
199
200     cfg::handleInput();
201     game::handleInput();
202
203     if(cfg::endGame())
204         s_bIsRunning = false;
205 }
206
207 void update(float fTimeStep)
208 {
209     game::update(fTimeStep);
210     s_iUpdateCount++;
211 }
212
213 void draw()
214 {
215     game::draw();
216
217     SDL_PumpEvents(); // has to be on the Draw thread for the Windows API
218
219     SDL_GL_SwapBuffers();
220
221     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
222
223     s_iDrawCount++;
224 }
225
226 int startUpdateThread(void*)
227 {
228     updatesInit();
229
230     s_micLastSecond = tickCountMicro();
231
232     while(s_bIsRunning)
233     {
234         MICRO time = tickCountMicro();
235             handleInput();
236             update(s_fGameStep);
237
238             updateFPSCounters();
239         time = tickCountMicro() - time;
240
241         float wait = (1000000.0 / s_iTargetUPS - time);
242         s_fAccUpdateWait += 0 < wait ? wait : 0;
243
244         if(s_iMinWaitMicro < s_fAccUpdateWait)
245         {
246             int iWaits = (int)(s_fAccUpdateWait / s_iMinWaitMicro);
247             s_fAccUpdateWait -= iWaits * s_iMinWaitMicro;
248             SDL_Delay(iWaits * s_iMinWaitMilli);
249         }
250     }
251
252     updatesClean();
253
254     return 0;
255 }
256
257 int startDrawThread(void*)
258 {
259     drawInit();
260
261     while(s_bIsRunning)
262     {
263         MICRO time = tickCountMicro();
264             draw();
265         time = tickCountMicro() - time;
266
267         float wait = (1000000.0 / s_iTargetFPS - time);
268         s_fAccDrawWait += 0 < wait ? wait : 0;
269
270         if(s_iMinWaitMicro < s_fAccDrawWait)
271         {
272             int iWaits = (int)(s_fAccDrawWait / s_iMinWaitMicro);
273             s_fAccDrawWait -= iWaits * s_iMinWaitMicro;
274             SDL_Delay(iWaits * s_iMinWaitMilli);
275         }
276     }
277
278     drawClean();
279
280     return 0;
281 }