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

Make use of the new map feature in codegen (#1801)

Browse Source
This commit is contained in:
Alexander Bock
2022-01-02 13:36:41 +01:00
committed by GitHub
parent d7d279ea16
commit 21df9066e1
33 changed files with 279 additions and 882 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -52,6 +52,7 @@ enum class DistanceUnit {
Kiloparsec,
Megaparsec,
Gigaparsec,
Gigalightyear,
// Weird units
Thou,
@@ -81,6 +82,7 @@ constexpr const char* DistanceUnitParsec = "parsec";
constexpr const char* DistanceUnitKiloparsec = "kiloparsec";
constexpr const char* DistanceUnitMegaparsec = "megaparsec";
constexpr const char* DistanceUnitGigaparsec = "gigaparsec";
constexpr const char* DistanceUnitGigalightyear = "gigalightyear";
constexpr const char* DistanceUnitThou = "thou";
constexpr const char* DistanceUnitInch = "inch";
constexpr const char* DistanceUnitFoot = "foot";
@@ -108,6 +110,7 @@ constexpr const char* DistanceUnitParsecs = "parsecs";
constexpr const char* DistanceUnitKiloparsecs = "kiloparsecs";
constexpr const char* DistanceUnitMegaparsecs = "megaparsecs";
constexpr const char* DistanceUnitGigaparsecs = "gigaparsecs";
constexpr const char* DistanceUnitGigalightyears = "gigalightyears";
constexpr const char* DistanceUnitThous = "thou";
constexpr const char* DistanceUnitInches = "inches";
constexpr const char* DistanceUnitFeet = "feet";
@@ -124,9 +127,9 @@ DistanceUnits = {
DistanceUnit::Kilometer, DistanceUnit::AU, DistanceUnit::Lighthour,
DistanceUnit::Lightday, DistanceUnit::Lightmonth, DistanceUnit::Lightyear,
DistanceUnit::Parsec, DistanceUnit::Kiloparsec, DistanceUnit::Megaparsec,
DistanceUnit::Gigaparsec, DistanceUnit::Thou, DistanceUnit::Inch,
DistanceUnit::Foot, DistanceUnit::Yard, DistanceUnit::Chain, DistanceUnit::Furlong,
DistanceUnit::Mile, DistanceUnit::League
DistanceUnit::Gigaparsec, DistanceUnit::Gigalightyear, DistanceUnit::Thou,
DistanceUnit::Inch, DistanceUnit::Foot, DistanceUnit::Yard, DistanceUnit::Chain,
DistanceUnit::Furlong, DistanceUnit::Mile, DistanceUnit::League
};
constexpr const std::array<const char*, static_cast<int>(DistanceUnit::League) + 1>
@@ -136,9 +139,9 @@ DistanceUnitNamesSingular = {
DistanceUnitKilometer, DistanceUnitAU, DistanceUnitLighthour,
DistanceUnitLightday, DistanceUnitLightmonth, DistanceUnitLightyear,
DistanceUnitParsec, DistanceUnitKiloparsec, DistanceUnitMegaparsec,
DistanceUnitGigaparsec, DistanceUnitThou, DistanceUnitInch, DistanceUnitFoot,
DistanceUnitYard, DistanceUnitChain, DistanceUnitFurlong, DistanceUnitMile,
DistanceUnitLeague
DistanceUnitGigaparsec, DistanceUnitGigalightyear, DistanceUnitThou, DistanceUnitInch,
DistanceUnitFoot, DistanceUnitYard, DistanceUnitChain, DistanceUnitFurlong,
DistanceUnitMile, DistanceUnitLeague
};
constexpr const std::array<const char*, static_cast<int>(DistanceUnit::League) + 1>
@@ -148,9 +151,9 @@ DistanceUnitNamesPlural = {
DistanceUnitKilometers, DistanceUnitAUs, DistanceUnitLighthours,
DistanceUnitLightdays, DistanceUnitLightmonths, DistanceUnitLightyears,
DistanceUnitParsecs, DistanceUnitKiloparsecs, DistanceUnitMegaparsecs,
DistanceUnitGigaparsecs, DistanceUnitThous, DistanceUnitInches, DistanceUnitFeet,
DistanceUnitYards, DistanceUnitChains, DistanceUnitFurlongs, DistanceUnitMile,
DistanceUnitLeague
DistanceUnitGigaparsecs, DistanceUnitGigalightyears, DistanceUnitThous,
DistanceUnitInches, DistanceUnitFeet, DistanceUnitYards, DistanceUnitChains,
DistanceUnitFurlongs, DistanceUnitMile, DistanceUnitLeague
};
constexpr bool isValidDistanceUnitName(const char* name) {
@@ -190,6 +193,7 @@ constexpr const char* nameForDistanceUnit(DistanceUnit unit, bool pluralForm = f
case DistanceUnit::Kiloparsec:
case DistanceUnit::Megaparsec:
case DistanceUnit::Gigaparsec:
case DistanceUnit::Gigalightyear:
case DistanceUnit::Thou:
case DistanceUnit::Inch:
case DistanceUnit::Foot:
@@ -277,6 +281,8 @@ constexpr double convertMeters(double meters, DistanceUnit requestedUnit) {
return meters / (1e6 * distanceconstants::Parsec);
case DistanceUnit::Gigaparsec:
return meters / (1e9 * distanceconstants::Parsec);
case DistanceUnit::Gigalightyear:
return meters / (1e9 * distanceconstants::LightYear);
case DistanceUnit::Thou:
return meters / (1e-3 * distanceconstants::Inch);
case DistanceUnit::Inch:
@@ -332,6 +338,8 @@ constexpr double toMeter(DistanceUnit unit) {
return 1e6 * distanceconstants::Parsec;
case DistanceUnit::Gigaparsec:
return 1e9 * distanceconstants::Parsec;
case DistanceUnit::Gigalightyear:
return 1e9 * distanceconstants::LightYear;
case DistanceUnit::Thou:
return 1e-3 * distanceconstants::Inch;
case DistanceUnit::Inch:

44
modules/base/dashboard/dashboarditemangle.cpp
View File

@@ -40,6 +40,12 @@
#include <ghoul/misc/profiling.h>
namespace {
enum Type {
Node = 0,
Focus,
Camera
};
constexpr openspace::properties::Property::PropertyInfo SourceTypeInfo = {
"SourceType",
"Source Type",
@@ -87,7 +93,7 @@ namespace {
};
struct [[codegen::Dictionary(DashboardItemAngle)]] Parameters {
enum class Type {
enum class [[codegen::map(Type)]] Type {
Node,
Focus,
Camera
@@ -155,17 +161,7 @@ DashboardItemAngle::DashboardItemAngle(const ghoul::Dictionary& dictionary)
);
});
if (p.sourceType.has_value()) {
switch (*p.sourceType) {
case Parameters::Type::Node:
_source.type = Type::Node;
break;
case Parameters::Type::Focus:
_source.type = Type::Focus;
break;
default:
_source.type = Type::Camera;
break;
}
_source.type = codegen::map<Type>(*p.sourceType);
}
else {
_source.type = Type::Camera;
@@ -197,17 +193,7 @@ DashboardItemAngle::DashboardItemAngle(const ghoul::Dictionary& dictionary)
properties::Property::Visibility(_reference.type == Type::Node)
);
});
switch (p.referenceType) {
case Parameters::Type::Node:
_reference.type = Type::Node;
break;
case Parameters::Type::Focus:
_reference.type = Type::Focus;
break;
default:
_reference.type = Type::Camera;
break;
}
_reference.type = codegen::map<Type>(p.referenceType);
addProperty(_reference.type);
_reference.nodeName.onChange([this]() { _reference.node = nullptr; });
@@ -235,17 +221,7 @@ DashboardItemAngle::DashboardItemAngle(const ghoul::Dictionary& dictionary)
);
});
if (p.destinationType.has_value()) {
switch (*p.destinationType) {
case Parameters::Type::Node:
_destination.type = Type::Node;
break;
case Parameters::Type::Focus:
_destination.type = Type::Focus;
break;
default:
_destination.type = Type::Camera;
break;
}
_destination.type = codegen::map<Type>(*p.destinationType);
}
else {
_destination.type = Type::Focus;

6
modules/base/dashboard/dashboarditemangle.h
View File

@@ -49,12 +49,6 @@ public:
static documentation::Documentation Documentation();
private:
enum Type {
Node = 0,
Focus,
Camera
};
struct Component {
properties::OptionProperty type;
properties::StringProperty nodeName;

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

@@ -41,6 +41,13 @@
#include <ghoul/misc/profiling.h>
namespace {
enum Type {
Node = 0,
NodeSurface,
Focus,
Camera
};
constexpr openspace::properties::Property::PropertyInfo SourceTypeInfo = {
"SourceType",
"Source Type",
@@ -106,7 +113,7 @@ namespace {
}
struct [[codegen::Dictionary(DashboardItemDistance)]] Parameters {
enum class TypeInfo {
enum class [[codegen::map(Type)]] TypeInfo {
Node,
NodeSurface [[codegen::key("Node Surface")]],
Focus,
@@ -181,20 +188,7 @@ DashboardItemDistance::DashboardItemDistance(const ghoul::Dictionary& dictionary
);
});
if (p.sourceType.has_value()) {
switch (*p.sourceType) {
case Parameters::TypeInfo::Node:
_source.type = Type::Node;
break;
case Parameters::TypeInfo::NodeSurface:
_source.type = Type::NodeSurface;
break;
case Parameters::TypeInfo::Focus:
_source.type = Type::Focus;
break;
case Parameters::TypeInfo::Camera:
_source.type = Type::Camera;
break;
}
_source.type = codegen::map<Type>(*p.sourceType);
}
else {
_source.type = Type::Camera;
@@ -229,20 +223,7 @@ DashboardItemDistance::DashboardItemDistance(const ghoul::Dictionary& dictionary
);
});
if (p.destinationType.has_value()) {
switch (*p.destinationType) {
case Parameters::TypeInfo::Node:
_destination.type = Type::Node;
break;
case Parameters::TypeInfo::NodeSurface:
_destination.type = Type::NodeSurface;
break;
case Parameters::TypeInfo::Focus:
_destination.type = Type::Focus;
break;
case Parameters::TypeInfo::Camera:
_destination.type = Type::Camera;
break;
}
_destination.type = codegen::map<Type>(*p.destinationType);
}
else {
_destination.type = Type::Focus;

7
modules/base/dashboard/dashboarditemdistance.h
View File

@@ -52,13 +52,6 @@ public:
bool storyStyleActive();
private:
enum Type {
Node = 0,
NodeSurface,
Focus,
Camera
};
struct Component {
properties::OptionProperty type;
properties::StringProperty nodeName;

53
modules/base/dashboard/dashboarditemframerate.cpp
View File

@@ -35,6 +35,16 @@
#include <optional>
namespace {
enum FrametimeType {
DtTimeAvg = 0,
DtTimeExtremes,
DtStandardDeviation,
DtCoefficientOfVariation,
FPS,
FPSAvg,
None
};
constexpr openspace::properties::Property::PropertyInfo FrametimeInfo = {
"FrametimeType",
"Type of the frame time display",
@@ -104,23 +114,22 @@ namespace {
);
}
[[ nodiscard ]] char* format(std::vector<char>& buffer,
openspace::DashboardItemFramerate::FrametimeType frametimeType,
[[ nodiscard ]] char* format(std::vector<char>& buffer, FrametimeType frametimeType,
double minFrametimeCache, double maxFrametimeCache)
{
using namespace openspace;
switch (frametimeType) {
case DashboardItemFramerate::FrametimeType::DtTimeAvg:
case FrametimeType::DtTimeAvg:
return formatDt(buffer);
case DashboardItemFramerate::FrametimeType::DtTimeExtremes:
case FrametimeType::DtTimeExtremes:
return formatDtExtremes(buffer, minFrametimeCache, maxFrametimeCache);
case DashboardItemFramerate::FrametimeType::DtStandardDeviation:
case FrametimeType::DtStandardDeviation:
return formatDtStandardDeviation(buffer);
case DashboardItemFramerate::FrametimeType::DtCoefficientOfVariation:
case FrametimeType::DtCoefficientOfVariation:
return formatDtCoefficientOfVariation(buffer);
case DashboardItemFramerate::FrametimeType::FPS:
case FrametimeType::FPS:
return formatFps(buffer);
case DashboardItemFramerate::FrametimeType::FPSAvg:
case FrametimeType::FPSAvg:
return formatAverageFps(buffer);
default:
throw ghoul::MissingCaseException();
@@ -128,9 +137,9 @@ namespace {
}
struct [[codegen::Dictionary(DashboardItemFramerate)]] Parameters {
enum class Type {
DtAvg [[codegen::key("Average Deltatime")]],
DtExtremes [[codegen::key("Deltatime extremes")]],
enum class [[codegen::map(FrametimeType)]] Type {
DtTimeAvg [[codegen::key("Average Deltatime")]],
DtTimeExtremes [[codegen::key("Deltatime extremes")]],
DtStandardDeviation [[codegen::key("Deltatime standard deviation")]],
DtCoefficientOfVariation
[[codegen::key("Deltatime coefficient of variation")]],
@@ -175,27 +184,7 @@ DashboardItemFramerate::DashboardItemFramerate(const ghoul::Dictionary& dictiona
});
if (p.frametimeType.has_value()) {
switch (*p.frametimeType) {
case Parameters::Type::DtAvg:
_frametimeType = static_cast<int>(FrametimeType::DtTimeAvg);
break;
case Parameters::Type::DtExtremes:
_frametimeType = static_cast<int>(FrametimeType::DtTimeExtremes);
break;
case Parameters::Type::DtStandardDeviation:
_frametimeType = static_cast<int>(FrametimeType::DtStandardDeviation);
break;
case Parameters::Type::DtCoefficientOfVariation:
_frametimeType =
static_cast<int>(FrametimeType::DtCoefficientOfVariation);
break;
case Parameters::Type::FPS:
_frametimeType = static_cast<int>(FrametimeType::FPS);
break;
case Parameters::Type::FPSAvg:
_frametimeType = static_cast<int>(FrametimeType::FPSAvg);
break;
}
_frametimeType = codegen::map<FrametimeType>(*p.frametimeType);
}
else {
_frametimeType = static_cast<int>(FrametimeType::FPSAvg);

10
modules/base/dashboard/dashboarditemframerate.h
View File

@@ -38,16 +38,6 @@ namespace documentation { struct Documentation; }
class DashboardItemFramerate : public DashboardTextItem {
public:
enum class FrametimeType {
DtTimeAvg = 0,
DtTimeExtremes,
DtStandardDeviation,
DtCoefficientOfVariation,
FPS,
FPSAvg,
None
};
DashboardItemFramerate(const ghoul::Dictionary& dictionary);
void render(glm::vec2& penPosition) override;

134
modules/base/rendering/renderablelabels.cpp
View File

@@ -53,7 +53,7 @@ namespace {
constexpr const char* KilometerUnit = "Km";
constexpr const char* MegameterUnit = "Mm";
constexpr const char* GigameterUnit = "Gm";
constexpr const char* AstronomicalUnit = "au";
constexpr const char* AstronomicalUnitUnit = "au";
constexpr const char* TerameterUnit = "Tm";
constexpr const char* PetameterUnit = "Pm";
constexpr const char* ParsecUnit = "pc";
@@ -63,12 +63,29 @@ namespace {
constexpr const char* GigalightyearUnit = "Gly";
enum BlendMode {
BlendModeNormal = 0,
BlendModeAdditive
Normal = 0,
Additive
};
constexpr const int ViewDirection = 0;
constexpr const int NormalDirection = 1;
enum Orientation {
ViewDirection = 0,
PositionNormal
};
enum Unit {
Meter = 0,
Kilometer,
Megameter,
Gigameter,
AstronomicalUnit,
Terameter,
Petameter,
Parsec,
KiloParsec,
MegaParsec,
GigaParsec,
GigaLightyear
};
constexpr double PARSEC = 0.308567756E17;
@@ -150,7 +167,7 @@ namespace {
};
struct [[codegen::Dictionary(RenderableLabels)]] Parameters {
enum class BlendMode {
enum class [[codegen::map(BlendMode)]] BlendMode {
Normal,
Additive
};
@@ -158,7 +175,7 @@ namespace {
// [[codegen::verbatim(BlendModeInfo.description)]]
std::optional<BlendMode> blendMode;
enum class Orientation {
enum class [[codegen::map(Orientation)]] Orientation {
ViewDirection [[codegen::key("Camera View Direction")]],
PositionNormal [[codegen::key("Camera Position Normal")]]
};
@@ -187,7 +204,7 @@ namespace {
// [[codegen::verbatim(TransformationMatrixInfo.description)]]
std::optional<glm::dmat4x4> transformationMatrix;
enum class Unit {
enum class [[codegen::map(Unit)]] Unit {
Meter [[codegen::key("m")]],
Kilometer [[codegen::key("Km")]],
Megameter [[codegen::key("Mm")]],
@@ -246,15 +263,15 @@ RenderableLabels::RenderableLabels(const ghoul::Dictionary& dictionary)
registerUpdateRenderBinFromOpacity();
_blendMode.addOptions({
{ BlendModeNormal, "Normal" },
{ BlendModeAdditive, "Additive"}
{ BlendMode::Normal, "Normal" },
{ BlendMode::Additive, "Additive"}
});
_blendMode.onChange([&]() {
switch (_blendMode) {
case BlendModeNormal:
case BlendMode::Normal:
setRenderBinFromOpacity();
break;
case BlendModeAdditive:
case BlendMode::Additive:
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
break;
default:
@@ -263,31 +280,17 @@ RenderableLabels::RenderableLabels(const ghoul::Dictionary& dictionary)
});
if (p.blendMode.has_value()) {
switch (*p.blendMode) {
case Parameters::BlendMode::Normal:
_blendMode = BlendModeNormal;
break;
case Parameters::BlendMode::Additive:
_blendMode = BlendModeAdditive;
break;
}
_blendMode = codegen::map<BlendMode>(*p.blendMode);
}
addProperty(_blendMode);
_orientationOption.addOption(ViewDirection, "Camera View Direction");
_orientationOption.addOption(NormalDirection, "Camera Position Normal");
_orientationOption.addOption(PositionNormal, "Camera Position Normal");
_orientationOption = NormalDirection;
_orientationOption = PositionNormal;
if (p.orientationOption.has_value()) {
switch (*p.orientationOption) {
case Parameters::Orientation::ViewDirection:
_orientationOption = ViewDirection;
break;
case Parameters::Orientation::PositionNormal:
_orientationOption = NormalDirection;
break;
}
_orientationOption = codegen::map<Orientation>(*p.orientationOption);
}
addProperty(_orientationOption);
@@ -329,57 +332,20 @@ RenderableLabels::RenderableLabels(const ghoul::Dictionary& dictionary)
_fadeUnitOption.addOption(Kilometer, KilometerUnit);
_fadeUnitOption.addOption(Megameter, MegameterUnit);
_fadeUnitOption.addOption(Gigameter, GigameterUnit);
_fadeUnitOption.addOption(AU, AstronomicalUnit);
_fadeUnitOption.addOption(AstronomicalUnit, AstronomicalUnitUnit);
_fadeUnitOption.addOption(Terameter, TerameterUnit);
_fadeUnitOption.addOption(Petameter, PetameterUnit);
_fadeUnitOption.addOption(Parsec, ParsecUnit);
_fadeUnitOption.addOption(Kiloparsec, KiloparsecUnit);
_fadeUnitOption.addOption(Megaparsec, MegaparsecUnit);
_fadeUnitOption.addOption(Gigaparsec, GigaparsecUnit);
_fadeUnitOption.addOption(GigalightYears, GigalightyearUnit);
_fadeUnitOption.addOption(KiloParsec, KiloparsecUnit);
_fadeUnitOption.addOption(MegaParsec, MegaparsecUnit);
_fadeUnitOption.addOption(GigaParsec, GigaparsecUnit);
_fadeUnitOption.addOption(GigaLightyear, GigalightyearUnit);
if (p.fadeUnit.has_value()) {
switch (*p.fadeUnit) {
case Parameters::Unit::Meter:
_fadeUnitOption = Meter;
break;
case Parameters::Unit::Kilometer:
_fadeUnitOption = Kilometer;
break;
case Parameters::Unit::Megameter:
_fadeUnitOption = Megameter;
break;
case Parameters::Unit::Gigameter:
_fadeUnitOption = Gigameter;
break;
case Parameters::Unit::Terameter:
_fadeUnitOption = Terameter;
break;
case Parameters::Unit::Petameter:
_fadeUnitOption = Petameter;
break;
case Parameters::Unit::AstronomicalUnit:
_fadeUnitOption = AU;
break;
case Parameters::Unit::Parsec:
_fadeUnitOption = Parsec;
break;
case Parameters::Unit::KiloParsec:
_fadeUnitOption = Kiloparsec;
break;
case Parameters::Unit::MegaParsec:
_fadeUnitOption = Megaparsec;
break;
case Parameters::Unit::GigaParsec:
_fadeUnitOption = Gigaparsec;
break;
case Parameters::Unit::GigaLightyear:
_fadeUnitOption = GigalightYears;
break;
}
_fadeUnitOption = codegen::map<Unit>(*p.fadeUnit);
}
else {
_fadeUnitOption = AU;
_fadeUnitOption = AstronomicalUnit;
}
addProperty(_fadeUnitOption);
@@ -533,14 +499,14 @@ float RenderableLabels::unit(int unit) const {
case Kilometer: return 1e3f;
case Megameter: return 1e6f;
case Gigameter: return 1e9f;
case AU: return 149597870700.f;
case AstronomicalUnit: return 149597870700.f;
case Terameter: return 1e12f;
case Petameter: return 1e15f;
case Parsec: return static_cast<float>(PARSEC);
case Kiloparsec: return static_cast<float>(1e3 * PARSEC);
case Megaparsec: return static_cast<float>(1e6 * PARSEC);
case Gigaparsec: return static_cast<float>(1e9 * PARSEC);
case GigalightYears: return static_cast<float>(306391534.73091 * PARSEC);
case KiloParsec: return static_cast<float>(1e3 * PARSEC);
case MegaParsec: return static_cast<float>(1e6 * PARSEC);
case GigaParsec: return static_cast<float>(1e9 * PARSEC);
case GigaLightyear: return static_cast<float>(306391534.73091 * PARSEC);
default: throw std::logic_error("Missing case label");
}
}
@@ -551,14 +517,14 @@ std::string RenderableLabels::toString(int unit) const {
case Kilometer: return KilometerUnit;
case Megameter: return MegameterUnit;
case Gigameter: return GigameterUnit;
case AU: return AstronomicalUnit;
case AstronomicalUnit: return AstronomicalUnitUnit;
case Terameter: return TerameterUnit;
case Petameter: return PetameterUnit;
case Parsec: return ParsecUnit;
case Kiloparsec: return KiloparsecUnit;
case Megaparsec: return MegaparsecUnit;
case Gigaparsec: return GigaparsecUnit;
case GigalightYears: return GigalightyearUnit;
case KiloParsec: return KiloparsecUnit;
case MegaParsec: return MegaparsecUnit;
case GigaParsec: return GigaparsecUnit;
case GigaLightyear: return GigalightyearUnit;
default: throw std::logic_error("Missing case label");
}
}

15
modules/base/rendering/renderablelabels.h
View File

@@ -81,21 +81,6 @@ protected:
// applied
glm::dmat4 _transformationMatrix = glm::dmat4(1.0);
enum Unit {
Meter = 0,
Kilometer,
Megameter,
Gigameter,
AU,
Terameter,
Petameter,
Parsec,
Kiloparsec,
Megaparsec,
Gigaparsec,
GigalightYears
};
private:
void renderLabels(const RenderData& data, const glm::dmat4& modelViewProjectionMatrix,
const glm::dvec3& orthoRight, const glm::dvec3& orthoUp, float fadeInVariable);

77
modules/base/rendering/renderablemodel.cpp
View File

@@ -150,7 +150,7 @@ namespace {
// the Renderable.
std::filesystem::path geometryFile;
enum class ScaleUnit {
enum class [[codegen::map(openspace::DistanceUnit)]] ScaleUnit {
Nanometer,
Micrometer,
Millimeter,
@@ -189,7 +189,7 @@ namespace {
// In format 'YYYY MM DD hh:mm:ss'.
std::optional<std::string> animationStartTime [[codegen::datetime()]];
enum class AnimationTimeUnit {
enum class [[codegen::map(openspace::TimeUnit)]] AnimationTimeUnit {
Nanosecond,
Microsecond,
Millisecond,
@@ -318,56 +318,7 @@ RenderableModel::RenderableModel(const ghoul::Dictionary& dictionary)
if (std::holds_alternative<Parameters::ScaleUnit>(*p.modelScale)) {
Parameters::ScaleUnit scaleUnit =
std::get<Parameters::ScaleUnit>(*p.modelScale);
DistanceUnit distanceUnit;
switch (scaleUnit) {
case Parameters::ScaleUnit::Nanometer:
distanceUnit = DistanceUnit::Nanometer;
break;
case Parameters::ScaleUnit::Micrometer:
distanceUnit = DistanceUnit::Micrometer;
break;
case Parameters::ScaleUnit::Millimeter:
distanceUnit = DistanceUnit::Millimeter;
break;
case Parameters::ScaleUnit::Centimeter:
distanceUnit = DistanceUnit::Centimeter;
break;
case Parameters::ScaleUnit::Decimeter:
distanceUnit = DistanceUnit::Decimeter;
break;
case Parameters::ScaleUnit::Meter:
distanceUnit = DistanceUnit::Meter;
break;
case Parameters::ScaleUnit::Kilometer:
distanceUnit = DistanceUnit::Kilometer;
break;
// Weird units
case Parameters::ScaleUnit::Thou:
distanceUnit = DistanceUnit::Thou;
break;
case Parameters::ScaleUnit::Inch:
distanceUnit = DistanceUnit::Inch;
break;
case Parameters::ScaleUnit::Foot:
distanceUnit = DistanceUnit::Foot;
break;
case Parameters::ScaleUnit::Yard:
distanceUnit = DistanceUnit::Yard;
break;
case Parameters::ScaleUnit::Chain:
distanceUnit = DistanceUnit::Chain;
break;
case Parameters::ScaleUnit::Furlong:
distanceUnit = DistanceUnit::Furlong;
break;
case Parameters::ScaleUnit::Mile:
distanceUnit = DistanceUnit::Mile;
break;
default:
throw ghoul::MissingCaseException();
}
DistanceUnit distanceUnit = codegen::map<DistanceUnit>(scaleUnit);
_modelScale = toMeter(distanceUnit);
}
else if (std::holds_alternative<double>(*p.modelScale)) {
@@ -415,27 +366,7 @@ RenderableModel::RenderableModel(const ghoul::Dictionary& dictionary)
{
Parameters::AnimationTimeUnit animationTimeUnit =
std::get<Parameters::AnimationTimeUnit>(*p.animationTimeScale);
TimeUnit timeUnit;
switch (animationTimeUnit) {
case Parameters::AnimationTimeUnit::Nanosecond:
timeUnit = TimeUnit::Nanosecond;
break;
case Parameters::AnimationTimeUnit::Microsecond:
timeUnit = TimeUnit::Microsecond;
break;
case Parameters::AnimationTimeUnit::Millisecond:
timeUnit = TimeUnit::Millisecond;
break;
case Parameters::AnimationTimeUnit::Second:
timeUnit = TimeUnit::Second;
break;
case Parameters::AnimationTimeUnit::Minute:
timeUnit = TimeUnit::Minute;
break;
default:
throw ghoul::MissingCaseException();
}
TimeUnit timeUnit = codegen::map<TimeUnit>(animationTimeUnit);
_geometry->setTimeScale(static_cast<float>(
convertTime(1.0, timeUnit, TimeUnit::Second))

11
modules/base/rendering/renderableplane.cpp
View File

@@ -45,7 +45,7 @@
namespace {
constexpr const char* ProgramName = "Plane";
enum class BlendMode {
enum BlendMode {
Normal = 0,
Additive
};
@@ -95,7 +95,7 @@ namespace {
// [[codegen::verbatim(SizeInfo.description)]]
float size;
enum class BlendMode {
enum class [[codegen::map(BlendMode)]] BlendMode {
Normal,
Additive
};
@@ -155,12 +155,7 @@ RenderablePlane::RenderablePlane(const ghoul::Dictionary& dictionary)
});
if (p.blendMode.has_value()) {
if (*p.blendMode == Parameters::BlendMode::Normal) {
_blendMode = static_cast<int>(BlendMode::Normal);
}
else if (*p.blendMode == Parameters::BlendMode::Additive) {
_blendMode = static_cast<int>(BlendMode::Additive);
}
_blendMode = codegen::map<BlendMode>(*p.blendMode);
}
_multiplyColor = p.multiplyColor.value_or(_multiplyColor);

24
modules/base/rendering/renderableplaneimagelocal.cpp
View File

@@ -56,11 +56,11 @@ namespace {
// [[codegen::verbatim(TextureInfo.description)]]
std::string texture;
enum class RenderType {
enum class [[codegen::map(openspace::Renderable::RenderBin)]] RenderType {
Background,
Opaque,
PreDeferredTransparency,
PostDeferredTransparency,
PreDeferredTransparent [[codegen::key("PreDeferredTransparency")]],
PostDeferredTransparent [[codegen::key("PostDeferredTransparency")]],
Overlay
};
@@ -110,23 +110,7 @@ RenderablePlaneImageLocal::RenderablePlaneImageLocal(const ghoul::Dictionary& di
_textureFile->setCallback([this]() { _textureIsDirty = true; });
if (p.renderType.has_value()) {
switch (*p.renderType) {
case Parameters::RenderType::Background:
setRenderBin(Renderable::RenderBin::Background);
break;
case Parameters::RenderType::Opaque:
setRenderBin(Renderable::RenderBin::Opaque);
break;
case Parameters::RenderType::PreDeferredTransparency:
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
break;
case Parameters::RenderType::PostDeferredTransparency:
setRenderBin(Renderable::RenderBin::PostDeferredTransparent);
break;
case Parameters::RenderType::Overlay:
setRenderBin(Renderable::RenderBin::Overlay);
break;
}
setRenderBin(codegen::map<Renderable::RenderBin>(*p.renderType));
}
else {
setRenderBin(Renderable::RenderBin::Opaque);

24
modules/base/rendering/renderableplanetimevaryingimage.cpp
View File

@@ -59,11 +59,11 @@ namespace {
// [[codegen::verbatim(SourceFolderInfo.description)]]
std::string sourceFolder;
enum class RenderType {
enum class [[codegen::map(openspace::Renderable::RenderBin)]] RenderType {
Background,
Opaque,
PreDeferredTransparency,
PostDeferredTransparency,
PreDeferredTransparent [[codegen::key("PreDeferredTransparency")]],
PostDeferredTransparent [[codegen::key("PostDeferredTransparency")]],
Overlay
};
@@ -113,23 +113,7 @@ RenderablePlaneTimeVaryingImage::RenderablePlaneTimeVaryingImage(
_sourceFolder.onChange([this]() { _texture = loadTexture(); });
if (p.renderType.has_value()) {
switch (*p.renderType) {
case Parameters::RenderType::Background:
setRenderBin(Renderable::RenderBin::Background);
break;
case Parameters::RenderType::Opaque:
setRenderBin(Renderable::RenderBin::Opaque);
break;
case Parameters::RenderType::PreDeferredTransparency:
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
break;
case Parameters::RenderType::PostDeferredTransparency:
setRenderBin(Renderable::RenderBin::PostDeferredTransparent);
break;
case Parameters::RenderType::Overlay:
setRenderBin(Renderable::RenderBin::Overlay);
break;
}
setRenderBin(codegen::map<Renderable::RenderBin>(*p.renderType));
}
else {
setRenderBin(Renderable::RenderBin::Opaque);

16
modules/base/rendering/renderablesphere.cpp
View File

@@ -129,7 +129,7 @@ namespace {
// [[codegen::verbatim(TextureInfo.description)]]
std::string texture;
enum class Orientation {
enum class [[codegen::map(Orientation)]] Orientation {
Outside,
Inside,
Both
@@ -194,19 +194,7 @@ RenderableSphere::RenderableSphere(const ghoul::Dictionary& dictionary)
});
if (p.orientation.has_value()) {
switch (*p.orientation) {
case Parameters::Orientation::Inside:
_orientation = static_cast<int>(Orientation::Inside);
break;
case Parameters::Orientation::Outside:
_orientation = static_cast<int>(Orientation::Outside);
break;
case Parameters::Orientation::Both:
_orientation = static_cast<int>(Orientation::Both);
break;
default:
throw ghoul::MissingCaseException();
}
_orientation = static_cast<int>(codegen::map<Orientation>(*p.orientation));
}
else {
_orientation = static_cast<int>(Orientation::Outside);

16
modules/base/rendering/renderabletimevaryingsphere.cpp
View File

@@ -133,7 +133,7 @@ namespace {
// [[codegen::verbatim(TextureSourceInfo.description)]]
std::string textureSource;
enum class Orientation {
enum class [[codegen::map(Orientation)]] Orientation {
Outside,
Inside,
Both
@@ -201,19 +201,7 @@ RenderableTimeVaryingSphere::RenderableTimeVaryingSphere(
});
if (p.orientation.has_value()) {
switch (*p.orientation) {
case Parameters::Orientation::Inside:
_orientation = static_cast<int>(Orientation::Inside);
break;
case Parameters::Orientation::Outside:
_orientation = static_cast<int>(Orientation::Outside);
break;
case Parameters::Orientation::Both:
_orientation = static_cast<int>(Orientation::Both);
break;
default:
throw ghoul::MissingCaseException();
}
_orientation = static_cast<int>(codegen::map<Orientation>(*p.orientation));
}
else {
_orientation = static_cast<int>(Orientation::Outside);

22
modules/base/rendering/renderabletrailorbit.cpp
View File

@@ -119,7 +119,7 @@ namespace {
// [[codegen::verbatim(ResolutionInfo.description)]]
int resolution;
enum class RenderableType {
enum class [[codegen::map(openspace::Renderable::RenderBin)]] RenderableType {
Background,
Opaque,
PreDeferredTransparent,
@@ -177,25 +177,7 @@ RenderableTrailOrbit::RenderableTrailOrbit(const ghoul::Dictionary& dictionary)
_primaryRenderInformation.sorting = RenderInformation::VertexSorting::NewestFirst;
if (p.renderableType.has_value()) {
switch (*p.renderableType) {
case Parameters::RenderableType::Background:
setRenderBin(Renderable::RenderBin::Background);
break;
case Parameters::RenderableType::Opaque:
setRenderBin(Renderable::RenderBin::Opaque);
break;
case Parameters::RenderableType::PreDeferredTransparent:
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
break;
case Parameters::RenderableType::PostDeferredTransparent:
setRenderBin(Renderable::RenderBin::PostDeferredTransparent);
break;
case Parameters::RenderableType::Overlay:
setRenderBin(Renderable::RenderBin::Overlay);
break;
default:
throw ghoul::MissingCaseException();
}
setRenderBin(codegen::map<Renderable::RenderBin>(*p.renderableType));
}
else {
setRenderBin(Renderable::RenderBin::Overlay);

22
modules/debugging/rendering/renderabledebugplane.cpp
View File

@@ -84,7 +84,7 @@ namespace {
// [[codegen::verbatim(SizeInfo.description)]]
std::optional<float> size;
enum class Origin {
enum class [[codegen::map(Origin)]] Origin {
LowerLeft,
LowerRight,
UpperLeft,
@@ -134,25 +134,7 @@ RenderableDebugPlane::RenderableDebugPlane(const ghoul::Dictionary& dictionary)
_origin.setValue(Center);
if (p.origin.has_value()) {
switch (*p.origin) {
case Parameters::Origin::LowerLeft:
_origin = LowerLeft;
break;
case Parameters::Origin::LowerRight:
_origin = LowerRight;
break;
case Parameters::Origin::UpperLeft:
_origin = UpperLeft;
break;
case Parameters::Origin::UpperRight:
_origin = UpperRight;
break;
case Parameters::Origin::Center:
_origin = Center;
break;
default:
throw ghoul::MissingCaseException();
}
_origin = codegen::map<Origin>(*p.origin);
}
else {
_origin = Center;

74
modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
View File

@@ -69,8 +69,10 @@ namespace {
constexpr double PARSEC = 0.308567756E17;
constexpr const int RenderOptionViewDirection = 0;
constexpr const int RenderOptionPositionNormal = 1;
enum RenderOption {
ViewDirection = 0,
PositionNormal
};
constexpr openspace::properties::Property::PropertyInfo SpriteTextureInfo = {
"Texture",
@@ -230,21 +232,21 @@ namespace {
// [[codegen::verbatim(DrawElementsInfo.description)]]
std::optional<bool> drawElements;
enum class RenderOption {
enum class [[codegen::map(RenderOption)]] RenderOption {
ViewDirection [[codegen::key("Camera View Direction")]],
PositionNormal [[codegen::key("Camera Position Normal")]]
};
// [[codegen::verbatim(RenderOptionInfo.description)]]
std::optional<RenderOption> renderOption;
enum class Unit {
enum class [[codegen::map(openspace::DistanceUnit)]] Unit {
Meter [[codegen::key("m")]],
Kilometer [[codegen::key("Km")]],
Parsec [[codegen::key("pc")]],
Kiloparsec [[codegen::key("Kpc")]],
Megaparsec [[codegen::key("Mpc")]],
Gigaparsec [[codegen::key("Gpc")]],
GigalightYears [[codegen::key("Gly")]]
Gigalightyear [[codegen::key("Gly")]]
};
// The unit used for all distances. Must match the unit of any
// distances/positions in the data files
@@ -378,52 +380,22 @@ RenderableBillboardsCloud::RenderableBillboardsCloud(const ghoul::Dictionary& di
_drawElements.onChange([&]() { _hasSpeckFile = !_hasSpeckFile; });
addProperty(_drawElements);
_renderOption.addOption(RenderOptionViewDirection, "Camera View Direction");
_renderOption.addOption(RenderOptionPositionNormal, "Camera Position Normal");
_renderOption.addOption(RenderOption::ViewDirection, "Camera View Direction");
_renderOption.addOption(RenderOption::PositionNormal, "Camera Position Normal");
if (p.renderOption.has_value()) {
switch (*p.renderOption) {
case Parameters::RenderOption::ViewDirection:
_renderOption = RenderOptionViewDirection;
break;
case Parameters::RenderOption::PositionNormal:
_renderOption = RenderOptionPositionNormal;
break;
}
_renderOption = codegen::map<RenderOption>(*p.renderOption);
}
else {
_renderOption = RenderOptionViewDirection;
_renderOption = RenderOption::ViewDirection;
}
addProperty(_renderOption);
if (p.unit.has_value()) {
switch (*p.unit) {
case Parameters::Unit::Meter:
_unit = Meter;
break;
case Parameters::Unit::Kilometer:
_unit = Kilometer;
break;
case Parameters::Unit::Parsec:
_unit = Parsec;
break;
case Parameters::Unit::Kiloparsec:
_unit = Kiloparsec;
break;
case Parameters::Unit::Megaparsec:
_unit = Megaparsec;
break;
case Parameters::Unit::Gigaparsec:
_unit = Gigaparsec;
break;
case Parameters::Unit::GigalightYears:
_unit = GigalightYears;
break;
}
_unit = codegen::map<DistanceUnit>(*p.unit);
}
else {
LWARNING("No unit given for RenderableBillboardsCloud. Using meters as units");
_unit = Meter;
_unit = DistanceUnit::Meter;
}
if (p.texture.has_value()) {
@@ -776,7 +748,7 @@ void RenderableBillboardsCloud::renderLabels(const RenderData& data,
for (const speck::Labelset::Entry& e : _labelset.entries) {
glm::vec3 scaledPos(e.position);
scaledPos *= unitToMeter(_unit);
scaledPos *= toMeter(_unit);
ghoul::fontrendering::FontRenderer::defaultProjectionRenderer().render(
*_font,
scaledPos,
@@ -793,7 +765,7 @@ void RenderableBillboardsCloud::render(const RenderData& data, RendererTasks&) {
float distCamera = static_cast<float>(glm::length(data.camera.positionVec3()));
const glm::vec2 fadeRange = _fadeInDistances;
const float a = static_cast<float>(
1.f / ((fadeRange.y - fadeRange.x) * unitToMeter(_unit))
1.f / ((fadeRange.y - fadeRange.x) * toMeter(_unit))
);
const float b = -(fadeRange.x / (fadeRange.y - fadeRange.x));
const float funcValue = a * distCamera + b;
@@ -986,20 +958,6 @@ void RenderableBillboardsCloud::update(const UpdateData&) {
}
}
double RenderableBillboardsCloud::unitToMeter(Unit unit) const {
// @TODO (abock, 2021-05-10) This should be moved to a centralized conversion code
switch (unit) {
case Meter: return 1.0;
case Kilometer: return 1e3;
case Parsec: return PARSEC;
case Kiloparsec: return 1000 * PARSEC;
case Megaparsec: return 1e6 * PARSEC;
case Gigaparsec: return 1e9 * PARSEC;
case GigalightYears: return 306391534.73091 * PARSEC;
default: throw ghoul::MissingCaseException();
}
}
std::vector<float> RenderableBillboardsCloud::createDataSlice() {
ZoneScoped
@@ -1044,7 +1002,7 @@ std::vector<float> RenderableBillboardsCloud::createDataSlice() {
));
glm::vec4 position(transformedPos, static_cast<float>(_unit));
const double unitMeter = unitToMeter(_unit);
const double unitMeter = toMeter(_unit);
glm::dvec3 p = glm::dvec3(position) * unitMeter;
const double r = glm::length(p);
maxRadius = std::max(maxRadius, r);

13
modules/digitaluniverse/rendering/renderablebillboardscloud.h
View File

@@ -36,6 +36,7 @@
#include <openspace/properties/vector/ivec2property.h>
#include <openspace/properties/vector/vec2property.h>
#include <openspace/properties/vector/vec3property.h>
#include <openspace/util/distanceconversion.h>
#include <ghoul/opengl/ghoul_gl.h>
#include <ghoul/opengl/uniformcache.h>
#include <functional>
@@ -69,16 +70,6 @@ public:
static documentation::Documentation Documentation();
private:
enum Unit {
Meter = 0,
Kilometer = 1,
Parsec = 2,
Kiloparsec = 3,
Megaparsec = 4,
Gigaparsec = 5,
GigalightYears = 6
};
double unitToMeter(Unit unit) const;
std::vector<float> createDataSlice();
void createPolygonTexture();
@@ -148,7 +139,7 @@ private:
std::string _colorOptionString;
std::string _datavarSizeOptionString;
Unit _unit = Parsec;
DistanceUnit _unit = DistanceUnit::Parsec;
speck::Dataset _dataset;
speck::Labelset _labelset;

82
modules/digitaluniverse/rendering/renderabledumeshes.cpp
View File

@@ -132,14 +132,14 @@ namespace {
// [[codegen::verbatim(DrawLabelInfo.description)]]
std::optional<bool> drawLabels;
enum class Unit {
enum class [[codegen::map(openspace::DistanceUnit)]] Unit {
Meter [[codegen::key("m")]],
Kilometer [[codegen::key("Km")]],
Parsec [[codegen::key("pc")]],
Kiloparsec [[codegen::key("Kpc")]],
MegaParsec [[codegen::key("Mpc")]],
Megaparsec [[codegen::key("Mpc")]],
Gigaparsec [[codegen::key("Gpc")]],
Gigalightyears [[codegen::key("Gly")]]
Gigalightyear [[codegen::key("Gly")]]
};
std::optional<Unit> unit;
@@ -212,33 +212,11 @@ RenderableDUMeshes::RenderableDUMeshes(const ghoul::Dictionary& dictionary)
addProperty(_renderOption);
if (p.unit.has_value()) {
switch (*p.unit) {
case Parameters::Unit::Meter:
_unit = Meter;
break;
case Parameters::Unit::Kilometer:
_unit = Kilometer;
break;
case Parameters::Unit::Parsec:
_unit = Parsec;
break;
case Parameters::Unit::Kiloparsec:
_unit = Kiloparsec;
break;
case Parameters::Unit::MegaParsec:
_unit = Megaparsec;
break;
case Parameters::Unit::Gigaparsec:
_unit = Gigaparsec;
break;
case Parameters::Unit::Gigalightyears:
_unit = GigalightYears;
break;
}
_unit = codegen::map<DistanceUnit>(*p.unit);
}
else {
LWARNING("No unit given for RenderableDUMeshes. Using meters as units.");
_unit = Meter;
_unit = DistanceUnit::Meter;
}
_lineWidth = p.lineWidth.value_or(_lineWidth);
@@ -381,30 +359,7 @@ void RenderableDUMeshes::renderLabels(const RenderData& data,
const glm::vec3& orthoRight,
const glm::vec3& orthoUp)
{
float scale = 0.f;
switch (_unit) {
case Meter:
scale = 1.f;
break;
case Kilometer:
scale = 1e3f;
break;
case Parsec:
scale = static_cast<float>(PARSEC);
break;
case Kiloparsec:
scale = static_cast<float>(1e3 * PARSEC);
break;
case Megaparsec:
scale = static_cast<float>(1e6 * PARSEC);
break;
case Gigaparsec:
scale = static_cast<float>(1e9 * PARSEC);
break;
case GigalightYears:
scale = static_cast<float>(306391534.73091 * PARSEC);
break;
}
float scale = toMeter(_unit);
ghoul::fontrendering::FontRenderer::ProjectedLabelsInformation labelInfo;
labelInfo.orthoRight = orthoRight;
@@ -627,30 +582,7 @@ void RenderableDUMeshes::createMeshes() {
LDEBUG("Creating planes");
for (std::pair<const int, RenderingMesh>& p : _renderingMeshesMap) {
float scale = 0.f;
switch (_unit) {
case Meter:
scale = 1.f;
break;
case Kilometer:
scale = 1e3f;
break;
case Parsec:
scale = static_cast<float>(PARSEC);
break;
case Kiloparsec:
scale = static_cast<float>(1e3 * PARSEC);
break;
case Megaparsec:
scale = static_cast<float>(1e6 * PARSEC);
break;
case Gigaparsec:
scale = static_cast<float>(1e9 * PARSEC);
break;
case GigalightYears:
scale = static_cast<float>(306391534.73091 * PARSEC);
break;
}
float scale = toMeter(_unit);
for (GLfloat& v : p.second.vertices) {
v *= scale;

13
modules/digitaluniverse/rendering/renderabledumeshes.h
View File

@@ -34,6 +34,7 @@
#include <openspace/properties/scalar/floatproperty.h>
#include <openspace/properties/vector/ivec2property.h>
#include <openspace/properties/vector/vec3property.h>
#include <openspace/util/distanceconversion.h>
#include <ghoul/opengl/ghoul_gl.h>
#include <ghoul/opengl/uniformcache.h>
#include <unordered_map>
@@ -65,16 +66,6 @@ public:
static documentation::Documentation Documentation();
private:
enum Unit {
Meter = 0,
Kilometer = 1,
Parsec = 2,
Kiloparsec = 3,
Megaparsec = 4,
Gigaparsec = 5,
GigalightYears = 6
};
enum MeshType {
Solid = 0,
Wire = 1,
@@ -135,7 +126,7 @@ private:
std::string _speckFile;
std::string _labelFile;
Unit _unit = Parsec;
DistanceUnit _unit = DistanceUnit::Parsec;
std::vector<float> _fullData;
speck::Labelset _labelset;

50
modules/digitaluniverse/rendering/renderableplanescloud.cpp
View File

@@ -211,14 +211,14 @@ namespace {
// [[codegen::verbatim(BlendModeInfo.description)]]
std::optional<BlendMode> blendMode;
enum class Unit {
enum class [[codegen::map(openspace::DistanceUnit)]] Unit {
Meter [[codegen::key("m")]],
Kilometer [[codegen::key("Km")]],
Parsec [[codegen::key("pc")]],
Kiloparsec [[codegen::key("Kpc")]],
Megaparsec [[codegen::key("Mpc")]],
Gigaparsec [[codegen::key("Gpc")]],
Gigalightyears [[codegen::key("Gly")]]
Gigalightyear [[codegen::key("Gly")]]
};
std::optional<Unit> unit;
@@ -286,33 +286,10 @@ RenderablePlanesCloud::RenderablePlanesCloud(const ghoul::Dictionary& dictionary
//_renderOption.set(1);
if (p.unit.has_value()) {
switch (*p.unit) {
case Parameters::Unit::Meter:
_unit = Meter;
break;
case Parameters::Unit::Kilometer:
_unit = Kilometer;
break;
case Parameters::Unit::Parsec:
_unit = Parsec;
break;
case Parameters::Unit::Kiloparsec:
_unit = Kiloparsec;
break;
case Parameters::Unit::Megaparsec:
_unit = Megaparsec;
break;
case Parameters::Unit::Gigaparsec:
_unit = Gigaparsec;
break;
case Parameters::Unit::Gigalightyears:
_unit = GigalightYears;
break;
}
_unit = codegen::map<DistanceUnit>(*p.unit);
}
else {
LWARNING("No unit given for RenderablePlanesCloud. Using meters as units.");
_unit = Meter;
_unit = DistanceUnit::Meter;
}
_scaleFactor = p.scaleFactor.value_or(_scaleFactor);
@@ -522,7 +499,7 @@ void RenderablePlanesCloud::renderLabels(const RenderData& data,
const glm::dvec3& orthoRight,
const glm::dvec3& orthoUp, float fadeInVariable)
{
double scale = unitToMeter(_unit);
double scale = toMeter(_unit);
glm::vec4 textColor = glm::vec4(glm::vec3(_textColor), _textOpacity * fadeInVariable);
ghoul::fontrendering::FontRenderer::ProjectedLabelsInformation labelInfo;
@@ -551,7 +528,7 @@ void RenderablePlanesCloud::renderLabels(const RenderData& data,
}
void RenderablePlanesCloud::render(const RenderData& data, RendererTasks&) {
const double scale = unitToMeter(_unit);
const double scale = toMeter(_unit);
float fadeInVariable = 1.f;
if (!_disableFadeInDistance) {
@@ -650,23 +627,10 @@ void RenderablePlanesCloud::loadTextures() {
}
}
double RenderablePlanesCloud::unitToMeter(Unit unit) const {
switch (unit) {
case Meter: return 1.0;
case Kilometer: return 1e3;
case Parsec: return PARSEC;
case Kiloparsec: return 1000 * PARSEC;
case Megaparsec: return 1e6 * PARSEC;
case Gigaparsec: return 1e9 * PARSEC;
case GigalightYears: return 306391534.73091 * PARSEC;
default: throw ghoul::MissingCaseException();
}
}
void RenderablePlanesCloud::createPlanes() {
if (_dataIsDirty && _hasSpeckFile) {
const int lumIdx = std::max(_dataset.index(_luminosityVar), 0);
const double scale = unitToMeter(_unit);
const double scale = toMeter(_unit);
LDEBUG("Creating planes...");
float maxSize = 0.f;

14
modules/digitaluniverse/rendering/renderableplanescloud.h
View File

@@ -34,6 +34,7 @@
#include <openspace/properties/scalar/floatproperty.h>
#include <openspace/properties/vector/vec2property.h>
#include <openspace/properties/vector/vec3property.h>
#include <openspace/util/distanceconversion.h>
#include <ghoul/opengl/ghoul_gl.h>
#include <ghoul/opengl/uniformcache.h>
#include <filesystem>
@@ -70,17 +71,6 @@ public:
static documentation::Documentation Documentation();
private:
enum Unit {
Meter = 0,
Kilometer = 1,
Parsec = 2,
Kiloparsec = 3,
Megaparsec = 4,
Gigaparsec = 5,
GigalightYears = 6
};
double unitToMeter(Unit unit) const;
struct PlaneAggregate {
int textureIndex;
int numberOfPlanes;
@@ -133,7 +123,7 @@ private:
std::filesystem::path _texturesPath;
std::string _luminosityVar;
Unit _unit = Parsec;
DistanceUnit _unit = DistanceUnit::Parsec;
speck::Dataset _dataset;
speck::Labelset _labelset;

53
modules/digitaluniverse/rendering/renderablepoints.cpp
View File

@@ -90,14 +90,14 @@ namespace {
// Astronomical Object Color (r,g,b)
glm::vec3 color [[codegen::color()]];
enum class Unit {
enum class [[codegen::map(openspace::DistanceUnit)]] Unit {
Meter [[codegen::key("m")]],
Kilometer [[codegen::key("Km")]],
Parsec [[codegen::key("pc")]],
Kiloparsec [[codegen::key("Kpc")]],
Megaparsec [[codegen::key("Mpc")]],
Gigaparsec [[codegen::key("Gpc")]],
Gigalightyears [[codegen::key("Gly")]]
Gigalightyear [[codegen::key("Gly")]]
};
std::optional<Unit> unit;
@@ -138,33 +138,10 @@ RenderablePoints::RenderablePoints(const ghoul::Dictionary& dictionary)
_speckFile = absPath(p.file);
if (p.unit.has_value()) {
switch (*p.unit) {
case Parameters::Unit::Meter:
_unit = Meter;
break;
case Parameters::Unit::Kilometer:
_unit = Kilometer;
break;
case Parameters::Unit::Parsec:
_unit = Parsec;
break;
case Parameters::Unit::Kiloparsec:
_unit = Kiloparsec;
break;
case Parameters::Unit::Megaparsec:
_unit = Megaparsec;
break;
case Parameters::Unit::Gigaparsec:
_unit = Gigaparsec;
break;
case Parameters::Unit::Gigalightyears:
_unit = GigalightYears;
break;
}
_unit = codegen::map<DistanceUnit>(*p.unit);
}
else {
LWARNING("No unit given for RenderablePoints. Using meters as units.");
_unit = Meter;
_unit = DistanceUnit::Meter;
}
_pointColor = p.color;
@@ -425,26 +402,8 @@ std::vector<double> RenderablePoints::createDataSlice() {
int colorIndex = 0;
for (const speck::Dataset::Entry& e : _dataset.entries) {
glm::dvec3 p = e.position;
// Converting units
if (_unit == Kilometer) {
p *= 1E3;
}
else if (_unit == Parsec) {
p *= PARSEC;
}
else if (_unit == Kiloparsec) {
p *= 1E3 * PARSEC;
}
else if (_unit == Megaparsec) {
p *= 1E6 * PARSEC;
}
else if (_unit == Gigaparsec) {
p *= 1E9 * PARSEC;
}
else if (_unit == GigalightYears) {
p *= 306391534.73091 * PARSEC;
}
double scale = toMeter(_unit);
p *= scale;
glm::dvec4 position(p, 1.0);

13
modules/digitaluniverse/rendering/renderablepoints.h
View File

@@ -33,6 +33,7 @@
#include <openspace/properties/scalar/boolproperty.h>
#include <openspace/properties/scalar/floatproperty.h>
#include <openspace/properties/vector/vec3property.h>
#include <openspace/util/distanceconversion.h>
#include <ghoul/opengl/ghoul_gl.h>
#include <ghoul/opengl/uniformcache.h>
#include <filesystem>
@@ -65,16 +66,6 @@ public:
static documentation::Documentation Documentation();
private:
enum Unit {
Meter = 0,
Kilometer = 1,
Parsec = 2,
Kiloparsec = 3,
Megaparsec = 4,
Gigaparsec = 5,
GigalightYears = 6
};
std::vector<double> createDataSlice();
void readColorMapFile();
@@ -99,7 +90,7 @@ private:
std::filesystem::path _speckFile;
std::filesystem::path _colorMapFile;
Unit _unit = Parsec;
DistanceUnit _unit = DistanceUnit::Parsec;
speck::Dataset _dataset;
std::vector<glm::vec4> _colorMapData;

10
modules/gaia/rendering/gaiaoptions.h
View File

@@ -42,11 +42,11 @@ enum FileReaderOption {
};
enum ShaderOption {
Point_SSBO = 0,
Point_VBO = 1,
Billboard_SSBO = 2,
Billboard_VBO = 3,
Billboard_SSBO_noFBO = 4
PointSSBO = 0,
PointVBO = 1,
BillboardSSBO = 2,
BillboardVBO = 3,
BillboardSSBONoFBO = 4
};
} // namespace openspace::gaiamission

144
modules/gaia/rendering/renderablegaiastars.cpp
View File

@@ -305,7 +305,7 @@ namespace {
// [[codegen::verbatim(FilePathInfo.description)]]
std::string file;
enum class FileReader {
enum class [[codegen::map(openspace::gaia::FileReaderOption)]] FileReader {
Fits,
Speck,
BinaryRaw,
@@ -315,7 +315,7 @@ namespace {
// [[codegen::verbatim(FileReaderOptionInfo.description)]]
FileReader fileReaderOption;
enum class RenderOption {
enum class [[codegen::map(openspace::gaia::RenderOption)]] RenderOption {
Static,
Color,
Motion
@@ -323,7 +323,7 @@ namespace {
// [[codegen::verbatim(RenderOptionInfo.description)]]
std::optional<RenderOption> renderOption;
enum class ShaderOption {
enum class [[codegen::map(openspace::gaia::ShaderOption)]] ShaderOption {
PointSSBO [[codegen::key("Point_SSBO")]],
PointVBO [[codegen::key("Point_VBO")]],
BillboardSSBO [[codegen::key("Billboard_SSBO")]],
@@ -474,25 +474,7 @@ RenderableGaiaStars::RenderableGaiaStars(const ghoul::Dictionary& dictionary)
{ gaia::FileReaderOption::BinaryOctree, "BinaryOctree" },
{ gaia::FileReaderOption::StreamOctree, "StreamOctree" }
});
switch (p.fileReaderOption) {
case Parameters::FileReader::Fits:
_fileReaderOption = gaia::FileReaderOption::Fits;
break;
case Parameters::FileReader::Speck:
_fileReaderOption = gaia::FileReaderOption::Speck;
break;
case Parameters::FileReader::BinaryRaw:
_fileReaderOption = gaia::FileReaderOption::BinaryRaw;
break;
case Parameters::FileReader::BinaryOctree:
_fileReaderOption = gaia::FileReaderOption::BinaryOctree;
break;
case Parameters::FileReader::StreamOctree:
_fileReaderOption = gaia::FileReaderOption::StreamOctree;
break;
default:
throw ghoul::MissingCaseException();
}
_fileReaderOption = codegen::map<gaia::FileReaderOption>(p.fileReaderOption);
_renderOption.addOptions({
{ gaia::RenderOption::Static, "Static" },
@@ -500,63 +482,31 @@ RenderableGaiaStars::RenderableGaiaStars(const ghoul::Dictionary& dictionary)
{ gaia::RenderOption::Motion, "Motion" }
});
if (p.renderOption.has_value()) {
switch (*p.renderOption) {
case Parameters::RenderOption::Static:
_renderOption = gaia::RenderOption::Static;
break;
case Parameters::RenderOption::Color:
_renderOption = gaia::RenderOption::Color;
break;
case Parameters::RenderOption::Motion:
_renderOption = gaia::RenderOption::Motion;
break;
default:
throw ghoul::MissingCaseException();
}
_renderOption = codegen::map<gaia::RenderOption>(*p.renderOption);
}
_renderOption.onChange([&]() { _buffersAreDirty = true; });
addProperty(_renderOption);
_shaderOption.addOptions({
{ gaia::ShaderOption::Point_SSBO, "Point_SSBO" },
{ gaia::ShaderOption::Point_VBO, "Point_VBO" },
{ gaia::ShaderOption::Billboard_SSBO, "Billboard_SSBO" },
{ gaia::ShaderOption::Billboard_VBO, "Billboard_VBO" },
{ gaia::ShaderOption::Billboard_SSBO_noFBO, "Billboard_SSBO_noFBO" }
{ gaia::ShaderOption::PointSSBO, "Point_SSBO" },
{ gaia::ShaderOption::PointVBO, "Point_VBO" },
{ gaia::ShaderOption::BillboardSSBO, "Billboard_SSBO" },
{ gaia::ShaderOption::BillboardVBO, "Billboard_VBO" },
{ gaia::ShaderOption::BillboardSSBONoFBO, "Billboard_SSBO_noFBO" }
});
if (p.shaderOption.has_value()) {
switch (*p.shaderOption) {
case Parameters::ShaderOption::PointSSBO:
_shaderOption = gaia::ShaderOption::Point_SSBO;
_shaderOption = codegen::map<gaia::ShaderOption>(*p.shaderOption);
#ifdef __APPLE__
switch (_shaderOption) {
case gaia::ShaderOption::Point_SSBO:
case gaia::ShaderOption::Billboard_SSBO:
case gaia::ShaderOption::Billboard_SSBO_noFBO:
LWARNING("Shader option unsupported, changing to Point VBO");
_shaderOption = gaia::ShaderOption::Point_VBO;
#endif // __APPLE__
break;
case Parameters::ShaderOption::PointVBO:
_shaderOption = gaia::ShaderOption::Point_VBO;
break;
case Parameters::ShaderOption::BillboardSSBO:
_shaderOption = gaia::ShaderOption::Billboard_SSBO;
#ifdef __APPLE__
LWARNING("Shader option unsupported, changing to Point VBO");
_shaderOption = gaia::ShaderOption::Point_VBO;
#endif // __APPLE__
break;
case Parameters::ShaderOption::BillboardVBO:
_shaderOption = gaia::ShaderOption::Billboard_VBO;
break;
case Parameters::ShaderOption::BillboardSSBONoFBO:
_shaderOption = gaia::ShaderOption::Billboard_SSBO_noFBO;
#ifdef __APPLE__
LWARNING("Shader option unsupported, changing to Point VBO");
_shaderOption = gaia::ShaderOption::Point_VBO;
#endif // __APPLE__
break;
default:
throw ghoul::MissingCaseException();
}
#endif // __APPLE__
}
_shaderOption.onChange([&]() {
_buffersAreDirty = true;
@@ -705,7 +655,7 @@ void RenderableGaiaStars::initializeGL() {
// Construct shader program depending on user-defined shader option.
const int option = _shaderOption;
switch (option) {
case gaia::ShaderOption::Point_SSBO: {
case gaia::ShaderOption::PointSSBO: {
_program = ghoul::opengl::ProgramObject::Build(
"GaiaStar",
absPath("${MODULE_GAIA}/shaders/gaia_ssbo_vs.glsl"),
@@ -733,7 +683,7 @@ void RenderableGaiaStars::initializeGL() {
addProperty(_tmPointPixelWeightThreshold);
break;
}
case gaia::ShaderOption::Point_VBO: {
case gaia::ShaderOption::PointVBO: {
_program = ghoul::opengl::ProgramObject::Build(
"GaiaStar",
absPath("${MODULE_GAIA}/shaders/gaia_vbo_vs.glsl"),
@@ -757,7 +707,7 @@ void RenderableGaiaStars::initializeGL() {
addProperty(_tmPointPixelWeightThreshold);
break;
}
case gaia::ShaderOption::Billboard_SSBO: {
case gaia::ShaderOption::BillboardSSBO: {
_program = ghoul::opengl::ProgramObject::Build(
"GaiaStar",
absPath("${MODULE_GAIA}/shaders/gaia_ssbo_vs.glsl"),
@@ -791,7 +741,7 @@ void RenderableGaiaStars::initializeGL() {
//addProperty(_pointSpreadFunctionTexturePath);
break;
}
case gaia::ShaderOption::Billboard_SSBO_noFBO: {
case gaia::ShaderOption::BillboardSSBONoFBO: {
_program = global::renderEngine->buildRenderProgram("GaiaStar",
absPath("${MODULE_GAIA}/shaders/gaia_ssbo_vs.glsl"),
absPath("${MODULE_GAIA}/shaders/gaia_billboard_nofbo_fs.glsl"),
@@ -817,7 +767,7 @@ void RenderableGaiaStars::initializeGL() {
addProperty(_closeUpBoostDist);
break;
}
case gaia::ShaderOption::Billboard_VBO: {
case gaia::ShaderOption::BillboardVBO: {
_program = ghoul::opengl::ProgramObject::Build(
"GaiaStar",
absPath("${MODULE_GAIA}/shaders/gaia_vbo_vs.glsl"),
@@ -1025,9 +975,9 @@ void RenderableGaiaStars::render(const RenderData& data, RendererTasks&) {
// Switch rendering technique depending on user-defined shader option.
const int shaderOption = _shaderOption;
if (shaderOption == gaia::ShaderOption::Billboard_SSBO ||
shaderOption == gaia::ShaderOption::Point_SSBO ||
shaderOption == gaia::ShaderOption::Billboard_SSBO_noFBO)
if (shaderOption == gaia::ShaderOption::BillboardSSBO ||
shaderOption == gaia::ShaderOption::PointSSBO ||
shaderOption == gaia::ShaderOption::BillboardSSBONoFBO)
{
#ifndef __APPLE__
//------------------------ RENDER WITH SSBO ---------------------------
@@ -1238,19 +1188,19 @@ void RenderableGaiaStars::render(const RenderData& data, RendererTasks&) {
ghoul::opengl::TextureUnit psfUnit;
switch (shaderOption) {
case gaia::ShaderOption::Point_SSBO: {
case gaia::ShaderOption::PointSSBO: {
_program->setUniform(_uniformCache.maxStarsPerNode, maxStarsPerNode);
_program->setUniform(_uniformCache.valuesPerStar, valuesPerStar);
_program->setUniform(_uniformCache.nChunksToRender, nChunksToRender);
break;
}
case gaia::ShaderOption::Point_VBO: {
case gaia::ShaderOption::PointVBO: {
// Specify how many potential stars we have to render.
nShaderCalls = maxStarsPerNode * nChunksToRender;
break;
}
case gaia::ShaderOption::Billboard_SSBO:
case gaia::ShaderOption::Billboard_SSBO_noFBO: {
case gaia::ShaderOption::BillboardSSBO:
case gaia::ShaderOption::BillboardSSBONoFBO: {
_program->setUniform(
_uniformCache.cameraPos,
data.camera.positionVec3()
@@ -1275,7 +1225,7 @@ void RenderableGaiaStars::render(const RenderData& data, RendererTasks&) {
_program->setUniform(_uniformCache.psfTexture, psfUnit);
break;
}
case gaia::ShaderOption::Billboard_VBO: {
case gaia::ShaderOption::BillboardVBO: {
_program->setUniform(
_uniformCache.cameraPos,
data.camera.positionVec3()
@@ -1301,7 +1251,7 @@ void RenderableGaiaStars::render(const RenderData& data, RendererTasks&) {
}
}
if (shaderOption != gaia::ShaderOption::Billboard_SSBO_noFBO) {
if (shaderOption != gaia::ShaderOption::BillboardSSBONoFBO) {
// Render to FBO.
glBindFramebuffer(GL_FRAMEBUFFER, _fbo);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -1321,7 +1271,7 @@ void RenderableGaiaStars::render(const RenderData& data, RendererTasks&) {
//glDisable(GL_PROGRAM_POINT_SIZE);
_program->deactivate();
if (shaderOption != gaia::ShaderOption::Billboard_SSBO_noFBO) {
if (shaderOption != gaia::ShaderOption::BillboardSSBONoFBO) {
// Use ToneMapping shaders and render to default FBO again!
_programTM->activate();
@@ -1334,8 +1284,8 @@ void RenderableGaiaStars::render(const RenderData& data, RendererTasks&) {
_programTM->setUniform(_uniformCacheTM.renderedTexture, fboTexUnit);
}
if (shaderOption == gaia::ShaderOption::Point_SSBO ||
shaderOption == gaia::ShaderOption::Point_VBO)
if (shaderOption == gaia::ShaderOption::PointSSBO ||
shaderOption == gaia::ShaderOption::PointVBO)
{
_programTM->setUniform(_uniformCacheTM.screenSize, screenSize);
_programTM->setUniform(_uniformCacheTM.filterSize, _tmPointFilterSize);
@@ -1411,7 +1361,7 @@ void RenderableGaiaStars::update(const UpdateData&) {
if (_program->isDirty() || _shadersAreDirty) {
switch (shaderOption) {
case gaia::ShaderOption::Point_SSBO: {
case gaia::ShaderOption::PointSSBO: {
#ifndef __APPLE__
std::unique_ptr<ghoul::opengl::ProgramObject> program =
ghoul::opengl::ProgramObject::Build(
@@ -1475,7 +1425,7 @@ void RenderableGaiaStars::update(const UpdateData&) {
#endif // !__APPLE__
break;
}
case gaia::ShaderOption::Point_VBO: {
case gaia::ShaderOption::PointVBO: {
std::unique_ptr<ghoul::opengl::ProgramObject> program =
ghoul::opengl::ProgramObject::Build(
"GaiaStar",
@@ -1514,11 +1464,11 @@ void RenderableGaiaStars::update(const UpdateData&) {
}
break;
}
case gaia::ShaderOption::Billboard_SSBO:
case gaia::ShaderOption::Billboard_SSBO_noFBO: {
case gaia::ShaderOption::BillboardSSBO:
case gaia::ShaderOption::BillboardSSBONoFBO: {
#ifndef __APPLE__
std::unique_ptr<ghoul::opengl::ProgramObject> program;
if (shaderOption == gaia::ShaderOption::Billboard_SSBO) {
if (shaderOption == gaia::ShaderOption::BillboardSSBO) {
program = ghoul::opengl::ProgramObject::Build(
"GaiaStar",
absPath("${MODULE_GAIA}/shaders/gaia_ssbo_vs.glsl"),
@@ -1600,7 +1550,7 @@ void RenderableGaiaStars::update(const UpdateData&) {
#endif // !__APPLE__
break;
}
case gaia::ShaderOption::Billboard_VBO: {
case gaia::ShaderOption::BillboardVBO: {
std::unique_ptr<ghoul::opengl::ProgramObject> program =
ghoul::opengl::ProgramObject::Build(
"GaiaStar",
@@ -1676,8 +1626,8 @@ void RenderableGaiaStars::update(const UpdateData&) {
if (_programTM->isDirty() || _shadersAreDirty) {
switch (shaderOption) {
case gaia::ShaderOption::Point_SSBO:
case gaia::ShaderOption::Point_VBO: {
case gaia::ShaderOption::PointSSBO:
case gaia::ShaderOption::PointVBO: {
std::unique_ptr<ghoul::opengl::ProgramObject> programTM =
global::renderEngine->buildRenderProgram(
"ToneMapping",
@@ -1698,8 +1648,8 @@ void RenderableGaiaStars::update(const UpdateData&) {
);
break;
}
case gaia::ShaderOption::Billboard_SSBO:
case gaia::ShaderOption::Billboard_VBO: {
case gaia::ShaderOption::BillboardSSBO:
case gaia::ShaderOption::BillboardVBO: {
std::filesystem::path vs = absPath(
"${MODULE_GAIA}/shaders/gaia_tonemapping_vs.glsl"
);
@@ -1763,9 +1713,9 @@ void RenderableGaiaStars::update(const UpdateData&) {
));
// ------------------ RENDER WITH SSBO -----------------------
if (shaderOption == gaia::ShaderOption::Billboard_SSBO ||
shaderOption == gaia::ShaderOption::Point_SSBO ||
shaderOption == gaia::ShaderOption::Billboard_SSBO_noFBO)
if (shaderOption == gaia::ShaderOption::BillboardSSBO ||
shaderOption == gaia::ShaderOption::PointSSBO ||
shaderOption == gaia::ShaderOption::BillboardSSBONoFBO)
{
#ifndef __APPLE__
_useVBO = false;

20
modules/galaxy/rendering/renderablegalaxy.cpp
View File

@@ -57,6 +57,11 @@ namespace {
constexpr const char* _loggerCat = "Renderable Galaxy";
enum StarRenderingMethod {
Points,
Billboards
};
constexpr const std::array<const char*, 4> UniformNamesPoints = {
"modelMatrix", "viewProjectionMatrix", "eyePosition",
"opacityCoefficient"
@@ -147,7 +152,7 @@ namespace {
// [[codegen::verbatim(EmissionMultiplyInfo.description)]]
std::optional<float> emissionMultiply;
enum class StarRenderingMethod {
enum class [[codegen::map(StarRenderingMethod)]] StarRenderingMethod {
Points,
Billboards
};
@@ -255,18 +260,11 @@ RenderableGalaxy::RenderableGalaxy(const ghoul::Dictionary& dictionary)
_emissionMultiply = p.emissionMultiply.value_or(_emissionMultiply);
_starRenderingMethod.addOptions({
{ 0, "Points" },
{ 1, "Billboards" }
{ StarRenderingMethod::Points, "Points" },
{ StarRenderingMethod::Billboards, "Billboards" }
});
if (p.starRenderingMethod.has_value()) {
switch (*p.starRenderingMethod) {
case Parameters::StarRenderingMethod::Points:
_starRenderingMethod = 0;
break;
case Parameters::StarRenderingMethod::Billboards:
_starRenderingMethod = 1;
break;
}
_starRenderingMethod = codegen::map<StarRenderingMethod>(*p.starRenderingMethod);
}
_rotation = p.rotation.value_or(_rotation);

13
modules/globebrowsing/src/globelabelscomponent.cpp
View File

@@ -183,7 +183,7 @@ namespace {
// [[codegen::verbatim(DistanceEPSInfo.description)]]
std::optional<float> distanceEPS;
enum class Alignment {
enum class [[codegen::map(LabelRenderingAlignmentType)]] Alignment {
Horizontally,
Circularly
};
@@ -282,16 +282,7 @@ void GlobeLabelsComponent::initialize(const ghoul::Dictionary& dictionary,
_distanceEPS = p.distanceEPS.value_or(_distanceEPS);
if (p.alignmentOption.has_value()) {
switch (*p.alignmentOption) {
case Parameters::Alignment::Horizontally:
_alignmentOption = Horizontally;
break;
case Parameters::Alignment::Circularly:
_alignmentOption = Circularly;
break;
default:
throw ghoul::MissingCaseException();
}
_alignmentOption = codegen::map<LabelRenderingAlignmentType>(*p.alignmentOption);
}
initializeFonts();

73
modules/space/rendering/renderablestars.cpp
View File

@@ -58,8 +58,19 @@ namespace {
"otherDataRange", "filterOutOfRange", "fixedColor"
};
constexpr const int RenderOptionPointSpreadFunction = 0;
constexpr const int RenderOptionTexture = 1;
enum RenderMethod {
PointSpreadFunction = 0,
TextureBased
};
enum SizeComposition {
AppBrightness = 0,
LumSize,
LumSizeAppBrightness,
AbsMagnitude,
AppMagnitude,
DistanceModulus
};
constexpr const int PsfMethodSpencer = 0;
constexpr const int PsfMethodMoffat = 1;
@@ -393,8 +404,8 @@ namespace {
// [[codegen::verbatim(MagnitudeExponentInfo.description)]]
std::optional<float> magnitudeExponent;
enum class RenderMethod {
PSF,
enum class [[codegen::map(RenderMethod)]] RenderMethod {
PointSpreadFunction [[codegen::key("PSF")]],
TextureBased [[codegen::key("Texture Based")]]
};
@@ -404,7 +415,7 @@ namespace {
// [[codegen::verbatim(PsfTextureInfo.description)]]
std::filesystem::path texture;
enum class SizeComposition {
enum class [[codegen::map(SizeComposition)]] SizeComposition {
AppBrightness [[codegen::key("App Brightness")]],
LumSize [[codegen::key("Lum and Size")]],
LumSizeAppBrightness [[codegen::key("Lum, Size and App Brightness")]],
@@ -630,18 +641,13 @@ RenderableStars::RenderableStars(const ghoul::Dictionary& dictionary)
addProperty(_filterOutOfRange);
_renderingMethodOption.addOption(
RenderOptionPointSpreadFunction,
RenderMethod::PointSpreadFunction,
"Point Spread Function Based"
);
_renderingMethodOption.addOption(RenderOptionTexture, "Textured Based");
_renderingMethodOption.addOption(RenderMethod::TextureBased, "Textured Based");
addProperty(_renderingMethodOption);
if (p.renderMethod == Parameters::RenderMethod::PSF) {
_renderingMethodOption = RenderOptionPointSpreadFunction;
}
else {
_renderingMethodOption = RenderOptionTexture;
}
_renderingMethodOption = codegen::map<RenderMethod>(p.renderMethod);
_pointSpreadFunctionTexturePath = absPath(p.texture.string()).string();
_pointSpreadFunctionFile = std::make_unique<File>(
@@ -661,35 +667,20 @@ RenderableStars::RenderableStars(const ghoul::Dictionary& dictionary)
_psfMethodOption.onChange([&]() { renderPSFToTexture(); });
_parametersOwner.addProperty(_psfMethodOption);
_psfMultiplyOption.addOption(0, "Use Star's Apparent Brightness");
_psfMultiplyOption.addOption(1, "Use Star's Luminosity and Size");
_psfMultiplyOption.addOption(2, "Luminosity, Size, App Brightness");
_psfMultiplyOption.addOption(3, "Absolute Magnitude");
_psfMultiplyOption.addOption(4, "Apparent Magnitude");
_psfMultiplyOption.addOption(5, "Distance Modulus");
_psfMultiplyOption.addOption(AppBrightness, "Use Star's Apparent Brightness");
_psfMultiplyOption.addOption(LumSize, "Use Star's Luminosity and Size");
_psfMultiplyOption.addOption(
LumSizeAppBrightness,
"Luminosity, Size, App Brightness"
);
_psfMultiplyOption.addOption(AbsMagnitude, "Absolute Magnitude");
_psfMultiplyOption.addOption(AppMagnitude, "Apparent Magnitude");
_psfMultiplyOption.addOption(DistanceModulus, "Distance Modulus");
if (p.sizeComposition.has_value()) {
switch (*p.sizeComposition) {
case Parameters::SizeComposition::AppBrightness:
_psfMultiplyOption = 0;
break;
case Parameters::SizeComposition::LumSize:
_psfMultiplyOption = 1;
break;
case Parameters::SizeComposition::LumSizeAppBrightness:
_psfMultiplyOption = 2;
break;
case Parameters::SizeComposition::AbsMagnitude:
_psfMultiplyOption = 3;
break;
case Parameters::SizeComposition::AppMagnitude:
_psfMultiplyOption = 4;
break;
case Parameters::SizeComposition::DistanceModulus:
_psfMultiplyOption = 5;
break;
}
_psfMultiplyOption =
static_cast<int>(codegen::map<SizeComposition>(*p.sizeComposition));
}
else {
_psfMultiplyOption = 5;
@@ -1052,12 +1043,12 @@ void RenderableStars::render(const RenderData& data, RendererTasks&) {
ghoul::opengl::TextureUnit psfUnit;
psfUnit.activate();
if (_renderingMethodOption.value() == 0) { // PSF Based Methods
if (_renderingMethodOption.value() == RenderMethod::PointSpreadFunction) {
glBindTexture(GL_TEXTURE_2D, _psfTexture);\
// Convolutioned texture
//glBindTexture(GL_TEXTURE_2D, _convolvedTexture);
}
else if (_renderingMethodOption.value() == 1) { // Textured based Method
else if (_renderingMethodOption.value() == RenderMethod::TextureBased) {
_pointSpreadFunctionTexture->bind();
}

14
modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp
View File

@@ -115,12 +115,12 @@ namespace {
// [[codegen::verbatim(ShadowColorInfo.description)]]
std::optional<glm::vec3> shadowColor [[codegen::color()]];
enum class TerminatorType {
enum class [[codegen::map(openspace::SpiceManager::TerminatorType)]] Terminator {
Umbral [[codegen::key("UMBRAL")]],
Penumbral [[codegen::key("PENUMBRAL")]]
};
// [[codegen::verbatim(TerminatorTypeInfo.description)]]
TerminatorType terminatorType;
Terminator terminatorType;
// [[codegen::verbatim(LightSourceInfo.description)]]
std::string lightSource;
@@ -180,14 +180,8 @@ RenderableShadowCylinder::RenderableShadowCylinder(const ghoul::Dictionary& dict
{ static_cast<int>(SpiceManager::TerminatorType::Umbral), "Umbral" },
{ static_cast<int>(SpiceManager::TerminatorType::Penumbral), "Penumbral" }
});
switch (p.terminatorType) {
case Parameters::TerminatorType::Umbral:
_terminatorType = static_cast<int>(SpiceManager::TerminatorType::Umbral);
break;
case Parameters::TerminatorType::Penumbral:
_terminatorType = static_cast<int>(SpiceManager::TerminatorType::Penumbral);
break;
}
_terminatorType =
static_cast<int>(codegen::map<SpiceManager::TerminatorType>(p.terminatorType));
addProperty(_terminatorType);

27
src/engine/logfactory.cpp
View File

@@ -70,7 +70,7 @@ namespace {
// was used to create the log message
std::optional<bool> logLevelStamping;
enum class LogLevel {
enum class [[codegen::map(ghoul::logging::LogLevel)]] LogLevel {
AllLogging,
Trace,
Debug,
@@ -101,28 +101,9 @@ std::unique_ptr<ghoul::logging::Log> createLog(const ghoul::Dictionary& dictiona
bool dateStamp = p.dateStamping.value_or(true);
bool categoryStamp = p.categoryStamping.value_or(true);
bool logLevelStamp = p.logLevelStamping.value_or(true);
ghoul::logging::LogLevel level = [](Parameters::LogLevel l) {
switch (l) {
case Parameters::LogLevel::AllLogging:
return ghoul::logging::LogLevel::AllLogging;
case Parameters::LogLevel::Trace:
return ghoul::logging::LogLevel::Trace;
case Parameters::LogLevel::Debug:
return ghoul::logging::LogLevel::Debug;
case Parameters::LogLevel::Info:
return ghoul::logging::LogLevel::Info;
case Parameters::LogLevel::Warning:
return ghoul::logging::LogLevel::Warning;
case Parameters::LogLevel::Error:
return ghoul::logging::LogLevel::Error;
case Parameters::LogLevel::Fatal:
return ghoul::logging::LogLevel::Fatal;
case Parameters::LogLevel::NoLogging:
return ghoul::logging::LogLevel::NoLogging;
default:
throw ghoul::MissingCaseException();
}
}(p.logLevel.value_or(Parameters::LogLevel::AllLogging));
ghoul::logging::LogLevel level = codegen::map<ghoul::logging::LogLevel>(
p.logLevel.value_or(Parameters::LogLevel::AllLogging)
);
switch (p.type) {
case Parameters::Type::Html:

2
support/coding/codegen

Submodule support/coding/codegen updated: 026af925ee...4bb5b66dae