From cd33ec06c94cb0c5befd057b467cf01b2b593eac Mon Sep 17 00:00:00 2001 From: Alexander Bock Date: Thu, 8 Feb 2018 17:42:22 -0500 Subject: [PATCH] Cleanup of distance and time conversion classes, Modifies GuiSpaceTimeComponent Changed previous slider into text field + dropbox Added acceleration slider Added shuffle slider (closes #479) --- ext/ghoul | 2 +- include/openspace/util/distanceconversion.h | 165 +++++++- include/openspace/util/timeconversion.h | 175 ++++++++- .../base/dashboard/dashboarditemdistance.cpp | 2 +- .../dashboarditemsimulationincrement.cpp | 6 +- modules/imgui/include/guispacetimecomponent.h | 18 +- modules/imgui/src/guispacetimecomponent.cpp | 367 +++++++++++------- src/util/distanceconversion.cpp | 133 ------- src/util/timeconversion.cpp | 101 +---- 9 files changed, 575 insertions(+), 394 deletions(-) diff --git a/ext/ghoul b/ext/ghoul index 0830bb186a..2b5e82a6ff 160000 --- a/ext/ghoul +++ b/ext/ghoul @@ -1 +1 @@ -Subproject commit 0830bb186a10f83d4e7d7791b584a1a7235c2e3c +Subproject commit 2b5e82a6ff061bebd9c8b605160dafc6ade2ad65 diff --git a/include/openspace/util/distanceconversion.h b/include/openspace/util/distanceconversion.h index 27a36840f3..80a3a962da 100644 --- a/include/openspace/util/distanceconversion.h +++ b/include/openspace/util/distanceconversion.h @@ -25,6 +25,11 @@ #ifndef __OPENSPACE_CORE___DISTANCECONVERSION___H__ #define __OPENSPACE_CORE___DISTANCECONVERSION___H__ +#include + +#include +#include + #include #include #include @@ -47,6 +52,39 @@ enum class DistanceUnit { Megaparsec, Gigaparsec }; + +// Assumption: Unit names are sequential in memory +constexpr const char* DistanceUnitNanometer = "nanometer"; +constexpr const char* DistanceUnitMicrometer = "micrometer"; +constexpr const char* DistanceUnitMillimeter = "millimeter"; +constexpr const char* DistanceUnitMeter = "meter"; +constexpr const char* DistanceUnitKilometer = "km"; +constexpr const char* DistanceUnitAU = "AU"; +constexpr const char* DistanceUnitLighthour = "lighthour"; +constexpr const char* DistanceUnitLightday = "lightday"; +constexpr const char* DistanceUnitLightmonth = "lightmonth"; +constexpr const char* DistanceUnitLightyear = "lightyear"; +constexpr const char* DistanceUnitParsec = "parsec"; +constexpr const char* DistanceUnitKiloparsec = "kiloparsec"; +constexpr const char* DistanceUnitMegaparsec = "megaparsec"; +constexpr const char* DistanceUnitGigaparsec = "gigaparsec"; + +// Assumption: Unit names are sequential in memory +constexpr const char* DistanceUnitNanometers = "nanometers"; +constexpr const char* DistanceUnitMicrometers = "micrometers"; +constexpr const char* DistanceUnitMillimeters = "millimeters"; +constexpr const char* DistanceUnitMeters = "meters"; +constexpr const char* DistanceUnitKilometers = "km"; +constexpr const char* DistanceUnitAUs = "AU"; +constexpr const char* DistanceUnitLighthours = "lighthours"; +constexpr const char* DistanceUnitLightdays = "lightdays"; +constexpr const char* DistanceUnitLightmonths = "lightmonths"; +constexpr const char* DistanceUnitLightyears = "lightyears"; +constexpr const char* DistanceUnitParsecs = "parsecs"; +constexpr const char* DistanceUnitKiloparsecs = "kiloparsecs"; +constexpr const char* DistanceUnitMegaparsecs = "megaparsecs"; +constexpr const char* DistanceUnitGigaparsecs = "gigaparsecs"; + constexpr std::array(DistanceUnit::Gigaparsec) + 1> DistanceUnits = { DistanceUnit::Nanometer, DistanceUnit::Micrometer, DistanceUnit::Millimeter, @@ -56,13 +94,132 @@ DistanceUnits = { DistanceUnit::Megaparsec, DistanceUnit::Gigaparsec }; +constexpr std::array(DistanceUnit::Gigaparsec) + 1> +DistanceUnitNamesSingular = { + DistanceUnitNanometer, DistanceUnitMicrometer, DistanceUnitMillimeter, + DistanceUnitMeter, DistanceUnitKilometer, DistanceUnitAU, DistanceUnitLighthour, + DistanceUnitLightday, DistanceUnitLightmonth, DistanceUnitLightyear, + DistanceUnitParsec, DistanceUnitKiloparsec, DistanceUnitMegaparsec, + DistanceUnitGigaparsec +}; + +constexpr std::array(DistanceUnit::Gigaparsec) + 1> +DistanceUnitNamesPlural = { + DistanceUnitNanometers, DistanceUnitMicrometers, DistanceUnitMillimeters, + DistanceUnitMeters, DistanceUnitKilometers, DistanceUnitAUs, DistanceUnitLighthours, + DistanceUnitLightdays, DistanceUnitLightmonths, DistanceUnitLightyears, + DistanceUnitParsecs, DistanceUnitKiloparsecs, DistanceUnitMegaparsecs, + DistanceUnitGigaparsecs +}; + +constexpr bool isValidDistanceUnitName(const char* name) { + int i = 0; + for (const char* val : DistanceUnitNamesSingular) { + if (ghoul::equal(name, val)) { + return true; + } + ++i; + } + + i = 0; + for (const char* val : DistanceUnitNamesPlural) { + if (ghoul::equal(name, val)) { + return true; + } + ++i; + } + return false; +} + +constexpr const char* nameForDistanceUnit(DistanceUnit unit, bool pluralForm = false) { + switch (unit) { + case DistanceUnit::Nanometer: + case DistanceUnit::Micrometer: + case DistanceUnit::Millimeter: + case DistanceUnit::Meter: + case DistanceUnit::Kilometer: + case DistanceUnit::AU: + case DistanceUnit::Lighthour: + case DistanceUnit::Lightday: + case DistanceUnit::Lightmonth: + case DistanceUnit::Lightyear: + case DistanceUnit::Parsec: + case DistanceUnit::Kiloparsec: + case DistanceUnit::Megaparsec: + case DistanceUnit::Gigaparsec: + if (pluralForm) { + return DistanceUnitNamesPlural[static_cast(unit)]; + } + else { + return DistanceUnitNamesSingular[static_cast(unit)]; + } + default: + throw ghoul::MissingCaseException(); + } +} + +constexpr DistanceUnit distanceUnitFromString(const char* unitName) { + int i = 0; + for (const char* val : DistanceUnitNamesSingular) { + if (ghoul::equal(unitName, val)) { + return static_cast(i); + } + ++i; + } + + i = 0; + for (const char* val : DistanceUnitNamesPlural) { + if (ghoul::equal(unitName, val)) { + return static_cast(i); + } + ++i; + } + + ghoul_assert(false, "Unit name is not a valid name"); + throw ghoul::MissingCaseException(); +} + + + + + std::pair simplifyDistance(double meters, bool forceSingularForm = false); -double convertDistance(double meters, DistanceUnit requestedUnit); - -std::string nameForDistanceUnit(DistanceUnit unit, bool pluralForm = false); -DistanceUnit distanceUnitFromString(const std::string& unit); +constexpr double convertDistance(double meters, DistanceUnit requestedUnit) { + switch (requestedUnit) { + case DistanceUnit::Nanometer: + return meters / 1e-9; + case DistanceUnit::Micrometer: + return meters / 1e-6; + case DistanceUnit::Millimeter: + return meters / 1e-3; + case DistanceUnit::Meter: + return meters; + case DistanceUnit::Kilometer: + return meters / 1000.0; + case DistanceUnit::AU: + return meters / distanceconstants::AstronomicalUnit; + case DistanceUnit::Lighthour: + return meters / distanceconstants::LightHour; + case DistanceUnit::Lightday: + return meters / distanceconstants::LightDay; + case DistanceUnit::Lightmonth: + return meters / distanceconstants::LightMonth; + case DistanceUnit::Lightyear: + return meters / distanceconstants::LightYear; + case DistanceUnit::Parsec: + return meters / distanceconstants::Parsec; + case DistanceUnit::Kiloparsec: + return meters / (1e3 * distanceconstants::Parsec); + case DistanceUnit::Megaparsec: + return meters / (1e6 * distanceconstants::Parsec); + case DistanceUnit::Gigaparsec: + return meters / (1e9 * distanceconstants::Parsec); + default: + throw ghoul::MissingCaseException(); + } +} } // namespace openspace diff --git a/include/openspace/util/timeconversion.h b/include/openspace/util/timeconversion.h index 6e5f349936..c9ea8452eb 100644 --- a/include/openspace/util/timeconversion.h +++ b/include/openspace/util/timeconversion.h @@ -25,12 +25,29 @@ #ifndef __OPENSPACE_CORE___TIMECONVERSION___H__ #define __OPENSPACE_CORE___TIMECONVERSION___H__ +#include +#include + #include +#include #include #include namespace openspace { +constexpr double SecondsPerYear = 31556952; // seconds in average Gregorian year +constexpr double SecondsPerMonth = SecondsPerYear / 12; +constexpr double SecondsPerDay = static_cast( + std::chrono::seconds(std::chrono::hours(24)).count() +); +constexpr double SecondsPerHour = static_cast( + std::chrono::seconds(std::chrono::hours(1)).count() +); +constexpr double SecondsPerMinute = static_cast( + std::chrono::seconds(std::chrono::minutes(1)).count() +); + +// Assumption: static_cast(TimeUnit) == position in the list enum class TimeUnit { Nanosecond = 0, Microsecond, @@ -42,20 +59,168 @@ enum class TimeUnit { Month, Year }; -constexpr std::array(TimeUnit::Year) + 1> -TimeUnits = { + +// Assumption: Unit names are sequential in memory +constexpr const char* TimeUnitNanosecond = "nanosecond"; +constexpr const char* TimeUnitMicrosecond = "microsecond"; +constexpr const char* TimeUnitMillisecond = "millisecond"; +constexpr const char* TimeUnitSecond = "second"; +constexpr const char* TimeUnitMinute = "minute"; +constexpr const char* TimeUnitHour = "hour"; +constexpr const char* TimeUnitDay = "day"; +constexpr const char* TimeUnitMonth = "month"; +constexpr const char* TimeUnitYear = "year"; + +// Assumption: Unit names are sequential in memory +constexpr const char* TimeUnitNanoseconds = "nanoseconds"; +constexpr const char* TimeUnitMicroseconds = "microseconds"; +constexpr const char* TimeUnitMilliseconds = "milliseconds"; +constexpr const char* TimeUnitSeconds = "seconds"; +constexpr const char* TimeUnitMinutes = "minutes"; +constexpr const char* TimeUnitHours = "hours"; +constexpr const char* TimeUnitDays = "days"; +constexpr const char* TimeUnitMonths = "months"; +constexpr const char* TimeUnitYears = "years"; + +constexpr std::array(TimeUnit::Year) + 1> TimeUnits = { TimeUnit::Nanosecond, TimeUnit::Microsecond, TimeUnit::Millisecond, TimeUnit::Second, TimeUnit::Minute, TimeUnit::Hour, TimeUnit::Day, TimeUnit::Month, TimeUnit::Year }; +constexpr std::array(TimeUnit::Year) + 1> +TimeUnitNamesSingular = { + TimeUnitNanosecond, TimeUnitMicrosecond, TimeUnitMillisecond, TimeUnitSecond, + TimeUnitMinute, TimeUnitHour, TimeUnitDay, TimeUnitMonth, TimeUnitYear +}; + +constexpr std::array(TimeUnit::Year) + 1> +TimeUnitNamesPlural = { + TimeUnitNanoseconds, TimeUnitMicroseconds, TimeUnitMilliseconds, TimeUnitSeconds, + TimeUnitMinutes, TimeUnitHours, TimeUnitDays, TimeUnitMonths, TimeUnitYears +}; + +constexpr bool isValidTimeUnitName(const char* name) { + int i = 0; + for (const char* val : TimeUnitNamesSingular) { + if (ghoul::equal(name, val)) { + return true; + } + ++i; + } + + i = 0; + for (const char* val : TimeUnitNamesPlural) { + if (ghoul::equal(name, val)) { + return true; + } + ++i; + } + return false; +} + +constexpr const char* nameForTimeUnit(TimeUnit unit, bool pluralForm = false) { + switch (unit) { + case TimeUnit::Nanosecond: + case TimeUnit::Microsecond: + case TimeUnit::Millisecond: + case TimeUnit::Second: + case TimeUnit::Minute: + case TimeUnit::Hour: + case TimeUnit::Day: + case TimeUnit::Month: + case TimeUnit::Year: + if (pluralForm) { + return TimeUnitNamesPlural[static_cast(unit)]; + } + else { + return TimeUnitNamesSingular[static_cast(unit)]; + } + default: + throw ghoul::MissingCaseException(); + } +} + +constexpr TimeUnit timeUnitFromString(const char* unitName) { + int i = 0; + for (const char* val : TimeUnitNamesSingular) { + if (ghoul::equal(unitName, val)) { + return static_cast(i); + } + ++i; + } + + i = 0; + for (const char* val : TimeUnitNamesPlural) { + if (ghoul::equal(unitName, val)) { + return static_cast(i); + } + ++i; + } + + ghoul_assert(false, "Unit name is not a valid name"); + throw ghoul::MissingCaseException(); +} + + + std::pair simplifyTime(double seconds, bool forceSingularForm = false); -double convertTime(double seconds, TimeUnit requestedUnit); +constexpr double convertTime(double t, TimeUnit sourceUnit, TimeUnit destinationUnit) { + double seconds = t; + switch (sourceUnit) { + case TimeUnit::Nanosecond: + seconds = t * 1e-9; + break; + case TimeUnit::Microsecond: + seconds = t * 1e-6; + break; + case TimeUnit::Millisecond: + seconds = t * 1e-3; + break; + case TimeUnit::Minute: + seconds = t * SecondsPerMinute; + break; + case TimeUnit::Hour: + seconds = t * SecondsPerHour; + break; + case TimeUnit::Day: + seconds = t * SecondsPerDay; + break; + case TimeUnit::Month: + seconds = t * SecondsPerMonth; + break; + case TimeUnit::Year: + seconds = t * SecondsPerYear; + break; + default: ; + } + + switch (destinationUnit) { + case TimeUnit::Nanosecond: + return seconds / 1e-9; + case TimeUnit::Microsecond: + return seconds / 1e-6; + case TimeUnit::Millisecond: + return seconds / 1e-3; + case TimeUnit::Second: + return seconds; + case TimeUnit::Minute: + return seconds / SecondsPerMinute; + case TimeUnit::Hour: + return seconds / SecondsPerHour; + case TimeUnit::Day: + return seconds / SecondsPerDay; + case TimeUnit::Month: + return seconds / SecondsPerMonth; + case TimeUnit::Year: + return seconds / SecondsPerYear; + default: + throw ghoul::MissingCaseException(); + } +} -std::string nameForTimeUnit(TimeUnit unit, bool pluralForm = false); -TimeUnit timeUnitFromString(const std::string& unit); } // namespace openspace diff --git a/modules/base/dashboard/dashboarditemdistance.cpp b/modules/base/dashboard/dashboarditemdistance.cpp index 2d8c0aa9ff..9f0954a657 100644 --- a/modules/base/dashboard/dashboarditemdistance.cpp +++ b/modules/base/dashboard/dashboarditemdistance.cpp @@ -349,7 +349,7 @@ DashboardItemDistance::DashboardItemDistance(ghoul::Dictionary dictionary) _requestedUnit = static_cast(DistanceUnit::Meter); if (dictionary.hasKey(RequestedUnitInfo.identifier)) { std::string value = dictionary.value(RequestedUnitInfo.identifier); - DistanceUnit unit = distanceUnitFromString(value); + DistanceUnit unit = distanceUnitFromString(value.c_str()); _requestedUnit = static_cast(unit); } _requestedUnit.setVisibility(properties::Property::Visibility::Hidden); diff --git a/modules/base/dashboard/dashboarditemsimulationincrement.cpp b/modules/base/dashboard/dashboarditemsimulationincrement.cpp index 6126e62476..0e56cadb3a 100644 --- a/modules/base/dashboard/dashboarditemsimulationincrement.cpp +++ b/modules/base/dashboard/dashboarditemsimulationincrement.cpp @@ -171,7 +171,7 @@ DashboardItemSimulationIncrement::DashboardItemSimulationIncrement( _requestedUnit = static_cast(TimeUnit::Second); if (dictionary.hasKey(RequestedUnitInfo.identifier)) { std::string value = dictionary.value(RequestedUnitInfo.identifier); - TimeUnit unit = timeUnitFromString(value); + TimeUnit unit = timeUnitFromString(value.c_str()); _requestedUnit = static_cast(unit); } _requestedUnit.setVisibility(properties::Property::Visibility::Hidden); @@ -188,7 +188,7 @@ void DashboardItemSimulationIncrement::render(glm::vec2& penPosition) { } else { TimeUnit unit = static_cast(_requestedUnit.value()); - double convertedT = convertTime(t, unit); + double convertedT = convertTime(t, TimeUnit::Second, unit); deltaTime = { convertedT, nameForTimeUnit(unit, convertedT != 1.0) }; } @@ -210,7 +210,7 @@ glm::vec2 DashboardItemSimulationIncrement::size() const { } else { TimeUnit unit = static_cast(_requestedUnit.value()); - double convertedT = convertTime(t, unit); + double convertedT = convertTime(t, TimeUnit::Second, unit); deltaTime = { convertedT, nameForTimeUnit(unit, convertedT != 1.0) }; } diff --git a/modules/imgui/include/guispacetimecomponent.h b/modules/imgui/include/guispacetimecomponent.h index 81c4ff416a..41dbc556eb 100644 --- a/modules/imgui/include/guispacetimecomponent.h +++ b/modules/imgui/include/guispacetimecomponent.h @@ -28,6 +28,7 @@ #include #include +#include namespace openspace::gui { @@ -37,8 +38,21 @@ public: void render() override; private: - properties::FloatProperty _minMaxDeltaTime; - float _localMinMaxDeltatime; // We don't want the default display inside the component + float _deltaTime; + int _deltaTimeUnit; // aka static_cast(TimeUnit) + + float _accelerationDelta; + + double _oldDeltaTime; + float _slidingDelta; + + bool _firstFrame; + + std::string _timeUnits; + + + //properties::FloatProperty _minMaxDeltaTime; + //float _localMinMaxDeltatime; // We don't want the default display inside the component }; } // namespace openspace::gui diff --git a/modules/imgui/src/guispacetimecomponent.cpp b/modules/imgui/src/guispacetimecomponent.cpp index c432cedfaa..88e652392e 100644 --- a/modules/imgui/src/guispacetimecomponent.cpp +++ b/modules/imgui/src/guispacetimecomponent.cpp @@ -36,16 +36,18 @@ #include #include +#include + #include namespace { static const ImVec2 Size = ImVec2(350, 500); - static const openspace::properties::Property::PropertyInfo MinMaxInfo = { - "MinMax", - "Minimum/Maximum value for delta time", - "This value determines the minimum and maximum value for the delta time slider." - }; + //static const openspace::properties::Property::PropertyInfo MinMaxInfo = { + // "MinMax", + // "Minimum/Maximum value for delta time", + // "This value determines the minimum and maximum value for the delta time slider." + //}; void showTooltip(const std::string& message, double delay) { // Hackish way to enfore a window size for TextWrapped (SetNextWindowSize did not @@ -74,13 +76,19 @@ namespace openspace::gui { GuiSpaceTimeComponent::GuiSpaceTimeComponent() : GuiComponent("Space/Time") - , _minMaxDeltaTime(MinMaxInfo, 100000.f, 0.f, 1e8f, 1.f, 5.f) - , _localMinMaxDeltatime(100000.f) + , _deltaTime(0.f) + , _deltaTimeUnit(static_cast(TimeUnit::Second)) + , _accelerationDelta(0.f) + , _slidingDelta(0.f) + , _firstFrame(true) + //, _minMaxDeltaTime(MinMaxInfo, 100000.f, 0.f, 1e8f, 1.f, 5.f) + //, _localMinMaxDeltatime(100000.f) { - _minMaxDeltaTime.onChange([this]() { - _localMinMaxDeltatime = _minMaxDeltaTime; - }); - addProperty(_minMaxDeltaTime); + + //_minMaxDeltaTime.onChange([this]() { + // _localMinMaxDeltatime = _minMaxDeltaTime; + //}); + //addProperty(_minMaxDeltaTime); } void GuiSpaceTimeComponent::render() { @@ -279,71 +287,140 @@ void GuiSpaceTimeComponent::render() { ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 20.f); // -// { -// float deltaTime = static_cast(OsEng.timeManager().time().deltaTime()); -// //std::pair dt = simplifyTime(deltaTime, true); -// -// -// //float val = dt.first; -// ImGui::InputFloat("", &val); -// -// //bool ImGui::Combo(const char* label, int* current_item, const char* const* items, int items_count, int height_in_items) -// -// const char* TimeSteps = "nanoseconds / second\0microseconds / second\0\ -//milliseconds / second\0seconds / second\0minutes / second\0hours / second\0days / second\ -//months / second\0years / second\0"; -// -// std::string nodeNames = ""; -// for (SceneGraphNode* n : nodes) { -// nodeNames += n->name() + '\0'; -// } -// -// auto iCurrentFocus = std::find(nodes.begin(), nodes.end(), currentFocus); -// if (!nodes.empty()) { -// // Only check if we found the current focus node if we have any nodes at all -// // only then it would be a real error -// ghoul_assert(iCurrentFocus != nodes.end(), "Focus node not found"); -// } -// int currentPosition = static_cast(std::distance(nodes.begin(), iCurrentFocus)); -// -// -// bool hasChanged = ImGui::Combo("", ); -// -// bool hasChanged = ImGui::Combo("", ¤tPosition, nodeNames.c_str()); -// -// } -// + { + float deltaTime = static_cast(OsEng.timeManager().time().deltaTime()); + if (_firstFrame) { + std::pair dt = simplifyTime(deltaTime); + _deltaTime = dt.first; + _deltaTimeUnit = static_cast(timeUnitFromString(dt.second.c_str())); - //bool minMaxChanged = ImGui::InputFloat( - // "Time slider range", - // &_localMinMaxDeltatime - //); - //if (minMaxChanged) { - // _minMaxDeltaTime = _localMinMaxDeltatime; - //} + _timeUnits = std::accumulate( + openspace::TimeUnits.begin(), + openspace::TimeUnits.end(), + std::string(""), + [](const std::string& a, const openspace::TimeUnit& unit) { + return a + nameForTimeUnit(unit, true) + " / second" + '\0'; + } + ); + + _firstFrame = false; + } + + _deltaTime = convertTime( + deltaTime, + TimeUnit::Second, + static_cast(_deltaTimeUnit) + ); + + bool valueChanged = ImGui::InputFloat( + "##inputValueDeltaTime", + &_deltaTime, + 1.f, + 100.f, + -1, + ImGuiInputTextFlags_EnterReturnsTrue + ); + ImGui::SameLine(); + + bool unitChanged = ImGui::Combo( + "##inputUnit", + &_deltaTimeUnit, + _timeUnits.c_str() + ); + + if (valueChanged) { + LINFOC("valueChanged", valueChanged); + // If the value changed, we want to change the delta time to the new value + + double newDeltaTime = convertTime( + _deltaTime, + static_cast(_deltaTimeUnit), + TimeUnit::Second + ); + + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(newDeltaTime) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + if (unitChanged) { + LINFOC("unitChanged", unitChanged); + // If only the unit changes, we keep the delta time, but need to convert the + // value to the new unit + + _deltaTime = convertTime( + deltaTime, + TimeUnit::Second, + static_cast(_deltaTimeUnit) + ); + } + } + + ImGui::Text("%s", "Time Slider"); + bool accelerationDeltaChanged = ImGui::SliderFloat( + "Delta Time Acceleration", + &_accelerationDelta, + -100.f, + 100.f, + "%.6f" + ); + + if (accelerationDeltaChanged || ImGui::IsItemActive() || ImGui::IsItemClicked()) { + double newDeltaTime = convertTime( + _deltaTime + _accelerationDelta, + static_cast(_deltaTimeUnit), + TimeUnit::Second + ); + + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(newDeltaTime) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + else { + _accelerationDelta = 0.f; + } + + _deltaTime -= _slidingDelta; + + bool firstSlidingValue = _slidingDelta == 0.f; + bool slidingDeltaChanged = ImGui::SliderFloat( + "Delta Time Slider", + &_slidingDelta, + -100.f, + 100.f, + "%.6f" + ); + firstSlidingValue &= _slidingDelta != 0.f; + + if (slidingDeltaChanged) { + if (firstSlidingValue) { + _oldDeltaTime = _deltaTime; + } + + double newDeltaTime = convertTime( + _deltaTime + _slidingDelta, + static_cast(_deltaTimeUnit), + TimeUnit::Second + ); + + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(newDeltaTime) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + if (!ImGui::IsItemActive() && !ImGui::IsItemClicked()) { + if (_slidingDelta != 0.f) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(_oldDeltaTime) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + + } + _slidingDelta = 0.f; + } - //float deltaTime = static_cast(OsEng.timeManager().time().deltaTime()); - //bool deltaChanged = ImGui::SliderFloat( - // "Delta Time", - // &deltaTime, - // -_minMaxDeltaTime, - // _minMaxDeltaTime, - // "%.6f", - // 5.f - //); - //if (deltaChanged) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(deltaTime) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //showTooltip( - // "This determines the simulation time increment, that is the passage of time in " - // "OpenSpace relative to a wall clock. Times are expressed as simulation time / " - // "real world time.", - // _tooltipDelay - //); bool isPaused = OsEng.timeManager().time().paused(); @@ -358,87 +435,87 @@ void GuiSpaceTimeComponent::render() { ); } - //bool minusDs = ImGui::Button("-1d/s"); - //if (minusDs) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(-24 * 60 * 60) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool minusDs = ImGui::Button("-1d/s"); + if (minusDs) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(-24 * 60 * 60) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); - //bool minusHs = ImGui::Button("-1h/s"); - //if (minusHs) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(-60 * 60) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool minusHs = ImGui::Button("-1h/s"); + if (minusHs) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(-60 * 60) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); - //bool minusMs = ImGui::Button("-1min/s"); - //if (minusMs) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(-60) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool minusMs = ImGui::Button("-1min/s"); + if (minusMs) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(-60) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); - //bool minusSs = ImGui::Button("-1s/s"); - //if (minusSs) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(-1) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool minusSs = ImGui::Button("-1s/s"); + if (minusSs) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(-1) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); - //bool zero = ImGui::Button("0"); - //if (zero) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(0) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool zero = ImGui::Button("0"); + if (zero) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(0) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); - //bool plusSs = ImGui::Button("+1s/s"); - //if (plusSs) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(1) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool plusSs = ImGui::Button("+1s/s"); + if (plusSs) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(1) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); - //bool plusMs = ImGui::Button("1min/s"); - //if (plusMs) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(60) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool plusMs = ImGui::Button("1min/s"); + if (plusMs) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(60) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); - //bool plusHs = ImGui::Button("1h/s"); - //if (plusHs) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(60 * 60) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool plusHs = ImGui::Button("1h/s"); + if (plusHs) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(60 * 60) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); - //bool plusDs = ImGui::Button("1d/s"); - //if (plusDs) { - // OsEng.scriptEngine().queueScript( - // "openspace.time.setDeltaTime(" + std::to_string(24 * 60 * 60) + ")", - // scripting::ScriptEngine::RemoteScripting::Yes - // ); - //} - //ImGui::SameLine(); + bool plusDs = ImGui::Button("1d/s"); + if (plusDs) { + OsEng.scriptEngine().queueScript( + "openspace.time.setDeltaTime(" + std::to_string(24 * 60 * 60) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); + } + ImGui::SameLine(); ImGui::End(); diff --git a/src/util/distanceconversion.cpp b/src/util/distanceconversion.cpp index e0e53243c6..89b9150954 100644 --- a/src/util/distanceconversion.cpp +++ b/src/util/distanceconversion.cpp @@ -27,18 +27,6 @@ #include #include -#include - -namespace { - constexpr bool equal(char const* lhs, char const* rhs) { - while (*lhs || *rhs) { - if (*lhs++ != *rhs++) { - return false; - } - } - return true; - } -} namespace openspace { @@ -105,125 +93,4 @@ std::pair simplifyDistance(double meters, bool forceSingula } } - -double convertDistance(double meters, DistanceUnit requestedUnit) { - switch (requestedUnit) { - case DistanceUnit::Nanometer: - return meters / 1e-9; - case DistanceUnit::Micrometer: - return meters / 1e-6; - case DistanceUnit::Millimeter: - return meters / 1e-3; - case DistanceUnit::Meter: - return meters; - case DistanceUnit::Kilometer: - return meters / 1000.0; - case DistanceUnit::AU: - return meters / distanceconstants::AstronomicalUnit; - case DistanceUnit::Lighthour: - return meters / distanceconstants::LightHour; - case DistanceUnit::Lightday: - return meters / distanceconstants::LightDay; - case DistanceUnit::Lightmonth: - return meters / distanceconstants::LightMonth; - case DistanceUnit::Lightyear: - return meters / distanceconstants::LightYear; - case DistanceUnit::Parsec: - return meters / distanceconstants::Parsec; - case DistanceUnit::Kiloparsec: - return meters / (1e3 * distanceconstants::Parsec); - case DistanceUnit::Megaparsec: - return meters / (1e6 * distanceconstants::Parsec); - case DistanceUnit::Gigaparsec: - return meters / (1e9 * distanceconstants::Parsec); - default: - throw ghoul::MissingCaseException(); - } -} - -std::string nameForDistanceUnit(DistanceUnit unit, bool pluralForm) { - switch (unit) { - case DistanceUnit::Nanometer: - return pluralForm ? "nanometers" : "nanometer"; - case DistanceUnit::Micrometer: - return pluralForm ? "micrometers" : "micrometer"; - case DistanceUnit::Millimeter: - return pluralForm ? "millimeters" : "millimeter"; - case DistanceUnit::Meter: - return pluralForm ? "meters" : "meter"; - case DistanceUnit::Kilometer: - return "km"; - case DistanceUnit::AU: - return "AU"; - case DistanceUnit::Lighthour: - return pluralForm ? "lighthours" : "lighthour"; - case DistanceUnit::Lightday: - return pluralForm ? "lightdays" : "lightday"; - case DistanceUnit::Lightmonth: - return pluralForm ? "lightmonths" : "lightmonth"; - case DistanceUnit::Lightyear: - return pluralForm ? "lightyears" : "lightyear"; - case DistanceUnit::Parsec: - return pluralForm ? "parsecs" : "parsec"; - case DistanceUnit::Kiloparsec: - return pluralForm ? "kiloparsecs" : "kiloparsec"; - case DistanceUnit::Megaparsec: - return pluralForm ? "megaparsecs" : "megaparsec"; - case DistanceUnit::Gigaparsec: - return pluralForm ? "gigaparsecs" : "gigaparsec"; - default: - throw ghoul::MissingCaseException(); - } -} - - -DistanceUnit distanceUnitFromString(const std::string& unit) { - if (unit == "nanometer" || unit == "nanometers") { - return DistanceUnit::Nanometer; - } - else if (unit == "micrometer" || unit == "micrometers") { - return DistanceUnit::Micrometer; - } - else if (unit == "millimeter" || unit == "millimeters") { - return DistanceUnit::Millimeter; - } - else if (unit == "meter" || unit == "meters") { - return DistanceUnit::Meter; - } - else if (unit == "km") { - return DistanceUnit::Kilometer; - } - else if (unit == "AU") { - return DistanceUnit::AU; - } - else if (unit == "lighthour" || unit == "lighthours") { - return DistanceUnit::Lighthour; - } - else if (unit == "lightday" || unit == "lightdays") { - return DistanceUnit::Lightday; - } - else if (unit == "lightmonth" || unit == "lightmonths") { - return DistanceUnit::Lightmonth; - } - else if (unit == "lightyear" || unit == "lightyears") { - return DistanceUnit::Lightyear; - } - else if (unit == "parsec" || unit == "parsecs") { - return DistanceUnit::Parsec; - } - else if (unit == "kiloparsec" || unit == "kiloparsecs") { - return DistanceUnit::Kiloparsec; - } - else if (unit == "megaparsec" || unit == "megaparsecs") { - return DistanceUnit::Megaparsec; - } - else if (unit == "gigaparsec" || unit == "gigaparsecs") { - return DistanceUnit::Gigaparsec; - } - else { - throw ghoul::MissingCaseException(); - } -} - - } // namespace openspace diff --git a/src/util/timeconversion.cpp b/src/util/timeconversion.cpp index fd2b2d67ca..eb61bc6950 100644 --- a/src/util/timeconversion.cpp +++ b/src/util/timeconversion.cpp @@ -25,23 +25,8 @@ #include #include -#include -#include - -namespace { - constexpr double SecondsPerYear = 31556952; // seconds in average Gregorian year - constexpr double SecondsPerMonth = SecondsPerYear / 12; - constexpr double SecondsPerDay = static_cast( - std::chrono::seconds(std::chrono::hours(24)).count() - ); - constexpr double SecondsPerHour = static_cast( - std::chrono::seconds(std::chrono::hours(1)).count() - ); - constexpr double SecondsPerMinute = static_cast( - std::chrono::seconds(std::chrono::minutes(1)).count() - ); -} // namespace +#include namespace openspace { @@ -96,88 +81,4 @@ std::pair simplifyTime(double seconds, bool forceSingularFo } } -double convertTime(double seconds, TimeUnit requestedUnit) { - switch (requestedUnit) { - case TimeUnit::Nanosecond: - return seconds / 1e-9; - case TimeUnit::Microsecond: - return seconds / 1e-6; - case TimeUnit::Millisecond: - return seconds / 1e-3; - case TimeUnit::Second: - return seconds; - case TimeUnit::Minute: - return seconds / SecondsPerMinute; - case TimeUnit::Hour: - return seconds / SecondsPerHour; - case TimeUnit::Day: - return seconds / SecondsPerDay; - case TimeUnit::Month: - return seconds / SecondsPerMonth; - case TimeUnit::Year: - return seconds / SecondsPerYear; - default: - throw ghoul::MissingCaseException(); - } -} - -std::string nameForTimeUnit(TimeUnit unit, bool pluralForm) { - switch (unit) { - case TimeUnit::Nanosecond: - return pluralForm ? "nanoseconds" : "nanosecond"; - case TimeUnit::Microsecond: - return pluralForm ? "microseconds" : "microsecond"; - case TimeUnit::Millisecond: - return pluralForm ? "milliseconds" : "millisecond"; - case TimeUnit::Second: - return pluralForm ? "seconds" : "second"; - case TimeUnit::Minute: - return pluralForm ? "minutes" : "minute"; - case TimeUnit::Hour: - return pluralForm ? "hours" : "hour"; - case TimeUnit::Day: - return pluralForm ? "days" : "day"; - case TimeUnit::Month: - return pluralForm ? "months" : "month"; - case TimeUnit::Year: - return pluralForm ? "years" : "year"; - default: - throw ghoul::MissingCaseException(); - } -} - -TimeUnit timeUnitFromString(const std::string& unit) { - if (unit == "nanosecond" || unit == "nanoseconds") { - return TimeUnit::Nanosecond; - } - else if (unit == "microsecond" || unit == "microseconds") { - return TimeUnit::Microsecond; - } - else if (unit == "millisecond" || unit == "milliseconds") { - return TimeUnit::Millisecond; - } - else if (unit == "second" || unit == "seconds") { - return TimeUnit::Second; - } - else if (unit == "minute" || unit == "minutes") { - return TimeUnit::Minute; - } - else if (unit == "hour" || unit == "hours") { - return TimeUnit::Hour; - } - else if (unit == "day" || unit == "days") { - return TimeUnit::Day; - } - else if (unit == "month" || unit == "months") { - return TimeUnit::Month; - } - else if (unit == "year" || unit == "years") { - return TimeUnit::Year; - } - else { - throw ghoul::MissingCaseException(); - } -} - - } // namespace openspace