mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-08 12:39:49 -06:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup of distance and time conversion classes, Modifies GuiSpaceTimeComponent

Browse Source 
Changed previous slider into text field + dropbox
Added acceleration slider
Added shuffle slider (closes #479)
This commit is contained in:
Alexander Bock
2018-02-08 17:42:22 -05:00
parent d5f158ad0b
commit cd33ec06c9
9 changed files with 575 additions and 394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ext/ghoul

Submodule ext/ghoul updated: 0830bb186a...2b5e82a6ff

165
include/openspace/util/distanceconversion.h
View File

@@ -25,6 +25,11 @@
#ifndef __OPENSPACE_CORE___DISTANCECONVERSION___H__
#define __OPENSPACE_CORE___DISTANCECONVERSION___H__
#include <openspace/util/distanceconstants.h>
#include <ghoul/misc/assert.h>
#include <ghoul/misc/constexpr.h>
#include <array>
#include <string>
#include <utility>
@@ -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, static_cast<int>(DistanceUnit::Gigaparsec) + 1>
DistanceUnits = {
DistanceUnit::Nanometer, DistanceUnit::Micrometer, DistanceUnit::Millimeter,
@@ -56,13 +94,132 @@ DistanceUnits = {
DistanceUnit::Megaparsec, DistanceUnit::Gigaparsec
};
constexpr std::array<const char*, static_cast<int>(DistanceUnit::Gigaparsec) + 1>
DistanceUnitNamesSingular = {
DistanceUnitNanometer, DistanceUnitMicrometer, DistanceUnitMillimeter,
DistanceUnitMeter, DistanceUnitKilometer, DistanceUnitAU, DistanceUnitLighthour,
DistanceUnitLightday, DistanceUnitLightmonth, DistanceUnitLightyear,
DistanceUnitParsec, DistanceUnitKiloparsec, DistanceUnitMegaparsec,
DistanceUnitGigaparsec
};
constexpr std::array<const char*, static_cast<int>(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<int>(unit)];
}
else {
return DistanceUnitNamesSingular[static_cast<int>(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<DistanceUnit>(i);
}
++i;
}
i = 0;
for (const char* val : DistanceUnitNamesPlural) {
if (ghoul::equal(unitName, val)) {
return static_cast<DistanceUnit>(i);
}
++i;
}
ghoul_assert(false, "Unit name is not a valid name");
throw ghoul::MissingCaseException();
}
std::pair<double, std::string> 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

175
include/openspace/util/timeconversion.h
View File

@@ -25,12 +25,29 @@
#ifndef __OPENSPACE_CORE___TIMECONVERSION___H__
#define __OPENSPACE_CORE___TIMECONVERSION___H__
#include <ghoul/misc/assert.h>
#include <ghoul/misc/constexpr.h>
#include <array>
#include <chrono>
#include <string>
#include <utility>
namespace openspace {
constexpr double SecondsPerYear = 31556952; // seconds in average Gregorian year
constexpr double SecondsPerMonth = SecondsPerYear / 12;
constexpr double SecondsPerDay = static_cast<double>(
std::chrono::seconds(std::chrono::hours(24)).count()
);
constexpr double SecondsPerHour = static_cast<double>(
std::chrono::seconds(std::chrono::hours(1)).count()
);
constexpr double SecondsPerMinute = static_cast<double>(
std::chrono::seconds(std::chrono::minutes(1)).count()
);
// Assumption: static_cast<int>(TimeUnit) == position in the list
enum class TimeUnit {
Nanosecond = 0,
Microsecond,
@@ -42,20 +59,168 @@ enum class TimeUnit {
Month,
Year
};
constexpr std::array<TimeUnit, static_cast<int>(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, static_cast<int>(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<const char*, static_cast<int>(TimeUnit::Year) + 1>
TimeUnitNamesSingular = {
TimeUnitNanosecond, TimeUnitMicrosecond, TimeUnitMillisecond, TimeUnitSecond,
TimeUnitMinute, TimeUnitHour, TimeUnitDay, TimeUnitMonth, TimeUnitYear
};
constexpr std::array<const char*, static_cast<int>(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<int>(unit)];
}
else {
return TimeUnitNamesSingular[static_cast<int>(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<TimeUnit>(i);
}
++i;
}
i = 0;
for (const char* val : TimeUnitNamesPlural) {
if (ghoul::equal(unitName, val)) {
return static_cast<TimeUnit>(i);
}
++i;
}
ghoul_assert(false, "Unit name is not a valid name");
throw ghoul::MissingCaseException();
}
std::pair<double, std::string> 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

2
modules/base/dashboard/dashboarditemdistance.cpp
View File

@@ -349,7 +349,7 @@ DashboardItemDistance::DashboardItemDistance(ghoul::Dictionary dictionary)
_requestedUnit = static_cast<int>(DistanceUnit::Meter);
if (dictionary.hasKey(RequestedUnitInfo.identifier)) {
std::string value = dictionary.value<std::string>(RequestedUnitInfo.identifier);
DistanceUnit unit = distanceUnitFromString(value);
DistanceUnit unit = distanceUnitFromString(value.c_str());
_requestedUnit = static_cast<int>(unit);
}
_requestedUnit.setVisibility(properties::Property::Visibility::Hidden);

6
modules/base/dashboard/dashboarditemsimulationincrement.cpp
View File

@@ -171,7 +171,7 @@ DashboardItemSimulationIncrement::DashboardItemSimulationIncrement(
_requestedUnit = static_cast<int>(TimeUnit::Second);
if (dictionary.hasKey(RequestedUnitInfo.identifier)) {
std::string value = dictionary.value<std::string>(RequestedUnitInfo.identifier);
TimeUnit unit = timeUnitFromString(value);
TimeUnit unit = timeUnitFromString(value.c_str());
_requestedUnit = static_cast<int>(unit);
}
_requestedUnit.setVisibility(properties::Property::Visibility::Hidden);
@@ -188,7 +188,7 @@ void DashboardItemSimulationIncrement::render(glm::vec2& penPosition) {
}
else {
TimeUnit unit = static_cast<TimeUnit>(_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<TimeUnit>(_requestedUnit.value());
double convertedT = convertTime(t, unit);
double convertedT = convertTime(t, TimeUnit::Second, unit);
deltaTime = { convertedT, nameForTimeUnit(unit, convertedT != 1.0) };
}

18
modules/imgui/include/guispacetimecomponent.h
View File

@@ -28,6 +28,7 @@
#include <modules/imgui/include/guicomponent.h>
#include <openspace/properties/scalar/floatproperty.h>
#include <openspace/util/timeconversion.h>
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<int>(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

367
modules/imgui/src/guispacetimecomponent.cpp
View File

@@ -36,16 +36,18 @@
#include <openspace/util/timeconversion.h>
#include <openspace/util/timemanager.h>
#include <numeric>
#include <imgui_internal.h>
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<int>(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<float>(OsEng.timeManager().time().deltaTime());
// //std::pair<double, std::string> 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<int>(std::distance(nodes.begin(), iCurrentFocus));
//
//
// bool hasChanged = ImGui::Combo("", );
//
// bool hasChanged = ImGui::Combo("", &currentPosition, nodeNames.c_str());
//
// }
//
{
float deltaTime = static_cast<float>(OsEng.timeManager().time().deltaTime());
if (_firstFrame) {
std::pair<double, std::string> dt = simplifyTime(deltaTime);
_deltaTime = dt.first;
_deltaTimeUnit = static_cast<int>(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<TimeUnit>(_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<TimeUnit>(_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<TimeUnit>(_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<TimeUnit>(_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<TimeUnit>(_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<float>(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();

133
src/util/distanceconversion.cpp
View File

@@ -27,18 +27,6 @@
#include <openspace/util/distanceconstants.h>
#include <ghoul/glm.h>
#include <ghoul/misc/assert.h>
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<double, std::string> 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

101
src/util/timeconversion.cpp
View File

@@ -25,23 +25,8 @@
#include <openspace/util/timeconversion.h>
#include <ghoul/glm.h>
#include <ghoul/misc/assert.h>
#include <chrono>
namespace {
constexpr double SecondsPerYear = 31556952; // seconds in average Gregorian year
constexpr double SecondsPerMonth = SecondsPerYear / 12;
constexpr double SecondsPerDay = static_cast<double>(
std::chrono::seconds(std::chrono::hours(24)).count()
);
constexpr double SecondsPerHour = static_cast<double>(
std::chrono::seconds(std::chrono::hours(1)).count()
);
constexpr double SecondsPerMinute = static_cast<double>(
std::chrono::seconds(std::chrono::minutes(1)).count()
);
} // namespace
#include <cstring>
namespace openspace {
@@ -96,88 +81,4 @@ std::pair<double, std::string> 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