core/code/system/f_engine.h

   1 /*
   2     fegdk: FE Game Development Kit
   3     Copyright (C) 2001-2008 Alexey "waker" Yakovenko
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public
  16     License along with this library; if not, write to the Free
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19     Alexey Yakovenko
  20     waker@users.sourceforge.net
  21 */
  22
  23 #ifndef __F_ENGINE_H
  24 #define __F_ENGINE_H
  25
  26 #include "config.h"
  27 #include "f_baseobject.h"
  28 #include <vector>
  29 #include "f_helpers.h"
  30
  31 namespace fe
  32 {
  33
  34         class fileSystem;
  35         class baseViewport;
  36         class inputDevice;
  37         class application;
  38         class effect;
  39         class timer;
  40         class console;
  41         class effectParms;
  42         class parmMgr;
  43         class baseRenderer;
  44 #ifndef SOUND_DISABLED
  45         class baseSoundDriver;
  46 #endif
  47         class resourceMgr;
  48         class texture;
  49         class drawUtil;
  50         class rBackend;
  51         class logger;
  52         class sceneManager;
  53         class keyBinder;
  54         class script;
  55         class entityManager;
  56         class metaShader;
  57         class fontFT;
  58         class animSequencer;
  59         class stackAllocator;
  60         class cvarManager;
  61
  62         struct cvar_t;
  63         extern cvar_t *sys_int_mainloop;
  64         extern cvar_t *sys_profile;
  65         extern cvar_t *sys_mainscript;
  66         extern cvar_t *sys_debug_freetype;
  67         extern cvar_t *sys_stack_size;
  68
  69         class FE_API engine : public baseObject
  70         {
  71
  72         private:
  73
  74                 /**
  75                  * Specifies size of buffer returned by tmpBuffer
  76                  * FIXME: should be set by configure script
  77                  */
  78                 enum { default_tmpbuffer_size = 65536 };
  79                 ubyte* mpTmpBuffer;
  80
  81                 smartPtr <baseRenderer>                 mpRenderer;
  82                 smartPtr <baseViewport>                 mpViewport;
  83                 smartPtr <fileSystem>                   mpFileSystem;
  84                 smartPtr <inputDevice>                  mpInputDevice;
  85                 smartPtr <application>                  mpApp;
  86                 smartPtr <logger>                               mpLogger;
  87                 smartPtr <timer>                                mpTimer;
  88                 smartPtr <console>                              mpConsole;
  89                 smartPtr <effectParms>                  mpEffectParms;
  90                 smartPtr <parmMgr>                              mpParmMgr;
  91 #ifndef SOUND_DISABLED
  92                 smartPtr <baseSoundDriver>              mpSoundDriver;
  93 #endif
  94                 smartPtr <resourceMgr>                  mpResourceMgr;
  95                 smartPtr <drawUtil>                             mpDrawUtil;
  96                 smartPtr <rBackend>                             mpRBackend;
  97                 smartPtr <sceneManager>                 mpSceneManager;
  98                 smartPtr <keyBinder>                    mpKeyBinder;
  99                 smartPtr <script>                               mpScript;
 100                 smartPtr <entityManager>                mpEntManager;
 101                 smartPtr <metaShader>                   mpMetaShader;
 102                 smartPtr <fontFT>                               mpSysFont;
 103                 smartPtr <animSequencer>                mpAnimSequencer;
 104                 smartPtr <stackAllocator>               mpStackAllocator;
 105                 smartPtr <cvarManager>                  mpCVarManager;
 106
 107                 // initializes subsystems which are *shared* between all engine usage patterns
 108                 // i mean different 'run' methods
 109                 void sharedInit (void);
 110                 void initResourceMgr (void);
 111
 112                 // platform-specific stuff
 113                 void mainLoop (void);
 114                 void beginScene (void);
 115                 void endScene (void);
 116
 117         public:
 118
 119                 engine (void);
 120                 ~engine (void);
 121
 122                 /**
 123                  * Use this one if your application has own renderer/mainloop (e.g. FEditor uses this scheme).
 124                  * Be aware that this method is gonna be abandoned someday, cause it causes compatibility problems.
 125                  * @param renderer pointer to a renderer object
 126                  * @param dataPath VFS root
 127                  */
 128                 void                                                            run (const smartPtr <baseRenderer> &renderer, const char *dataPath = "./");
 129
 130                 /**
 131                  * Use this if u wanna use internal renderer/mainloop (see feApplication for reference and usage tutorial)
 132                  * @param app pointer to application object
 133                  */
 134                 void                                                            run (const smartPtr <application> &app, int argc, char *argv[]);
 135
 136                 // TODO: do 2 more 'run' methods -- internal renderer vs own mainloop; internal mainloop vs own renderer
 137
 138                 /**
 139                  * This can be used to close application by user choice
 140                  * console 'quit' command uses this
 141                  */
 142                 void                                                            quit (void);
 143
 144                 /**
 145                  * Normal engine tick, performs usual stuff -- update states, render stuff, etc
 146                  * Shouldn't it be private? :-/
 147                  */
 148                 void                                                            tick (void);
 149
 150                 /**
 151                  * Use that if u need to emulate keydown event
 152                  */
 153                 void                                                            keyDown (int code);
 154
 155                 /**
 156                  * Use that when ur gonna emulate keyup event
 157                  */
 158                 void                                                            keyUp (int code);
 159
 160                 /**
 161                  * @return application pointer.
 162                  * \deprecated Some subsystems used this to check renderer requirements, etc. It is now controlled through cvars.
 163                  */
 164                 application*                    getApplication (void) const;
 165
 166                 /**
 167                  * Renderer access.
 168                  * You don't gonna need one in usual portable application.
 169                  * You may use it to query supported vidmodes, renderer info, etc.
 170                  * @return renderer pointer.
 171                  */
 172                 baseRenderer*                   getRenderer (void) const;
 173
 174 #ifndef SOUND_DISABLED
 175                 /**
 176                  * @return sound mixer object pointer
 177                  */
 178                 smartPtr <baseSoundDriver>                      getSoundDriver (void) const;
 179 #endif
 180
 181                 /**
 182                  * @return the main filesystem object used by the engine to load resources
 183                  */
 184                 fileSystem*                     getFileSystem (void) const;
 185
 186                 /**
 187                  * @return current viewport. can be NULL if u want it that way.
 188                  */
 189                 baseViewport*                   getViewport (void) const;
 190
 191                 /**
 192                  * Changes current viewport. Used mostly in FEditor.
 193                  * @param vp new current viewport object pointer
 194                  */
 195                 void                                                    setViewport (baseViewport* vp);
 196
 197                 /**
 198                  * @return input system object
 199                  */
 200                 inputDevice*                    getInputDevice (void) const;
 201
 202                 /**
 203                  * Faster than any malloc, but must be used carefully, since many internal routines use it as a temporary storage.
 204                  * It is constant storage, so it is NOT THREAD-SAFE and risky even in single-threaded environment.
 205                  * @param sz size of buffer required
 206                  * @return temporary sysmem buffer of requested size if it is less than default_tmpbuffer_size, or NULL otherwise
 207                  */
 208                 ubyte*                                                  getTmpBuffer (int sz) const;
 209
 210                 /**
 211                  * @return logger object ptr
 212                  */
 213                 logger*                         getLogger (void);
 214
 215                 /**
 216                  * @return main system timer, used to sync everything in the game
 217                  */
 218                 timer*                          getTimer (void) const;
 219
 220                 /**
 221                  * Should be available always, even if not visible/renderable (even in non-graphical apps, such as 'fgp').
 222                  * @return console object pointer.
 223                  */
 224                 console*                                getConsole (void);
 225
 226                 /**
 227                  * @return effect file parameter manager
 228                  */
 229                 effectParms*                    getEffectParms (void) const;
 230
 231                 /**
 232                  * @return global parameter manager, used in feMathExpression class and maybe somewhere else
 233                  */
 234                 parmMgr*                                getParmMgr (void) const;
 235
 236                 /**
 237                  * @return global resource manager
 238                  */
 239                 resourceMgr*                    getResourceMgr (void) const;
 240
 241                 /**
 242                  * @return feDrawUtil object
 243                  */
 244                 drawUtil*                               getDrawUtil (void) const;
 245
 246                 /**
 247                  * @return render backend object
 248                  */
 249                 rBackend*                       getRBackend (void) const;
 250
 251                 /**
 252                  * @return scene manager object
 253                  */
 254                 sceneManager*                   getSceneManager (void) const;
 255
 256                 /**
 257                  * @return keybinder object
 258                  */
 259                 keyBinder*                      getKeyBinder (void) const;
 260
 261                 /**
 262                  * @return entity manager object
 263                  */
 264                 entityManager*          getEntManager (void) const;
 265
 266                 /**
 267                  * @return metashader object
 268                  */
 269                 metaShader*                     getMetaShader (void) const;
 270
 271                 /**
 272                  * @return system font used to draw console, etc
 273                  */
 274                 fontFT*                         getSysFont (void) const;
 275
 276                 /**
 277                  * @return animation sequencer object
 278                  */
 279                 animSequencer*          getAnimSequencer (void) const;
 280
 281                 /**
 282                  * @return global stack allocator
 283                  */
 284                 stackAllocator *getStackAllocator (void) const;
 285
 286                 /**
 287                  * [re]starts video subsystem
 288                  */
 289                 void restartVideo (void);
 290
 291                 /**
 292                  * [re]starts audio subsystem
 293                  */
 294                 void restartAudio (void);
 295
 296                 /**
 297                  * @return console variable manager
 298                  */
 299                 cvarManager* getCVarManager (void) const;
 300         };
 301
 302         extern FE_API engine *g_engine;
 303
 304 }
 305
 306 #endif // __F_ENGINE_H
 307