Merge lp:~xalioth/stellarium/planet-shadows into lp:stellarium

[Fabien Chéreau]

Re-integrated Jörg's work on planet shadow rendering

[Alexander Wolf (alexwolf)]

This code give strange effect on the Sun in the moment of solar eclipse.

review: Needs Fixing

[lp:~xalioth/stellarium/planet-shadows]

6814. By Fabien Chéreau on 2014-06-04

Don't draw planet when standing on it, even for planet with rings.

6815. By Fabien Chéreau on 2014-06-04

Fixed sun rendering.

6816. By Fabien Chéreau on 2014-06-04

Use new moon eclipse rendering. Got rid of old stencil based code.

[Fabien Chéreau (xalioth)]

Thanks. I fixed this issue. I also improved moon eclipse rendering.

On Wed, Jun 4, 2014 at 7:20 PM, Alexander Wolf <email address hidden>
wrote:

> Review: Needs Fixing
>
> This code give strange effect on the Sun in the moment of solar eclipse.
> --
> https://code.launchpad.net/~xalioth/stellarium/planet-shadows/+merge/221967
> You are the owner of lp:~xalioth/stellarium/planet-shadows.
>

[lp:~xalioth/stellarium/planet-shadows]

6817. By Fabien Chéreau on 2014-06-04

First shader cleanup.

More can probably be done by replacing some trigo with simpler
vector operations.

6818. By Fabien Chéreau on 2014-06-04

Simplified further shader.

=== modified file 'src/core/StelPainter.cpp'
--- src/core/StelPainter.cpp	2014-05-23 22:05:02 +0000
+++ src/core/StelPainter.cpp	2014-06-04 22:13:44 +0000
@@ -226,94 +226,7 @@
 	enableClientStates(false);
 }
 
-// Arrays to keep cos/sin of angles and multiples of angles. rho and theta are delta angles, and these arrays
-#define MAX_STACKS 4096
-static float cos_sin_rho[2*(MAX_STACKS+1)];
-#define MAX_SLICES 4096
-static float cos_sin_theta[2*(MAX_SLICES+1)];
-
-//! Compute cosines and sines around a circle which is split in "segments" parts.
-//! Values are stored in the global static array cos_sin_theta.
-//! Used for the sin/cos values along a latitude circle, equator, etc. for a spherical mesh.
-//! @param dTheta a difference angle between the stops. Always use 2*M_PI/segments!
-//! @param segments number of partitions (elsewhere called "slices") for the circle
-static void ComputeCosSinTheta(const float dTheta, const int segments)
-{
-	float *cos_sin = cos_sin_theta;
-	float *cos_sin_rev = cos_sin + 2*(segments+1);
-	const float c = std::cos(dTheta);
-	const float s = std::sin(dTheta);
-	*cos_sin++ = 1.f;
-	*cos_sin++ = 0.f;
-	*--cos_sin_rev = -cos_sin[-1];
-	*--cos_sin_rev =  cos_sin[-2];
-	*cos_sin++ = c;
-	*cos_sin++ = s;
-	*--cos_sin_rev = -cos_sin[-1];
-	*--cos_sin_rev =  cos_sin[-2];
-	while (cos_sin < cos_sin_rev)   // compares array address indices only!
-	{
-		// avoid expensive trig functions by use of the addition theorem.
-		cos_sin[0] = cos_sin[-2]*c - cos_sin[-1]*s;
-		cos_sin[1] = cos_sin[-2]*s + cos_sin[-1]*c;
-		cos_sin += 2;
-		*--cos_sin_rev = -cos_sin[-1];
-		*--cos_sin_rev =  cos_sin[-2];
-	}
-}
-
-//! Compute cosines and sines around a half-circle 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 for a spherical mesh.
-//! @param dRho a difference angle between the stops. Always use M_PI/segments!
-//! @param segments number of partitions (elsewhere called "stacks") for the half-circle
-static void ComputeCosSinRho(const float dRho, const int segments)
-{
-	float *cos_sin = cos_sin_rho;
-	float *cos_sin_rev = cos_sin + 2*(segments+1);
-	const float c = std::cos(dRho);
-	const float s = std::sin(dRho);
-	*cos_sin++ = 1.f;
-	*cos_sin++ = 0.f;
-	*--cos_sin_rev =  cos_sin[-1];
-	*--cos_sin_rev = -cos_sin[-2];
-	*cos_sin++ = c;
-	*cos_sin++ = s;
-	*--cos_sin_rev =  cos_sin[-1];
-	*--cos_sin_rev = -cos_sin[-2];
-	while (cos_sin < cos_sin_rev)    // compares array address indices only!
-	{
-		// avoid expensive trig functions by use of the addition theorem.
-		cos_sin[0] = cos_sin[-2]*c - cos_sin[-1]*s;
-		cos_sin[1] = cos_sin[-2]*s + cos_sin[-1]*c;
-		cos_sin += 2;
-		*--cos_sin_rev =  cos_sin[-1];
-		*--cos_sin_rev = -cos_sin[-2];
-		// segments--;                       // GZ: WHAT'S THAT GOOD FOR?
-	}
-}
-
-//! 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
-//! @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
-static void ComputeCosSinRhoZone(const float dRho, const int segments, const float minAngle)
-{
-	float *cos_sin = cos_sin_rho;
-	const float c = cos(dRho);
-	const float s = sin(dRho);
-	*cos_sin++ = cos(minAngle);
-	*cos_sin++ = sin(minAngle);
-	for (int i=0; i<segments; ++i) // we cannot mirror this, it may be unequal.
-	{   // efficient computation, avoid expensive trig functions by use of the addition theorem.
-		cos_sin[0] = cos_sin[-2]*c - cos_sin[-1]*s;
-		cos_sin[1] = cos_sin[-2]*s + cos_sin[-1]*c;
-		cos_sin += 2;
-	}
-}
+
 
 void StelPainter::computeFanDisk(float radius, int innerFanSlices, int level, QVector<double>& vertexArr, QVector<float>& texCoordArr)
 {
@@ -326,9 +239,8 @@
 		rad[i] = rad[i+1]*(1.f-M_PI/(innerFanSlices<<(i+1)))*2.f/3.f;
 	}
 	int slices = innerFanSlices<<level;
-	const float dtheta = 2.f * M_PI / slices;
-	Q_ASSERT(slices<=MAX_SLICES);
-	ComputeCosSinTheta(dtheta,slices);
+	
+	float* cos_sin_theta = StelUtils::ComputeCosSinTheta(slices);
 	float* cos_sin_theta_p;
 	int slices_step = 2;
 	float x,y,xa,ya;
@@ -419,83 +331,6 @@
 
 }
 
