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

Merge branch 'master' into feature/horizons-framework

Browse Source
This commit is contained in:
Malin E
2022-02-17 10:58:24 +01:00
parent 8eb4c3b586 e8072495ec
commit a9dde8f2b6
100 changed files with 561 additions and 659 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/atmosphere/atmospheremodule.cpp
+3 -1
View File
@@ -36,8 +36,10 @@ namespace openspace {
AtmosphereModule::AtmosphereModule() : OpenSpaceModule(Name) {}
void AtmosphereModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableAtmosphere>("RenderableAtmosphere");
}
modules/base/basemodule.cpp
+16 -12
View File
@@ -88,12 +88,10 @@ ghoul::opengl::TextureManager BaseModule::TextureManager;
BaseModule::BaseModule() : OpenSpaceModule(BaseModule::Name) {}
void BaseModule::internalInitialize(const ghoul::Dictionary&) {
FactoryManager::ref().addFactory(
std::make_unique<ghoul::TemplateFactory<ScreenSpaceRenderable>>(),
"ScreenSpaceRenderable"
);
FactoryManager::ref().addFactory<ScreenSpaceRenderable>("ScreenSpaceRenderable");
auto fSsRenderable = FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul::TemplateFactory<ScreenSpaceRenderable>* fSsRenderable =
FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul_assert(fSsRenderable, "ScreenSpaceRenderable factory was not created");
fSsRenderable->registerClass<ScreenSpaceDashboard>("ScreenSpaceDashboard");
@@ -101,7 +99,8 @@ void BaseModule::internalInitialize(const ghoul::Dictionary&) {
fSsRenderable->registerClass<ScreenSpaceImageOnline>("ScreenSpaceImageOnline");
fSsRenderable->registerClass<ScreenSpaceFramebuffer>("ScreenSpaceFramebuffer");
auto fDashboard = FactoryManager::ref().factory<DashboardItem>();
ghoul::TemplateFactory<DashboardItem>* fDashboard =
FactoryManager::ref().factory<DashboardItem>();
ghoul_assert(fDashboard, "Dashboard factory was not created");
fDashboard->registerClass<DashboardItemAngle>("DashboardItemAngle");
@@ -122,7 +121,8 @@ void BaseModule::internalInitialize(const ghoul::Dictionary&) {
fDashboard->registerClass<DashboardItemText>("DashboardItemText");
fDashboard->registerClass<DashboardItemVelocity>("DashboardItemVelocity");
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "Renderable factory was not created");
fRenderable->registerClass<RenderableBoxGrid>("RenderableBoxGrid");
@@ -147,14 +147,16 @@ void BaseModule::internalInitialize(const ghoul::Dictionary&) {
fRenderable->registerClass<RenderableTrailOrbit>("RenderableTrailOrbit");
fRenderable->registerClass<RenderableTrailTrajectory>("RenderableTrailTrajectory");
auto fTranslation = FactoryManager::ref().factory<Translation>();
ghoul::TemplateFactory<Translation>* fTranslation =
FactoryManager::ref().factory<Translation>();
ghoul_assert(fTranslation, "Ephemeris factory was not created");
fTranslation->registerClass<TimelineTranslation>("TimelineTranslation");
fTranslation->registerClass<LuaTranslation>("LuaTranslation");
fTranslation->registerClass<StaticTranslation>("StaticTranslation");
auto fRotation = FactoryManager::ref().factory<Rotation>();
ghoul::TemplateFactory<Rotation>* fRotation =
FactoryManager::ref().factory<Rotation>();
ghoul_assert(fRotation, "Rotation factory was not created");
fRotation->registerClass<ConstantRotation>("ConstantRotation");
@@ -164,7 +166,7 @@ void BaseModule::internalInitialize(const ghoul::Dictionary&) {
fRotation->registerClass<TimelineRotation>("TimelineRotation");
auto fScale = FactoryManager::ref().factory<Scale>();
ghoul::TemplateFactory<Scale>* fScale = FactoryManager::ref().factory<Scale>();
ghoul_assert(fScale, "Scale factory was not created");
fScale->registerClass<LuaScale>("LuaScale");
@@ -172,13 +174,15 @@ void BaseModule::internalInitialize(const ghoul::Dictionary&) {
fScale->registerClass<StaticScale>("StaticScale");
fScale->registerClass<TimeDependentScale>("TimeDependentScale");
auto fTimeFrame = FactoryManager::ref().factory<TimeFrame>();
ghoul::TemplateFactory<TimeFrame>* fTimeFrame =
FactoryManager::ref().factory<TimeFrame>();
ghoul_assert(fTimeFrame, "Scale factory was not created");
fTimeFrame->registerClass<TimeFrameInterval>("TimeFrameInterval");
fTimeFrame->registerClass<TimeFrameUnion>("TimeFrameUnion");
auto fLightSource = FactoryManager::ref().factory<LightSource>();
ghoul::TemplateFactory<LightSource>* fLightSource =
FactoryManager::ref().factory<LightSource>();
ghoul_assert(fLightSource, "Light Source factory was not created");
fLightSource->registerClass<CameraLightSource>("CameraLightSource");
modules/base/dashboard/dashboarditemmission.cpp
+1 -2
View File
@@ -92,8 +92,7 @@ void DashboardItemMission::render(glm::vec2& penPosition) {
ghoul::fontrendering::CrDirection::Down
);
auto phaseTrace = mission.phaseTrace(currentTime);
MissionPhase::Trace phaseTrace = mission.phaseTrace(currentTime);
if (!phaseTrace.empty()) {
const MissionPhase& phase = phaseTrace.back().get();
const std::string title = "Current Mission Phase: " + phase.name();
modules/base/rendering/renderabledisc.cpp
-2
View File
@@ -39,8 +39,6 @@
#include <optional>
namespace {
constexpr const char _loggerCat[] = "RenderableDisc";
constexpr const std::array<const char*, 4> UniformNames = {
"modelViewProjectionTransform", "opacity", "width", "colorTexture"
};
modules/base/rendering/renderablemodel.cpp
+1 -4
View File
@@ -586,10 +586,7 @@ void RenderableModel::render(const RenderData& data, RendererTasks&) {
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale)) *
glm::scale(
glm::dmat4(_modelTransform.value()),
glm::dvec3(_modelScale) // Model scale unit
);
glm::scale(_modelTransform.value(), glm::dvec3(_modelScale));
const glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() *
modelTransform;
modules/base/rendering/renderableplanetimevaryingimage.cpp
+1 -1
View File
@@ -291,7 +291,7 @@ void RenderablePlaneTimeVaryingImage::computeSequenceEndTime() {
const double lastTriggerTime = _startTimes[_sourceFiles.size() - 1];
const double sequenceDuration = lastTriggerTime - _startTimes[0];
const double averageStateDuration = sequenceDuration /
(static_cast<double>(_sourceFiles.size() - 1.0));
static_cast<double>(_sourceFiles.size() - 1);
_sequenceEndTime = lastTriggerTime + averageStateDuration;
}
}
modules/base/rendering/renderableprism.cpp
-2
View File
@@ -36,8 +36,6 @@
#include <optional>
namespace {
constexpr const char _loggerCat[] = "RenderablePrism";
constexpr const std::array<const char*, 2> UniformNames = {
"modelViewProjectionTransform", "vs_color"
};
modules/base/rendering/renderabletimevaryingsphere.cpp
+1 -1
View File
@@ -44,7 +44,7 @@
namespace {
constexpr const char* ProgramName = "Timevarying Sphere";
constexpr const char* _loggerCat = "RenderableTimeVaryingSphere";
constexpr const std::array<const char*, 5> UniformNames = {
"opacity", "modelViewProjection", "modelViewRotation", "colorTexture",
"mirrorTexture"
modules/debugging/debuggingmodule.cpp
+2 -1
View File
@@ -39,7 +39,8 @@ namespace openspace {
DebuggingModule::DebuggingModule() : OpenSpaceModule(Name) {}
void DebuggingModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableDebugPlane>("RenderableDebugPlane");
modules/debugging/debuggingmodule_lua.inl
+3 -5
View File
@@ -108,7 +108,7 @@ int renderCameraPath(lua_State* L) {
return fmt::format("Point_{}", i);
};
auto addPoint = [pointIdentifier] (const std::string& id, glm::dvec3 p) {
auto addPoint = [](const std::string& id, glm::dvec3 p) {
const std::string pointNode = "{"
"Identifier = '" + id + "',"
"Parent = '" + RenderedPathIdentifier + "',"
@@ -126,10 +126,8 @@ int renderCameraPath(lua_State* L) {
);
};
auto addLineBetweenPoints = [pointIdentifier] (const std::string& id1,
const std::string& id2,
const glm::vec3& color,
float lineWidth)
auto addLineBetweenPoints = [](const std::string& id1, const std::string& id2,
const glm::vec3& color, float lineWidth)
{
const std::string lineNode = "{"
"Identifier = '" + fmt::format("Line{}", id1) + "',"
modules/digitaluniverse/digitaluniversemodule.cpp
+2 -1
View File
@@ -44,7 +44,8 @@ DigitalUniverseModule::DigitalUniverseModule()
{}
void DigitalUniverseModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "Renderable factory was not created");
fRenderable->registerClass<RenderablePoints>("RenderablePoints");
modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
-2
View File
@@ -67,8 +67,6 @@ namespace {
"hasColorMap", "enabledRectSizeControl", "hasDvarScaling"
};
constexpr double PARSEC = 0.308567756E17;
enum RenderOption {
ViewDirection = 0,
PositionNormal
modules/digitaluniverse/rendering/renderabledumeshes.cpp
-2
View File
@@ -59,8 +59,6 @@ namespace {
constexpr const int RenderOptionViewDirection = 0;
constexpr const int RenderOptionPositionNormal = 1;
constexpr const double PARSEC = 0.308567756E17;
constexpr openspace::properties::Property::PropertyInfo TextColorInfo = {
"TextColor",
"Text Color",
modules/digitaluniverse/rendering/renderablepoints.cpp
-2
View File
@@ -55,8 +55,6 @@ namespace {
"spriteTexture", "hasColorMap"
};
constexpr double PARSEC = 0.308567756E17;
constexpr openspace::properties::Property::PropertyInfo SpriteTextureInfo = {
"Texture",
"Point Sprite Texture",
modules/exoplanets/exoplanetsmodule.cpp
+3 -2
View File
@@ -328,8 +328,9 @@ void ExoplanetsModule::internalInitialize(const ghoul::Dictionary& dict) {
_habitableZoneOpacity = p.habitableZoneOpacity.value_or(_habitableZoneOpacity);
auto fTask = FactoryManager::ref().factory<Task>();
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Task>* fTask = FactoryManager::ref().factory<Task>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fTask, "No task factory existed");
fTask->registerClass<ExoplanetsDataPreparationTask>("ExoplanetsDataPreparationTask");
fRenderable->registerClass<RenderableOrbitDisc>("RenderableOrbitDisc");
modules/fieldlines/fieldlinesmodule.cpp
+2 -1
View File
@@ -35,7 +35,8 @@ namespace openspace {
FieldlinesModule::FieldlinesModule() : OpenSpaceModule(Name) {}
void FieldlinesModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableFieldlines>("RenderableFieldlines");
modules/fieldlinessequence/fieldlinessequencemodule.cpp
+2 -1
View File
@@ -60,7 +60,8 @@ FieldlinesSequenceModule::FieldlinesSequenceModule() : OpenSpaceModule(Name) {
}
void FieldlinesSequenceModule::internalInitialize(const ghoul::Dictionary&) {
auto factory = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* factory =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(factory, "No renderable factory existed");
factory->registerClass<RenderableFieldlinesSequence>("RenderableFieldlinesSequence");
modules/fieldlinessequence/util/kameleonfieldlinehelper.cpp
+2 -4
View File
@@ -181,8 +181,7 @@ bool addLinesToState(ccmc::Kameleon* kameleon, const std::vector<glm::vec3>& see
// We have to create a new tracer (or actually a new interpolator) for each //
// new line, otherwise some issues occur //
//--------------------------------------------------------------------------//
std::unique_ptr<ccmc::Interpolator> interpolator =
std::make_unique<ccmc::KameleonInterpolator>(kameleon->model);
auto interpolator = std::make_unique<ccmc::KameleonInterpolator>(kameleon->model);
ccmc::Tracer tracer(kameleon, interpolator.get());
tracer.setInnerBoundary(innerBoundaryLimit); // TODO specify in Lua?
ccmc::Fieldline ccmcFieldline = tracer.bidirectionalTrace(
@@ -235,8 +234,7 @@ void addExtraQuantities(ccmc::Kameleon* kameleon,
const size_t nXtraScalars = extraScalarVars.size();
const size_t nXtraMagnitudes = extraMagVars.size() / 3;
std::unique_ptr<ccmc::Interpolator> interpolator =
std::make_unique<ccmc::KameleonInterpolator>(kameleon->model);
auto interpolator = std::make_unique<ccmc::KameleonInterpolator>(kameleon->model);
// ------ Extract all the extraQuantities from kameleon and store in state! ------ //
for (const glm::vec3& p : state.vertexPositions()) {
modules/gaia/gaiamodule.cpp
+3 -2
View File
@@ -40,11 +40,12 @@ namespace openspace {
GaiaModule::GaiaModule() : OpenSpaceModule(Name) {}
void GaiaModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableGaiaStars>("RenderableGaiaStars");
auto fTask = FactoryManager::ref().factory<Task>();
ghoul::TemplateFactory<Task>* fTask = FactoryManager::ref().factory<Task>();
ghoul_assert(fRenderable, "No task factory existed");
fTask->registerClass<ReadFitsTask>("ReadFitsTask");
fTask->registerClass<ReadSpeckTask>("ReadSpeckTask");
modules/gaia/rendering/octreemanager.cpp
+4 -4
View File
@@ -134,7 +134,7 @@ void OctreeManager::sliceLodData(size_t branchIndex) {
}
void OctreeManager::printStarsPerNode() const {
auto accumulatedString = std::string();
std::string accumulatedString;
for (int i = 0; i < 8; ++i) {
std::string prefix = "{" + std::to_string(i);
@@ -297,7 +297,7 @@ void OctreeManager::findAndFetchNeighborNode(unsigned long long firstParentId, i
int y, int z, int additionalLevelsToFetch)
{
unsigned long long parentId = firstParentId;
auto indexStack = std::stack<int>();
std::stack<int> indexStack;
// Fetch first layer children if we're already at root.
if (parentId == 8) {
@@ -398,7 +398,7 @@ std::map<int, std::vector<float>> OctreeManager::traverseData(const glm::dmat4&
gaia::RenderOption option,
float lodPixelThreshold)
{
auto renderData = std::map<int, std::vector<float>>();
std::map<int, std::vector<float>> renderData;
bool innerRebuild = false;
_minTotalPixelsLod = lodPixelThreshold;
@@ -1264,7 +1264,7 @@ std::vector<float> OctreeManager::getNodeData(const OctreeNode& node,
}
// If we're not in a leaf, get data from all children recursively.
auto nodeData = std::vector<float>();
std::vector<float> nodeData;
for (size_t i = 0; i < 8; ++i) {
std::vector<float> tmpData = getNodeData(*node.Children[i], option);
nodeData.insert(nodeData.end(), tmpData.begin(), tmpData.end());
modules/galaxy/galaxymodule.cpp
+3 -2
View File
@@ -38,11 +38,12 @@ namespace openspace {
GalaxyModule::GalaxyModule() : OpenSpaceModule(Name) {}
void GalaxyModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableGalaxy>("RenderableGalaxy");
auto fTask = FactoryManager::ref().factory<Task>();
ghoul::TemplateFactory<Task>* fTask = FactoryManager::ref().factory<Task>();
ghoul_assert(fRenderable, "No task factory existed");
fTask->registerClass<MilkywayConversionTask>("MilkywayConversionTask");
fTask->registerClass<MilkywayPointsConversionTask>("MilkywayPointsConversionTask");
modules/globebrowsing/globebrowsingmodule.cpp
+39 -47
View File
@@ -274,65 +274,57 @@ void GlobeBrowsingModule::internalInitialize(const ghoul::Dictionary& dict) {
GdalWrapper::destroy();
});
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "Renderable factory was not created");
fRenderable->registerClass<globebrowsing::RenderableGlobe>("RenderableGlobe");
auto fTranslation = FactoryManager::ref().factory<Translation>();
ghoul::TemplateFactory<Translation>* fTranslation =
FactoryManager::ref().factory<Translation>();
ghoul_assert(fTranslation, "Translation factory was not created");
fTranslation->registerClass<globebrowsing::GlobeTranslation>("GlobeTranslation");
auto fRotation = FactoryManager::ref().factory<Rotation>();
ghoul::TemplateFactory<Rotation>* fRotation =
FactoryManager::ref().factory<Rotation>();
ghoul_assert(fRotation, "Rotation factory was not created");
fRotation->registerClass<globebrowsing::GlobeRotation>("GlobeRotation");
auto fTileProvider = std::make_unique<ghoul::TemplateFactory<TileProvider>>();
FactoryManager::ref().addFactory<TileProvider>(_factoryName);
ghoul::TemplateFactory<TileProvider>* fTileProvider =
FactoryManager::ref().factory<TileProvider>();
ghoul_assert(fTileProvider, "TileProvider factory was not created");
fTileProvider->registerClass<DefaultTileProvider>(
layergroupid::LAYER_TYPE_NAMES[static_cast<int>(
layergroupid::TypeID::DefaultTileLayer
)]
);
fTileProvider->registerClass<SingleImageProvider>(
layergroupid::LAYER_TYPE_NAMES[static_cast<int>(
layergroupid::TypeID::SingleImageTileLayer
)]
);
fTileProvider->registerClass<ImageSequenceTileProvider>(
layergroupid::LAYER_TYPE_NAMES[static_cast<int>(
layergroupid::TypeID::ImageSequenceTileLayer
)]
);
fTileProvider->registerClass<TemporalTileProvider>(
layergroupid::LAYER_TYPE_NAMES[static_cast<int>(
layergroupid::TypeID::TemporalTileLayer
)]
);
fTileProvider->registerClass<TileIndexTileProvider>(
layergroupid::LAYER_TYPE_NAMES[static_cast<int>(
layergroupid::TypeID::TileIndexTileLayer
)]
);
fTileProvider->registerClass<SizeReferenceTileProvider>(
layergroupid::LAYER_TYPE_NAMES[static_cast<int>(
layergroupid::TypeID::SizeReferenceTileLayer
)]
);
fTileProvider->registerClass<TileProviderByLevel>(
layergroupid::LAYER_TYPE_NAMES[static_cast<int>(
layergroupid::TypeID::ByLevelTileLayer
)]
);
fTileProvider->registerClass<TileProviderByIndex>(
layergroupid::LAYER_TYPE_NAMES[static_cast<int>(
layergroupid::TypeID::ByIndexTileLayer
)]
);
{
using namespace layergroupid;
fTileProvider->registerClass<DefaultTileProvider>(
LAYER_TYPE_NAMES[static_cast<int>(TypeID::DefaultTileLayer)]
);
fTileProvider->registerClass<SingleImageProvider>(
LAYER_TYPE_NAMES[static_cast<int>(TypeID::SingleImageTileLayer)]
);
fTileProvider->registerClass<ImageSequenceTileProvider>(
LAYER_TYPE_NAMES[static_cast<int>(TypeID::ImageSequenceTileLayer)]
);
fTileProvider->registerClass<TemporalTileProvider>(
LAYER_TYPE_NAMES[static_cast<int>(TypeID::TemporalTileLayer)]
);
fTileProvider->registerClass<TileIndexTileProvider>(
LAYER_TYPE_NAMES[static_cast<int>(TypeID::TileIndexTileLayer)]
);
fTileProvider->registerClass<SizeReferenceTileProvider>(
LAYER_TYPE_NAMES[static_cast<int>(TypeID::SizeReferenceTileLayer)]
);
fTileProvider->registerClass<TileProviderByLevel>(
LAYER_TYPE_NAMES[static_cast<int>(TypeID::ByLevelTileLayer)]
);
fTileProvider->registerClass<TileProviderByIndex>(
LAYER_TYPE_NAMES[static_cast<int>(TypeID::ByIndexTileLayer)]
);
}
FactoryManager::ref().addFactory(std::move(fTileProvider), _factoryName);
auto fDashboard = FactoryManager::ref().factory<DashboardItem>();
ghoul::TemplateFactory<DashboardItem>* fDashboard =
FactoryManager::ref().factory<DashboardItem>();
ghoul_assert(fDashboard, "Dashboard factory was not created");
fDashboard->registerClass<DashboardItemGlobeLocation>("DashboardItemGlobeLocation");
modules/globebrowsing/src/globelabelscomponent.cpp
+1 -1
View File
@@ -365,7 +365,7 @@ bool GlobeLabelsComponent::readLabelsFile(const std::filesystem::path& file) {
// atlas)
// Once this limitation is fixed, we can remove the next piece of code
// Removing non ASCII characters:
strncpy(lEntry.feature, token.c_str(), 256);
strncpy(lEntry.feature, token.c_str(), 255);
int tokenChar = 0;
while (tokenChar < 256) {
if (lEntry.feature[tokenChar] < 0 && lEntry.feature[tokenChar] != '\0') {
modules/globebrowsing/src/tileprovider/imagesequencetileprovider.cpp
+1 -1
View File
@@ -112,7 +112,7 @@ TileDepthTransform ImageSequenceTileProvider::depthTransform() {
void ImageSequenceTileProvider::update() {
if (_isImageDirty && !_imagePaths.empty() &&
_index >= 0 && _index < _imagePaths.size())
_index >= 0 && _index < static_cast<int>(_imagePaths.size()))
{
if (_currentTileProvider) {
_currentTileProvider->deinitialize();
modules/globebrowsing/src/tileprovider/sizereferencetileprovider.cpp
+1 -1
View File
@@ -104,7 +104,7 @@ Tile SizeReferenceTileProvider::tile(const TileIndex& tileIndex) {
return TextTileProvider::renderTile(tileIndex, text, textPosition, glm::vec4(1.f));
}
Tile::Status SizeReferenceTileProvider::tileStatus(const TileIndex& index) {
Tile::Status SizeReferenceTileProvider::tileStatus(const TileIndex&) {
return Tile::Status::OK;
}
modules/globebrowsing/src/tileprovider/temporaltileprovider.cpp
+6 -14
View File
@@ -44,17 +44,8 @@
#include <sstream>
namespace {
constexpr const char* KeyBasePath = "BasePath";
constexpr const char* TimePlaceholder = "${OpenSpaceTimeId}";
constexpr openspace::properties::Property::PropertyInfo FilePathInfo = {
"FilePath",
"File Path",
"This is the path to the XML configuration file that describes the temporal tile "
"information."
};
constexpr openspace::properties::Property::PropertyInfo UseFixedTimeInfo = {
"UseFixedTime",
"Use Fixed Time",
@@ -450,8 +441,8 @@ DefaultTileProvider* TemporalTileProvider::retrieveTileProvider(const Time& t) {
_folder.files.cbegin(),
_folder.files.cend(),
time,
[](const std::pair<double, std::string>& p, double time) {
return p.first < time;
[](const std::pair<double, std::string>& p, double sec) {
return p.first < sec;
}
);
return std::string_view(it->second);
@@ -721,9 +712,10 @@ Tile TemporalTileProvider::InterpolateTileProvider::tile(const TileIndex& tileIn
Tile prev = t1->tile(tileIndex);
Tile next = t2->tile(tileIndex);
// the tile before and the tile after the interpolation interval are loaded so the
// interpolation goes smoother
Tile prevprev = before->tile(tileIndex);
Tile nextnext = future->tile(tileIndex);
// interpolation goes smoother. It is on purpose that we are not actually storing the
// return tile here, we just want to trigger the load already
before->tile(tileIndex);
future->tile(tileIndex);
cache::ProviderTileKey key = { tileIndex, uniqueIdentifier };
if (!prev.texture || !next.texture) {
modules/globebrowsing/src/tileprovider/tileprovider.cpp
+5 -3
View File
@@ -65,8 +65,6 @@ namespace {
std::unique_ptr<ghoul::opengl::Texture> DefaultTileTexture;
Tile DefaultTile = Tile { nullptr, std::nullopt, Tile::Status::Unavailable };
constexpr const char* KeyFilePath = "FilePath";
} // namespace
unsigned int TileProvider::NumTileProviders = 0;
@@ -78,7 +76,11 @@ std::unique_ptr<TileProvider> TileProvider::createFromDictionary(
ZoneScoped
const char* type = layergroupid::LAYER_TYPE_NAMES[static_cast<int>(layerTypeID)];
auto factory = FactoryManager::ref().factory<TileProvider>();
ghoul::TemplateFactory<TileProvider>* factory =
FactoryManager::ref().factory<TileProvider>();
ghoul_assert(factory, "TileProvider factory not created");
TileProvider* result = factory->create(type, dictionary);
return std::unique_ptr<TileProvider>(result);
}
modules/globebrowsing/src/tileprovider/tileproviderbyindex.cpp
+14 -5
View File
@@ -27,23 +27,32 @@
#include <openspace/documentation/documentation.h>
namespace {
constexpr const char* KeyDefaultProvider = "DefaultProvider";
constexpr const char* KeyProviders = "IndexTileProviders";
constexpr const char* KeyTileIndex = "TileIndex";
constexpr const char* KeyTileProvider = "TileProvider";
struct [[codegen::Dictionary(TileProviderByIndex)]] Parameters {
ghoul::Dictionary defaultProvider;
struct IndexProvider {
struct Index {
// The x coordinate for this index. This specifies the horizontal
// direction (longitude) component
int x [[codegen::greaterequal(0)]];
// The y coordinate for this index. This specifies the vertical direction
// (latitude) component
int y [[codegen::greaterequal(0)]];
// The z-level which corresponds to the depth of the tile pyramid, which
// directly impacts the applied resolution of the tileprovider shown here
int level [[codegen::inrange(0, 255)]];
};
// The index for which the provided tile provider is used
Index tileIndex;
// The dictionary that described the tileprovider to be used by the provided
// index
ghoul::Dictionary tileProvider;
};
// The list of all tileprovides and the indices at which they are used
std::vector<IndexProvider> indexTileProviders;
};
#include "tileproviderbyindex_codegen.cpp"
modules/globebrowsing/src/timequantizer.cpp
+1 -2
View File
@@ -630,9 +630,8 @@ std::vector<std::string> TimeQuantizer::quantized(Time& start, Time& end) {
const double startSeconds = s.J2000();
const double endSeconds = e.J2000();
const double delta = endSeconds - startSeconds;
ghoul_assert(
static_cast<int>(delta) % static_cast<int>(_resolution) == 0,
static_cast<int>(endSeconds - startSeconds) % static_cast<int>(_resolution) == 0,
"Quantization error"
);
modules/imgui/src/guipropertycomponent.cpp
+1 -1
View File
@@ -131,7 +131,7 @@ namespace {
}
else {
// We don't have a child, so we must generate it
std::unique_ptr<TreeNode> newNode = std::make_unique<TreeNode>(*path.begin());
auto newNode = std::make_unique<TreeNode>(*path.begin());
n = newNode.get();
node.children.push_back(std::move(newNode));
}
modules/iswa/iswamodule.cpp
+4 -3
View File
@@ -50,8 +50,8 @@ IswaModule::IswaModule() : OpenSpaceModule(Name) {
}
void IswaModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<TexturePlane>("TexturePlane");
@@ -59,7 +59,8 @@ void IswaModule::internalInitialize(const ghoul::Dictionary&) {
fRenderable->registerClass<KameleonPlane>("KameleonPlane");
fRenderable->registerClass<DataSphere>("DataSphere");
auto fScreenSpaceRenderable = FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul::TemplateFactory<ScreenSpaceRenderable>* fScreenSpaceRenderable =
FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul_assert(fScreenSpaceRenderable, "No fScreenSpaceRenderable factory existed");
fScreenSpaceRenderable->registerClass<ScreenSpaceCygnet>("ScreenSpaceCygnet");
modules/iswa/rendering/datacygnet.cpp
+2 -3
View File
@@ -132,8 +132,7 @@ bool DataCygnet::updateTexture() {
}
if (!_textures[option]) {
using namespace ghoul::opengl;
std::unique_ptr<Texture> texture = std::make_unique<Texture>(
auto texture = std::make_unique<ghoul::opengl::Texture>(
values,
_textureDimensions,
GL_TEXTURE_2D,
@@ -146,7 +145,7 @@ bool DataCygnet::updateTexture() {
if (texture) {
texture->uploadTexture();
texture->setFilter(Texture::FilterMode::LinearMipMap);
texture->setFilter(ghoul::opengl::Texture::FilterMode::LinearMipMap);
_textures[option] = std::move(texture);
}
}
modules/iswa/util/dataprocessor.cpp
+1 -1
View File
@@ -232,7 +232,7 @@ void DataProcessor::add(const std::vector<std::vector<float>>& optionValues,
_histNormValues
);
//unnormalize histMin, histMax
std::unique_ptr<Histogram> newHist = std::make_unique<Histogram>(
auto newHist = std::make_unique<Histogram>(
std::min(min, normalizeWithStandardScore(
unNormHistMin,
mean,
modules/iswa/util/iswamanager.cpp
+6 -7
View File
@@ -336,8 +336,7 @@ std::map<std::string, std::vector<CdfInfo>>& IswaManager::cdfInformation() {
}
std::shared_ptr<MetadataFuture> IswaManager::downloadMetadata(int id) {
std::shared_ptr<MetadataFuture> metaFuture = std::make_shared<MetadataFuture>();
auto metaFuture = std::make_shared<MetadataFuture>();
metaFuture->id = id;
global::downloadManager->fetchFile(
_baseUrl + std::to_string(-id),
@@ -672,7 +671,7 @@ void IswaManager::fillCygnetInfo(std::string jsonString) {
// ,"listOfStaleCygnets", "listOfInactiveCygnets",
};
for (auto list : lists) {
for (const std::string& list : lists) {
json jsonList = j[list];
for (size_t i = 0; i < jsonList.size(); ++i) {
json jCygnet = jsonList.at(i);
@@ -699,10 +698,10 @@ ghoul::Event<>& IswaManager::iswaEvent() {
}
void IswaManager::addCdfFiles(std::string cdfpath) {
std::filesystem::path cdf = absPath(cdfpath);
if (std::filesystem::is_regular_file(cdf)) {
std::filesystem::path cdfFile = absPath(cdfpath);
if (std::filesystem::is_regular_file(cdfFile)) {
//std::string basePath = path.substr(0, path.find_last_of("/\\"));
std::ifstream jsonFile(cdf);
std::ifstream jsonFile(cdfFile);
if (jsonFile.is_open()) {
json cdfGroups = json::parse(jsonFile);
@@ -741,7 +740,7 @@ void IswaManager::addCdfFiles(std::string cdfpath) {
}
}
else {
LWARNING(fmt::format("{} is not a cdf file or can't be found", cdf));
LWARNING(fmt::format("{} is not a cdf file or can't be found", cdfFile));
}
}
modules/iswa/util/iswamanager_lua.inl
+8 -6
View File
@@ -74,13 +74,14 @@ int iswa_addScreenSpaceCygnet(lua_State* L) {
int id = static_cast<int>(d.value<double>("CygnetId"));
auto cygnetInformation = IswaManager::ref().cygnetInformation();
std::map<int, std::shared_ptr<CygnetInfo>> cygnetInformation =
IswaManager::ref().cygnetInformation();
if (cygnetInformation.find(id) == cygnetInformation.end()) {
LWARNING("Could not find Cygnet with id = " + std::to_string(id));
return 0;
}
auto info = cygnetInformation[id];
std::shared_ptr<CygnetInfo> info = cygnetInformation[id];
std::string name = info->name;
int updateInterval = info->updateInterval;
info->selected = true;
@@ -140,13 +141,14 @@ int iswa_removeScrenSpaceCygnet(lua_State* L) {
int id = static_cast<int>(lua_tonumber(L, 1));
auto cygnetInformation = IswaManager::ref().cygnetInformation();
std::map<int, std::shared_ptr<CygnetInfo>> cygnetInformation =
IswaManager::ref().cygnetInformation();
if (cygnetInformation.find(id) == cygnetInformation.end()) {
LWARNING("Could not find Cygnet with id = " + std::to_string(id));
return 0;
}
auto info = cygnetInformation[id];
std::shared_ptr<CygnetInfo> info = cygnetInformation[id];
info->selected = false;
std::string script =
@@ -164,7 +166,8 @@ int iswa_removeGroup(lua_State* L) {
std::string name = luaL_checkstring(L, -1);
// IswaManager::ref().unregisterGroup(id);
auto groups = IswaManager::ref().groups();
std::map<std::string, std::shared_ptr<IswaBaseGroup>> groups =
IswaManager::ref().groups();
if (groups.find(name) != groups.end()) {
groups[name]->clearGroup();
}
@@ -183,7 +186,6 @@ int iswa_addKameleonPlanes(lua_State* L) {
std::string group = luaL_checkstring(L, 1);
int pos = static_cast<int>(lua_tonumber(L, 2));
IswaManager::ref().addKameleonCdf(group, pos);
// auto cdfInfo =
return 0;
}
modules/kameleon/src/kameleonhelper.cpp
+1 -1
View File
@@ -48,7 +48,7 @@ namespace {
namespace openspace::kameleonHelper {
std::unique_ptr<ccmc::Kameleon> createKameleonObject(const std::string& cdfFilePath) {
std::unique_ptr<ccmc::Kameleon> kameleon = std::make_unique<ccmc::Kameleon>();
auto kameleon = std::make_unique<ccmc::Kameleon>();
LDEBUG(fmt::format("\tOpening the cdf file: {}", cdfFilePath));
long kamStatus = kameleon->open(cdfFilePath);
modules/kameleonvolume/kameleonvolumemodule.cpp
+3 -2
View File
@@ -40,11 +40,12 @@ KameleonVolumeModule::KameleonVolumeModule() : OpenSpaceModule(Name) {}
void KameleonVolumeModule::internalInitialize(const ghoul::Dictionary&) {
using namespace kameleonvolume;
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableKameleonVolume>("RenderableKameleonVolume");
auto fTask = FactoryManager::ref().factory<Task>();
ghoul::TemplateFactory<Task>* fTask = FactoryManager::ref().factory<Task>();
ghoul_assert(fTask, "No task factory existed");
fTask->registerClass<KameleonMetadataToJsonTask>("KameleonMetadataToJsonTask");
fTask->registerClass<KameleonDocumentationTask>("KameleonDocumentationTask");
modules/kameleonvolume/kameleonvolumereader.cpp
+1 -2
View File
@@ -122,8 +122,7 @@ std::unique_ptr<volume::RawVolume<float>> KameleonVolumeReader::readFloatVolume(
minValue = std::numeric_limits<float>::max();
maxValue = -std::numeric_limits<float>::max();
std::unique_ptr<volume::RawVolume<float>> volume =
std::make_unique<volume::RawVolume<float>>(dimensions);
auto volume = std::make_unique<volume::RawVolume<float>>(dimensions);
const glm::vec3 dims = volume->dimensions();
const glm::vec3 diff = upperBound - lowerBound;
modules/multiresvolume/multiresvolumemodule.cpp
+2 -1
View File
@@ -35,7 +35,8 @@ namespace openspace {
MultiresVolumeModule::MultiresVolumeModule() : OpenSpaceModule(Name) {}
void MultiresVolumeModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableMultiresVolume>("RenderableMultiresVolume");
modules/server/servermodule.cpp
+1 -1
View File
@@ -137,7 +137,7 @@ void ServerModule::preSync() {
continue;
}
socket->startStreams();
std::shared_ptr<Connection> connection = std::make_shared<Connection>(
auto connection = std::make_shared<Connection>(
std::move(socket),
address,
false,
modules/server/src/jsonconverters.cpp
-5
View File
@@ -130,11 +130,6 @@ void to_json(json& j, const SceneGraphNode& n) {
{ "subowners", n.propertySubOwners() }
};
/*
auto renderable = n.renderable();
if (renderable != nullptr) {
j["renderable"] = renderable;
}*/
SceneGraphNode* parent = n.parent();
if (parent) {
modules/server/src/serverinterface.cpp
+1 -1
View File
@@ -94,7 +94,7 @@ std::unique_ptr<ServerInterface> ServerInterface::createFromDictionary(
const ghoul::Dictionary& config)
{
// TODO: Use documentation to verify dictionary
std::unique_ptr<ServerInterface> si = std::make_unique<ServerInterface>(config);
auto si = std::make_unique<ServerInterface>(config);
return si;
}
modules/server/src/topics/authorizationtopic.cpp
+5 -3
View File
@@ -54,7 +54,7 @@ void AuthorizationTopic::handleJson(const nlohmann::json& json) {
}
else {
try {
auto providedKey = json.at("key").get<std::string>();
std::string providedKey = json.at("key").get<std::string>();
if (authorize(providedKey)) {
_connection->setAuthorized(true);
_connection->sendJson(wrappedPayload({ KeyStatus, Authorized }));
@@ -63,9 +63,11 @@ void AuthorizationTopic::handleJson(const nlohmann::json& json) {
else {
_connection->sendJson(wrappedPayload({ KeyStatus, IncorrectKey }));
}
} catch (const std::out_of_range&) {
}
catch (const std::out_of_range&) {
_connection->sendJson(wrappedPayload({ KeyStatus, BadRequest }));
} catch (const std::domain_error&) {
}
catch (const std::domain_error&) {
_connection->sendJson(wrappedPayload({ KeyStatus, BadRequest }));
}
}
modules/space/rendering/planetgeometry.cpp
+2 -1
View File
@@ -48,7 +48,8 @@ std::unique_ptr<PlanetGeometry> PlanetGeometry::createFromDictionary(
{
const Parameters p = codegen::bake<Parameters>(dictionary);
auto factory = FactoryManager::ref().factory<PlanetGeometry>();
ghoul::TemplateFactory<PlanetGeometry>* factory =
FactoryManager::ref().factory<PlanetGeometry>();
PlanetGeometry* result = factory->create(p.type, dictionary);
return std::unique_ptr<PlanetGeometry>(result);
modules/space/rendering/renderablefluxnodes.cpp
+19 -35
View File
@@ -155,11 +155,6 @@ namespace {
"Skipping Nodes By Radius",
"Select nodes to skip depending on Radius."
};
constexpr openspace::properties::Property::PropertyInfo DistanceplanetInfo = {
"Distanceplanet",
"Distance Planet",
"Deciding what planet to check distance to."
};
constexpr openspace::properties::Property::PropertyInfo DistanceThresholdInfo = {
"DistancePlanetThreshold",
"Threshold for distance between planet",
@@ -170,11 +165,6 @@ namespace {
"Earths Proximity Nodes Size",
"Changes size of nodes only close to earth."
};
constexpr openspace::properties::Property::PropertyInfo MisalignedIndexInfo = {
"MisalignedIndex",
"Index to shift sequence number",
"The misalignment number for sequence for fluxnodes vs Fieldlines"
};
constexpr openspace::properties::Property::PropertyInfo MaxNodeDistanceSizeInfo = {
"MaxNodeDistanceSize",
"Max Node Distance Size",
@@ -248,42 +238,43 @@ documentation::Documentation RenderableFluxNodes::Documentation() {
RenderableFluxNodes::RenderableFluxNodes(const ghoul::Dictionary& dictionary)
: Renderable(dictionary)
, _earthdistGroup({ "Earthfocus" })
, _goesEnergyBins(GoesEnergyBinsInfo, properties::OptionProperty::DisplayType::Radio)
, _styleGroup({ "Style" })
, _colorMode(ColorModeInfo, properties::OptionProperty::DisplayType::Radio)
, _scalingMethod(ScalingmethodInfo, properties::OptionProperty::DisplayType::Radio)
, _nodeskipMethod(NodeskipMethodInfo, properties::OptionProperty::DisplayType::Radio)
, _streamColor(
StreamColorInfo,
glm::vec4(0.96f, 0.88f, 0.8f, 1.f),
glm::vec4(0.f),
glm::vec4(1.f))
, _streamGroup({ "Streams" })
, _nodesAmountGroup({ "NodeGroup" })
, _nodeSize(NodeSizeInfo, 2.f, 1.f, 10.f)
glm::vec4(1.f)
)
, _colorTablePath(ColorTablePathInfo)
, _colorTableRange(colorTableRangeInfo, { -2.f, 4.f }, { -8.f, -8.f }, { 8.f, 8.f })
, _domainZ(DomainZInfo, { -2.5f, 2.5f }, { -2.5f, -2.5f }, { 2.5f, 2.5f})
, _fluxColorAlpha(FluxColorAlphaInfo, 1.f, 0.f, 1.f)
, _streamGroup({ "Streams" })
, _scalingMethod(ScalingmethodInfo, properties::OptionProperty::DisplayType::Radio)
, _nodesAmountGroup({ "NodeGroup" })
, _nodeSize(NodeSizeInfo, 2.f, 1.f, 10.f)
, _distanceThreshold(DistanceThresholdInfo, 0.f, 0.f, 1.f)
, _proximityNodesSize(ProximityNodesSizeInfo, 1.f, 0.f, 100.f)
, _maxNodeDistanceSize(MaxNodeDistanceSizeInfo, 1.f, 1.f, 10.f)
, _minMaxNodeSize(MinMaxNodeSizeInfo, { 2.f, 30.f }, { 1.f, 1.f }, { 10.f, 200.f })
, _domainZ(DomainZInfo, { -2.5f, 2.5f }, { -2.5f, -2.5f }, { 2.5f, 2.5f })
, _thresholdFlux(ThresholdFluxInfo, -1.5f, -50.f, 10.f)
, _filteringLower(FilteringInfo, 0.f, 0.f, 5.f)
, _filteringUpper(FilteringUpperInfo, 5.f, 0.f, 5.f)
, _amountofNodes(AmountofNodesInfo, 1, 1, 100)
, _nodeskipMethod(NodeskipMethodInfo, properties::OptionProperty::DisplayType::Radio)
, _defaultNodeSkip(DefaultNodeSkipInfo, 1, 1, 100)
, _earthNodeSkip(EarthNodeSkipInfo, 1, 1, 100)
, _fluxNodeskipThreshold(FluxNodeskipThresholdInfo, 0, -20, 10)
, _earthNodeSkip(EarthNodeSkipInfo, 1, 1, 100)
, _radiusNodeSkipThreshold(RadiusNodeSkipThresholdInfo, 0.f, 0.f, 5.f)
, _earthdistGroup({ "Earthfocus" })
, _distanceThreshold(DistanceThresholdInfo, 0.f, 0.f, 1.f)
, _proximityNodesSize(ProximityNodesSizeInfo, 1.f, 0.f, 100.f)
, _maxNodeDistanceSize(MaxNodeDistanceSizeInfo, 1.f, 1.f, 10.f)
, _cameraPerspectiveGroup({ "CameraPerspective" })
, _cameraPerspectiveEnabled(CameraPerspectiveEnabledInfo, false)
, _drawingCircles(DrawingCirclesInfo, true)
, _cameraPerspectiveGroup({ "CameraPerspective" })
, _drawingHollow(DrawingHollowInfo, false)
, _gaussianAlphaFilter(GaussiandAlphaFilterInfo, false)
, _perspectiveDistanceFactor(PerspectiveDistanceFactorInfo, 2.67f, 1.f, 20.f)
, _minMaxNodeSize(MinMaxNodeSizeInfo, {2.f, 30.f}, {1.f, 1.f}, {10.f, 200.f})
, _pulseEnabled(pulseEnabledInfo, false)
, _gaussianPulseEnabled(gaussianPulseEnabledInfo, false)
{
@@ -528,10 +519,6 @@ bool RenderableFluxNodes::isReady() const {
}
void RenderableFluxNodes::populateStartTimes() {
// number of characters in UTC ISO8601 format (without additional Z)
// 'YYYY-MM-DDTHH-MM-SS-XXX'
constexpr const int timeFormatSize = 23;
std::string timeFile;
std::string fileType;
for (const std::string& filePath : _binarySourceFiles) {
@@ -641,10 +628,7 @@ void RenderableFluxNodes::render(const RenderData& data, RendererTasks&) {
const glm::dmat4 rotMat = glm::dmat4(data.modelTransform.rotation);
const glm::dmat4 modelMat =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
rotMat *
glm::dmat4(glm::scale(
glm::dmat4(1.0), data.modelTransform.scale
));
rotMat * glm::scale(glm::dmat4(1.0), data.modelTransform.scale);
const glm::dmat4 modelViewMat = data.camera.combinedViewMatrix() * modelMat;
_shaderProgram->setUniform("modelViewProjection",
@@ -812,7 +796,7 @@ void RenderableFluxNodes::updatePositionBuffer() {
glEnableVertexAttribArray(0);
glEnable(GL_PROGRAM_POINT_SIZE);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
@@ -830,7 +814,7 @@ void RenderableFluxNodes::updateVertexColorBuffer() {
);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 0, nullptr);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
@@ -848,7 +832,7 @@ void RenderableFluxNodes::updateVertexFilteringBuffer() {
);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 0, nullptr);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
modules/space/rendering/renderablefluxnodes.h
+1 -4
View File
@@ -100,8 +100,7 @@ private:
nodeSkipFluxThreshold, nodeSkipRadiusThreshold, fluxColorAlpha,
earthPos, distanceThreshold, time, maxNodeDistanceSize, usingCameraPerspective,
drawCircles, drawHollow, useGaussian, perspectiveDistanceFactor, minMaxNodeSize,
usingPulse, usingGaussianPulse)
_uniformCache;
usingPulse, usingGaussianPulse) _uniformCache;
std::filesystem::path _binarySourceFolderPath;
@@ -121,8 +120,6 @@ private:
GLuint _vertexColorBuffer = 0;
// OpenGL Vertex Buffer Object containing the positions to filter the nodes
GLuint _vertexFilteringBuffer = 0;
// OpenGL Vertex Buffer Object containing the index of nodes
GLuint _vertexindexBuffer = 0;
std::unique_ptr<ghoul::opengl::ProgramObject> _shaderProgram;
modules/space/rendering/renderablehabitablezone.cpp
-2
View File
@@ -40,8 +40,6 @@
#include <optional>
namespace {
constexpr const char* _loggerCat = "RenderableHabitableZone";
constexpr const std::array<const char*, 6> UniformNames = {
"modelViewProjectionTransform", "opacity", "width", "transferFunctionTexture",
"conservativeBounds", "showOptimistic"
modules/space/rendering/renderableorbitalkepler.cpp
-1
View File
@@ -45,7 +45,6 @@
#include <vector>
namespace {
constexpr const char* _loggerCat = "OrbitalKepler";
constexpr const char* ProgramName = "OrbitalKepler";
// Fragile! Keep in sync with documentation
modules/space/rendering/renderabletravelspeed.cpp
+2 -4
View File
@@ -37,8 +37,6 @@
#include <optional>
namespace {
constexpr const char* _loggerCat = "renderableTravelSpeed";
constexpr const std::array<const char*, 2> UniformNames = {"lineColor", "opacity"};
constexpr openspace::properties::Property::PropertyInfo SpeedInfo = {
@@ -126,9 +124,9 @@ RenderableTravelSpeed::RenderableTravelSpeed(const ghoul::Dictionary& dictionary
)
, _indicatorLength(IndicatorLengthInfo, 1, 1, 360)
, _fadeLength(FadeLengthInfo, 1, 0, 360)
, _lineColor(LineColorInfo, glm::vec3(1.f), glm::vec3(0.f), glm::vec3(1.f))
, _opacity(LineOpacityInfo, 1.f, 0.f, 1.f)
, _lineWidth(LineWidthInfo, 2.f, 1.f, 20.f)
, _opacity(LineOpacityInfo, 1.f, 0.f, 1.f)
, _lineColor(LineColorInfo, glm::vec3(1.f), glm::vec3(0.f), glm::vec3(1.f))
{
const Parameters p = codegen::bake<Parameters>(dictionary);
setRenderBin(RenderBin::Overlay);
modules/space/spacemodule.cpp
+9 -12
View File
@@ -73,12 +73,10 @@ SpaceModule::SpaceModule()
}
void SpaceModule::internalInitialize(const ghoul::Dictionary& dictionary) {
FactoryManager::ref().addFactory(
std::make_unique<ghoul::TemplateFactory<planetgeometry::PlanetGeometry>>(),
"PlanetGeometry"
);
FactoryManager::ref().addFactory<planetgeometry::PlanetGeometry>("PlanetGeometry");
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "Renderable factory was not created");
fRenderable->registerClass<RenderableConstellationBounds>(
@@ -92,7 +90,8 @@ void SpaceModule::internalInitialize(const ghoul::Dictionary& dictionary) {
fRenderable->registerClass<RenderableStars>("RenderableStars");
fRenderable->registerClass<RenderableTravelSpeed>("RenderableTravelSpeed");
auto fTranslation = FactoryManager::ref().factory<Translation>();
ghoul::TemplateFactory<Translation>* fTranslation =
FactoryManager::ref().factory<Translation>();
ghoul_assert(fTranslation, "Ephemeris factory was not created");
fTranslation->registerClass<KeplerTranslation>("KeplerTranslation");
@@ -100,16 +99,14 @@ void SpaceModule::internalInitialize(const ghoul::Dictionary& dictionary) {
fTranslation->registerClass<TLETranslation>("TLETranslation");
fTranslation->registerClass<HorizonsTranslation>("HorizonsTranslation");
/*auto fTasks = FactoryManager::ref().factory<Task>();
ghoul_assert(fTasks, "No task factory existed");
fTasks->registerClass<volume::GenerateDebrisVolumeTask>("GenerateDebrisVolumeTask");*/
auto fRotation = FactoryManager::ref().factory<Rotation>();
ghoul::TemplateFactory<Rotation>* fRotation =
FactoryManager::ref().factory<Rotation>();
ghoul_assert(fRotation, "Rotation factory was not created");
fRotation->registerClass<SpiceRotation>("SpiceRotation");
auto fGeometry = FactoryManager::ref().factory<planetgeometry::PlanetGeometry>();
ghoul::TemplateFactory<planetgeometry::PlanetGeometry>* fGeometry =
FactoryManager::ref().factory<planetgeometry::PlanetGeometry>();
ghoul_assert(fGeometry, "Planet geometry factory was not created");
fGeometry->registerClass<planetgeometry::SimpleSphereGeometry>("SimpleSphere");
modules/space/translation/horizonstranslation.cpp
+5 -2
View File
@@ -113,8 +113,11 @@ HorizonsTranslation::HorizonsTranslation(const ghoul::Dictionary& dictionary)
glm::dvec3 HorizonsTranslation::position(const UpdateData& data) const {
glm::dvec3 interpolatedPos = glm::dvec3(0.0);
auto lastBefore = _timeline.lastKeyframeBefore(data.time.j2000Seconds(), true);
auto firstAfter = _timeline.firstKeyframeAfter(data.time.j2000Seconds(), false);
const Keyframe<glm::dvec3>* lastBefore =
_timeline.lastKeyframeBefore(data.time.j2000Seconds(), true);
const Keyframe<glm::dvec3>* firstAfter =
_timeline.firstKeyframeAfter(data.time.j2000Seconds(), false);
if (lastBefore && firstAfter) {
// We're inbetween first and last value.
double timelineDiff = firstAfter->timestamp - lastBefore->timestamp;
modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp
-2
View File
@@ -38,8 +38,6 @@
#include <ghoul/opengl/textureunit.h>
namespace {
constexpr const char* _loggerCat = "RenderableModelProjection";
constexpr const char* DestinationFrame = "GALACTIC";
constexpr const std::array<const char*, 7> MainUniformNames = {
modules/spacecraftinstruments/spacecraftinstrumentsmodule.cpp
+6 -7
View File
@@ -48,17 +48,16 @@ void SpacecraftInstrumentsModule::internalInitialize(const ghoul::Dictionary&) {
ImageSequencer::initialize();
FactoryManager::ref().addFactory(
std::make_unique<ghoul::TemplateFactory<Decoder>>(),
"Decoder"
);
FactoryManager::ref().addFactory<Decoder>("Decoder");
auto fDashboard = FactoryManager::ref().factory<DashboardItem>();
ghoul::TemplateFactory<DashboardItem>* fDashboard =
FactoryManager::ref().factory<DashboardItem>();
ghoul_assert(fDashboard, "Dashboard factory was not created");
fDashboard->registerClass<DashboardItemInstruments>("DashboardItemInstruments");
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableCrawlingLine>("RenderableCrawlingLine");
@@ -68,7 +67,7 @@ void SpacecraftInstrumentsModule::internalInitialize(const ghoul::Dictionary&) {
fRenderable->registerClass<RenderablePlanetProjection>("RenderablePlanetProjection");
fRenderable->registerClass<RenderableShadowCylinder>("RenderableShadowCylinder");
auto fDecoder = FactoryManager::ref().factory<Decoder>();
ghoul::TemplateFactory<Decoder>* fDecoder = FactoryManager::ref().factory<Decoder>();
fDecoder->registerClass<InstrumentDecoder>("Instrument");
fDecoder->registerClass<TargetDecoder>("Target");
}
modules/spout/spoutmodule.cpp
+4 -2
View File
@@ -37,11 +37,13 @@ SpoutModule::SpoutModule() : OpenSpaceModule(Name) {}
void SpoutModule::internalInitialize(const ghoul::Dictionary&) {
#ifdef WIN32
auto fSsRenderable = FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul::TemplateFactory<ScreenSpaceRenderable>* fSsRenderable =
FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul_assert(fSsRenderable, "ScreenSpaceRenderable factory was not created");
fSsRenderable->registerClass<ScreenSpaceSpout>("ScreenSpaceSpout");
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "Renderable factory was not created");
fRenderable->registerClass<RenderablePlaneSpout>("RenderablePlaneSpout");
#endif // WIN32
modules/sync/syncmodule.cpp
+2 -5
View File
@@ -44,10 +44,6 @@
#include "syncmodule_lua.inl"
namespace {
constexpr const char* KeyHttpSynchronizationRepositories =
"HttpSynchronizationRepositories";
constexpr const char* KeySynchronizationRoot = "SynchronizationRoot";
struct [[codegen::Dictionary(SyncModule)]] Parameters {
// The list of all repository URLs that are used to fetch data from for
// HTTPSynchronizations
@@ -72,7 +68,8 @@ void SyncModule::internalInitialize(const ghoul::Dictionary& configuration) {
_synchronizationRoot = absPath(p.synchronizationRoot);
auto fSynchronization = FactoryManager::ref().factory<ResourceSynchronization>();
ghoul::TemplateFactory<ResourceSynchronization>* fSynchronization =
FactoryManager::ref().factory<ResourceSynchronization>();
ghoul_assert(fSynchronization, "ResourceSynchronization factory was not created");
fSynchronization->registerClass(
modules/sync/syncs/httpsynchronization.cpp
+5 -9
View File
@@ -35,9 +35,6 @@ namespace {
constexpr const char* TempSuffix = ".tmp";
constexpr const char* QueryKeyIdentifier = "identifier";
constexpr const char* QueryKeyFileVersion = "file_version";
constexpr const char* QueryKeyApplicationVersion = "application_version";
constexpr const int ApplicationVersion = 1;
struct [[codegen::Dictionary(HttpSynchronization)]] Parameters {
@@ -170,12 +167,11 @@ bool HttpSynchronization::trySyncFromUrl(std::string listUrl) {
continue;
}
std::unique_ptr<HttpFileDownload> download =
std::make_unique<HttpFileDownload>(
line,
destination,
HttpFileDownload::Overwrite::Yes
);
auto download = std::make_unique<HttpFileDownload>(
line,
destination,
HttpFileDownload::Overwrite::Yes
);
HttpFileDownload* dl = download.get();
downloads.push_back(std::move(download));
modules/sync/syncs/urlsynchronization.cpp
+5 -6
View File
@@ -156,12 +156,11 @@ void UrlSynchronization::start() {
}
std::filesystem::path destination = directory() / (_filename + TempSuffix);
std::unique_ptr<HttpFileDownload> download =
std::make_unique<HttpFileDownload>(
url,
destination,
HttpFileDownload::Overwrite::Yes
);
auto download = std::make_unique<HttpFileDownload>(
url,
destination,
HttpFileDownload::Overwrite::Yes
);
HttpFileDownload* dl = download.get();
downloads.push_back(std::move(download));
modules/touch/src/win32_touch.cpp
+2 -6
View File
@@ -119,18 +119,14 @@ LRESULT CALLBACK HookCallback(int nCode, WPARAM wParam, LPARAM lParam) {
if (info.pointerFlags & POINTER_FLAG_DOWN) {
#ifdef ENABLE_DIRECTMSG
std::unique_ptr<TouchInputHolder> points =
std::make_unique<TouchInputHolder>(touchInput);
auto points = std::make_unique<TouchInputHolder>(touchInput);
gTouchInputsMap.emplace(info.pointerId, std::move(points));
global::openSpaceEngine->touchDetectionCallback(touchInput);
#endif
#ifdef ENABLE_TUIOMESSAGES
// Handle new touchpoint
gTuioServer->initFrame(TUIO::TuioTime::getSessionTime());
gCursorMap[info.pointerId] = gTuioServer->addTuioCursor(
xPos,
yPos
);
gCursorMap[info.pointerId] = gTuioServer->addTuioCursor(xPos, yPos);
gTuioServer->commitFrame();
#endif
}
modules/toyvolume/toyvolumemodule.cpp
+2 -1
View File
@@ -34,7 +34,8 @@ namespace openspace {
ToyVolumeModule::ToyVolumeModule() : OpenSpaceModule(Name) {}
void ToyVolumeModule::internalInitialize(const ghoul::Dictionary&) {
auto fRenderable = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* fRenderable =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(fRenderable, "No renderable factory existed");
fRenderable->registerClass<RenderableToyVolume>("RenderableToyVolume");
}
modules/vislab/vislabmodule.cpp
+2 -1
View File
@@ -35,7 +35,8 @@ namespace openspace {
VisLabModule::VisLabModule() : OpenSpaceModule(Name) {}
void VisLabModule::internalInitialize(const ghoul::Dictionary&) {
auto renderableFactory = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* renderableFactory =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(renderableFactory, "No renderable factory existed");
renderableFactory->registerClass<RenderableDistanceLabel>("RenderableDistanceLabel");
modules/volume/rawvolumereader.inl
+2 -4
View File
@@ -80,9 +80,7 @@ glm::uvec3 RawVolumeReader<VoxelType>::indexToCoords(size_t linear) const {
template <typename VoxelType>
std::unique_ptr<RawVolume<VoxelType>> RawVolumeReader<VoxelType>::read(bool invertZ) {
glm::uvec3 dims = dimensions();
std::unique_ptr<RawVolume<VoxelType>> volume = std::make_unique<RawVolume<VoxelType>>(
dims
);
auto volume = std::make_unique<RawVolume<VoxelType>>(dims);
std::ifstream file(_path, std::ios::binary);
char* buffer = reinterpret_cast<char*>(volume->data());
@@ -106,7 +104,7 @@ std::unique_ptr<RawVolume<VoxelType>> RawVolumeReader<VoxelType>::read(bool inve
std::unique_ptr<RawVolume<VoxelType>> newVolume =
std::make_unique<RawVolume<VoxelType>>(dims);
for (int i = 0; i < volume->nCells(); ++i) {
for (size_t i = 0; i < volume->nCells(); ++i) {
const glm::uvec3& coords = volume->indexToCoords(i);
glm::uvec3 newcoords = glm::uvec3(coords.x, coords.y, dims.z - coords.z - 1);
modules/volume/textureslicevolumereader.inl
+4 -2
View File
@@ -82,8 +82,10 @@ TextureSliceVolumeReader<VoxelType>::getSlice(int sliceIndex) const
std::shared_ptr<ghoul::opengl::Texture> texture =
ghoul::io::TextureReader::ref().loadTexture(_paths[sliceIndex], 2);
glm::ivec2 dimensions = glm::uvec2(texture->dimensions());
ghoul_assert(dimensions == _sliceDimensions, "Slice dimensions do not agree.");
ghoul_assert(
glm::ivec2(texture->dimensions()) == _sliceDimensions,
"Slice dimensions do not agree"
);
_cache.set(sliceIndex, std::move(texture));
}
return *_cache.get(sliceIndex).get();
modules/volume/volumemodule.cpp
+3 -2
View File
@@ -40,11 +40,12 @@ using namespace volume;
VolumeModule::VolumeModule() : OpenSpaceModule(Name) {}
void VolumeModule::internalInitialize(const ghoul::Dictionary&) {
auto rFactory = FactoryManager::ref().factory<Renderable>();
ghoul::TemplateFactory<Renderable>* rFactory =
FactoryManager::ref().factory<Renderable>();
ghoul_assert(rFactory, "No renderable factory existed");
rFactory->registerClass<RenderableTimeVaryingVolume>("RenderableTimeVaryingVolume");
auto tFactory = FactoryManager::ref().factory<Task>();
ghoul::TemplateFactory<Task>* tFactory = FactoryManager::ref().factory<Task>();
ghoul_assert(tFactory, "No task factory existed");
tFactory->registerClass<GenerateRawVolumeTask>("GenerateRawVolumeTask");
}
modules/webbrowser/webbrowsermodule.cpp
+2 -1
View File
@@ -163,7 +163,8 @@ void WebBrowserModule::internalInitialize(const ghoul::Dictionary& dictionary) {
_eventHandler->initialize();
// register ScreenSpaceBrowser
auto fScreenSpaceRenderable = FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul::TemplateFactory<ScreenSpaceRenderable>* fScreenSpaceRenderable =
FactoryManager::ref().factory<ScreenSpaceRenderable>();
ghoul_assert(fScreenSpaceRenderable, "ScreenSpaceRenderable factory was not created");
fScreenSpaceRenderable->registerClass<ScreenSpaceBrowser>("ScreenSpaceBrowser");
}