Merge lp:~georg-zotti/stellarium/gz_milkyway-extinction into lp:stellarium

[Alexander Wolf]

I finally managed to add extinction to the Milky Way (and other extended objects could have the same now.) I added some comments where the new items are, these will be cleaned up during merge. I had to change the Milky Way texture (now half the size without loss of function).

[Fabien Chéreau (xalioth)]

Hi, thanks for the contribution!
Somehow I'm a bit afraid by the large change and the impact on
performances...

I wonder if there is not a much simpler way more in line with the way
refraction was done, I.e. process extinction more at projection time by
passing the vertex color in the project function.

Fabien
Le 17 oct. 2014 16:29, "gzotti" <email address hidden> a écrit :

> gzotti has proposed merging
> lp:~georg-zotti/stellarium/gz_milkyway-extinction into lp:stellarium.
>
> Commit message:
> Extinction for Milky Way
>
> Requested reviews:
> Stellarium (stellarium)
>
> For more details, see:
>
> https://code.launchpad.net/~georg-zotti/stellarium/gz_milkyway-extinction/+merge/238721
>
> I finally managed to add extinction to the Milky Way (and other extended
> objects could have the same now.) I added some comments where the new items
> are, these will be cleaned up during merge. I had to change the Milky Way
> texture (now half the size without loss of function).
>
>
> --
>
> https://code.launchpad.net/~georg-zotti/stellarium/gz_milkyway-extinction/+merge/238721
> You are subscribed to branch lp:stellarium.
>
> === modified file 'src/core/RefractionExtinction.hpp'
> --- src/core/RefractionExtinction.hpp 2013-11-15 14:34:44 +0000
> +++ src/core/RefractionExtinction.hpp 2014-10-17 14:28:29 +0000
> @@ -45,7 +45,7 @@
> class Extinction
> {
> public:
> - //! Define the extinction strategy for rendering underground
> objects (usefull when ground is not rendered)
> + //! Define the extinction strategy for rendering underground
> objects (useful when ground is not rendered)
> enum UndergroundExtinctionMode {
> UndergroundExtinctionZero = 0, //!< Zero extinction:
> stars visible in full brightness
> UndergroundExtinctionMax = 1, //!< Maximum extinction:
> coef 42, i.e practically invisible
>
> === modified file 'src/core/StelCore.hpp'
> --- src/core/StelCore.hpp 2014-10-05 11:32:51 +0000
> +++ src/core/StelCore.hpp 2014-10-17 14:28:29 +0000
> @@ -198,6 +198,7 @@
> Vec3d altAzToJ2000(const Vec3d& v, RefractionMode
> refMode=RefractionAuto) const;
> Vec3d j2000ToAltAz(const Vec3d& v, RefractionMode
> refMode=RefractionAuto) const;
> void j2000ToAltAzInPlaceNoRefraction(Vec3f* v) const
> {v->transfo4d(matJ2000ToAltAz);}
> + void j2000ToAltAzInPlaceNoRefraction(Vec3d* v) const
> {v->transfo4d(matJ2000ToAltAz);} // GZ NEW for milky way
> Vec3d galacticToJ2000(const Vec3d& v) const;
> Vec3d equinoxEquToJ2000(const Vec3d& v) const;
> Vec3d j2000ToEquinoxEqu(const Vec3d& v) const;
>
> === modified file 'src/core/StelPainter.cpp'
> --- src/core/StelPainter.cpp 2014-06-06 04:26:56 +0000
> +++ src/core/StelPainter.cpp 2014-10-17 14:28:29 +0000
> @@ -699,7 +699,7 @@
> // Project the passed triangle on the screen ensuring that it will look
> smooth, even for non linear distortion
> // by splitting it into subtriangles.
> void StelPainter::projectSphericalTriangle(const SphericalCap*
> clippingCap, const Vec3d* vertices, QVarLengthArray<Vec3f, 4096>*
> outVertices,
> - const Vec2f* texturePos, QVarLengthAr...

[Alexander Wolf (alexwolf)]

It's a very good feature! I checked the performance but this parameter not changed on my linux-box.

review: Approve

[gzotti (georg-zotti)]

Fabien, do you mean in StelPainter::projectArray() or even prj->project()? At this step we need azimuthal coordinates, I don't see how I could extract those from this overall projection to viewport. Where can this be done?

The longest change in code was the required extension of StelPainter into actually being able to use vertex color arrays - the shader was already here, but StelVertexArray had no color array.

I had to increase Milky Way vertex density for better accuracy, but decreased overall spherical coverage by removing half of the texture (the black parts at the poles) and so also removed about half the required vertices.

I don't know how often update() is called. If less frequently than draw() but still every few frames, the extinction loop could also go there.

I will try to test equal setups of trunk vs. this for performance comparison.

[Fabien Chéreau (xalioth)]

Well in fact you are right, there is no other easy way to deal with a color modulation, excepted maybe by computing the extinction directly in the vertex shader (by revert projecting the 2D vertices to get the original 3D vertex).

So the remaining comments are more minor ones:
 - please avoid to add // GZ in comments, it doesn't makes sense to the reader in the long term
 - please cleanup debug stuff
 - For simplicity I would also avoid the draw a ring but rather the full sphere with the higher resolution texture. We would really need a better 1024x512 milky way texture by the way. I do have one from mellinger that I re-processed that he allowed us to use. I'll send it to you by email.

[gzotti (georg-zotti)]

OK. Settings: all default, debug builds. Today evening, Stereographic, 138°fov, FullHD, NVidia GTX580M.

Original trunk, 20x20 vertices, : 97fps. Atmosphere off: 108fps.

Milky Way with 72x18: 79fps
Milky Way with 48x15: 86fps
Milky Way with 45x15: 87fps
Milky Way with 40x15: 88fps (same. All figures went up/down by about +/- 1fps.)
Atmosphere off: 108fps
Putting the extinction loop in update(): no noticeable change (Is update called for every frame?)

So I think somewhere 40x15 should stay, if not better. This means a grid of 9x6 degrees, I would not want to go anywhere larger given the fast increase of extinction below 10 degrees. Yes, there is a penalty with the new function, but in the release builds I usually had almost 200fps, so I think there is ample reserve. But if there is a faster way, I don't see it, please show it to me.
Would it be useful to add a configuration option for this? I mean, extinction is one of the hi-quality features of this program, so it should be applied to all visible objects.

[gzotti (georg-zotti)]

Most of the "GZs" are to be removed during merge. They are just to show where I have changed things or explain things to reviewers. Is it OK to remove MilkyWay.cpp:912ff, the original X/Y/Z rotations?

The texture resolution was only 512x512. Removing black parts leave 512x256. Replacing the sphere by the ring avoids about half of the vertices which are only black, so I do think this makes sense. But yes, a higher res drop-in replacement texture would be very welcome!

[gzotti (georg-zotti)]

I think it looks fine now. Any further objections?

review: Needs Resubmitting

[Alexander Wolf (alexwolf)]

I think this branch ready for merge. Maybe here required some calibration for brightness of Milky Way, but it can be solved in trunk.

review: Approve

[Fabien Chéreau (xalioth)]

I'm still not quite fond of the ring trick as it will make it harder for people to change the milky way map, some people like to use other images such as infrared maps etc..

What about we keep it simple for now with a full sphere, and try to optimize the nominal code rather than this way?

[Fabien Chéreau (xalioth)]

review: Needs Information

[gzotti (georg-zotti)]

Hu?

I am now using your new texture, and must therefore use a full sphere.
Although I would prefer the ring with a reprojected texture without poles.

G.

[Fabien Chéreau (xalioth)]

Ooops, I read too quickly. then in this case fine for me for merging,
thanks!

On Mon, Oct 27, 2014 at 10:30 PM, gzotti <email address hidden> wrote:

> Hu?
>
> I am now using your new texture, and must therefore use a full sphere.
> Although I would prefer the ring with a reprojected texture without poles.
>
> G.
>
>
> --
>
> https://code.launchpad.net/~georg-zotti/stellarium/gz_milkyway-extinction/+merge/239766
> You are reviewing the proposed merge of
> lp:~georg-zotti/stellarium/gz_milkyway-extinction into lp:stellarium.
>

[gzotti (georg-zotti)]

Of course I agree :-) I will cleanup some intermediate lines after merge.

review: Approve

=== modified file 'src/core/RefractionExtinction.hpp'
--- src/core/RefractionExtinction.hpp	2013-11-15 14:34:44 +0000
+++ src/core/RefractionExtinction.hpp	2014-10-27 19:13:24 +0000
@@ -45,7 +45,7 @@
 class Extinction
 {
 public:
-	//! Define the extinction strategy for rendering underground objects (usefull when ground is not rendered)
+	//! Define the extinction strategy for rendering underground objects (useful when ground is not rendered)
 	enum UndergroundExtinctionMode {
 		UndergroundExtinctionZero = 0,	//!< Zero extinction: stars visible in full brightness
 		UndergroundExtinctionMax = 1,   //!< Maximum extinction: coef 42, i.e practically invisible

=== modified file 'src/core/StelObject.cpp'
--- src/core/StelObject.cpp	2014-10-26 11:18:06 +0000
+++ src/core/StelObject.cpp	2014-10-27 19:13:24 +0000
@@ -100,7 +100,7 @@
 	Vec3d altAzPos = getAltAzPosGeometric(core);
 	altAzPos.normalize();
 	float vMag = getVMagnitude(core);
-	// GZ 2014-01-02: without the test, planets flicker stupidly in fullsky atmosphere-less view.
+	// without the test, planets flicker stupidly in fullsky atmosphere-less view.
 	if (core->getSkyDrawer()->getFlagHasAtmosphere())
 		core->getSkyDrawer()->getExtinction().forward(altAzPos, &vMag);
 	return vMag;

=== modified file 'src/core/StelObject.hpp'
--- src/core/StelObject.hpp	2014-07-31 10:51:23 +0000
+++ src/core/StelObject.hpp	2014-10-27 19:13:24 +0000
@@ -134,7 +134,7 @@
 	virtual float getVMagnitude(const StelCore* core) const;
 	
 	//! Return object's apparent V magnitude as seen from observer including extinction.
-	//! GZ 2014-01-02: Extinction obviously only if atmosphere=on.
+	//! Extinction obviously only if atmosphere=on.
 	float getVMagnitudeWithExtinction(const StelCore* core) const;
 
 	//! Return a priority value which is used to discriminate objects by priority

=== modified file 'src/core/StelPainter.cpp'
--- src/core/StelPainter.cpp	2014-06-06 04:26:56 +0000
+++ src/core/StelPainter.cpp	2014-10-27 19:13:24 +0000
@@ -699,7 +699,7 @@
 // Project the passed triangle on the screen ensuring that it will look smooth, even for non linear distortion
 // by splitting it into subtriangles.
 void StelPainter::projectSphericalTriangle(const SphericalCap* clippingCap, const Vec3d* vertices, QVarLengthArray<Vec3f, 4096>* outVertices,
-		const Vec2f* texturePos, QVarLengthArray<Vec2f, 4096>* outTexturePos,
+		const Vec2f* texturePos, QVarLengthArray<Vec2f, 4096>* outTexturePos, const Vec3f *colors, QVarLengthArray<Vec3f, 4096> *outColors,
 		const double maxSqDistortion, const int nbI, const bool checkDisc1, const bool checkDisc2, const bool checkDisc3) const
 {
 	Q_ASSERT(fabs(vertices[0].length()-1.)<0.00001);
@@ -758,6 +758,8 @@
 		outVertices->append(Vec3f(e0[0], e0[1], e0[2])); outVertices->append(Vec3f(e1[0], e1[1], e1[2])); outVertices->append(Vec3f(e2[0], e2[1], e2[2]));
 		if (outTexturePos)
 			outTexturePos->append(texturePos,3);
+		if (outColors)
+			outColors->append(colors,3);
 		return;
 	}
 
@@ -772,6 +774,8 @@
 		outVertices->append(Vec3f(e0[0], e0[1], e0[2])); outVertices->append(Vec3f(e1[0], e1[1], e2[2])); outVertices->append(Vec3f(e2[0], e2[1], e2[2]));
 		if (outTexturePos)
 			outTexturePos->append(texturePos,3);
+		if (outColors)
+			outColors->append(colors,3);
 		return;
 	}
 
@@ -779,6 +783,7 @@
 	// Depending on which combination of sides of the triangle has to be split a different strategy is used.
 	Vec3d va[3];
 	Vec2f ta[3];
+	Vec3f ca[3];
 	// Only 1 side has to be split: split the triangle in 2
 	if (cDiscontinuity1 && !cDiscontinuity2 && !cDiscontinuity3)
 	{
@@ -792,7 +797,13 @@
 			ta[1]=(texturePos[0]+texturePos[1])*0.5;
 			ta[2]=texturePos[2];
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, true, true, false);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=(colors[0]+colors[1])*0.5;
+			ca[2]=colors[2];
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, true, true, false);
 
 		//va[0]=vertices[0]+vertices[1];
 		//va[0].normalize();
@@ -805,7 +816,13 @@
 			ta[1]=texturePos[1];
 			ta[2]=texturePos[2];
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, true, false, true);
+		if (outColors)
+		{
+			ca[0]=(colors[0]+colors[1])*0.5;
+			ca[1]=colors[1];
+			ca[2]=colors[2];
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, true, false, true);
 		return;
 	}
 