-void StelPainter::sRing(const float rMin, const float rMax, int slices, const int stacks, const int orientInside)
-{
-	float x,y;
-	int j;
-
-	static Vec3f lightPos3;
-	static Vec4f ambientLight;
-	static Vec4f diffuseLight;
-	float c;
-	const bool isLightOn = light.isEnabled();
-	if (isLightOn)
-	{
-		lightPos3.set(light.getPosition()[0], light.getPosition()[1], light.getPosition()[2]);
-		Vec3f tmpv(0.f);
-		prj->getModelViewTransform()->forward(tmpv); // -posCenterEye
-		//lightPos3 -= tmpv;
-		//lightPos3 = prj->modelViewMatrixf.transpose().multiplyWithoutTranslation(lightPos3);
-		prj->getModelViewTransform()->getApproximateLinearTransfo().transpose().multiplyWithoutTranslation(Vec3d(lightPos3[0], lightPos3[1], lightPos3[2]));
-		prj->getModelViewTransform()->backward(lightPos3);
-		lightPos3.normalize();
-		ambientLight = light.getAmbient();
-		diffuseLight = light.getDiffuse();
-	}
-
-	const float nsign = orientInside?-1.f:1.f;
-
-	const float dr = (rMax-rMin) / stacks;
-	const float dtheta = 2.f * M_PI / slices;
-	if (slices < 0) slices = -slices;
-	Q_ASSERT(slices<=MAX_SLICES);
-	ComputeCosSinTheta(dtheta,slices);
-	float *cos_sin_theta_p;
-
-	static QVector<double> vertexArr;
-	static QVector<float> texCoordArr;
-	static QVector<float> colorArr;
-
-	// draw intermediate stacks as quad strips
-	for (float r = rMin; r < rMax; r+=dr)
-	{
-		const float tex_r0 = (r-rMin)/(rMax-rMin);
-		const float tex_r1 = (r+dr-rMin)/(rMax-rMin);
-		vertexArr.resize(0);
-		texCoordArr.resize(0);
-		colorArr.resize(0);
-		for (j=0,cos_sin_theta_p=cos_sin_theta; j<=slices; ++j,cos_sin_theta_p+=2)
-		{
-			x = r*cos_sin_theta_p[0];
-			y = r*cos_sin_theta_p[1];
-			if (isLightOn)
-			{
-				c = nsign * (lightPos3[0]*x + lightPos3[1]*y);
-				if (c<0) {c=0;}
-				colorArr << c*diffuseLight[0] + ambientLight[0] << c*diffuseLight[1] + ambientLight[1] << c*diffuseLight[2] + ambientLight[2];
-			}
-			texCoordArr << tex_r0 << 0.5f;
-			vertexArr << x << y << 0.f;
-			x = (r+dr)*cos_sin_theta_p[0];
-			y = (r+dr)*cos_sin_theta_p[1];
-			if (isLightOn)
-			{
-				c = nsign * (lightPos3[0]*x + lightPos3[1]*y);
-				if (c<0) {c=0;}
-				colorArr << c*diffuseLight[0] + ambientLight[0] << c*diffuseLight[1] + ambientLight[1] << c*diffuseLight[2] + ambientLight[2];
-			}
-			texCoordArr << tex_r1 << 0.5f;
-			vertexArr << x << y << 0.f;
-		}
-
-		if (isLightOn)
-			setArrays((Vec3d*)vertexArr.constData(), (Vec2f*)texCoordArr.constData(), (Vec3f*)colorArr.constData());
-		else
-			setArrays((Vec3d*)vertexArr.constData(), (Vec2f*)texCoordArr.constData());
-		drawFromArray(TriangleStrip, vertexArr.size()/3);
-	}
-}
-
 static void sSphereMapTexCoordFast(float rho_div_fov, const float costheta, const float sintheta, QVector<float>& out)
 {
 	if (rho_div_fov>0.5f)
@@ -507,17 +342,13 @@
 {
 	float rho,x,y,z;
 	int i, j;
+	const float* cos_sin_rho = StelUtils::ComputeCosSinRho(stacks);
+	const float* cos_sin_rho_p;
+
+	const float* cos_sin_theta = StelUtils::ComputeCosSinTheta(slices);
+	const float* cos_sin_theta_p;
+
 	float drho = M_PI / stacks;
-	Q_ASSERT(stacks<=MAX_STACKS);
-	ComputeCosSinRho(drho,stacks);
-	float* cos_sin_rho_p;
-
-	const float dtheta = 2.f * M_PI / slices;
-	Q_ASSERT(slices<=MAX_SLICES);
-
-	ComputeCosSinTheta(dtheta,slices);
-	float* cos_sin_theta_p;
-
 	drho/=textureFov;
 
 	// texturing: s goes from 0.0/0.25/0.5/0.75/1.0 at +y/+x/-y/-x/+y axis
@@ -1546,28 +1377,6 @@
 // GZ This used to draw a full sphere. Now 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)
 {
-	// It is really good for performance to have Vec4f,Vec3f objects
-	// static rather than on the stack. But why?
-	// Is the constructor/destructor so expensive?
-	static Vec3f lightPos3;
-	static Vec4f ambientLight;
-	static Vec4f diffuseLight;
-	float c;
-	const bool isLightOn = light.isEnabled();
-	if (isLightOn)
-	{
-		lightPos3.set(light.getPosition()[0], light.getPosition()[1], light.getPosition()[2]);
-		Vec3f tmpv(0.f);
-		prj->getModelViewTransform()->forward(tmpv); // -posCenterEye
-		//lightPos3 -= tmpv;
-		//lightPos3 = prj->modelViewMatrixf.transpose().multiplyWithoutTranslation(lightPos3);
-		prj->getModelViewTransform()->getApproximateLinearTransfo().transpose().multiplyWithoutTranslation(Vec3d(lightPos3[0], lightPos3[1], lightPos3[2]));
-		prj->getModelViewTransform()->backward(lightPos3);
-		lightPos3.normalize();
-		ambientLight = light.getAmbient();
-		diffuseLight = light.getDiffuse();
-	}
-
 	GLfloat x, y, z;
 	GLfloat s=0.f, t=0.f;
 	GLint i, j;
@@ -1584,20 +1393,19 @@
 		t=1.f;
 	}
 
+	const float* cos_sin_rho = NULL;
 	Q_ASSERT(topAngle<bottomAngle); // don't forget: These are opening angles counted from top.
-	const float drho = (bottomAngle-topAngle) / stacks; // deltaRho:  originally just 180degrees/stacks, now the range clamped.
-	Q_ASSERT(stacks<=MAX_STACKS);
-	//if ((bottomAngle==M_PI) && (topAngle==0))
 	if ((bottomAngle>3.1415) && (topAngle<0.0001)) // safety margin.
-		ComputeCosSinRho(drho, stacks);
+		cos_sin_rho = StelUtils::ComputeCosSinRho(stacks);
 	else
-		ComputeCosSinRhoZone(drho, stacks, M_PI-bottomAngle);
+	{
+		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.
-	float* cos_sin_rho_p;
+	const float* cos_sin_rho_p;
 
-	const float dtheta = 2.f * M_PI / slices;
-	Q_ASSERT(slices<=MAX_SLICES);
-	ComputeCosSinTheta(dtheta,slices);
+	const float* cos_sin_theta = StelUtils::ComputeCosSinTheta(slices);
 	const float *cos_sin_theta_p;
 
 	// texturing: s goes from 0.0/0.25/0.5/0.75/1.0 at +y/+x/-y/-x/+y axis
@@ -1627,23 +1435,11 @@
 			y = cos_sin_theta_p[0] * cos_sin_rho_p[1];
 			z = nsign * cos_sin_rho_p[0];
 			texCoordArr << s << t;
-			if (isLightOn)
-			{
-				c = nsign * (lightPos3[0]*x*oneMinusOblateness + lightPos3[1]*y*oneMinusOblateness + lightPos3[2]*z);
-				if (c<0) {c=0;}
-				colorArr << c*diffuseLight[0] + ambientLight[0] << c*diffuseLight[1] + ambientLight[1] << c*diffuseLight[2] + ambientLight[2];
-			}
 			vertexArr << x * radius << y * radius << z * oneMinusOblateness * radius;
 			x = -cos_sin_theta_p[1] * cos_sin_rho_p[3];
 			y = cos_sin_theta_p[0] * cos_sin_rho_p[3];
 			z = nsign * cos_sin_rho_p[2];
 			texCoordArr << s << t - dt;
-			if (isLightOn)
-			{
-				c = nsign * (lightPos3[0]*x*oneMinusOblateness + lightPos3[1]*y*oneMinusOblateness + lightPos3[2]*z);
-				if (c<0) {c=0;}
-				colorArr << c*diffuseLight[0] + ambientLight[0] << c*diffuseLight[1] + ambientLight[1] << c*diffuseLight[2] + ambientLight[2];
-			}
 			vertexArr << x * radius << y * radius << z * oneMinusOblateness * radius;
 			s += ds;
 		}
@@ -1657,10 +1453,7 @@
 	}
 
 	// Draw the array now
-	if (isLightOn)
-		setArrays((Vec3d*)vertexArr.constData(), (Vec2f*)texCoordArr.constData(), (Vec3f*)colorArr.constData());
-	else
-		setArrays((Vec3d*)vertexArr.constData(), (Vec2f*)texCoordArr.constData());
+	setArrays((Vec3d*)vertexArr.constData(), (Vec2f*)texCoordArr.constData());
 	drawFromArray(Triangles, indiceArr.size(), 0, true, indiceArr.constData());
 }
 
@@ -1682,14 +1475,10 @@
 		t=1.f;
 	}
 
-	const float drho = M_PI / stacks;
-	Q_ASSERT(stacks<=MAX_STACKS);
-	ComputeCosSinRho(drho,stacks);
-	float* cos_sin_rho_p;
+	const float* cos_sin_rho = StelUtils::ComputeCosSinRho(stacks);
+	const float* cos_sin_rho_p;
 
-	const float dtheta = 2.f * M_PI / slices;
-	Q_ASSERT(slices<=MAX_SLICES);
-	ComputeCosSinTheta(dtheta,slices);
+	const float* cos_sin_theta = StelUtils::ComputeCosSinTheta(slices);
 	const float *cos_sin_theta_p;
 
 	// texturing: s goes from 0.0/0.25/0.5/0.75/1.0 at +y/+x/-y/-x/+y axis
@@ -1726,8 +1515,6 @@
 		t -= dt;
 	}
 	return result;
-	//setArrays((Vec3d*)vertexArr.constData(), (Vec2f*)texCoordArr.constData());
-	//drawFromArray(Triangles, indiceArr.size(), 0, true, indiceArr.constData());
 }
 
 // Reimplementation of gluCylinder : glu is overrided for non standard projection
@@ -2018,7 +1805,6 @@
 	else
 	{
 		qDebug() << "Unhandled parameters." << texCoordArray.enabled << colorArray.enabled << normalArray.enabled;
-		qDebug() << "Light: " << light.isEnabled();
 		Q_ASSERT(0);
 		return;
 	}
@@ -2092,42 +1878,3 @@
 	return ret;
 }
 
-// Light methods
-
-void StelPainterLight::setPosition(const Vec4f& v)
-{
-	position = v;
-}
-
-void StelPainterLight::setDiffuse(const Vec4f& v)
-{
-	diffuse = v;
-}
-
-void StelPainterLight::setSpecular(const Vec4f& v)
-{
-	specular = v;
-}
-
-void StelPainterLight::setAmbient(const Vec4f& v)
-{
-	ambient = v;
-}
-
-void StelPainterLight::setEnable(bool v)
-{
-	if (v)
-		enable();
-	else
-		disable();
-}
-
-void StelPainterLight::enable()
-{
-	enabled = true;
-}
-
-void StelPainterLight::disable()
-{
-	enabled = false;
-}

