doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / gameengine / GamePlayer / common / GPC_Engine.cpp
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #ifdef WIN32
31         #pragma warning (disable:4786) // suppress stl-MSVC debug info warning
32 #endif // WIN32
33
34 #include <iostream>
35
36 #include "BKE_blender.h"  // initglobals()
37 #include "BKE_global.h"  // Global G
38 #include "BKE_report.h"
39 #include "DNA_scene_types.h"
40 #include "DNA_camera_types.h"  // Camera
41 #include "DNA_object_types.h"  // Object
42
43 #include "BLO_readfile.h"
44 #include "BLI_blenlib.h"
45
46 // include files needed by "KX_BlenderSceneConverter.h"
47
48 #include "GEN_Map.h"
49 #include "SCA_IActuator.h"
50 #include "RAS_MeshObject.h"
51
52 #include "KX_BlenderSceneConverter.h"
53 #include "KX_KetsjiEngine.h"
54 #include "NG_LoopBackNetworkDeviceInterface.h"
55
56 #include "RAS_IRenderTools.h"
57
58 #include "GPC_Engine.h"
59 #include "GPC_KeyboardDevice.h"
60 #include "GPC_MouseDevice.h"
61 #include "GPC_RawImage.h"
62 #include "GPC_RawLoadDotBlendArray.h"
63
64
65
66 GPC_Engine::GPC_Engine(char *customLoadingAnimationURL,
67                 int foregroundColor, int backgroundColor, int frameRate) :
68                 m_initialized(false), m_running(false), m_loading(false),
69                 m_customLoadingAnimation(false), m_previousProgress(0.0),
70                 m_system(NULL), m_keyboarddev(NULL),
71                 m_mousedev(NULL), m_canvas(NULL), m_rendertools(NULL),
72                 m_portal(NULL), m_sceneconverter(NULL), m_networkdev(NULL),
73                 m_curarea(NULL), m_customLoadingAnimationURL(NULL),
74                 m_foregroundColor(foregroundColor), m_backgroundColor(backgroundColor),
75                 m_frameRate(frameRate),
76                 m_BlenderLogo(0), m_Blender3DLogo(0)/*, m_NaNLogo(0)*/
77 {
78         if(customLoadingAnimationURL[0] != '\0')
79         {
80                 m_customLoadingAnimationURL = new char[sizeof(customLoadingAnimationURL)];
81 // not yet, need to be implemented first...             m_customLoadingAnimation = true;
82         }
83
84         // load the Blender logo into memory
85         m_BlenderLogo = new GPC_RawImage();
86         // blender3d size is 115 x 32 so make resulting texture 128 x 128
87         if(!m_BlenderLogo->Load("BlenderLogo", 128, 128, GPC_RawImage::alignTopLeft, 8, 8))
88                 m_BlenderLogo = 0;
89
90         // load the Blender3D logo into memory
91         m_Blender3DLogo = new GPC_RawImage();
92         // blender3d size is 136 x 11 so make resulting texture 256 x 256
93         if(!m_Blender3DLogo->Load("Blender3DLogo", 256, 256, GPC_RawImage::alignBottomRight, 8, 8))
94                 m_Blender3DLogo = 0;
95
96 #if 0
97         // obsolete logo
98         // load the NaN logo into memory
99         m_NaNLogo = new GPC_RawImage();
100         // blender3d size is 32 x 31 so make resulting texture 64 x 64
101         if(!m_NaNLogo->Load("NaNLogo", 64, 64, GPC_RawImage::alignBottomRight, 8, 8))
102                 m_NaNLogo = 0;
103 #endif
104 }
105
106
107 GPC_Engine::~GPC_Engine()
108 {
109         // deleting everything in reverse order of creation
110 #if 0
111 // hmm deleted in Stop()        delete m_portal;
112 // hmm deleted in Stop()        delete m_sceneconverter;
113         delete m_system;
114         delete m_networkdev;
115         delete m_rendertools;
116         delete m_canvas;
117         delete m_mousedev;
118         delete m_keyboarddev;
119 // not yet used so be careful and not delete them
120 //      delete m_WaveCache;
121 //      delete m_curarea;  // for future use, not used yet
122 #endif
123         delete m_BlenderLogo;
124         delete m_Blender3DLogo;
125 #if 0
126         delete m_NaNLogo;
127 #endif
128 }
129
130
131 bool GPC_Engine::Start(char *filename)
132 {
133         ReportList reports;
134         BlendFileData *bfd;
135         
136         BKE_reports_init(&reports, RPT_STORE);
137         bfd= BLO_read_from_file(filename, &reports);
138         BKE_reports_clear(&reports);
139
140         if (!bfd) {
141                         // XXX, deal with error here
142                 cout << "Unable to load: " << filename << endl;
143                 return false;
144         }
145
146         StartKetsji();
147
148         if(bfd->type == BLENFILETYPE_PUB)
149                 m_canvas->SetBannerDisplayEnabled(false);
150
151         return true;
152 }
153
154
155 bool GPC_Engine::Start(unsigned char *blenderDataBuffer,
156                 unsigned int blenderDataBufferSize)
157 {
158         ReportList reports;
159         BlendFileData *bfd;
160         
161         BKE_reports_init(&reports, RPT_STORE);
162         bfd= BLO_read_from_memory(blenderDataBuffer, blenderDataBufferSize, &reports);
163         BKE_reports_clear(&reports);
164
165         if (!bfd) {
166                         // XXX, deal with error here
167                 cout << "Unable to load. " << endl;
168                 return false;
169         }
170         
171         StartKetsji();
172
173         if(bfd->type == BLENFILETYPE_PUB)
174                 m_canvas->SetBannerDisplayEnabled(false);
175
176         return true;
177 }
178
179
180 bool GPC_Engine::StartKetsji(void)
181 {
182         STR_String startSceneName = ""; // XXX scene->id.name + 2;
183 /*
184         KX_KetsjiEngine* ketsjieng = new KX_KetsjiEngine(m_system);
185         m_portal = new KetsjiPortal(ketsjieng);
186         m_portal->setSecurity(psl_Highest);
187                 
188         KX_ISceneConverter *sceneconverter = new KX_BlenderSceneConverter(&G, ketsjieng);
189                 
190         m_portal->Enter(
191                         startSceneName,
192                         sceneconverter,
193                         m_canvas,
194                         m_rendertools,
195                         m_keyboarddev,
196                         m_mousedev,
197                         m_networkdev,
198                         m_system);
199
200         m_system->SetMainLoop(m_portal->m_ketsjieng);
201
202         m_running = true;
203         */
204         return true;
205 }
206
207
208 void GPC_Engine::StartLoadingAnimation()
209 {
210         if(m_customLoadingAnimation)
211         {
212         }
213         else
214         {
215                 unsigned char *blenderDataBuffer;
216                 int blenderDataBufferSize;
217                 GetRawLoadingAnimation(&blenderDataBuffer, &blenderDataBufferSize);
218                 if(!Start(blenderDataBuffer, blenderDataBufferSize))
219                         cout << "something went wrong when starting the engine" << endl;
220                 delete blenderDataBuffer;  // created with 'new' in GetRawLoadingAnimation()
221         }
222 }
223
224         
225 // will be platform dependant
226 float GPC_Engine::DetermineProgress(void)
227 {
228 #if 0
229         float progress;
230         if ((m_blenderData.m_ulProgress > 0) &&
231                         (m_blenderData.m_ulProgressMax != m_blenderData.m_ulProgress)) {
232                 progress = (float)m_blenderData.m_ulProgress;
233                 progress /= (float)m_blenderData.m_ulProgressMax;
234         }
235         else {
236                 progress = 0.f;
237         }
238         progress *= 100.f;
239         return (unsigned int) progress ;
240 #endif
241         return m_previousProgress + 0.01;  // temporary TODO
242 }
243
244         
245 void GPC_Engine::UpdateLoadingAnimation(void)
246 {
247         //int delta;
248
249         float progress = DetermineProgress();
250
251         if(progress > m_previousProgress)
252         {
253 //              delta = progress - m_previousProgress;
254                 m_previousProgress = progress;
255                 if(m_previousProgress > 1.0)
256                         m_previousProgress = 1.0;  // limit to 1.0 (has to change !)
257 //                      m_engine->m_previousProgress = 0.0;
258         }
259
260         STR_String to = "";
261         STR_String from = "";
262         STR_String subject = "progress";
263         STR_String body;
264         body.Format("%f", progress);  // a number between 0.0 and 1.0
265
266         if(m_networkdev)
267         {
268                 // Store a progress message in the network device.
269                 NG_NetworkMessage* msg = new NG_NetworkMessage(to, from, subject, body);
270                 m_networkdev->SendNetworkMessage(msg);
271                 msg->Release();
272         }
273 }
274
275
276 void GPC_Engine::Stop()
277 {
278         // only delete things that are created in StartKetsji()
279 /*      if(m_portal)
280         {
281                 m_portal->Leave();
282                 delete m_portal;  // also gets rid of KX_KetsjiEngine (says Maarten)
283                 m_portal = 0;
284         }
285 */      if(m_sceneconverter)
286         {
287                 delete m_sceneconverter;
288                 m_sceneconverter = 0;
289         }
290 #if 0
291         if(m_frameTimerID)
292         {
293                 ::KillTimer(0, m_frameTimerID);
294                 m_frameTimerID = 0;
295         }
296         m_engineRunning = false;
297 #endif
298
299         m_running = false;
300 }
301
302
303 void GPC_Engine::Exit()
304 {
305         if(m_running)
306                 Stop();
307
308         if (m_system) {
309                 delete m_system;
310                 m_system = 0;
311         }
312         if (m_keyboarddev) {
313                 delete m_keyboarddev;
314                 m_keyboarddev = 0;
315         }
316         if (m_mousedev) {
317                 delete m_mousedev;
318                 m_mousedev = 0;
319         }
320         if (m_canvas) {
321                 delete m_canvas;
322                 m_canvas = 0;
323         }
324         if (m_rendertools) {
325                 delete m_rendertools;
326                 m_rendertools = 0;
327         }
328         if (m_networkdev) {
329                 delete m_networkdev;
330                 m_networkdev = 0;
331         }
332
333         m_initialized = false;
334 }
335