@@ -821,7 +838,13 @@
 			ta[1]=texturePos[1];
 			ta[2]=(texturePos[1]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, false, true, true);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=colors[1];
+			ca[2]=(colors[1]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, false, true, true);
 
 		va[0]=vertices[0];
 		//va[1]=vertices[1]+vertices[2];
@@ -834,7 +857,13 @@
 			ta[1]=(texturePos[1]+texturePos[2])*0.5;
 			ta[2]=texturePos[2];
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, true, true, false);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=(colors[1]+colors[2])*0.5;
+			ca[2]=colors[2];
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, true, true, false);
 		return;
 	}
 
@@ -850,7 +879,13 @@
 			ta[1]=texturePos[1];
 			ta[2]=(texturePos[0]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, false, true, true);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=colors[1];
+			ca[2]=(colors[0]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, false, true, true);
 
 		//va[0]=vertices[0]+vertices[2];
 		//va[0].normalize();
@@ -863,7 +898,13 @@
 			ta[1]=texturePos[1];
 			ta[2]=texturePos[2];
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, true, false, true);
+		if (outColors)
+		{
+			ca[0]=(colors[0]+colors[2])*0.5;
+			ca[1]=colors[1];
+			ca[2]=colors[2];
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, true, false, true);
 		return;
 	}
 
