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

Code review changes on new profile initialization

Browse Source
This commit is contained in:
GPayne
2021-09-16 23:11:02 -06:00
parent 5b63fff944
commit a4d84d8703
12 changed files with 131 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/openspace/engine/configuration.h
View File

@@ -45,7 +45,6 @@ struct Configuration {
std::string windowConfiguration = "${CONFIG}/single.xml";
std::string asset;
std::string profileOutPrefixName;
std::string profile;
std::vector<std::string> readOnlyProfiles;
std::vector<std::string> globalCustomizationScripts;
@@ -132,7 +131,6 @@ struct Configuration {
HTTPProxy httpProxy;
// Values not read from the openspace.cfg file
bool usingProfile = false;
std::string sgctConfigNameInitialized;
static documentation::Documentation Documentation;

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

@@ -102,61 +102,6 @@ public:
void writeStaticDocumentation();
void createUserDirectoriesIfNecessary();
/**
* Sets the camera position using the time contents of a profile. The function will
* set an absolute position or a go-to-geolocation command using the globebrowsing
* module.
* \param p The Profile to be read.
*/
void setFromProfile_camera(const Profile& p);
/**
* Sets the delta times using the delta time array from a profile.
*
* \param p The Profile to be read.
*/
void setFromProfile_deltaTimes(const Profile& p);
/**
* Reads a list of modules from a profile, and executes scripts based on whether or
* not the corresponding module is loaded.
*
* \param p The Profile to be read.
*/
void setFromProfile_modules(const Profile& p);
/**
* Registers actions from the contents of a profile.
*
* \param p The Profile to be read.
*/
void setFromProfile_actions(const Profile& p);
/**
* Registers keybindings from the contents of a profile.
*
* \param p The Profile to be read.
*/
void setFromProfile_keybindings(const Profile& p);
/**
* Reads list of nodes from profile to be marked as interesting nodes.
* If any nodes are listed, a script to mark these will be queued with the
* script engine.
*
* \param p The Profile to be read.
*/
void setFromProfile_markInterestingNodes(const Profile& p);
/**
* Reads list of "additional scripts" that are added to the profile to be run
* at the end of the initialization. Any openspace lua commands are allowed,
* and will be added to the script queue.
*
* \param p The Profile to be read.
*/
void setFromProfile_additionalScripts(const Profile& p);
/**
* Returns the Lua library that contains all Lua functions available to affect the
* application.
@@ -164,16 +109,13 @@ public:
static scripting::LuaLibrary luaLibrary();
private:
void loadAsset_init(const std::string assetName);
void loadAsset_postInit(const std::string assetName);
void loadAsset(const std::string& assetName);
void loadFonts();
void runGlobalCustomizationScripts();
void configureLogging();
std::string generateFilePath(std::string openspaceRelativePath);
void resetPropertyChangeFlagsOfSubowners(openspace::properties::PropertyOwner* po);
void loadInitAssetSection(std::string& initAssetOutput,
std::string profileSectionName);
std::unique_ptr<Scene> _scene;
std::unique_ptr<AssetManager> _assetManager;
@@ -183,7 +125,6 @@ private:
bool _hasScheduledAssetLoading = false;
std::string _scheduledAssetPathToLoad;
bool _hasInitializedProfile = false;
glm::vec2 _mousePosition = glm::vec2(0.f);
@@ -196,9 +137,57 @@ private:
// 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 minute
bool _isFirstRenderingFirstFrame = true;
bool _isRenderingFirstFrame = true;
};
/**
* Sets the camera position using the time contents of a profile. The function will
* set an absolute position or a go-to-geolocation command using the globebrowsing
* module.
* \param p The Profile to be read.
*/
void setCameraFromProfile(const Profile& p);
/**
* Reads a list of modules from a profile, and executes scripts based on whether or
* not the corresponding module is loaded.
*
* \param p The Profile to be read.
*/
void setModulesFromProfile(const Profile& p);
/**
* Registers actions from the contents of a profile.
*
* \param p The Profile to be read.
*/
void setActionsFromProfile(const Profile& p);
/**
* Registers keybindings from the contents of a profile.
*
* \param p The Profile to be read.
*/
void setKeybindingsFromProfile(const Profile& p);
/**
* Reads list of nodes from profile to be marked as interesting nodes.
* If any nodes are listed, a script to mark these will be queued with the
* script engine.
*
* \param p The Profile to be read.
*/
void setMarkInterestingNodesFromProfile(const Profile& p);
/**
* Reads list of "additional scripts" that are added to the profile to be run
* at the end of the initialization. Any openspace lua commands are allowed,
* and will be added to the script queue.
*
* \param p The Profile to be read.
*/
void setAdditionalScriptsFromProfile(const Profile& p);
} // namespace openspace
// Lua functions - exposed for testing

12
include/openspace/scene/profile.h
View File

@@ -163,20 +163,8 @@ public:
* \return The Lua library that contains all Lua functions available for profiles
*/
static scripting::LuaLibrary luaLibrary();
std::string file_subName_assets = "";
std::string assetFileExtension = ".asset";
};
/**
* Function to retrieve the individual additional script lines included in the profile
*
* \param p The profile that should be processed
*
* \return vector of strings containing the individual script lines
*/
std::vector<std::string>& additionalScripts(Profile& p);
} // namespace openspace
#endif // __OPENSPACE_CORE___PROFILE___H__