=== modified file 'src/core/StelPainter.hpp'
--- src/core/StelPainter.hpp	2014-05-23 22:05:02 +0000
+++ src/core/StelPainter.hpp	2014-06-04 22:13:44 +0000
@@ -30,38 +30,6 @@
 
 class QOpenGLShaderProgram;
 
-class StelPainterLight
-{
-public:
-	StelPainterLight(int alight=0) : light(alight), enabled(false) {}
-
-	void setPosition(const Vec4f& v);
-	Vec4f& getPosition() {return position;}
-
-	void setDiffuse(const Vec4f& v);
-	Vec4f& getDiffuse() {return diffuse;}
-
-	void setSpecular(const Vec4f& v);
-	Vec4f& getSpecular() {return specular;}
-
-	void setAmbient(const Vec4f& v);
-	Vec4f& getAmbient() {return ambient;}
-
-	void setEnable(bool v);
-	void enable();
-	void disable();
-	bool isEnabled() const {return enabled;}
-
-private:
-	int light;
-	Vec4f position;
-	Vec4f diffuse;
-	Vec4f specular;
-	Vec4f ambient;
-	bool enabled;
-};
-
-
 //! @class StelPainter
 //! Provides functions for performing openGL drawing operations.
 //! All coordinates are converted using the StelProjector instance passed at construction.
@@ -225,9 +193,6 @@
 	//! @param texCoordArr the vertex array in which the resulting texture coordinates are returned.
 	static void computeFanDisk(float radius, int innerFanSlices, int level, QVector<double>& vertexArr, QVector<float>& texCoordArr);
 
-	//! Draw a ring with a radial texturing.
-	void sRing(const float rMin, const float rMax, int slices, const int stacks, const int orientInside);
-
 	//! Draw a fisheye texture in a sphere.
 	void sSphereMap(const float radius, const int slices, const int stacks, const float textureFov = 2.f*M_PI, const int orientInside = 0);
 
@@ -240,9 +205,6 @@
 	//! Get the color currently used for drawing.
 	Vec4f getColor() const;
 
-	//! Get the light
-	StelPainterLight& getLight() {return light;}
-
 	//! Get the font metrics for the current font.
 	QFontMetrics getFontMetrics() const;
 
@@ -404,9 +366,6 @@
 	ArrayDesc normalArray;
 	//! The descriptor for the current opengl color array
 	ArrayDesc colorArray;
-
-	//! the single light used by the painter
-	StelPainterLight light;
 };
 
 #endif // _STELPAINTER_HPP_

=== modified file 'src/core/StelTexture.cpp'
--- src/core/StelTexture.cpp	2014-05-23 22:05:02 +0000
+++ src/core/StelTexture.cpp	2014-06-04 22:13:44 +0000
@@ -108,12 +108,12 @@
  Bind the texture so that it can be used for openGL drawing (calls glBindTexture)
  *************************************************************************/
 
-bool StelTexture::bind()
+bool StelTexture::bind(int slot)
 {
 	if (id != 0)
 	{
 		// The texture is already fully loaded, just bind and return true;
-		glActiveTexture(GL_TEXTURE0);
+		glActiveTexture(GL_TEXTURE0 + slot);
 		glBindTexture(GL_TEXTURE_2D, id);
 		return true;
 	}

=== modified file 'src/core/StelTexture.hpp'
--- src/core/StelTexture.hpp	2014-05-23 22:05:02 +0000
+++ src/core/StelTexture.hpp	2014-06-04 22:13:44 +0000
@@ -65,7 +65,7 @@
 	//! If the texture is lazyly loaded, this starts the loading and return false immediately.
 	//! @return true if the binding successfully occured, false if the texture is not yet loaded.
 	
-	bool bind();
+	bool bind(int slot=0);
 
 	//! Return whether the texture can be binded, i.e. it is fully loaded
 	bool canBind() const {return id!=0;}

=== modified file 'src/core/StelUtils.cpp'
--- src/core/StelUtils.cpp	2014-05-23 22:05:02 +0000
+++ src/core/StelUtils.cpp	2014-06-04 22:13:44 +0000
@@ -1780,5 +1780,105 @@
 	return sigma;
 }
 
+
+// Arrays to keep cos/sin of angles and multiples of angles. rho and theta are delta angles, and these arrays
+#define MAX_STACKS 4096
+static float cos_sin_rho[2*(MAX_STACKS+1)];
+#define MAX_SLICES 4096
+static float cos_sin_theta[2*(MAX_SLICES+1)];
+
+//! Compute cosines and sines around a circle which is split in "segments" parts.
+//! Values are stored in the global static array cos_sin_theta.
+//! Used for the sin/cos values along a latitude circle, equator, etc. for a spherical mesh.
+//! @param slices number of partitions (elsewhere called "segments") for the circle
+float* ComputeCosSinTheta(const int slices)
+{
+	Q_ASSERT(slices<=MAX_SLICES);
+	
+	// Difference angle between the stops. Always use 2*M_PI/slices!
+	const float dTheta = 2.f * M_PI / slices;
+	float *cos_sin = cos_sin_theta;
+	float *cos_sin_rev = cos_sin + 2*(slices+1);
+	const float c = std::cos(dTheta);
+	const float s = std::sin(dTheta);
+	*cos_sin++ = 1.f;
+	*cos_sin++ = 0.f;
+	*--cos_sin_rev = -cos_sin[-1];
+	*--cos_sin_rev =  cos_sin[-2];
+	*cos_sin++ = c;
+	*cos_sin++ = s;
+	*--cos_sin_rev = -cos_sin[-1];
+	*--cos_sin_rev =  cos_sin[-2];
+	while (cos_sin < cos_sin_rev)   // compares array address indices only!
+	{
+		// avoid expensive trig functions by use of the addition theorem.
+		cos_sin[0] = cos_sin[-2]*c - cos_sin[-1]*s;
+		cos_sin[1] = cos_sin[-2]*s + cos_sin[-1]*c;
+		cos_sin += 2;
+		*--cos_sin_rev = -cos_sin[-1];
+		*--cos_sin_rev =  cos_sin[-2];
+	}
+	return cos_sin_theta;
+}
+
+//! Compute cosines and sines around a half-circle 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 for a spherical mesh.
+//! @param segments number of partitions (elsewhere called "stacks") for the half-circle
+float* ComputeCosSinRho(const int segments)
+{
+	Q_ASSERT(segments<=MAX_STACKS);
+	
+	// Difference angle between the stops. Always use M_PI/segments!
+	const float dRho = M_PI / segments;
+	float *cos_sin = cos_sin_rho;
+	float *cos_sin_rev = cos_sin + 2*(segments+1);
+	const float c = std::cos(dRho);
+	const float s = std::sin(dRho);
+	*cos_sin++ = 1.f;
+	*cos_sin++ = 0.f;
+	*--cos_sin_rev =  cos_sin[-1];
+	*--cos_sin_rev = -cos_sin[-2];
+	*cos_sin++ = c;
+	*cos_sin++ = s;
+	*--cos_sin_rev =  cos_sin[-1];
+	*--cos_sin_rev = -cos_sin[-2];
+	while (cos_sin < cos_sin_rev)    // compares array address indices only!
+	{
+		// avoid expensive trig functions by use of the addition theorem.
+		cos_sin[0] = cos_sin[-2]*c - cos_sin[-1]*s;
+		cos_sin[1] = cos_sin[-2]*s + cos_sin[-1]*c;
+		cos_sin += 2;
+		*--cos_sin_rev =  cos_sin[-1];
+		*--cos_sin_rev = -cos_sin[-2];
+	}
+	
+	return cos_sin_rho;
+}
+
+//! 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
+//! @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
+float *ComputeCosSinRhoZone(const float dRho, const int segments, const float minAngle)
+{
+	float *cos_sin = cos_sin_rho;
+	const float c = cos(dRho);
+	const float s = sin(dRho);
+	*cos_sin++ = cos(minAngle);
+	*cos_sin++ = sin(minAngle);
+	for (int i=0; i<segments; ++i) // we cannot mirror this, it may be unequal.
+	{   // efficient computation, avoid expensive trig functions by use of the addition theorem.
+		cos_sin[0] = cos_sin[-2]*c - cos_sin[-1]*s;
+		cos_sin[1] = cos_sin[-2]*s + cos_sin[-1]*c;
+		cos_sin += 2;
+	}
+	return cos_sin_rho;
+}
+
+
 } // end of the StelUtils namespace
 

=== modified file 'src/core/StelUtils.hpp'
--- src/core/StelUtils.hpp	2014-05-23 22:05:02 +0000
+++ src/core/StelUtils.hpp	2014-06-04 22:13:44 +0000
@@ -36,6 +36,7 @@
 // speed of light (km/sec)
 #define SPEED_OF_LIGHT 299792.458
 
+
 //! @namespace StelUtils contains general purpose utility functions.
 namespace StelUtils
 {
@@ -570,6 +571,27 @@
 	template <typename T> int sign(T val) {
 		return (T(0) < val) - (val < T(0));
 	}
+	
+	//! Compute cosines and sines around a circle which is split in "segments" parts.
+	//! Values are stored in the global static array cos_sin_theta.
+	//! Used for the sin/cos values along a latitude circle, equator, etc. for a spherical mesh.
+	//! @param slices number of partitions (elsewhere called "segments") for the circle
+	float *ComputeCosSinTheta(const int slices);
+	
+	//! Compute cosines and sines around a half-circle 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 for a spherical mesh.
+	//! @param segments number of partitions (elsewhere called "stacks") for the half-circle
+	float *ComputeCosSinRho(const int segments);
+	
+	//! 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
+	//! @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
+	float* ComputeCosSinRhoZone(const float dRho, const int segments, const float minAngle);
 }
 
 #endif // _STELUTILS_HPP_