@@ -881,7 +922,13 @@
 			ta[1]=(texturePos[0]+texturePos[1])*0.5;
 			ta[2]=(texturePos[1]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=(colors[0]+colors[1])*0.5;
+			ca[2]=(colors[1]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 		//va[0]=vertices[0]+vertices[1];
 		//va[0].normalize();
@@ -895,7 +942,13 @@
 			ta[1]=texturePos[1];
 			ta[2]=(texturePos[1]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+		if (outColors)
+		{
+			ca[0]=(colors[0]+colors[1])*0.5;
+			ca[1]=colors[1];
+			ca[2]=(colors[1]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 		va[0]=vertices[0];
 		//va[1]=vertices[1]+vertices[2];
@@ -908,7 +961,13 @@
 			ta[1]=(texturePos[1]+texturePos[2])*0.5;
 			ta[2]=texturePos[2];
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, true, true, false);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=(colors[1]+colors[2])*0.5;
+			ca[2]=colors[2];
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, true, true, false);
 		return;
 	}
 	if (cDiscontinuity1 && !cDiscontinuity2 && cDiscontinuity3)
@@ -924,7 +983,13 @@
 			ta[1]=(texturePos[0]+texturePos[1])*0.5;
 			ta[2]=(texturePos[0]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=(colors[0]+colors[1])*0.5;
+			ca[2]=(colors[0]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 		//va[0]=vertices[0]+vertices[1];
 		//va[0].normalize();
@@ -938,7 +1003,13 @@
 			ta[1]=texturePos[2];
 			ta[2]=(texturePos[0]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+		if (outColors)
+		{
+			ca[0]=(colors[0]+colors[1])*0.5;
+			ca[1]=colors[2];
+			ca[2]=(colors[0]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 
 		//va[0]=vertices[0]+vertices[1];
@@ -951,7 +1022,13 @@
 			ta[1]=texturePos[1];
 			ta[2]=texturePos[2];
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, true, false, true);
+		if (outColors)
+		{
+			ca[0]=(colors[0]+colors[1])*0.5;
+			ca[1]=colors[1];
+			ca[2]=colors[2];
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, true, false, true);
 
 		return;
 	}
@@ -967,7 +1044,13 @@
 			ta[1]=texturePos[1];
 			ta[2]=(texturePos[1]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1, false, true, true);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=colors[1];
+			ca[2]=(colors[1]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1, false, true, true);
 
 		//va[0]=vertices[1]+vertices[2];
 		//va[0].normalize();
@@ -981,7 +1064,13 @@
 			ta[1]=texturePos[2];
 			ta[2]=(texturePos[0]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+		if (outColors)
+		{
+			ca[0]=(colors[1]+colors[2])*0.5;
+			ca[1]=colors[2];
+			ca[2]=(colors[0]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 		va[1]=va[0];
 		va[0]=vertices[0];
@@ -995,7 +1084,13 @@
 			ta[1]=(texturePos[1]+texturePos[2])*0.5;
 			ta[2]=(texturePos[0]+texturePos[2])*0.5;
 		}
-		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+		if (outColors)
+		{
+			ca[0]=colors[0];
+			ca[1]=(colors[1]+colors[2])*0.5;
+			ca[2]=(colors[0]+colors[2])*0.5;
+		}
+		projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 		return;
 	}
 
@@ -1012,7 +1107,13 @@
 		ta[1]=(texturePos[1]+texturePos[2])*0.5;
 		ta[2]=(texturePos[0]+texturePos[2])*0.5;
 	}
-	projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+	if (outColors)
+	{
+		ca[0]=(colors[0]+colors[1])*0.5;
+		ca[1]=(colors[1]+colors[2])*0.5;
+		ca[2]=(colors[0]+colors[2])*0.5;
+	}
+	projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 	va[1]=va[0];
 	va[0]=vertices[0];
@@ -1026,7 +1127,13 @@
 		ta[1]=(texturePos[0]+texturePos[1])*0.5;
 		ta[2]=(texturePos[0]+texturePos[2])*0.5;
 	}
-	projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+	if (outColors)
+	{
+		ca[0]=colors[0];
+		ca[1]=(colors[0]+colors[1])*0.5;
+		ca[2]=(colors[0]+colors[2])*0.5;
+	}
+	projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 	//va[0]=vertices[0]+vertices[1];
 	//va[0].normalize();
@@ -1040,7 +1147,13 @@
 		ta[1]=texturePos[1];
 		ta[2]=(texturePos[1]+texturePos[2])*0.5;
 	}
-	projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+	if (outColors)
+	{
+		ca[0]=(colors[0]+colors[1])*0.5;
+		ca[1]=colors[1];
+		ca[2]=(colors[1]+colors[2])*0.5;
+	}
+	projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 	va[0]=vertices[0];va[0]+=vertices[2];
 	va[0].normalize();
@@ -1054,13 +1167,20 @@
 		ta[1]=(texturePos[1]+texturePos[2])*0.5;
 		ta[2]=texturePos[2];
 	}
-	projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, maxSqDistortion, nbI+1);
+	if (outColors)
+	{
+		ca[0]=(colors[0]+colors[2])*0.5;
+		ca[1]=(colors[1]+colors[2])*0.5;
+		ca[2]=colors[2];
+	}
+	projectSphericalTriangle(clippingCap, va, outVertices, ta, outTexturePos, ca, outColors, maxSqDistortion, nbI+1);
 
 	return;
 }
 
 static QVarLengthArray<Vec3f, 4096> polygonVertexArray;
 static QVarLengthArray<Vec2f, 4096> polygonTextureCoordArray;
+static QVarLengthArray<Vec3f, 4096> polygonColorArray;
 static QVarLengthArray<unsigned int, 4096> indexArray;
 
 void StelPainter::drawGreatCircleArcs(const StelVertexArray& va, const SphericalCap* clippingCap)
@@ -1097,26 +1217,38 @@
 {
 public:
 	VertexArrayProjector(const StelVertexArray& ar, StelPainter* apainter, const SphericalCap* aclippingCap,
-						 QVarLengthArray<Vec3f, 4096>* aoutVertices, QVarLengthArray<Vec2f, 4096>* aoutTexturePos=NULL, double amaxSqDistortion=5.)
+						 QVarLengthArray<Vec3f, 4096>* aoutVertices, QVarLengthArray<Vec2f, 4096>* aoutTexturePos=NULL, QVarLengthArray<Vec3f, 4096>* aoutColors=NULL, double amaxSqDistortion=5.)
 		   : vertexArray(ar), painter(apainter), clippingCap(aclippingCap), outVertices(aoutVertices),
-			 outTexturePos(aoutTexturePos), maxSqDistortion(amaxSqDistortion)
+			 outColors(aoutColors), outTexturePos(aoutTexturePos), maxSqDistortion(amaxSqDistortion)
 	{
 	}
 
 	// Project a single triangle and add it into the output arrays
 	inline void operator()(const Vec3d* v0, const Vec3d* v1, const Vec3d* v2,
 						   const Vec2f* t0, const Vec2f* t1, const Vec2f* t2,
+						   const Vec3f* c0, const Vec3f* c1, const Vec3f* c2,
 						   unsigned int, unsigned int, unsigned)
 	{
 		// XXX: we may optimize more by putting the declaration and the test outside of this method.
 		const Vec3d tmpVertex[3] = {*v0, *v1, *v2};
-		if (outTexturePos)
-		{
-			const Vec2f tmpTexture[3] = {*t0, *t1, *t2};
-			painter->projectSphericalTriangle(clippingCap, tmpVertex, outVertices, tmpTexture, outTexturePos, maxSqDistortion);
+		if ( (outTexturePos) && (outColors))
+		{
+			const Vec2f tmpTexture[3] = {*t0, *t1, *t2};
+			const Vec3f tmpColor[3] = {*c0, *c1, *c2};
+			painter->projectSphericalTriangle(clippingCap, tmpVertex, outVertices, tmpTexture, outTexturePos, tmpColor, outColors, maxSqDistortion);
+		}
+		else if (outTexturePos)
+		{
+			const Vec2f tmpTexture[3] = {*t0, *t1, *t2};
+			painter->projectSphericalTriangle(clippingCap, tmpVertex, outVertices, tmpTexture, outTexturePos, NULL, NULL, maxSqDistortion);
+		}
+		else if (outColors)
+		{
+			const Vec3f tmpColor[3] = {*c0, *c1, *c2};
+			painter->projectSphericalTriangle(clippingCap, tmpVertex, outVertices, NULL, NULL, tmpColor, outColors, maxSqDistortion);
 		}
 		else
-			painter->projectSphericalTriangle(clippingCap, tmpVertex, outVertices, NULL, NULL, maxSqDistortion);
+			painter->projectSphericalTriangle(clippingCap, tmpVertex, outVertices, NULL, NULL, NULL, NULL, maxSqDistortion);
 	}
 
 	// Draw the resulting arrays
@@ -1125,7 +1257,10 @@
 		painter->setVertexPointer(3, GL_FLOAT, outVertices->constData());
 		if (outTexturePos)
 			painter->setTexCoordPointer(2, GL_FLOAT, outTexturePos->constData());
-		painter->enableClientStates(true, outTexturePos != NULL);
+		if (outColors)
+			painter->setColorPointer(3, GL_FLOAT, outColors->constData());
+
+		painter->enableClientStates(true, outTexturePos != NULL, outColors != NULL);
 		painter->drawFromArray(StelPainter::Triangles, outVertices->size(), 0, false);
 		painter->enableClientStates(false);
 	}
