mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-02 09:41:13 -06:00
427 lines
14 KiB
C++
427 lines
14 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2015 *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
|
|
* software and associated documentation files (the "Software"), to deal in the Software *
|
|
* without restriction, including without limitation the rights to use, copy, modify, *
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
|
|
* permit persons to whom the Software is furnished to do so, subject to the following *
|
|
* conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in all copies *
|
|
* or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
|
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
****************************************************************************************/
|
|
|
|
#include <modules/fieldlines/rendering/renderablefieldlines.h>
|
|
#include <openspace/engine/openspaceengine.h>
|
|
#include <openspace/util/powerscaledcoordinate.h>
|
|
#include <modules/kameleon/include/kameleonwrapper.h>
|
|
#include <openspace/util/constants.h>
|
|
#include <openspace/scene/scenegraphnode.h>
|
|
|
|
#include <ghoul/filesystem/filesystem.h>
|
|
#include <ghoul/filesystem/file.h>
|
|
#include <ghoul/misc/assert.h>
|
|
|
|
#include <fstream>
|
|
|
|
namespace {
|
|
std::string _loggerCat = "RenderableFieldlines";
|
|
|
|
const float defaultFieldlineStepSize = 0.5f;;
|
|
const glm::vec4 defaultFieldlineColor = glm::vec4(1.f, 0.f, 0.f, 1.f);
|
|
|
|
const std::string keyVectorField = "VectorField";
|
|
const std::string keyVectorFieldType = "Type";
|
|
const std::string keyVectorFieldFile = "File";
|
|
const std::string keyVectorFieldVolumeModel = "Model";
|
|
const std::string keyVectorFieldVolumeVariable = "Variables";
|
|
|
|
const std::string keyFieldlines = "Fieldlines";
|
|
const std::string keyFieldlinesStepSize = "Stepsize";
|
|
const std::string keyFieldlinesClassification = "Classification";
|
|
const std::string keyFieldlinesColor = "Color";
|
|
|
|
const std::string keySeedPoints = "SeedPoints";
|
|
const std::string keySeedPointsType = "Type";
|
|
const std::string keySeedPointsFile = "File";
|
|
const std::string keySeedPointsTable = "SeedPoints";
|
|
|
|
const std::string seedPointsSourceFile = "File";
|
|
const std::string seedPointsSourceTable = "Table";
|
|
|
|
const std::string vectorFieldTypeVolumeKameleon = "VolumeKameleon";
|
|
|
|
const std::string vectorFieldKameleonModelBATSRUS = "BATSRUS";
|
|
|
|
const std::string vectorFieldKameleonVariableLorentz = "Lorentz";
|
|
|
|
const int SeedPointSourceFile = 0;
|
|
const int SeedPointSourceTable = 1;
|
|
}
|
|
|
|
namespace openspace {
|
|
|
|
RenderableFieldlines::RenderableFieldlines(const ghoul::Dictionary& dictionary)
|
|
: Renderable(dictionary)
|
|
, _stepSize("stepSize", "Fieldline Step Size", defaultFieldlineStepSize, 0.f, 10.f)
|
|
, _classification("classification", "Fieldline Classification", true)
|
|
, _fieldlineColor(
|
|
"fieldlineColor",
|
|
"Fieldline Color",
|
|
defaultFieldlineColor,
|
|
glm::vec4(0.f),
|
|
glm::vec4(1.f)
|
|
)
|
|
, _seedPointSource("source", "SeedPoint Source")
|
|
, _seedPointSourceFile("sourceFile", "SeedPoint File")
|
|
, _program(nullptr)
|
|
, _seedPointsAreDirty(true)
|
|
, _fieldLinesAreDirty(true)
|
|
, _fieldlineVAO(0)
|
|
, _vertexPositionBuffer(0)
|
|
{
|
|
ghoul_assert(
|
|
dictionary.hasKeyAndValue<std::string>(SceneGraphNode::KeyName),
|
|
"Renderable does not have a name"
|
|
);
|
|
|
|
std::string name;
|
|
dictionary.getValue(SceneGraphNode::KeyName, name);
|
|
|
|
_loggerCat = "RenderableFieldlines [" + name + "]";
|
|
|
|
bool success = dictionary.getValue(keyVectorField, _vectorFieldInfo);
|
|
if (!success) {
|
|
LERROR("Renderable does not contain a key for '" <<
|
|
keyVectorField << "'");
|
|
}
|
|
|
|
success = dictionary.getValue(keyFieldlines, _fieldlineInfo);
|
|
if (!success) {
|
|
LERROR("Renderable does not contain a key for '" <<
|
|
keyFieldlines << "'");
|
|
}
|
|
|
|
success = dictionary.getValue(keySeedPoints, _seedPointsInfo);
|
|
if (!success) {
|
|
LERROR("Renderable does not contain a key for '" <<
|
|
keySeedPoints << "'");
|
|
}
|
|
|
|
// @TODO a non-magic number perhaps ---abock
|
|
setBoundingSphere(PowerScaledScalar::CreatePSS(250.f*6371000.f));
|
|
|
|
_seedPointSource.addOption(SeedPointSourceFile, "File");
|
|
_seedPointSource.addOption(SeedPointSourceTable, "Lua Table");
|
|
|
|
initializeDefaultPropertyValues();
|
|
|
|
// @TODO hook up visibility changes ---abock
|
|
|
|
auto dirtyFieldlines = [this]() { this->_fieldLinesAreDirty = true; };
|
|
auto dirtySeedpoints = [this]() { this->_seedPointsAreDirty = true; };
|
|
|
|
_stepSize.onChange(dirtyFieldlines);
|
|
addProperty(_stepSize);
|
|
|
|
addProperty(_classification);
|
|
|
|
_fieldlineColor.setViewOption(properties::Property::ViewOptions::Color);
|
|
addProperty(_fieldlineColor);
|
|
|
|
_seedPointSource.onChange(dirtySeedpoints);
|
|
addProperty(_seedPointSource);
|
|
|
|
_seedPointSourceFile.onChange(dirtySeedpoints);
|
|
addProperty(_seedPointSourceFile);
|
|
}
|
|
|
|
void RenderableFieldlines::initializeDefaultPropertyValues() {
|
|
bool success;
|
|
|
|
// Step size
|
|
float stepSize;
|
|
success = _fieldlineInfo.getValue(keyFieldlinesStepSize, stepSize);
|
|
if (success)
|
|
_stepSize = stepSize;
|
|
|
|
// Classification
|
|
bool classification;
|
|
success = _fieldlineInfo.getValue(keyFieldlinesClassification, classification);
|
|
if (success)
|
|
_classification = classification;
|
|
|
|
// Fieldline Color
|
|
glm::vec4 color;
|
|
success = _fieldlineInfo.getValue(keyFieldlinesColor, color);
|
|
if (success)
|
|
_fieldlineColor = color;
|
|
|
|
// Seedpoints Type
|
|
std::string sourceType;
|
|
success = _seedPointsInfo.getValue(keySeedPointsType, sourceType);
|
|
if (success) {
|
|
if (sourceType == seedPointsSourceFile) {
|
|
_seedPointSource = SeedPointSourceFile;
|
|
|
|
std::string seedPointSourceFile;
|
|
success = _seedPointsInfo.getValue(keySeedPointsFile, seedPointSourceFile);
|
|
if (success)
|
|
_seedPointSourceFile = absPath(seedPointSourceFile);
|
|
}
|
|
else if (sourceType == seedPointsSourceTable)
|
|
_seedPointSource = SeedPointSourceTable;
|
|
}
|
|
}
|
|
|
|
bool RenderableFieldlines::isReady() const {
|
|
bool programReady = _program != nullptr;
|
|
bool vectorFieldReady = !_vectorFieldInfo.empty();
|
|
bool fieldlineReady = !_fieldlineInfo.empty();
|
|
bool seedPointsReady = !_seedPointsInfo.empty();
|
|
return programReady && vectorFieldReady && fieldlineReady && seedPointsReady;
|
|
}
|
|
|
|
bool RenderableFieldlines::initialize() {
|
|
if (_vectorFieldInfo.empty() ||
|
|
_fieldlineInfo.empty() ||
|
|
_seedPointsInfo.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_program = ghoul::opengl::ProgramObject::Build(
|
|
"Fieldline",
|
|
"${SHADERS}/modules/fieldlines/fieldline_vs.glsl",
|
|
"${SHADERS}/modules/fieldlines/fieldline_fs.glsl",
|
|
"${SHADERS}/modules/fieldlines/fieldline_gs.glsl"
|
|
);
|
|
if (!_program)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RenderableFieldlines::deinitialize() {
|
|
glDeleteVertexArrays(1, &_fieldlineVAO);
|
|
_fieldlineVAO = 0;
|
|
glDeleteBuffers(1, &_vertexPositionBuffer);
|
|
_vertexPositionBuffer = 0;
|
|
return true;
|
|
}
|
|
|
|
void RenderableFieldlines::render(const RenderData& data) {
|
|
_program->activate();
|
|
_program->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
|
|
_program->setUniform("modelTransform", glm::mat4(1.0));
|
|
_program->setUniform("cameraViewDir", data.camera.viewDirection());
|
|
setPscUniforms(_program.get(), &data.camera, data.position);
|
|
|
|
_program->setUniform("classification", _classification);
|
|
if (!_classification)
|
|
_program->setUniform("fieldLineColor", _fieldlineColor);
|
|
|
|
glBindVertexArray(_fieldlineVAO);
|
|
glMultiDrawArrays(
|
|
GL_LINE_STRIP_ADJACENCY,
|
|
&_lineStart[0],
|
|
&_lineCount[0],
|
|
static_cast<GLsizei>(_lineStart.size())
|
|
);
|
|
glBindVertexArray(0);
|
|
|
|
_program->deactivate();
|
|
}
|
|
|
|
void RenderableFieldlines::update(const UpdateData&) {
|
|
if (_program->isDirty())
|
|
_program->rebuildFromFile();
|
|
|
|
if (_seedPointsAreDirty) {
|
|
loadSeedPoints();
|
|
_seedPointsAreDirty = false;
|
|
_fieldLinesAreDirty = true;
|
|
}
|
|
|
|
if (_fieldLinesAreDirty) {
|
|
std::vector<Line> fieldlines = generateFieldlines();
|
|
|
|
if (fieldlines.empty())
|
|
return ;
|
|
|
|
int prevEnd = 0;
|
|
std::vector<LinePoint> vertexData;
|
|
// Arrange data for glMultiDrawArrays
|
|
for (int j = 0; j < fieldlines.size(); ++j) {
|
|
_lineStart.push_back(prevEnd);
|
|
_lineCount.push_back(static_cast<int>(fieldlines[j].size()));
|
|
prevEnd = prevEnd + static_cast<int>(fieldlines[j].size());
|
|
vertexData.insert(vertexData.end(), fieldlines[j].begin(), fieldlines[j].end());
|
|
}
|
|
LDEBUG("Number of vertices : " << vertexData.size());
|
|
|
|
if (_fieldlineVAO == 0)
|
|
glGenVertexArrays(1, &_fieldlineVAO);
|
|
glBindVertexArray(_fieldlineVAO);
|
|
|
|
if (_vertexPositionBuffer == 0)
|
|
glGenBuffers(1, &_vertexPositionBuffer);
|
|
glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer);
|
|
|
|
glBufferData(GL_ARRAY_BUFFER, vertexData.size()*sizeof(LinePoint), &vertexData.front(), GL_STATIC_DRAW);
|
|
|
|
GLuint vertexLocation = 0;
|
|
glEnableVertexAttribArray(vertexLocation);
|
|
glVertexAttribPointer(vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(LinePoint), reinterpret_cast<void*>(0));
|
|
|
|
GLuint colorLocation = 1;
|
|
glEnableVertexAttribArray(colorLocation);
|
|
glVertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, sizeof(LinePoint), (void*)(sizeof(glm::vec3)));
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
glBindVertexArray(0);
|
|
|
|
_fieldLinesAreDirty = false;
|
|
}
|
|
}
|
|
|
|
void RenderableFieldlines::loadSeedPoints() {
|
|
_seedPoints.clear();
|
|
switch (_seedPointSource.value()) {
|
|
case SeedPointSourceFile:
|
|
loadSeedPointsFromFile();
|
|
break;
|
|
case SeedPointSourceTable:
|
|
loadSeedPointsFromTable();
|
|
break;
|
|
default:
|
|
ghoul_assert(false, "Missing case label");
|
|
}
|
|
}
|
|
|
|
void RenderableFieldlines::loadSeedPointsFromFile() {
|
|
LINFO("Reading seed points from file '" << _seedPointSourceFile.value() << "'");
|
|
|
|
std::ifstream seedFile(_seedPointSourceFile);
|
|
if (!seedFile.good())
|
|
LERROR("Could not open seed points file '" << _seedPointSourceFile.value() << "'");
|
|
else {
|
|
std::string line;
|
|
glm::vec3 point;
|
|
while (std::getline(seedFile, line)) {
|
|
std::stringstream s(line);
|
|
s >> point.x;
|
|
s >> point.y;
|
|
s >> point.z;
|
|
_seedPoints.push_back(std::move(point));
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenderableFieldlines::loadSeedPointsFromTable() {
|
|
// @TODO needs testing ---abock
|
|
LINFO("Loading provided list of seed points");
|
|
ghoul::Dictionary seedpointsDictionary;
|
|
_seedPointsInfo.getValue(keySeedPointsTable, seedpointsDictionary);
|
|
glm::vec3 seedPos;
|
|
for (const std::string& index : seedpointsDictionary.keys()) {
|
|
_fieldlineInfo.getValue(keySeedPointsTable + "." + index, seedPos);
|
|
_seedPoints.push_back(seedPos);
|
|
}
|
|
}
|
|
|
|
std::vector<RenderableFieldlines::Line> RenderableFieldlines::generateFieldlines() {
|
|
std::string type;
|
|
bool success = _vectorFieldInfo.getValue(keyVectorFieldType, type);
|
|
if (!success) {
|
|
LERROR(keyVectorField << " does not contain a '" <<
|
|
keyVectorFieldType << "' key");
|
|
return {};
|
|
}
|
|
|
|
if (type == vectorFieldTypeVolumeKameleon)
|
|
return generateFieldlinesVolumeKameleon();
|
|
else {
|
|
LERROR(keyVectorField << "." << keyVectorFieldType <<
|
|
" does not name a valid type");
|
|
return {};
|
|
}
|
|
}
|
|
|
|
std::vector<RenderableFieldlines::Line>
|
|
RenderableFieldlines::generateFieldlinesVolumeKameleon()
|
|
{
|
|
std::string model;
|
|
bool success = _vectorFieldInfo.getValue(keyVectorFieldVolumeModel, model);
|
|
if (!success) {
|
|
LERROR(keyVectorField << " does not name a model");
|
|
return {};
|
|
}
|
|
|
|
std::string fileName;
|
|
success = _vectorFieldInfo.getValue(keyVectorFieldFile, fileName);
|
|
if (!success) {
|
|
LERROR(keyVectorField << " does not name a file");
|
|
return {};
|
|
}
|
|
fileName = absPath(fileName);
|
|
|
|
//KameleonWrapper::Model modelType;
|
|
if (model != vectorFieldKameleonModelBATSRUS) {
|
|
//modelType = KameleonWrapper::Model::BATSRUS;
|
|
//else {
|
|
LERROR(keyVectorField << "." << keyVectorFieldVolumeModel << " model '" <<
|
|
model << "' not supported");
|
|
return {};
|
|
}
|
|
|
|
std::string v1 = keyVectorFieldVolumeVariable + ".1";
|
|
std::string v2 = keyVectorFieldVolumeVariable + ".2";
|
|
std::string v3 = keyVectorFieldVolumeVariable + ".3";
|
|
|
|
bool threeVariables =
|
|
_vectorFieldInfo.hasKeyAndValue<std::string>(v1) &&
|
|
_vectorFieldInfo.hasKeyAndValue<std::string>(v2) &&
|
|
_vectorFieldInfo.hasKeyAndValue<std::string>(v3);
|
|
|
|
bool lorentzForce =
|
|
_vectorFieldInfo.hasKeyAndValue<std::string>(v1) &&
|
|
(_vectorFieldInfo.value<std::string>(v1) == vectorFieldKameleonVariableLorentz);
|
|
|
|
if (!threeVariables && !lorentzForce) {
|
|
LERROR(keyVectorField << " does not name variables");
|
|
return {};
|
|
}
|
|
|
|
if (threeVariables) {
|
|
std::string xVariable, yVariable, zVariable;
|
|
_vectorFieldInfo.getValue(v1, xVariable);
|
|
_vectorFieldInfo.getValue(v2, yVariable);
|
|
_vectorFieldInfo.getValue(v3, zVariable);
|
|
|
|
KameleonWrapper kw(fileName);
|
|
return kw.getClassifiedFieldLines(xVariable, yVariable, zVariable, _seedPoints, _stepSize);
|
|
}
|
|
|
|
if (lorentzForce) {
|
|
KameleonWrapper kw(fileName);
|
|
return kw.getLorentzTrajectories(_seedPoints, _fieldlineColor, _stepSize);
|
|
}
|
|
|
|
ghoul_assert(false, "Should not reach this");
|
|
return {};
|
|
}
|
|
|
|
} // namespace openspace
|