mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-02-19 03:19:06 -06:00
Code Issues Packages Projects Releases Wiki Activity

Use exceptions instead of success return values for initialize and

Browse Source 
create methods
This commit is contained in:
Alexander Bock
2017-02-25 11:51:41 -05:00
parent 6c4efc4eec
commit bc75334eb4
6 changed files with 370 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
apps/OpenSpace/main.cpp
View File

@@ -49,7 +49,6 @@ sgct::SGCTWindow* FirstOpenVRWindow = nullptr;
std::pair<int, int> supportedOpenGLVersion() {
// Just create a window in order to retrieve the available OpenGL version before we
// create the real window
glfwInit();
// On OS X we need to explicitly set the version and specify that we are using CORE
@@ -77,26 +76,20 @@ std::pair<int, int> supportedOpenGLVersion() {
// And get rid of the window again
glfwDestroyWindow(offscreen);
glfwWindowHint(GLFW_VISIBLE, GL_TRUE);
return { major, minor };
}
void mainInitFunc() {
LTRACE("main::mainInitFunc(begin)");
LDEBUG("Initializing OpenSpace Engine");
// @CLEANUP: The return value should be replaced with an exception ---abock
bool success = OsEng.initialize();
LDEBUG("Initializing OpenSpace Engine started");
OsEng.initialize();
LDEBUG("Initializing OpenSpace Engine finished");
LDEBUG("Initializing OpenGL in OpenSpace Engine");
if (success) {
success = OsEng.initializeGL();
}
if (!success) {
LFATAL("Initializing OpenSpaceEngine failed");
LogMgr.flushLogs();
exit(EXIT_FAILURE);
}
LDEBUG("Initializing OpenGL in OpenSpace Engine started");
OsEng.initializeGL();
LDEBUG("Initializing OpenGL in OpenSpace Engine finished");
// Find if we have at least one OpenVR window
// Save reference to first OpenVR window, which is the one we will copy to the HMD.
@@ -160,21 +153,17 @@ void mainPostSyncPreDrawFunc() {
void mainRenderFunc() {
LTRACE("main::mainRenderFunc(begin)");
using glm::mat4;
using glm::translate;
//not the most efficient, but for clarity @JK
mat4 userMatrix = translate(mat4(1.f), SgctEngine->getDefaultUserPtr()->getPos());
mat4 sceneMatrix = SgctEngine->getModelMatrix();
mat4 viewMatrix = SgctEngine->getCurrentViewMatrix() * userMatrix;
//dont shift nav-direction on master, makes it very tricky to navigate @JK
if (!SgctEngine->isMaster()) {
viewMatrix = viewMatrix * sceneMatrix;
}
mat4 projectionMatrix = SgctEngine->getCurrentProjectionMatrix();
glm::mat4 viewMatrix =
SgctEngine->getCurrentViewMatrix() *
// User matrix
glm::translate(
glm::mat4(1.f),
SgctEngine->getDefaultUserPtr()->getPos()
)
;
glm::mat4 projectionMatrix = SgctEngine->getCurrentProjectionMatrix();
#ifdef OPENVR_SUPPORT
bool currentWindowIsHMD = FirstOpenVRWindow == _sgctEngine->getCurrentWindowPtr();
if (sgct::SGCTOpenVR::isHMDActive() && currentWindowIsHMD) {
@@ -184,9 +173,13 @@ void mainRenderFunc() {
}
#endif
// @CLEANUP: Pass the scene matrix to the render function as well and let the
// OpenSpaceEngine decide whether it wants to apply it or not
OsEng.render(projectionMatrix, viewMatrix);
if (SgctEngine->isMaster()) {
OsEng.render(viewMatrix, projectionMatrix);
}
else {
glm::mat4 sceneMatrix = SgctEngine->getModelMatrix();
OsEng.render(viewMatrix * sceneMatrix, projectionMatrix);
}
LTRACE("main::mainRenderFunc(end)");
}
@@ -195,7 +188,7 @@ void mainPostDrawFunc() {
#ifdef OPENVR_SUPPORT
if (FirstOpenVRWindow) {
//Copy the first OpenVR window to the HMD
// Copy the first OpenVR window to the HMD
sgct::SGCTOpenVR::copyWindowToHMD(FirstOpenVRWindow);
}
#endif
@@ -242,9 +235,11 @@ void mainMousePosCallback(double x, double y) {
}
void mainMouseScrollCallback(double posX, double posY) {
LTRACE("main::mainMouseScrollCallback(begin");
if (SgctEngine->isMaster()) {
OsEng.mouseScrollWheelCallback(posY);
}
LTRACE("main::mainMouseScrollCallback(end)");
}
void mainCharCallback(unsigned int codepoint, int mods) {
@@ -273,28 +268,30 @@ void mainLogCallback(const char* msg) {
return;
}
// Remove the trailing \n that is passed along
LINFOC("SGCT", message.substr(0, std::max<size_t>(message.size() - 1, 0)));
LINFOC("SGCT", message.substr(0, message.size() - 1));
}
int main_main(int argc, char** argv) {
std::pair<int, int> glVersion = supportedOpenGLVersion();
// create the OpenSpace engine and get arguments for the sgct engine
// Create the OpenSpace engine and get arguments for the SGCT engine
// @CLEANUP: Replace the return valua with throwing an exception --abock
std::vector<std::string> sgctArguments;
bool success = openspace::OpenSpaceEngine::create(
bool requestQuit = false;
openspace::OpenSpaceEngine::create(
argc, argv,
std::make_unique<openspace::SGCTWindowWrapper>(),
sgctArguments
sgctArguments,
requestQuit
);
if (!success) {
return EXIT_FAILURE;
if (requestQuit) {
return EXIT_SUCCESS;
}
LINFO("Detected OpenGL version: " << glVersion.first << "." << glVersion.second);
// create sgct engine c arguments
// Create sgct engine c arguments
int newArgc = static_cast<int>(sgctArguments.size());
char** newArgv = new char*[newArgc];
@@ -315,7 +312,7 @@ int main_main(int argc, char** argv) {
LDEBUG("Creating SGCT Engine");
SgctEngine = new sgct::Engine(newArgc, newArgv);
// deallocate sgct c arguments
// Deallocate sgct c arguments
delete[] newArgv;
// Bind functions
@@ -336,12 +333,12 @@ int main_main(int argc, char** argv) {
sgct::MessageHandler::instance()->setNotifyLevel(sgct::MessageHandler::NOTIFY_ALL);
// set encode and decode functions
// Set encode and decode functions
// NOTE: starts synchronizing before init functions
sgct::SharedData::instance()->setEncodeFunction(mainEncodeFun);
sgct::SharedData::instance()->setDecodeFunction(mainDecodeFun);
// try to open a window
// Try to open a window
LDEBUG("Initialize SGCT Engine");
std::map<std::pair<int, int>, sgct::Engine::RunMode> versionMapping = {
{ { 3, 3 }, sgct::Engine::RunMode::OpenGL_3_3_Core_Profile },
@@ -360,14 +357,13 @@ int main_main(int argc, char** argv) {
auto cleanup = [&](){
OsEng.deinitialize();
// clear function bindings to avoid crash after destroying the OpenSpace Engine
// Clear function bindings to avoid crash after destroying the OpenSpace Engine
sgct::MessageHandler::instance()->setLogToCallback(false);
sgct::MessageHandler::instance()->setLogCallback(nullptr);
LDEBUG("Destroying OpenSpaceEngine");
openspace::OpenSpaceEngine::destroy();
// Clean up (deallocate)
LDEBUG("Destroying SGCT Engine");
delete SgctEngine;
};
@@ -405,21 +401,19 @@ int main(int argc, char** argv) {
return main_main(argc, argv);
}
catch (const ghoul::RuntimeError& e) {
// Write out all of the information about the exception, flush the logs, and throw
// Write out all of the information about the exception and flush the logs
LFATALC(e.component, e.message);
LogMgr.flushLogs();
throw;
return EXIT_FAILURE;
}
catch (const std::exception& e) {
// Write out all of the information about the exception, flush the logs, and throw
LFATALC("Exception", e.what());
LogMgr.flushLogs();
throw;
return EXIT_FAILURE;
}
catch (...) {
// Write out all of the information about the exception, flush the logs, and throw
LFATALC("Exception", "Unknown exception");
LogMgr.flushLogs();
throw;
return EXIT_FAILURE;
}
}

139
include/openspace/engine/openspaceengine.h
View File

@@ -36,39 +36,43 @@
#include <vector>
namespace ghoul {
class Dictionary;
namespace cmdparser { class CommandlineParser; }
namespace fontrendering { class FontManager; }
}
} // namespace ghoul
namespace openspace {
class ConfigurationManager;
class DownloadManager;
class LuaConsole;
class NetworkEngine;
class GUI;
class RenderEngine;
class LuaConsole;
class ModuleEngine;
class WindowWrapper;
class SettingsEngine;
class TimeManager;
class SyncEngine;
class NetworkEngine;
class ParallelConnection;
class RenderEngine;
class SettingsEngine;
class SyncEngine;
class TimeManager;
class WindowWrapper;
namespace interaction { class InteractionHandler; }
namespace gui { class GUI; }
//namespace scripting { class ScriptEngine; }
namespace properties { class PropertyOwner; }
namespace scripting { struct LuaLibrary; }
namespace scripting { class ScriptScheduler; }
namespace scripting { class ScriptEngine; }
namespace scripting {
struct LuaLibrary;
class ScriptEngine;
class ScriptScheduler;
} // namespace scripting
class OpenSpaceEngine {
public:
static bool create(int argc, char** argv,
static void create(int argc, char** argv,
std::unique_ptr<WindowWrapper> windowWrapper,
std::vector<std::string>& sgctArguments);
std::vector<std::string>& sgctArguments, bool& requestClose);
static void destroy();
static bool isInitialized();
static OpenSpaceEngine& ref();
@@ -76,30 +80,13 @@ public:
double runTime();
void setRunTime(double t);
// Guaranteed to return a valid pointer
ConfigurationManager& configurationManager();
interaction::InteractionHandler& interactionHandler();
RenderEngine& renderEngine();
scripting::ScriptEngine& scriptEngine();
scripting::ScriptScheduler& scriptScheduler();
NetworkEngine& networkEngine();
LuaConsole& console();
ModuleEngine& moduleEngine();
ParallelConnection& parallelConnection();
properties::PropertyOwner& globalPropertyOwner();
WindowWrapper& windowWrapper();
ghoul::fontrendering::FontManager& fontManager();
DownloadManager& downloadManager();
TimeManager& timeManager();
SettingsEngine& settingsEngine();
// SGCT callbacks
bool initialize();
bool initializeGL();
// callbacks
void initialize();
void initializeGL();
void deinitialize();
void preSynchronization();
void postSynchronizationPreDraw();
void render(const glm::mat4& projectionMatrix, const glm::mat4& viewMatrix);
void render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix);
void postDraw();
void keyboardCallback(Key key, KeyModifier mod, KeyAction action);
void charCallback(unsigned int codepoint, KeyModifier mod);
@@ -109,22 +96,35 @@ public:
void externalControlCallback(const char* receivedChars, int size, int clientId);
void encode();
void decode();
void enableBarrier();
void disableBarrier();
void writeDocumentation();
void toggleShutdownMode();
bool useBusyWaitForDecode();
bool logSGCTOutOfOrderErrors();
void runPostInitializationScripts(const std::string& sceneDescription);
// Guaranteed to return a valid pointer
ConfigurationManager& configurationManager();
LuaConsole& console();
DownloadManager& downloadManager();
ModuleEngine& moduleEngine();
NetworkEngine& networkEngine();
ParallelConnection& parallelConnection();
RenderEngine& renderEngine();
SettingsEngine& settingsEngine();
TimeManager& timeManager();
WindowWrapper& windowWrapper();
ghoul::fontrendering::FontManager& fontManager();
interaction::InteractionHandler& interactionHandler();
properties::PropertyOwner& globalPropertyOwner();
scripting::ScriptEngine& scriptEngine();
scripting::ScriptScheduler& scriptScheduler();
// This method is only to be called from Modules
enum class CallbackOption {
Initialize = 0, // Callback for the end of the initialization
Deinitialize, // Callback for the end of the deinitialization
@@ -186,39 +186,38 @@ public:
void registerModuleMouseScrollWheelCallback(std::function<bool (double)> function);
/**
* Returns the Lua library that contains all Lua functions available to affect the
* application.
*/
* Returns the Lua library that contains all Lua functions available to affect the
* application.
*/
static scripting::LuaLibrary luaLibrary();
private:
OpenSpaceEngine(std::string programName, std::unique_ptr<WindowWrapper> windowWrapper);
~OpenSpaceEngine();
~OpenSpaceEngine() = default;
void clearAllWindows();
void gatherCommandlineArguments();
void loadFonts();
void runScripts(const ghoul::Dictionary& scripts);
void runPreInitializationScripts(const std::string& sceneDescription);
void configureLogging();
// Components
std::unique_ptr<ConfigurationManager> _configurationManager;
std::unique_ptr<interaction::InteractionHandler> _interactionHandler;
std::unique_ptr<RenderEngine> _renderEngine;
std::unique_ptr<scripting::ScriptEngine> _scriptEngine;
std::unique_ptr<scripting::ScriptScheduler> _scriptScheduler;
std::unique_ptr<NetworkEngine> _networkEngine;
std::unique_ptr<SyncEngine> _syncEngine;
std::unique_ptr<ghoul::cmdparser::CommandlineParser> _commandlineParser;
std::unique_ptr<DownloadManager> _downloadManager;
std::unique_ptr<LuaConsole> _console;
std::unique_ptr<ModuleEngine> _moduleEngine;
std::unique_ptr<SettingsEngine> _settingsEngine;
std::unique_ptr<TimeManager> _timeManager;
std::unique_ptr<DownloadManager> _downloadManager;
std::unique_ptr<NetworkEngine> _networkEngine;
std::unique_ptr<ParallelConnection> _parallelConnection;
std::unique_ptr<RenderEngine> _renderEngine;
std::unique_ptr<SettingsEngine> _settingsEngine;
std::unique_ptr<SyncEngine> _syncEngine;
std::unique_ptr<TimeManager> _timeManager;
std::unique_ptr<WindowWrapper> _windowWrapper;
std::unique_ptr<ghoul::cmdparser::CommandlineParser> _commandlineParser;
std::unique_ptr<ghoul::fontrendering::FontManager> _fontManager;
std::unique_ptr<interaction::InteractionHandler> _interactionHandler;
std::unique_ptr<scripting::ScriptEngine> _scriptEngine;
std::unique_ptr<scripting::ScriptScheduler> _scriptScheduler;
// Others
std::unique_ptr<properties::PropertyOwner> _globalPropertyNamespace;
@@ -241,24 +240,24 @@ private:
std::vector<std::function<bool (MouseButton, MouseAction)>> mouseButton;
std::vector<std::function<void (double, double)>> mousePosition;
std::vector<std::function<bool (double)>> mouseScrollWheel;
} _moduleCallbacks;
double _runTime;
// Whether the application is currently in shutdown mode (i.e. counting down the timer
// and closing it at '0'
bool _isInShutdownMode;
// The total amount of time the application will wait before actually shutting down
float _shutdownWait;
// The current state of the countdown; if it reaches '0', the application will close
float _shutdownCountdown;
// Structure that is responsible for the delayed shutdown of the application
struct {
// Whether the application is currently in shutdown mode (i.e. counting down the
// timer and closing it at '0'
bool inShutdown;
// Total amount of time the application will wait before actually shutting down
float waitTime;
// Current state of the countdown; if it reaches '0', the application will
// close
float timer;
} _shutdown;
// The first frame might take some more time in the update loop, so we need to know to
// disable the synchronization; otherwise a hardware sync will kill us after 1 sec
// disable the synchronization; otherwise a hardware sync will kill us after 1 minute
bool _isFirstRenderingFirstFrame;
static OpenSpaceEngine* _engine;

2
include/openspace/rendering/renderengine.h
View File

@@ -100,7 +100,7 @@ public:
void updateFade();
void updateRenderer();
void updateScreenSpaceRenderables();
void render(const glm::mat4& projectionMatrix, const glm::mat4& viewMatrix);
void render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix);
void renderScreenLog();
void renderShutdownInformation(float timer, float fullTime);

466
src/engine/openspaceengine.cpp
View File

@@ -69,6 +69,7 @@
#include <ghoul/lua/lua_helper.h>
#include <ghoul/lua/luastate.h>
#include <ghoul/misc/dictionary.h>
#include <ghoul/misc/exception.h>
#include <ghoul/misc/onscopeexit.h>
#include <ghoul/systemcapabilities/systemcapabilities>
@@ -91,14 +92,13 @@ using namespace ghoul::logging;
using namespace ghoul::cmdparser;
namespace {
const std::string _loggerCat = "OpenSpaceEngine";
const std::string _sgctDefaultConfigFile = "${SGCT}/single.xml";
const std::string _defaultCacheLocation = "${BASE_PATH}/cache";
const char* _loggerCat = "OpenSpaceEngine";
const char* SgctDefaultConfigFile = "${SGCT}/single.xml";
const std::string _sgctConfigArgumentCommand = "-config";
const char* SgctConfigArgumentCommand = "-config";
const std::string PreInitializeFunction = "preInitialization";
const std::string PostInitializationFunction = "postInitialization";
const char* PreInitializeFunction = "preInitialization";
const char* PostInitializationFunction = "postInitialization";
const int CacheVersion = 1;
const int DownloadVersion = 1;
@@ -140,9 +140,7 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
, _windowWrapper(std::move(windowWrapper))
, _globalPropertyNamespace(new properties::PropertyOwner)
, _runTime(0.0)
, _isInShutdownMode(false)
, _shutdownCountdown(0.f)
, _shutdownWait(0.f)
, _shutdown({false, 0.f, 0.f})
, _isFirstRenderingFirstFrame(true)
{
_interactionHandler->setPropertyOwner(_globalPropertyNamespace.get());
@@ -173,34 +171,36 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
TransformationManager::initialize();
}
OpenSpaceEngine::~OpenSpaceEngine() {
_globalPropertyNamespace = nullptr;
_windowWrapper = nullptr;
_parallelConnection = nullptr;
_configurationManager = nullptr;
_interactionHandler = nullptr;
_renderEngine = nullptr;
_scriptEngine = nullptr;
_networkEngine = nullptr;
_syncEngine = nullptr;
_commandlineParser = nullptr;
_console = nullptr;
_moduleEngine = nullptr;
_settingsEngine = nullptr;
}
//OpenSpaceEngine::~OpenSpaceEngine() {
// _globalPropertyNamespace = nullptr;
// _windowWrapper = nullptr;
// _parallelConnection = nullptr;
// _configurationManager = nullptr;
// _interactionHandler = nullptr;
// _renderEngine = nullptr;
// _scriptEngine = nullptr;
// _networkEngine = nullptr;
// _syncEngine = nullptr;
// _commandlineParser = nullptr;
// _console = nullptr;
// _moduleEngine = nullptr;
// _settingsEngine = nullptr;
//}
OpenSpaceEngine& OpenSpaceEngine::ref() {
ghoul_assert(_engine, "OpenSpaceEngine not created");
return *_engine;
}
bool OpenSpaceEngine::create(int argc, char** argv,
void OpenSpaceEngine::create(int argc, char** argv,
std::unique_ptr<WindowWrapper> windowWrapper,
std::vector<std::string>& sgctArguments)
std::vector<std::string>& sgctArguments, bool& requestClose)
{
ghoul_assert(!_engine, "OpenSpaceEngine was already created");
ghoul_assert(windowWrapper != nullptr, "No Window Wrapper was provided");
requestClose = false;
ghoul::initialize();
// Initialize the LogManager and add the console log as this will be used every time
@@ -225,8 +225,10 @@ bool OpenSpaceEngine::create(int argc, char** argv,
// Sanity check of values
if (argc < 1 || argv == nullptr) {
LFATAL("No arguments were passed to this function");
return false;
throw ghoul::RuntimeError(
"No arguments were passed to this function",
"OpenSpaceEngine"
);
}
// Create other objects
@@ -244,7 +246,8 @@ bool OpenSpaceEngine::create(int argc, char** argv,
bool showHelp = _engine->_commandlineParser->execute();
if (showHelp) {
_engine->_commandlineParser->displayHelp();
return false;
requestClose = true;
return;
}
sgctArguments = *arguments;
@@ -252,13 +255,8 @@ bool OpenSpaceEngine::create(int argc, char** argv,
std::string configurationFilePath = commandlineArgumentPlaceholders.configurationName;
if (configurationFilePath.empty()) {
LDEBUG("Finding configuration");
try {
configurationFilePath =
ConfigurationManager::findConfiguration(configurationFilePath);
}
catch (const ghoul::RuntimeError& e) {
LFATALC(e.component, e.message);
}
configurationFilePath =
ConfigurationManager::findConfiguration(configurationFilePath);
}
configurationFilePath = absPath(configurationFilePath);
LINFO("Configuration Path: '" << configurationFilePath << "'");
@@ -276,22 +274,21 @@ bool OpenSpaceEngine::create(int argc, char** argv,
for (const documentation::TestResult::Warning& w : e.result.warnings) {
LWARNINGC(w.offender, std::to_string(w.reason));
}
return false;
throw;
}
catch (const ghoul::RuntimeError& e) {
LFATAL("Loading of configuration file '" << configurationFilePath << "' failed");
LFATALC(e.component, e.message);
return false;
throw;
}
bool hasCacheCommandline = !commandlineArgumentPlaceholders.cacheFolder.empty();
bool hasCacheConfiguration = _engine->configurationManager().hasKeyAndValue<bool>(
const bool hasCacheCommandline = !commandlineArgumentPlaceholders.cacheFolder.empty();
const bool hasCacheConfiguration = _engine->configurationManager().hasKeyAndValue<bool>(
ConfigurationManager::KeyPerSceneCache
);
std::string cacheFolder = absPath("${CACHE}");
if (hasCacheCommandline) {
cacheFolder = commandlineArgumentPlaceholders.cacheFolder;
// @CLEANUP: Why is this commented out? ---abock
//FileSys.registerPathToken(
// "${CACHE}",
// commandlineArgumentPlaceholders.cacheFolder,
@@ -321,7 +318,9 @@ bool OpenSpaceEngine::create(int argc, char** argv,
LINFOC("OpenSpace Version",
OPENSPACE_VERSION_MAJOR << "." <<
OPENSPACE_VERSION_MINOR << "." <<
OPENSPACE_VERSION_PATCH << " (" << OPENSPACE_VERSION_STRING << ")");
OPENSPACE_VERSION_PATCH <<
" (" << OPENSPACE_VERSION_STRING << ")"
);
// Create directories that doesn't exist
auto tokens = FileSys.tokens();
@@ -356,7 +355,7 @@ bool OpenSpaceEngine::create(int argc, char** argv,
// Determining SGCT configuration file
LDEBUG("Determining SGCT configuration file");
std::string sgctConfigurationPath = _sgctDefaultConfigFile;
std::string sgctConfigurationPath = SgctDefaultConfigFile;
_engine->configurationManager().getValue(
ConfigurationManager::KeyConfigSgct, sgctConfigurationPath);
@@ -369,13 +368,12 @@ bool OpenSpaceEngine::create(int argc, char** argv,
// Prepend the outgoing sgctArguments with the program name
// as well as the configuration file that sgct is supposed to use
sgctArguments.insert(sgctArguments.begin(), argv[0]);
sgctArguments.insert(sgctArguments.begin() + 1, _sgctConfigArgumentCommand);
sgctArguments.insert(sgctArguments.begin() + 1, SgctConfigArgumentCommand);
sgctArguments.insert(sgctArguments.begin() + 2, absPath(sgctConfigurationPath));
return true;
}
void OpenSpaceEngine::destroy() {
LTRACE("OpenSpaceEngine::destroy(begin)");
for (const auto& func : _engine->_moduleCallbacks.deinitializeGL) {
func();
}
@@ -398,9 +396,11 @@ void OpenSpaceEngine::destroy() {
LogManager::deinitialize();
ghoul::deinitialize();
LTRACE("OpenSpaceEngine::destroy(end)");
}
bool OpenSpaceEngine::initialize() {
void OpenSpaceEngine::initialize() {
LTRACE("OpenSpaceEngine::initialize(begin)");
// clear the screen so the user don't have to see old buffer contents from the
// graphics card
LDEBUG("Clearing all Windows");
@@ -420,19 +420,22 @@ bool OpenSpaceEngine::initialize() {
using Verbosity = ghoul::systemcapabilities::SystemCapabilitiesComponent::Verbosity;
Verbosity verbosity = Verbosity::Default;
if (configurationManager().hasKeyAndValue<std::string>(
ConfigurationManager::KeyCapabilitiesVerbosity))
{
std::map<std::string, Verbosity> verbosityMap = {
if (configurationManager().hasKey(ConfigurationManager::KeyCapabilitiesVerbosity)) {
static const std::map<std::string, Verbosity> VerbosityMap = {
{ "None", Verbosity::None },
{ "Minimal", Verbosity::Minimal },
{ "Default", Verbosity::Default },
{ "Full", Verbosity::Full }
};
std::string v = configurationManager().value<std::string>(ConfigurationManager::KeyCapabilitiesVerbosity);
if (verbosityMap.find(v) != verbosityMap.end())
verbosity = verbosityMap[v];
std::string v = configurationManager().value<std::string>(
ConfigurationManager::KeyCapabilitiesVerbosity
);
ghoul_assert(
VerbosityMap.find(v) != VerbosityMap.end(),
"Missing check for syscaps verbosity in openspace.cfg documentation"
);
verbosity = VerbosityMap.find(v)->second;
}
SysCap.logCapabilities(verbosity);
@@ -442,14 +445,21 @@ bool OpenSpaceEngine::initialize() {
LINFO("Required OpenGL version: " << version.toString());
if (OpenGLCap.openGLVersion() < version) {
LFATAL("Module required higher OpenGL version than is supported");
return false;
throw ghoul::RuntimeError(
"Module required higher OpenGL version than is supported",
"OpenSpaceEngine"
);
}
std::string requestURL = "";
bool success = configurationManager().getValue(ConfigurationManager::KeyDownloadRequestURL, requestURL);
if (success) {
_downloadManager = std::make_unique<DownloadManager>(requestURL, DownloadVersion);
if (configurationManager().hasKey(ConfigurationManager::KeyDownloadRequestURL)) {
const std::string requestUrl = configurationManager().value<std::string>(
ConfigurationManager::KeyDownloadRequestURL
);
_downloadManager = std::make_unique<DownloadManager>(
requestUrl,
DownloadVersion
);
}
// Register Lua script functions
@@ -465,19 +475,25 @@ bool OpenSpaceEngine::initialize() {
writeDocumentation();
bool disableMasterRendering = false;
configurationManager().getValue(
ConfigurationManager::KeyDisableMasterRendering, disableMasterRendering);
_renderEngine->setDisableRenderingOnMaster(disableMasterRendering);
if (configurationManager().hasKey(ConfigurationManager::KeyDisableMasterRendering)) {
const bool disableMasterRendering = configurationManager().value<bool>(
ConfigurationManager::KeyDisableMasterRendering
);
_renderEngine->setDisableRenderingOnMaster(disableMasterRendering);
}
configurationManager().getValue(
ConfigurationManager::KeyShutdownCountdown, _shutdownWait
);
if (configurationManager().hasKey(ConfigurationManager::KeyShutdownCountdown)) {
_shutdown.waitTime = configurationManager().value<double>(
ConfigurationManager::KeyShutdownCountdown
);
}
if (!commandlineArgumentPlaceholders.sceneName.empty())
if (!commandlineArgumentPlaceholders.sceneName.empty()) {
configurationManager().setValue(
ConfigurationManager::KeyConfigScene,
commandlineArgumentPlaceholders.sceneName);
commandlineArgumentPlaceholders.sceneName
);
}
// Initialize the SettingsEngine
_settingsEngine->initialize();
@@ -490,6 +506,8 @@ bool OpenSpaceEngine::initialize() {
loadFonts();
// Initialize the Scene
// @CLEANUP: This should become a unique_ptr that is either created inside the
// renderengine or moved into it ---abock
Scene* sceneGraph = new Scene;
sceneGraph->initialize();
@@ -508,24 +526,23 @@ bool OpenSpaceEngine::initialize() {
}
// Run start up scripts
try {
runPreInitializationScripts(scenePath);
}
catch (const ghoul::RuntimeError& e) {
LFATALC(e.component, e.message);
}
runPreInitializationScripts(scenePath);
_syncEngine->addSyncables(Time::ref().getSyncables());
_syncEngine->addSyncables(_renderEngine->getSyncables());
_syncEngine->addSyncable(_scriptEngine.get());
LINFO("Finished initializing");
return true;
LTRACE("OpenSpaceEngine::initialize(end)");
}
void OpenSpaceEngine::deinitialize() {
LTRACE("OpenSpaceEngine::deinitialize(begin)");
_interactionHandler->deinitialize();
_renderEngine->deinitialize();
LTRACE("OpenSpaceEngine::deinitialize(end)");
}
void OpenSpaceEngine::writeDocumentation() {
@@ -538,13 +555,17 @@ void OpenSpaceEngine::writeDocumentation() {
const bool hasLuaDocType = configurationManager().hasKey(LuaDocumentationType);
const bool hasLuaDocFile = configurationManager().hasKey(LuaDocumentationFile);
if (hasLuaDocType && hasLuaDocFile) {
std::string luaDocumentationType;
configurationManager().getValue(LuaDocumentationType, luaDocumentationType);
std::string luaDocumentationFile;
configurationManager().getValue(LuaDocumentationFile, luaDocumentationFile);
std::string luaDocumentationType = configurationManager().value<std::string>(
LuaDocumentationType
);
std::string luaDocumentationFile = configurationManager().value<std::string>(
LuaDocumentationFile
);
luaDocumentationFile = absPath(luaDocumentationFile);
_scriptEngine->writeDocumentation(luaDocumentationFile, luaDocumentationType);
_scriptEngine->writeDocumentation(
absPath(luaDocumentationFile),
luaDocumentationType
);
}
// If a general documentation was specified, generate it now
@@ -556,24 +577,40 @@ void OpenSpaceEngine::writeDocumentation() {
const bool hasDocumentationType = configurationManager().hasKey(DocumentationType);
const bool hasDocumentationFile = configurationManager().hasKey(DocumentationFile);
if (hasDocumentationType && hasDocumentationFile) {
std::string documentationType;
configurationManager().getValue(DocumentationType, documentationType);
std::string documentationFile;
configurationManager().getValue(DocumentationFile, documentationFile);
documentationFile = absPath(documentationFile);
DocEng.writeDocumentation(documentationFile, documentationType);
std::string documentationType = configurationManager().value<std::string>(
DocumentationType
);
std::string documentationFile = configurationManager().value<std::string>(
DocumentationFile
);
DocEng.writeDocumentation(
absPath(documentationFile),
documentationType
);
}
const std::string FactoryDocumentationType =
ConfigurationManager::KeyFactoryDocumentation + '.' + ConfigurationManager::PartType;
ConfigurationManager::KeyFactoryDocumentation + '.' +
ConfigurationManager::PartType;
const std::string FactoryDocumentationFile =
ConfigurationManager::KeyFactoryDocumentation + '.' + ConfigurationManager::PartFile;
bool hasFactoryDocumentationType = configurationManager().hasKey(FactoryDocumentationType);
bool hasFactoryDocumentationFile = configurationManager().hasKey(FactoryDocumentationFile);
ConfigurationManager::KeyFactoryDocumentation + '.' +
ConfigurationManager::PartFile;
bool hasFactoryDocumentationType = configurationManager().hasKey(
FactoryDocumentationType
);
bool hasFactoryDocumentationFile = configurationManager().hasKey(
FactoryDocumentationFile
);
if (hasFactoryDocumentationType && hasFactoryDocumentationFile) {
std::string type = configurationManager().value<std::string>(FactoryDocumentationType);
std::string file = configurationManager().value<std::string>(FactoryDocumentationFile);
std::string type = configurationManager().value<std::string>(
FactoryDocumentationType
);
std::string file = configurationManager().value<std::string>(
FactoryDocumentationFile
);
FactoryManager::ref().writeDocumentation(absPath(file), type);
}
@@ -615,27 +652,8 @@ void OpenSpaceEngine::gatherCommandlineArguments() {
));
}
void OpenSpaceEngine::runScripts(const ghoul::Dictionary& scripts) {
for (size_t i = 1; i <= scripts.size(); ++i) {
std::stringstream stream;
stream << i;
const std::string& key = stream.str();
const bool hasKey = scripts.hasKeyAndValue<std::string>(key);
if (!hasKey) {
LERROR("The startup scripts have to be declared in a simple array format."
" Startup scripts did not contain the key '" << key << "'");
break;
}
std::string scriptPath;
scripts.getValue(key, scriptPath);
std::string&& absoluteScriptPath = absPath(scriptPath);
_engine->scriptEngine().runScriptFile(absoluteScriptPath);
}
}
void OpenSpaceEngine::runPreInitializationScripts(const std::string& sceneDescription) {
// @CLEANUP: Move this into the scene loading? ---abock
LINFO("Running Initialization scripts");
ghoul::lua::LuaState state;
@@ -645,24 +663,29 @@ void OpenSpaceEngine::runPreInitializationScripts(const std::string& sceneDescri
ghoul::lua::runScriptFile(state, absPath(sceneDescription));
// Get the preinitialize function
lua_getglobal(state, PreInitializeFunction.c_str());
lua_getglobal(state, PreInitializeFunction);
bool isFunction = lua_isfunction(state, -1);
if (!isFunction) {
LERROR("Error executing startup script '" << sceneDescription << "'. Scene '" <<
sceneDescription << "' does not have a function '" <<
PreInitializeFunction << "'");
LERROR(
"Error executing startup script '" << sceneDescription << "'. Scene '" <<
sceneDescription << "' does not have a function '" <<
PreInitializeFunction << "'"
);
return;
}
// And execute the preinitialize function
int success = lua_pcall(state, 0, 0, 0);
if (success != 0) {
LERROR("Error executing '" << PreInitializeFunction << "': " <<
lua_tostring(state, -1));
LERROR(
"Error executing '" << PreInitializeFunction << "': " <<
lua_tostring(state, -1)
);
}
}
void OpenSpaceEngine::runPostInitializationScripts(const std::string& sceneDescription) {
// @CLEANUP: Move this into the scene loading? ---abock
LINFO("Running Setup scripts");
ghoul::lua::LuaState state;
OsEng.scriptEngine().initializeLuaState(state);
@@ -671,20 +694,23 @@ void OpenSpaceEngine::runPostInitializationScripts(const std::string& sceneDescr
ghoul::lua::runScriptFile(state, absPath(sceneDescription));
// Get the preinitialize function
lua_getglobal(state, PostInitializationFunction.c_str());
lua_getglobal(state, PostInitializationFunction);
bool isFunction = lua_isfunction(state, -1);
if (!isFunction) {
LERROR("Error executing startup script '" << sceneDescription << "'. Scene '" <<
sceneDescription << "' does not have a function '" <<
PostInitializationFunction << "'");
LERROR(
"Error executing startup script '" << sceneDescription << "'. Scene '" <<
sceneDescription << "' does not have a function '" <<
PostInitializationFunction << "'"
);
return;
}
// And execute the preinitialize function
int success = lua_pcall(state, 0, 0, 0);
if (success != 0) {
LERROR("Error executing '" << PostInitializationFunction << "': " <<
lua_tostring(state, -1)
LERROR(
"Error executing '" << PostInitializationFunction << "': " <<
lua_tostring(state, -1)
);
}
}
@@ -693,12 +719,11 @@ void OpenSpaceEngine::loadFonts() {
ghoul::Dictionary fonts;
configurationManager().getValue(ConfigurationManager::KeyFonts, fonts);
const glm::ivec3 fontAtlasSize{1024, 1024, 1};
glm::ivec3 fontAtlasSize{1024, 1024, 1};
_fontManager = std::make_unique<ghoul::fontrendering::FontManager>(fontAtlasSize);
for (const std::string& key : fonts.keys()) {
std::string font;
fonts.getValue(key, font);
std::string font = fonts.value<std::string>(key);
font = absPath(font);
if (!FileSys.fileExists(font)) {
@@ -736,7 +761,7 @@ void OpenSpaceEngine::configureLogging() {
ConfigurationManager::KeyLogging + '.' + ConfigurationManager::PartLogs;
if (configurationManager().hasKeyAndValue<std::string>(KeyLogLevel)) {
std::string logLevel;
std::string logLevel = "Info";
configurationManager().getValue(KeyLogLevel, logLevel);
bool immediateFlush = false;
@@ -749,16 +774,15 @@ void OpenSpaceEngine::configureLogging() {
level,
immediateFlush ? ImmediateFlush::Yes : ImmediateFlush::No
);
LogMgr.addLog(std::make_unique<ConsoleLog>());
}
if (configurationManager().hasKeyAndValue<ghoul::Dictionary>(KeyLogs)) {
ghoul::Dictionary logs;
configurationManager().getValue(KeyLogs, logs);
ghoul::Dictionary logs = configurationManager().value<ghoul::Dictionary>(KeyLogs);
for (size_t i = 1; i <= logs.size(); ++i) {
ghoul::Dictionary logInfo;
logs.getValue(std::to_string(i), logInfo);
ghoul::Dictionary logInfo = logs.value<ghoul::Dictionary>(std::to_string(i));
try {
LogMgr.addLog(createLog(logInfo));
@@ -776,19 +800,24 @@ void OpenSpaceEngine::configureLogging() {
#endif // WIN32
#ifndef GHOUL_LOGGING_ENABLE_TRACE
std::string logLevel;
std::string logLevel = "Info";
configurationManager().getValue(KeyLogLevel, logLevel);
LogLevel level = ghoul::logging::levelFromString(logLevel);
if (level == ghoul::logging::LogLevel::Trace) {
LWARNING("Desired logging level is set to 'Trace' but application was " <<
"compiled without Trace support");
LWARNING(
"Desired logging level is set to 'Trace' but application was " <<
"compiled without Trace support"
);
}
#endif // GHOUL_LOGGING_ENABLE_TRACE
}
bool OpenSpaceEngine::initializeGL() {
void OpenSpaceEngine::initializeGL() {
LTRACE("OpenSpaceEngine::initializeGL(begin)");
LINFO("Initializing Rendering Engine");
// @CLEANUP: Remove the return statement and replace with exceptions ---abock
bool success = _renderEngine->initializeGL();
for (const auto& func : _moduleCallbacks.initializeGL) {
@@ -797,10 +826,12 @@ bool OpenSpaceEngine::initializeGL() {
LINFO("Finished initializing OpenGL");
// If using swapgroups,
LINFO("_windowWrapper->isUsingSwapGroups(): " << _windowWrapper->isUsingSwapGroups());
LINFO("_windowWrapper->isSwapGroupMaster(): " << _windowWrapper->isSwapGroupMaster());
return success;
// If using swapgroups,
LINFO("IsUsingSwapGroups: " << _windowWrapper->isUsingSwapGroups());
LINFO("IsSwapGroupMaster: " << _windowWrapper->isSwapGroupMaster());
LTRACE("OpenSpaceEngine::initializeGL(end)");
}
double OpenSpaceEngine::runTime() {
@@ -812,6 +843,7 @@ void OpenSpaceEngine::setRunTime(double d) {
}
void OpenSpaceEngine::preSynchronization() {
LTRACE("OpenSpaceEngine::preSynchronization(begin)");
FileSys.triggerFilesystemEvents();
if (_isFirstRenderingFirstFrame) {
@@ -845,17 +877,20 @@ void OpenSpaceEngine::preSynchronization() {
for (const auto& func : _moduleCallbacks.preSync) {
func();
}
LTRACE("OpenSpaceEngine::preSynchronization(end)");
}
void OpenSpaceEngine::postSynchronizationPreDraw() {
LTRACE("OpenSpaceEngine::postSynchronizationPreDraw(begin)");
bool master = _windowWrapper->isMaster();
_syncEngine->postsync(master);
if (_isInShutdownMode) {
if (_shutdownCountdown <= 0.f) {
if (_shutdown.inShutdown) {
if (_shutdown.timer <= 0.f) {
_windowWrapper->terminate();
}
_shutdownCountdown -= _windowWrapper->averageDeltaTime();
_shutdown.timer -= _windowWrapper->averageDeltaTime();
}
_renderEngine->updateSceneGraph();
@@ -893,11 +928,15 @@ void OpenSpaceEngine::postSynchronizationPreDraw() {
}
LogMgr.resetMessageCounters();
LTRACE("OpenSpaceEngine::postSynchronizationPreDraw(end)");
}
void OpenSpaceEngine::render(const glm::mat4& projectionMatrix, const glm::mat4& viewMatrix) {
void OpenSpaceEngine::render(const glm::mat4& viewMatrix,
const glm::mat4& projectionMatrix)
{
LTRACE("OpenSpaceEngine::render(begin)");
_renderEngine->render(projectionMatrix, viewMatrix);
_renderEngine->render(viewMatrix, projectionMatrix);
for (const auto& func : _moduleCallbacks.render) {
func();
@@ -907,12 +946,16 @@ void OpenSpaceEngine::render(const glm::mat4& projectionMatrix, const glm::mat4&
}
void OpenSpaceEngine::postDraw() {
LTRACE("OpenSpaceEngine::postDraw(begin)");
_renderEngine->postDraw();
for (const auto& func : _moduleCallbacks.postDraw) {
func();
}
// @CLEANUP: Replace the two windows by a single call to whether a gui should be
// rendered ---abock
bool showGui = _windowWrapper->hasGuiWindow() ? _windowWrapper->isGuiWindow() : true;
if (showGui) {
_renderEngine->renderScreenLog();
@@ -920,8 +963,8 @@ void OpenSpaceEngine::postDraw() {
_console->render();
}
if (_isInShutdownMode) {
_renderEngine->renderShutdownInformation(_shutdownCountdown, _shutdownWait);
if (_shutdown.inShutdown) {
_renderEngine->renderShutdownInformation(_shutdown.timer, _shutdown.waitTime);
}
if (_isFirstRenderingFirstFrame) {
@@ -929,6 +972,7 @@ void OpenSpaceEngine::postDraw() {
_isFirstRenderingFirstFrame = false;
}
LTRACE("OpenSpaceEngine::postDraw(end)");
}
void OpenSpaceEngine::keyboardCallback(Key key, KeyModifier mod, KeyAction action) {
@@ -939,11 +983,15 @@ void OpenSpaceEngine::keyboardCallback(Key key, KeyModifier mod, KeyAction actio
}
}
// @CLEANUP: Remove the commandInputButton and replace with a method just based
// on Lua by binding a key to the Lua script toggling the console ---abock
if (key == _console->commandInputButton()) {
if (action == KeyAction::Press) {
_console->toggleMode();
}
} else if (!_console->isVisible()) {
// @CLEANUP: Make the interaction handler return whether a key has been consumed
// and then pass it on to the console ---abock
_interactionHandler->keyboardCallback(key, mod, action);
} else {
_console->keyboardCallback(key, mod, action);
@@ -1015,16 +1063,16 @@ void OpenSpaceEngine::externalControlCallback(const char* receivedChars, int siz
}
void OpenSpaceEngine::toggleShutdownMode() {
if (_isInShutdownMode) {
// If we are already in shutdown mode, we want to disable it instead
if (_shutdown.inShutdown) {
// If we are already in shutdown mode, we want to disable it
LINFO("Disabled shutdown mode");
_isInShutdownMode = false;
_shutdown.inShutdown = false;
}
else {
// Else, we hav eto enable it
// Else, we have to enable it
LINFO("Shutting down OpenSpace");
_shutdownCountdown = _shutdownWait;
_isInShutdownMode = true;
_shutdown.timer = _shutdown.waitTime;
_shutdown.inShutdown = true;
}
}
@@ -1049,14 +1097,6 @@ scripting::LuaLibrary OpenSpaceEngine::luaLibrary() {
};
}
bool OpenSpaceEngine::useBusyWaitForDecode() {
return _settingsEngine->busyWaitForDecode();
}
bool OpenSpaceEngine::logSGCTOutOfOrderErrors() {
return _settingsEngine->logSGCTOutOfOrderErrors();
}
void OpenSpaceEngine::enableBarrier() {
_windowWrapper->setBarrier(true);
}
@@ -1096,6 +1136,21 @@ void OpenSpaceEngine::registerModuleMouseScrollWheelCallback(
_moduleCallbacks.mouseScrollWheel.push_back(std::move(function));
}
ConfigurationManager& OpenSpaceEngine::configurationManager() {
ghoul_assert(_configurationManager, "ConfigurationManager must not be nullptr");
return *_configurationManager;
}
LuaConsole& OpenSpaceEngine::console() {
ghoul_assert(_console, "LuaConsole must not be nullptr");
return *_console;
}
DownloadManager& OpenSpaceEngine::downloadManager() {
ghoul_assert(_downloadManager, "Download Manager must not be nullptr");
return *_downloadManager;
}
NetworkEngine& OpenSpaceEngine::networkEngine() {
ghoul_assert(_networkEngine, "NetworkEngine must not be nullptr");
return *_networkEngine;
@@ -1106,9 +1161,34 @@ ModuleEngine& OpenSpaceEngine::moduleEngine() {
return *_moduleEngine;
}
ConfigurationManager& OpenSpaceEngine::configurationManager() {
ghoul_assert(_configurationManager, "ConfigurationManager must not be nullptr");
return *_configurationManager;
ParallelConnection& OpenSpaceEngine::parallelConnection() {
ghoul_assert(_parallelConnection, "ParallelConnection must not be nullptr");
return *_parallelConnection;
}
RenderEngine& OpenSpaceEngine::renderEngine() {
ghoul_assert(_renderEngine, "RenderEngine must not be nullptr");
return *_renderEngine;
}
SettingsEngine& OpenSpaceEngine::settingsEngine() {
ghoul_assert(_settingsEngine, "Settings Engine must not be nullptr");
return *_settingsEngine;
}
TimeManager& OpenSpaceEngine::timeManager() {
ghoul_assert(_timeManager, "Download Manager must not be nullptr");
return *_timeManager;
}
WindowWrapper& OpenSpaceEngine::windowWrapper() {
ghoul_assert(_windowWrapper, "Window Wrapper must not be nullptr");
return *_windowWrapper;
}
ghoul::fontrendering::FontManager& OpenSpaceEngine::fontManager() {
ghoul_assert(_fontManager, "Font Manager must not be nullptr");
return *_fontManager;
}
interaction::InteractionHandler& OpenSpaceEngine::interactionHandler() {
@@ -1116,31 +1196,6 @@ interaction::InteractionHandler& OpenSpaceEngine::interactionHandler() {
return *_interactionHandler;
}
RenderEngine& OpenSpaceEngine::renderEngine() {
ghoul_assert(_renderEngine, "RenderEngine must not be nullptr");
return *_renderEngine;
}
ScriptEngine& OpenSpaceEngine::scriptEngine() {
ghoul_assert(_scriptEngine, "ScriptEngine must not be nullptr");
return *_scriptEngine;
}
ScriptScheduler& OpenSpaceEngine::scriptScheduler(){
ghoul_assert(_scriptScheduler, "ScriptScheduler must not be nullptr");
return *_scriptScheduler;
}
LuaConsole& OpenSpaceEngine::console() {
ghoul_assert(_console, "LuaConsole must not be nullptr");
return *_console;
}
ParallelConnection& OpenSpaceEngine::parallelConnection() {
ghoul_assert(_parallelConnection, "ParallelConnection must not be nullptr");
return *_parallelConnection;
}
properties::PropertyOwner& OpenSpaceEngine::globalPropertyOwner() {
ghoul_assert(
_globalPropertyNamespace,
@@ -1149,29 +1204,14 @@ properties::PropertyOwner& OpenSpaceEngine::globalPropertyOwner() {
return *_globalPropertyNamespace;
}
WindowWrapper& OpenSpaceEngine::windowWrapper() {
ghoul_assert(_windowWrapper, "Window Wrapper must not be nullptr");
return *_windowWrapper;
}
ghoul::fontrendering::FontManager& OpenSpaceEngine::fontManager() {
ghoul_assert(_fontManager, "Font Manager must not be nullptr");
return *_fontManager;
ScriptEngine& OpenSpaceEngine::scriptEngine() {
ghoul_assert(_scriptEngine, "ScriptEngine must not be nullptr");
return *_scriptEngine;
}
DownloadManager& OpenSpaceEngine::downloadManager() {
ghoul_assert(_downloadManager, "Download Manager must not be nullptr");
return *_downloadManager;
}
TimeManager& OpenSpaceEngine::timeManager() {
ghoul_assert(_timeManager, "Download Manager must not be nullptr");
return *_timeManager;
}
SettingsEngine& OpenSpaceEngine::settingsEngine() {
ghoul_assert(_settingsEngine, "Settings Engine must not be nullptr");
return *_settingsEngine;
ScriptScheduler& OpenSpaceEngine::scriptScheduler() {
ghoul_assert(_scriptScheduler, "ScriptScheduler must not be nullptr");
return *_scriptScheduler;
}
} // namespace openspace

3
src/rendering/renderengine.cpp
View File

@@ -468,7 +468,8 @@ void RenderEngine::updateFade() {
}
}
void RenderEngine::render(const glm::mat4& projectionMatrix, const glm::mat4& viewMatrix){
void RenderEngine::render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix)
{
LTRACE("RenderEngine::render(begin)");
_mainCamera->sgctInternal.setViewMatrix(viewMatrix);
_mainCamera->sgctInternal.setProjectionMatrix(projectionMatrix);

3
tests/main.cpp
View File

@@ -83,7 +83,8 @@ namespace {
int main(int argc, char** argv) {
std::vector<std::string> args;
openspace::OpenSpaceEngine::create(argc, argv, std::make_unique<openspace::WindowWrapper>(), args);
bool close;
openspace::OpenSpaceEngine::create(argc, argv, std::make_unique<openspace::WindowWrapper>(), args, close);
testing::InitGoogleTest(&argc, argv);