@@ -1135,6 +1270,7 @@
 	StelPainter* painter;
 	const SphericalCap* clippingCap;
 	QVarLengthArray<Vec3f, 4096>* outVertices;
+	QVarLengthArray<Vec3f, 4096>* outColors;
 	QVarLengthArray<Vec2f, 4096>* outTexturePos;
 	double maxSqDistortion;
 };
@@ -1152,11 +1288,23 @@
 	if (arr.isTextured())
 	{
 		setTexCoordPointer(2, GL_FLOAT, arr.texCoords.constData());
-		enableClientStates(true, true);
+		if (arr.isColored())
+		{
+			setColorPointer(3, GL_FLOAT, arr.colors.constData());
+			enableClientStates(true, true, true);
+		}
+		else
+			enableClientStates(true, true, false);
 	}
 	else
 	{
-		enableClientStates(true, false);
+		if (arr.isColored())
+		{
+			setColorPointer(3, GL_FLOAT, arr.colors.constData());
+			enableClientStates(true, false, true);
+		}
+		else
+			enableClientStates(true, false, false);
 	}
 	if (arr.isIndexed())
 		drawFromArray((StelPainter::DrawingMode)arr.primitiveType, arr.indices.size(), 0, true, arr.indices.constData());
@@ -1166,7 +1314,7 @@
 	enableClientStates(false);
 }
 
-void StelPainter::drawSphericalTriangles(const StelVertexArray& va, const bool textured, const SphericalCap* clippingCap, const bool doSubDivide, const double maxSqDistortion)
+void StelPainter::drawSphericalTriangles(const StelVertexArray& va, const bool textured, const bool colored, const SphericalCap* clippingCap, const bool doSubDivide, const double maxSqDistortion)
 {
 	if (va.vertex.isEmpty())
 		return;
@@ -1174,6 +1322,7 @@
 	Q_ASSERT(va.vertex.size()>2);
 	polygonVertexArray.clear();
 	polygonTextureCoordArray.clear();
+
 	indexArray.clear();
 
 	if (!doSubDivide)
@@ -1186,7 +1335,7 @@
 	// the last case.  It is the slowest, it process the triangles one by one.
 	{
 		// Project all the triangles of the VertexArray into our buffer arrays.
-		VertexArrayProjector result = va.foreachTriangle(VertexArrayProjector(va, this, clippingCap, &polygonVertexArray, textured ? &polygonTextureCoordArray : NULL, maxSqDistortion));
+		VertexArrayProjector result = va.foreachTriangle(VertexArrayProjector(va, this, clippingCap, &polygonVertexArray, textured ? &polygonTextureCoordArray : NULL, colored ? &polygonColorArray : NULL, maxSqDistortion));
 		result.drawResult();
 		return;
 	}
@@ -1211,7 +1360,8 @@
 			glEnable(GL_CULL_FACE);
 			// The polygon is already tesselated as triangles
 			if (doSubDivise || prj->intersectViewportDiscontinuity(poly->getBoundingCap()))
-				drawSphericalTriangles(poly->getFillVertexArray(), drawMode==SphericalPolygonDrawModeTextureFill, clippingCap, doSubDivise, maxSqDistortion);
+				// flag for color-modulated textured mode (e.g. for Milky Way/extincted)
+				drawSphericalTriangles(poly->getFillVertexArray(), drawMode>=SphericalPolygonDrawModeTextureFill, drawMode==SphericalPolygonDrawModeTextureFillColormodulated, clippingCap, doSubDivise, maxSqDistortion);
 			else
 				drawStelVertexArray(poly->getFillVertexArray(), false);
 
@@ -1373,7 +1523,7 @@
 
 ///////////////////////////////////////////////////////////////////////////
 // Drawing methods for general (non-linear) mode.
-// GZ This used to draw a full sphere. Now it's possible to have a spherical zone only.
+// This used to draw a full sphere. Since 0.13 it's possible to have a spherical zone only.
 void StelPainter::sSphere(const float radius, const float oneMinusOblateness, const int slices, const int stacks, const int orientInside, const bool flipTexture, const float topAngle, const float bottomAngle)
 {
 	GLfloat x, y, z;
@@ -1394,14 +1544,14 @@
 
 	const float* cos_sin_rho = NULL;
 	Q_ASSERT(topAngle<bottomAngle); // don't forget: These are opening angles counted from top.
-	if ((bottomAngle>3.1415) && (topAngle<0.0001)) // safety margin.
+	if ((bottomAngle>3.1415f) && (topAngle<0.0001f)) // safety margin.
 		cos_sin_rho = StelUtils::ComputeCosSinRho(stacks);
 	else
 	{
 		const float drho = (bottomAngle-topAngle) / stacks; // deltaRho:  originally just 180degrees/stacks, now the range clamped.
 		cos_sin_rho = StelUtils::ComputeCosSinRhoZone(drho, stacks, M_PI-bottomAngle);
 	}
-	// GZ: Allow parameters so that pole regions may remain free.
+	// Allow parameters so that pole regions may remain free.
 	const float* cos_sin_rho_p;
 
 	const float* cos_sin_theta = StelUtils::ComputeCosSinTheta(slices);
@@ -1414,7 +1564,7 @@
 	const GLfloat ds = (flipTexture ? -1.f : 1.f) / slices;
 	const GLfloat dt = nsign / stacks; // from inside texture is reversed
 
-	// draw intermediate  as quad strips
+	// draw intermediate as quad strips
 	static QVector<double> vertexArr;
 	static QVector<float> texCoordArr;
 	static QVector<float> colorArr;
@@ -1456,7 +1606,8 @@
 	drawFromArray(Triangles, indiceArr.size(), 0, true, indiceArr.constData());
 }
 
-StelVertexArray StelPainter::computeSphereNoLight(const float radius, const float oneMinusOblateness, const int slices, const int stacks, const int orientInside, const bool flipTexture)
+StelVertexArray StelPainter::computeSphereNoLight(const float radius, const float oneMinusOblateness, const int slices, const int stacks,
+						  const int orientInside, const bool flipTexture, const float topAngle, const float bottomAngle)
 {
 	StelVertexArray result(StelVertexArray::Triangles);
 	GLfloat x, y, z;
@@ -1474,7 +1625,16 @@
 		t=1.f;
 	}
 
-	const float* cos_sin_rho = StelUtils::ComputeCosSinRho(stacks);
+	const float* cos_sin_rho = NULL; //StelUtils::ComputeCosSinRho(stacks);
+	Q_ASSERT(topAngle<bottomAngle); // don't forget: These are opening angles counted from top.
+	if ((bottomAngle>3.1415f) && (topAngle<0.0001f)) // safety margin.
+		cos_sin_rho = StelUtils::ComputeCosSinRho(stacks);
+	else
+	{
+		const float drho = (bottomAngle-topAngle) / stacks; // deltaRho:  originally just 180degrees/stacks, now the range clamped.
+		cos_sin_rho = StelUtils::ComputeCosSinRhoZone(drho, stacks, M_PI-bottomAngle);
+	}
+	// Allow parameters so that pole regions may remain free.
 	const float* cos_sin_rho_p;
 
 	const float* cos_sin_theta = StelUtils::ComputeCosSinTheta(slices);
@@ -1487,7 +1647,7 @@
 	const GLfloat ds = (flipTexture ? -1.f : 1.f) / slices;
 	const GLfloat dt = nsign / stacks; // from inside texture is reversed
 
-	// draw intermediate  as quad strips
+	// draw intermediate as quad strips
 	for (i = 0,cos_sin_rho_p = cos_sin_rho; i < stacks; ++i,cos_sin_rho_p+=2)
 	{
 		s = !flipTexture ? 0.f : 1.f;

=== modified file 'src/core/StelPainter.hpp'
--- src/core/StelPainter.hpp	2014-06-10 19:20:20 +0000
+++ src/core/StelPainter.hpp	2014-10-27 19:13:24 +0000
@@ -45,9 +45,10 @@
 	//! Define the drawing mode when drawing polygons
 	enum SphericalPolygonDrawMode
 	{
-		SphericalPolygonDrawModeFill=0,			//!< Draw the interior of the polygon
-		SphericalPolygonDrawModeBoundary=1,		//!< Draw the boundary of the polygon
-		SphericalPolygonDrawModeTextureFill=2	//!< Draw the interior of the polygon filled with the current texture
+		SphericalPolygonDrawModeFill=0,				//!< Draw the interior of the polygon
+		SphericalPolygonDrawModeBoundary=1,			//!< Draw the boundary of the polygon
+		SphericalPolygonDrawModeTextureFill=2,			//!< Draw the interior of the polygon filled with the current texture
+		SphericalPolygonDrawModeTextureFillColormodulated=3	//!< Draw the interior of the polygon filled with the current texture multiplied by vertex colors
 	};
 
 	//! Define the drawing mode when drawing vertex
@@ -97,7 +98,7 @@
 
 	void drawGreatCircleArcs(const StelVertexArray& va, const SphericalCap* clippingCap=NULL);
 
-	void drawSphericalTriangles(const StelVertexArray& va, const bool textured, const SphericalCap* clippingCap=NULL, const bool doSubDivide=true, const double maxSqDistortion=5.);
+	void drawSphericalTriangles(const StelVertexArray& va, const bool textured, const bool colored, const SphericalCap* clippingCap=NULL, const bool doSubDivide=true, const double maxSqDistortion=5.);
 
 	//! Draw a small circle arc between points start and stop with rotation point in rotCenter.
 	//! The angle between start and stop must be < 180 deg.
@@ -165,7 +166,7 @@
 	//! @param slices: number of vertical segments ("meridian zones")
 	//! @param stacks: number of horizontal segments ("latitude zones")
 	//! @param orientInside: 1 to have normals point inside, e.g. for landscape horizons
-	//! @param flipTexture: if texture should be mapped to inside of shere, e.g. landscape horizons.
+	//! @param flipTexture: if texture should be mapped to inside of sphere, e.g. landscape horizons.
 	//! @param topAngle GZ: new parameter. An opening angle [radians] at top of the sphere. Useful if there is an empty
 	//!        region around the top pole, like for a spherical equirectangular horizon panorama (@class SphericalLandscape).
 	//!        Example: your horizon line (pano photo) goes up to 26 degrees altitude (highest mountains/trees):
@@ -178,8 +179,19 @@
 				 const float topAngle=0.0f, const float bottomAngle=M_PI);
 
 	//! Generate a StelVertexArray for a sphere.
+	//! @param radius
+	//! @param oneMinusOblateness
+	//! @param slices: number of vertical segments ("meridian zones")
+	//! @param stacks: number of horizontal segments ("latitude zones")
+	//! @param orientInside: 1 to have normals point inside, e.g. for Milky Way, Zodiacal Light, etc.
+	//! @param flipTexture: if texture should be mapped to inside of sphere, e.g. Milky Way.
+	//! @param topAngle GZ: new parameter. An opening angle [radians] at top of the sphere. Useful if there is an empty
+	//!        region around the top pole, like North Galactic Pole.
+	//! @param bottomAngle GZ: new parameter. An opening angle [radians] at bottom of the sphere. Useful if there is an empty
+	//!        region around the bottom pole, like South Galactic Pole.
 	static StelVertexArray computeSphereNoLight(const float radius, const float oneMinusOblateness, const int slices, const int stacks,
-												const int orientInside = 0, const bool flipTexture = false);
+						    const int orientInside = 0, const bool flipTexture = false,
+						    const float topAngle=0.0f, const float bottomAngle=M_PI);
 
 	//! Re-implementation of gluCylinder : glu is overridden for non-standard projection.
 	void sCylinder(const float radius, const float height, const int slices, const int orientInside = 0);
