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

Naive and simple distance dependent interaction speed. Useful for debugging

Browse Source
This commit is contained in:
Erik Broberg
2016-05-17 18:22:57 -04:00
parent f30a322623
commit ce67314065
5 changed files with 52 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/globebrowsing/geodetics/ellipsoid.cpp
+21 -23
View File
@@ -26,6 +26,7 @@
#define _USE_MATH_DEFINES
#include <math.h>
#include <algorithm>
namespace {
const std::string _loggerCat = "Ellipsoid";
@@ -45,8 +46,7 @@ namespace openspace {
updateInternalCache();
}
Ellipsoid::~Ellipsoid()
{
Ellipsoid::~Ellipsoid(){
}
@@ -58,22 +58,23 @@ namespace openspace {
_cached._oneOverRadiiSquared = Vec3(1) / _cached._radiiSquared;
_cached._radiiToTheFourth = _cached._radiiSquared * _cached._radiiSquared;
_cached._minimumRadius = glm::min(_radii.x, glm::min(_radii.y, _radii.z));
_cached._maximumRadius = glm::max(_radii.x, glm::max(_radii.y, _radii.z));
std::vector<Scalar> radii = { _radii.x, _radii.y, _radii.z };
std::sort(radii.begin(), radii.end());
_cached._minimumRadius = radii[0];
_cached._medianRadius = radii[1];
_cached._maximumRadius = radii[2];
}
Vec3 Ellipsoid::geocentricSurfaceProjection(const Vec3& p) const
{
Vec3 Ellipsoid::geocentricSurfaceProjection(const Vec3& p) const {
Scalar beta = 1.0 / sqrt(dot(p * p, _cached._oneOverRadiiSquared));
return beta * p;
}
Vec3 Ellipsoid::geodeticSurfaceProjection(const Vec3& p) const
{
Vec3 Ellipsoid::geodeticSurfaceProjection(const Vec3& p) const {
Scalar beta = 1.0 / sqrt(dot(p * p, _cached._oneOverRadiiSquared));
Scalar n = glm::length(beta * p * _cached._oneOverRadiiSquared);
Scalar alpha = (1.0 - beta) * (glm::length(p) / n);
@@ -100,14 +101,12 @@ namespace openspace {
return p / d;
}
Vec3 Ellipsoid::geodeticSurfaceNormalForGeocentricallyProjectedPoint(const Vec3& p) const
{
Vec3 Ellipsoid::geodeticSurfaceNormalForGeocentricallyProjectedPoint(const Vec3& p) const {
Vec3 normal = p * _cached._oneOverRadiiSquared;
return glm::normalize(normal);
}
Vec3 Ellipsoid::geodeticSurfaceNormal(Geodetic2 geodetic2) const
{
Vec3 Ellipsoid::geodeticSurfaceNormal(Geodetic2 geodetic2) const {
Scalar cosLat = glm::cos(geodetic2.lat);
//geodetic2.lon = geodetic2.lon > M_PI ? geodetic2.lon - M_PI * 2 : geodetic2.lon;
return Vec3(
@@ -116,31 +115,30 @@ namespace openspace {
sin(geodetic2.lat));
}
Vec3 Ellipsoid::radiiSquared() const
{
Vec3 Ellipsoid::radiiSquared() const {
return _cached._radiiSquared;
}
Vec3 Ellipsoid::oneOverRadiiSquared() const
{
Vec3 Ellipsoid::oneOverRadiiSquared() const {
return _cached._oneOverRadiiSquared;
}
Vec3 Ellipsoid::radiiToTheFourth() const
{
Vec3 Ellipsoid::radiiToTheFourth() const {
return _cached._radiiToTheFourth;
}
Scalar Ellipsoid::minimumRadius() const
{
Scalar Ellipsoid::minimumRadius() const {
return _cached._minimumRadius;
}
Scalar Ellipsoid::maximumRadius() const
{
Scalar Ellipsoid::maximumRadius() const {
return _cached._maximumRadius;
}
Scalar Ellipsoid::averageRadius() const {
return (_radii.x + _radii.y + _radii.z) / 3.0;
}
Geodetic2 Ellipsoid::cartesianToGeodetic2(const Vec3& p) const
{
Vec3 normal = geodeticSurfaceNormalForGeocentricallyProjectedPoint(p);
modules/globebrowsing/geodetics/ellipsoid.h
+2
View File
@@ -82,6 +82,7 @@ public:
Scalar minimumRadius() const;
Scalar maximumRadius() const;
Scalar averageRadius() const;
Geodetic2 cartesianToGeodetic2(const Vec3& p) const;
Vec3 cartesianSurfacePosition(const Geodetic2& geodetic2) const;
@@ -94,6 +95,7 @@ private:
Vec3 _radiiToTheFourth;
Scalar _minimumRadius;
Scalar _maximumRadius;
Scalar _medianRadius;
} _cached;
void updateInternalCache();
modules/globebrowsing/globes/renderableglobe.cpp
+5
View File
@@ -76,6 +76,7 @@ namespace openspace {
doHorizonCulling.setValue(true);
renderSmallChunksFirst.setValue(true);
// Read the radii in to its own dictionary
@@ -83,6 +84,10 @@ namespace openspace {
dictionary.getValue(keyRadii, radii);
_ellipsoid = Ellipsoid(radii);
setBoundingSphere(pss(_ellipsoid.averageRadius(), 1.0));
ghoul::Dictionary texturesDictionary;
dictionary.getValue(keyTextures, texturesDictionary);
modules/globebrowsing/globes/renderableglobe.h
+1
View File
@@ -69,6 +69,7 @@ public:
properties::FloatProperty lodScaleFactor;
properties::BoolProperty initChunkVisible;
properties::BoolProperty renderSmallChunksFirst;
private:
double _time;
src/interaction/interactionhandler.cpp
+23 -10
View File
@@ -245,14 +245,27 @@ void InteractionHandler::orbit(const float &dx, const float &dy, const float &dz
glm::vec3 cameraUp = glm::normalize((glm::inverse(_camera->viewRotationMatrix()) * glm::vec4(_camera->lookUpVector(), 0))).xyz();
glm::vec3 cameraRight = glm::cross(_camera->viewDirection(), cameraUp);
//get "old" focus position
psc camPos = _camera->position();
psc focusPos = _camera->focusPosition();
float distToFocusNodeCenter = (focusPos - camPos).length().lengthf();
float focusNodeBounds = _focusNode ? _focusNode->boundingSphere().lengthf() : 0.f;
float speedFactor = distToFocusNodeCenter - 0.098*focusNodeBounds;
float rotationSpeed = glm::min(0.00001f * speedFactor, 100.0f);
float zoomSpeed = glm::min(0.0000001f * speedFactor, 1.0f);
float rollSpeed = 100.0f;
glm::mat4 transform;
transform = glm::rotate(glm::radians(dx * 100.f), cameraUp) * transform;
transform = glm::rotate(glm::radians(dy * 100.f), cameraRight) * transform;
transform = glm::rotate(glm::radians(dz * 100.f), _camera->viewDirection()) * transform;
transform = glm::rotate(glm::radians(dx * rotationSpeed), cameraUp) * transform;
transform = glm::rotate(glm::radians(dy * rotationSpeed), cameraRight) * transform;
transform = glm::rotate(glm::radians(dz * rollSpeed), _camera->viewDirection()) * transform;
//get "old" focus position
psc focus = _camera->focusPosition();
//// get camera position
//psc relative = _camera->position();
@@ -261,7 +274,7 @@ void InteractionHandler::orbit(const float &dx, const float &dy, const float &dz
psc relative = _camera->unsynchedPosition();
//get relative vector
psc relative_focus_coordinate = relative - focus;
psc relative_focus_coordinate = relative - focusPos;
//rotate relative vector
relative_focus_coordinate = glm::inverse(transform) * relative_focus_coordinate.vec4();
@@ -274,12 +287,12 @@ void InteractionHandler::orbit(const float &dx, const float &dy, const float &dz
//new camera position
relative = origin + relative_focus_coordinate;
float bounds = _focusNode ? _focusNode->boundingSphere().lengthf() : 0.f;
psc target = relative + relative_focus_coordinate * dist;
psc target = relative + relative_focus_coordinate * dist * zoomSpeed;
//don't fly into objects
if ((target - origin).length() < bounds){
target = relative;
if ((target - origin).length() < focusNodeBounds){
//target = relative;
}
unlockControls();