=== modified file 'src/core/modules/Comet.cpp'
--- src/core/modules/Comet.cpp	2014-04-14 15:40:40 +0000
+++ src/core/modules/Comet.cpp	2014-06-04 22:13:44 +0000
@@ -368,7 +368,6 @@
 
 void Comet::drawTail(StelCore* core, StelProjector::ModelViewTranformP transfo, bool gas)
 {
-
 	// Find rotation matrix from 0/0/1 to eclipticPosition: crossproduct for axis (normal vector), dotproduct for angle.
 	Vec3d eclposNrm=eclipticPos; eclposNrm.normalize();
 	Mat4d tailrot=Mat4d::rotation(Vec3d(0.0, 0.0, 1.0)^(eclposNrm), std::acos(Vec3d(0.0, 0.0, 1.0).dot(eclposNrm)) );
@@ -388,7 +387,6 @@
 		transfo2->combine(dustTailYrot);
 	}
 	StelPainter* sPainter = new StelPainter(core->getProjection(transfo2));
-	sPainter->getLight().disable();
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_ONE, GL_ONE);
 	glDisable(GL_CULL_FACE);
@@ -439,14 +437,12 @@
 
 void Comet::drawComa(StelCore* core, StelProjector::ModelViewTranformP transfo)
 {
-
 	// Find rotation matrix from 0/0/1 to viewdirection! crossproduct for axis (normal vector), dotproduct for angle.
 	Vec3d eclposNrm=eclipticPos - core->getObserverHeliocentricEclipticPos()  ; eclposNrm.normalize();
 	Mat4d comarot=Mat4d::rotation(Vec3d(0.0, 0.0, 1.0)^(eclposNrm), std::acos(Vec3d(0.0, 0.0, 1.0).dot(eclposNrm)) );
 	StelProjector::ModelViewTranformP transfo2 = transfo->clone();
 	transfo2->combine(comarot);
 	StelPainter* sPainter = new StelPainter(core->getProjection(transfo2));
-	sPainter->getLight().disable();
 
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_ONE, GL_ONE);
@@ -460,7 +456,6 @@
 	float magFactor=std::pow(0.6f , magDrop);
 	magFactor=qMin(magFactor, 2.0f); // Limit excessively bright display.
 
-
 	comaTexture->bind();
 	sPainter->setColor(magFactor,magFactor,0.6f*magFactor);
 	sPainter->setArrays((Vec3d*)comaVertexArr.constData(), (Vec2f*)comaTexCoordArr.constData());

=== modified file 'src/core/modules/Planet.cpp'
--- src/core/modules/Planet.cpp	2014-05-23 22:05:02 +0000
+++ src/core/modules/Planet.cpp	2014-06-04 22:13:44 +0000
@@ -40,11 +40,58 @@
 #include <QString>
 #include <QDebug>
 #include <QVarLengthArray>
+#include <QOpenGLShader>
+
+#ifndef NDEBUG
+static const char* get_gl_error_text(int code) {
+    switch (code) {
+    case GL_INVALID_ENUM:
+        return "GL_INVALID_ENUM";
+    case GL_INVALID_FRAMEBUFFER_OPERATION:
+        return "GL_INVALID_FRAMEBUFFER_OPERATION";
+    case GL_INVALID_VALUE:
+        return "GL_INVALID_VALUE";
+    case GL_INVALID_OPERATION:
+        return "GL_INVALID_OPERATION";
+    case GL_OUT_OF_MEMORY:
+        return "GL_OUT_OF_MEMORY";
+    default:
+        return "undefined error";
+    }
+}
+
+int check_gl_errors(const char *file, int line)
+{
+    int errors = 0;
+    while (true)
+    {
+        GLenum x = glGetError();
+        if (x == GL_NO_ERROR)
+            return errors;
+        printf("%s:%d: OpenGL error: %d (%s)\n",
+            file, line, x, get_gl_error_text(x));
+        errors++;
+    }
+}
+#endif
+
+#ifndef NDEBUG
+#  define GL(line) do {                                 \
+       line;                                            \
+       if (check_gl_errors(__FILE__, __LINE__))         \
+           exit(-1);                                    \
+   } while(0)
+#else
+#  define GL(line) line
+#endif
 
 Vec3f Planet::labelColor = Vec3f(0.4,0.4,0.8);
 Vec3f Planet::orbitColor = Vec3f(1,0.6,1);
 StelTextureSP Planet::hintCircleTex;
 StelTextureSP Planet::texEarthShadow;
+QOpenGLShaderProgram* Planet::shaderProgram=NULL;
+Planet::ShaderVars Planet::shaderVars;
+
 Planet::Planet(const QString& englishName,
 	       int flagLighting,
 	       double radius,
@@ -316,6 +363,50 @@
 		return re.obliquity;
 }
 
+
+bool willCastShadow(const Planet* thisPlanet, const Planet* p)
+{
+	Vec3d thisPos = thisPlanet->getHeliocentricEclipticPos();
+	Vec3d planetPos = p->getHeliocentricEclipticPos();
+	
+	// If the planet p is farther from the sun than this planet, it can't cast shadow on it.
+	if (planetPos.lengthSquared()>thisPos.lengthSquared())
+		return false;
+	
+	Vec3d ppVector = planetPos;
+	ppVector.normalize();
+	
+	double shadowDistance = ppVector * thisPos;
+	static const double sunRadius = 696000./AU;
+	double d = planetPos.length() / (p->getRadius()/sunRadius+1);
+	double penumbraRadius = (shadowDistance-d)/d*sunRadius;
+	
+	double penumbraCenterToThisPlanetCenterDistance = (ppVector*shadowDistance-thisPos).length();
+	
+	if (penumbraCenterToThisPlanetCenterDistance<penumbraRadius+thisPlanet->getRadius())
+		return true;
+	return false;
+}
+
+QVector<const Planet*> Planet::getCandidatesForShadow() const
+{
+	QVector<const Planet*> res;
+	const SolarSystem *ssystem=GETSTELMODULE(SolarSystem);
+	const Planet* sun = ssystem->getSun().data();
+	if (this==sun || (parent.data()==sun && satellites.empty()))
+		return res;
+	
+	foreach (const PlanetP& planet, satellites)
+	{
+		if (willCastShadow(this, planet.data()))
+			res.append(planet.data());
+	}
+	if (willCastShadow(this, parent.data()))
+		res.append(parent.data());
+	
+	return res;
+}
+
 void Planet::computePosition(const double date)
 {
 
@@ -822,8 +913,7 @@
 		// Draw the rings if we are located on a planet with rings, but not the planet itself.
 		if (rings)
 		{
-			StelPainter sPainter(core->getProjection(transfo));
-			rings->draw(&sPainter,transfo,1000.0);
+			draw3dModel(core, transfo, 1024, true);
 		}
 		return;
 	}
@@ -861,7 +951,191 @@
 	return;
 }
 
