mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-02 01:30:34 -06:00
301 lines
10 KiB
C++
301 lines
10 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2018 *
|
|
* *
|
|
* 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/spacecraftinstruments/rendering/renderablecrawlingline.h>
|
|
|
|
#include <modules/spacecraftinstruments/util/imagesequencer.h>
|
|
#include <openspace/documentation/documentation.h>
|
|
#include <openspace/documentation/verifier.h>
|
|
#include <openspace/engine/openspaceengine.h>
|
|
#include <openspace/rendering/renderengine.h>
|
|
#include <openspace/util/spicemanager.h>
|
|
#include <openspace/util/updatestructures.h>
|
|
|
|
#include <ghoul/filesystem/filesystem.h>
|
|
#include <ghoul/opengl/programobject.h>
|
|
|
|
#include <ghoul/glm.h>
|
|
|
|
namespace {
|
|
const char* KeySource = "Source";
|
|
const char* KeyTarget = "Target";
|
|
const char* KeyInstrument = "Instrument";
|
|
const char* KeyColor = "Color";
|
|
const char* KeyColorStart = "Start";
|
|
const char* KeyColorEnd = "End";
|
|
|
|
struct VBOData {
|
|
float position[3];
|
|
float color[4];
|
|
};
|
|
} // namespace
|
|
|
|
namespace openspace {
|
|
|
|
documentation::Documentation RenderableCrawlingLine::Documentation() {
|
|
using namespace documentation;
|
|
return {
|
|
"RenderableCrawlingLine",
|
|
"newhorizons_renderable_crawlingline",
|
|
{
|
|
{
|
|
KeySource,
|
|
new StringVerifier,
|
|
Optional::No,
|
|
"Denotes the SPICE name of the source of the renderable crawling line, "
|
|
"for example, the space craft"
|
|
},
|
|
{
|
|
KeyTarget,
|
|
new StringVerifier,
|
|
Optional::Yes,
|
|
"Denotes the SPICE name of the target of the crawling line"
|
|
},
|
|
{
|
|
KeyInstrument,
|
|
new StringVerifier,
|
|
Optional::No,
|
|
"Denotes the SPICE name of the instrument that is used to render the "
|
|
"crawling line"
|
|
},
|
|
{
|
|
KeyColor,
|
|
new TableVerifier({
|
|
{
|
|
KeyColorStart,
|
|
new DoubleVector4Verifier,
|
|
Optional::No,
|
|
"The color at the start of the line",
|
|
},
|
|
{
|
|
KeyColorEnd,
|
|
new DoubleVector4Verifier,
|
|
Optional::No,
|
|
"The color at the end of the line"
|
|
}
|
|
}),
|
|
Optional::No,
|
|
"Specifies the colors that are used for the crawling line. One value "
|
|
"determines the starting color of the line, the second value is the "
|
|
"color at the end of the line."
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
RenderableCrawlingLine::RenderableCrawlingLine(const ghoul::Dictionary& dictionary)
|
|
: Renderable(dictionary)
|
|
, _program(nullptr)
|
|
, _frameCounter(0)
|
|
, _drawLine(false)
|
|
, _imageSequenceTime(-1.f)
|
|
, _vao(0)
|
|
, _vbo(0)
|
|
{
|
|
documentation::testSpecificationAndThrow(
|
|
Documentation(),
|
|
dictionary,
|
|
"RenderableCrawlingLine"
|
|
);
|
|
|
|
_source = dictionary.value<std::string>(KeySource);
|
|
_target = dictionary.value<std::string>(KeyTarget);
|
|
_instrumentName = dictionary.value<std::string>(KeyInstrument);
|
|
|
|
_lineColorBegin = dictionary.value<glm::vec4>(
|
|
std::string(KeyColor) + "." + KeyColorStart
|
|
);
|
|
|
|
_lineColorEnd = dictionary.value<glm::vec4>(
|
|
std::string(KeyColor) + "." + KeyColorEnd
|
|
);
|
|
}
|
|
|
|
bool RenderableCrawlingLine::isReady() const {
|
|
return (_program != nullptr);
|
|
}
|
|
|
|
void RenderableCrawlingLine::initializeGL() {
|
|
RenderEngine& renderEngine = OsEng.renderEngine();
|
|
_program = renderEngine.buildRenderProgram(
|
|
"RenderableCrawlingLine",
|
|
absPath("${MODULE_SPACECRAFTINSTRUMENTS}/shaders/crawlingline_vs.glsl"),
|
|
absPath("${MODULE_SPACECRAFTINSTRUMENTS}/shaders/crawlingline_fs.glsl")
|
|
);
|
|
|
|
glGenVertexArrays(1, &_vao);
|
|
glGenBuffers(1, &_vbo);
|
|
|
|
glBindVertexArray(_vao);
|
|
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
|
|
glBufferData(GL_ARRAY_BUFFER, 2 * sizeof(VBOData), nullptr, GL_DYNAMIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(VBOData), nullptr);
|
|
|
|
glEnableVertexAttribArray(1);
|
|
glVertexAttribPointer(
|
|
1,
|
|
4,
|
|
GL_FLOAT,
|
|
GL_FALSE,
|
|
sizeof(VBOData),
|
|
reinterpret_cast<void*>(offsetof(VBOData, color))
|
|
);
|
|
|
|
glBindVertexArray(0);
|
|
}
|
|
|
|
void RenderableCrawlingLine::deinitializeGL() {
|
|
glDeleteVertexArrays(1, &_vao);
|
|
_vao = 0;
|
|
glDeleteBuffers(1, &_vbo);
|
|
_vbo = 0;
|
|
|
|
RenderEngine& renderEngine = OsEng.renderEngine();
|
|
if (_program) {
|
|
renderEngine.removeRenderProgram(_program);
|
|
_program = nullptr;
|
|
}
|
|
}
|
|
|
|
void RenderableCrawlingLine::render(const RenderData& data, RendererTasks&) {
|
|
if (!_drawLine) {
|
|
return;
|
|
}
|
|
|
|
_program->activate();
|
|
_frameCounter++;
|
|
|
|
glm::dmat4 modelTransform =
|
|
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
|
|
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
|
|
glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale));
|
|
|
|
glm::dmat4 modelViewProjectionTransform =
|
|
data.camera.projectionMatrix() *
|
|
glm::mat4(data.camera.combinedViewMatrix() *
|
|
modelTransform
|
|
)
|
|
;
|
|
//glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
|
|
|
|
// setup the data to the shader
|
|
//_program->setUniform("modelViewTransform", glm::mat4(modelViewTransform));
|
|
//_program->setUniform("projectionTransform", data.camera.projectionMatrix());
|
|
_program->setUniform("modelViewProjection", modelViewProjectionTransform);
|
|
|
|
int frame = _frameCounter % 60;
|
|
float fadingFactor = static_cast<float>(sin((frame * 3.14159) / 60));
|
|
float alpha = 0.6f + fadingFactor*0.4f;
|
|
|
|
glLineWidth(2.f);
|
|
|
|
_program->setUniform("_alpha", alpha);
|
|
//_program->setUniform("color", _lineColor);
|
|
//setPscUniforms(*_program.get(), data.camera, data.position);
|
|
|
|
glBindVertexArray(_vao);
|
|
|
|
glDrawArrays(GL_LINES, 0, 2);
|
|
glBindVertexArray(0);
|
|
|
|
_program->deactivate();
|
|
}
|
|
|
|
void RenderableCrawlingLine::update(const UpdateData& data) {
|
|
if (_program->isDirty()) {
|
|
_program->rebuildFromFile();
|
|
}
|
|
|
|
// glm::dmat3 transformMatrix = SpiceManager::ref().positionTransformMatrix(
|
|
// _source,
|
|
// //"ECLIPJ2000",
|
|
// "GALACTIC",
|
|
// data.time.j2000Seconds()
|
|
// );
|
|
|
|
glm::dmat3 tm = SpiceManager::ref().frameTransformationMatrix(
|
|
_instrumentName,
|
|
"ECLIPJ2000",
|
|
data.time.j2000Seconds()
|
|
);
|
|
|
|
//_positions[SourcePosition] = { 0.f, 0.f, 0.f, 0.f };
|
|
|
|
glm::dvec3 boresight;
|
|
//try {
|
|
SpiceManager::FieldOfViewResult res =
|
|
SpiceManager::ref().fieldOfView(_source);
|
|
boresight = res.boresightVector;
|
|
|
|
//}
|
|
//catch (const SpiceManager::SpiceException& e) {
|
|
//LERROR(e.what());
|
|
//}
|
|
|
|
glm::vec4 target(boresight[0], boresight[1], boresight[2], 12);
|
|
target = glm::dmat4(tm) * target;
|
|
|
|
//_positions[TargetPosition] = target;
|
|
//_positions[TargetPosition] = {
|
|
// target.x * pow(10, target.w),
|
|
// target.y * pow(10, target.w),
|
|
// target.z * pow(10, target.w),
|
|
// 0
|
|
//};
|
|
|
|
VBOData vboData[2] = {
|
|
{
|
|
{ 0.f, 0.f, 0.f },
|
|
{ _lineColorBegin.r, _lineColorBegin.g, _lineColorBegin.b, _lineColorBegin.a }
|
|
},
|
|
{
|
|
{
|
|
target.x * powf(10, target.w),
|
|
target.y * powf(10, target.w),
|
|
target.z * powf(10, target.w)
|
|
},
|
|
{ _lineColorEnd.r, _lineColorEnd.g, _lineColorEnd.b, _lineColorEnd.a }
|
|
}
|
|
};
|
|
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
|
|
glBufferSubData(
|
|
GL_ARRAY_BUFFER,
|
|
0,
|
|
2 * sizeof(VBOData),
|
|
vboData
|
|
);
|
|
//glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(psc) * 2, _positions);
|
|
|
|
if (ImageSequencer::ref().isReady()) {
|
|
_imageSequenceTime = ImageSequencer::ref().instrumentActiveTime(_instrumentName);
|
|
_drawLine = _imageSequenceTime != -1.f;
|
|
}
|
|
}
|
|
|
|
} // namespace openspace
|