/*************************************************************************** * Copyright (C) 2005-2019 by the FIFE team * * http://www.fifengine.net * * This file is part of FIFE. * * * * FIFE is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ // Standard C++ library includes #include #include // 3rd party library includes #include #include // FIFE includes // These includes are split up in two parts, separated by one empty line // First block: files included from the FIFE root src directory // Second block: files included from the same folder #include "util/base/exception.h" #include "util/log/logger.h" #include "util/time/timemanager.h" #include "audio/soundmanager.h" #include "gui/guimanager.h" #include "vfs/vfs.h" #include "vfs/vfsdirectory.h" #include "vfs/directoryprovider.h" #include "vfs/zip/zipprovider.h" #include "eventchannel/eventmanager.h" #include "video/imagemanager.h" #include "video/animationmanager.h" #include "audio/soundclipmanager.h" #include "video/renderbackend.h" #include "video/cursor.h" #include "video/devicecaps.h" #ifdef HAVE_OPENGL #include "video/opengl/fife_opengl.h" #include "video/opengl/renderbackendopengl.h" #endif #include "video/sdl/renderbackendsdl.h" #include "loaders/native/video/imageloader.h" #include "loaders/native/audio/ogg_loader.h" #include "model/model.h" #include "pathfinder/routepather/routepather.h" #include "model/metamodel/grids/hexgrid.h" #include "model/metamodel/grids/squaregrid.h" #include "view/renderers/quadtreerenderer.h" #include "view/renderers/gridrenderer.h" #include "view/renderers/instancerenderer.h" #include "view/renderers/coordinaterenderer.h" #include "view/renderers/floatingtextrenderer.h" #include "view/renderers/cellselectionrenderer.h" #include "view/renderers/blockinginforenderer.h" #include "view/renderers/genericrenderer.h" #include "view/renderers/targetrenderer.h" #include "view/renderers/lightrenderer.h" #include "view/renderers/offrenderer.h" #include "view/renderers/cellrenderer.h" #include "video/image.h" #include "engine.h" #include "version.h" #ifdef USE_COCOA #include #include int32_t main(int32_t argc, char **argv) { return 0; } #endif namespace FIFE { static Logger _log(LM_CONTROLLER); Engine::Engine(): m_renderbackend(0), m_guimanager(0), m_eventmanager(0), m_soundmanager(0), m_timemanager(0), m_imagemanager(0), m_animationmanager(0), m_soundclipmanager(0), m_vfs(0), m_model(0), m_logmanager(0), m_cursor(0), m_destroyed(false), m_settings(), m_devcaps(), m_offrenderer(0), m_targetrenderer(0), m_changelisteners() { #ifdef USE_COCOA // The next lines ensure that Cocoa is initialzed correctly. // This is needed for SDL to function properly on MAC OS X. void* cocoa_lib; cocoa_lib = dlopen( "/System/Library/Frameworks/Cocoa.framework/Cocoa", RTLD_LAZY ); void (*nsappload)(void); nsappload = (void(*)()) dlsym( cocoa_lib, "NSApplicationLoad"); nsappload(); // Create an autorelease pool, so autoreleased SDL objects don't leak. #ifdef OSX_109 Class NSAutoreleasePool = objc_getClass("NSAutoreleasePool"); m_autoreleasePool = class_createInstance(NSAutoreleasePool, 0); #else objc_object *NSAutoreleasePool = objc_getClass("NSAutoreleasePool"); m_autoreleasePool = objc_msgSend(NSAutoreleasePool, sel_registerName("new")); #endif #endif m_logmanager = LogManager::instance(); } EngineSettings& Engine::getSettings() { return m_settings; } const DeviceCaps& Engine::getDeviceCaps() const { return m_devcaps; } void Engine::changeScreenMode(const ScreenMode& mode){ m_cursor->invalidate(); m_imagemanager->invalidateAll(); // recreate main screen m_renderbackend->createMainScreen(mode, m_settings.getWindowTitle(), m_settings.getWindowIcon()); if (m_guimanager) { m_guimanager->resizeTopContainer(0,0,mode.getWidth(), mode.getHeight()); } std::vector::iterator i = m_changelisteners.begin(); while (i != m_changelisteners.end()) { (*i)->onScreenModeChanged(mode); ++i; } } void Engine::init() { m_destroyed = false; FL_LOG(_log, LMsg("Fifengine v") << FIFE::getVersion()); FL_LOG(_log, "================== Engine initialize start ================="); m_timemanager = new TimeManager(); FL_LOG(_log, "Time manager created"); FL_LOG(_log, "Creating VFS"); m_vfs = new VFS(); FL_LOG(_log, "Adding root directory to VFS"); m_vfs->addSource( new VFSDirectory(m_vfs) ); m_vfs->addProvider( new DirectoryProvider() ); FL_LOG(_log, "Adding zip provider to VFS"); m_vfs->addProvider( new ZipProvider() ); //m_vfs->addProvider(ProviderDAT2()); //m_vfs->addProvider(ProviderDAT1()); FL_LOG(_log, "Engine pre-init done"); // If failed to init SDL throw exception. if (SDL_Init(SDL_INIT_NOPARACHUTE | SDL_INIT_TIMER) < 0) { throw SDLException(SDL_GetError()); } TTF_Init(); FL_LOG(_log, "Creating event manager"); m_eventmanager = new EventManager(); m_eventmanager->setMouseSensitivity(m_settings.getMouseSensitivity()); m_eventmanager->setMouseAccelerationEnabled(m_settings.isMouseAccelerationEnabled()); m_eventmanager->setJoystickSupport(m_settings.isJoystickSupport()); FL_LOG(_log, "Creating resource managers"); m_imagemanager = new ImageManager(); m_animationmanager = new AnimationManager(); m_soundclipmanager = new SoundClipManager(); FL_LOG(_log, "Creating render backend"); std::string rbackend(m_settings.getRenderBackend()); if (rbackend == "SDL") { m_renderbackend = new RenderBackendSDL(m_settings.getColorKey()); FL_LOG(_log, "SDL Render backend created"); } else { #ifdef HAVE_OPENGL m_renderbackend = new RenderBackendOpenGL(m_settings.getColorKey()); FL_LOG(_log, "OpenGL Render backend created"); #else m_renderbackend = new RenderBackendSDL(m_settings.getColorKey()); // Remember the choice so we pick the right graphics class. rbackend = "SDL"; FL_WARN(_log, "Tried to select OpenGL, even though it is not compiled into the engine. Falling back to SDL Render backend"); #endif } FL_LOG(_log, "Initializing render backend"); m_renderbackend->setColorKeyEnabled(m_settings.isColorKeyEnabled()); // we always set this to false //m_renderbackend->setAlphaOptimizerEnabled(false); m_renderbackend->setImageCompressingEnabled(m_settings.isGLCompressImages()); m_renderbackend->setFramebufferEnabled(m_settings.isGLUseFramebuffer()); m_renderbackend->setNPOTEnabled(m_settings.isGLUseNPOT()); m_renderbackend->setTextureFiltering(m_settings.getGLTextureFiltering()); m_renderbackend->setMipmappingEnabled(m_settings.isGLUseMipmapping()); m_renderbackend->setMonochromeEnabled(m_settings.isGLUseMonochrome()); m_renderbackend->setDepthBufferEnabled(m_settings.isGLUseDepthBuffer()); m_renderbackend->setAlphaTestValue(m_settings.getGLAlphaTestValue()); m_renderbackend->setVSyncEnabled(m_settings.isVSync()); if (m_settings.isFrameLimitEnabled()) { m_renderbackend->setFrameLimitEnabled(true); m_renderbackend->setFrameLimit(m_settings.getFrameLimit()); } std::string driver = m_settings.getVideoDriver(); if (driver != ""){ std::vector drivers = m_devcaps.getAvailableVideoDrivers(); if (std::find (drivers.begin(), drivers.end(), driver) == drivers.end()) { FL_WARN(_log, "Selected video driver is not supported for your Operating System! Reverting to default driver."); driver = ""; } m_devcaps.setVideoDriverName(driver); } // init backend with selected video driver or default m_renderbackend->init(driver); // in case of SDL we use this to create the SDL_Renderer driver = m_settings.getSDLDriver(); if (driver != ""){ std::vector drivers = m_devcaps.getAvailableRenderDrivers(); if (std::find (drivers.begin(), drivers.end(), driver) == drivers.end()) { FL_WARN(_log, "Selected render driver is not supported for your Operating System! Reverting to default driver."); driver = ""; } m_devcaps.setRenderDriverName(driver); } FL_LOG(_log, "Querying device capabilities"); m_devcaps.fillDeviceCaps(); uint16_t bpp = m_settings.getBitsPerPixel(); m_screenMode = m_devcaps.getNearestScreenMode( m_settings.getScreenWidth(), m_settings.getScreenHeight(), bpp, rbackend, m_settings.isFullScreen(), m_settings.getRefreshRate(), m_settings.getDisplay()); FL_LOG(_log, "Creating main screen"); m_renderbackend->createMainScreen( m_screenMode, m_settings.getWindowTitle(), m_settings.getWindowIcon()); FL_LOG(_log, "Main screen created"); #ifdef HAVE_OPENGL if (m_settings.getLightingModel() != 0) { m_renderbackend->setLightingModel(m_settings.getLightingModel()); } #endif FL_LOG(_log, "Creating sound manager"); m_soundmanager = new SoundManager(); m_soundmanager->setVolume(static_cast(m_settings.getInitialVolume()) / 10); FL_LOG(_log, "Creating renderers"); m_offrenderer = new OffRenderer(m_renderbackend); m_targetrenderer = new TargetRenderer(m_renderbackend); m_renderers.push_back(new InstanceRenderer(m_renderbackend, 10)); m_renderers.push_back(new GridRenderer(m_renderbackend, 20)); m_renderers.push_back(new CellSelectionRenderer(m_renderbackend, 30)); m_renderers.push_back(new BlockingInfoRenderer(m_renderbackend, 40)); m_renderers.push_back(new FloatingTextRenderer(m_renderbackend, 50)); m_renderers.push_back(new QuadTreeRenderer(m_renderbackend, 60)); m_renderers.push_back(new CoordinateRenderer(m_renderbackend, 70)); m_renderers.push_back(new GenericRenderer(m_renderbackend, 80)); m_renderers.push_back(new LightRenderer(m_renderbackend, 90)); m_renderers.push_back(new CellRenderer(m_renderbackend, 100)); FL_LOG(_log, "Creating model"); m_model = new Model(m_renderbackend, m_renderers); FL_LOG(_log, "Adding pathers to model"); m_model->adoptPather(new RoutePather()); FL_LOG(_log, "Adding grid prototypes to model"); m_model->adoptCellGrid(new SquareGrid()); m_model->adoptCellGrid(new HexGrid(false)); m_model->adoptCellGrid(new HexGrid(true)); m_cursor = new Cursor(m_renderbackend); m_cursor->setNativeImageCursorEnabled(m_settings.isNativeImageCursorEnabled()); FL_LOG(_log, "Engine initialized"); } Engine::~Engine() { if( !m_destroyed ) { destroy(); } } void Engine::destroy() { FL_LOG(_log, "Destructing engine"); delete m_cursor; delete m_model; delete m_soundmanager; delete m_guimanager; delete m_animationmanager; delete m_imagemanager; delete m_soundclipmanager; delete m_eventmanager; // properly remove all the renderers created during init delete m_offrenderer; delete m_targetrenderer; std::vector::iterator rendererIter = m_renderers.begin(); for ( ; rendererIter != m_renderers.end(); ++rendererIter) { delete *rendererIter; } m_renderers.clear(); delete m_renderbackend; delete m_vfs; delete m_timemanager; TTF_Quit(); SDL_Quit(); #ifdef USE_COCOA objc_msgSend(m_autoreleasePool, sel_registerName("release")); #endif FL_LOG(_log, "================== Engine destructed =================="); m_destroyed = true; //delete m_logmanager; } void Engine::initializePumping() { m_eventmanager->processEvents(); } void Engine::pump() { m_renderbackend->startFrame(); m_eventmanager->processEvents(); m_timemanager->update(); m_soundmanager->update(); m_targetrenderer->render(); if (m_model->getActiveCameraCount() == 0) { m_renderbackend->clearBackBuffer(); m_offrenderer->render(); } else { m_model->update(); } if (m_guimanager) { m_guimanager->turn(); } m_cursor->draw(); m_renderbackend->endFrame(); } void Engine::finalizePumping() { // nothing here at the moment.. } void Engine::addChangeListener(IEngineChangeListener* listener) { m_changelisteners.push_back(listener); } void Engine::removeChangeListener(IEngineChangeListener* listener) { std::vector::iterator i = m_changelisteners.begin(); while (i != m_changelisteners.end()) { if ((*i) == listener) { m_changelisteners.erase(i); return; } ++i; } } }