-void Planet::draw3dModel(StelCore* core, StelProjector::ModelViewTranformP transfo, float screenSz)
+class StelPainterLight
+{
+public:
+	Vec3f position;
+	Vec3f diffuse;
+	Vec3f ambient;
+};
+static StelPainterLight light;
+
+void Planet::initShader()
+{
+	// Default planet texture shader program
+	QOpenGLShader vshader(QOpenGLShader::Vertex);
+	const char *vsrc =
+		"attribute highp vec3 vertex;\n"
+		"attribute highp vec3 unprojectedVertex;\n"
+		"attribute mediump vec2 texCoord;\n"
+		"uniform highp mat4 projectionMatrix;\n"
+		"uniform highp vec3 lightPos;\n"
+		"varying mediump vec2 texc;\n"
+		"varying mediump float lambert;\n"
+		"varying highp vec3 P;\n"
+		"\n"
+		"void main()\n"
+		"{\n"
+		"    gl_Position = projectionMatrix * vec4(vertex, 1.);\n"
+		"    texc = texCoord;\n"
+		"    vec3 normal = normalize(unprojectedVertex);\n"
+		"    float c = lightPos.x * normal.x +\n"
+		"              lightPos.y * normal.y +\n"
+		"              lightPos.z * normal.z;\n"
+		"    lambert = clamp(c, 0.0, 1.0);\n"
+		"\n"
+		"    P = unprojectedVertex;\n"
+		"}\n"
+		"\n";
+	vshader.compileSourceCode(vsrc);
+	if (!vshader.log().isEmpty()) { qWarning() << "Planet: Warnings while compiling vshader: " << vshader.log(); }
+
+	QOpenGLShader fshader(QOpenGLShader::Fragment);
+	
+	const char *fsrc =
+		"varying mediump vec2 texc;\n"
+		"varying mediump float lambert;\n"
+		"uniform sampler2D tex;\n"
+		"uniform mediump vec3 ambientLight;\n"
+		"uniform mediump vec3 diffuseLight;\n"
+		"uniform highp vec4 sunInfo;\n"
+		"\n"
+		"varying highp vec3 P;\n"
+		"\n"
+		"uniform int shadowCount;\n"
+		"uniform highp mat4 shadowData;\n"
+		"\n"
+		"uniform bool ring;\n"
+		"uniform highp float outerRadius;\n"
+		"uniform highp float innerRadius;\n"
+		"uniform sampler2D ringS;\n"
+		"uniform bool isRing;\n"
+		"\n"
+		"uniform bool isMoon;\n"
+		"uniform sampler2D earthShadow;\n"
+		"\n"
+		"void main()\n"
+		"{\n"
+		"    float final_illumination = 1.0;\n"
+		"    if(lambert > 0.0 || isRing)\n"
+		"    {\n"
+		"        vec3 sunPosition = sunInfo.xyz;\n"
+		"        if(ring && !isRing)\n"
+		"        {\n"
+		"            vec3 ray = normalize(sunPosition);\n"
+		"            float u = - P.z / ray.z;\n"
+		"            if(u > 0.0 && u < 1e10)\n"
+		"            {\n"
+		"                float ring_radius = length(P + u * ray);\n"
+		"                if(ring_radius > innerRadius && ring_radius < outerRadius)\n"
+		"                {\n"
+		"                    ring_radius = (ring_radius - innerRadius) / (outerRadius - innerRadius);\n"
+		"                    float ringAlpha = texture2D(ringS, vec2(ring_radius, 0.5)).w;\n"
+		"                    final_illumination = 1.0 - ringAlpha;\n"
+		"                }\n"
+		"            }\n"
+		"        }\n"
+		"\n"
+		"        float sunRadius = sunInfo.w;\n"
+		"        float L = length(sunPosition - P);\n"
+		"        float R = asin(sunRadius / L);\n"
+		"        for (int i = 0; i < shadowCount; ++i)\n"
+		"        {\n"
+		"            vec3 satellitePosition = shadowData[i].xyz;\n"
+		"            float satelliteRadius = shadowData[i].w;\n"
+		"            float l = length(satellitePosition - P);\n"
+		"            float r = asin(satelliteRadius / l);\n"
+		"            float d = acos(min(1.0, dot(normalize(sunPosition - P), normalize(satellitePosition - P))));\n"
+		"\n"
+		"            float illumination = 1.0;\n"
+		"\n"
+		"            // distance too far\n"
+		"            if(d >= R + r)\n"
+		"            {\n"
+		"                illumination = 1.0;\n"
+		"            }\n"
+		"            // umbra\n"
+		"            else if(r >= R + d)\n"
+		"            {\n"
+		"                if(isMoon)\n"
+		"                    illumination = d / (r - R) * 0.6;\n"
+		"                else"
+		"                    illumination = 0.0;\n"
+		"            }\n"
+		"            // penumbra completely inside\n"
+		"            else if(d + r <= R)\n"
+		"            {\n"
+		"                illumination = 1.0 - r * r / (R * R);\n"
+		"            }\n"
+		"            // penumbra partially inside\n"
+		"            else\n"
+		"            {\n"
+		"                if(isMoon)\n"
+		"                    illumination = ((d - abs(R-r)) / (R + r - abs(R-r))) * 0.4 + 0.6;\n"
+		"                else\n"
+		"                {\n"
+		"                    float x = (R * R + d * d - r * r) / (2.0 * d);\n"
+		"                    float alpha = acos(x / R);\n"
+		"                    float beta = acos((d - x) / r);\n"
+		"                    float AR = R * R * (alpha - 0.5 * sin(2.0 * alpha));\n"
+		"                    float Ar = r * r * (beta - 0.5 * sin(2.0 * beta));\n"
+		"                    float AS = R * R * 2.0 * 1.57079633;\n"
+		"                    illumination = 1.0 - (AR + Ar) / AS;\n"
+		"                }\n"
+		"            }\n"
+		"\n"
+		"            if(illumination < final_illumination)\n"
+		"                final_illumination = illumination;\n"
+		"        }\n"
+		"    }\n"
+		"\n"
+		"    vec4 litColor = vec4((isRing ? 1.0 : lambert) * final_illumination * diffuseLight + ambientLight, 1.0);\n"
+		"    if(isMoon && final_illumination < 1.0)\n"
+		"    {\n"
+		"        vec4 shadowColor = texture2D(earthShadow, vec2(final_illumination, 0.5));\n"
+		"        gl_FragColor = mix(texture2D(tex, texc) * litColor, shadowColor, shadowColor.a);\n"
+		"    }\n"
+		"    else\n"
+		"        gl_FragColor = texture2D(tex, texc) * litColor;\n"
+		"}\n"
+		"\n";
+	fshader.compileSourceCode(fsrc);
+	if (!fshader.log().isEmpty()) { qWarning() << "Planet: Warnings while compiling fshader: " << fshader.log(); }
+
+	shaderProgram = new QOpenGLShaderProgram(QOpenGLContext::currentContext());
+	shaderProgram->addShader(&vshader);
+	shaderProgram->addShader(&fshader);
+	GL(StelPainter::linkProg(shaderProgram, "planetShaderProgram"));
+	GL(shaderProgram->bind());
+	GL(shaderVars.projectionMatrix = shaderProgram->uniformLocation("projectionMatrix"));
+	GL(shaderVars.texCoord = shaderProgram->attributeLocation("texCoord"));
+	GL(shaderVars.unprojectedVertex = shaderProgram->attributeLocation("unprojectedVertex"));
+	GL(shaderVars.vertex = shaderProgram->attributeLocation("vertex"));
+	GL(shaderVars.texture = shaderProgram->uniformLocation("tex"));
+
+	GL(shaderVars.lightPos = shaderProgram->uniformLocation("lightPos"));
+	GL(shaderVars.diffuseLight = shaderProgram->uniformLocation("diffuseLight"));
+	GL(shaderVars.ambientLight = shaderProgram->uniformLocation("ambientLight"));
+	GL(shaderVars.shadowCount = shaderProgram->uniformLocation("shadowCount"));
+	GL(shaderVars.shadowData = shaderProgram->uniformLocation("shadowData"));
+	GL(shaderVars.sunInfo = shaderProgram->uniformLocation("sunInfo"));
+	GL(shaderVars.isRing = shaderProgram->uniformLocation("isRing"));
+	GL(shaderVars.ring = shaderProgram->uniformLocation("ring"));
+	GL(shaderVars.outerRadius = shaderProgram->uniformLocation("outerRadius"));
+	GL(shaderVars.innerRadius = shaderProgram->uniformLocation("innerRadius"));
+	GL(shaderVars.ringS = shaderProgram->uniformLocation("ringS"));
+	GL(shaderVars.isMoon = shaderProgram->uniformLocation("isMoon"));
+	GL(shaderVars.earthShadow = shaderProgram->uniformLocation("earthShadow"));
+	GL(shaderProgram->release());
+}
+
+void Planet::deinitShader()
+{
+	delete shaderProgram;
+	shaderProgram = NULL;
+}
+
+void Planet::draw3dModel(StelCore* core, StelProjector::ModelViewTranformP transfo, float screenSz, bool drawOnlyRing)
 {
 	// This is the main method drawing a planet 3d model
 	// Some work has to be done on this method to make the rendering nicer
@@ -872,39 +1146,33 @@
 		StelProjector::ModelViewTranformP transfo2 = transfo->clone();
 		transfo2->combine(Mat4d::zrotation(M_PI/180*(axisRotation + 90.)));
 		StelPainter* sPainter = new StelPainter(core->getProjection(transfo2));
-
+		
 		if (flagLighting)
 		{
-			sPainter->getLight().enable();
-
 			// Set the main source of light to be the sun
 			Vec3d sunPos(0);
 			core->getHeliocentricEclipticModelViewTransform()->forward(sunPos);
-			sPainter->getLight().setPosition(Vec4f(sunPos[0],sunPos[1],sunPos[2],1.f));
+			light.position=Vec4f(sunPos[0],sunPos[1],sunPos[2],1.f);
 
 			// Set the light parameters taking sun as the light source
-			static Vec4f diffuse = Vec4f(1.f,1.f,1.f,1.f);
-			static Vec4f zero = Vec4f(0.f,0.f,0.f,0.f);
-			static Vec4f ambient = Vec4f(0.02f,0.02f,0.02f,0.02f);
+			light.diffuse = Vec4f(1.f,1.f,1.f);
+			light.ambient = Vec4f(0.02f,0.02f,0.02f);
 
 			if (this==ssm->getMoon())
 			{
 				// Special case for the Moon (maybe better use 1.5,1.5,1.5,1.0 ?)
-				diffuse = Vec4f(1.6f,1.6f,1.6f,1.f);
+				light.diffuse = Vec4f(1.6f,1.6f,1.6f,1.f);
 			}
-			
-			sPainter->getLight().setAmbient(ambient);
-			sPainter->getLight().setDiffuse(diffuse);
-			sPainter->getLight().setSpecular(zero);
 		}
 		else
 		{
-			sPainter->getLight().disable();
 			sPainter->setColor(albedo,albedo,albedo);
 		}
 
 		if (rings)
 		{
+			// The planet has rings, we need to use depth buffer and adjust the clipping planes to avoid 
+			// reaching the maximum resolution of the depth buffer
 			const double dist = getEquinoxEquatorialPos(core).length();
 			double z_near = 0.9*(dist - rings->getSize());
 			double z_far  = 1.1*(dist + rings->getSize());
@@ -912,48 +1180,22 @@
 			double n,f;
 			core->getClippingPlanes(&n,&f); // Save clipping planes
 			core->setClippingPlanes(z_near,z_far);
-			glDepthMask(GL_TRUE);
-			glClear(GL_DEPTH_BUFFER_BIT);
-			glEnable(GL_DEPTH_TEST);
+
+			drawSphere(sPainter, screenSz, drawOnlyRing);
+			
+			core->setClippingPlanes(n,f);  // Restore old clipping planes
+		}
+		else
+		{
+			// Normal planet
 			drawSphere(sPainter, screenSz);
-			glDepthMask(GL_FALSE);
-			sPainter->getLight().disable();
-			rings->draw(sPainter,transfo,screenSz);
-			sPainter->getLight().enable();
-			glDisable(GL_DEPTH_TEST);
-			core->setClippingPlanes(n,f);  // Restore old clipping planes
-		}
-		else
-		{
-			if (this==ssm->getMoon() && core->getCurrentLocation().planetName=="Earth" && ssm->nearLunarEclipse())
-			{
-				// Draw earth shadow over moon using stencil buffer if appropriate
-				// This effect curently only looks right from earth viewpoint
-				// TODO: moon magnitude label during eclipse isn't accurate...
-				glClearStencil(0x0);
-				glClear(GL_STENCIL_BUFFER_BIT);
-				glStencilFunc(GL_ALWAYS, 0x1, 0x1);
-				glStencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);
-				glEnable(GL_STENCIL_TEST);
-				drawSphere(sPainter, screenSz);
-				glDisable(GL_STENCIL_TEST);
-
-				sPainter->getLight().disable();
-				drawEarthShadow(core, sPainter);
-			}
-			else
-			{
-				// Normal planet
-				drawSphere(sPainter, screenSz);
-			}
-		}
-		if (sPainter)
-			delete sPainter;
+		}
+		delete sPainter;
 		sPainter=NULL;
 	}
 
 	// Draw the halo if it enabled in the ssystem.ini file (+ special case for backward compatible for the Sun)