@@ -304,8 +316,11 @@
 	//! @param vertices a pointer to an array of 3 vertices.
 	//! @param edgeFlags a pointer to an array of 3 flags indicating whether the next segment is an edge.
 	//! @param texturePos a pointer to an array of 3 texture coordinates, or NULL if the triangle should not be textured.
+	//! @param colors a pointer to an array of 3 colors, or NULL if the triangle should not be vertex-colored. If texture and color coords are present, texture is modulated by vertex colors. (e.g. extinction)
 	void projectSphericalTriangle(const SphericalCap* clippingCap, const Vec3d* vertices, QVarLengthArray<Vec3f, 4096>* outVertices,
-			const Vec2f* texturePos=NULL, QVarLengthArray<Vec2f, 4096>* outTexturePos=NULL, const double maxSqDistortion=5., const int nbI=0,
+			const Vec2f* texturePos=NULL, QVarLengthArray<Vec2f, 4096>* outTexturePos=NULL,
+			const Vec3f* colors=NULL, QVarLengthArray<Vec3f, 4096>* outColors=NULL,
+			const double maxSqDistortion=5., const int nbI=0,
 			const bool checkDisc1=true, const bool checkDisc2=true, const bool checkDisc3=true) const;
 
 	void drawTextGravity180(float x, float y, const QString& str, const float xshift = 0, const float yshift = 0);

=== modified file 'src/core/StelProjector.hpp'
--- src/core/StelProjector.hpp	2014-04-18 19:29:32 +0000
+++ src/core/StelProjector.hpp	2014-10-27 19:13:24 +0000
@@ -45,7 +45,7 @@
 	//! Shared pointer on a ModelViewTranform instance (implement reference counting)
 	typedef QSharedPointer<ModelViewTranform> ModelViewTranformP;
 