22
include/openspace/scene/scene.h
View File

@@ -243,17 +243,7 @@ public:
*
* \param p The Profile to be read.
*/
void setFromProfile_properties(const Profile& p);
/**
* Accepts string version of a property value from a profile, converts it to the
* appropriate type, and then pushes the value onto the lua state.
*
* \param L the lua state to push value to
* \param value string representation of the value with which to set property
*/
void property_pushValueFromProfileToLuaState(ghoul::lua::LuaState& L,
const std::string& value);
void setPropertiesFromProfile(const Profile& p);
private:
/**
@@ -289,6 +279,16 @@ private:
ghoul::MemoryPool<4096> _memoryPool;
};
/**
* Accepts string version of a property value from a profile, converts it to the
* appropriate type, and then pushes the value onto the lua state.
*
* \param L the lua state to push value to
* \param value string representation of the value with which to set property
*/
void propertyPushValueFromProfileToLuaState(ghoul::lua::LuaState& L,
const std::string& value);
} // namespace openspace
#endif // __OPENSPACE_CORE___SCENE___H__

4
include/openspace/util/time.h
View File

@@ -146,14 +146,14 @@ public:
* \param setTime a string containing time adjustment as described in documentation
* for luascriptfunctions::time_advancedTime
*/
void setFromProfile_timeRelative(const std::string& setTime);
void setTimeRelativeFromProfile(const std::string& setTime);
/**
* Sets an absolute time from profile.
* \param setTime a string containing time to set, which must be a valid
* ISO 8601-like date string of the format YYYY-MM-DDTHH:MN:SS
*/
void setFromProfile_timeAbsolute(const std::string& setTime);
void setTimeAbsoluteFromProfile(const std::string& setTime);
/**
* Returns the Lua library that contains all Lua functions available to change the

2
include/openspace/util/timemanager.h
View File

@@ -85,7 +85,7 @@ public:
*
* \param p The Profile to be read.
*/
void setFromProfile_time(const Profile& p);
void setTimeFromProfile(const Profile& p);
bool isPaused() const;

131
src/engine/openspaceengine.cpp
View File

