StelProjector.hpp   StelProjector.hpp 
skipping to change at line 52 skipping to change at line 52
enum StelProjectorMaskType enum StelProjectorMaskType
{ {
MaskNone, //!< Regular - no mask. MaskNone, //!< Regular - no mask.
MaskDisk //!< For disk viewport mode (circular mask t o seem like bins/telescope) MaskDisk //!< For disk viewport mode (circular mask t o seem like bins/telescope)
}; };
//! @struct StelProjectorParams //! @struct StelProjectorParams
//! Contains all the param needed to initialize a StelProjector //! Contains all the param needed to initialize a StelProjector
struct StelProjectorParams struct StelProjectorParams
{ {
StelProjectorParams() : viewportXywh(0), fov(60.), gravityLa StelProjectorParams() : viewportXywh(0, 0, 256, 256), fov(60
bels(false), maskType(MaskNone), viewportCenter(0., 0.), flipHorz(false), f .f), gravityLabels(false), maskType(MaskNone), viewportCenter(128.f, 128.f)
lipVert(false) {;} , flipHorz(false), flipVert(false) {;}
Vector4<int> viewportXywh; //! posX, posY, width, height Vector4<int> viewportXywh; //! posX, posY, width, heigh
double fov; //! FOV in degrees t
bool gravityLabels; //! the flag to use gravity l float fov; //! FOV in degrees
abels or not bool gravityLabels; //! the flag to use gravity
StelProjectorMaskType maskType; //! The current projector labels or not
mask StelProjectorMaskType maskType; //! The current projector ma
double zNear, zFar; //! Near and far clipping pla sk
nes float zNear, zFar; //! Near and far clipping pl
Vec2d viewportCenter; //! Viewport center in screen anes
pixel Vec2f viewportCenter; //! Viewport center in scree
double viewportFovDiameter; //! diameter of the FOV disk n pixel
in pixel float viewportFovDiameter; //! diameter of the FOV disk
bool flipHorz, flipVert; //! Whether to flip in horizo in pixel
ntal or vertical directions bool flipHorz, flipVert; //! Whether to flip in horiz
ontal or vertical directions
}; };
//! Destructor //! Destructor
virtual ~StelProjector() {;} virtual ~StelProjector() {;}
//////////////////////////////////////////////////////////////////// /////// //////////////////////////////////////////////////////////////////// ///////
// Methods which must be reimplemented by all instance of StelProjec tor // Methods which must be reimplemented by all instance of StelProjec tor
//! Get a human-readable name for this projection type //! Get a human-readable name for this projection type
virtual QString getNameI18() const = 0; virtual QString getNameI18() const = 0;
//! Get a human-readable short description for this projection type //! Get a human-readable short description for this projection type
virtual QString getDescriptionI18() const {return "No description";} virtual QString getDescriptionI18() const {return "No description";}
//! Get a HTML version of the short description for this projection type //! Get a HTML version of the short description for this projection type
QString getHtmlSummary() const; QString getHtmlSummary() const;
//! Get the maximum FOV apperture in degree //! Get the maximum FOV apperture in degree
virtual double getMaxFov() const = 0; virtual float getMaxFov() const = 0;
//! Apply the transformation in the forward direction in place. //! Apply the transformation in the forward direction in place.
//! After transformation v[2] will always contain the length of the original v: sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]) //! After transformation v[2] will always contain the length of the original v: sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2])
//! regardless of the projection type. This makes it possible to imp lement depth buffer testing in a way independent of the //! regardless of the projection type. This makes it possible to imp lement depth buffer testing in a way independent of the
//! projection type. I would like to return the squared length inste ad of the length because of performance reasons. //! projection type. I would like to return the squared length inste ad of the length because of performance reasons.
//! But then far away objects are not textured any more, perhaps bec ause of a depth buffer overflow although //! But then far away objects are not textured any more, perhaps bec ause of a depth buffer overflow although
//! the depth test is disabled? //! the depth test is disabled?
virtual bool forward(Vec3d &v) const = 0; virtual bool forward(Vec3f& v) const = 0;
//! Apply the transformation in the backward projection in place. //! Apply the transformation in the backward projection in place.
virtual bool backward(Vec3d &v) const = 0; virtual bool backward(Vec3d& v) const = 0;
//! Return the small zoom increment to use at the given FOV for nice movements //! Return the small zoom increment to use at the given FOV for nice movements
virtual double deltaZoom(double fov) const = 0; virtual float deltaZoom(float fov) const = 0;
//! Determine whether a great circle connection p1 and p2 intersects with a projection discontinuity. //! Determine whether a great circle connection p1 and p2 intersects with a projection discontinuity.
//! For many projections without discontinuity, this should return a lways false, but for other like //! For many projections without discontinuity, this should return a lways false, but for other like
//! cylindrical projection it will return true if the line cuts the wrap-around line (i.e. at lon=180 if the observer look at lon=0). //! cylindrical projection it will return true if the line cuts the wrap-around line (i.e. at lon=180 if the observer look at lon=0).
bool intersectViewportDiscontinuity(const Vec3d& p1, const Vec3d& p2 ) const bool intersectViewportDiscontinuity(const Vec3d& p1, const Vec3d& p2 ) const
{ {
if (hasDiscontinuity()==false) return hasDiscontinuity() && intersectViewportDiscontinuityI
return false; nternal(modelViewMatrix*p1, modelViewMatrix*p2);
return intersectViewportDiscontinuityInternal(modelViewMatri }
x*p1, modelViewMatrix*p2);
bool intersectViewportDiscontinuity(const SphericalCap& cap) const
{
return hasDiscontinuity() && intersectViewportDiscontinuityI
nternal(modelViewMatrix*cap.n, cap.d);
} }
//! Convert a Field Of View radius value in radians in ViewScalingFa ctor (used internally) //! Convert a Field Of View radius value in radians in ViewScalingFa ctor (used internally)
virtual double fovToViewScalingFactor(double fov) const = 0; virtual float fovToViewScalingFactor(float fov) const = 0;
//! Convert a ViewScalingFactor value (used internally) in Field Of View radius in radians //! Convert a ViewScalingFactor value (used internally) in Field Of View radius in radians
virtual double viewScalingFactorToFov(double vsf) const = 0; virtual float viewScalingFactorToFov(float vsf) const = 0;
//! Get the current state of the flag which decides whether to //! Get the current state of the flag which decides whether to
//! arrage labels so that they are aligned with the bottom of a 2d //! arrage labels so that they are aligned with the bottom of a 2d
//! screen, or a 3d dome. //! screen, or a 3d dome.
bool getFlagGravityLabels() const { return gravityLabels; } bool getFlagGravityLabels() const { return gravityLabels; }
//! Get the lower left corner of the viewport and the width, height. //! Get the lower left corner of the viewport and the width, height.
const Vec4i& getViewport(void) const {return viewportXywh;} const Vec4i& getViewport() const {return viewportXywh;}
//! Get the center of the viewport relative to the lower left corner of the screen. //! Get the center of the viewport relative to the lower left corner of the screen.
Vec2d getViewportCenter(void) const Vec2f getViewportCenter() const
{ {
return Vec2d(viewportCenter[0]-viewportXywh[0],viewportCente r[1]-viewportXywh[1]); return Vec2f(viewportCenter[0]-viewportXywh[0],viewportCente r[1]-viewportXywh[1]);
} }
//! Get the horizontal viewport offset in pixels. //! Get the horizontal viewport offset in pixels.
int getViewportPosX(void) const {return viewportXywh[0];} int getViewportPosX() const {return viewportXywh[0];}
//! Get the vertical viewport offset in pixels. //! Get the vertical viewport offset in pixels.
int getViewportPosY(void) const {return viewportXywh[1];} int getViewportPosY() const {return viewportXywh[1];}
//! Get the viewport width in pixels. //! Get the viewport width in pixels.
int getViewportWidth(void) const {return viewportXywh[2];} int getViewportWidth() const {return viewportXywh[2];}
//! Get the viewport height in pixels. //! Get the viewport height in pixels.
int getViewportHeight(void) const {return viewportXywh[3];} int getViewportHeight() const {return viewportXywh[3];}
//! Return a convex polygon on the sphere which includes the viewpor t in the current frame. //! Return a convex polygon on the sphere which includes the viewpor t in the current frame.
//! @param marginX an extra margin in pixel which extends the polygo n size in the X direction. //! @param marginX an extra margin in pixel which extends the polygo n size in the X direction.
//! @param marginY an extra margin in pixel which extends the polygo n size in the Y direction. //! @param marginY an extra margin in pixel which extends the polygo n size in the Y direction.
//! @return a SphericalConvexPolygon or the special fullSky region i f the viewport cannot be //! @return a SphericalConvexPolygon or the special fullSky region i f the viewport cannot be
//! represented by a convex polygon (e.g. if aperture > 180 deg). //! represented by a convex polygon (e.g. if aperture > 180 deg).
SphericalRegionP getViewportConvexPolygon(double marginX=0., double marginY=0.) const; SphericalRegionP getViewportConvexPolygon(float marginX=0., float ma rginY=0.) const;
//! Return a Halfspace containing the whole viewport //! Return a SphericalCap containing the whole viewport
SphericalCap getBoundingSphericalCap() const; const SphericalCap& getBoundingCap() const {return boundingCap;}
//! Get size of a radian in pixels at the center of the viewport dis k //! Get size of a radian in pixels at the center of the viewport dis k
double getPixelPerRadAtCenter(void) const {return pixelPerRad;} float getPixelPerRadAtCenter() const {return pixelPerRad;}
//! Get the current FOV diameter in degree //! Get the current FOV diameter in degree
double getFov() const {return 360./M_PI*viewScalingFactorToFov(0.5*v iewportFovDiameter/pixelPerRad);} float getFov() const {return 360.f/M_PI*viewScalingFactorToFov(0.5f* viewportFovDiameter/pixelPerRad);}
//! Get whether front faces need to be oriented in the clockwise dir ection //! Get whether front faces need to be oriented in the clockwise dir ection
bool needGlFrontFaceCW(void) const {return (flipHorz*flipVert < 0.0) ;} bool needGlFrontFaceCW() const {return (flipHorz*flipVert < 0.f);}
//////////////////////////////////////////////////////////////////// /////// //////////////////////////////////////////////////////////////////// ///////
// Full projection methods // Full projection methods
//! Check to see if a 2d position is inside the viewport. //! Check to see if a 2d position is inside the viewport.
//! TODO Optimize by storing viewportXywh[1] + viewportXywh[3] and v iewportXywh[0] + viewportXywh[2] already computed //! TODO Optimize by storing viewportXywh[1] + viewportXywh[3] and v iewportXywh[0] + viewportXywh[2] already computed
bool checkInViewport(const Vec3d& pos) const bool checkInViewport(const Vec3d& pos) const
{ {
return (pos[1]>=viewportXywh[1] && pos[0]>=viewportXywh[0] & & return (pos[1]>=viewportXywh[1] && pos[0]>=viewportXywh[0] & &
pos[1]<=(viewportXywh[1] + viewportXywh[3]) && pos[0 ]<=(viewportXywh[0] + viewportXywh[2])); pos[1]<=(viewportXywh[1] + viewportXywh[3]) && pos[0 ]<=(viewportXywh[0] + viewportXywh[2]));
} }
//! Check to see if a 2d position is inside the viewport.
//! TODO Optimize by storing viewportXywh[1] + viewportXywh[3] and v
iewportXywh[0] + viewportXywh[2] already computed
bool checkInViewport(const Vec3f& pos) const
{
return (pos[1]>=viewportXywh[1] && pos[0]>=viewportXywh[0] &
&
pos[1]<=(viewportXywh[1] + viewportXywh[3]) && pos[0
]<=(viewportXywh[0] + viewportXywh[2]));
}
//! Return the position where the 2 2D point p1 and p2 cross the vie wport edge //! Return the position where the 2 2D point p1 and p2 cross the vie wport edge
//! P1 must be inside the viewport and P2 outside (check with checkI nViewport() before calling this method) //! P1 must be inside the viewport and P2 outside (check with checkI nViewport() before calling this method)
Vec3d viewPortIntersect(const Vec3d& p1, const Vec3d& p2) const Vec3d viewPortIntersect(const Vec3d& p1, const Vec3d& p2) const
{ {
Vec3d v1=p1; Vec3d v1=p1;
Vec3d v2=p2; Vec3d v2=p2;
Vec3d v; Vec3d v;
for (int i=0;i<8;++i) for (int i=0;i<8;++i)
{ {
v=(v1+v2)*0.5; v=(v1+v2)*0.5;
skipping to change at line 183 skipping to change at line 194
//! Project the vector v from the current frame into the viewport. //! Project the vector v from the current frame into the viewport.
//! @param v the vector in the current frame. //! @param v the vector in the current frame.
//! @param win the projected vector in the viewport 2D frame. //! @param win the projected vector in the viewport 2D frame.
//! @return true if the projected coordinate is valid. //! @return true if the projected coordinate is valid.
inline bool project(const Vec3d& v, Vec3d& win) const inline bool project(const Vec3d& v, Vec3d& win) const
{ {
win = v; win = v;
return projectInPlace(win); return projectInPlace(win);
} }
//! Project the vector v from the current frame into the viewport.
//! @param v the vector in the current frame.
//! @param win the projected vector in the viewport 2D frame.
//! @return true if the projected coordinate is valid.
inline bool project(const Vec3f& v, Vec3f& win) const
{
win = v;
return projectInPlace(win);
}
virtual void project(int n, const Vec3d* in, Vec3f* out) virtual void project(int n, const Vec3d* in, Vec3f* out)
{ {
Vec3d v; Vec3d v;
for (int i = 0; i < n; ++i) for (int i = 0; i < n; ++i, ++out)
{ {
v = in[i]; v = in[i];
v.transfo4d(modelViewMatrix); v.transfo4d(modelViewMatrix);
forward(v); out->set(v[0], v[1], v[2]);
out[i][0] = viewportCenter[0] + flipHorz * pixelPerR forward(*out);
ad * v[0]; out->set(viewportCenter[0] + flipHorz * pixelPerRad
out[i][1] = viewportCenter[1] + flipVert * pixelPerR * (*out)[0],
ad * v[1]; viewportCenter[1] + flipVert * pixelPerRad *
out[i][2] = (v[2] - zNear) * oneOverZNearMinusZFar; (*out)[1],
((*out)[2] - zNear) * oneOverZNearMinusZFar)
;
}
}
virtual void project(int n, const Vec3f* in, Vec3f* out)
{
for (int i = 0; i < n; ++i, ++out)
{
*out=in[i];
out->transfo4d(modelViewMatrixf);
forward(*out);
out->set(viewportCenter[0] + flipHorz * pixelPerRad
* (*out)[0],
viewportCenter[1] + flipVert * pixelPerRad *
(*out)[1],
((*out)[2] - zNear) * oneOverZNearMinusZFar)
;
} }
} }
//! Project the vector v from the current frame into the viewport. //! Project the vector v from the current frame into the viewport.
//! @param vd the vector in the current frame.
//! @return true if the projected coordinate is valid.
inline bool projectInPlace(Vec3d& vd) const
{
vd.transfo4d(modelViewMatrix);
Vec3f v(vd[0], vd[1], vd[2]);
const bool rval = forward(v);
// very important: even when the projected point comes from
an
// invisible region of the sky (rval=false), we must finish
// reprojecting, so that OpenGl can successfully eliminate
// polygons by culling.
vd[0] = viewportCenter[0] + flipHorz * pixelPerRad * v[0];
vd[1] = viewportCenter[1] + flipVert * pixelPerRad * v[1];
vd[2] = (v[2] - zNear) * oneOverZNearMinusZFar;
return rval;
}
//! Project the vector v from the current frame into the viewport.
//! @param v the vector in the current frame. //! @param v the vector in the current frame.
//! @return true if the projected coordinate is valid. //! @return true if the projected coordinate is valid.
inline bool projectInPlace(Vec3d& v) const inline bool projectInPlace(Vec3f& v) const
{ {
v.transfo4d(modelViewMatrix); v.transfo4d(modelViewMatrixf);
const bool rval = forward(v); const bool rval = forward(v);
// very important: even when the projected point comes from an // very important: even when the projected point comes from an
// invisible region of the sky (rval=false), we must finish // invisible region of the sky (rval=false), we must finish
// reprojecting, so that OpenGl can successfully eliminate // reprojecting, so that OpenGl can successfully eliminate
// polygons by culling. // polygons by culling.
v[0] = viewportCenter[0] + flipHorz * pixelPerRad * v[0]; v[0] = viewportCenter[0] + flipHorz * pixelPerRad * v[0];
v[1] = viewportCenter[1] + flipVert * pixelPerRad * v[1]; v[1] = viewportCenter[1] + flipVert * pixelPerRad * v[1];
v[2] = (v[2] - zNear) * oneOverZNearMinusZFar; v[2] = (v[2] - zNear) * oneOverZNearMinusZFar;
return rval; return rval;
} }
//! Project the vector v from the current frame into the viewport. //! Project the vector v from the current frame into the viewport.
//! @param v the direction vector in the current frame. Does not nee d to be normalized. //! @param v the direction vector in the current frame. Does not nee d to be normalized.
//! @param win the projected vector in the viewport 2D frame. win[0] and win[1] are in screen pixels, win[2] is unused. //! @param win the projected vector in the viewport 2D frame. win[0] and win[1] are in screen pixels, win[2] is unused.
//! @return true if the projected point is inside the viewport. //! @return true if the projected point is inside the viewport.
bool projectCheck(const Vec3d& v, Vec3d& win) const {return (project (v, win) && checkInViewport(win));} bool projectCheck(const Vec3d& v, Vec3d& win) const {return (project (v, win) && checkInViewport(win));}
//! Project the vector v from the current frame into the viewport.
//! @param v the direction vector in the current frame. Does not nee
d to be normalized.
//! @param win the projected vector in the viewport 2D frame. win[0]
and win[1] are in screen pixels, win[2] is unused.
//! @return true if the projected point is inside the viewport.
bool projectCheck(const Vec3f& v, Vec3f& win) const {return (project
(v, win) && checkInViewport(win));}
//! Project the vector v from the viewport frame into the current fr ame. //! Project the vector v from the viewport frame into the current fr ame.
//! @param win the vector in the viewport 2D frame. win[0] and win[1 ] are in screen pixels, win[2] is unused. //! @param win the vector in the viewport 2D frame. win[0] and win[1 ] are in screen pixels, win[2] is unused.
//! @param v the unprojected direction vector in the current frame. //! @param v the unprojected direction vector in the current frame.
//! @return true if the projected coordinate is valid. //! @return true if the projected coordinate is valid.
bool unProject(const Vec3d& win, Vec3d& v) const {return unProject(w in[0], win[1], v);} bool unProject(const Vec3d& win, Vec3d& v) const {return unProject(w in[0], win[1], v);}
bool unProject(double x, double y, Vec3d& v) const; bool unProject(double x, double y, Vec3d& v) const;
//! Project the vectors v1 and v2 from the current frame into the vi ewport. //! Project the vectors v1 and v2 from the current frame into the vi ewport.
//! @param v1 the first vector in the current frame. //! @param v1 the first vector in the current frame.
//! @param v2 the second vector in the current frame. //! @param v2 the second vector in the current frame.
//! @param win1 the first projected vector in the viewport 2D frame. //! @param win1 the first projected vector in the viewport 2D frame.
//! @param win2 the second projected vector in the viewport 2D frame . //! @param win2 the second projected vector in the viewport 2D frame .
//! @return true if at least one of the projected vector is within t he viewport. //! @return true if at least one of the projected vector is within t he viewport.
bool projectLineCheck(const Vec3d& v1, Vec3d& win1, const Vec3d& v2, Vec3d& win2) const bool projectLineCheck(const Vec3d& v1, Vec3d& win1, const Vec3d& v2, Vec3d& win2) const
{return project(v1, win1) && project(v2, win2) && (checkInVi ewport(win1) || checkInViewport(win2));} {return project(v1, win1) && project(v2, win2) && (checkInVi ewport(win1) || checkInViewport(win2));}
//! Get the current model view matrix. //! Get the current model view matrix.
const Mat4d& getModelViewMatrix() const {return modelViewMatrix;} const Mat4d& getModelViewMatrix() const {return modelViewMatrix;}
//! Get the current projection matrix. //! Get the current projection matrix.
Mat4f getProjectionMatrix() const {return Mat4f(2./viewportXywh[2], 0, 0, 0, 0, 2./viewportXywh[3], 0, 0, 0, 0, -1., 0., -(2.f*viewportXywh[0] + viewportXywh[2])/viewportXywh[2], -(2.f*viewportXywh[1] + viewportXywh[3] )/viewportXywh[3], 0, 1);} Mat4f getProjectionMatrix() const {return Mat4f(2.f/viewportXywh[2], 0, 0, 0, 0, 2.f/viewportXywh[3], 0, 0, 0, 0, -1., 0., -(2.f*viewportXywh[0 ] + viewportXywh[2])/viewportXywh[2], -(2.f*viewportXywh[1] + viewportXywh[ 3])/viewportXywh[3], 0, 1);}
//////////////////////////////////////////////////////////////////// /////// //////////////////////////////////////////////////////////////////// ///////
//! Get a string description of a StelProjectorMaskType. //! Get a string description of a StelProjectorMaskType.
static const QString maskTypeToString(StelProjectorMaskType type); static const QString maskTypeToString(StelProjectorMaskType type);
//! Get a StelProjectorMaskType from a string description. //! Get a StelProjectorMaskType from a string description.
static StelProjectorMaskType stringToMaskType(const QString &s); static StelProjectorMaskType stringToMaskType(const QString &s);
//! Get the current type of the mask if any. //! Get the current type of the mask if any.
StelProjectorMaskType getMaskType(void) const {return maskType;} StelProjectorMaskType getMaskType(void) const {return maskType;}
protected: protected:
//! Private constructor. Only StelCore can create instances of StelP rojector. //! Private constructor. Only StelCore can create instances of StelP rojector.
StelProjector(const Mat4d& modelViewMat) : modelViewMatrix(modelView StelProjector(const Mat4d& modelViewMat) : modelViewMatrix(modelView
Mat) {;} Mat),
modelViewMatrixf(modelViewMat[0], modelViewMat[1], modelView
Mat[2], modelViewMat[3],
modelViewMat[4], modelViewM
at[5], modelViewMat[6], modelViewMat[7],
modelViewMat[8], modelViewM
at[9], modelViewMat[10], modelViewMat[11],
modelViewMat[12], modelView
Mat[13], modelViewMat[14], modelViewMat[15]) {;}
//! Return whether the projection presents discontinuities. Used for optimization. //! Return whether the projection presents discontinuities. Used for optimization.
virtual bool hasDiscontinuity() const =0; virtual bool hasDiscontinuity() const =0;
//! Determine whether a great circle connection p1 and p2 intersects with a projection discontinuity. //! Determine whether a great circle connection p1 and p2 intersects with a projection discontinuity.
//! For many projections without discontinuity, this should return a lways false, but for other like //! For many projections without discontinuity, this should return a lways false, but for other like
//! cylindrical projection it will return true if the line cuts the wrap-around line (i.e. at lon=180 if the observer look at lon=0). //! cylindrical projection it will return true if the line cuts the wrap-around line (i.e. at lon=180 if the observer look at lon=0).
virtual bool intersectViewportDiscontinuityInternal(const Vec3d& p1, const Vec3d& p2) const = 0; virtual bool intersectViewportDiscontinuityInternal(const Vec3d& p1, const Vec3d& p2) const = 0;
Mat4d modelViewMatrix; // openGL MODELVIEW Matrix //! Determine whether a cap intersects with a projection discontinui
double flipHorz,flipVert; // Whether to flip in horizontal or v ty.
ertical directions virtual bool intersectViewportDiscontinuityInternal(const Vec3d& cap
double pixelPerRad; // pixel per rad at the center of the N, double capD) const = 0;
viewport disk
StelProjectorMaskType maskType; // The current projector mask //! Initialize the bounding cap.
double zNear, oneOverZNearMinusZFar; // Near and far clipping plane virtual void computeBoundingCap();
s
Vec4i viewportXywh; // Viewport parameters Mat4d modelViewMatrix; // openGL MODELVIEW Matr
Vec2d viewportCenter; // Viewport center in screen pixel ix
double viewportFovDiameter; // diameter of the FOV disk in pixel Mat4f modelViewMatrixf; // openGL MODELVIEW Matrix
bool gravityLabels; // should label text align with the h float flipHorz,flipVert; // Whether to flip in horizontal
orizon? or vertical directions
float pixelPerRad; // pixel per rad at the center o
f the viewport disk
StelProjectorMaskType maskType; // The current projector mask
float zNear, oneOverZNearMinusZFar; // Near and far clipping planes
Vec4i viewportXywh; // Viewport parameters
Vec2f viewportCenter; // Viewport center in screen pix
el
float viewportFovDiameter; // diameter of the FOV disk in p
ixel
bool gravityLabels; // should label text align with
the horizon?
SphericalCap boundingCap; // Bounding cap of the whole vie
wport
private: private:
//! Initialise the StelProjector from a param instance //! Initialise the StelProjector from a param instance.
void init(const StelProjectorParams& param); void init(const StelProjectorParams& param);
}; };
#endif // _STELPROJECTOR_HPP_ #endif // _STELPROJECTOR_HPP_
 End of changes. 32 change blocks. 
66 lines changed or deleted 159 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/