-	if (hasHalo() || getEnglishName().contains("Sun"))
+	if (hasHalo() || this==ssm->getSun())
 	{
 		// Prepare openGL lighting parameters according to luminance
 		float surfArcMin2 = getSpheroidAngularSize(core)*60;
@@ -965,8 +1207,120 @@
 	}
 }
 
-
-void Planet::drawSphere(StelPainter* painter, float screenSz)
+struct Planet3DModel
+{
+	QVector<float> vertexArr;
+	QVector<float> texCoordArr;
+	QVector<unsigned short> indiceArr;
+};
+
+void sSphere(Planet3DModel* model, const float radius, const float oneMinusOblateness, const int slices, const int stacks)
+{
+	model->indiceArr.resize(0);
+	model->vertexArr.resize(0);
+	model->texCoordArr.resize(0);
+	
+	GLfloat x, y, z;
+	GLfloat s=0.f, t=1.f;
+	GLint i, j;
+
+	const float* cos_sin_rho = StelUtils::ComputeCosSinRho(stacks);
+	const float* cos_sin_theta =  StelUtils::ComputeCosSinTheta(slices);
+	
+	const float* cos_sin_rho_p;
+	const float *cos_sin_theta_p;
+
+	// texturing: s goes from 0.0/0.25/0.5/0.75/1.0 at +y/+x/-y/-x/+y axis
+	// t goes from -1.0/+1.0 at z = -radius/+radius (linear along longitudes)
+	// cannot use triangle fan on texturing (s coord. at top/bottom tip varies)
+	// If the texture is flipped, we iterate the coordinates backward.
+	const GLfloat ds = 1.f / slices;
+	const GLfloat dt = 1.f / stacks; // from inside texture is reversed
+
+	// draw intermediate  as quad strips
+	for (i = 0,cos_sin_rho_p = cos_sin_rho; i < stacks; ++i,cos_sin_rho_p+=2)
+	{
+		s = 0.f;
+		for (j = 0,cos_sin_theta_p = cos_sin_theta; j<=slices;++j,cos_sin_theta_p+=2)
+		{
+			x = -cos_sin_theta_p[1] * cos_sin_rho_p[1];
+			y = cos_sin_theta_p[0] * cos_sin_rho_p[1];
+			z = cos_sin_rho_p[0];
+			model->texCoordArr << s << t;
+			model->vertexArr << x * radius << y * radius << z * oneMinusOblateness * radius;
+			x = -cos_sin_theta_p[1] * cos_sin_rho_p[3];
+			y = cos_sin_theta_p[0] * cos_sin_rho_p[3];
+			z = cos_sin_rho_p[2];
+			model->texCoordArr << s << t - dt;
+			model->vertexArr << x * radius << y * radius << z * oneMinusOblateness * radius;
+			s += ds;
+		}
+		unsigned int offset = i*(slices+1)*2;
+		for (j = 2;j<slices*2+2;j+=2)
+		{
+			model->indiceArr << offset+j-2 << offset+j-1 << offset+j;
+			model->indiceArr << offset+j << offset+j-1 << offset+j+1;
+		}
+		t -= dt;
+	}
+}
+
+struct Ring3DModel
+{
+	QVector<float> vertexArr;
+	QVector<float> texCoordArr;
+	QVector<unsigned short> indiceArr;
+};
+
+
+void sRing(Ring3DModel* model, const float rMin, const float rMax, int slices, const int stacks)
+{
+	float x,y;
+	
+	const float dr = (rMax-rMin) / stacks;
+	const float* cos_sin_theta = StelUtils::ComputeCosSinTheta(slices);
+	const float* cos_sin_theta_p;
+
+	model->vertexArr.resize(0);
+	model->texCoordArr.resize(0);
+	model->indiceArr.resize(0);
+
+	float r = rMin;
+	for (int i=0; i<=stacks; ++i)
+	{
+		const float tex_r0 = (r-rMin)/(rMax-rMin);
+		int j;
+		for (j=0,cos_sin_theta_p=cos_sin_theta; j<=slices; ++j,cos_sin_theta_p+=2)
+		{
+			x = r*cos_sin_theta_p[0];
+			y = r*cos_sin_theta_p[1];
+			model->texCoordArr << tex_r0 << 0.5f;
+			model->vertexArr << x << y << 0.f;
+		}
+		r+=dr;
+	}
+	for (int i=0; i<stacks; ++i)
+	{
+		for (int j=0; j<slices; ++j)
+		{
+			model->indiceArr << i*slices+j << (i+1)*slices+j << i*slices+j+1;
+			model->indiceArr << i*slices+j+1 << (i+1)*slices+j << (i+1)*slices+j+1;
+		}
+	}
+}
+
+void Planet::computeModelMatrix(Mat4d &result) const
+{
+	result = Mat4d::translation(eclipticPos) * rotLocalToParent * Mat4d::zrotation(M_PI/180*(axisRotation + 90.));
+	PlanetP p = parent;
+	while (p && p->parent)
+	{
+		result = Mat4d::translation(p->eclipticPos) * result * p->rotLocalToParent;
+		p = p->parent;
+	}
+}
+
+void Planet::drawSphere(StelPainter* painter, float screenSz, bool drawOnlyRing)
 {
 	if (texMap)
 	{
@@ -976,119 +1330,166 @@
 			return;
 		}
 	}
-	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GZ deactivated. 2013-12-27. If disabling blend, who cares which one?
-	painter->setColor(1.f, 1.f, 1.f);
-
 	painter->enableTexture2d(true);
 	glDisable(GL_BLEND);
 	glEnable(GL_CULL_FACE);
 
 	// Draw the spheroid itself
 	// Adapt the number of facets according with the size of the sphere for optimization
-	int nb_facet = (int)(screenSz * 40/50);	// 40 facets for 1024 pixels diameter on screen
+	int nb_facet = (int)(screenSz * 40.f/50.f);	// 40 facets for 1024 pixels diameter on screen
 	if (nb_facet<10) nb_facet = 10;
