mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-02 01:30:34 -06:00
419 lines
17 KiB
C++
419 lines
17 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2016 *
|
|
* *
|
|
* 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/base/rendering/renderabletrailnew.h>
|
|
|
|
#include <openspace/util/time.h>
|
|
#include <openspace/util/spicemanager.h>
|
|
#include <openspace/util/updatestructures.h>
|
|
#include <openspace/util/timerange.h>
|
|
|
|
#include <openspace/engine/openspaceengine.h>
|
|
#include <openspace/rendering/renderengine.h>
|
|
#include <openspace/interaction/interactionhandler.h>
|
|
|
|
#include <ghoul/opengl/programobject.h>
|
|
|
|
#include <limits>
|
|
#include <stdint.h>
|
|
|
|
namespace {
|
|
const std::string _loggerCat = "RenderableTrailNew";
|
|
|
|
// Spice
|
|
const std::string keyBody = "Body";
|
|
const std::string keyFrame = "Frame";
|
|
const std::string keyObserver = "Observer";
|
|
// Rendering properties
|
|
const std::string keyLineColor = "LineColor";
|
|
const std::string keyPointColor = "PointColor";
|
|
const std::string keyLineFade = "LineFade";
|
|
const std::string keyLineWidth = "LineWidth";
|
|
const std::string keyRenderPart = "RenderPart";
|
|
const std::string keyShowTimeStamps = "ShowTimeStamps";
|
|
const std::string keyRenderFullTrail = "RenderFullTrail";
|
|
// Time interval
|
|
const std::string keyTimeRange = "TimeRange";
|
|
const std::string keySampleDeltaTime = "SampleDeltaTime";
|
|
const std::string keySubSamples = "SubSamples";
|
|
// Static Constants
|
|
static const glm::vec3 DEFAULT_COLOR = glm::vec3(1.0f);
|
|
static const float DEFAULT_LINE_FADE = 0.5f;
|
|
static const float DEFAULT_LINE_WIDTH = 2.0f;
|
|
static const int DEFAULT_POINT_STEPS = 1;
|
|
static const int DEFAULT_RENDER_PART = 1;
|
|
static const bool DEFAULT_SHOW_TIME_STAMPS = false;
|
|
static const bool DEFAULT_RENDER_FULL_TRAIL = false;
|
|
}
|
|
|
|
namespace openspace {
|
|
|
|
RenderableTrailNew::RenderableTrailNew(const ghoul::Dictionary& dictionary)
|
|
: Renderable(dictionary)
|
|
// Properties
|
|
, _lineColor("lineColor", "Line Color", DEFAULT_COLOR, glm::vec3(0), glm::vec3(1))
|
|
, _pointColor("pointColor", "Point Color", DEFAULT_COLOR, glm::vec3(0), glm::vec3(1))
|
|
, _lineFade("lineFade", "Line Fade", DEFAULT_LINE_FADE, 0, 1)
|
|
, _lineWidth("lineWidth", "Line Width", DEFAULT_LINE_WIDTH, 1, 10)
|
|
, _renderPart("renderPart", "Render Part", DEFAULT_RENDER_PART, 0, DEFAULT_RENDER_PART)
|
|
, _showTimeStamps("showTimeStamps", "Show TimeStamps", DEFAULT_SHOW_TIME_STAMPS)
|
|
, _renderFullTrail("renderFullTrail", "Render Full Trail", DEFAULT_RENDER_FULL_TRAIL)
|
|
// OpenGL
|
|
, _vaoGlobalID(0)
|
|
, _vBufferGlobalID(0)
|
|
, _vaoLocalID(0)
|
|
, _vBufferLocalID(0)
|
|
// Other
|
|
, _programObject(nullptr)
|
|
, _successfullDictionaryFetch(true)
|
|
, _currentTimeClamped(0)
|
|
, _subSamples(0)
|
|
{
|
|
ghoul::Dictionary timeRangeDict;
|
|
|
|
// Values that needs to be set
|
|
_successfullDictionaryFetch &= dictionary.getValue(keyBody, _body);
|
|
_successfullDictionaryFetch &= dictionary.getValue(keyObserver, _observer);
|
|
_successfullDictionaryFetch &= dictionary.getValue(keyFrame, _frame);
|
|
_successfullDictionaryFetch &= dictionary.getValue(keySampleDeltaTime, _sampleDeltaTime);
|
|
_successfullDictionaryFetch &= dictionary.getValue(keyTimeRange, timeRangeDict);
|
|
_successfullDictionaryFetch &= TimeRange::initializeFromDictionary(
|
|
timeRangeDict, _timeRange);
|
|
|
|
// Validate
|
|
_successfullDictionaryFetch &= _sampleDeltaTime > 0;
|
|
|
|
// Initialize optional values
|
|
glm::vec3 lineColor = glm::vec3(DEFAULT_COLOR);
|
|
glm::vec3 pointColor = glm::vec3(DEFAULT_COLOR);
|
|
float lineFade = DEFAULT_LINE_FADE;
|
|
float lineWidth = DEFAULT_LINE_WIDTH;
|
|
float pointSteps = DEFAULT_POINT_STEPS;
|
|
double renderPart = DEFAULT_RENDER_PART;
|
|
bool showTimeStamps = DEFAULT_SHOW_TIME_STAMPS;
|
|
bool renderFullTrail = DEFAULT_RENDER_FULL_TRAIL;
|
|
|
|
// Fetch from dictionary
|
|
dictionary.getValue(keyLineColor, lineColor);
|
|
dictionary.getValue(keyPointColor, pointColor);
|
|
dictionary.getValue(keyLineFade, lineFade);
|
|
dictionary.getValue(keyLineWidth, lineWidth);
|
|
dictionary.getValue(keyRenderPart, renderPart);
|
|
dictionary.getValue(keyShowTimeStamps, showTimeStamps);
|
|
dictionary.getValue(keyRenderFullTrail, renderFullTrail);
|
|
float fSubSamples; // ghoul can not read ints from dictionaries...
|
|
if (dictionary.getValue(keySubSamples, fSubSamples))
|
|
_subSamples = fSubSamples;
|
|
|
|
// Set property values
|
|
_lineColor = lineColor;
|
|
_pointColor = pointColor;
|
|
_lineFade = lineFade;
|
|
_lineWidth = lineWidth;
|
|
_renderPart = renderPart;
|
|
_showTimeStamps = showTimeStamps;
|
|
_renderFullTrail = renderFullTrail;
|
|
|
|
// Add all properties and set view options
|
|
addProperty(_lineColor);
|
|
addProperty(_pointColor);
|
|
addProperty(_lineFade);
|
|
addProperty(_lineWidth);
|
|
addProperty(_renderPart);
|
|
addProperty(_showTimeStamps);
|
|
addProperty(_renderFullTrail);
|
|
|
|
_lineColor.setViewOption(properties::Property::ViewOptions::Color);
|
|
_pointColor.setViewOption(properties::Property::ViewOptions::Color);
|
|
}
|
|
|
|
bool RenderableTrailNew::initialize() {
|
|
if (!_successfullDictionaryFetch) {
|
|
LERROR("The following keys need to be set in the Dictionary. Cannot initialize!");
|
|
LERROR(keyBody << ": " << _body);
|
|
LERROR(keyObserver << ": " << _observer);
|
|
LERROR(keyFrame << ": " << _frame);
|
|
LERROR(keyTimeRange);
|
|
return false;
|
|
}
|
|
if (_subSamples < 0)
|
|
LERROR("SubSamples must not be less than 0: " << _subSamples);
|
|
|
|
RenderEngine& renderEngine = OsEng.renderEngine();
|
|
_programObject = renderEngine.buildRenderProgram("RenderableTrailNewProgram",
|
|
"${MODULE_BASE}/shaders/renderabletrailnew_vs.glsl",
|
|
"${MODULE_BASE}/shaders/renderabletrailnew_fs.glsl");
|
|
|
|
if (!_programObject)
|
|
return false;
|
|
|
|
sweepTimeRange();
|
|
initializeGlobalOpenGLPathData();
|
|
initializeLocalOpenGLPathData();
|
|
|
|
return true;
|
|
}
|
|
|
|
void RenderableTrailNew::initializeGlobalOpenGLPathData() {
|
|
glGenVertexArrays(1, &_vaoGlobalID);
|
|
glGenBuffers(1, &_vBufferGlobalID);
|
|
|
|
glBindVertexArray(_vaoGlobalID);
|
|
glBindBuffer(GL_ARRAY_BUFFER, _vBufferGlobalID);
|
|
// No need to update the trail several times, no need for stream draw.
|
|
glBufferData(
|
|
GL_ARRAY_BUFFER,
|
|
_vertexPositionArray.size() * sizeof(glm::vec3),
|
|
&_vertexPositionArray[0],
|
|
GL_STATIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
|
|
glBindVertexArray(0);
|
|
}
|
|
|
|
void RenderableTrailNew::initializeLocalOpenGLPathData() {
|
|
glGenVertexArrays(1, &_vaoLocalID);
|
|
glGenBuffers(1, &_vBufferLocalID);
|
|
|
|
glBindVertexArray(_vaoLocalID);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, _vBufferLocalID);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
|
|
|
|
glBindVertexArray(0);
|
|
}
|
|
|
|
void RenderableTrailNew::deInitializeGlobalOpenGLPathData() {
|
|
glDeleteVertexArrays(1, &_vaoGlobalID);
|
|
glDeleteBuffers(1, &_vBufferGlobalID);
|
|
}
|
|
|
|
void RenderableTrailNew::deInitializeLocalOpenGLPathData() {
|
|
glDeleteVertexArrays(1, &_vaoLocalID);
|
|
glDeleteBuffers(1, &_vBufferLocalID);
|
|
}
|
|
|
|
bool RenderableTrailNew::deinitialize() {
|
|
deInitializeGlobalOpenGLPathData();
|
|
deInitializeLocalOpenGLPathData();
|
|
|
|
RenderEngine& renderEngine = OsEng.renderEngine();
|
|
if (_programObject) {
|
|
renderEngine.removeRenderProgram(_programObject);
|
|
_programObject = nullptr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void RenderableTrailNew::sweepTimeRange() {
|
|
double lightTime = 0.0;
|
|
double subDeltaTime = _sampleDeltaTime / (1 + _subSamples);
|
|
glm::dvec3 bodyPosition;
|
|
// Loop through all points from time range start to end
|
|
for (double t = _timeRange.start; t < _timeRange.end; t += subDeltaTime) {
|
|
try {
|
|
bodyPosition = SpiceManager::ref().targetPosition(
|
|
_body, _observer, _frame, {}, t, lightTime);
|
|
}
|
|
catch (const SpiceManager::SpiceException& e) {
|
|
LERROR(e.what());
|
|
break;
|
|
}
|
|
// Convert from km used by SPICE to meters used by OpenSpace
|
|
bodyPosition *= 1000;
|
|
_vertexPositionArray.push_back(glm::vec3(bodyPosition));
|
|
}
|
|
// Last point
|
|
bodyPosition = SpiceManager::ref().targetPosition(
|
|
_body, _observer, _frame, {}, _timeRange.end, lightTime);
|
|
_vertexPositionArray.push_back(glm::vec3(bodyPosition));
|
|
}
|
|
|
|
bool RenderableTrailNew::isReady() const {
|
|
return (_programObject != nullptr) && _successfullDictionaryFetch;
|
|
}
|
|
|
|
void RenderableTrailNew::render(const RenderData& data) {
|
|
_programObject->activate();
|
|
if (_renderFullTrail.value() == true) {
|
|
preRender(_vertexPositionArray.size());
|
|
preRenderSubPathGlobally(data);
|
|
// Easy but not beautiful solution to render all vertices with max alpha
|
|
_programObject->setUniform(
|
|
"vertexIDPadding", static_cast<int>(_vertexPositionArray.size()));
|
|
|
|
renderLines(_vaoGlobalID, _vertexPositionArray.size() - 1);
|
|
if (_showTimeStamps) {
|
|
renderPoints(_vaoGlobalID, _vertexPositionArray.size() - 1);
|
|
}
|
|
}
|
|
else { // Only render the trail up to the point of the object body
|
|
int nVerticesToDraw = glm::ceil(_vertexPositionArray.size() *
|
|
(_currentTimeClamped - _timeRange.start) / (_timeRange.end - _timeRange.start));
|
|
|
|
nVerticesToDraw = glm::min(
|
|
nVerticesToDraw, static_cast<int>(_vertexPositionArray.size())) - 1;
|
|
if (nVerticesToDraw > 1) {
|
|
preRender(nVerticesToDraw);
|
|
// Perform rendering of the bulk of the trail in single floating point precision
|
|
preRenderSubPathGlobally(data);
|
|
// The last vertex is drawn with higher precision after this
|
|
// Hence we subtract one vertex from the ones to draw globally
|
|
int nVerticesToDrawGlobally = nVerticesToDraw - 1;
|
|
renderLines(_vaoGlobalID, nVerticesToDrawGlobally);
|
|
if (_showTimeStamps) {
|
|
renderPoints(_vaoGlobalID, nVerticesToDrawGlobally);
|
|
}
|
|
|
|
// The last line segment is rendered relative to body to achieve high precision
|
|
preRenderSubPathLocally(data, nVerticesToDraw);
|
|
renderLines(_vaoLocalID, 2);
|
|
if (_showTimeStamps) {
|
|
renderPoints(_vaoLocalID, 2);
|
|
}
|
|
}
|
|
else if (_currentTimeClamped > _timeRange.start) {
|
|
preRenderSubPathLocally(data, 2);
|
|
renderLines(_vaoLocalID, 2);
|
|
}
|
|
}
|
|
|
|
|
|
_programObject->deactivate();
|
|
}
|
|
|
|
void RenderableTrailNew::preRender(int totalNumVerticesToDraw) {
|
|
// Upload uniforms that are the same for global and local rendering to the program
|
|
_programObject->setUniform("lineFade", _lineFade.value());
|
|
_programObject->setUniform("subSamples", _subSamples);
|
|
_programObject->setUniform("maxNumVertices",
|
|
static_cast<int>(_renderPart.value() * _vertexPositionArray.size()));
|
|
_programObject->setUniform("numVertices", totalNumVerticesToDraw);
|
|
}
|
|
|
|
void RenderableTrailNew::preRenderSubPathGlobally(const RenderData& data) {
|
|
// Model transform and view transform needs to be in double precision
|
|
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * _modelTransform;
|
|
glm::mat4 modelViewProjectionTransform =
|
|
data.camera.projectionMatrix() * glm::mat4(modelViewTransform);
|
|
|
|
// Upload uniforms that are specific to global rendering to the shader program
|
|
_programObject->setUniform(
|
|
"modelViewProjectionTransform", modelViewProjectionTransform);
|
|
_programObject->setUniform("vertexIDPadding", 0);
|
|
}
|
|
|
|
void RenderableTrailNew::preRenderSubPathLocally(
|
|
const RenderData& data, int totalNumVerticesToDraw) {
|
|
glm::dvec3 v0; // Vertex that connects to the global part of the trail
|
|
glm::dvec3 v1; // last vertex of the trail is in the position of the body
|
|
|
|
v0 = _vertexPositionArray[totalNumVerticesToDraw - 2];
|
|
v1 = _clampedBodyPosition;
|
|
|
|
// Define positions relative to body (v1) which gives the high precision
|
|
glm::vec3 vertexData[2] = {glm::vec3(v0 - v1), glm::vec3(0)};
|
|
|
|
// Translation translates from the position of body so vertices should
|
|
// be defined relative to body (hence the added v1 in translation part of model matrix)
|
|
glm::dmat4 localTranslation = glm::translate(glm::dmat4(1.0), v1);
|
|
glm::dmat4 modelTransformLocal = _modelTransform * localTranslation;
|
|
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransformLocal;
|
|
glm::mat4 modelViewProjectionTransform =
|
|
data.camera.projectionMatrix() * glm::mat4(modelViewTransform);
|
|
|
|
// Upload the new MVP matrix to the shader program
|
|
_programObject->setUniform(
|
|
"modelViewProjectionTransform", modelViewProjectionTransform);
|
|
_programObject->setUniform("vertexIDPadding", totalNumVerticesToDraw - 2);
|
|
|
|
// Update the attribute data on the GPU
|
|
glBindBuffer(GL_ARRAY_BUFFER, _vBufferLocalID);
|
|
glBufferData(
|
|
GL_ARRAY_BUFFER,
|
|
2 * sizeof(glm::vec3), // Only two vertices for this part of the trail
|
|
vertexData, // Two vertices
|
|
GL_DYNAMIC_DRAW); // This part of the path is rendered dynamically
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
|
|
}
|
|
|
|
void RenderableTrailNew::renderLines(GLuint vao, int numberOfVertices) {
|
|
glLineWidth(_lineWidth);
|
|
|
|
_programObject->setUniform("color", _lineColor.value());
|
|
|
|
glBindVertexArray(vao);
|
|
glDrawArrays(GL_LINE_STRIP, 0, static_cast<GLsizei>(numberOfVertices));
|
|
glBindVertexArray(0);
|
|
|
|
glLineWidth(1.f);
|
|
}
|
|
|
|
void RenderableTrailNew::renderPoints(GLuint vao, int numberOfVertices) {
|
|
glEnable(GL_PROGRAM_POINT_SIZE);
|
|
|
|
_programObject->setUniform("color", _pointColor.value());
|
|
_programObject->setUniform("pointSize", static_cast<float>(_lineWidth * 3));
|
|
|
|
glBindVertexArray(vao);
|
|
glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(numberOfVertices));
|
|
glBindVertexArray(0);
|
|
|
|
glDisable(GL_PROGRAM_POINT_SIZE);
|
|
}
|
|
|
|
void RenderableTrailNew::update(const UpdateData& data) {
|
|
_currentTimeClamped = glm::clamp(data.time, _timeRange.start, _timeRange.end);
|
|
_modelTransform =
|
|
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
|
|
glm::dmat4(data.modelTransform.rotation) *
|
|
glm::dmat4(glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale)));
|
|
|
|
// Fetch the body position using SPICE
|
|
double lightTime = 0.0;
|
|
try {
|
|
_clampedBodyPosition = SpiceManager::ref().targetPosition(
|
|
_body, _observer, _frame, {}, _currentTimeClamped, lightTime);
|
|
}
|
|
catch (const SpiceManager::SpiceException& e) {
|
|
try {
|
|
_clampedBodyPosition = SpiceManager::ref().targetPosition(
|
|
_body, _observer, _frame, {}, _currentTimeClamped, _timeRange.end);
|
|
}
|
|
catch (const SpiceManager::SpiceException& e) {
|
|
return;
|
|
}
|
|
}
|
|
// Convert from km used by SPICE to meters used by OpenSpace
|
|
_clampedBodyPosition *= 1000;
|
|
}
|
|
|
|
} // namespace openspace
|