diff --git a/include/openspace/rendering/renderablefov.h b/include/openspace/rendering/renderablefov.h index c0725a5b94..50e0db35b7 100644 --- a/include/openspace/rendering/renderablefov.h +++ b/include/openspace/rendering/renderablefov.h @@ -66,8 +66,6 @@ public: double _ratio; double _day; - // need to write robust method for vbo id selection - // (right now galactic grid has to be present) (why though?) solve later... GLuint _vaoID ; GLuint _vBufferID ; GLuint _iBufferID; @@ -83,8 +81,6 @@ public: unsigned int _vtotal; unsigned int _stride; - double _startTrail; - //Vertex* _varray; std::vector _varray; int* _iarray; diff --git a/include/openspace/util/spicemanager.h b/include/openspace/util/spicemanager.h index 7eb56e5c05..4ac6253475 100644 --- a/include/openspace/util/spicemanager.h +++ b/include/openspace/util/spicemanager.h @@ -250,6 +250,8 @@ public: bool getDateFromET(double ephemerisTime, std::string& date, const std::string& format = "YYYY MON DDTHR:MN:SC.### ::RND"); + void frameConversion(glm::dvec3& v, const std::string from, const std::string to, double ephemerisTime) const; + /** * Returns the position of a target body relative to an * observer in a specific referenceFrame, optionally @@ -290,7 +292,37 @@ public: psc& position, double& lightTime) const; - void getPointingAttitude(); + /** + * Given an observer and a direction vector defining a ray, compute + * the surface intercept of the ray on a target body at a specified + * epoch, optionally corrected for light time and stellar + * aberration. + * \param method Computation method. + * \param target Name of target body. + * \param et Epoch in ephemeris seconds past J2000 TDB. + * \param fixref Body-fixed, body-centered target body frame. + * \param abcorr Aberration correction. + * \param obsrvr Name of observing body. + * \param dref Reference frame of ray's direction vector. + * \param dvec Ray's direction vector. + * \param spoint Surface intercept point on the target body. + * \param trgepc Intercept epoch. + * \param srfvec Vector from observer to intercept point. + * \param found Flag indicating whether intercept was found. + * For further details, refer to + * http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/sincpt_c.html + */ + bool getSurfaceIntercept(const std::string& target, + const std::string& observer, + const std::string& fovFrame, + const std::string& bodyFixedFrame, + const std::string& method, + const std::string& aberrationCorrection, + double ephemerisTime, + double& targetEpoch, + psc& directionVector, + psc& surfaceIntercept, + psc& surfaceVector) const; /** * Returns the state vector (position and velocity) of a @@ -523,34 +555,6 @@ public: glm::dvec3& subObserverPoint, double& targetEphemerisTime, glm::dvec3& vectorToSurfacePoint) const; - - /** - * Computes the rectangular coordinates of the sub-solar point on - * a target body at a specified epoch, optionally corrected for - * light time and stellar aberration. - * For further details, please refer to 'subslr_c ' in SPICE Docummentation - * - * \param computationMethod Computation method. - * \param target Name of target body. - * \param ephemeris Epoch in ephemeris seconds past J2000 TDB. - * \param bodyFixedFrame Body-fixed, body-centered target body frame. - * \param aberrationCorrection Aberration correction. - * \param observer Name of observing body. - * \param subObserverPoint Sub-observer point on the target body. - * \param targetEpoch Sub-observer point epoch. - * \param observerToSubObserverVec Vector from observer to sub-observer point. - * \return Whether the function succeeded or not - */ - //bool getSubSolarPoint(std::string target, - // std::string computationMethod, - // - // double ephemeris, - // std::string bodyFixedFrame, - // std::string aberrationCorrection, - // - // glm::dvec3& subSolarPoint, - // double& targetEpoch, - // glm::dvec3& vectorToSurfacePoint) const; /** * This method checks if one of the previous SPICE methods has failed. If it has, the diff --git a/openspace-data b/openspace-data index b8179a6d15..79b6eaed96 160000 --- a/openspace-data +++ b/openspace-data @@ -1 +1 @@ -Subproject commit b8179a6d15943315cc7f21dd4daca90e31e40d8c +Subproject commit 79b6eaed961df78822203e874041faed4cb99cbd diff --git a/scripts/default_startup.lua b/scripts/default_startup.lua index b55e7f337e..04ad6c3fbc 100644 --- a/scripts/default_startup.lua +++ b/scripts/default_startup.lua @@ -1,10 +1,10 @@ --openspace.setPropertyValue('Earth.renderable.colorTexture', '${OPENSPACE_DATA}/modules/mars/textures/mars.png') -openspace.time.setTime("2007-02-26T17:30:00") +openspace.time.setTime("2007-02-26T17:57:54") --openspace.time.setTime("2006-08-22T20:00:00") --openspace.time.setDeltaTime(200000.0) --openspace.time.setDeltaTime(5000.00) ---openspace.time.setDeltaTime(864000) -openspace.time.setDeltaTime(100.0) +openspace.time.setDeltaTime(3600) +--openspace.time.setDeltaTime(100.0) -- print(openspace.time.currentTimeUTC()) diff --git a/shaders/pscstandard_fs.glsl b/shaders/pscstandard_fs.glsl index a0dc64aa16..99f75fe5dc 100644 --- a/shaders/pscstandard_fs.glsl +++ b/shaders/pscstandard_fs.glsl @@ -71,6 +71,7 @@ void main() } */ diffuse = max(intensity * diffuse, ambient); + diffuse[3] = 0.8f; //diffuse = vec4(1); ABufferStruct_t frag = createGeometryFragment(diffuse, position, depth); diff --git a/src/rendering/model/renderablemodel.cpp b/src/rendering/model/renderablemodel.cpp index d19cce054b..613a273e30 100644 --- a/src/rendering/model/renderablemodel.cpp +++ b/src/rendering/model/renderablemodel.cpp @@ -125,6 +125,8 @@ void RenderableModel::render(const RenderData& data) // scale the planet to appropriate size since the planet is a unit sphere glm::mat4 transform = glm::mat4(1); + glm::mat4 roty = glm::rotate(transform, 90.f, glm::vec3(0, 1, 0)); + glm::mat4 scale = glm::scale(transform, glm::vec3(1, -1, 1)); glm::mat4 tmp = glm::mat4(1); for (int i = 0; i < 3; i++){ @@ -132,7 +134,6 @@ void RenderableModel::render(const RenderData& data) tmp[i][j] = _stateMatrix[i][j]; } } - transform *= tmp; glm::mat4 modelview = data.camera.viewMatrix()*data.camera.modelMatrix(); diff --git a/src/rendering/renderablefov.cpp b/src/rendering/renderablefov.cpp index bb59e2a9c7..f5f8a955b2 100644 --- a/src/rendering/renderablefov.cpp +++ b/src/rendering/renderablefov.cpp @@ -52,19 +52,11 @@ namespace openspace{ , _vaoID(0) , _vBufferID(0) , _iBufferID(0) - , _mode(GL_LINE_STRIP){ + , _mode(GL_LINES){ assert(dictionary.getValue(keyBody , _target)); assert(dictionary.getValue(keyObserver , _observer)); assert(dictionary.getValue(keyFrame , _frame)); - - if (!dictionary.getValue(keyColor, _c)){ - _c = glm::vec3(0.0); - }else{ - _r = 1 / _c[0]; - _g = 1 / _c[1]; - _b = 1 / _c[2]; - } } void RenderableFov::fullYearSweep(){ @@ -122,9 +114,6 @@ bool RenderableFov::initialize(){ if (_programObject == nullptr) completeSuccess &= OsEng.ref().configurationManager().getValue("EphemerisProgram", _programObject); - _startTrail; - SpiceManager::ref().getETfromDate("2007 feb 26 20:00:00", _startTrail); - fullYearSweep(); sendToGPU(); @@ -147,74 +136,93 @@ void RenderableFov::render(const RenderData& data){ _programObject->activate(); // fetch data - glm::mat4 tmat = glm::mat4(1); - glm::mat4 transform(1); glm::mat4 tmp = glm::mat4(1); - glm::mat4 rot = glm::rotate(transform, 90.f, glm::vec3(0, 1, 0)); + glm::mat4 roty = glm::rotate(transform, 90.f, glm::vec3(0, 1, 0)); + glm::mat4 rotx = glm::rotate(transform, -90.f, glm::vec3(1, 0, 0)); + + glm::mat4 scale = glm::scale(transform, glm::vec3(1, -1, 1)); for (int i = 0; i < 3; i++){ for (int j = 0; j < 3; j++){ tmp[i][j] = _stateMatrix[i][j]; } } - transform = tmp*rot; // setup the data to the shader _programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix()); _programObject->setUniform("ModelTransform", transform); setPscUniforms(_programObject, &data.camera, data.position); + if (_oldTime != _time){ + //boresight vector + std::string shape, instrument; + std::vector bounds; + glm::dvec3 boresight; - //boresight vector - std::string shape, name; - shape.resize(32); - name.resize(32); - std::vector bounds; - glm::dvec3 boresight; + bool found = openspace::SpiceManager::ref().getFieldOfView("NH_LORRI", shape, instrument, boresight, bounds); + if (!found) LERROR("Could not locate instrument"); // fixlater - bool found = openspace::SpiceManager::ref().getFieldOfView("NH_LORRI", shape, name, boresight, bounds); + float size = 4 * sizeof(float); + float *begin = &_varray[0]; - float size = 4 * sizeof(float); - float *begin = &_varray[0]; + glm::vec4 origin(0); + glm::vec4 col_gray(0.3, 0.3, 0.3, 1); + glm::vec4 col_start(1.00, 0.89, 0.00, 1); + glm::vec4 col_end(1.00, 0.29, 0.00, 1); + // glm::vec4 bsight_t(boresight[0], boresight[1], boresight[2], data.position[3] - 3); - glm::vec4 origin(0); - glm::vec4 col_start(1.00, 0.89, 0.00, 1); - glm::vec4 col_end(1.00, 0.29, 0.00, 1); - glm::vec4 bsight_t(boresight[0], boresight[1], boresight[2], data.position[3]-3); + float sc = 2.4; + int indx = 0; + for (int i = 0; i < 4; i++){ + // might as well take glm. Would be nice if we had just one type to deal with here... + psc dir = PowerScaledCoordinate::PowerScaledCoordinate(bounds[i][0], bounds[i][1], bounds[i][2], 1); + psc intercept, interceptVector; + double targetEpoch; + found = openspace::SpiceManager::ref().getSurfaceIntercept("JUPITER", _target, instrument, + _frame, "ELLIPSOID", "XCN+S", + _time, targetEpoch, dir, intercept, interceptVector); + interceptVector[3] += 3; + glm::vec4 corner(bounds[i][0], bounds[i][1], bounds[i][2], data.position[3]); - float sc = 2.2; - glm::vec4 corner1(bounds[0][0], bounds[0][1], bounds[0][2], data.position[3]-sc); - memcpy(begin, glm::value_ptr(origin), size); - memcpy(begin + 4, glm::value_ptr(col_start), size); - memcpy(begin + 8, glm::value_ptr(corner1), size); - memcpy(begin + 12, glm::value_ptr(col_end), size); + corner = tmp*corner; - glm::vec4 corner2(bounds[1][0], bounds[1][1], bounds[1][2], data.position[3]-sc); - memcpy(begin + 16, glm::value_ptr(origin), size); - memcpy(begin + 20, glm::value_ptr(col_start), size); - memcpy(begin + 24, glm::value_ptr(corner2), size); - memcpy(begin + 28, glm::value_ptr(col_end), size); - - glm::vec4 corner3(bounds[2][0], bounds[2][1], bounds[2][2], data.position[3]-sc); - memcpy(begin + 32, glm::value_ptr(origin), size); - memcpy(begin + 36, glm::value_ptr(col_start), size); - memcpy(begin + 40, glm::value_ptr(corner3), size); - memcpy(begin + 44, glm::value_ptr(col_end), size); - - glm::vec4 corner4(bounds[3][0], bounds[3][1], bounds[3][2], data.position[3]-sc); - memcpy(begin + 48, glm::value_ptr(origin), size); - memcpy(begin + 52, glm::value_ptr(col_start), size); - memcpy(begin + 56, glm::value_ptr(corner4), size); - memcpy(begin + 60, glm::value_ptr(col_end), size); - - updateData(); + //cleanup later. + if (found){ + memcpy(&_varray[indx], glm::value_ptr(origin), size); + indx += 4; + memcpy(&_varray[indx], glm::value_ptr(col_start), size); + indx += 4; + memcpy(&_varray[indx], glm::value_ptr(interceptVector.vec4()), size); + indx += 4; + memcpy(&_varray[indx], glm::value_ptr(col_end), size); + indx += 4; + }else{ + memcpy(&_varray[indx], glm::value_ptr(origin), size); + indx += 4; + memcpy(&_varray[indx], glm::value_ptr(col_gray), size); + indx += 4; + memcpy(&_varray[indx], glm::value_ptr(corner), size); + indx += 4; + memcpy(&_varray[indx], glm::value_ptr(glm::vec4(0)), size); + indx += 4; + } + } + updateData(); + } + _oldTime = _time; glBindVertexArray(_vaoID); glDrawArrays(_mode, 0, _vtotal); glBindVertexArray(0); + + glPointSize(3.f); + glBindVertexArray(_vaoID); + glDrawArrays(GL_POINTS, 0, _vtotal); + glBindVertexArray(0); + _programObject->deactivate(); } @@ -223,7 +231,7 @@ void RenderableFov::update(const UpdateData& data){ _time = data.time; _delta = data.delta; - openspace::SpiceManager::ref().getPositionTransformMatrix("NH_SPACECRAFT", "GALACTIC", data.time, _stateMatrix); + openspace::SpiceManager::ref().getPositionTransformMatrix("NH_LORRI", "GALACTIC", data.time, _stateMatrix); } void RenderableFov::loadTexture() diff --git a/src/rendering/renderablepath.cpp b/src/rendering/renderablepath.cpp index 25b4963f07..8974c57361 100644 --- a/src/rendering/renderablepath.cpp +++ b/src/rendering/renderablepath.cpp @@ -94,7 +94,7 @@ void RenderablePath::fullYearSweep(){ int indx = 0; for (int i = 0; i < segments + 1; i++){ - SpiceManager::ref().getTargetState(_target, _observer, _frame, "LT+S", et, _pscpos, _pscvel, lightTime); + SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", et, _pscpos, _pscvel, lightTime); if (_pscpos[0] != 0 && _pscpos[1] != 0 && _pscpos[2] != 0 && _pscpos[3] != 1){ _pscpos[3] += 3; _varray.push_back(_pscpos[0]); @@ -214,7 +214,7 @@ void RenderablePath::fullYearSweep(){ _delta = data.delta; int newhorizons = 0; - SpiceManager::ref().getTargetState(_target, _observer, _frame, "LT+S", data.time, _pscpos, _pscvel, lightTime); + SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", data.time, _pscpos, _pscvel, lightTime); } void RenderablePath::loadTexture() diff --git a/src/rendering/renderabletrail.cpp b/src/rendering/renderabletrail.cpp index 9637a86ef9..79c5067c88 100644 --- a/src/rendering/renderabletrail.cpp +++ b/src/rendering/renderabletrail.cpp @@ -104,7 +104,7 @@ void RenderableTrail::fullYearSweep(){ _iarray = new int[_isize]; for (int i = 0; i < segments+2; i++){ - SpiceManager::ref().getTargetState(_target, _observer, _frame, "LT+S", et, _pscpos, _pscvel, lightTime); + SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", et, _pscpos, _pscvel, lightTime); _pscpos[3] += 3; for (int k = 0; k < 4; k++) @@ -172,7 +172,7 @@ bool RenderableTrail::initialize(){ _startTrail; // SpiceManager::ref().getETfromDate("2006 Aug 22 17:00:00", _startTrail); - SpiceManager::ref().getETfromDate("2007 feb 26 17:30:00", _startTrail); + SpiceManager::ref().getETfromDate("2007 feb 26 17:57:54", _startTrail); _dtEt = _startTrail; fullYearSweep(); @@ -215,7 +215,7 @@ void RenderableTrail::updateTrail(){ while (_dtEt < _time){ // get intermediary points psc dtPoint; - SpiceManager::ref().getTargetState(_target, _observer, _frame, "NONE", _dtEt, dtPoint, _pscvel, lightTime); + SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", _dtEt, dtPoint, _pscvel, lightTime); dtPoint[3] += 3; // overwrite the old position @@ -281,7 +281,7 @@ void RenderableTrail::update(const UpdateData& data){ _time = data.time; _delta = data.delta; - SpiceManager::ref().getTargetState(_target, _observer, _frame, "NONE", data.time, _pscpos, _pscvel, lightTime); + SpiceManager::ref().getTargetState(_target, _observer, _frame, "CN+S", data.time, _pscpos, _pscvel, lightTime); _pscpos[3] += 3; // KM to M } diff --git a/src/scenegraph/spiceephemeris.cpp b/src/scenegraph/spiceephemeris.cpp index 3f7a71e28f..c8634c7c74 100644 --- a/src/scenegraph/spiceephemeris.cpp +++ b/src/scenegraph/spiceephemeris.cpp @@ -75,8 +75,16 @@ void SpiceEphemeris::update(const UpdateData& data) { glm::dvec3 position(0,0,0); double lightTime = 0.0; - SpiceManager::ref().getTargetPosition(_targetName, _originName, "GALACTIC", "CN+S", data.time, position, lightTime); + SpiceManager::ref().getTargetPosition(_targetName, _originName, + "GALACTIC", "NONE", data.time, position, lightTime); + if (_targetName == "NEW HORIZONS"){ + // In order to properly draw the viewfrustrum, the craft might have to be + // positioned using the X-variations of aberration methods (ongoing investigation). + SpiceManager::ref().getTargetPosition(_targetName, _originName, + "GALACTIC", "NONE", data.time, position, lightTime); + } + _position = psc::CreatePowerScaledCoordinate(position.x, position.y, position.z); _position[3] += 3; } diff --git a/src/util/factorymanager.cpp b/src/util/factorymanager.cpp index 650f11c357..416431ade9 100644 --- a/src/util/factorymanager.cpp +++ b/src/util/factorymanager.cpp @@ -29,7 +29,6 @@ // renderables #include #include -#include #include #include @@ -68,8 +67,6 @@ void FactoryManager::initialize() "RenderablePlanet"); _manager->factory()->registerClass( "RenderableStars"); - _manager->factory()->registerClass( - "RenderableEphemeris"); //will replace ephemeris class soon... _manager->factory()->registerClass( "RenderablePath"); diff --git a/src/util/spicemanager.cpp b/src/util/spicemanager.cpp index 35aac55809..d8cb472d09 100644 --- a/src/util/spicemanager.cpp +++ b/src/util/spicemanager.cpp @@ -310,6 +310,72 @@ bool SpiceManager::getTargetPosition(const std::string& target, return true; } +void SpiceManager::frameConversion(glm::dvec3& v, const std::string from, const std::string to, double ephemerisTime) const{ + glm::dmat3 transform; + pxform_c(from.c_str(), to.c_str(), ephemerisTime, (double(*)[3])glm::value_ptr(transform)); + transform = glm::transpose(transform); + + v = transform*v; +} + +bool SpiceManager::getSurfaceIntercept(const std::string& target, + const std::string& observer, + const std::string& fovInstrument, + const std::string& referenceFrame, + const std::string& method, + const std::string& aberrationCorrection, + double ephemerisTime, + double& targetEpoch, + psc& directionVector, + psc& surfaceIntercept, + psc& surfaceVector) const{ + // make pretty latr + double dvec[3], spoint[3], et; + glm::dvec3 srfvec; + int found; + bool convert; + + dvec[0] = directionVector[0]; + dvec[1] = directionVector[1]; + dvec[2] = directionVector[2]; + + // allow client specify non-inertial frame. + std::string bodyfixed = "IAU_"; + convert = (referenceFrame.find(bodyfixed) == std::string::npos); + if (convert){ + bodyfixed += target; + }else{ + bodyfixed = referenceFrame; + } + + sincpt_c(method.c_str(), + target.c_str(), + ephemerisTime, + bodyfixed.c_str(), + aberrationCorrection.c_str(), + observer.c_str(), + fovInstrument.c_str(), + dvec, + spoint, + &et, + glm::value_ptr(srfvec), + &found); + + bool hasError = checkForError("Error retrieving surface intercept on target '" + target + "'" + + "viewed from observer '" + observer + "' in " + + "reference frame '" + bodyfixed + "' at time '" + + std::to_string(ephemerisTime) + "'"); + + if (convert) frameConversion(srfvec, bodyfixed, referenceFrame, ephemerisTime); + + if (!hasError && found){ + directionVector = PowerScaledCoordinate::CreatePowerScaledCoordinate(dvec[0] , dvec[1] , dvec[2] ); + surfaceIntercept = PowerScaledCoordinate::CreatePowerScaledCoordinate(spoint[0], spoint[1], spoint[2]); + surfaceVector = PowerScaledCoordinate::CreatePowerScaledCoordinate(srfvec[0], srfvec[1], srfvec[2]); + } + return found; +} + bool SpiceManager::getTargetState(const std::string& target, const std::string& observer, const std::string& referenceFrame,