-	//! @class PreModelViewFunc
+	//! @class ModelViewTranform
 	//! Allows to define non linear operations in addition to the standard linear (Matrix 4d) ModelView transformation.
 	class ModelViewTranform
 	{

=== modified file 'src/core/StelSphereGeometry.cpp'
--- src/core/StelSphereGeometry.cpp	2014-04-19 09:40:17 +0000
+++ src/core/StelSphereGeometry.cpp	2014-10-27 19:13:24 +0000
@@ -709,7 +709,8 @@
 
 	TriangleSerializer() {}
 	inline void operator()(const Vec3d* v1, const Vec3d* v2, const Vec3d* v3,
-						   const Vec2f* , const Vec2f* , const Vec2f* ,
+			       const Vec2f* , const Vec2f* , const Vec2f* ,
+			       const Vec3f* , const Vec3f* , const Vec3f* , // GZ NEW
 						   unsigned int , unsigned int , unsigned int )
 	{
 		QVariantList triangle;
@@ -1151,7 +1152,8 @@
 
 	TriangleDumper() {}
 	inline void operator()(const Vec3d* v1, const Vec3d* v2, const Vec3d* v3,
-						   const Vec2f* , const Vec2f* , const Vec2f* ,
+			       const Vec2f* , const Vec2f* , const Vec2f* ,
+			       const Vec3f* , const Vec3f* , const Vec3f* , // GZ NEW
 						   unsigned int , unsigned int , unsigned int )
 	{
 		QVector<Vec3d> triangle;

=== modified file 'src/core/StelSphereGeometry.hpp'
--- src/core/StelSphereGeometry.hpp	2014-02-20 15:07:04 +0000
+++ src/core/StelSphereGeometry.hpp	2014-10-27 19:13:24 +0000
@@ -284,7 +284,7 @@
 	//! @param an a unit vector indicating the direction.
 	//! @param ar cosinus of the aperture.
 	SphericalCap(const Vec3d& an, double ar) : n(an), d(ar) {//n.normalize();
-															 Q_ASSERT(d==0 || std::fabs(n.lengthSquared()-1.)<0.0000001);}
+		Q_ASSERT(d==0 || std::fabs(n.lengthSquared()-1.)<0.0000001);}
 	// FIXME: GZ reports 2013-03-02: apparently the Q_ASSERT is here because n should be normalized at this point, but
 	// for efficiency n.normalize() should not be called at this point.
 	// However, when zooming in a bit in Hammer-Aitoff and Mercator projections, this Assertion fires.

=== modified file 'src/core/StelUtils.cpp'
--- src/core/StelUtils.cpp	2014-10-26 11:18:06 +0000
+++ src/core/StelUtils.cpp	2014-10-27 19:13:24 +0000
@@ -546,13 +546,11 @@
 	*lng = atan2(v[1],v[0]);
 }
 
-// GZ: some additions. I need those just for quick conversions for text display.
 void ctRadec2Ecl(const double raRad, const double decRad, const double eclRad, double *lambdaRad, double *betaRad)
 {
 	*lambdaRad=std::atan2(std::sin(raRad)*std::cos(eclRad)+std::tan(decRad)*std::sin(eclRad), std::cos(raRad));
 	*betaRad=std::asin(std::sin(decRad)*std::cos(eclRad)-std::cos(decRad)*std::sin(eclRad)*std::sin(raRad));
 }
-// GZ: done
 
 double getDecAngle(const QString& str)
 {
@@ -1265,8 +1263,6 @@
 	// "Five Millennium Canon of Solar Eclipses" [Espenak and Meeus, 2006]
 	// A summary is described here:
 	// http://eclipse.gsfc.nasa.gov/SEhelp/deltatpoly2004.html
-	// GZ: I replaced the std::pow() calls by Horner's scheme with reversed factors, it's more accurate and efficient.
-	//     Old code left for readability, but can also be deleted.
 
 	double y = year+((month-1)*30.5+day/31*30.5)/366;
 
@@ -1532,7 +1528,7 @@
 
 // Implementation of algorithm by JPL Horizons for DeltaT computation
 double getDeltaTByJPLHorizons(const double jDay)
-{ // GZ: TODO: FIXME! It does not make sense to have zeros after 1620 in a JPL Horizons compatible implementation!
+{ // TODO: FIXME! It does not make sense to have zeros after 1620 in a JPL Horizons compatible implementation!
 	int year, month, day;
 	double u;
 	double deltaT = 0.;
@@ -1716,16 +1712,16 @@
 }
 
 // Implementation of algorithm by Reingold & Dershowitz (Cal. Calc. 1997, 2001, 2007, Cal. Tab. 2002) for DeltaT computation.
-// GZ: Created as yet another multi-segment polynomial fit through the table in Meeus: Astronomical Algorithms (1991).
-// GZ: Note that only the Third edition (2007) adds the 1700-1799 term.
-// GZ: More efficient reimplementation with stricter adherence to the source.
+// Created as yet another multi-segment polynomial fit through the table in Meeus: Astronomical Algorithms (1991).
+// Note that only the Third edition (2007) adds the 1700-1799 term.
+// More efficient reimplementation with stricter adherence to the source.
 double getDeltaTByReingoldDershowitz(const double jDay)
 {
 	int year, month, day;	
 	getDateFromJulianDay(jDay, &year, &month, &day);
-	// GZ: R&D don't use a float-fraction year, but explicitly only the integer year! And R&D use a proleptic Gregorian year before 1582.
-	// GZ: We cannot do that, but the difference is negligible.
-	// GZ: FIXME: why are displayed values so far off the computed values? It seems currently broken!
+	// R&D don't use a float-fraction year, but explicitly only the integer year! And R&D use a proleptic Gregorian year before 1582.
+	// We cannot do that, but the difference is negligible.
+	// FIXME: why are displayed values so far off the computed values? It seems currently broken!
 	double deltaT=0.0; // If it returns 0, there is a bug!
 
 	if ((year >= 2019) || (year < 1620))
@@ -1945,7 +1941,7 @@
 //! Compute cosines and sines around part of a circle (from top to bottom) which is split in "segments" parts.
 //! Values are stored in the global static array cos_sin_rho.
 //! Used for the sin/cos values along a meridian.
-//! GZ: allow leaving away pole caps. The array now contains values for the region minAngle+segments*phi
+//! This allows leaving away pole caps. The array now contains values for the region minAngle+segments*phi
 //! @param dRho a difference angle between the stops
 //! @param segments number of segments
 //! @param minAngle start angle inside the half-circle. maxAngle=minAngle+segments*phi

=== modified file 'src/core/StelUtils.hpp'
--- src/core/StelUtils.hpp	2014-10-26 11:18:06 +0000
+++ src/core/StelUtils.hpp	2014-10-27 19:13:24 +0000
@@ -174,10 +174,8 @@
 	//! @param v the input 3D vector
 	void rectToSphe(float *lng, float *lat, const Vec3f& v);
 
-	// GZ: some additions. I need those just for quick conversions for text display.
 	//! Coordinate Transformation from equatorial to ecliptical
 	void ctRadec2Ecl(const double raRad, const double decRad, const double eclRad, double *lambdaRad, double *betaRad);
-	// GZ: done
 
 	//! Convert a string longitude, latitude, RA or Declination angle
 	//! to radians.
@@ -611,7 +609,7 @@
 	//! Compute cosines and sines around part of a circle (from top to bottom) which is split in "segments" parts.
 	//! Values are stored in the global static array cos_sin_rho.
 	//! Used for the sin/cos values along a meridian.
-	//! GZ: allow leaving away pole caps. The array now contains values for the region minAngle+segments*phi
+	//! This allows leaving away pole caps. The array now contains values for the region minAngle+segments*phi
 	//! @param dRho a difference angle between the stops
 	//! @param segments number of segments
 	//! @param minAngle start angle inside the half-circle. maxAngle=minAngle+segments*phi

=== modified file 'src/core/StelVertexArray.cpp'
--- src/core/StelVertexArray.cpp	2014-04-06 12:19:27 +0000
+++ src/core/StelVertexArray.cpp	2014-10-27 19:13:24 +0000
@@ -100,7 +100,7 @@
 				Q_ASSERT(false);
 		}
 	}
-	// Just in case we don't have any triangles, we also remove all the vertex.
+	// Just in case we don't have any triangles, we also remove all the vertices.
 	// This is because we can't specify an empty indexed VertexArray.
 	// FIXME: we should use an attribute for indexed array.
 	if (ret.indices.isEmpty())
@@ -114,6 +114,7 @@
 {
 	out << p.vertex;
 	out << p.texCoords;
+	out << p.colors; // GZ NEW
 	out << p.indices;
 	out << (unsigned int)p.primitiveType;
 	return out;
@@ -123,6 +124,7 @@
 {
 	in >> p.vertex;
 	in >> p.texCoords;
+	in >> p.colors; // GZ NEW
 	in >> p.indices;
 	unsigned int t;
 	in >> t;

=== modified file 'src/core/StelVertexArray.hpp'
--- src/core/StelVertexArray.hpp	2014-02-18 06:36:58 +0000
+++ src/core/StelVertexArray.hpp	2014-10-27 19:13:24 +0000
@@ -49,6 +49,9 @@
 	QVector<Vec3d> vertex;
 	//! OpenGL compatible array of edge flags to be displayed using vertex arrays.
 	QVector<Vec2f> texCoords;
+	//! OpenGL compatible array of vertex colors to be displayed using arrays. (GZ/NEW)
+	//! The color (if exists) shall be multiplied with texture to modulate e.g. for extinction of Milky Way or other large items.
+	QVector<Vec3f> colors;
 	//! OpenGL compatible array of indices for the vertex and the textures
 	QVector<unsigned short> indices;
 
@@ -58,20 +61,24 @@
 
 	bool isTextured() const {return !texCoords.isEmpty();}
 
+	bool isColored() const {return !colors.isEmpty();}
+
+
 	//! call a function for each triangle of the array.
-	//! func should define the following method :
-	//!     void operator() (const Vec3d* vertex[3], const Vec2f* tex[3], unsigned int indices[3])
+	//! func should define the following method : // GZ NEW: colors
+	//!     void operator() (const Vec3d* vertex[3], const Vec2f* tex[3], const Vec3f* colors[3], unsigned int indices[3])
 	//! The method takes arrays of *pointers* as arguments because we can't assume the values are contiguous
 	template<class Func>
 	inline Func foreachTriangle(Func func) const;
 
-	//! Create a copy of the array with all the triangles intersecting the projector discontinuty removed.
+	//! Create a copy of the array with all the triangles intersecting the projector discontinuity removed.
 	StelVertexArray removeDiscontinuousTriangles(const class StelProjector* prj) const;
 
 private:
 	// Below we define a few methods that are templated to be optimized according to different types of VertexArray :
 	// The template parameter <bool T> defines whether the array has a texture.
 	// The template parameter <bool I> defines whether the array is indexed.
+	// The template parameter <bool C> defines whether the array is colored. // NEW GZ
 	template <bool I>
 	const Vec3d* specVertexAt(int i) const {
 		return &vertex.at(specIndiceAt<I>(i));
@@ -82,12 +89,18 @@
 		return T ? &texCoords.at(specIndiceAt<I>(i)) : NULL;
 	}
 
+	// NEW GZ
+	template <bool C, bool I>
+	const Vec3f* specColorAt(int i) const {
+		return C ? &colors.at(specIndiceAt<I>(i)) : NULL;
+	}
+
 	template<bool I>
 	unsigned int specIndiceAt(unsigned int i) const {
 		return I ? indices.at(i) : i;
 	}
 
-	template<bool T, bool I, class Func>
+	template<bool T, bool I, bool C, class Func> // GZ added bool C
 	inline Func specForeachTriangle(Func func) const;
 
 };
@@ -99,23 +112,49 @@
 template<class Func>
 Func StelVertexArray::foreachTriangle(Func func) const
 {
-	// Here we just dispach the method into one of the 4 possible cases
+	// Here we just dispatch the method into one of the 8 possible cases // GZ NEW: 8, not 4, cases
 	bool textured = isTextured();
+	bool colored  = isColored();
 	bool useIndice = isIndexed();
 
 	if (textured)
-		if (useIndice)
-			return specForeachTriangle<true, true, Func>(func);
-		else
-			return specForeachTriangle<true, false, Func>(func);
-	else
-		if (useIndice)
-			return specForeachTriangle<false, true, Func>(func);
-		else
-			return specForeachTriangle<false, false, Func>(func);
+	{
+		if (useIndice)
+		{
+			if (colored)
+				return specForeachTriangle<true, true, true, Func>(func);
+			else
+				return specForeachTriangle<true, true, false, Func>(func);
+		}
+		else // not indiced
+		{
+			if (colored)
+				return specForeachTriangle<true, false, true, Func>(func);
+			else
+				return specForeachTriangle<true, false, false, Func>(func);
+		}
+	}
+	else // not textured
+	{
+		if (useIndice)
+		{
+			if (colored)
+				return specForeachTriangle<false, true, true, Func>(func);
+			else
+				return specForeachTriangle<false, true, false, Func>(func);
+		}
+		else // not indiced
+		{
+			if (colored)
+				return specForeachTriangle<false, false, true, Func>(func);
+			else
+				return specForeachTriangle<false, false, false, Func>(func);
+		}
+	}
+	Q_ASSERT(0); // GZ. Just make sure...
 }
 
-template<bool T, bool I, class Func>
+template<bool T, bool I, bool C, class Func>
 Func StelVertexArray::specForeachTriangle(Func func) const
 {
 	switch (primitiveType)
@@ -126,6 +165,7 @@
 			{
 				func(specVertexAt<I>(i), specVertexAt<I>(i+1), specVertexAt<I>(i+2),
 					 specTexCoordAt<T, I>(i), specTexCoordAt<T, I>(i+1), specTexCoordAt<T, I>(i+2),
+					 specColorAt<C, I>(i), specColorAt<C, I>(i+1), specColorAt<C, I>(i+2),
 					 specIndiceAt<I>(i), specIndiceAt<I>(i+1), specIndiceAt<I>(i+2));
 			}
 			break;
@@ -133,12 +173,14 @@
 		{
 			const Vec3d* v0 = specVertexAt<I>(0);
 			const Vec2f* t0 = specTexCoordAt<T, I>(0);
+			const Vec3f* c0 = specColorAt<C, I>(0);
 			unsigned int i0 = specIndiceAt<I>(0);
 			for (int i = 1; i < vertex.size() - 1; ++i)
 			{
 				func(v0, specVertexAt<I>(i), specVertexAt<I>(i+1),
 					 t0, specTexCoordAt<T, I>(i), specTexCoordAt<T, I>(i+1),
-					 i0, specIndiceAt<I>(i), specIndiceAt<I>(i+1));
+					 c0, specColorAt<C, I>(i),    specColorAt<C, I>(i+1),
+					 i0, specIndiceAt<I>(i),      specIndiceAt<I>(i+1));
 			}
 			break;
 		}
@@ -149,16 +191,18 @@
 				if (i % 2 == 0)
 					func(specVertexAt<I>(i-2), specVertexAt<I>(i-1), specVertexAt<I>(i),
 						 specTexCoordAt<T, I>(i-2), specTexCoordAt<T, I>(i-1), specTexCoordAt<T, I>(i),
+						 specColorAt<C, I>(i-2), specColorAt<C, I>(i-1), specColorAt<C, I>(i),
 						 specIndiceAt<I>(i-2), specIndiceAt<I>(i-1), specIndiceAt<I>(i));
 				else
 					func(specVertexAt<I>(i-1), specVertexAt<I>(i-2), specVertexAt<I>(i),
 						 specTexCoordAt<T, I>(i-1), specTexCoordAt<T, I>(i-2), specTexCoordAt<T, I>(i),
+						 specColorAt<C, I>(i-1), specColorAt<C, I>(i-2), specColorAt<C, I>(i),
 						 specIndiceAt<I>(i-1), specIndiceAt<I>(i-2), specIndiceAt<I>(i));
 			}
 			break;
 		}
 		default:
-			Q_ASSERT_X(0, Q_FUNC_INFO, "unsuported primitive type");
+			Q_ASSERT_X(0, Q_FUNC_INFO, "unsupported primitive type");
 	}
 	return func;
 }