@@ -305,8 +305,6 @@ void OpenSpaceEngine::initialize() {
+ ".profile";
std::string inputUserProfile = absPath("${USER_PROFILES}").string() + "/" +
global::configuration->profile + ".profile";
std::string outputProfilePrefix = outputScenePath + "/"
+ global::configuration->profile;
if (std::filesystem::is_regular_file(inputUserProfile)) {
inputProfile = inputUserProfile;
@@ -335,9 +333,6 @@ void OpenSpaceEngine::initialize() {
std::istreambuf_iterator<char>()
);
*global::profile = Profile(content);
global::configuration->profileOutPrefixName = outputProfilePrefix;
global::configuration->usingProfile = true;
}
}
@@ -689,10 +684,10 @@ void OpenSpaceEngine::scheduleLoadSingleAsset(std::string assetPath) {
_scheduledAssetPathToLoad = std::move(assetPath);
}
void OpenSpaceEngine::loadAsset_init(const std::string assetName) {
void OpenSpaceEngine::loadAsset(const std::string& assetName) {
ZoneScoped
LTRACE("OpenSpaceEngine::loadAsset_init(begin)");
LTRACE("OpenSpaceEngine::loadAsset(begin)");
global::windowDelegate->setBarrier(false);
global::windowDelegate->setSynchronization(false);
@@ -752,7 +747,7 @@ void OpenSpaceEngine::loadAsset_init(const std::string assetName) {
if (!assetName.empty()) {
_assetManager->add(assetName);
}
for (auto a : global::profile->assets) {
for (const std::string& a : global::profile->assets) {
_assetManager->add(a);
}
@@ -866,16 +861,7 @@ void OpenSpaceEngine::loadAsset_init(const std::string assetName) {
_writeDocumentationTask = std::async(&OpenSpaceEngine::writeSceneDocumentation, this);
LTRACE("OpenSpaceEngine::loadAsset_init(end)");
}
void OpenSpaceEngine::loadAsset_postInit(const std::string assetName) {
ZoneScoped
LTRACE("OpenSpaceEngine::loadAsset_postInit(begin)");
_assetManager->add(assetName);
_assetManager->update();
LTRACE("OpenSpaceEngine::loadAsset_postInit(end)");
LTRACE("OpenSpaceEngine::loadAsset(end)");
}
void OpenSpaceEngine::deinitialize() {
@@ -1110,27 +1096,24 @@ void OpenSpaceEngine::preSynchronization() {
if (_hasScheduledAssetLoading) {
LINFO(fmt::format("Loading asset: {}", absPath(_scheduledAssetPathToLoad)));
global::profile->ignoreUpdates = true;
loadAsset_init(_scheduledAssetPathToLoad);
loadAsset(_scheduledAssetPathToLoad);
global::profile->ignoreUpdates = false;
resetPropertyChangeFlagsOfSubowners(global::rootPropertyOwner);
_hasScheduledAssetLoading = false;
_scheduledAssetPathToLoad.clear();
}
else if (!_hasInitializedProfile) {
else if (_isRenderingFirstFrame) {
global::profile->ignoreUpdates = true;
loadAsset_init("");
global::renderEngine->scene()->setFromProfile_properties(*global::profile);
global::timeManager->setFromProfile_time(*global::profile);
setFromProfile_deltaTimes(*global::profile);
setFromProfile_actions(*global::profile);
setFromProfile_keybindings(*global::profile);
setFromProfile_modules(*global::profile);
setFromProfile_markInterestingNodes(*global::profile);
loadAsset("");
global::renderEngine->scene()->setPropertiesFromProfile(*global::profile);
global::timeManager->setTimeFromProfile(*global::profile);
global::timeManager->setDeltaTimeSteps(global::profile->deltaTimes);
setActionsFromProfile(*global::profile);
setKeybindingsFromProfile(*global::profile);
setModulesFromProfile(*global::profile);
setMarkInterestingNodesFromProfile(*global::profile);
global::profile->ignoreUpdates = false;
resetPropertyChangeFlagsOfSubowners(global::rootPropertyOwner);
}
if (_isFirstRenderingFirstFrame) {
global::windowDelegate->setSynchronization(false);
}
@@ -1175,29 +1158,13 @@ void OpenSpaceEngine::preSynchronization() {
func();
}
if (!_hasInitializedProfile) {
setFromProfile_camera(*global::profile);
setFromProfile_additionalScripts(*global::profile);
_hasInitializedProfile = true;
if (_isRenderingFirstFrame) {
setCameraFromProfile(*global::profile);
setAdditionalScriptsFromProfile(*global::profile);
}
LTRACE("OpenSpaceEngine::preSynchronization(end)");
}
void OpenSpaceEngine::loadInitAssetSection(std::string& initAssetOutput,
std::string profileSectionName)
{
std::string filename = fmt::format(
"{}_{}{}",
global::configuration->profileOutPrefixName,
profileSectionName,
global::profile->assetFileExtension
);
std::ifstream in(filename);
initAssetOutput.append(std::string(std::istreambuf_iterator<char>(in),
std::istreambuf_iterator<char>()));
LINFO(fmt::format("Loading profile subsection {}", profileSectionName));
}
void OpenSpaceEngine::postSynchronizationPreDraw() {
ZoneScoped
TracyGpuZone("postSynchronizationPreDraw")
@@ -1223,7 +1190,6 @@ void OpenSpaceEngine::postSynchronizationPreDraw() {
_shutdown.timer -= static_cast<float>(global::windowDelegate->averageDeltaTime());
}
const bool updated = _assetManager->update();
if (updated) {
if (_writeDocumentationTask.valid()) {
@@ -1337,10 +1303,10 @@ void OpenSpaceEngine::postDraw() {
func();
}
if (_isFirstRenderingFirstFrame) {
if (_isRenderingFirstFrame) {
global::windowDelegate->setSynchronization(true);
resetPropertyChangeFlags();
_isFirstRenderingFirstFrame = false;
_isRenderingFirstFrame = false;
}
global::memoryManager->PersistentMemory.housekeeping();
@@ -1584,7 +1550,7 @@ void OpenSpaceEngine::toggleShutdownMode() {
}
}
void OpenSpaceEngine::setFromProfile_camera(const Profile& p) {
void setCameraFromProfile(const Profile& p) {
std::visit(
overloaded{
[](const Profile::CameraNavState& navStateProfile) {
@@ -1609,6 +1575,10 @@ void OpenSpaceEngine::setFromProfile_camera(const Profile& p) {
global::navigationHandler->setNavigationStateNextFrame(nav);
},
[](const Profile::CameraGoToGeo& geo) {
//Instead of direct calls to navigation state code, lua commands with
//globebrowsing goToGeo are used because this prevents a module
//dependency in this core code. Eventually, goToGeo will be incorporated
//in the OpenSpace core and this code will change.
std::string geoScript = fmt::format("openspace.globebrowsing.goToGeo"
"([[{}]], {}, {}", geo.anchor, geo.latitude, geo.longitude);
if (geo.altitude.has_value()) {
@@ -1625,17 +1595,12 @@ void OpenSpaceEngine::setFromProfile_camera(const Profile& p) {
);
}
void OpenSpaceEngine::setFromProfile_deltaTimes(const Profile& p) {
global::timeManager->setDeltaTimeSteps(p.deltaTimes);
}
void OpenSpaceEngine::setFromProfile_modules(const Profile& p)
{
void setModulesFromProfile(const Profile& p) {
for (Profile::Module mod : p.modules) {
const std::vector<OpenSpaceModule*>& m = global::moduleEngine->modules();
const auto it = std::find_if(m.begin(), m.end(),
[&mod](const OpenSpaceModule* moduleSearch) {
return (moduleSearch->identifier().compare(mod.name) == 0);
return (moduleSearch->identifier() == mod.name);
});
if (it != m.end()) {
if (mod.loadedInstruction.has_value()) {
@@ -1656,39 +1621,35 @@ void OpenSpaceEngine::setFromProfile_modules(const Profile& p)
}
}
void OpenSpaceEngine::setFromProfile_actions(const Profile& p)
{
void setActionsFromProfile(const Profile& p) {
for (Profile::Action a : p.actions) {
if (a.identifier.empty()) {
LERROR("Identifier must to provided to register action");
}
if (global::actionManager->hasAction(a.identifier)) {
LERROR(fmt::format("Action for identifier '{}' already existed & registered",
a.identifier));
LERROR(
fmt::format("Action for identifier '{}' already existed & registered",
a.identifier)
);
}
if (a.script.empty()) {
LERROR(fmt::format("Identifier '{}' doesn't provide a Lua command to execute",
a.identifier));
LERROR(
fmt::format("Identifier '{}' doesn't provide a Lua command to execute",
a.identifier)
);
}
interaction::Action action;
action.identifier = a.identifier;
action.command = a.script;
if (!a.name.empty()) {
action.name = a.name;
}
if (!a.documentation.empty()) {
action.documentation = a.documentation;
}
if (!a.guiPath.empty()) {
action.guiPath = a.guiPath;
}
action.name = a.name;
action.documentation = a.documentation;
action.guiPath = a.guiPath;
action.synchronization = interaction::Action::IsSynchronized(a.isLocal);
global::actionManager->registerAction(std::move(action));
}
}
void OpenSpaceEngine::setFromProfile_keybindings(const Profile& p)
{
void setKeybindingsFromProfile(const Profile& p) {
for (Profile::Keybinding k : p.keybindings) {
if (k.action.empty()) {
LERROR("Action must not be empty");
@@ -1697,15 +1658,19 @@ void OpenSpaceEngine::setFromProfile_keybindings(const Profile& p)
LERROR(fmt::format("Action '{}' does not exist", k.action));
}
if (k.key.key == openspace::Key::Unknown) {
LERROR(fmt::format("Could not find key '{}'",
std::to_string(static_cast<uint16_t>(k.key.key))));
LERROR(
fmt::format(
"Could not find key '{}'",
std::to_string(static_cast<uint16_t>(k.key.key))
)
);
}
global::keybindingManager->bindKey(k.key.key, k.key.modifier, k.action);
}
}
void OpenSpaceEngine::setFromProfile_markInterestingNodes(const Profile& p) {
for (std::string nodeName : p.markNodes) {
void setMarkInterestingNodesFromProfile(const Profile& p) {
for (const std::string& nodeName : p.markNodes) {
SceneGraphNode* node = global::renderEngine->scene()->sceneGraphNode(nodeName);
if (node) {
node->addTag("GUI.Interesting");
@@ -1713,7 +1678,7 @@ void OpenSpaceEngine::setFromProfile_markInterestingNodes(const Profile& p) {
}
}
void OpenSpaceEngine::setFromProfile_additionalScripts(const Profile& p) {
void setAdditionalScriptsFromProfile(const Profile& p) {
for (const std::string& a : p.additionalScripts) {
global::scriptEngine->queueScript(
a,

4
src/scene/profile.cpp
View File

@@ -738,8 +738,4 @@ scripting::LuaLibrary Profile::luaLibrary() {
};
}
std::vector<std::string>& additionalScripts(Profile& p) {
return p.additionalScripts;
}
} // namespace openspace

8
src/scene/profile_lua.inl
View File

@@ -36,14 +36,6 @@
namespace openspace::luascriptfunctions {
int saveSettingsToProfile(lua_State* L) {
if (!global::configuration->usingProfile) {
return ghoul::lua::luaError(
L,
"Program was not started with a profile, so cannot use this "
"save-current-settings feature"
);
}
ghoul::lua::checkArgumentsAndThrow(L, { 0, 2 }, "lua::saveSettingsToProfile");
auto [saveFilePath, overwrite] =
ghoul::lua::values<std::optional<std::string>, std::optional<bool>>(L);

10
src/scene/scene.cpp
View File

@@ -485,7 +485,7 @@ std::chrono::steady_clock::time_point Scene::currentTimeForInterpolation() {
}
void Scene::addPropertyInterpolation(properties::Property* prop, float durationSeconds,
ghoul::EasingFunction easingFunction)
ghoul::EasingFunction easingFunction)
{
ghoul_precondition(prop != nullptr, "prop must not be nullptr");
ghoul_precondition(durationSeconds > 0.f, "durationSeconds must be positive");
@@ -603,7 +603,7 @@ const std::vector<Scene::InterestingTime>& Scene::interestingTimes() const {
return _interestingTimes;
}
void Scene::setFromProfile_properties(const Profile& p) {
void Scene::setPropertiesFromProfile(const Profile& p) {
ghoul::lua::LuaState L(ghoul::lua::LuaState::IncludeStandardLibrary::Yes);
for (const Profile::Property& prop : p.properties) {
@@ -616,7 +616,7 @@ void Scene::setFromProfile_properties(const Profile& p) {
ghoul::lua::push(L, uriOrRegex);
ghoul::lua::push(L, 0.0);
// Later functions expect the value to be at the last position on the stack
property_pushValueFromProfileToLuaState(L, prop.value);
propertyPushValueFromProfileToLuaState(L, prop.value);
applyRegularExpression(
L,
@@ -631,8 +631,8 @@ void Scene::setFromProfile_properties(const Profile& p) {
}
}
void Scene::property_pushValueFromProfileToLuaState(ghoul::lua::LuaState& L,
const std::string& value)
void propertyPushValueFromProfileToLuaState(ghoul::lua::LuaState& L,
const std::string& value)
{
if (!luascriptfunctions::convertStringToLuaAndPush_bool(L, value)) {
if (!luascriptfunctions::convertStringToLuaAndPush_float(L, value)) {

4
src/util/time.cpp
View File

@@ -122,7 +122,7 @@ void Time::ISO8601(char* buffer) const {
SpiceManager::ref().dateFromEphemerisTime(_time, buffer, S, Format);
}
void Time::setFromProfile_timeRelative(const std::string& setTime) {
void Time::setTimeRelativeFromProfile(const std::string& setTime) {
ghoul::lua::LuaState L(ghoul::lua::LuaState::IncludeStandardLibrary::Yes);
luascriptfunctions::time_currentWallTime(L);
@@ -131,7 +131,7 @@ void Time::setFromProfile_timeRelative(const std::string& setTime) {
luascriptfunctions::time_setTime(L);
}
void Time::setFromProfile_timeAbsolute(const std::string& setTime) {
void Time::setTimeAbsoluteFromProfile(const std::string& setTime) {
ghoul::lua::LuaState L(ghoul::lua::LuaState::IncludeStandardLibrary::Yes);
ghoul::lua::push(L, setTime);

18
src/util/timemanager.cpp
View File

@@ -868,14 +868,20 @@ double TimeManager::previousApplicationTimeForInterpolation() const {
return _previousApplicationTime;
}
void TimeManager::setFromProfile_time(const Profile& p) {
void TimeManager::setTimeFromProfile(const Profile& p) {
Time t;
if (p.time->type == Profile::Time::Type::Relative) {
t.setFromProfile_timeRelative(p.time->value);
}
else if (p.time->type == Profile::Time::Type::Absolute) {
t.setFromProfile_timeAbsolute(p.time->value);
switch (p.time.value().type) {
case Profile::Time::Type::Relative:
t.setTimeRelativeFromProfile(p.time.value().value);
break;
case Profile::Time::Type::Absolute:
t.setTimeAbsoluteFromProfile(p.time.value().value);
break;
default:
throw ghoul::MissingCaseException();
}
}