Merge lp:~cardinot/stellarium/MeteorShower into lp:stellarium

[Marcos Cardinot]

* refactoring Meteor and MeteorMgr classes based on MeteorShowers plugin
  - it makes us able to reuse the code on MeteorShowers plugin
* drawing train as a triangular prism;
  - reduce aliasing
  - it makes us able to control thickness
* implements the color of meteors
   - JSON format:
   "colors":
   [
   {
    "color": "white",
    "intensity": 90
   },
   {
    "color": "red",
    "intensity": 10
   },
                        ]
* initial implementation of bolides
* improvements on magnitude managment

[Alexander Wolf (alexwolf)]

Please update default showers.json file.

review: Needs Fixing

[lp:~cardinot/stellarium/MeteorShower]

6886. By Alexander Wolf on 2014-06-26

updated Windows stuff

6887. By Alexander Wolf on 2014-06-26

a bit cleanup of the code

[Marcos Cardinot (cardinot)]

> Please update default showers.json file.

Done! =D

[Fabien Chéreau (xalioth)]

Please wait a bit before merging I want to make the review as well
Le 26 juin 2014 21:23, "Marcos CARDINOT" <email address hidden> a écrit :

> > Please update default showers.json file.
>
> Done! =D
> --
> https://code.launchpad.net/~mcardinot/stellarium/MeteorShower/+merge/224654
> You are subscribed to branch lp:stellarium.
>

[lp:~cardinot/stellarium/MeteorShower]

6888. By barrykgerdes on 2014-06-27

updated textures for M105 area

6889. By Alexander Wolf on 2014-06-27

updated README

[Fabien Chéreau (xalioth)]

Good work!
Please avoid using double when float could do it. It's faster and uses less memory.
Also we should try to avoid using GL_DOUBLE as OpenGL ES2 doesn't support it

[Fabien Chéreau (xalioth)]

So needs a bit of fixinf, but I like the code

review: Needs Fixing

[lp:~cardinot/stellarium/MeteorShower]

6890. By Alexander Wolf on 2014-06-28

Updated message for InnoSetup

[Marcos Cardinot (cardinot)]

Hello Fabien,
thanks a million for your review!

> Please avoid using double when float could do it. It's faster and uses less memory.

Yeah, good point!
done

> Also we should try to avoid using GL_DOUBLE as OpenGL ES2 doesn't support it

Hmmm... what's your suggestion to sort it out?
I saw that we have a Q_ASSERT(array.type == GL_DOUBLE); in StelPainter::projectArray

[Alexander Wolf (alexwolf)]

Marcos, please see diff comments also :)

[Marcos Cardinot (cardinot)]

> Marcos, please see diff comments also :)

Thanks Alex, I hadn't noticed it! =D

Anyway, it seems that I just left things around GL_DOUBLE issue.
What would be the best way to use GL_FLOAT? it seems that just change the type of the vertexArrays is not enough, because we have a QASSERT(type==GL_DOUBLE)...

[Alexander Wolf (alexwolf)]

>Also we should try to avoid using GL_DOUBLE as OpenGL ES2 doesn't support it

What about make a test - use only GL_FLOAT (in StelPainter too)?

[lp:~cardinot/stellarium/MeteorShower]

6891. By Alexander Wolf on 2014-06-29

apply translations for testing (0.13.0beta1)

[Fabien Chéreau (xalioth)]

Hey Marcos,
you are right for the GL_DOUBLE in fact if you let the StelProjector do the
vertex projection it's OK to have GL_DOUBLE, because they are converted to
GL_FLOAT before being sent to opengl.
Fabien

On Sun, Jun 29, 2014 at 8:45 AM, Alexander Wolf <email address hidden>
wrote:

> >Also we should try to avoid using GL_DOUBLE as OpenGL ES2 doesn't support
> it
>
> What about make a test - use only GL_FLOAT (in StelPainter too)?
> --
> https://code.launchpad.net/~mcardinot/stellarium/MeteorShower/+merge/224654
> You are reviewing the proposed merge of
> lp:~mcardinot/stellarium/MeteorShower into lp:stellarium.
>

[lp:~cardinot/stellarium/MeteorShower]

6892. By Alexander Wolf on 2014-06-29

Updated settings for MSVC

6893. By Alexander Wolf on 2014-06-29

tiny fix for MSVC2012

[Alexander Wolf (alexwolf)]

I think it's ready to merge

review: Approve

[Fabien Chéreau (xalioth)]

OK for me

On Sun, Jun 29, 2014 at 7:10 PM, Alexander Wolf <email address hidden>
wrote:

> Review: Approve
>
> I think it's ready to merge
> --
> https://code.launchpad.net/~mcardinot/stellarium/MeteorShower/+merge/224654
> You are reviewing the proposed merge of
> lp:~mcardinot/stellarium/MeteorShower into lp:stellarium.
>

[lp:~cardinot/stellarium/MeteorShower]

6894. By Marcos Cardinot on 2014-06-29

MeteorMgr and MeteorShowers Improvements

=== modified file 'plugins/MeteorShowers/resources/showers.json'
--- plugins/MeteorShowers/resources/showers.json	2014-05-10 23:16:09 +0000
+++ plugins/MeteorShowers/resources/showers.json	2014-06-29 14:51:17 +0000
@@ -290,6 +290,17 @@
 			"radiantDelta": "-10",
 			"driftAlpha": "5",
 			"driftDelta": "1",
+			"colors":
+			[
+			{
+				"color": "white",
+				"intensity": 60
+			},
+			{
+				"color": "yellow",
+				"intensity": 40
+			}
+			],
 			"parentObj": "Comet 169P/NEAT",
 			"pidx": 2.5
 		},
@@ -487,6 +498,21 @@
 			"radiantDelta": "+54",
 			"driftAlpha": "0",
 			"driftDelta": "0",
+			"colors":
+			[
+			{
+				"color": "white",
+				"intensity": 50
+			},
+			{
+				"color": "orangeYellow",
+				"intensity": 30
+			},
+			{
+				"color": "yellow",
+				"intensity": 20
+			}
+			],
 			"parentObj": "Comet 21P/Giacobini-Zinner",
 			"pidx": 2.6
 		},
@@ -630,6 +656,17 @@
 			"radiantDelta": "-1",
 			"driftAlpha": "5",
 			"driftDelta": "2",
+			"colors":
+			[
+			{
+				"color": "white",
+				"intensity": 70
+			},
+			{
+				"color": "yellow",
+				"intensity": 30
+			}
+			],
 			"parentObj": "Comet 1P/Halley",
 			"pidx": 2.4
 		},
@@ -705,6 +742,21 @@
 			"radiantDelta": "+33",
 			"driftAlpha": "5",
 			"driftDelta": "-0.1",
+			"colors":
+			[
+			{
+				"color": "white",
+				"intensity": 65
+			},
+			{
+				"color": "yellow",
+				"intensity": 25
+			},
+			{
+				"color": "greenBlue",
+				"intensity": 10
+			}
+			],
 			"parentObj": "Minor planet (3200) Phaethon",
 			"pidx": 2.6
 		},
@@ -1008,6 +1060,17 @@
 			"radiantDelta": "+22",
 			"driftAlpha": "3",
 			"driftDelta": "-1.25",
+			"colors":
+			[
+			{
+				"color": "blueGreen",
+				"intensity": 50
+			},
+			{
+				"color": "white",
+				"intensity": 50
+			}
+			],
 			"parentObj": "Comet 55P/Tempel-Tuttle",
 			"pidx": 2.5
 		},
@@ -1215,6 +1278,17 @@
 			"radiantDelta": "+22",
 			"driftAlpha": "5",
 			"driftDelta": "1",
+			"colors":
+			[
+			{
+				"color": "yellow",
+				"intensity": 80
+			},
+			{
+				"color": "white",
+				"intensity": 20
+			}
+			],
 			"parentObj": "Comet C/1917 F1 (Mellish)",
 			"pidx": 2.3
 		},
@@ -1268,6 +1342,21 @@
 			"radiantDelta": "+16",
 			"driftAlpha": "3",
 			"driftDelta": "0.5",
+			"colors":
+			[
+			{
+				"color": "white",
+				"intensity": 50
+			},
+			{
+				"color": "greenBlue",
+				"intensity": 30
+			},
+			{
+				"color": "yellow",
+				"intensity": 20
+			}
+			],
 			"pidx": 2.5
 		},
 		"PAU":
@@ -1371,6 +1460,17 @@
 			"radiantDelta": "+58",
 			"driftAlpha": "6",
 			"driftDelta": "1",
+			"colors":
+			[
+			{
+				"color": "white",
+				"intensity": 70
+			},
+			{
+				"color": "blueGreen",
+				"intensity": 30
+			}
+			],
 			"parentObj": "Comet 109P/Swift-Tuttle",
 			"pidx": 2.2
 		},
@@ -1548,6 +1648,17 @@
 			"radiantDelta": "49",
 			"driftAlpha": "3",
 			"driftDelta": "-1",
+			"colors":
+			[
+			{
+				"color": "white",
+				"intensity": 70
+			},
+			{
+				"color": "blueGreen",
+				"intensity": 30
+			}
+			],
 			"parentObj": "Minor planet 2003 EH1 and Comet C/1490 Y1",
 			"pidx": 2.1
 		},
@@ -1622,6 +1733,17 @@
 			"radiantDelta": "-16",
 			"driftAlpha": "4",
 			"driftDelta": "0.5",
+			"colors":
+			[
+			{
+				"color": "white",
+				"intensity": 60
+			},
+			{
+				"color": "yellow",
+				"intensity": 40
+			}
+			],
 			"parentObj": "Comet 96P/Machholz",
 			"pidx": 3.2
 		},