-	if (nb_facet>40) nb_facet = 40;
-	// Rotate and add an extra quarter rotation so that the planet texture map
-	// fits to the observers position. No idea why this is necessary,
-	// perhaps some openGl strangeness, or confusing sin/cos.
-
-	painter->sSphere(radius*sphereScale, oneMinusOblateness, nb_facet, nb_facet);
+	if (nb_facet>100) nb_facet = 100;
+
+	// Generates the vertice
+	Planet3DModel model;
+	sSphere(&model, radius*sphereScale, oneMinusOblateness, nb_facet, nb_facet);
+	
+	QVector<float> projectedVertexArr;
+	projectedVertexArr.resize(model.vertexArr.size());
+	for (int i=0;i<model.vertexArr.size()/3;++i)
+		painter->getProjector()->project(*((Vec3f*)(model.vertexArr.constData()+i*3)), *((Vec3f*)(projectedVertexArr.data()+i*3)));
+	
+	if (englishName=="Sun")
+	{
+		texMap->bind();
+		painter->setColor(2, 2, 2);
+		painter->setArrays((Vec3f*)projectedVertexArr.constData(), (Vec2f*)model.texCoordArr.constData());
+		painter->drawFromArray(StelPainter::Triangles, model.indiceArr.size(), 0, false, model.indiceArr.constData());
+		return;
+	}
+	
+	if (shaderProgram==NULL)
+		Planet::initShader();
+	Q_ASSERT(shaderProgram!=NULL);
+	GL(shaderProgram->bind());
+	
+	const Mat4f& m = painter->getProjector()->getProjectionMatrix();
+	const QMatrix4x4 qMat(m[0], m[4], m[8], m[12], m[1], m[5], m[9], m[13], m[2], m[6], m[10], m[14], m[3], m[7], m[11], m[15]);
+	shaderProgram->setUniformValue(shaderVars.projectionMatrix, qMat);
+	
+	Mat4d modelMatrix;
+	computeModelMatrix(modelMatrix);
+	// TODO explain this
+	const Mat4d mTarget = modelMatrix.inverse();
+	
+	QMatrix4x4 shadowCandidatesData;
+	QVector<const Planet*> shadowCandidates = getCandidatesForShadow();
+	// Our shader doesn't support more than 4 planets creating shadow
+	if (shadowCandidates.size()>4)
+		shadowCandidates.resize(4);
+	for (int i=0;i<shadowCandidates.size();++i)
+	{
+		shadowCandidates.at(i)->computeModelMatrix(modelMatrix);
+		const Vec4d position = mTarget * modelMatrix.getColumn(3);
+		shadowCandidatesData(0, i) = position[0];
+		shadowCandidatesData(1, i) = position[1];
+		shadowCandidatesData(2, i) = position[2];
+		shadowCandidatesData(3, i) = shadowCandidates.at(i)->getRadius();
+	}
+	
+	const StelProjectorP& projector = painter->getProjector();
+	
+	Vec3f lightPos3;
+	lightPos3.set(light.position[0], light.position[1], light.position[2]);
+	Vec3f tmpv(0.f);
+	projector->getModelViewTransform()->forward(tmpv);
+	projector->getModelViewTransform()->getApproximateLinearTransfo().transpose().multiplyWithoutTranslation(Vec3d(lightPos3[0], lightPos3[1], lightPos3[2]));
+	projector->getModelViewTransform()->backward(lightPos3);
+	lightPos3.normalize();
+	
+	GL(shaderProgram->setUniformValue(shaderVars.lightPos, lightPos3[0], lightPos3[1], lightPos3[2]));
+	GL(shaderProgram->setUniformValue(shaderVars.diffuseLight, light.diffuse[0], light.diffuse[1], light.diffuse[2]));
+	GL(shaderProgram->setUniformValue(shaderVars.ambientLight, light.ambient[0], light.ambient[1], light.ambient[2]));
+	GL(shaderProgram->setUniformValue(shaderVars.texture, 0));
+	GL(shaderProgram->setUniformValue(shaderVars.shadowCount, shadowCandidates.size()));
+	GL(shaderProgram->setUniformValue(shaderVars.shadowData, shadowCandidatesData));
+	
+	const SolarSystem* ssm = GETSTELMODULE(SolarSystem);
+	GL(shaderProgram->setUniformValue(shaderVars.sunInfo, mTarget[12], mTarget[13], mTarget[14], ssm->getSun()->getRadius()));
+	GL(shaderProgram->setUniformValue(shaderVars.isRing, false));
+
+	GL(shaderProgram->setUniformValue(shaderVars.ring, rings!=NULL));
+	if (rings!=NULL)
+	{
+		rings->tex->bind(2);
+		GL(shaderProgram->setUniformValue(shaderVars.outerRadius, rings->radiusMax));
+		GL(shaderProgram->setUniformValue(shaderVars.innerRadius, rings->radiusMin));
+		GL(shaderProgram->setUniformValue(shaderVars.ringS, rings ? 2 : 0));
+	}
+
+	const bool isMoon = (this==ssm->getMoon());
+	if (isMoon)
+		texEarthShadow->bind(3);
+	GL(shaderProgram->setUniformValue(shaderVars.isMoon, isMoon));
+	GL(shaderProgram->setUniformValue(shaderVars.earthShadow, isMoon ? 3: 0));
+
+	GL(texMap->bind(1));
+	
+	GL(shaderProgram->setAttributeArray(shaderVars.vertex, (const GLfloat*)projectedVertexArr.constData(), 3));
+	GL(shaderProgram->enableAttributeArray(shaderVars.vertex));
+	GL(shaderProgram->setAttributeArray(shaderVars.unprojectedVertex, (const GLfloat*)model.vertexArr.constData(), 3));
+	GL(shaderProgram->enableAttributeArray(shaderVars.unprojectedVertex));
+	GL(shaderProgram->setAttributeArray(shaderVars.texCoord, (const GLfloat*)model.texCoordArr.constData(), 2));
+	GL(shaderProgram->enableAttributeArray(shaderVars.texCoord));
+
+	if (rings)
+	{
+		glDepthMask(GL_TRUE);
+		glClear(GL_DEPTH_BUFFER_BIT);
+		glEnable(GL_DEPTH_TEST);
+	}
+	
+	if (!drawOnlyRing)
+		GL(glDrawElements(GL_TRIANGLES, model.indiceArr.size(), GL_UNSIGNED_SHORT, model.indiceArr.constData()));
+
+	if (rings)
+	{
+		// Draw the rings just after the planet
+		
+		glDepthMask(GL_FALSE);
+	
+		// Normal transparency mode
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		glEnable(GL_BLEND);
+	
+		Ring3DModel ringModel;
+		sRing(&ringModel, rings->radiusMin, rings->radiusMax, 128, 32);
+		
+		GL(shaderProgram->setUniformValue(shaderVars.isRing, true));
+		GL(shaderProgram->setUniformValue(shaderVars.texture, 2));
+		
+		computeModelMatrix(modelMatrix);
+		const Vec4d position = mTarget * modelMatrix.getColumn(3);
+		shadowCandidatesData(0, 0) = position[0];
+		shadowCandidatesData(1, 0) = position[1];
+		shadowCandidatesData(2, 0) = position[2];
+		shadowCandidatesData(3, 0) = getRadius();
+		GL(shaderProgram->setUniformValue(shaderVars.shadowCount, 1));
+		GL(shaderProgram->setUniformValue(shaderVars.shadowData, shadowCandidatesData));
+		
+		projectedVertexArr.resize(ringModel.vertexArr.size());
+		for (int i=0;i<ringModel.vertexArr.size()/3;++i)
+			painter->getProjector()->project(*((Vec3f*)(ringModel.vertexArr.constData()+i*3)), *((Vec3f*)(projectedVertexArr.data()+i*3)));
+		
+		GL(shaderProgram->setAttributeArray(shaderVars.vertex, (const GLfloat*)projectedVertexArr.constData(), 3));
+		GL(shaderProgram->enableAttributeArray(shaderVars.vertex));
+		GL(shaderProgram->setAttributeArray(shaderVars.unprojectedVertex, (const GLfloat*)ringModel.vertexArr.constData(), 3));
+		GL(shaderProgram->enableAttributeArray(shaderVars.unprojectedVertex));
+		GL(shaderProgram->setAttributeArray(shaderVars.texCoord, (const GLfloat*)ringModel.texCoordArr.constData(), 2));
+		GL(shaderProgram->enableAttributeArray(shaderVars.texCoord));
+		
+		glDisable(GL_CULL_FACE);
+		
+		GL(glDrawElements(GL_TRIANGLES, ringModel.indiceArr.size(), GL_UNSIGNED_SHORT, ringModel.indiceArr.constData()));
+		
+		glDisable(GL_DEPTH_TEST);
+	}
+	
+	GL(shaderProgram->release());
+	
 	glDisable(GL_CULL_FACE);
 }
 