=== modified file 'src/core/modules/Landscape.cpp'
--- src/core/modules/Landscape.cpp	2014-10-25 00:04:08 +0000
+++ src/core/modules/Landscape.cpp	2014-10-27 19:13:24 +0000
@@ -589,7 +589,7 @@
 		if (side.light==drawLight)
 		{
 			side.tex->bind();
-			sPainter.drawSphericalTriangles(side.arr, true, NULL, false);
+			sPainter.drawSphericalTriangles(side.arr, true, false, NULL, false);
 		}
 	}
 }

=== modified file 'src/core/modules/MilkyWay.cpp'
--- src/core/modules/MilkyWay.cpp	2014-04-15 17:10:07 +0000
+++ src/core/modules/MilkyWay.cpp	2014-10-27 19:13:24 +0000
@@ -1,6 +1,7 @@
 /*
  * Stellarium
  * Copyright (C) 2002 Fabien Chereau
+ * Copyright (C) 2014 Georg Zotti (extinction parts)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -58,15 +59,35 @@
 	QSettings* conf = StelApp::getInstance().getSettings();
 	Q_ASSERT(conf);
 
-	tex = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/milkyway.png");
+	//tex = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/milkyway.png");
+	tex = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/milkyway_2048.png");
 	setFlagShow(conf->value("astro/flag_milky_way").toBool());
 	setIntensity(conf->value("astro/milky_way_intensity",1.f).toFloat());
-
-	vertexArray = new StelVertexArray(StelPainter::computeSphereNoLight(1.f,1.f,20,20,1));
-}
-
-
-void MilkyWay::update(double deltaTime) {fader->update((int)(deltaTime*1000));}
+	// GZ: I cut the original milkyway.png 512x512 to 512x256. Center line was shifted southwards by 32 pixels to keep Magellanic Clouds visible.
+	// 256px were 90 degrees. 128:45, 64:22.5, 32:11.25. So this spherical ring goes from -45-11.25 to 45-11.25.
+
+	// A new texture was provided by Fabien. Better resolution, but in equatorial coordinates. I had to enhance it a bit, and shift it by 90 degrees.
+	// GZ: Note that a full sphere (i.e., a texture not aligned to galactic coordinates) costs performance!
+	//vertexArray = new StelVertexArray(StelPainter::computeSphereNoLight(1.f,1.f,45,15,1, true, (90.0f-33.75f)*M_PI/180.0f, (90.0f+56.25f)*M_PI/180.0f)); // GZ orig: slices=stacks=20.
+	vertexArray = new StelVertexArray(StelPainter::computeSphereNoLight(1.f,1.f,45,15,1, true)); // GZ orig: slices=stacks=20.
+	vertexArray->colors.resize(vertexArray->vertex.length());
+	vertexArray->colors.fill(Vec3f(1.0, 0.3, 0.9));
+
+	// If we have a texture in galactic coordinates, we can transform the vertex coordinates already here.
+	// The texture had to be rotated/flipped and shifted compared to 0.13.0
+//	StelCore* core=StelApp::getInstance().getCore();
+//	for (int i=0; i<vertexArray->vertex.size(); ++i)
+//	{
+//		Vec3d tmp=vertexArray->vertex.at(i);
+//		vertexArray->vertex.replace(i, core->galacticToJ2000(tmp));
+//	}
+}
+
+
+void MilkyWay::update(double deltaTime)
+{
+	fader->update((int)(deltaTime*1000));
+}
 
 void MilkyWay::setFlagShow(bool b){*fader = b;}
 bool MilkyWay::getFlagShow() const {return *fader;}
@@ -77,27 +98,36 @@
 		return;
 
 	StelProjector::ModelViewTranformP transfo = core->getJ2000ModelViewTransform();
-	transfo->combine(Mat4d::xrotation(M_PI/180.*23.)*
-					 Mat4d::yrotation(M_PI/180.*120.)*
-					 Mat4d::zrotation(M_PI/180.*7.));
+	// GZ: No idea where this came from. Empirical correction? Now the vertices have been replaced already in init().
+	// (the "official" angles are not integers...)
+//	transfo->combine(Mat4d::xrotation(M_PI/180.*23.)*
+//					 Mat4d::yrotation(M_PI/180.*120.)*
+//					 Mat4d::zrotation(M_PI/180.*7.));
 
-	const StelProjectorP prj = core->getProjection(transfo);
+	const StelProjectorP prj = core->getProjection(transfo); // GZ: Maybe this can now be simplified?
 	StelToneReproducer* eye = core->getToneReproducer();
 
 	Q_ASSERT(tex);	// A texture must be loaded before calling this
 
 	// This RGB color corresponds to the night blue scotopic color = 0.25, 0.25 in xyY mode.
 	// since milky way is always seen white RGB value in the texture (1.0,1.0,1.0)
-	Vec3f c = Vec3f(0.34165f, 0.429666f, 0.63586f);
+	// Vec3f c = Vec3f(0.34165f, 0.429666f, 0.63586f);
+	// GZ: This is the same color, just brighter to have Blue=1.
+	Vec3f c = Vec3f(0.53730381f, .675724216f, 1.0f);
 
-	float lum = core->getSkyDrawer()->surfacebrightnessToLuminance(13.5f);
+	float lum = core->getSkyDrawer()->surfacebrightnessToLuminance(13.5f); // Source? How to calibrate the new texture?
 
 	// Get the luminance scaled between 0 and 1
 	float aLum =eye->adaptLuminanceScaled(lum*fader->getInterstate());
 
-	// Bound a maximum luminance
+	// Bound a maximum luminance. GZ: Is there any reference/reason, or just trial and error?
 	aLum = qMin(0.38f, aLum*2.f);
 
+	// GZ I have the impression we must also adjust milky way to light pollution.
+	// Is there any way to calibrate this?
+	int bortle=core->getSkyDrawer()->getBortleScaleIndex();
+	aLum*=(11.0f-bortle)*0.1f;
+
 	// intensity of 1.0 is "proper", but allow boost for dim screens
 	c*=aLum*intensity;
 
@@ -105,8 +135,31 @@
 	if (c[1]<0) c[1]=0;
 	if (c[2]<0) c[2]=0;
 
+	const bool withExtinction=(core->getSkyDrawer()->getFlagHasAtmosphere() && core->getSkyDrawer()->getExtinction().getExtinctionCoefficient()>=0.01f);
+
+	if (withExtinction)
+	{
+		// We must process the vertices to find geometric altitudes in order to compute vertex colors.
+		// Note that there is a visible boost of extinction for higher Bortle indices. I must reflect that as well.
+		Extinction extinction=core->getSkyDrawer()->getExtinction();
+		vertexArray->colors.clear();
+
+		for (int i=0; i<vertexArray->vertex.size(); ++i)
+		{
+			Vec3d vertAltAz=core->j2000ToAltAz(vertexArray->vertex.at(i), StelCore::RefractionOn);
+			Q_ASSERT(vertAltAz.lengthSquared()-1.0 < 0.001f);
+
+			float oneMag=0.0f;
+			extinction.forward(vertAltAz, &oneMag);
+			float extinctionFactor=std::pow(0.4f , oneMag) * (1.0f-bortle*0.1f); // drop of one magnitude: factor 2.5 or 40%
+			Vec3f thisColor=Vec3f(c[0]*extinctionFactor, c[1]*extinctionFactor, c[2]*extinctionFactor);
+			vertexArray->colors.append(thisColor);
+		}
+	}
+	else
+		vertexArray->colors.fill(Vec3f(c[0], c[1], c[2]));
+
 	StelPainter sPainter(prj);
-	sPainter.setColor(c[0],c[1],c[2]);
 	glEnable(GL_CULL_FACE);
 	sPainter.enableTexture2d(true);
 	glDisable(GL_BLEND);

=== modified file 'src/core/modules/MilkyWay.hpp'
--- src/core/modules/MilkyWay.hpp	2014-04-15 17:10:07 +0000
+++ src/core/modules/MilkyWay.hpp	2014-10-27 19:13:24 +0000
@@ -71,7 +71,7 @@
 	
 private:
 	StelTextureSP tex;
-	Vec3f color;
+	Vec3f color; // global color
 	float intensity;
 	class LinearFader* fader;
 

=== modified file 'src/core/modules/Nebula.hpp'
--- src/core/modules/Nebula.hpp	2014-04-06 14:34:01 +0000
+++ src/core/modules/Nebula.hpp	2014-10-27 19:13:24 +0000
@@ -30,6 +30,7 @@
 class StelPainter;
 class QDataStream;
 
+// This only draws nebula icons. For the DSO images, see StelSkylayerMgr and StelSkyImageTile.
 class Nebula : public StelObject
 {
 friend class NebulaMgr;

=== modified file 'src/gui/LocationDialog.hpp'
--- src/gui/LocationDialog.hpp	2014-09-08 12:47:22 +0000
+++ src/gui/LocationDialog.hpp	2014-10-27 19:13:24 +0000
@@ -82,7 +82,7 @@
 	void updateFromProgram(const StelLocation& location);
 	
 	//! Called when the map is clicked.
-	//! GZ_New: create new list for places nearby and feed into location list box.
+	//! create new list for places nearby and feed into location list box.
 	void setPositionFromMap(double longitude, double latitude);
 	
 	//! Called when the user activates an item from the locations list.

=== modified file 'textures/milkyway.png'
Binary files textures/milkyway.png	2005-10-30 19:51:28 +0000 and textures/milkyway.png	2014-10-27 19:13:24 +0000 differ
=== added file 'textures/milkyway_2048.png'
Binary files textures/milkyway_2048.png	1970-01-01 00:00:00 +0000 and textures/milkyway_2048.png	2014-10-27 19:13:24 +0000 differ