@@ -1727,6 +1849,17 @@
 			"radiantDelta": "+15",
 			"driftAlpha": "3",
 			"driftDelta": "1",
+			"colors":
+			[
+			{
+				"color": "yellow",
+				"intensity": 80
+			},
+			{
+				"color": "white",
+				"intensity": 20
+			}
+			],
 			"parentObj": "Comet 2P/Encke",
 			"pidx": 2.3
 		},

=== modified file 'plugins/MeteorShowers/src/MeteorShower.cpp'
--- plugins/MeteorShowers/src/MeteorShower.cpp	2014-05-22 08:08:43 +0000
+++ plugins/MeteorShowers/src/MeteorShower.cpp	2014-06-29 14:51:17 +0000
@@ -1,4 +1,5 @@
 /*
+ * Stellarium: Meteor Showers Plug-in
  * Copyright (C) 2013 Marcos Cardinot
  * Copyright (C) 2011 Alexander Wolf
  *
@@ -22,17 +23,9 @@
 #include "StelApp.hpp"
 #include "StelCore.hpp"
 #include "StelModuleMgr.hpp"
-#include "StelObject.hpp"
-#include "StelPainter.hpp"
 #include "StelTexture.hpp"
 #include "StelUtils.hpp"
 
-#include <QDebug>
-#include <QList>
-#include <QTextStream>
-#include <QVariant>
-#include <QVariantMap>
-
 StelTextureSP MeteorShower::radiantTexture;
 float MeteorShower::showLabels = true;
 bool MeteorShower::radiantMarkerEnabled = true;
@@ -82,6 +75,17 @@
 		}
 	}
 
+	if(map.contains("colors"))
+	{
+		foreach(const QVariant &ms, map.value("colors").toList())
+		{
+			QVariantMap colorMap = ms.toMap();
+			QString color = colorMap.value("color").toString();
+			int intensity = colorMap.value("intensity").toInt();
+			colors.append(colorPair(color, intensity));
+		}
+	}
+
 	updateCurrentData(getSkyQDateTime());
 	// ensures that all objects will be drawn once
 	// that's to avoid crashes by trying select a nonexistent object
@@ -123,6 +127,16 @@
 	}
 	map["activity"] = activityList;
 
+	QVariantList colorList;
+	foreach(const colorPair &c, colors)
+	{
+		QVariantMap colorMap;
+		colorMap["color"] = c.first;
+		colorMap["intensity"] = c.second;
+		colorList << colorMap;
+	}
+	map["colors"] = colorList;
+
 	return map;
 }
 

=== modified file 'plugins/MeteorShowers/src/MeteorShower.hpp'
--- plugins/MeteorShowers/src/MeteorShower.hpp	2014-05-06 12:09:45 +0000
+++ plugins/MeteorShowers/src/MeteorShower.hpp	2014-06-29 14:51:17 +0000
@@ -1,4 +1,5 @@
 /*
+ * Stellarium: Meteor Showers Plug-in
  * Copyright (C) 2013 Marcos Cardinot
  * Copyright (C) 2011 Alexander Wolf
  *
@@ -21,8 +22,6 @@
 #define _METEORSHOWER_HPP_
 
 #include <QDateTime>
-#include <QVariantMap>
-#include <QString>
 
 #include "StelFader.hpp"
 #include "StelObject.hpp"
@@ -30,8 +29,6 @@
 #include "StelTextureTypes.hpp"
 #include "StelTranslator.hpp"
 
-class StelPainter;
-
 //! @class MeteorShower
 //! A MeteorShower object represents one meteor shower on the sky.
 //! Details about the meteor showers are passed using a QVariant which contains
@@ -105,6 +102,9 @@
 		return zhr;
 	}
 
+	//! <colorName, intensity>
+	typedef QPair<QString, int> colorPair;
+
 private:
 	Vec3d XYZ;                      //! Cartesian equatorial position
 	Vec3d XY;                       //! Store temporary 2D position
@@ -131,12 +131,13 @@
 	QString designation;            //! The designation of the meteor shower
 	QList<activityData> activity;	//! List of activity
 	int speed;                      //! Speed of meteors
-	double rAlphaPeak;              //! R.A. for radiant of meteor shower on the peak day
-	double rDeltaPeak;              //! Dec. for radiant of meteor shower on the peak day
-	double driftAlpha;		//! Drift of R.A.
-	double driftDelta;		//! Drift of Dec.
+	float rAlphaPeak;               //! R.A. for radiant of meteor shower on the peak day
+	float rDeltaPeak;               //! Dec. for radiant of meteor shower on the peak day
+	float driftAlpha;		//! Drift of R.A.
+	float driftDelta;		//! Drift of Dec.
 	QString parentObj;		//! Parent object for meteor shower
 	float pidx;			//! The population index
+	QList<colorPair> colors;	//! <colorName, 0-100>
 
 	//current information
 	double radiantAlpha;            //! Current R.A. for radiant of meteor shower

=== modified file 'plugins/MeteorShowers/src/MeteorShowers.cpp'
--- plugins/MeteorShowers/src/MeteorShowers.cpp	2014-05-31 07:52:58 +0000
+++ plugins/MeteorShowers/src/MeteorShowers.cpp	2014-06-29 14:51:17 +0000
@@ -1,4 +1,5 @@
 /*
+ * Stellarium: Meteor Showers Plug-in
  * Copyright (C) 2013 Marcos Cardinot
  * Copyright (C) 2011 Alexander Wolf
  *
@@ -17,22 +18,16 @@
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
  */
 
-#include <QColor>
-#include <QDebug>
 #include <QDir>
-#include <QFileInfo>
-#include <QList>
-#include <QNetworkAccessManager>
 #include <QNetworkReply>
+#include <QSettings>
 #include <QTimer>
-#include <QSettings>
 
 #include "LabelMgr.hpp"
 #include "LandscapeMgr.hpp"
-#include "MeteorShower.hpp"
+#include "MeteorMgr.hpp"
+#include "MeteorShowerDialog.hpp"
 #include "MeteorShowers.hpp"
-#include "MeteorShowerDialog.hpp"
-#include "MeteorStream.hpp"
 #include "Planet.hpp"
 #include "StelApp.hpp"
 #include "StelCore.hpp"
@@ -42,15 +37,12 @@
 #include "StelJsonParser.hpp"
 #include "StelModuleMgr.hpp"
 #include "StelObjectMgr.hpp"
-#include "StelPainter.hpp"
 #include "StelProgressController.hpp"
-#include "StelProjector.hpp"
 #include "StelTextureMgr.hpp"
-#include "StelUtils.hpp"
 
 #define CATALOG_FORMAT_VERSION 1 /* Version of format of catalog */
 