-// draws earth shadow overlapping the moon using stencil buffer
-// umbra and penumbra are sized separately for accuracy
-void Planet::drawEarthShadow(StelCore* core, StelPainter* sPainter)
-{
-	SolarSystem* ssm = GETSTELMODULE(SolarSystem);
-	Vec3d e = ssm->getEarth()->getEclipticPos();
-	Vec3d m = ssm->getMoon()->getEclipticPos();  // relative to earth
-	Vec3d mh = ssm->getMoon()->getHeliocentricEclipticPos();  // relative to sun
-	float mscale = ssm->getMoon()->getSphereScale();
-
-	// shadow location at earth + moon distance along earth vector from sun
-	Vec3d en = e;
-	en.normalize();
-	Vec3d shadow = en * (e.length() + m.length());
-
-	// find shadow radii in AU
-	double r_penumbra = shadow.length()*702378.1/AU/e.length() - 696000./AU;
-	double r_umbra = 6378.1/AU - m.length()*(689621.9/AU/e.length());
-
-	// find vector orthogonal to sun-earth vector using cross product with
-	// a non-parallel vector
-	Vec3d rpt = shadow^Vec3d(0,0,1);
-	rpt.normalize();
-	Vec3d upt = rpt*r_umbra*mscale*1.02;  // point on umbra edge
-	rpt *= r_penumbra*mscale;  // point on penumbra edge
-
-	// modify shadow location for scaled moon
-	Vec3d mdist = shadow - mh;
-	if (mdist.length() > r_penumbra + 2000./AU)
-		return;   // not visible so don't bother drawing
-
-	shadow = mh + mdist*mscale;
-
-	StelProjectorP saveProj = sPainter->getProjector();
-	sPainter->setProjector(core->getProjection(StelCore::FrameHeliocentricEcliptic));
-
-	sPainter->enableTexture2d(true);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	sPainter->setColor(1,1,1);
-
-	glEnable(GL_STENCIL_TEST);
-	// We draw only where the stencil buffer is at 1, i.e. where the moon was drawn
-	glStencilFunc(GL_EQUAL, 0x1, 0x1);
-	// Don't change stencil buffer value
-	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
-
-	// shadow radial texture
-	texEarthShadow->bind();
-
-	Vec3d r;
-
-	// Draw umbra first
-	QVector<Vec2f> texCoordArray;
-	QVector<Vec3d> vertexArray;
-	texCoordArray.reserve(210);
-	vertexArray.reserve(210);
-	texCoordArray << Vec2f(0.f, 0.5f);
-	// johannes: work-around for nasty ATI rendering bug: use y-texture coordinate of 0.5 instead of 0.0
-	vertexArray << shadow;
-
-	const Mat4d& rotMat = Mat4d::rotation(shadow, 2.*M_PI/100.);
-	r = upt;
-	for (int i=1; i<=101; ++i)
-	{
-		// position in texture of umbra edge
-		texCoordArray << Vec2f(0.6f, 0.5f);
-		r.transfo4d(rotMat);
-		vertexArray << shadow + r;
-	}
-	sPainter->setArrays(vertexArray.constData(), texCoordArray.constData());
-	sPainter->drawFromArray(StelPainter::TriangleFan, 102);
-
-	// now penumbra
-	vertexArray.resize(0);
-	texCoordArray.resize(0);
-	Vec3d u;
-	r = rpt;
-	u = upt;
-	for (int i=0; i<=200; i+=2)
-	{
-		r.transfo4d(rotMat);
-		u.transfo4d(rotMat);
-		texCoordArray << Vec2f(0.6f, 0.5f) << Vec2f(1.f, 0.5f); // position in texture of umbra edge
-		vertexArray <<  shadow + u << shadow + r;
-	}
-	sPainter->setArrays(vertexArray.constData(), texCoordArray.constData());
-	sPainter->drawFromArray(StelPainter::TriangleStrip, 202);
-	glDisable(GL_STENCIL_TEST);
-	glClearStencil(0x0);
-	glClear(GL_STENCIL_BUFFER_BIT);	// Clean again to let a clean buffer for later Qt display
-	sPainter->setProjector(saveProj);
-}
 
 void Planet::drawHints(const StelCore* core, const QFont& planetNameFont)
 {
@@ -1118,44 +1519,12 @@
 	sPainter.drawSprite2dMode(screenPos[0], screenPos[1], 11);
 }
 
-Ring::Ring(double radiusMin,double radiusMax,const QString &texname)
+Ring::Ring(float radiusMin, float radiusMax, const QString &texname)
 	 :radiusMin(radiusMin),radiusMax(radiusMax)
 {
 	tex = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/"+texname);
 }
 
-Ring::~Ring(void)
-{
-}
-
-void Ring::draw(StelPainter* sPainter,StelProjector::ModelViewTranformP transfo,double screenSz)
-{
-	screenSz -= 50;
-	screenSz /= 250.0;
-	if (screenSz < 0.0) screenSz = 0.0;
-	else if (screenSz > 1.0) screenSz = 1.0;
-	const int slices = 128+(int)((256-128)*screenSz);
-	const int stacks = 8+(int)((32-8)*screenSz);
-
-	// Normal transparency mode
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	sPainter->setColor(1.f, 1.f, 1.f);
-	sPainter->enableTexture2d(true);
-	glEnable(GL_CULL_FACE);
-	glEnable(GL_BLEND);
-
-	if (tex) tex->bind();
-
-	Mat4d mat = transfo->getApproximateLinearTransfo();
-	  // solve the ring wraparound by culling:
-	  // decide if we are above or below the ring plane
-	const double h = mat.r[ 8]*mat.r[12]
-				   + mat.r[ 9]*mat.r[13]
-				   + mat.r[10]*mat.r[14];
-	sPainter->sRing(radiusMin,radiusMax,(h<0.0)?slices:-slices,stacks, 0);
-	glDisable(GL_CULL_FACE);
-}
-
 
 // draw orbital path of Planet
 void Planet::drawOrbit(const StelCore* core)

=== modified file 'src/core/modules/Planet.hpp'
--- src/core/modules/Planet.hpp	2014-05-23 22:05:02 +0000
+++ src/core/modules/Planet.hpp	2014-06-04 22:13:44 +0000
@@ -43,13 +43,6 @@
 class StelPainter;
 class StelTranslator;
 
-struct TrailPoint
-{
-	Vec3d point;
-	double date;
-};
-
-
 // Class used to store orbital elements
 class RotationElements
 {
@@ -68,13 +61,10 @@
 class Ring
 {
 public:
-	Ring(double radiusMin,double radiusMax,const QString &texname);
-	~Ring(void);
-	void draw(StelPainter* painter, StelProjector::ModelViewTranformP transfo, double screenSz);
+	Ring(float radiusMin, float radiusMax,const QString &texname);
 	double getSize(void) const {return radiusMax;}
-private:
-	const double radiusMin;
-	const double radiusMax;
+	const float radiusMin;
+	const float radiusMax;
 	StelTextureSP tex;
 };
 
@@ -241,20 +231,22 @@
 	static void setOrbitColor(const Vec3f& oc) {orbitColor = oc;}
 	static const Vec3f& getOrbitColor() {return orbitColor;}
 
+	//! Return the list of planets which project some shadow on this planet
+	QVector<const Planet*> getCandidatesForShadow() const;
+	
 protected:
 	static StelTextureSP texEarthShadow;     // for lunar eclipses
 
-	// draw earth shadow on moon for lunar eclipses
-	void drawEarthShadow(StelCore* core, StelPainter* sPainter);
-
+	void computeModelMatrix(Mat4d &result) const;
+	
 	// Return the information string "ready to print" :)
 	QString getSkyLabel(const StelCore* core) const;
 
 	// Draw the 3d model. Call the proper functions if there are rings etc..
-	void draw3dModel(StelCore* core, StelProjector::ModelViewTranformP transfo, float screenSz);
+	void draw3dModel(StelCore* core, StelProjector::ModelViewTranformP transfo, float screenSz, bool drawOnlyRing=false);
 
 	// Draw the 3D sphere
-	void drawSphere(StelPainter* painter, float screenSz);
+	void drawSphere(StelPainter* painter, float screenSz, bool drawOnlyRing=false);
 
 	// Draw the circle and name of the Planet
 	void drawHints(const StelCore* core, const QFont& planetNameFont);
@@ -299,6 +291,34 @@
 
 	static Vec3f labelColor;
 	static StelTextureSP hintCircleTex;
+	
+	// Shader-related variables
+	struct ShaderVars {
+		int projectionMatrix;
+		int texCoord;
+		int unprojectedVertex;
+		int vertex;
+		int texture;
+
+		int lightPos;
+		int diffuseLight;
+		int ambientLight;
+		int shadowCount;
+		int shadowData;
+		int sunInfo;
+		int isRing;
+		int ring;
+		int outerRadius;
+		int innerRadius;
+		int ringS;
+		int isMoon;
+		int earthShadow;
+	};
+	static ShaderVars shaderVars;
+
+	static void initShader();
+	static void deinitShader();
+	static class QOpenGLShaderProgram* shaderProgram;
 };
 
 #endif // _PLANET_HPP_

=== modified file 'src/core/modules/SolarSystem.cpp'
--- src/core/modules/SolarSystem.cpp	2014-05-23 22:05:02 +0000
+++ src/core/modules/SolarSystem.cpp	2014-06-04 22:13:44 +0000
@@ -147,7 +147,7 @@
 
 	texPointer = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/pointeur4.png");
 	Planet::hintCircleTex = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/planet-indicator.png");
-
+	
 	StelApp *app = &StelApp::getInstance();
 	connect(app, SIGNAL(languageChanged()), this, SLOT(updateI18n()));
 	connect(app, SIGNAL(colorSchemeChanged(const QString&)), this, SLOT(setStelStyle(const QString&)));
@@ -158,6 +158,11 @@
 	addAction("actionShow_Planets_Trails", displayGroup, N_("Planet trails"), "trailsDisplayed", "Shift+T");
 }
 
+void SolarSystem::deinit()
+{
+	Planet::deinitShader();
+}
+
 void SolarSystem::recreateTrails()
 {
 	// Create a trail group containing all the planets orbiting the sun (not including satellites)

=== modified file 'src/core/modules/SolarSystem.hpp'
--- src/core/modules/SolarSystem.hpp	2014-05-23 22:05:02 +0000
+++ src/core/modules/SolarSystem.hpp	2014-06-04 22:13:44 +0000
@@ -69,6 +69,8 @@
 	//! - set display options from application settings
 	virtual void init();
 
+	virtual void deinit();
+	
 	//! Draw SolarSystem objects (planets).
 	//! @param core The StelCore object.
 	//! @return The maximum squared distance in pixels that any SolarSystem object