2002-11-03 13:33:30 -07:00
|
|
|
/***************************************************************************
|
|
|
|
url.cpp - description
|
|
|
|
-------------------
|
|
|
|
begin : Wed Aug 7 2002
|
|
|
|
copyright : (C) 2002 by chris
|
|
|
|
email : chris@tux.teyssier.org
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
* *
|
|
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
|
|
* it under the terms of the GNU General Public License as published by *
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
|
|
* (at your option) any later version. *
|
|
|
|
* *
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
|
|
#include <string>
|
2008-11-16 03:19:38 -07:00
|
|
|
#include <cstring>
|
2008-02-20 19:25:48 -07:00
|
|
|
#include <cstdio>
|
|
|
|
#include <cassert>
|
2008-05-05 13:09:31 -06:00
|
|
|
#include <sstream>
|
2002-11-03 13:33:30 -07:00
|
|
|
#include "celestiacore.h"
|
2008-11-16 03:19:38 -07:00
|
|
|
#include "celutil/util.h"
|
2002-11-03 13:33:30 -07:00
|
|
|
#include "celengine/astro.h"
|
|
|
|
#include "url.h"
|
|
|
|
|
2008-05-05 13:09:31 -06:00
|
|
|
using namespace std;
|
|
|
|
|
|
|
|
const unsigned int Url::CurrentVersion = 3;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static string getSelectionName(const Selection& sel, CelestiaCore* appCore);
|
|
|
|
|
|
|
|
|
|
|
|
CelestiaState::CelestiaState() :
|
|
|
|
coordSys(ObserverFrame::Universal),
|
|
|
|
observerPosition(0.0, 0.0, 0.0),
|
|
|
|
observerOrientation(1.0f),
|
|
|
|
fieldOfView(45.0f),
|
|
|
|
tdb(0.0),
|
|
|
|
timeScale(1.0f),
|
|
|
|
pauseState(false),
|
|
|
|
lightTimeDelay(false),
|
|
|
|
labelMode(0),
|
|
|
|
renderFlags(0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
CelestiaState::captureState(CelestiaCore* appCore)
|
|
|
|
{
|
|
|
|
Simulation *sim = appCore->getSimulation();
|
|
|
|
Renderer *renderer = appCore->getRenderer();
|
|
|
|
|
|
|
|
const ObserverFrame* frame = sim->getFrame();
|
|
|
|
|
|
|
|
coordSys = frame->getCoordinateSystem();
|
|
|
|
if (coordSys != ObserverFrame::Universal)
|
|
|
|
{
|
|
|
|
refBodyName = getSelectionName(frame->getRefObject(), appCore);
|
|
|
|
if (coordSys == ObserverFrame::PhaseLock)
|
|
|
|
{
|
|
|
|
targetBodyName = getSelectionName(frame->getTargetObject(), appCore);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tdb = sim->getTime();
|
|
|
|
|
|
|
|
// Store the position and orientation of the observer in the current
|
|
|
|
// frame.
|
|
|
|
observerPosition = sim->getObserver().getPosition();
|
|
|
|
observerPosition = frame->convertFromUniversal(observerPosition, tdb);
|
|
|
|
|
|
|
|
Quatd q = sim->getObserver().getOrientation();
|
|
|
|
q = frame->convertFromUniversal(q, tdb);
|
|
|
|
observerOrientation = Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z);
|
|
|
|
|
|
|
|
Selection tracked = sim->getTrackedObject();
|
|
|
|
trackedBodyName = getSelectionName(tracked, appCore);
|
|
|
|
Selection selected = sim->getSelection();
|
|
|
|
selectedBodyName = getSelectionName(selected, appCore);
|
|
|
|
fieldOfView = radToDeg(sim->getActiveObserver()->getFOV());
|
|
|
|
timeScale = (float) sim->getTimeScale();
|
|
|
|
pauseState = sim->getPauseState();
|
|
|
|
lightTimeDelay = appCore->getLightDelayActive();
|
|
|
|
renderFlags = renderer->getRenderFlags();
|
|
|
|
labelMode = renderer->getLabelMode();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
bool CelestiaState::loadState(std::map<std::string, std::string> params)
|
|
|
|
{
|
|
|
|
sscanf(timeString.c_str(), "%d-%d-%dT%d:%d:%lf",
|
|
|
|
&date.year, &date.month, &date.day,
|
|
|
|
&date.hour, &date.minute, &date.seconds);
|
|
|
|
|
|
|
|
observerPosition = UniversalCoord(BigFix(params["x"]),
|
|
|
|
BigFix(params["y"]),
|
|
|
|
BigFix(params["z"]));
|
|
|
|
|
|
|
|
float ow = 0.0f;
|
|
|
|
float ox = 0.0f;
|
|
|
|
float oy = 0.0f;
|
|
|
|
float oz = 0.0f;
|
|
|
|
if (sscanf(params["ow"].c_str(), "%f", &ow) != 1 ||
|
|
|
|
sscanf(params["ox"].c_str(), "%f", &ox) != 1 ||
|
|
|
|
sscanf(params["oy"].c_str(), "%f", &oy) != 1 ||
|
|
|
|
sscanf(params["oz"].c_str(), "%f", &oz) != 1)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
orientation = Quatf(ow, ox, oy, oz);
|
|
|
|
|
|
|
|
if (params["select"] != "")
|
|
|
|
selectedBodyName = params["select"];
|
|
|
|
if (params["track"] != "")
|
|
|
|
trackedBodyName = params["track"];
|
|
|
|
if (params["ltd"] != "")
|
|
|
|
lightTimeDelay = (strcmp(params["ltd"].c_str(), "1") == 0);
|
|
|
|
else
|
|
|
|
lightTimeDelay = false;
|
|
|
|
|
|
|
|
if (params["fov"] != "")
|
|
|
|
{
|
|
|
|
if (sscanf(params["fov"].c_str(), "%f", &fieldOfView) != 1.0f)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (params["ts"] != "")
|
|
|
|
{
|
|
|
|
if (sscanf(params["ts"].c_str(), "%f", &timeScale) != 1.0f)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int paused = 0;
|
|
|
|
if (params["p"] != "")
|
|
|
|
{
|
|
|
|
if (sscanf(params["p"].c_str(), "%d", &paused) != 1)
|
|
|
|
return false;
|
|
|
|
if (paused != 0 && paused != 1)
|
|
|
|
return false;
|
|
|
|
pauseState = paused == 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Render settings
|
|
|
|
if (params["rf"] != "")
|
|
|
|
{
|
|
|
|
if (sscanf(params["rf"].c_str(), "%d", &renderFlags) != 1)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (params["lm"] != "")
|
|
|
|
{
|
|
|
|
if (sscanf(params["lm"].c_str(), "%d", &labelMode) != 1)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
2005-07-19 15:31:04 -06:00
|
|
|
Url::Url()
|
2003-01-23 15:46:46 -07:00
|
|
|
{};
|
2002-11-07 22:28:42 -07:00
|
|
|
|
2007-11-03 03:49:29 -06:00
|
|
|
Url::Url(const std::string& str, CelestiaCore *core):
|
|
|
|
urlStr(str),
|
|
|
|
appCore(core),
|
2008-05-05 13:09:31 -06:00
|
|
|
pauseState(false),
|
|
|
|
timeSource(UseUrlTime),
|
|
|
|
version(2)
|
2002-11-07 22:28:42 -07:00
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
std::string::size_type pos, endPrevious;
|
|
|
|
std::vector<Selection> bodies;
|
|
|
|
Simulation *sim = appCore->getSimulation();
|
|
|
|
std::map<std::string, std::string> params = parseUrlParams(urlStr);
|
|
|
|
|
2002-11-07 22:28:42 -07:00
|
|
|
if (urlStr.substr(0, 6) != "cel://")
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
urlStr = "";
|
|
|
|
return;
|
|
|
|
}
|
2008-05-05 13:09:31 -06:00
|
|
|
|
|
|
|
// Version labelling of cel URLs was only added in Celestia 1.5, cel URL
|
|
|
|
// version 2. Assume any URL without a version is version 1.
|
|
|
|
if (params["ver"] != "")
|
|
|
|
{
|
|
|
|
sscanf(params["ver"].c_str(), "%u", &version);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
version = 1;
|
|
|
|
}
|
2004-02-09 14:06:41 -07:00
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
pos = urlStr.find("/", 6);
|
2008-05-05 13:09:31 -06:00
|
|
|
if (pos == std::string::npos)
|
|
|
|
pos = urlStr.find("?", 6);
|
2002-11-03 13:33:30 -07:00
|
|
|
|
2008-05-05 13:09:31 -06:00
|
|
|
if (pos == std::string::npos)
|
|
|
|
modeStr = urlStr.substr(6);
|
|
|
|
else
|
|
|
|
modeStr = decode_string(urlStr.substr(6, pos - 6));
|
2002-11-03 13:33:30 -07:00
|
|
|
|
2004-02-11 15:25:42 -07:00
|
|
|
if (!compareIgnoringCase(modeStr, std::string("Freeflight")))
|
2002-11-07 22:28:42 -07:00
|
|
|
{
|
2008-02-08 14:46:02 -07:00
|
|
|
mode = ObserverFrame::Universal;
|
2002-11-03 13:33:30 -07:00
|
|
|
nbBodies = 0;
|
|
|
|
}
|
2004-02-11 15:25:42 -07:00
|
|
|
else if (!compareIgnoringCase(modeStr, std::string("Follow")))
|
2002-11-07 22:28:42 -07:00
|
|
|
{
|
2008-02-08 14:46:02 -07:00
|
|
|
mode = ObserverFrame::Ecliptical;
|
2002-11-03 13:33:30 -07:00
|
|
|
nbBodies = 1;
|
|
|
|
}
|
2004-02-11 15:25:42 -07:00
|
|
|
else if (!compareIgnoringCase(modeStr, std::string("SyncOrbit")))
|
2002-11-07 22:28:42 -07:00
|
|
|
{
|
2008-02-08 14:46:02 -07:00
|
|
|
mode = ObserverFrame::BodyFixed;
|
2002-11-03 13:33:30 -07:00
|
|
|
nbBodies = 1;
|
|
|
|
}
|
2004-02-11 15:25:42 -07:00
|
|
|
else if (!compareIgnoringCase(modeStr, std::string("Chase")))
|
2002-11-07 22:28:42 -07:00
|
|
|
{
|
2008-02-08 14:46:02 -07:00
|
|
|
mode = ObserverFrame::Chase;
|
2002-11-03 13:33:30 -07:00
|
|
|
nbBodies = 1;
|
|
|
|
}
|
2004-02-11 15:25:42 -07:00
|
|
|
else if (!compareIgnoringCase(modeStr, std::string("PhaseLock")))
|
2002-11-07 22:28:42 -07:00
|
|
|
{
|
2008-02-08 14:46:02 -07:00
|
|
|
mode = ObserverFrame::PhaseLock;
|
2002-11-03 13:33:30 -07:00
|
|
|
nbBodies = 2;
|
|
|
|
}
|
2004-02-11 15:25:42 -07:00
|
|
|
else if (!compareIgnoringCase(modeStr, std::string("Settings")))
|
2003-05-31 11:40:19 -06:00
|
|
|
{
|
|
|
|
type = Settings;
|
|
|
|
nbBodies = 0;
|
|
|
|
}
|
2008-05-05 13:09:31 -06:00
|
|
|
|
2002-11-07 22:28:42 -07:00
|
|
|
if (nbBodies == -1)
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
urlStr = "";
|
|
|
|
return; // Mode not recognized
|
|
|
|
}
|
2008-05-05 13:09:31 -06:00
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
endPrevious = pos;
|
|
|
|
int nb = nbBodies, i=1;
|
2002-12-09 14:24:12 -07:00
|
|
|
while (nb != 0 && endPrevious != std::string::npos) {
|
2002-11-03 13:33:30 -07:00
|
|
|
std::string bodyName="";
|
|
|
|
pos = urlStr.find("/", endPrevious + 1);
|
|
|
|
if (pos == std::string::npos) pos = urlStr.find("?", endPrevious + 1);
|
|
|
|
if (pos == std::string::npos) bodyName = urlStr.substr(endPrevious + 1);
|
|
|
|
else bodyName = urlStr.substr(endPrevious + 1, pos - endPrevious - 1);
|
|
|
|
endPrevious = pos;
|
2008-05-05 13:09:31 -06:00
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
bodyName = decode_string(bodyName);
|
|
|
|
pos = 0;
|
|
|
|
if (i==1) body1 = bodyName;
|
|
|
|
if (i==2) body2 = bodyName;
|
|
|
|
while(pos != std::string::npos) {
|
|
|
|
pos = bodyName.find(":", pos + 1);
|
|
|
|
if (pos != std::string::npos) bodyName[pos]='/';
|
|
|
|
}
|
2008-05-05 13:09:31 -06:00
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
bodies.push_back(sim->findObjectFromPath(bodyName));
|
2008-05-05 13:09:31 -06:00
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
nb--;
|
|
|
|
i++;
|
|
|
|
}
|
2008-05-05 13:09:31 -06:00
|
|
|
|
2002-12-09 14:24:12 -07:00
|
|
|
if (nb != 0) {
|
2002-11-03 13:33:30 -07:00
|
|
|
urlStr = "";
|
|
|
|
return; // Number of bodies in Url doesn't match Mode
|
|
|
|
}
|
2008-05-05 13:09:31 -06:00
|
|
|
|
2008-02-08 14:46:02 -07:00
|
|
|
if (nbBodies == 0) ref = ObserverFrame();
|
|
|
|
if (nbBodies == 1) ref = ObserverFrame(mode, bodies[0]);
|
|
|
|
if (nbBodies == 2) ref = ObserverFrame(mode, bodies[0], bodies[1]);
|
2002-11-03 13:33:30 -07:00
|
|
|
fromString = true;
|
2008-05-05 13:09:31 -06:00
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
std::string time="";
|
|
|
|
pos = urlStr.find("?", endPrevious + 1);
|
2008-05-05 13:09:31 -06:00
|
|
|
if (pos == std::string::npos)
|
|
|
|
time = urlStr.substr(endPrevious + 1);
|
2002-11-03 13:33:30 -07:00
|
|
|
else time = urlStr.substr(endPrevious + 1, pos - endPrevious -1);
|
2008-05-05 13:09:31 -06:00
|
|
|
time = decode_string(time);
|
|
|
|
|
|
|
|
switch (version)
|
2003-05-31 11:40:19 -06:00
|
|
|
{
|
2008-05-05 13:09:31 -06:00
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
initVersion2(params, time);
|
2003-05-31 11:40:19 -06:00
|
|
|
break;
|
2008-05-05 13:09:31 -06:00
|
|
|
case 3:
|
|
|
|
initVersion3(params, time);
|
2003-01-23 15:46:46 -07:00
|
|
|
break;
|
2008-05-05 13:09:31 -06:00
|
|
|
default:
|
|
|
|
urlStr = "";
|
|
|
|
return;
|
2002-11-03 13:33:30 -07:00
|
|
|
}
|
|
|
|
|
2003-01-23 15:46:46 -07:00
|
|
|
evalName();
|
2002-11-03 13:33:30 -07:00
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
2005-11-18 02:00:39 -07:00
|
|
|
Url::Url(CelestiaCore* core, UrlType type)
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
appCore = core;
|
2008-05-05 13:09:31 -06:00
|
|
|
version = 2;
|
|
|
|
timeSource = UseUrlTime;
|
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
Simulation *sim = appCore->getSimulation();
|
|
|
|
Renderer *renderer = appCore->getRenderer();
|
2003-05-06 16:13:33 -06:00
|
|
|
|
2003-01-23 15:46:46 -07:00
|
|
|
this->type = type;
|
2002-11-03 13:33:30 -07:00
|
|
|
|
2008-02-08 14:46:02 -07:00
|
|
|
modeStr = getCoordSysName(sim->getFrame()->getCoordinateSystem());
|
2003-05-31 11:40:19 -06:00
|
|
|
if (type == Settings) modeStr = "Settings";
|
2008-02-08 14:46:02 -07:00
|
|
|
ref = *sim->getFrame();
|
2002-11-03 13:33:30 -07:00
|
|
|
urlStr += "cel://" + modeStr;
|
2008-02-08 14:46:02 -07:00
|
|
|
if (type != Settings && sim->getFrame()->getCoordinateSystem() != ObserverFrame::Universal) {
|
|
|
|
body1 = getSelectionName(sim->getFrame()->getRefObject());
|
2002-11-03 13:33:30 -07:00
|
|
|
urlStr += "/" + body1;
|
2008-02-08 14:46:02 -07:00
|
|
|
if (sim->getFrame()->getCoordinateSystem() == ObserverFrame::PhaseLock) {
|
|
|
|
body2 = getSelectionName(sim->getFrame()->getTargetObject());
|
2002-11-03 13:33:30 -07:00
|
|
|
urlStr += "/" + body2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-05 13:09:31 -06:00
|
|
|
double simTime = sim->getTime();
|
|
|
|
|
2006-10-11 14:44:17 -06:00
|
|
|
char date_str[50];
|
2008-05-05 13:09:31 -06:00
|
|
|
date = astro::Date(simTime);
|
2002-11-03 13:33:30 -07:00
|
|
|
char buff[255];
|
2003-05-06 16:13:33 -06:00
|
|
|
|
2003-01-23 15:46:46 -07:00
|
|
|
switch (type) {
|
2003-05-06 16:13:33 -06:00
|
|
|
case Absolute:
|
2006-10-11 14:44:17 -06:00
|
|
|
snprintf(date_str, sizeof(date_str), "%04d-%02d-%02dT%02d:%02d:%08.5f",
|
2003-01-23 15:46:46 -07:00
|
|
|
date.year, date.month, date.day, date.hour, date.minute, date.seconds);
|
|
|
|
|
|
|
|
coord = sim->getObserver().getPosition();
|
|
|
|
urlStr += std::string("/") + date_str + "?x=" + coord.x.toString();
|
|
|
|
urlStr += "&y=" + coord.y.toString();
|
|
|
|
urlStr += "&z=" + coord.z.toString();
|
2003-05-06 16:13:33 -06:00
|
|
|
|
2008-02-08 14:46:02 -07:00
|
|
|
orientation = sim->getObserver().getOrientationf();
|
2003-01-23 15:46:46 -07:00
|
|
|
sprintf(buff, "&ow=%f&ox=%f&oy=%f&oz=%f", orientation.w, orientation.x, orientation.y, orientation.z);
|
|
|
|
urlStr += buff;
|
|
|
|
break;
|
2003-05-06 16:13:33 -06:00
|
|
|
case Relative:
|
2003-01-23 15:46:46 -07:00
|
|
|
sim->getSelectionLongLat(distance, longitude, latitude);
|
|
|
|
sprintf(buff, "dist=%f&long=%f&lat=%f", distance, longitude, latitude);
|
|
|
|
urlStr += std::string("/?") + buff;
|
|
|
|
break;
|
2003-05-31 11:40:19 -06:00
|
|
|
case Settings:
|
|
|
|
urlStr += std::string("/?");
|
|
|
|
break;
|
2003-01-23 15:46:46 -07:00
|
|
|
}
|
2003-05-06 16:13:33 -06:00
|
|
|
|
2003-05-31 11:40:19 -06:00
|
|
|
switch (type) {
|
|
|
|
case Absolute: // Intentional Fall-Through
|
|
|
|
case Relative:
|
|
|
|
tracked = sim->getTrackedObject();
|
|
|
|
trackedStr = getSelectionName(tracked);
|
|
|
|
if (trackedStr != "") urlStr += "&track=" + trackedStr;
|
|
|
|
|
|
|
|
selected = sim->getSelection();
|
|
|
|
selectedStr = getSelectionName(selected);
|
|
|
|
if (selectedStr != "") urlStr += "&select=" + selectedStr;
|
|
|
|
|
|
|
|
fieldOfView = radToDeg(sim->getActiveObserver()->getFOV());
|
2007-01-11 12:30:04 -07:00
|
|
|
timeScale = (float) sim->getTimeScale();
|
2007-11-03 03:49:29 -06:00
|
|
|
pauseState = sim->getPauseState();
|
2003-05-31 11:40:19 -06:00
|
|
|
lightTimeDelay = appCore->getLightDelayActive();
|
2007-11-03 03:49:29 -06:00
|
|
|
sprintf(buff, "&fov=%f&ts=%f<d=%c&p=%c&", fieldOfView,
|
|
|
|
timeScale, lightTimeDelay?'1':'0', pauseState?'1':'0');
|
2003-05-31 11:40:19 -06:00
|
|
|
urlStr += buff;
|
2003-05-31 11:52:31 -06:00
|
|
|
case Settings: // Intentional Fall-Through
|
2003-05-31 11:40:19 -06:00
|
|
|
renderFlags = renderer->getRenderFlags();
|
|
|
|
labelMode = renderer->getLabelMode();
|
|
|
|
sprintf(buff, "rf=%d&lm=%d", renderFlags, labelMode);
|
|
|
|
urlStr += buff;
|
|
|
|
break;
|
|
|
|
}
|
2002-11-03 13:33:30 -07:00
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
// Append the Celestia URL version
|
|
|
|
{
|
|
|
|
char buf[32];
|
2008-05-05 13:09:31 -06:00
|
|
|
sprintf(buf, "&ver=%u", version);
|
2007-01-11 12:30:04 -07:00
|
|
|
urlStr += buf;
|
|
|
|
}
|
|
|
|
|
2003-01-23 15:46:46 -07:00
|
|
|
evalName();
|
2002-11-03 13:33:30 -07:00
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
2008-05-05 13:09:31 -06:00
|
|
|
/*! Construct a new cel URL from a saved CelestiaState object. This method may
|
|
|
|
* may only be called to create a version 3 or later url.
|
|
|
|
*/
|
|
|
|
Url::Url(const CelestiaState& appState, unsigned int _version, TimeSource _timeSource)
|
|
|
|
{
|
|
|
|
ostringstream u;
|
|
|
|
|
|
|
|
appCore = NULL;
|
|
|
|
|
|
|
|
assert(_version >= 3);
|
|
|
|
version = _version;
|
|
|
|
timeSource = _timeSource;
|
|
|
|
type = Absolute;
|
|
|
|
|
|
|
|
modeStr = getCoordSysName(appState.coordSys);
|
|
|
|
body1 = appState.refBodyName;
|
|
|
|
body2 = appState.targetBodyName;
|
|
|
|
selectedStr = appState.selectedBodyName;
|
|
|
|
trackedStr = appState.trackedBodyName;
|
|
|
|
|
|
|
|
coord = appState.observerPosition;
|
|
|
|
orientation = appState.observerOrientation;
|
|
|
|
|
|
|
|
//ref =
|
|
|
|
//selected =
|
|
|
|
//tracked =
|
|
|
|
nbBodies = 1;
|
|
|
|
if (appState.coordSys == ObserverFrame::Universal)
|
|
|
|
nbBodies = 0;
|
|
|
|
else if (appState.coordSys == ObserverFrame::PhaseLock)
|
|
|
|
nbBodies = 2;
|
|
|
|
|
|
|
|
fieldOfView = appState.fieldOfView;
|
|
|
|
renderFlags = appState.renderFlags;
|
|
|
|
labelMode = appState.labelMode;
|
|
|
|
|
|
|
|
date = astro::Date(appState.tdb);
|
|
|
|
timeScale = appState.timeScale;
|
|
|
|
pauseState = appState.pauseState;
|
|
|
|
lightTimeDelay = appState.lightTimeDelay;
|
|
|
|
|
|
|
|
u << "cel://" << modeStr;
|
|
|
|
|
|
|
|
if (appState.coordSys != ObserverFrame::Universal)
|
|
|
|
{
|
|
|
|
u << "/" << appState.refBodyName;
|
|
|
|
if (appState.coordSys == ObserverFrame::PhaseLock)
|
|
|
|
{
|
|
|
|
u << "/" << appState.targetBodyName;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
char date_str[50];
|
|
|
|
snprintf(date_str, sizeof(date_str), "%04d-%02d-%02dT%02d:%02d:%08.5f",
|
|
|
|
date.year, date.month, date.day, date.hour, date.minute, date.seconds);
|
|
|
|
u << "/" << date_str;
|
|
|
|
|
|
|
|
// observer position
|
|
|
|
u << "?x=" << coord.x.toString() << "&y=" << coord.y.toString() << "&z=" << coord.z.toString();
|
|
|
|
|
|
|
|
// observer orientation
|
|
|
|
u << "&ow=" << orientation.w
|
|
|
|
<< "&ox=" << orientation.x
|
|
|
|
<< "&oy=" << orientation.y
|
|
|
|
<< "&oz=" << orientation.z;
|
|
|
|
|
|
|
|
if (trackedStr != "")
|
|
|
|
u << "&track=" << trackedStr;
|
|
|
|
if (selectedStr != "")
|
|
|
|
u << "&select=" << selectedStr;
|
|
|
|
|
|
|
|
u << "&fov=" << fieldOfView;
|
|
|
|
u << "&ts=" << timeScale;
|
|
|
|
u << "<d=" << (lightTimeDelay ? 1 : 0);
|
|
|
|
u << "&p=" << (pauseState ? 1 : 0);
|
|
|
|
|
|
|
|
u << "&rf=" << renderFlags;
|
|
|
|
u << "&lm=" << labelMode;
|
|
|
|
|
|
|
|
// Append the url settings: time source and version
|
|
|
|
u << "&tsrc=" << (int) timeSource;
|
|
|
|
u << "&ver=" << version;
|
|
|
|
|
|
|
|
urlStr = u.str();
|
|
|
|
|
|
|
|
evalName();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Url::initVersion2(std::map<std::string, std::string>& params,
|
|
|
|
const std::string& timeString)
|
|
|
|
{
|
|
|
|
if (type != Settings)
|
|
|
|
{
|
|
|
|
if (params["dist"] != "")
|
|
|
|
type = Relative;
|
|
|
|
else
|
|
|
|
type = Absolute;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case Absolute:
|
|
|
|
date = astro::Date(0.0);
|
|
|
|
sscanf(timeString.c_str(), "%d-%d-%dT%d:%d:%lf",
|
|
|
|
&date.year, &date.month, &date.day,
|
|
|
|
&date.hour, &date.minute, &date.seconds);
|
|
|
|
|
|
|
|
coord = UniversalCoord(BigFix(params["x"]),
|
|
|
|
BigFix(params["y"]),
|
|
|
|
BigFix(params["z"]));
|
|
|
|
|
|
|
|
float ow, ox, oy, oz;
|
|
|
|
sscanf(params["ow"].c_str(), "%f", &ow);
|
|
|
|
sscanf(params["ox"].c_str(), "%f", &ox);
|
|
|
|
sscanf(params["oy"].c_str(), "%f", &oy);
|
|
|
|
sscanf(params["oz"].c_str(), "%f", &oz);
|
|
|
|
|
|
|
|
orientation = Quatf(ow, ox, oy, oz);
|
|
|
|
|
|
|
|
// Intentional Fall-Through
|
|
|
|
case Relative:
|
|
|
|
if (params["dist"] != "") {
|
|
|
|
sscanf(params["dist"].c_str(), "%lf", &distance);
|
|
|
|
}
|
|
|
|
if (params["long"] != "") {
|
|
|
|
sscanf(params["long"].c_str(), "%lf", &longitude);
|
|
|
|
}
|
|
|
|
if (params["lat"] != "") {
|
|
|
|
sscanf(params["lat"].c_str(), "%lf", &latitude);
|
|
|
|
}
|
|
|
|
if (params["select"] != "") {
|
|
|
|
selectedStr = params["select"];
|
|
|
|
}
|
|
|
|
if (params["track"] != "") {
|
|
|
|
trackedStr = params["track"];
|
|
|
|
}
|
|
|
|
if (params["ltd"] != "") {
|
|
|
|
lightTimeDelay = (strcmp(params["ltd"].c_str(), "1") == 0);
|
|
|
|
} else {
|
|
|
|
lightTimeDelay = false;
|
|
|
|
}
|
|
|
|
if (params["fov"] != "") {
|
|
|
|
sscanf(params["fov"].c_str(), "%f", &fieldOfView);
|
|
|
|
}
|
|
|
|
if (params["ts"] != "") {
|
|
|
|
sscanf(params["ts"].c_str(), "%f", &timeScale);
|
|
|
|
}
|
|
|
|
if (params["p"] != "") {
|
|
|
|
int pauseInt = 0;
|
|
|
|
sscanf(params["p"].c_str(), "%d", &pauseInt);
|
|
|
|
pauseState = pauseInt == 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Settings:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (params["rf"] != "") {
|
|
|
|
sscanf(params["rf"].c_str(), "%d", &renderFlags);
|
|
|
|
}
|
|
|
|
if (params["lm"] != "") {
|
|
|
|
sscanf(params["lm"].c_str(), "%d", &labelMode);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Url::initVersion3(std::map<std::string, std::string>& params,
|
|
|
|
const std::string& timeString)
|
|
|
|
{
|
|
|
|
// Type field not used for version 3 urls; position is always relative
|
|
|
|
// to the frame center. Time setting is controlled by the time source.
|
|
|
|
type = Absolute;
|
|
|
|
|
|
|
|
date = astro::Date(0.0);
|
|
|
|
sscanf(timeString.c_str(), "%d-%d-%dT%d:%d:%lf",
|
|
|
|
&date.year, &date.month, &date.day,
|
|
|
|
&date.hour, &date.minute, &date.seconds);
|
|
|
|
|
|
|
|
coord = UniversalCoord(BigFix(params["x"]),
|
|
|
|
BigFix(params["y"]),
|
|
|
|
BigFix(params["z"]));
|
|
|
|
|
|
|
|
float ow, ox, oy, oz;
|
|
|
|
sscanf(params["ow"].c_str(), "%f", &ow);
|
|
|
|
sscanf(params["ox"].c_str(), "%f", &ox);
|
|
|
|
sscanf(params["oy"].c_str(), "%f", &oy);
|
|
|
|
sscanf(params["oz"].c_str(), "%f", &oz);
|
|
|
|
|
|
|
|
orientation = Quatf(ow, ox, oy, oz);
|
|
|
|
|
|
|
|
if (params["select"] != "")
|
|
|
|
selectedStr = params["select"];
|
|
|
|
if (params["track"] != "")
|
|
|
|
trackedStr = params["track"];
|
|
|
|
if (params["ltd"] != "")
|
|
|
|
lightTimeDelay = (strcmp(params["ltd"].c_str(), "1") == 0);
|
|
|
|
else
|
|
|
|
lightTimeDelay = false;
|
|
|
|
|
|
|
|
if (params["fov"] != "")
|
|
|
|
sscanf(params["fov"].c_str(), "%f", &fieldOfView);
|
|
|
|
if (params["ts"] != "")
|
|
|
|
sscanf(params["ts"].c_str(), "%f", &timeScale);
|
|
|
|
|
|
|
|
int paused = 0;
|
|
|
|
if (params["p"] != "")
|
|
|
|
sscanf(params["p"].c_str(), "%d", &paused);
|
|
|
|
pauseState = paused == 1;
|
|
|
|
|
|
|
|
// Render settings
|
|
|
|
if (params["rf"] != "")
|
|
|
|
sscanf(params["rf"].c_str(), "%d", &renderFlags);
|
|
|
|
if (params["lm"] != "")
|
|
|
|
sscanf(params["lm"].c_str(), "%d", &labelMode);
|
|
|
|
|
|
|
|
int timeSourceInt = 0;
|
|
|
|
if (params["tsrc"] != "")
|
|
|
|
sscanf(params["tsrc"].c_str(), "%d", &timeSourceInt);
|
|
|
|
if (timeSourceInt >= 0 && timeSourceInt < TimeSourceCount)
|
|
|
|
timeSource = (TimeSource) timeSourceInt;
|
|
|
|
else
|
|
|
|
timeSource = UseUrlTime;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
std::string Url::getAsString() const
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
return urlStr;
|
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
|
|
|
std::string Url::getName() const
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
|
|
|
void Url::evalName()
|
|
|
|
{
|
2003-05-31 11:40:19 -06:00
|
|
|
char buff[50];
|
|
|
|
double lo = longitude, la = latitude;
|
|
|
|
char los = 'E';
|
|
|
|
char las = 'N';
|
2003-01-23 15:46:46 -07:00
|
|
|
switch(type) {
|
|
|
|
case Absolute:
|
2005-07-19 15:31:04 -06:00
|
|
|
name = _(modeStr.c_str());
|
|
|
|
if (body1 != "") name += " " + std::string(_(getBodyShortName(body1).c_str()));
|
|
|
|
if (body2 != "") name += " " + std::string(_(getBodyShortName(body2).c_str()));
|
|
|
|
if (trackedStr != "") name += " -> " + std::string(_(getBodyShortName(trackedStr).c_str()));
|
|
|
|
if (selectedStr != "") name += " [" + std::string(_(getBodyShortName(selectedStr).c_str())) + "]";
|
2003-01-23 15:46:46 -07:00
|
|
|
break;
|
|
|
|
case Relative:
|
2005-07-19 15:31:04 -06:00
|
|
|
if (selectedStr != "") name = std::string(_(getBodyShortName(selectedStr).c_str())) + " ";
|
2003-01-23 15:46:46 -07:00
|
|
|
if (lo < 0) { lo = -lo; los = 'W'; }
|
|
|
|
if (la < 0) { la = -la; las = 'S'; }
|
2003-05-06 16:13:33 -06:00
|
|
|
sprintf(buff, "(%.1lf%c, %.1lf%c)", lo, los, la, las);
|
2003-01-23 15:46:46 -07:00
|
|
|
name += buff;
|
|
|
|
break;
|
2003-05-31 11:40:19 -06:00
|
|
|
case Settings:
|
2005-07-19 15:31:04 -06:00
|
|
|
name = _("Settings");
|
2003-05-31 11:40:19 -06:00
|
|
|
break;
|
2003-01-23 15:46:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
|
|
|
std::string Url::getBodyShortName(const std::string& body) const
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
std::string::size_type pos;
|
|
|
|
if (body != "") {
|
|
|
|
pos = body.rfind(":");
|
|
|
|
if (pos != std::string::npos) return body.substr(pos+1);
|
|
|
|
else return body;
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
|
|
|
std::map<std::string, std::string> Url::parseUrlParams(const std::string& url) const
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
std::string::size_type pos, startName, startValue;
|
|
|
|
std::map<std::string, std::string> params;
|
|
|
|
|
|
|
|
pos = url.find("?");
|
|
|
|
while (pos != std::string::npos) {
|
|
|
|
startName = pos + 1;
|
|
|
|
startValue = url.find("=", startName);
|
|
|
|
pos = url.find("&", pos + 1);
|
|
|
|
if (startValue != std::string::npos) {
|
|
|
|
startValue++;
|
|
|
|
if (pos != std::string::npos)
|
|
|
|
params[url.substr(startName, startValue - startName -1)] = decode_string(url.substr(startValue, pos - startValue));
|
|
|
|
else
|
|
|
|
params[url.substr(startName, startValue - startName -1)] = decode_string(url.substr(startValue));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return params;
|
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
2008-02-08 14:46:02 -07:00
|
|
|
std::string Url::getCoordSysName(ObserverFrame::CoordinateSystem mode) const
|
2002-11-07 22:28:42 -07:00
|
|
|
{
|
|
|
|
switch (mode)
|
|
|
|
{
|
2008-02-08 14:46:02 -07:00
|
|
|
case ObserverFrame::Universal:
|
2002-11-03 13:33:30 -07:00
|
|
|
return "Freeflight";
|
2008-02-08 14:46:02 -07:00
|
|
|
case ObserverFrame::Ecliptical:
|
2002-11-07 22:28:42 -07:00
|
|
|
return "Follow";
|
2008-02-08 14:46:02 -07:00
|
|
|
case ObserverFrame::BodyFixed:
|
2002-11-03 13:33:30 -07:00
|
|
|
return "SyncOrbit";
|
2008-02-08 14:46:02 -07:00
|
|
|
case ObserverFrame::Chase:
|
2002-11-03 13:33:30 -07:00
|
|
|
return "Chase";
|
2008-02-08 14:46:02 -07:00
|
|
|
case ObserverFrame::PhaseLock:
|
2002-11-03 13:33:30 -07:00
|
|
|
return "PhaseLock";
|
2008-02-08 14:46:02 -07:00
|
|
|
case ObserverFrame::Equatorial:
|
2002-12-13 12:39:18 -07:00
|
|
|
return "Unknown";
|
2008-02-08 14:46:02 -07:00
|
|
|
case ObserverFrame::ObserverLocal:
|
2002-12-13 12:39:18 -07:00
|
|
|
return "Unknown";
|
2008-05-05 13:09:31 -06:00
|
|
|
default:
|
|
|
|
return "Unknown";
|
2002-11-03 13:33:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-22 21:52:03 -06:00
|
|
|
static std::string getBodyName(Universe* universe, Body* body)
|
|
|
|
{
|
|
|
|
std::string name = body->getName();
|
|
|
|
PlanetarySystem* parentSystem = body->getSystem();
|
2007-11-03 08:54:42 -06:00
|
|
|
const Body* parentBody = NULL;
|
2007-10-22 21:52:03 -06:00
|
|
|
|
|
|
|
if (parentSystem != NULL)
|
|
|
|
parentBody = parentSystem->getPrimaryBody();
|
2007-11-03 08:54:42 -06:00
|
|
|
else
|
2008-02-20 19:25:48 -07:00
|
|
|
assert(0);
|
|
|
|
// TODO: Figure out why the line below was added.
|
|
|
|
//parentBody = body->getOrbitBarycenter();
|
2007-10-22 21:52:03 -06:00
|
|
|
|
|
|
|
while (parentBody != NULL)
|
|
|
|
{
|
|
|
|
name = parentBody->getName() + ":" + name;
|
|
|
|
parentSystem = parentBody->getSystem();
|
|
|
|
if (parentSystem == NULL)
|
|
|
|
parentBody = NULL;
|
|
|
|
else
|
|
|
|
parentBody = parentSystem->getPrimaryBody();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (body->getSystem()->getStar() != NULL)
|
|
|
|
{
|
|
|
|
name = universe->getStarCatalog()->getStarName(*(body->getSystem()->getStar())) + ":" + name;
|
|
|
|
}
|
|
|
|
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-11-07 22:28:42 -07:00
|
|
|
std::string Url::getSelectionName(const Selection& selection) const
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
Universe *universe = appCore->getSimulation()->getUniverse();
|
2003-06-25 11:40:24 -06:00
|
|
|
|
|
|
|
switch (selection.getType())
|
2002-11-07 22:28:42 -07:00
|
|
|
{
|
2003-06-25 11:40:24 -06:00
|
|
|
case Selection::Type_Body:
|
2007-10-22 21:52:03 -06:00
|
|
|
return getBodyName(universe, selection.body());
|
2002-11-03 13:33:30 -07:00
|
|
|
|
2003-06-25 11:40:24 -06:00
|
|
|
case Selection::Type_Star:
|
|
|
|
return universe->getStarCatalog()->getStarName(*selection.star());
|
|
|
|
|
|
|
|
case Selection::Type_DeepSky:
|
2005-11-18 02:00:39 -07:00
|
|
|
return universe->getDSOCatalog()->getDSOName(selection.deepsky());
|
2003-06-25 11:40:24 -06:00
|
|
|
|
|
|
|
case Selection::Type_Location:
|
2007-10-22 21:52:03 -06:00
|
|
|
{
|
|
|
|
std::string name = selection.location()->getName();
|
|
|
|
Body* parentBody = selection.location()->getParentBody();
|
|
|
|
if (parentBody != NULL)
|
|
|
|
name = getBodyName(universe, parentBody) + ":" + name;
|
|
|
|
return name;
|
|
|
|
}
|
2003-06-25 11:40:24 -06:00
|
|
|
|
|
|
|
default:
|
|
|
|
return "";
|
2002-11-03 13:33:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
2002-11-07 22:28:42 -07:00
|
|
|
void Url::goTo()
|
2007-01-11 12:30:04 -07:00
|
|
|
{
|
2003-05-31 11:40:19 -06:00
|
|
|
Selection sel;
|
|
|
|
|
2002-11-07 22:28:42 -07:00
|
|
|
if (urlStr == "")
|
|
|
|
return;
|
2002-11-03 13:33:30 -07:00
|
|
|
Simulation *sim = appCore->getSimulation();
|
|
|
|
Renderer *renderer = appCore->getRenderer();
|
|
|
|
std::string::size_type pos;
|
|
|
|
|
|
|
|
sim->update(0.0);
|
2003-05-31 11:40:19 -06:00
|
|
|
|
|
|
|
switch(type) {
|
|
|
|
case Absolute:// Intentional Fall-Through
|
|
|
|
case Relative:
|
2008-02-08 14:46:02 -07:00
|
|
|
sim->setFrame(ref.getCoordinateSystem(), ref.getRefObject(), ref.getTargetObject());
|
2003-05-31 11:40:19 -06:00
|
|
|
sim->getActiveObserver()->setFOV(degToRad(fieldOfView));
|
2003-06-03 15:49:54 -06:00
|
|
|
appCore->setZoomFromFOV();
|
2003-05-31 11:40:19 -06:00
|
|
|
sim->setTimeScale(timeScale);
|
2007-11-03 03:49:29 -06:00
|
|
|
sim->setPauseState(pauseState);
|
2003-05-31 11:40:19 -06:00
|
|
|
appCore->setLightDelayActive(lightTimeDelay);
|
|
|
|
|
2007-11-03 03:49:29 -06:00
|
|
|
if (selectedStr != "")
|
|
|
|
{
|
|
|
|
pos = 0;
|
|
|
|
while(pos != std::string::npos)
|
|
|
|
{
|
|
|
|
pos = selectedStr.find(":", pos + 1);
|
|
|
|
if (pos != std::string::npos) selectedStr[pos]='/';
|
|
|
|
}
|
|
|
|
sel = sim->findObjectFromPath(selectedStr);
|
|
|
|
sim->setSelection(sel);
|
|
|
|
}
|
|
|
|
else
|
2003-05-31 11:40:19 -06:00
|
|
|
{
|
2007-11-03 03:49:29 -06:00
|
|
|
sim->setSelection(Selection());
|
2003-05-31 11:40:19 -06:00
|
|
|
}
|
2002-11-03 13:33:30 -07:00
|
|
|
|
2007-11-03 03:49:29 -06:00
|
|
|
if (trackedStr != "")
|
|
|
|
{
|
|
|
|
pos = 0;
|
|
|
|
while(pos != std::string::npos)
|
|
|
|
{
|
|
|
|
pos = trackedStr.find(":", pos + 1);
|
|
|
|
if (pos != std::string::npos) trackedStr[pos]='/';
|
|
|
|
}
|
|
|
|
sel = sim->findObjectFromPath(trackedStr);
|
|
|
|
sim->setTrackedObject(sel);
|
|
|
|
}
|
|
|
|
else
|
2003-05-31 11:40:19 -06:00
|
|
|
{
|
2007-11-03 03:49:29 -06:00
|
|
|
if (!sim->getTrackedObject().empty())
|
|
|
|
sim->setTrackedObject(Selection());
|
2003-05-31 11:40:19 -06:00
|
|
|
}
|
|
|
|
// Intentional Fall-Through
|
|
|
|
case Settings:
|
|
|
|
renderer->setRenderFlags(renderFlags);
|
|
|
|
renderer->setLabelMode(labelMode);
|
|
|
|
break;
|
2002-11-03 13:33:30 -07:00
|
|
|
}
|
|
|
|
|
2008-05-05 13:09:31 -06:00
|
|
|
if (version >= 3)
|
|
|
|
{
|
|
|
|
switch (timeSource)
|
|
|
|
{
|
|
|
|
case UseUrlTime:
|
|
|
|
sim->setTime((double) date);
|
|
|
|
break;
|
|
|
|
case UseSimulationTime:
|
|
|
|
// Leave the current simulation time unmodified
|
|
|
|
break;
|
|
|
|
case UseSystemTime:
|
|
|
|
sim->setTime(astro::UTCtoTDB(astro::Date::systemDate()));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Position and orientation stored in frame coordinates; convert them
|
|
|
|
// to universal and set the observer position.
|
|
|
|
double tdb = sim->getTime();
|
|
|
|
coord = sim->getObserver().getFrame()->convertToUniversal(coord, tdb);
|
|
|
|
Quatd q(orientation.w, orientation.x, orientation.y, orientation.z);
|
|
|
|
q = sim->getObserver().getFrame()->convertToUniversal(q, tdb);
|
2003-01-23 15:46:46 -07:00
|
|
|
sim->setObserverPosition(coord);
|
2008-05-05 13:09:31 -06:00
|
|
|
sim->setObserverOrientation(Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch(type) {
|
|
|
|
case Absolute:
|
|
|
|
sim->setTime((double) date);
|
|
|
|
sim->setObserverPosition(coord);
|
|
|
|
sim->setObserverOrientation(orientation);
|
|
|
|
break;
|
|
|
|
case Relative:
|
|
|
|
sim->gotoSelectionLongLat(0, astro::kilometersToLightYears(distance), (float) (longitude * PI / 180), (float) (latitude * PI / 180), Vec3f(0, 1, 0));
|
|
|
|
break;
|
|
|
|
case Settings:
|
|
|
|
break;
|
|
|
|
}
|
2003-01-23 15:46:46 -07:00
|
|
|
}
|
2002-11-03 13:33:30 -07:00
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
2002-11-07 22:28:42 -07:00
|
|
|
Url::~Url()
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
}
|
|
|
|
|
2007-01-11 12:30:04 -07:00
|
|
|
|
2002-11-07 22:28:42 -07:00
|
|
|
std::string Url::decode_string(const std::string& str)
|
|
|
|
{
|
2002-11-03 13:33:30 -07:00
|
|
|
std::string::size_type a=0, b;
|
|
|
|
std::string out = "";
|
2003-05-06 16:13:33 -06:00
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
b = str.find("%");
|
2002-11-07 22:28:42 -07:00
|
|
|
while (b != std::string::npos)
|
|
|
|
{
|
2002-12-13 12:39:18 -07:00
|
|
|
unsigned int c;
|
|
|
|
out += str.substr(a, b-a);
|
2003-05-06 16:13:33 -06:00
|
|
|
std::string c_code = str.substr(b+1, 2);
|
2002-11-03 13:33:30 -07:00
|
|
|
sscanf(c_code.c_str(), "%02x", &c);
|
|
|
|
out += c;
|
|
|
|
a = b + 3;
|
|
|
|
b = str.find("%", a);
|
|
|
|
}
|
|
|
|
out += str.substr(a);
|
2006-10-11 14:44:17 -06:00
|
|
|
|
2002-11-03 13:33:30 -07:00
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-05 13:09:31 -06:00
|
|
|
// Utility function that returns the complete path for a selection.
|
|
|
|
string
|
|
|
|
getSelectionName(const Selection& selection, CelestiaCore* appCore)
|
|
|
|
{
|
|
|
|
Universe *universe = appCore->getSimulation()->getUniverse();
|
|
|
|
|
|
|
|
switch (selection.getType())
|
|
|
|
{
|
|
|
|
case Selection::Type_Body:
|
|
|
|
return getBodyName(universe, selection.body());
|
|
|
|
|
|
|
|
case Selection::Type_Star:
|
|
|
|
return universe->getStarCatalog()->getStarName(*selection.star());
|
|
|
|
|
|
|
|
case Selection::Type_DeepSky:
|
|
|
|
return universe->getDSOCatalog()->getDSOName(selection.deepsky());
|
|
|
|
|
|
|
|
case Selection::Type_Location:
|
|
|
|
{
|
|
|
|
std::string name = selection.location()->getName();
|
|
|
|
Body* parentBody = selection.location()->getParentBody();
|
|
|
|
if (parentBody != NULL)
|
|
|
|
name = getBodyName(universe, parentBody) + ":" + name;
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
}
|