-const double MeteorShowers::zhrToWsr = 1.6667f / 3600.f;
+const double MeteorShowers::zhrToWsr = MeteorMgr::zhrToWsr;
 
 /*
  This method is the one called automatically by the StelModuleMgr just
@@ -138,7 +130,7 @@
 {
 	if (actionName == StelModule::ActionDraw)
 	{
-		return StelApp::getInstance().getModuleMgr().getModule("MeteorMgr")->getCallOrder(actionName)+0;
+		return GETSTELMODULE(MeteorMgr)->getCallOrder(actionName)+10.;
 	}
 
 	return 0;
@@ -371,16 +363,12 @@
 
 void MeteorShowers::drawStream(StelCore* core, StelPainter& painter)
 {
-	LandscapeMgr* landmgr = (LandscapeMgr*)StelApp::getInstance().getModuleMgr().getModule("LandscapeMgr");
+	LandscapeMgr* landmgr = GETSTELMODULE(LandscapeMgr);
 	if (landmgr->getFlagAtmosphere() && landmgr->getLuminance()>5)
 	{
 		return;
 	}
 
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable(GL_BLEND);
-	painter.enableTexture2d(false);
-
 	int index = 0;
 	if (active.size() > 0)
 	{
@@ -388,7 +376,8 @@
 		{
 			Q_UNUSED(a);
 			// step through and draw all active meteors
-			for (std::vector<MeteorStream*>::iterator iter = active[index].begin(); iter != active[index].end(); ++iter)
+			std::vector<MeteorStream*>::iterator iter;
+			for (iter = active[index].begin(); iter != active[index].end(); ++iter)
 			{
 				(*iter)->draw(core, painter);
 			}
@@ -480,6 +469,7 @@
 					newData.finish = ms->finish;
 					newData.peak = ms->peak;
 					newData.status = ms->status;
+					newData.colors = ms->colors;
 					activeInfo.append(newData);
 				}
 				else //just overwrites
@@ -505,6 +495,20 @@
 	}
 
 	StelCore* core = StelApp::getInstance().getCore();
+
+	double tspeed = core->getTimeRate()*86400;  // sky seconds per actual second
+	if (!tspeed) { // is paused?
+		return; // freeze meteors at the current position
+	}
+
+	deltaTime*=1000;
+	// if stellarium has been suspended, don't create huge number of meteors to
+	// make up for lost time!
+	if (deltaTime > 500)
+	{
+		deltaTime = 500;
+	}
+
 	QList<activeData> old_activeInfo;
 
 	//check if the sky date changed
@@ -546,8 +550,6 @@
 		}
 	}
 
-	deltaTime*=1000;
-
 	std::vector<std::vector<MeteorStream*> >::iterator iterOut;
 	std::vector<MeteorStream*>::iterator iterIn;
 	index = 0;
@@ -578,19 +580,23 @@
 	index = 0;
 	foreach (const activeData &current, activeInfo)
 	{
+		std::vector<MeteorStream*> aux;
+		if (active.empty() || active.size() < (unsigned) activeInfo.size())
+		{
+			if(tspeed<0 || fabs(tspeed)>1.)
+			{
+				activeInfo.removeAt(index);
+				continue; // don't create new meteors
+			}
+			active.push_back(aux);
+		}
+
 		int ZHR = calculateZHR(current.zhr,
 				       current.variable,
 				       current.start,
 				       current.finish,
 				       current.peak);
 
-		// if stellarium has been suspended, don't create huge number of meteors to
-		// make up for lost time!
-		if (deltaTime > 500)
-		{
-			deltaTime = 500;
-		}
-
 		// determine average meteors per frame needing to be created
 		int mpf = (int)((double)ZHR*zhrToWsr*deltaTime/1000.0 + 0.5);
 		if (mpf<1)
@@ -598,12 +604,6 @@
 			mpf = 1;
 		}
 
-		std::vector<MeteorStream*> aux;
-		if (active.empty() || active.size() < (unsigned) activeInfo.size())
-		{
-			active.push_back(aux);
-		}
-
 		for (int i=0; i<mpf; ++i)
 		{
 			// start new meteor based on ZHR time probability
@@ -614,7 +614,8 @@
 								   current.speed,
 								   current.radiantAlpha,
 								   current.radiantDelta,
-								   current.pidx);
+								   current.pidx,
+								   current.colors);
 				active[index].push_back(m);
 			}
 		}

=== modified file 'plugins/MeteorShowers/src/MeteorShowers.hpp'
--- plugins/MeteorShowers/src/MeteorShowers.hpp	2014-04-25 12:54:45 +0000
+++ plugins/MeteorShowers/src/MeteorShowers.hpp	2014-06-29 14:51:17 +0000
@@ -1,4 +1,5 @@
 /*
+ * Stellarium: Meteor Showers Plug-in
  * Copyright (C) 2013 Marcos Cardinot
  * Copyright (C) 2011 Alexander Wolf
  *
@@ -20,27 +21,16 @@
 #ifndef METEORSHOWERS_HPP_
 #define METEORSHOWERS_HPP_
 
+#include <QColor>
+
 #include "MeteorShower.hpp"
 #include "MeteorStream.hpp"
-#include "StelFader.hpp"
-#include "StelModule.hpp"
 #include "StelObjectModule.hpp"
-#include "StelTextureTypes.hpp"
-
-#include <QColor>
-#include <QDateTime>
-#include <QFont>
-#include <QSharedPointer>
-#include <QVariantMap>
-
+
+class MeteorShowerDialog;
 class QNetworkAccessManager;
 class QNetworkReply;
-class QProgressBar;
-class QSettings;
-class QTimer;
-class MeteorShowerDialog;
 class StelButton;
-class StelPainter;
 
 typedef QSharedPointer<MeteorShower> MeteorShowerP;
 
@@ -365,17 +355,18 @@
 
 	typedef struct
 	{
-		QString showerID;	//! The ID of the meteor shower
-		QDateTime start;	//! First day for activity
-		QDateTime finish;	//! Latest day for activity
-		QDateTime peak;		//! Day with maximum for activity
-		int status;		//! 0:inactive 1:activeRealData 2:activeGenericData
-		int zhr;		//! ZHR of shower
-		QString variable;	//! value of variable for ZHR
-		int speed;		//! Speed of meteors
-		double radiantAlpha;    //! R.A. for radiant of meteor shower
-		double radiantDelta;    //! Dec. for radiant of meteor shower
-		float pidx;		//! Population index
+		QString showerID;		//! The ID of the meteor shower
+		QDateTime start;		//! First day for activity
+		QDateTime finish;		//! Latest day for activity
+		QDateTime peak;			//! Day with maximum for activity
+		int status;			//! 0:inactive 1:activeRealData 2:activeGenericData
+		int zhr;			//! ZHR of shower
+		QString variable;		//! value of variable for ZHR
+		int speed;			//! Speed of meteors
+		float radiantAlpha;		//! R.A. for radiant of meteor shower
+		float radiantDelta;		//! Dec. for radiant of meteor shower
+		float pidx;			//! Population index
+		QList<MeteorShower::colorPair> colors;	//! Population index
 	} activeData;
 
 	QList<activeData> activeInfo;	//! List of active meteors

=== modified file 'plugins/MeteorShowers/src/MeteorStream.cpp'
--- plugins/MeteorShowers/src/MeteorStream.cpp	2014-05-08 21:22:20 +0000
+++ plugins/MeteorShowers/src/MeteorStream.cpp	2014-06-29 14:51:17 +0000
@@ -1,4 +1,5 @@
 /*
+ * Stellarium: Meteor Showers Plug-in
  * Copyright (C) 2013 Marcos Cardinot
  *
  * This program is free software; you can redistribute it and/or
@@ -16,116 +17,78 @@
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
  */
 
-#include <cstdlib>
-
+#include "MeteorShowers.hpp"
 #include "MeteorStream.hpp"
-#include "StelCore.hpp"
-#include "StelToneReproducer.hpp"
-#include "StelMovementMgr.hpp"
-#include "StelPainter.hpp"
 
 MeteorStream::MeteorStream(const StelCore* core,
-			   double speed,
-			   double radiantAlpha,
-			   double radiantDelta,
-			   float pidx)
+			   int speed,
+			   float radiantAlpha,
+			   float radiantDelta,
+			   float pidx,
+			   QList<MeteorShower::colorPair> colors)
 	: m_speed(speed)
-	, m_pidx(pidx)
-	, m_minDist(0.)
-	, m_distMultiplier(0.)
-	, m_startH(0.)
-	, m_endH(0.)
-	, m_mag(1.f)
+	, m_segments(10)
 {
-
 	// if speed is zero, use a random value
 	if (!speed)
 	{
 		m_speed = 11+(double)rand()/((double)RAND_MAX+1)*61;  // abs range 11-72 km/s
 	}
 
-	// the meteor starts dead, after we'll calculate the position
-	// if the position is within the bounds, this parameter will be changed to TRUE
-	m_alive = false;
-
-	double high_range = EARTH_RADIUS+HIGH_ALTITUDE;
-	double low_range = EARTH_RADIUS+LOW_ALTITUDE;
-
 	// view matrix of meteor model
 	m_viewMatrix = Mat4d::zrotation(radiantAlpha) * Mat4d::yrotation(M_PI_2 - radiantDelta);
 
-	// find observer position in meteor coordinate system
-	m_obs = core->altAzToJ2000(Vec3d(0,0,EARTH_RADIUS));
-	m_obs.transfo4d(m_viewMatrix.transpose());
-
-	// select random trajectory using polar coordinates in XY plane, centered on observer
-	m_xydistance = (double)rand() / ((double)RAND_MAX+1)*(VISIBLE_RADIUS);
-	double angle = (double)rand() / ((double)RAND_MAX+1)*2*M_PI;
-
-	// set meteor start x,y
-	m_position[0] = m_posInternal[0] = m_posTrain[0] = m_xydistance*cos(angle) + m_obs[0];
-	m_position[1] = m_posInternal[1] = m_posTrain[1] = m_xydistance*sin(angle) + m_obs[1];
-
-	// D is distance from center of earth
-	double D = sqrt(m_position[0]*m_position[0] + m_position[1]*m_position[1]);
-
-	if (D > high_range)     // won't be visible, meteor still dead
+	// building meteor model
+	m_alive = Meteor::initMeteorModel(core, m_segments, m_viewMatrix, meteor);
+	if (!m_alive)
 	{
 		return;
 	}
 
-	m_posTrain[2] = m_position[2] = m_startH = sqrt(high_range*high_range - D*D);
-
-	// determine end of burn point, and nearest point to observer for distance mag calculation
-	// mag should be max at nearest point still burning
-	m_endH = -m_startH;  // earth grazing
-	m_minDist = m_xydistance;
-	if (D <= low_range)
-	{
-		m_endH = sqrt(low_range*low_range - D*D);
-		m_minDist = sqrt(m_xydistance*m_xydistance + pow(m_endH - m_obs[2], 2));
-	}
-
-	if (m_minDist > VISIBLE_RADIUS)
-	{
-		// on average, not visible (although if were zoomed ...)
-		return; //meteor still dead
-	}
-
-	// If everything is ok until here,
-	m_alive = true;  //the meteor is alive
-
-	// determine intensity [-3; 4.5]
-	float Mag1 = (double)rand()/((double)RAND_MAX+1)*7.5f - 3;
-	float Mag2 = (double)rand()/((double)RAND_MAX+1)*7.5f - 3;
-	float Mag = (Mag1 + Mag2)/2.0f;
-
-	// compute RMag and CMag
-	RCMag rcMag;
-	core->getSkyDrawer()->computeRCMag(Mag, &rcMag);
-	m_mag = rcMag.luminance;
-
-	// most visible meteors are under about 180km distant
-	// scale max mag down if outside this range
-	float scale = 1;
-	if (m_minDist!=0)
-	{
-		scale = 180*180 / (m_minDist*m_minDist);
-	}
-	if (scale < 1)
-	{
-		m_mag *= scale;
-	}
-
 	// implements the population index
 	float oneMag = -0.2; // negative, working in different scale ( 0 to 1 - where 1 is brighter)
-	if (m_pidx) // is not zero
+	if (pidx) // is not zero
 	{
 		if (rand()%100 < 100.f/pidx) // probability
 		{
-			m_mag += oneMag;  // (m+1)
-		}
-	}
+			meteor.mag += oneMag;  // (m+1)
+		}
+	}
+
+	// determine the meteor color
+	if (colors.isEmpty()) {
+		colors.push_back(MeteorShower::colorPair("white", 100));
+	} else {
+		// handle cases when the total intensity is less than 100
+		int totalIntensity = 0;
+		int indexWhite = -1;
+		for (int i=0; i<colors.size(); i++) {
+			totalIntensity += colors.at(i).second;
+			if (colors.at(i).first == "white") {
+				indexWhite = i;
+			}
+		}
+
+		int increaseWhite = 0;
+		if (totalIntensity > 100) {
+			qDebug() << "MeteorShowers plugin (showers.json): Total intensity must be less than 100";
+			colors.clear();
+			colors.push_back(MeteorShower::colorPair("white", 100));
+		} else {
+			increaseWhite = 100 - totalIntensity;
+		}
+
+		if (increaseWhite > 0) {
+			if (indexWhite == -1) {
+				colors.push_back(MeteorShower::colorPair("white", increaseWhite));
+			} else {
+				colors[indexWhite].second = increaseWhite;
+			}
+		}
+	}
+
+	// building lineColorArray and trainColorArray
+	Meteor::buildColorArrays(m_segments, colors, m_lineColorArray, m_trainColorArray);
 }
 
 MeteorStream::~MeteorStream()
