// Draw all the Nebulae
void NebulaMgr::draw(StelCore* core)
{
const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000);
StelPainter sPainter(prj);
StelSkyDrawer* skyDrawer = core->getSkyDrawer();
Nebula::hintsBrightness = hintsFader.getInterstate()*flagShow.getInterstate();
sPainter.enableTexture2d(true);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
// Use a 1 degree margin
const double margin = 1.*M_PI/180.*prj->getPixelPerRadAtCenter();
const SphericalRegionP& p = prj->getViewportConvexPolygon(margin, margin);
// Print all the nebulae of all the selected zones
float maxMagHints = skyDrawer->getLimitMagnitude()*1.2f-2.f+(hintsAmount*1.2f)-2.f;
float maxMagLabels = skyDrawer->getLimitMagnitude()-2.f+(labelsAmount*1.2f)-2.f;
sPainter.setFont(nebulaFont);
DrawNebulaFuncObject func(maxMagHints, maxMagLabels, &sPainter, core, hintsFader.getInterstate()>0.0001);
nebGrid.processIntersectingRegions(p, func);
if (GETSTELMODULE(StelObjectMgr)->getFlagSelectedObjectPointer())
drawPointer(core, sPainter);
}
void LabelMgr::draw(StelCore* core)
{
StelPainter sPainter(core->getProjection(StelCore::FrameJ2000));
foreach(StelLabel* l, allLabels)
if (l!=NULL)
l->draw(core, sPainter);
}
void PointerCoordinates::draw(StelCore *core)
{
if (!isEnabled())
return;
const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000, StelCore::RefractionAuto);
StelPainter sPainter(prj);
sPainter.setColor(textColor[0], textColor[1], textColor[2], 1.f);
font.setPixelSize(getFontSize());
sPainter.setFont(font);
QPoint p = QCursor::pos(); // get screen coordinates of mouse cursor
Vec3d mousePosition;
float wh = prj->getViewportWidth()/2; // get half of width of the screen
float hh = prj->getViewportHeight()/2; // get half of height of the screen
float mx = p.x()-wh; // point 0 in center of the screen, axis X directed to right
float my = p.y()-hh; // point 0 in center of the screen, axis Y directed to bottom
// calculate position of mouse cursor via position of center of the screen (and invert axis Y)
prj->unProject(prj->getViewportPosX()+wh+mx, prj->getViewportPosY()+hh+1-my, mousePosition);
double dec_j2000, ra_j2000;
StelUtils::rectToSphe(&ra_j2000,&dec_j2000,mousePosition); // Calculate RA/DE (J2000.0) and show it...
QString coordsText = QString("%1/%2").arg(StelUtils::radToHmsStr(ra_j2000, true)).arg(StelUtils::radToDmsStr(dec_j2000, true));
sPainter.drawText(getCoordinatesPlace(coordsText).first, getCoordinatesPlace(coordsText).second, coordsText);
}
void StelViewportEffect::paintViewportBuffer(const QGLFramebufferObject* buf) const
{
StelPainter sPainter(StelApp::getInstance().getCore()->getProjection2d());
sPainter.setColor(1,1,1);
sPainter.enableTexture2d(true);
glBindTexture(GL_TEXTURE_2D, buf->texture());
sPainter.drawRect2d(0, 0, buf->size().width(), buf->size().height());
}
void ToastMgr::draw(StelCore* core)
{
if (!getFlagShow())
return;
StelPainter sPainter(core->getProjection(StelCore::FrameJ2000));
survey->draw(&sPainter);
}
void TelescopeControl::draw(StelCore* core)
{
const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000);
StelPainter sPainter(prj);
sPainter.setFont(labelFont);
reticleTexture->bind();
foreach (const TelescopeClientP& telescope, telescopeClients)
{
if (telescope->isConnected() && telescope->hasKnownPosition())
{
Vec3d XY;
if (prj->projectCheck(telescope->getJ2000EquatorialPos(core), XY))
{
//Telescope circles appear synchronously with markers
if (circleFader.getInterstate() >= 0)
{
sPainter.setColor(circleColor[0], circleColor[1], circleColor[2], circleFader.getInterstate());
glDisable(GL_TEXTURE_2D);
foreach (double circle, telescope->getOculars())
{
sPainter.drawCircle(XY[0], XY[1], 0.5 * prj->getPixelPerRadAtCenter() * (M_PI/180) * (circle));
}
glEnable(GL_TEXTURE_2D);
}
if (reticleFader.getInterstate() >= 0)
{
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
sPainter.setColor(reticleColor[0], reticleColor[1], reticleColor[2], reticleFader.getInterstate());
sPainter.drawSprite2dMode(XY[0],XY[1],15.f);
glDisable(GL_TEXTURE_2D);
}
if (labelFader.getInterstate() >= 0)
{
sPainter.setColor(labelColor[0], labelColor[1], labelColor[2], labelFader.getInterstate());
//TODO: Different position of the label if circles are shown?
//TODO: Remove magic number (text spacing)
sPainter.drawText(XY[0], XY[1], telescope->getNameI18n(), 0, 6 + 10, -4, false);
//Same position as the other objects: doesn't work, telescope label overlaps object label
//sPainter.drawText(XY[0], XY[1], scope->getNameI18n(), 0, 10, 10, false);
reticleTexture->bind();
}
}
}
void SporadicMeteorMgr::draw(StelCore* core)
{
if (!m_flagShow || !core->getSkyDrawer()->getFlagHasAtmosphere())
{
return;
}
LandscapeMgr* landmgr = GETSTELMODULE(LandscapeMgr);
if (landmgr->getFlagAtmosphere() && landmgr->getLuminance() > 5.f)
{
return;
}
// step through and draw all active meteors
StelPainter sPainter(core->getProjection(StelCore::FrameAltAz));
foreach (SporadicMeteor* m, activeMeteors)
{
m->draw(core, sPainter);
}
void MeteorMgr::draw(StelCore* core)
{
if (!flagShow)
return;
LandscapeMgr* landmgr = (LandscapeMgr*)StelApp::getInstance().getModuleMgr().getModule("LandscapeMgr");
if (landmgr->getFlagAtmosphere() && landmgr->getLuminance()>5)
return;
StelPainter sPainter(core->getProjection(StelCore::FrameAltAz));
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
sPainter.enableTexture2d(false);
// step through and draw all active meteors
for (std::vector<Meteor*>::iterator iter = active.begin(); iter != active.end(); ++iter)
{
(*iter)->draw(core, sPainter);
}
}
void PointerCoordinates::draw(StelCore *core)
{
if (!isEnabled())
return;
const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000, StelCore::RefractionAuto);
StelPainter sPainter(prj);
sPainter.setColor(textColor[0], textColor[1], textColor[2], 1.f);
font.setPixelSize(getFontSize());
sPainter.setFont(font);
QPoint p = StelMainView::getInstance().getMousePos(); // get screen coordinates of mouse cursor
Vec3d mousePosition;
float wh = prj->getViewportWidth()/2.; // get half of width of the screen
float hh = prj->getViewportHeight()/2.; // get half of height of the screen
float mx = p.x()-wh; // point 0 in center of the screen, axis X directed to right
float my = p.y()-hh; // point 0 in center of the screen, axis Y directed to bottom
// calculate position of mouse cursor via position of center of the screen (and invert axis Y)
// If coordinates are invalid, don't draw them.
bool coordsValid=false;
coordsValid = prj->unProject(prj->getViewportPosX()+wh+mx, prj->getViewportPosY()+hh+1-my, mousePosition);
{ // Nick Fedoseev patch
Vec3d win;
prj->project(mousePosition,win);
float dx = prj->getViewportPosX()+wh+mx - win.v[0];
float dy = prj->getViewportPosY()+hh+1-my - win.v[1];
coordsValid = prj->unProject(prj->getViewportPosX()+wh+mx+dx, prj->getViewportPosY()+hh+1-my+dy, mousePosition);
}
if (!coordsValid)
return;
bool withDecimalDegree = StelApp::getInstance().getFlagShowDecimalDegrees();
bool useSouthAzimuth = StelApp::getInstance().getFlagSouthAzimuthUsage();
QString coordsSystem, cxt, cyt;
double cx, cy;
switch (getCurrentCoordinateSystem())
{
case RaDecJ2000:
{
StelUtils::rectToSphe(&cx,&cy,mousePosition); // Calculate RA/DE (J2000.0) and show it...
coordsSystem = qc_("RA/Dec (J2000.0)", "abbreviated in the plugin");
if (withDecimalDegree)
{
cxt = StelUtils::radToDecDegStr(cx, 5, false, true);
cyt = StelUtils::radToDecDegStr(cy);
}
else
{
cxt = StelUtils::radToHmsStr(cx, true);
cyt = StelUtils::radToDmsStr(cy, true);
}
break;
}
case RaDec:
{
StelUtils::rectToSphe(&cx,&cy,core->j2000ToEquinoxEqu(mousePosition)); // Calculate RA/DE and show it...
coordsSystem = qc_("RA/Dec", "abbreviated in the plugin");
if (withDecimalDegree)
{
cxt = StelUtils::radToDecDegStr(cx, 5, false, true);
cyt = StelUtils::radToDecDegStr(cy);
}
else
{
cxt = StelUtils::radToHmsStr(cx, true);
cyt = StelUtils::radToDmsStr(cy, true);
}
break;
}
case AltAzi:
{
StelUtils::rectToSphe(&cy,&cx,core->j2000ToAltAz(mousePosition, StelCore::RefractionAuto));
float direction = 3.; // N is zero, E is 90 degrees
if (useSouthAzimuth)
direction = 2.;
cy = direction*M_PI - cy;
if (cy > M_PI*2)
cy -= M_PI*2;
coordsSystem = qc_("Az/Alt", "abbreviated in the plugin");
if (withDecimalDegree)
{
cxt = StelUtils::radToDecDegStr(cy);
cyt = StelUtils::radToDecDegStr(cx);
}
else
{
cxt = StelUtils::radToDmsStr(cy);
cyt = StelUtils::radToDmsStr(cx);
}
break;
}
case Galactic:
{
StelUtils::rectToSphe(&cx,&cy,core->j2000ToGalactic(mousePosition)); // Calculate galactic position and show it...
coordsSystem = qc_("Gal. Long/Lat", "abbreviated in the plugin");
if (withDecimalDegree)
{
cxt = StelUtils::radToDecDegStr(cx);
cyt = StelUtils::radToDecDegStr(cy);
}
else
{
cxt = StelUtils::radToDmsStr(cx, true);
cyt = StelUtils::radToDmsStr(cy, true);
}
break;
}
case Ecliptic:
{
double lambda, beta;
StelUtils::rectToSphe(&cx,&cy,core->j2000ToEquinoxEqu(mousePosition));
StelUtils::equToEcl(cx, cy, core->getCurrentPlanet()->getRotObliquity(core->getJDE()), &lambda, &beta); // Calculate ecliptic position and show it...
if (lambda<0) lambda+=2.0*M_PI;
coordsSystem = qc_("Ecl. Long/Lat", "abbreviated in the plugin");
if (withDecimalDegree)
{
cxt = StelUtils::radToDecDegStr(lambda);
cyt = StelUtils::radToDecDegStr(beta);
}
else
{
cxt = StelUtils::radToDmsStr(lambda, true);
cyt = StelUtils::radToDmsStr(beta, true);
}
break;
}
case EclipticJ2000:
{
double lambda, beta;
StelUtils::rectToSphe(&cx,&cy, mousePosition);
StelUtils::equToEcl(cx, cy, core->getCurrentPlanet()->getRotObliquity(2451545.0), &lambda, &beta); // Calculate ecliptic position and show it...
if (lambda<0) lambda+=2.0*M_PI;
coordsSystem = qc_("Ecl. Long/Lat (J2000.0)", "abbreviated in the plugin");
if (withDecimalDegree)
{
cxt = StelUtils::radToDecDegStr(lambda);
cyt = StelUtils::radToDecDegStr(beta);
}
else
{
cxt = StelUtils::radToDmsStr(lambda, true);
cyt = StelUtils::radToDmsStr(beta, true);
}
break;
}
case HourAngle:
{
Vec3d v = core->j2000ToAltAz(mousePosition, StelCore::RefractionAuto);
StelUtils::rectToSphe(&cx,&cy,Mat4d::zrotation(-core->getLocalSiderealTime())*core->altAzToEquinoxEqu(v, StelCore::RefractionOff));
cx = 2.*M_PI-cx;
coordsSystem = qc_("HA/Dec", "abbreviated in the plugin");
if (withDecimalDegree)
{
double ha_sidereal = cx*12/M_PI;
if (ha_sidereal>24.)
ha_sidereal -= 24.;
cxt = QString("%1h").arg(ha_sidereal, 0, 'f', 5);
cyt = StelUtils::radToDecDegStr(cy);
}
else
{
cxt = StelUtils::radToHmsStr(cx);
cyt = StelUtils::radToDmsStr(cy);
}
break;
}
}
QString coordsText = QString("%1: %2/%3").arg(coordsSystem).arg(cxt).arg(cyt);
sPainter.drawText(getCoordinatesPlace(coordsText).first, getCoordinatesPlace(coordsText).second, coordsText);
}
void SkyLine::draw(StelCore *core) const
{
if (!fader.getInterstate())
return;
StelProjectorP prj = core->getProjection(frameType, frameType!=StelCore::FrameAltAz ? StelCore::RefractionAuto : StelCore::RefractionOff);
// Get the bounding halfspace
const SphericalCap& viewPortSphericalCap = prj->getBoundingCap();
// Initialize a painter and set openGL state
StelPainter sPainter(prj);
sPainter.setColor(color[0], color[1], color[2], fader.getInterstate());
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
Vec4f textColor(color[0], color[1], color[2], 0);
textColor[3]=fader.getInterstate();
ViewportEdgeIntersectCallbackData userData(&sPainter);
sPainter.setFont(font);
userData.textColor = textColor;
userData.text = label;
/////////////////////////////////////////////////
// Draw the line
SphericalCap meridianSphericalCap(Vec3d(0,0,1), 0);
Vec3d fpt(1,0,0);
if (line_type==MERIDIAN)
{
meridianSphericalCap.n.set(0,1,0);
}
Vec3d p1, p2;
if (!SphericalCap::intersectionPoints(viewPortSphericalCap, meridianSphericalCap, p1, p2))
{
if ((viewPortSphericalCap.d<meridianSphericalCap.d && viewPortSphericalCap.contains(meridianSphericalCap.n))
|| (viewPortSphericalCap.d<-meridianSphericalCap.d && viewPortSphericalCap.contains(-meridianSphericalCap.n)))
{
// The meridian is fully included in the viewport, draw it in 3 sub-arcs to avoid length > 180.
const Mat4d& rotLon120 = Mat4d::rotation(meridianSphericalCap.n, 120.*M_PI/180.);
Vec3d rotFpt=fpt;
rotFpt.transfo4d(rotLon120);
Vec3d rotFpt2=rotFpt;
rotFpt2.transfo4d(rotLon120);
sPainter.drawGreatCircleArc(fpt, rotFpt, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(rotFpt, rotFpt2, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(rotFpt2, fpt, NULL, viewportEdgeIntersectCallback, &userData);
return;
}
else
return;
}
Vec3d middlePoint = p1+p2;
middlePoint.normalize();
if (!viewPortSphericalCap.contains(middlePoint))
middlePoint*=-1.;
// Draw the arc in 2 sub-arcs to avoid lengths > 180 deg
sPainter.drawGreatCircleArc(p1, middlePoint, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(p2, middlePoint, NULL, viewportEdgeIntersectCallback, &userData);
// // Johannes: use a big radius as a dirty workaround for the bug that the
// // ecliptic line is not drawn around the observer, but around the sun:
// const Vec3d vv(1000000,0,0);
}
//! Draw the sky grid in the current frame
void SkyGrid::draw(const StelCore* core) const
{
const StelProjectorP prj = core->getProjection(frameType, frameType!=StelCore::FrameAltAz ? StelCore::RefractionAuto : StelCore::RefractionOff);
if (!fader.getInterstate())
return;
bool withDecimalDegree = dynamic_cast<StelGui*>(StelApp::getInstance().getGui())->getFlagShowDecimalDegrees();
// Look for all meridians and parallels intersecting with the disk bounding the viewport
// Check whether the pole are in the viewport
bool northPoleInViewport = false;
bool southPoleInViewport = false;
Vec3f win;
if (prj->project(Vec3f(0,0,1), win) && prj->checkInViewport(win))
northPoleInViewport = true;
if (prj->project(Vec3f(0,0,-1), win) && prj->checkInViewport(win))
southPoleInViewport = true;
// Get the longitude and latitude resolution at the center of the viewport
Vec3d centerV;
prj->unProject(prj->getViewportPosX()+prj->getViewportWidth()/2, prj->getViewportPosY()+prj->getViewportHeight()/2+1, centerV);
double lon2, lat2;
StelUtils::rectToSphe(&lon2, &lat2, centerV);
const double gridStepParallelRad = M_PI/180.*getClosestResolutionDMS(prj->getPixelPerRadAtCenter());
double gridStepMeridianRad;
if (northPoleInViewport || southPoleInViewport)
gridStepMeridianRad = (frameType==StelCore::FrameAltAz || frameType==StelCore::FrameGalactic) ? M_PI/180.* 10. : M_PI/180.* 15.;
else
{
const double closetResLon = (frameType==StelCore::FrameAltAz || frameType==StelCore::FrameGalactic) ? getClosestResolutionDMS(prj->getPixelPerRadAtCenter()*std::cos(lat2)) : getClosestResolutionHMS(prj->getPixelPerRadAtCenter()*std::cos(lat2));
gridStepMeridianRad = M_PI/180.* ((northPoleInViewport || southPoleInViewport) ? 15. : closetResLon);
}
// Get the bounding halfspace
const SphericalCap& viewPortSphericalCap = prj->getBoundingCap();
// Compute the first grid starting point. This point is close to the center of the screen
// and lays at the intersection of a meridien and a parallel
lon2 = gridStepMeridianRad*((int)(lon2/gridStepMeridianRad+0.5));
lat2 = gridStepParallelRad*((int)(lat2/gridStepParallelRad+0.5));
Vec3d firstPoint;
StelUtils::spheToRect(lon2, lat2, firstPoint);
firstPoint.normalize();
// Q_ASSERT(viewPortSphericalCap.contains(firstPoint));
// Initialize a painter and set openGL state
StelPainter sPainter(prj);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
Vec4f textColor(color[0], color[1], color[2], 0);
sPainter.setColor(color[0],color[1],color[2], fader.getInterstate());
textColor*=2;
textColor[3]=fader.getInterstate();
sPainter.setFont(font);
ViewportEdgeIntersectCallbackData userData(&sPainter);
userData.textColor = textColor;
userData.frameType = frameType;
/////////////////////////////////////////////////
// Draw all the meridians (great circles)
SphericalCap meridianSphericalCap(Vec3d(1,0,0), 0);
Mat4d rotLon = Mat4d::zrotation(gridStepMeridianRad);
Vec3d fpt = firstPoint;
Vec3d p1, p2;
int maxNbIter = (int)(M_PI/gridStepMeridianRad);
int i;
for (i=0; i<maxNbIter; ++i)
{
StelUtils::rectToSphe(&lon2, &lat2, fpt);
userData.raAngle = lon2;
meridianSphericalCap.n = fpt^Vec3d(0,0,1);
meridianSphericalCap.n.normalize();
if (!SphericalCap::intersectionPoints(viewPortSphericalCap, meridianSphericalCap, p1, p2))
{
if (viewPortSphericalCap.d<meridianSphericalCap.d && viewPortSphericalCap.contains(meridianSphericalCap.n))
{
// The meridian is fully included in the viewport, draw it in 3 sub-arcs to avoid length > 180.
const Mat4d& rotLon120 = Mat4d::rotation(meridianSphericalCap.n, 120.*M_PI/180.);
Vec3d rotFpt=fpt;
rotFpt.transfo4d(rotLon120);
Vec3d rotFpt2=rotFpt;
rotFpt2.transfo4d(rotLon120);
sPainter.drawGreatCircleArc(fpt, rotFpt, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(rotFpt, rotFpt2, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(rotFpt2, fpt, NULL, viewportEdgeIntersectCallback, &userData);
fpt.transfo4d(rotLon);
continue;
}
else
break;
}
Vec3d middlePoint = p1+p2;
middlePoint.normalize();
if (!viewPortSphericalCap.contains(middlePoint))
middlePoint*=-1.;
// Draw the arc in 2 sub-arcs to avoid lengths > 180 deg
sPainter.drawGreatCircleArc(p1, middlePoint, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(p2, middlePoint, NULL, viewportEdgeIntersectCallback, &userData);
fpt.transfo4d(rotLon);
}
if (i!=maxNbIter)
{
rotLon = Mat4d::zrotation(-gridStepMeridianRad);
fpt = firstPoint;
fpt.transfo4d(rotLon);
for (int j=0; j<maxNbIter-i; ++j)
{
StelUtils::rectToSphe(&lon2, &lat2, fpt);
userData.raAngle = lon2;
meridianSphericalCap.n = fpt^Vec3d(0,0,1);
meridianSphericalCap.n.normalize();
if (!SphericalCap::intersectionPoints(viewPortSphericalCap, meridianSphericalCap, p1, p2))
break;
Vec3d middlePoint = p1+p2;
middlePoint.normalize();
if (!viewPortSphericalCap.contains(middlePoint))
middlePoint*=-1;
sPainter.drawGreatCircleArc(p1, middlePoint, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(p2, middlePoint, NULL, viewportEdgeIntersectCallback, &userData);
fpt.transfo4d(rotLon);
}
}
/////////////////////////////////////////////////
// Draw all the parallels (small circles)
SphericalCap parallelSphericalCap(Vec3d(0,0,1), 0);
rotLon = Mat4d::rotation(firstPoint^Vec3d(0,0,1), gridStepParallelRad);
fpt = firstPoint;
maxNbIter = (int)(M_PI/gridStepParallelRad)-1;
for (i=0; i<maxNbIter; ++i)
{
StelUtils::rectToSphe(&lon2, &lat2, fpt);
if (withDecimalDegree)
userData.text = StelUtils::radToDecDegStr(lat2);
else
userData.text = StelUtils::radToDmsStrAdapt(lat2);
parallelSphericalCap.d = fpt[2];
if (parallelSphericalCap.d>0.9999999)
break;
const Vec3d rotCenter(0,0,parallelSphericalCap.d);
if (!SphericalCap::intersectionPoints(viewPortSphericalCap, parallelSphericalCap, p1, p2))
{
if ((viewPortSphericalCap.d<parallelSphericalCap.d && viewPortSphericalCap.contains(parallelSphericalCap.n))
|| (viewPortSphericalCap.d<-parallelSphericalCap.d && viewPortSphericalCap.contains(-parallelSphericalCap.n)))
{
// The parallel is fully included in the viewport, draw it in 3 sub-arcs to avoid lengths >= 180 deg
static const Mat4d rotLon120 = Mat4d::zrotation(120.*M_PI/180.);
Vec3d rotFpt=fpt;
rotFpt.transfo4d(rotLon120);
Vec3d rotFpt2=rotFpt;
rotFpt2.transfo4d(rotLon120);
sPainter.drawSmallCircleArc(fpt, rotFpt, rotCenter, viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(rotFpt, rotFpt2, rotCenter, viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(rotFpt2, fpt, rotCenter, viewportEdgeIntersectCallback, &userData);
fpt.transfo4d(rotLon);
continue;
}
else
break;
}
// Draw the arc in 2 sub-arcs to avoid lengths > 180 deg
Vec3d middlePoint = p1-rotCenter+p2-rotCenter;
middlePoint.normalize();
middlePoint*=(p1-rotCenter).length();
middlePoint+=rotCenter;
if (!viewPortSphericalCap.contains(middlePoint))
{
middlePoint-=rotCenter;
middlePoint*=-1.;
middlePoint+=rotCenter;
}
sPainter.drawSmallCircleArc(p1, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(p2, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData);
fpt.transfo4d(rotLon);
}
if (i!=maxNbIter)
{
rotLon = Mat4d::rotation(firstPoint^Vec3d(0,0,1), -gridStepParallelRad);
fpt = firstPoint;
fpt.transfo4d(rotLon);
for (int j=0; j<maxNbIter-i; ++j)
{
StelUtils::rectToSphe(&lon2, &lat2, fpt);
if (withDecimalDegree)
userData.text = StelUtils::radToDecDegStr(lat2);
else
userData.text = StelUtils::radToDmsStrAdapt(lat2);
parallelSphericalCap.d = fpt[2];
const Vec3d rotCenter(0,0,parallelSphericalCap.d);
if (!SphericalCap::intersectionPoints(viewPortSphericalCap, parallelSphericalCap, p1, p2))
{
if ((viewPortSphericalCap.d<parallelSphericalCap.d && viewPortSphericalCap.contains(parallelSphericalCap.n))
|| (viewPortSphericalCap.d<-parallelSphericalCap.d && viewPortSphericalCap.contains(-parallelSphericalCap.n)))
{
// The parallel is fully included in the viewport, draw it in 3 sub-arcs to avoid lengths >= 180 deg
static const Mat4d rotLon120 = Mat4d::zrotation(120.*M_PI/180.);
Vec3d rotFpt=fpt;
rotFpt.transfo4d(rotLon120);
Vec3d rotFpt2=rotFpt;
rotFpt2.transfo4d(rotLon120);
sPainter.drawSmallCircleArc(fpt, rotFpt, rotCenter, viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(rotFpt, rotFpt2, rotCenter, viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(rotFpt2, fpt, rotCenter, viewportEdgeIntersectCallback, &userData);
fpt.transfo4d(rotLon);
continue;
}
else
break;
}
// Draw the arc in 2 sub-arcs to avoid lengths > 180 deg
Vec3d middlePoint = p1-rotCenter+p2-rotCenter;
middlePoint.normalize();
middlePoint*=(p1-rotCenter).length();
middlePoint+=rotCenter;
if (!viewPortSphericalCap.contains(middlePoint))
{
middlePoint-=rotCenter;
middlePoint*=-1.;
middlePoint+=rotCenter;
}
sPainter.drawSmallCircleArc(p1, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(p2, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData);
fpt.transfo4d(rotLon);
}
}
}
void SkyLine::draw(StelCore *core) const
{
if (!fader.getInterstate())
return;
StelProjectorP prj = core->getProjection(frameType, frameType!=StelCore::FrameAltAz ? StelCore::RefractionAuto : StelCore::RefractionOff);
// Get the bounding halfspace
const SphericalCap& viewPortSphericalCap = prj->getBoundingCap();
// Initialize a painter and set openGL state
StelPainter sPainter(prj);
sPainter.setColor(color[0], color[1], color[2], fader.getInterstate());
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
#ifdef GL_LINE_SMOOTH
if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
glEnable(GL_LINE_SMOOTH);
#endif
Vec4f textColor(color[0], color[1], color[2], 0);
textColor[3]=fader.getInterstate();
ViewportEdgeIntersectCallbackData userData(&sPainter);
sPainter.setFont(font);
userData.textColor = textColor;
userData.text = label;
/////////////////////////////////////////////////
// Draw the line
// Precession circles are Small Circles, all others are Great Circles.
if (line_type==PRECESSIONCIRCLE_N || line_type==PRECESSIONCIRCLE_S)
{
const double lat=(line_type==PRECESSIONCIRCLE_S ? -1.0 : 1.0) * (M_PI/2.0-getPrecessionAngleVondrakCurrentEpsilonA());
SphericalCap declinationCap(Vec3d(0,0,1), std::sin(lat));
const Vec3d rotCenter(0,0,declinationCap.d);
Vec3d p1, p2;
if (!SphericalCap::intersectionPoints(viewPortSphericalCap, declinationCap, p1, p2))
{
if ((viewPortSphericalCap.d<declinationCap.d && viewPortSphericalCap.contains(declinationCap.n))
|| (viewPortSphericalCap.d<-declinationCap.d && viewPortSphericalCap.contains(-declinationCap.n)))
{
// The line is fully included in the viewport, draw it in 3 sub-arcs to avoid length > 180.
Vec3d pt1;
Vec3d pt2;
Vec3d pt3;
const double lon1=0.0;
const double lon2=120.0*M_PI/180.0;
const double lon3=240.0*M_PI/180.0;
StelUtils::spheToRect(lon1, lat, pt1); pt1.normalize();
StelUtils::spheToRect(lon2, lat, pt2); pt2.normalize();
StelUtils::spheToRect(lon3, lat, pt3); pt3.normalize();
sPainter.drawSmallCircleArc(pt1, pt2, rotCenter, viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(pt2, pt3, rotCenter, viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(pt3, pt1, rotCenter, viewportEdgeIntersectCallback, &userData);
#ifdef GL_LINE_SMOOTH
if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
glDisable(GL_LINE_SMOOTH);
#endif
glDisable(GL_BLEND);
return;
}
else
{
#ifdef GL_LINE_SMOOTH
if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
glDisable(GL_LINE_SMOOTH);
#endif
glDisable(GL_BLEND);
return;
}
}
// Draw the arc in 2 sub-arcs to avoid lengths > 180 deg
Vec3d middlePoint = p1-rotCenter+p2-rotCenter;
middlePoint.normalize();
middlePoint*=(p1-rotCenter).length();
middlePoint+=rotCenter;
if (!viewPortSphericalCap.contains(middlePoint))
{
middlePoint-=rotCenter;
middlePoint*=-1.;
middlePoint+=rotCenter;
}
sPainter.drawSmallCircleArc(p1, middlePoint, rotCenter,viewportEdgeIntersectCallback, &userData);
sPainter.drawSmallCircleArc(p2, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData);
// OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH
#ifdef GL_LINE_SMOOTH
if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
glDisable(GL_LINE_SMOOTH);
#endif
glDisable(GL_BLEND);
return;
}
// All the other "lines" are Great Circles
SphericalCap meridianSphericalCap(Vec3d(0,0,1), 0);
Vec3d fpt(1,0,0);
if ((line_type==MERIDIAN) || (line_type==COLURE_1))
{
meridianSphericalCap.n.set(0,1,0);
}
if ((line_type==PRIME_VERTICAL) || (line_type==COLURE_2))
{
meridianSphericalCap.n.set(1,0,0);
fpt.set(0,0,1);
}
if (line_type==LONGITUDE)
{
Vec3d coord;
double lambda, beta;
StelUtils::rectToSphe(&lambda, &beta, core->getCurrentPlanet()->getHeliocentricEclipticPos());
StelUtils::spheToRect(lambda + M_PI/2., 0., coord);
meridianSphericalCap.n.set(coord[0],coord[1],coord[2]);
fpt.set(0,0,1);
}
Vec3d p1, p2;
if (!SphericalCap::intersectionPoints(viewPortSphericalCap, meridianSphericalCap, p1, p2))
{
if ((viewPortSphericalCap.d<meridianSphericalCap.d && viewPortSphericalCap.contains(meridianSphericalCap.n))
|| (viewPortSphericalCap.d<-meridianSphericalCap.d && viewPortSphericalCap.contains(-meridianSphericalCap.n)))
{
// The meridian is fully included in the viewport, draw it in 3 sub-arcs to avoid length > 180.
const Mat4d& rotLon120 = Mat4d::rotation(meridianSphericalCap.n, 120.*M_PI/180.);
Vec3d rotFpt=fpt;
rotFpt.transfo4d(rotLon120);
Vec3d rotFpt2=rotFpt;
rotFpt2.transfo4d(rotLon120);
sPainter.drawGreatCircleArc(fpt, rotFpt, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(rotFpt, rotFpt2, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(rotFpt2, fpt, NULL, viewportEdgeIntersectCallback, &userData);
return;
}
else
return;
}
Vec3d middlePoint = p1+p2;
middlePoint.normalize();
if (!viewPortSphericalCap.contains(middlePoint))
middlePoint*=-1.;
// Draw the arc in 2 sub-arcs to avoid lengths > 180 deg
sPainter.drawGreatCircleArc(p1, middlePoint, NULL, viewportEdgeIntersectCallback, &userData);
sPainter.drawGreatCircleArc(p2, middlePoint, NULL, viewportEdgeIntersectCallback, &userData);
// OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH
#ifdef GL_LINE_SMOOTH
if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL)
glDisable(GL_LINE_SMOOTH);
#endif
glDisable(GL_BLEND);
// // Johannes: use a big radius as a dirty workaround for the bug that the
// // ecliptic line is not drawn around the observer, but around the sun:
// const Vec3d vv(1000000,0,0);
}
double StelGeodesicGridDrawer::draw(StelCore* core, int maxSearchLevel)
{
const StelProjectorP prj = core->getProjection();
StelPainter sPainter(prj);
StelGeodesicGrid* geodesicGrid = core->getGeodesicGrid();
const GeodesicSearchResult* geodesic_search_result = geodesicGrid->search(prj->unprojectViewport(), maxSearchLevel);
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
core->setCurrentFrame(StelCore::FrameJ2000); // set 2D coordinate
sPainter.setColor(0.2,0.3,0.2);
int lev = (int)(7./pow(prj->getFov(), 0.4))+2;
if (lev>geodesicGrid->getMaxLevel())
lev = geodesicGrid->getMaxLevel();
lev = maxSearchLevel;
Vec3d win1, win2;
int index;
Vec3d v0, v1, v2;
{
GeodesicSearchInsideIterator it1(*geodesic_search_result, lev);
while((index = it1.next()) >= 0)
{
Vec3d center(0);
geodesicGrid->getTriangleCorners(lev, index, v0, v1, v2);
prj->project(v0, win1);
prj->project(v1, win2);
center += win1;
sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]);
prj->project(v1, win1);
prj->project(v2, win2);
sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]);
center += win1;
prj->project(v2, win1);
prj->project(v0, win2);
sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]);
center += win1;
center*=0.33333;
QString str = QString("%1 (%2)").arg(index)
.arg(geodesicGrid->getPartnerTriangle(lev, index));
glEnable(GL_TEXTURE_2D);
prj->drawText(font,center[0]-6, center[1]+6, str);
glDisable(GL_TEXTURE_2D);
}
}
GeodesicSearchBorderIterator it1(*geodesic_search_result, lev);
while((index = it1.next()) >= 0)
{
Vec3d center(0);
geodesicGrid->getTriangleCorners(lev, index, v0, v1, v2);
prj->project(v0, win1);
prj->project(v1, win2);
center += win1;
sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]);
prj->project(v1, win1);
prj->project(v2, win2);
sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]);
center += win1;
prj->project(v2, win1);
prj->project(v0, win2);
sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]);
center += win1;
center*=0.33333;
QString str = QString("%1 (%2)").arg(index)
.arg(geodesicGrid->getPartnerTriangle(lev, index));
glEnable(GL_TEXTURE_2D);
prj->drawText(font,center[0]-6, center[1]+6, str);
glDisable(GL_TEXTURE_2D);
}
return 0.;
}