@@ -140,34 +103,11 @@
 		return false;
 	}
 
-	if (m_position[2] < m_endH)
-	{
-		// burning has stopped so magnitude fades out
-		// assume linear fade out
-		m_mag -= deltaTime/1000.0f;
-		if(m_mag < 0)
-		{
-			m_alive = false;    // no longer visible
-		}
-	}
-
-	// *** would need time direction multiplier to allow reverse time replay
-	m_position[2] -= m_speed*deltaTime/1000.0f;
-
-	// train doesn't extend beyond start of burn
-	if (m_position[2] + m_speed*0.5f > m_startH)
-	{
-		m_posTrain[2] = m_startH;
-	}
-	else
-	{
-		m_posTrain[2] -= m_speed*deltaTime/1000.0f;
-	}
+	m_alive = Meteor::updateMeteorModel(deltaTime, m_speed, meteor);
 
 	return m_alive;
 }
 
-
 // returns true if visible
 // Assumes that we are in local frame
 void MeteorStream::draw(const StelCore* core, StelPainter& sPainter)
@@ -177,48 +117,11 @@
 		return;
 	}
 
-	Vec3d spos = m_position;
-	Vec3d epos = m_posTrain;
-
-	// convert to equ
-	spos.transfo4d(m_viewMatrix);
-	epos.transfo4d(m_viewMatrix);
-
-	// convert to local and correct for earth radius
-	//[since equ and local coordinates in stellarium use same 0 point!]
-	spos = core->j2000ToAltAz(spos);
-	epos = core->j2000ToAltAz(epos);
-	spos[2] -= EARTH_RADIUS;
-	epos[2] -= EARTH_RADIUS;
-	// 1216 is to scale down under 1 for desktop version
-	spos/=1216;
-	epos/=1216;
-
-	QVector<Vec4f> colorArray;
-	QVector<Vec3d> vertexArray;
-	// last point - dark
-	colorArray.push_back(Vec4f(0,0,0,0));
-	vertexArray.push_back(epos);
-	// compute intermediate points to curve along projection distortions
-	int segments = 10;
-	for (int i=1; i<segments; i++) {
-		Vec3d posi = m_posInternal;
-		posi[2] = m_posTrain[2] + i*(m_position[2] - m_posTrain[2])/segments;
-		posi.transfo4d(m_viewMatrix);
-		posi = core->j2000ToAltAz(posi);
-		posi[2] -= EARTH_RADIUS;
-		posi/=1216;
-
-		colorArray.push_back(Vec4f(1,1,1,i*m_mag/segments));
-		vertexArray.push_back(posi);
-	}
-	// first point - light
-	colorArray.push_back(Vec4f(1,1,1,m_mag));
-	vertexArray.push_back(spos);
-
-	sPainter.setColorPointer(4, GL_FLOAT, colorArray.constData());
-	sPainter.setVertexPointer(3, GL_DOUBLE, vertexArray.constData());
-	sPainter.enableClientStates(true, false, true);
-	sPainter.drawFromArray(StelPainter::LineStrip, vertexArray.size(), 0, true);
-	sPainter.enableClientStates(false);
+	float thickness, bolideSize;
+	Meteor::calculateThickness(core, thickness, bolideSize);
+
+	Meteor::drawTrain(core, sPainter, meteor, m_viewMatrix, thickness,
+			  m_segments, m_lineColorArray, m_trainColorArray);
+
+	Meteor::drawBolide(core, sPainter, meteor, m_viewMatrix, bolideSize);
 }

=== modified file 'plugins/MeteorShowers/src/MeteorStream.hpp'
--- plugins/MeteorShowers/src/MeteorStream.hpp	2014-05-08 21:22:20 +0000
+++ plugins/MeteorShowers/src/MeteorStream.hpp	2014-06-29 14:51:17 +0000
@@ -1,4 +1,5 @@
 /*
+ * Stellarium: Meteor Showers Plug-in
  * Copyright (C) 2013 Marcos Cardinot
  *
  * This program is free software; you can redistribute it and/or
@@ -19,22 +20,17 @@
 #ifndef _METEORSTREAM_HPP_
 #define _METEORSTREAM_HPP_
 
+#include "Meteor.hpp"
 #include "VecMath.hpp"
+
 class StelCore;
 class StelPainter;
 
-// all in km - altitudes make up meteor range
-#define EARTH_RADIUS 6369.f
-#define VISIBLE_RADIUS 457.8f
-#define HIGH_ALTITUDE 115.f
-#define LOW_ALTITUDE 70.f
-
 //! @class MeteorStream
 //! Models a single meteor.
 //! Control of the meteor rate is performed in the MeteorShowers class.  Once
 //! created, a meteor object only lasts for some amount of time, and then
-//! "dies", after which, the update() member returns false.  The live/dead
-//! status of a meteor may also be determined using the isAlive member.
+//! "dies", after which, the update() member returns false.
 class MeteorStream
 {
 public:
@@ -44,10 +40,11 @@
 	//! @param rDelta the radiant delta in rad
 	//! @param pidx population index
 	MeteorStream(const StelCore*,
-		     double speed,
-		     double radiantAlpha,
-		     double radiantDelta,
-		     float pidx);
+		     int speed,
+		     float radiantAlpha,
+		     float radiantDelta,
+		     float pidx,
+		     QList<MeteorShower::colorPair> colors);
 
 	virtual ~MeteorStream();
 
@@ -61,22 +58,13 @@
 private:
 	bool m_alive;             //! Indicate if the meteor it still visible
 
-	Mat4d m_viewMatrix;       //! View Matrix
-	Vec3d m_obs;              //! Observer position
-	Vec3d m_position;         //! Equatorial coordinate position
-	Vec3d m_posInternal;      //! Middle of train
-	Vec3d m_posTrain;         //! End of train
-
-	double m_speed;           //! Velocity of meteor in km/s
-	float m_pidx;             //! population index
-	double m_xydistance;      //! Distance in XY plane (orthogonal to meteor path) from observer to meteor
-	double m_minDist;         //! Nearest point to observer along path
-	double m_distMultiplier;  //! Scale magnitude due to changes in distance
-
-	double m_startH;          //! Start height above center of earth
-	double m_endH;            //! End height
-
-	float m_mag;              //! Apparent magnitude at head, 0-1
+	float m_speed;              //! Velocity of meteor in km/s
+	Mat4d m_viewMatrix;         //! View Matrix
+	Meteor::MeteorModel meteor; //! Parameters of meteor model
+
+	QList<Vec4f> m_trainColorArray;
+	QList<Vec4f> m_lineColorArray;
+	int m_segments;                 //! Number of segments along the train
 };
 
 #endif // _METEORSTREAM_HPP_

=== modified file 'plugins/MeteorShowers/src/gui/MeteorShowerDialog.cpp'
--- plugins/MeteorShowers/src/gui/MeteorShowerDialog.cpp	2014-04-25 12:36:50 +0000
+++ plugins/MeteorShowers/src/gui/MeteorShowerDialog.cpp	2014-06-29 14:51:17 +0000
@@ -1,6 +1,5 @@
 /*
- * Stellarium Meteor Shower plugin config dialog
- *
+ * Stellarium: Meteor Showers Plug-in
  * Copyright (C) 2013 Marcos Cardinot
  * Copyright (C) 2011 Alexander Wolf
  *

=== modified file 'plugins/MeteorShowers/src/gui/MeteorShowerDialog.hpp'
--- plugins/MeteorShowers/src/gui/MeteorShowerDialog.hpp	2014-04-15 02:05:50 +0000
+++ plugins/MeteorShowers/src/gui/MeteorShowerDialog.hpp	2014-06-29 14:51:17 +0000
@@ -1,6 +1,5 @@
 /*
- * Stellarium Meteor Shower Plug-in GUI
- * 
+ * Stellarium: Meteor Showers Plug-in
  * Copyright (C) 2013 Marcos Cardinot
  * Copyright (C) 2011 Alexander Wolf
  * 

=== modified file 'src/core/modules/Meteor.cpp'
--- src/core/modules/Meteor.cpp	2014-04-15 19:00:10 +0000
+++ src/core/modules/Meteor.cpp	2014-06-29 14:51:17 +0000
@@ -1,6 +1,7 @@
 /*
  * Stellarium
- * This file Copyright (C) 2004 Robert Spearman
+ * Copyright (C) 2004 Robert Spearman
+ * Copyright (C) 2014 Marcos Cardinot
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -17,248 +18,416 @@
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
  */
 
-// This is an ad hoc meteor model
-// Could use a simple ablation physics model in the future
-
-/*
-NOTE: Here the radiant is always along the ecliptic at the apex of the Earth's way.
-In reality, individual meteor streams have varying velocity vectors and therefore radiants
-which are generally not at the apex of the Earth's way, such as the Perseids shower.
-*/
-
-// Improved realism and efficiency 2004-12
-
-#include <cstdlib>
 #include "Meteor.hpp"
 #include "StelCore.hpp"
-
-#include "StelToneReproducer.hpp"
 #include "StelMovementMgr.hpp"
 #include "StelPainter.hpp"
-
-Meteor::Meteor(const StelCore* core, double v)
-	: train(false)
-	, startH(0.)
-	, endH(0.)
-	, mag(1.)
-	, absMag(1.)
-	, visMag(1.)		
-	, initDist(0.)
-	, minDist(0.)
-	, distMultiplier(0.)
+#include "StelTexture.hpp"
+
+StelTextureSP Meteor::bolideTexture;
+
+Meteor::Meteor(const StelCore* core, float v)
+	: m_distMultiplier(0.)
+	, m_segments(10)
 {
-	const StelToneReproducer* eye = core->getToneReproducer();
-	
-	velocity = 11+(double)rand()/((double)RAND_MAX+1)*(v-11);  // abs range 11-72 km/s by default (see line 427 in StelApp.cpp)
-	maxMag = 1;
+	// determine meteor velocity
+	// abs range 11-72 km/s by default (see line 427 in StelApp.cpp)
+	m_speed = 11+(float)rand()/((float)RAND_MAX+1)*(v-11);
 
 	// view matrix of sporadic meteors model
-	double alpha = (double)rand()/((double)RAND_MAX+1)*2*M_PI;
-	double delta = M_PI_2 - (double)rand()/((double)RAND_MAX+1)*M_PI;
-	mmat = Mat4d::zrotation(alpha) * Mat4d::yrotation(delta);
+	float alpha = (double)rand()/((double)RAND_MAX+1)*2*M_PI;
+	float delta = M_PI_2 - (double)rand()/((double)RAND_MAX+1)*M_PI;
+	m_viewMatrix = Mat4d::zrotation(alpha) * Mat4d::yrotation(delta);
+
+	// building meteor model
+	m_alive = initMeteorModel(core, m_segments, m_viewMatrix, meteor);
+	if (!m_alive)
+	{
+		return;
+	}
+
+	// building lineColorArray and trainColorArray
+	buildColorArrays(m_segments, getRandColor(), m_lineColorArray, m_trainColorArray);
+}
+
+Meteor::~Meteor()
+{
+}
+
+// returns true if alive
+bool Meteor::initMeteorModel(const StelCore* core, const int segments, const Mat4d viewMatrix, MeteorModel &mm)
+{
+	float high_range = EARTH_RADIUS + HIGH_ALTITUDE;
+	float low_range = EARTH_RADIUS + LOW_ALTITUDE;
+
+	// find observer position in meteor coordinate system
+	mm.obs = core->altAzToJ2000(Vec3d(0,0,EARTH_RADIUS));
+	mm.obs.transfo4d(viewMatrix.transpose());
 
 	// select random trajectory using polar coordinates in XY plane, centered on observer
-	xydistance = (double)rand()/((double)RAND_MAX+1)*(VISIBLE_RADIUS);
-	double angle = (double)rand()/((double)RAND_MAX+1)*2*M_PI;
-
-	// find observer position in meteor coordinate system
-	obs = core->altAzToEquinoxEqu(Vec3d(0,0,EARTH_RADIUS));
-	obs.transfo4d(mmat.transpose());
+	mm.xydistance = (double)rand() / ((double)RAND_MAX+1)*(VISIBLE_RADIUS);
+	float angle = (double)rand() / ((double)RAND_MAX+1)*2*M_PI;
 
 	// set meteor start x,y
-	posInternal[0] = posTrain[0] = position[0] = xydistance*cos(angle) +obs[0];
-	posInternal[1] = posTrain[1] = position[1] = xydistance*sin(angle) +obs[1];
-
-	// determine life of meteor (start and end z value based on atmosphere burn altitudes)
+	mm.position[0] = mm.posTrain[0] = mm.xydistance*cos(angle) + mm.obs[0];
+	mm.position[1] = mm.posTrain[1] = mm.xydistance*sin(angle) + mm.obs[1];
 
 	// D is distance from center of earth
-	double D = sqrt( position[0]*position[0] + position[1]*position[1] );
+	float D = sqrt(mm.position[0]*mm.position[0] + mm.position[1]*mm.position[1]);
 
-	if( D > EARTH_RADIUS+HIGH_ALTITUDE ) {
-		// won't be visible
-		alive = 0;
-		return;
+	if (D > high_range)     // won't be visible, meteor still dead
+	{
+		return false;
 	}
 
-	startH = sqrt( pow(EARTH_RADIUS+HIGH_ALTITUDE,2) - D*D);
+	mm.posTrain[2] = mm.position[2] = mm.startH = sqrt(high_range*high_range - D*D);
 
 	// determine end of burn point, and nearest point to observer for distance mag calculation
 	// mag should be max at nearest point still burning
-	if( D > EARTH_RADIUS+LOW_ALTITUDE ) {
-		endH = -startH;  // earth grazing
-		minDist = xydistance;
-	} else {
-		endH = sqrt( pow(EARTH_RADIUS+LOW_ALTITUDE,2) - D*D);
-		minDist = sqrt( xydistance*xydistance + pow( endH - obs[2], 2) );
+	if (D > low_range)
+	{
+		mm.endH = -mm.startH;  // earth grazing
+		mm.minDist = mm.xydistance;
+	}
+	else
+	{
+		mm.endH = sqrt(low_range*low_range - D*D);
+		mm.minDist = sqrt(mm.xydistance*mm.xydistance + pow(mm.endH - mm.obs[2], 2));
 	}
 
-	if(minDist > VISIBLE_RADIUS ) {
+	if (mm.minDist > VISIBLE_RADIUS)
+	{
 		// on average, not visible (although if were zoomed ...)
-		alive = 0;
-		return;
-	}
-
-	/* experiment
-	// limit lifetime to 0.5-3.0 sec
-	double tmp_h = startH - velocity * (0.5 + (double)rand()/((double)RAND_MAX+1) * 2.5);
-	if( tmp_h > endH ) {
-		endH = tmp_h;
-	}
-	*/
-
-	posTrain[2] = position[2] = startH;
-
-	//  qDebug("New meteor: %f %f s:%f e:%f v:%f\n", position[0], position[1], startH, endH, velocity);
-
-	alive = 1;
-	train=0;
-
-	// Determine drawing color given magnitude and eye
-	// (won't be visible during daylight)
-
-	// *** color varies somewhat based on velocity, plus atmosphere reddening
-
-	// determine intensity
-	float Mag1 = (double)rand()/((double)RAND_MAX+1)*6.75f - 3;
-	float Mag2 = (double)rand()/((double)RAND_MAX+1)*6.75f - 3;
+		return false; //meteor still dead
+	}
+
+	// determine intensity [-3; 4.5]
+	float Mag1 = (double)rand()/((double)RAND_MAX+1)*7.5f - 3;
+	float Mag2 = (double)rand()/((double)RAND_MAX+1)*7.5f - 3;
 	float Mag = (Mag1 + Mag2)/2.0f;
 
-	mag = (5. + Mag) / 256.0;
-	if (mag>250) mag = mag - 256;
-
-	float term1 = std::exp(-0.92103f*(mag + 12.12331f)) * 108064.73f;
-
-	float cmag=1.f;
-	float rmag;
-
-	// Compute the equivalent star luminance for a 5 arc min circle and convert it
-	// in function of the eye adaptation
-	rmag = eye->adaptLuminanceScaled(term1);
-	rmag = rmag/powf(core->getMovementMgr()->getCurrentFov(),0.85f)*500.f;
-
-	// if size of star is too small (blink) we put its size to 1.2 --> no more blink
-	// And we compensate the difference of brighteness with cmag
-	if (rmag<1.2f) {
-		cmag=rmag*rmag/1.44f;
-	}
-
-	mag = cmag;  // assumes white
+	// compute RMag and CMag
+	RCMag rcMag;
+	core->getSkyDrawer()->computeRCMag(Mag, &rcMag);
+	mm.mag = rcMag.luminance;
 
 	// most visible meteors are under about 180km distant
 	// scale max mag down if outside this range
 	float scale = 1;
-	if(minDist!=0) scale = 180*180/(minDist*minDist);
-	if( scale < 1 ) mag *= scale;
-
-}
-
-Meteor::~Meteor()
-{   
-}
-
-// returns true if alive
-bool Meteor::update(double deltaTime)
-{
-	if(!alive) return(0);
-
-	if( position[2] < endH ) {
+	if (mm.minDist)
+	{
+		scale = 180*180 / (mm.minDist*mm.minDist);
+	}
+	if (scale < 1)
+	{
+		mm.mag *= scale;
+	}
+
+	mm.firstBrightSegment = (double)rand()/((double)RAND_MAX+1)*segments;
+
+	// If everything is ok until here,
+	return true;  //the meteor is alive
+}
+
+Vec4f Meteor::getColorFromName(QString colorName) {
+	int R, G, B; // 0-255
+	if (colorName == "violet") { // Calcium
+		R = 176;
+		G = 67;
+		B = 172;
+	} else if (colorName == "blueGreen") { // Magnesium
+		R = 0;
+		G = 255;
+		B = 152;
+	} else if (colorName == "yellow") { // Iron
+		R = 255;
+		G = 255;
+		B = 0;
+	} else if (colorName == "orangeYellow") { // Sodium
+		R = 255;
+		G = 160;
+		B = 0;
+	} else if (colorName == "red") { // atmospheric nitrogen and oxygen
+		R = 255;
+		G = 30;
+		B = 0;
+	} else { // white
+		R = 255;
+		G = 255;
+		B = 255;
+	}
+
+	return Vec4f(R/255.f, G/255.f, B/255.f, 1);
+}
+
+QList<Meteor::colorPair> Meteor::getRandColor() {
+	QList<colorPair> colors;
+	float prob = (double)rand()/((double)RAND_MAX+1);
+	if (prob > 0.9) {
+		colors.push_back(Meteor::colorPair("white", 70));
+		colors.push_back(Meteor::colorPair("orangeYellow", 10));
+		colors.push_back(Meteor::colorPair("yellow", 10));
+		colors.push_back(Meteor::colorPair("blueGreen", 10));
+	} else if (prob > 0.85)  {
+		colors.push_back(Meteor::colorPair("white", 80));
+		colors.push_back(Meteor::colorPair("violet", 20));
+	} else if (prob > 0.80)  {
+		colors.push_back(Meteor::colorPair("white", 80));
+		colors.push_back(Meteor::colorPair("orangeYellow", 20));
+	} else {
+		colors.push_back(Meteor::colorPair("white", 100));
+	}
+
+	return colors;
+}
+
+void Meteor::buildColorArrays(const int segments,
+			      const QList<colorPair> colors,
+			      QList<Vec4f> &lineColorArray,
+			      QList<Vec4f> &trainColorArray)
+{
+	// building color arrays (line and prism)
+	int totalOfSegments = 0;
+	int currentSegment = 1+(double)rand()/((double)RAND_MAX+1)*(segments-1);
+	for (int colorIndex=0; colorIndex<colors.size(); colorIndex++) {
+		colorPair currentColor = colors[colorIndex];
+
+		// segments which we'll paint with the current color
+		int numOfSegments = segments*(currentColor.second / 100.f) + 0.4f; // +0.4 affect approximation
+		if (colorIndex == colors.size()-1) {
+			numOfSegments = segments - totalOfSegments;
+		}
+
+		totalOfSegments += numOfSegments;
+		for (int i=0; i<numOfSegments; i++) {
+			lineColorArray.insert(currentSegment, getColorFromName(currentColor.first));
+			trainColorArray.insert(currentSegment, getColorFromName(currentColor.first));
+			if (currentSegment >= segments-1) {
+				currentSegment = 0;
+			} else {
+				currentSegment++;
+			}
+			trainColorArray.insert(currentSegment, getColorFromName(currentColor.first));
+		}
+	}
+}
+
+bool Meteor::updateMeteorModel(double deltaTime, double speed, MeteorModel &mm)
+{
+	if (mm.position[2] < mm.endH)
+	{
 		// burning has stopped so magnitude fades out
 		// assume linear fade out
-
-		mag -= maxMag * deltaTime/500.0f;
-		if( mag < 0 ) alive=0;  // no longer visible
-
+		mm.mag -= deltaTime/500.0f;
+		if(mm.mag < 0)
+		{
+			return false;    // no longer visible
+		}
 	}
 
 	// *** would need time direction multiplier to allow reverse time replay
-	position[2] = position[2] - velocity*deltaTime/1000.0f;
+	float dt = 820+(double)rand()/((double)RAND_MAX+1)*185; // range 820-1005
+	mm.position[2] -= speed*deltaTime/dt;
 
 	// train doesn't extend beyond start of burn
-	if( position[2] + velocity*0.5f > startH ) {
-		posTrain[2] = startH ;
-	} else {
-		posTrain[2] -= velocity*deltaTime/1000.0f;
-	}
-
-	//qDebug("meteor position: %f delta_t %d\n", position[2], deltaTime);
+	if (mm.position[2] + speed*0.5f > mm.startH)
+	{
+		mm.posTrain[2] = mm.startH;
+	}
+	else
+	{
+		mm.posTrain[2] -= speed*deltaTime/dt;
+	}
+
+	return true;
+}
+
+// returns true if alive
+bool Meteor::update(double deltaTime)
+{
+	if (!m_alive)
+	{
+		return false;
+	}
+
+	m_alive = updateMeteorModel(deltaTime, m_speed, meteor);
 
 	// determine visual magnitude based on distance to observer
-	double dist = sqrt( xydistance*xydistance + pow( position[2]-obs[2], 2) );
-
-	if( dist == 0 ) dist = .01;  // just to be cautious (meteor hits observer!)
-
-	distMultiplier = minDist*minDist / (dist*dist);
-
-	return(alive);
-}
-
+	double dist = sqrt(meteor.xydistance*meteor.xydistance + pow(meteor.position[2]-meteor.obs[2], 2));
+	if (dist == 0)
+	{
+		dist = .01;    // just to be cautious (meteor hits observer!)
+	}
+	m_distMultiplier = meteor.minDist*meteor.minDist / (dist*dist);
+
+	return m_alive;
+}
+
+void Meteor::insertVertex(const StelCore* core, const Mat4d& viewMatrix, QVector<Vec3d> &vertexArray, Vec3d vertex)
+{
+	vertex.transfo4d(viewMatrix);
+	vertex = core->j2000ToAltAz(vertex);
+	vertex[2] -= EARTH_RADIUS;
+	vertex/=1216; // 1216 is to scale down under 1 for desktop version
+	vertexArray.push_back(vertex);
+}
+
+void Meteor::calculateThickness(const StelCore* core, float& thickness, float& bolideSize)
+{
+	float maxFOV = core->getMovementMgr()->getMaxFov();
+	float FOV = core->getMovementMgr()->getCurrentFov();
+	thickness = 2*log(FOV + 0.25)/(1.2*maxFOV - (FOV + 0.25)) + 0.01;
+	if (FOV <= 0.5)
+	{
+		thickness = 0.013 * FOV; // decreasing faster
+	} else if (FOV > 100.0) {
+		thickness = 0; // remove prism
+	}
+	bolideSize = thickness*3;
+}
+
+void Meteor::drawBolide(const StelCore* core, StelPainter& sPainter, const MeteorModel& mm,
+			const Mat4d& viewMatrix, const float bolideSize)
+{
+	if (!bolideSize) {
+		return;
+	}
+
+	// bolide
+	//
+	QVector<Vec3d> vertexArrayBolide;
+	QVector<Vec4f> colorArrayBolide;
+	Vec4f bolideColor = Vec4f(1,1,1,mm.mag);
+
+	Vec3d topLeft = mm.position;
+	topLeft[1] -= bolideSize;
+	insertVertex(core, viewMatrix, vertexArrayBolide, topLeft);
+	colorArrayBolide.push_back(bolideColor);
+
+	Vec3d topRight = mm.position;
+	topRight[0] -= bolideSize;
+	insertVertex(core, viewMatrix, vertexArrayBolide, topRight);
+	colorArrayBolide.push_back(bolideColor);
+
+	Vec3d bottomRight = mm.position;
+	bottomRight[1] += bolideSize;
+	insertVertex(core, viewMatrix, vertexArrayBolide, bottomRight);
+	colorArrayBolide.push_back(bolideColor);
+
+	Vec3d bottomLeft = mm.position;
+	bottomLeft[0] += bolideSize;
+	insertVertex(core, viewMatrix, vertexArrayBolide, bottomLeft);
+	colorArrayBolide.push_back(bolideColor);
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_ONE, GL_ONE);
+	sPainter.enableClientStates(true, true, true);
+	Meteor::bolideTexture->bind();
+	static const float texCoordData[] = {1.,0., 0.,0., 0.,1., 1.,1.};
+	sPainter.setTexCoordPointer(2, GL_FLOAT, texCoordData);
+	sPainter.setColorPointer(4, GL_FLOAT, colorArrayBolide.constData());
+	sPainter.setVertexPointer(3, GL_DOUBLE, vertexArrayBolide.constData());
+	sPainter.drawFromArray(StelPainter::TriangleFan, vertexArrayBolide.size(), 0, true);
+
+	glDisable(GL_BLEND);
+	sPainter.enableClientStates(false);
+}
+
+void Meteor::drawTrain(const StelCore *core, StelPainter& sPainter, const MeteorModel& mm,
+		       const Mat4d& viewMatrix, const float thickness, const int segments,
+		       QList<Vec4f> lineColorArray, QList<Vec4f> trainColorArray)
+{
+	if (segments != lineColorArray.size() || 2*segments != trainColorArray.size())
+	{
+		qWarning() << "Meteor: color arrays have an inconsistent size!";
+		return;
+	}
+
+	// train (triangular prism)
+	//
+	QVector<Vec3d> vertexArrayLine;
+	QVector<Vec3d> vertexArrayL;
+	QVector<Vec3d> vertexArrayR;
+	QVector<Vec3d> vertexArrayTop;
+
+	Vec3d posTrainB = mm.posTrain;
+	posTrainB[0] += thickness*0.7;
+	posTrainB[1] += thickness*0.7;
+	Vec3d posTrainL = mm.posTrain;
+	posTrainL[1] -= thickness;
+	Vec3d posTrainR = mm.posTrain;
+	posTrainR[0] -= thickness;
+
+	for (int i=0; i<segments; i++) {
+		float mag = mm.mag * i/(3* (segments-1));
+		if (i > mm.firstBrightSegment) {
+			mag *= 12/5;
+		}
+
+		double height = mm.posTrain[2] + i*(mm.position[2] - mm.posTrain[2])/(segments-1);
+		Vec3d posi;
+
+		posi = mm.posTrain;
+		posi[2] = height;
+		insertVertex(core, viewMatrix, vertexArrayLine, posi);
+
+		posi = posTrainB;
+		posi[2] = height;
+		insertVertex(core, viewMatrix, vertexArrayL, posi);
+		insertVertex(core, viewMatrix, vertexArrayR, posi);
+
+		posi = posTrainL;
+		posi[2] = height;
+		insertVertex(core, viewMatrix, vertexArrayL, posi);
+		insertVertex(core, viewMatrix, vertexArrayTop, posi);
+
+		posi = posTrainR;
+		posi[2] = height;
+		insertVertex(core, viewMatrix, vertexArrayR, posi);
+		insertVertex(core, viewMatrix, vertexArrayTop, posi);
+
+		lineColorArray[i][3] = mag;
+		trainColorArray[i*2][3] = mag;
+		trainColorArray[i*2+1][3] = mag;
+	}
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	sPainter.enableClientStates(true, false, true);
+	if (thickness) {
+		sPainter.setColorPointer(4, GL_FLOAT, trainColorArray.toVector().constData());
+
+		sPainter.setVertexPointer(3, GL_DOUBLE, vertexArrayL.constData());
+		sPainter.drawFromArray(StelPainter::TriangleStrip, vertexArrayL.size(), 0, true);
+
+		sPainter.setVertexPointer(3, GL_DOUBLE, vertexArrayR.constData());
+		sPainter.drawFromArray(StelPainter::TriangleStrip, vertexArrayR.size(), 0, true);
+
+		sPainter.setVertexPointer(3, GL_DOUBLE, vertexArrayTop.constData());
+		sPainter.drawFromArray(StelPainter::TriangleStrip, vertexArrayTop.size(), 0, true);
+	}
+	sPainter.setColorPointer(4, GL_FLOAT, lineColorArray.toVector().constData());
+	sPainter.setVertexPointer(3, GL_DOUBLE, vertexArrayLine.constData());
+	sPainter.drawFromArray(StelPainter::LineStrip, vertexArrayLine.size(), 0, true);
+
+	glDisable(GL_BLEND);
+	sPainter.enableClientStates(false);
+}
 
 // returns true if visible
 // Assumes that we are in local frame
 void Meteor::draw(const StelCore* core, StelPainter& sPainter)
 {
-	if (!alive)
+	if (!m_alive)
+	{
 		return;
-
-	const StelProjectorP proj = sPainter.getProjector();
-
-	Vec3d spos = position;
-	Vec3d epos = posTrain;
-
-	// convert to equ
-	spos.transfo4d(mmat);
-	epos.transfo4d(mmat);
-
-	// convert to local and correct for earth radius [since equ and local coordinates in stellarium use same 0 point!] 
-	spos = core->equinoxEquToAltAz( spos );
-	epos = core->equinoxEquToAltAz( epos );
-	spos[2] -= EARTH_RADIUS;
-	epos[2] -= EARTH_RADIUS;
-	// 1216 is to scale down under 1 for desktop version
-	spos/=1216;
-	epos/=1216;
-
-	//qDebug("[%f %f %f]\n", position[0], position[1], position[2]);
-
-	if (train)
-	{
-		// connect this point with last drawn point
-		double tmag = mag*distMultiplier;
-
-		// compute an intermediate point so can curve slightly along projection distortions
-		Vec3d posi = posInternal; 
-		posi[2] = position[2] + (posTrain[2] - position[2])/2;
-		posi.transfo4d(mmat);
-		posi = core->equinoxEquToAltAz( posi );
-		posi[2] -= EARTH_RADIUS;
-		posi/=1216;
-
-		// draw dark to light
-		Vec4f colorArray[3];
-		colorArray[0].set(0,0,0,0);
-		colorArray[1].set(1,1,1,tmag*0.5);
-		colorArray[2].set(1,1,1,tmag);
-		Vec3d vertexArray[3];
-		vertexArray[0]=epos;
-		vertexArray[1]=posi;
-		vertexArray[2]=spos;
-		sPainter.setColorPointer(4, GL_FLOAT, colorArray);
-		sPainter.setVertexPointer(3, GL_DOUBLE, vertexArray);
-		sPainter.enableClientStates(true, false, true);
-		sPainter.drawFromArray(StelPainter::LineStrip, 3, 0, true);
-		sPainter.enableClientStates(false);
-	}
-	else
-	{
-		Vec3d start;
-		proj->project(spos, start);
-		sPainter.drawPoint2d(start[0],start[1]);
-	}
-
-	train = 1;
-}
-
-bool Meteor::isAlive(void)
-{
-	return(alive);
+	}
+
+	float thickness, bolideSize;
+	calculateThickness(core, thickness, bolideSize);
+
+	drawTrain(core, sPainter, meteor, m_viewMatrix, thickness,
+		  m_segments, m_lineColorArray, m_trainColorArray);
+
+	drawBolide(core, sPainter, meteor, m_viewMatrix, bolideSize);
 }

=== modified file 'src/core/modules/Meteor.hpp'
--- src/core/modules/Meteor.hpp	2013-08-24 21:33:23 +0000
+++ src/core/modules/Meteor.hpp	2014-06-29 14:51:17 +0000
@@ -1,6 +1,7 @@
 /*
  * Stellarium
- * This file Copyright (C) 2004 Robert Spearman
+ * Copyright (C) 2004 Robert Spearman
+ * Copyright (C) 2014 Marcos Cardinot
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -20,7 +21,12 @@
 #ifndef _METEOR_HPP_
 #define _METEOR_HPP_
 
+#include "StelTextureTypes.hpp"
 #include "VecMath.hpp"
+
+#include <QList>
+#include <QPair>
+
 class StelCore;
 class StelPainter;
 
@@ -34,14 +40,26 @@
 //! Models a single meteor.
 //! Control of the meteor rate is performed in the MeteorMgr class.  Once
 //! created, a meteor object only lasts for some amount of time, and then
-//! "dies", after which, the update() member returns false.  The live/dead
-//! status of a meteor may also be determined using the isAlive member.
+//! "dies", after which, the update() member returns false.
 class Meteor
 {
 public:
+	struct MeteorModel
+	{
+		Vec3d obs;         //! observer position
+		Vec3d position;    //! equatorial coordinate position
+		Vec3d posTrain;    //! end of train
+		float xydistance; //! Distance in XY plane (orthogonal to meteor path) from observer to meteor
+		float minDist;    //! Nearest point to observer along path
+		float startH;     //! Start height above center of earth
+		float endH;       //! End height
+		float mag;	   //! Apparent magnitude at head, 0-1
+		int firstBrightSegment; //! First bright segment of the train
+	};
+
 	//! Create a Meteor object.
 	//! @param v the velocity of the meteor in km/s.
-	Meteor(const StelCore*, double v);
+	Meteor(const StelCore*, float v);
 	virtual ~Meteor();
 	
 	//! Updates the position of the meteor, and expires it if necessary.
@@ -50,31 +68,55 @@
 	
 	//! Draws the meteor.
 	void draw(const StelCore* core, StelPainter& sPainter);
-	
-	//! Determine if a meteor is alive or has burned out.
+
+	//! Draws the meteor train. (useful to be reused in MeteorShowers plugin)
+	static void drawTrain(const StelCore* core, StelPainter& sPainter, const MeteorModel& mm,
+			      const Mat4d& viewMatrix, const float thickness, const int segments,
+			      QList<Vec4f> lineColorArray, QList<Vec4f> trainColorArray);
+
+	//! Draws the meteor bolide. (useful to be reused in MeteorShowers plugin)
+	static void drawBolide(const StelCore* core, StelPainter &sPainter, const MeteorModel& mm,
+			       const Mat4d& viewMatrix, const float bolideSize);
+
+	//! Calculates the train thickness and bolide size.
+	static void calculateThickness(const StelCore* core, float &thickness, float &bolideSize);
+
+	//! <colorName, intensity>
+	typedef QPair<QString, int> colorPair;
+
+	//! Updates parameters of meteor model. (useful to be reused in MeteorShowers plugin)
+	//! @return true of the meteor is still alive, else false.
+	static bool updateMeteorModel(double deltaTime, double speed, MeteorModel &mm);
+
+	//! Builds Meteor Model
 	//! @return true if alive, else false.
-	bool isAlive(void);
-	
+	static bool initMeteorModel(const StelCore *core, const int segments,
+				    const Mat4d viewMatrix, MeteorModel &mm);
+
+	//! Determine color arrays of line and prism used to draw meteor train.
+	static void buildColorArrays(const int segments,
+				     const QList<colorPair> colors,
+				     QList<Vec4f> &lineColorArray,
+				     QList<Vec4f> &trainColorArray);
+
+	static StelTextureSP bolideTexture;
+
 private:
-	Mat4d mmat; // tranformation matrix to align radiant with earth direction of travel
-	Vec3d obs;  // observer position in meteor coord. system
-	Vec3d position;  // equatorial coordinate position
-	Vec3d posInternal;  // middle of train
-	Vec3d posTrain;  // end of train
-	bool train;      // point or train visible?
-	double startH;  // start height above center of earth
-	double endH;    // end height
-	double velocity; // km/s
-	bool alive;      // is it still visible?
-	float mag;	   // Apparent magnitude at head, 0-1
-	float maxMag;  // 0-1
-	float absMag;  // absolute magnitude
-	float visMag;  // visual magnitude at observer
-	double xydistance; // distance in XY plane (orthogonal to meteor path) from observer to meteor
-	double initDist;  // initial distance from observer
-	double minDist;  // nearest point to observer along path
-	double distMultiplier;  // scale magnitude due to changes in distance 
-	
+	static void insertVertex(const StelCore* core, const Mat4d& viewMatrix,
+				 QVector<Vec3d> &vertexArray, Vec3d vertex);
+	static Vec4f getColorFromName(QString colorName);
+	QList<colorPair> getRandColor();
+
+	bool m_alive;        //! Indicate if the meteor it still visible
+
+	float m_speed;      //! Velocity of meteor in km/s
+	Mat4d m_viewMatrix;  //! tranformation matrix to align radiant with earth direction of travel
+	MeteorModel meteor;  //! Parameters of meteor model
+	double m_distMultiplier;  //! Scale magnitude due to changes in distance
+
+	QList<Vec4f> m_trainColorArray;
+	QList<Vec4f> m_lineColorArray;
+	const int m_segments;     //! Number of segments along the train (useful to curve along projection distortions)
 };
 
 

=== modified file 'src/core/modules/MeteorMgr.cpp'
--- src/core/modules/MeteorMgr.cpp	2014-02-18 06:36:58 +0000
+++ src/core/modules/MeteorMgr.cpp	2014-06-29 14:51:17 +0000
@@ -1,7 +1,8 @@
 /*
  * Stellarium
- * This file Copyright (C) 2004 Robert Spearman
- * 
+ * Copyright (C) 2004 Robert Spearman
+ * Copyright (C) 2014 Marcos Cardinot
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
@@ -17,47 +18,42 @@
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
  */
 
-#include "StelProjector.hpp"
-
+#include "LandscapeMgr.hpp"
+#include "Meteor.hpp"
 #include "MeteorMgr.hpp"
+#include "SolarSystem.hpp"
 #include "StelApp.hpp"
 #include "StelCore.hpp"
-#include "Meteor.hpp"
-#include "LandscapeMgr.hpp"
+#include "StelFileMgr.hpp"
 #include "StelModuleMgr.hpp"
 #include "StelPainter.hpp"
+#include "StelTextureMgr.hpp"
 
-#include <functional>
-#include <cstdlib>
 #include <QSettings>
 
-MeteorMgr::MeteorMgr(int zhr, int maxv ) : flagShow(true)
+MeteorMgr::MeteorMgr(int zhr, int maxv )
+	: ZHR(zhr)
+	, maxVelocity(maxv)
+	, flagShow(true)
 {
 	setObjectName("MeteorMgr");
-			
-	ZHR = zhr;
-	maxVelocity = maxv;
-
-	// calculate factor for meteor creation rate per second since visible area ZHR is for
-	// estimated visible radius of 458km
-	// (calculated for average meteor magnitude of +2.5 and limiting magnitude of 5)
-
-	//  zhrToWsr = 1.0f/3600.f;
-	zhrToWsr = 1.6667f/3600.f;
-	// this is a correction factor to adjust for the model as programmed to match observed rates
 }
 
 MeteorMgr::~MeteorMgr()
 {
-	for(std::vector<Meteor*>::iterator iter = active.begin(); iter != active.end(); ++iter)
+	std::vector<Meteor*>::iterator iter;
+	for(iter = active.begin(); iter != active.end(); ++iter)
 	{
 		delete *iter;
 	}
 	active.clear();
+	Meteor::bolideTexture.clear();
 }
 
 void MeteorMgr::init()
 {
+	Meteor::bolideTexture = StelApp::getInstance().getTextureManager().createTextureThread(StelFileMgr::getInstallationDir()+"/textures/cometTail.png", StelTexture::StelTextureParams(true, GL_LINEAR, GL_CLAMP_TO_EDGE));
+
 	setZHR(StelApp::getInstance().getSettings()->value("astro/meteor_rate", 10).toInt());
 }
 
@@ -67,7 +63,9 @@
 double MeteorMgr::getCallOrder(StelModuleActionName actionName) const
 {
 	if (actionName==StelModule::ActionDraw)
-		return StelApp::getInstance().getModuleMgr().getModule("SolarSystem")->getCallOrder(actionName)+10;
+	{
+		return GETSTELMODULE(SolarSystem)->getCallOrder(actionName)+10.;
+	}
 	return 0;
 }
 
@@ -93,78 +91,82 @@
 	return;
 #endif
 	if (!flagShow)
+	{
 		return;
-	
+	}
+
+	StelCore* core = StelApp::getInstance().getCore();
+
+	double tspeed = core->getTimeRate()*86400;  // sky seconds per actual second
+	if (!tspeed) { // is paused?
+		return; // freeze meteors at the current position
+	}
+
 	deltaTime*=1000;
-	StelCore* core = StelApp::getInstance().getCore();
+	// if stellarium has been suspended, don't create
+	// huge number of meteors to make up for lost time!
+	if (deltaTime > 500)
+	{
+		deltaTime = 500;
+	}
 
 	// step through and update all active meteors
-	for (std::vector<Meteor*>::iterator iter = active.begin(); iter != active.end(); ++iter)
+	std::vector<Meteor*>::iterator iter;
+	for (iter = active.begin(); iter != active.end(); ++iter)
 	{
 		if (!(*iter)->update(deltaTime))
 		{
-			// remove dead meteor
-			//      qDebug("Meteor \tdied\n");
-
 			delete *iter;
-			active.erase(iter);
+			iter = active.erase(iter);
 			iter--;  // important!
 		}
 	}
 
 	// only makes sense given lifetimes of meteors to draw when timeSpeed is realtime
 	// otherwise high overhead of large numbers of meteors
-	double tspeed = core->getTimeRate()*86400;  // sky seconds per actual second
-	if (tspeed<=0 || fabs(tspeed)>1.)
+	if (tspeed<0 || fabs(tspeed)>1.)
 	{
 		// don't start any more meteors
 		return;
 	}
 
-	// if stellarium has been suspended, don't create huge number of meteors to
-	// make up for lost time!
-	if (deltaTime > 500)
-	{
-		deltaTime = 500;
-	}
-
 	// determine average meteors per frame needing to be created
 	int mpf = (int)((double)ZHR*zhrToWsr*deltaTime/1000.0 + 0.5);
 	if (mpf<1)
+	{
 		mpf = 1;
+	}
 
-	int mlaunch = 0;
 	for (int i=0; i<mpf; ++i)
 	{
 		// start new meteor based on ZHR time probability
 		double prob = ((double)rand())/RAND_MAX;
-		if (ZHR>0 && prob<((double)ZHR*zhrToWsr*deltaTime/1000.0/(double)mpf) )
+		if (ZHR>0 && prob<((double)ZHR*zhrToWsr*deltaTime/1000.0/(double)mpf))
 		{
-			Meteor *m = new Meteor(StelApp::getInstance().getCore(), maxVelocity);
+			Meteor *m = new Meteor(core, maxVelocity);
 			active.push_back(m);
-			mlaunch++;
 		}
 	}
-	//  qDebug("mpf: %d\tm launched: %d\t(mps: %f)\t%d\n", mpf, mlaunch, ZHR*zhrToWsr, deltaTime);
 }
 
 
 void MeteorMgr::draw(StelCore* core)
 {
 	if (!flagShow)
+	{
 		return;
-	
-	LandscapeMgr* landmgr = (LandscapeMgr*)StelApp::getInstance().getModuleMgr().getModule("LandscapeMgr");
+	}
+
+	LandscapeMgr* landmgr = GETSTELMODULE(LandscapeMgr);
 	if (landmgr->getFlagAtmosphere() && landmgr->getLuminance()>5)
+	{
 		return;
+	}
 
+	// step through and draw all active meteors
 	StelPainter sPainter(core->getProjection(StelCore::FrameAltAz));
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable(GL_BLEND);
-	sPainter.enableTexture2d(false);
-
-	// step through and draw all active meteors
-	for (std::vector<Meteor*>::iterator iter = active.begin(); iter != active.end(); ++iter)
+	std::vector<Meteor*>::iterator iter;
+	for (iter = active.begin(); iter != active.end(); ++iter)
 	{
 		(*iter)->draw(core, sPainter);
 	}

=== modified file 'src/core/modules/MeteorMgr.hpp'
--- src/core/modules/MeteorMgr.hpp	2013-08-24 21:33:23 +0000
+++ src/core/modules/MeteorMgr.hpp	2014-06-29 14:51:17 +0000
@@ -1,17 +1,18 @@
 /*
  * Stellarium
- * This file Copyright (C) 2004 Robert Spearman
- * 
+ * Copyright (C) 2004 Robert Spearman
+ * Copyright (C) 2014 Marcos Cardinot
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
@@ -20,7 +21,6 @@
 #ifndef _METEORMGR_HPP_
 #define _METEORMGR_HPP_
 
-#include <vector>
 #include "StelModule.hpp"
 
 class Meteor;
@@ -59,6 +59,9 @@
 	
 	//! Defines the order in which the various modules are drawn.
 	virtual double getCallOrder(StelModuleActionName actionName) const;
+
+	//! Factor to convert from zhr to whole earth per second rate
+	static const double zhrToWsr = 1.6667f / 3600.f;
 	
 public slots:
 	///////////////////////////////////////////////////////////////////////////
@@ -80,10 +83,9 @@
 	void zhrChanged(int);
 	
 private:
-	std::vector<Meteor*> active;		// Vector containing all active meteors
+	std::vector<Meteor*> active;	// Vector containing all active meteors
 	int ZHR;
 	int maxVelocity;
-	double zhrToWsr;  // factor to convert from zhr to whole earth per second rate
 	bool flagShow;
 };