Merge lp:~stellarium/stellarium/gz_landscapePreload into lp:stellarium

[gzotti]

Allow caching for landscapes, including preloading and some other manipulation via scripting.

This branch adds caching for the landscapes, mostly useful for the multi-gigabyte GPUs of today, but (hopefully) not disturbing for older systems. Big landscapes take several seconds to load. Switching rapidly between several landscapes becomes much easier with this. It is also possible to pre-load or delete from the cache via scripting.

Cache size can be configured in config.ini.

[Alexander Wolf (alexwolf)]

review: Approve

=== modified file 'src/core/StelTexture.hpp'
--- src/core/StelTexture.hpp	2016-11-28 16:01:23 +0000
+++ src/core/StelTexture.hpp	2017-01-19 22:30:07 +0000
@@ -91,6 +91,9 @@
 	//! Return whether the image is currently being loaded
 	bool isLoading() const {return (loader || networkReply) && !canBind();}
 
+	//! Return texture memory size
+	unsigned int getGlSize() const {return glSize;}
+
 signals:
 	//! Emitted when the texture is ready to be bind(), i.e. when downloaded, imageLoading and	glLoading is over
 	//! or when an error occured and the texture will never be available
@@ -171,7 +174,7 @@
 	GLsizei height;	//! Texture image height
 
 	//! Size in GL memory
-	int glSize;
+	unsigned int glSize;
 };
 
 

=== modified file 'src/core/StelTextureMgr.hpp'
--- src/core/StelTextureMgr.hpp	2016-11-21 21:04:36 +0000
+++ src/core/StelTextureMgr.hpp	2017-01-19 22:30:07 +0000
@@ -61,7 +61,7 @@
 	//! Must be called after the creation of the GLContext.
 	void init();
 
-	int glMemoryUsage;
+	unsigned int glMemoryUsage;
 };
 
 

=== modified file 'src/core/modules/Landscape.cpp'
--- src/core/modules/Landscape.cpp	2017-01-08 16:39:11 +0000
+++ src/core/modules/Landscape.cpp	2017-01-19 22:30:07 +0000
@@ -2,6 +2,7 @@
  * Stellarium
  * Copyright (C) 2003 Fabien Chereau
  * Copyright (C) 2011 Bogdan Marinov
+ * Copyright (C) 2014-17 Georg Zotti
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -37,6 +38,7 @@
 
 Landscape::Landscape(float _radius)
 	: radius(_radius)
+	, id("uninitialized")
 	, minBrightness(-1.)
 	, landscapeBrightness(1.)
 	, lightScapeBrightness(0.)
@@ -63,6 +65,7 @@
 // Load attributes common to all landscapes
 void Landscape::loadCommon(const QSettings& landscapeIni, const QString& landscapeId)
 {
+	id = landscapeId;
 	name = landscapeIni.value("landscape/name").toString();
 	author = landscapeIni.value("landscape/author").toString();
 	description = landscapeIni.value("landscape/description").toString();
@@ -284,13 +287,14 @@
 		{
 			QString line=in.readLine();
 
-			// TODO: Read entries, construct vectors, put in list.
-			if (line.startsWith('#'))
+			// Skip comments and all-empty lines (space allowed and ignored)
+			if (line.startsWith('#') || line.trimmed().isEmpty() )
 				continue;
+			// Read entries, construct vectors, put in list.
 			QStringList parts=line.split('|');
 			if (parts.count() != 5)
 			{
-				qWarning() << "Invalid line in landscape" << descFileName << ":" << line;
+				qWarning() << "Invalid line in landscape gazetteer" << descFileName << ":" << line;
 				continue;
 			}
 			LandscapeLabel newLabel;
@@ -359,6 +363,7 @@
 	, drawGroundFirst(0)
 	, tanMode(false)
 	, calibrated(false)
+	, memorySize(sizeof(LandscapeOldStyle)) // start with just the known entries.
 {}
 
 LandscapeOldStyle::~LandscapeOldStyle()
@@ -391,7 +396,7 @@
 	{
 		qWarning() << "Landscape type mismatch for landscape " << landscapeId
 				   << ", expected old_style, found " << type << ".  No landscape in use.";
-		validLandscape = 0;
+		validLandscape = false;
 		return;
 	}
 
@@ -421,6 +426,7 @@
 		if ( (!horizonPolygon) && calibrated ) { // for uncalibrated landscapes the texture is currently never queried, so no need to store.
 			QImage *image = new QImage(texturePath);
 			sidesImages.append(image); // indices identical to those in sideTexs
+			memorySize+=image->byteCount();
 		}
 		// Also allow light textures. The light textures must cover the same geometry as the sides. It is allowed that not all or even any light textures are present!
 		textureKey = QString("landscape/light%1").arg(i);
@@ -429,6 +435,8 @@
 		{
 			const QString lightTexturePath = getTexturePath(textureName, landscapeId);
 			sideTexs[nbSideTexs+i] = StelApp::getInstance().getTextureManager().createTexture(lightTexturePath);
+			if(sideTexs[nbSideTexs+i])
+				memorySize+=sideTexs[nbSideTexs+i].data()->getGlSize();
 		}
 		else
 			sideTexs[nbSideTexs+i].clear();
@@ -471,28 +479,14 @@
 	QString groundTexName = landscapeIni.value("landscape/groundtex").toString();
 	QString groundTexPath = getTexturePath(groundTexName, landscapeId);
 	groundTex = StelApp::getInstance().getTextureManager().createTexture(groundTexPath, StelTexture::StelTextureParams(true));
-	// GZ 2013/11: I don't see any use of this:
-//	QString description = landscapeIni.value("landscape/ground").toString();
-//	//sscanf(description.toLocal8Bit(),"groundtex:%f:%f:%f:%f",&a,&b,&c,&d);
-//	QStringList parameters = description.split(':');
-//	groundTexCoord.tex = groundTex;
-//	groundTexCoord.texCoords[0] = parameters.at(1).toFloat();
-//	groundTexCoord.texCoords[1] = parameters.at(2).toFloat();
-//	groundTexCoord.texCoords[2] = parameters.at(3).toFloat();
-//	groundTexCoord.texCoords[3] = parameters.at(4).toFloat();
+	if (groundTex)
+		memorySize+=groundTex.data()->getGlSize();
 
 	QString fogTexName = landscapeIni.value("landscape/fogtex").toString();
 	QString fogTexPath = getTexturePath(fogTexName, landscapeId);
 	fogTex = StelApp::getInstance().getTextureManager().createTexture(fogTexPath, StelTexture::StelTextureParams(true, GL_LINEAR, GL_REPEAT));
-	// GZ 2013/11: I don't see any use of this:
-//	QString description = landscapeIni.value("landscape/fog").toString();
-//	//sscanf(description.toLocal8Bit(),"fogtex:%f:%f:%f:%f",&a,&b,&c,&d);
-//	QStringList parameters = description.split(':');
-//	fogTexCoord.tex = fogTex;
-//	fogTexCoord.texCoords[0] = parameters.at(1).toFloat();
-//	fogTexCoord.texCoords[1] = parameters.at(2).toFloat();
-//	fogTexCoord.texCoords[2] = parameters.at(3).toFloat();
-//	fogTexCoord.texCoords[3] = parameters.at(4).toFloat();
+	if (fogTex)
+		memorySize+=fogTex.data()->getGlSize();
 
 	// Precompute the vertex arrays for ground display
 	// Make slices_per_side=(3<<K) so that the innermost polygon of the fandisk becomes a triangle:
@@ -520,9 +514,9 @@
 	// GZ: the original code for vertical placement makes unfortunately no sense. There are many approximately-fitted landscapes, though.
 	// I added a switch "calibrated" for the ini file. If true, it works as this landscape apparently was originally intended,
 	// if false (or missing) it uses the original code.
-	// So I corrected the texture coordinates so that decorAltAngle is the total vertical angle, decorAngleShift the lower angle,
+	// I corrected the texture coordinates so that decorAltAngle is the total vertical angle, decorAngleShift the lower angle,
 	// and the texture in between is correctly stretched.
-	// I located an undocumented switch tan_mode, maybe tan_mode=true means cylindrical panorama projection.
+	// I located an undocumented switch tan_mode, maybe tan_mode=true means cylindrical panorama projection instead of equirectangular.
 	// Since V0.13, calibrated&&tanMode also works!
 	// In calibrated && !tan_mode, the vertical position is computed correctly, so that quads off the horizon are larger.
 	// in calibrated &&  tan_mode, d_z can become a constant because the texture is already predistorted in cylindrical projection.
@@ -619,6 +613,7 @@
 			}
 		}
 	}
+	//qDebug() << "OldStyleLandscape" << landscapeId << "loaded, mem size:" << memorySize;
 }
 
 void LandscapeOldStyle::draw(StelCore* core)
@@ -836,17 +831,18 @@
 	if(type != "polygonal")
 	{
 		qWarning() << "Landscape type mismatch for landscape "<< landscapeId << ", expected polygonal, found " << type << ".  No landscape in use.\n";
-		validLandscape = 0;
+		validLandscape = false;
 		return;
 	}
 	if (horizonPolygon.isNull())
 	{
 		qWarning() << "Landscape " << landscapeId << " does not declare a valid polygonal_horizon_list.  No landscape in use.\n";
-		validLandscape = 0;
+		validLandscape = false;
 		return;
 	}
 	groundColor=StelUtils::strToVec3f( landscapeIni.value("landscape/ground_color", "0,0,0" ).toString() );
-	validLandscape = 1;  // assume ok...
+	validLandscape = true;  // assume ok...
+	//qDebug() << "PolygonalLandscape" << landscapeId << "loaded, mem size:" << getMemorySize();
 }
 
 void LandscapePolygonal::draw(StelCore* core)
@@ -891,8 +887,12 @@
 
 LandscapeFisheye::LandscapeFisheye(float _radius)
 	: Landscape(_radius)
+	, mapTex(StelTextureSP())
+	, mapTexFog(StelTextureSP())
+	, mapTexIllum(StelTextureSP())
 	, mapImage(NULL)
 	, texFov(360.)
+	, memorySize(0)
 {}
 
 LandscapeFisheye::~LandscapeFisheye()
@@ -909,7 +909,7 @@
 	if(type != "fisheye")
 	{
 		qWarning() << "Landscape type mismatch for landscape "<< landscapeId << ", expected fisheye, found " << type << ".  No landscape in use.\n";
-		validLandscape = 0;
+		validLandscape = false;
 		return;
 	}
 	create(name,
@@ -918,25 +918,38 @@
 	       getTexturePath(landscapeIni.value("landscape/maptex_fog").toString(), landscapeId),
 	       getTexturePath(landscapeIni.value("landscape/maptex_illum").toString(), landscapeId),
 	       landscapeIni.value("landscape/angle_rotatez", 0.f).toFloat());
+	//qDebug() << "FisheyeLandscape" << landscapeId << "loaded, mem size:" << memorySize;
 }
 
 
 void LandscapeFisheye::create(const QString _name, float _texturefov, const QString& _maptex, const QString &_maptexFog, const QString& _maptexIllum, const float _angleRotateZ)
 {
 	// qDebug() << _name << " " << _fullpath << " " << _maptex << " " << _texturefov;
-	validLandscape = 1;  // assume ok...
+	validLandscape = true;  // assume ok...
 	name = _name;
 	texFov = _texturefov*M_PI/180.f;
 	angleRotateZ = _angleRotateZ*M_PI/180.f;
+
 	if (!horizonPolygon)
+	{
 		mapImage = new QImage(_maptex);
+		memorySize+=mapImage->byteCount();
+	}
 	mapTex = StelApp::getInstance().getTextureManager().createTexture(_maptex, StelTexture::StelTextureParams(true));
+	memorySize+=mapTex.data()->getGlSize();
 
-	if (_maptexIllum.length())
+	if (_maptexIllum.length() && (!_maptexIllum.endsWith("/")))
+	{
 		mapTexIllum = StelApp::getInstance().getTextureManager().createTexture(_maptexIllum, StelTexture::StelTextureParams(true));
-	if (_maptexFog.length())
+		if (mapTexIllum)
+			memorySize+=mapTexIllum.data()->getGlSize();
+	}
+	if (_maptexFog.length() && (!_maptexFog.endsWith("/")))
+	{
 		mapTexFog = StelApp::getInstance().getTextureManager().createTexture(_maptexFog, StelTexture::StelTextureParams(true));
-
+		if (mapTexFog)
+			memorySize+=mapTexFog.data()->getGlSize();
+	}
 }
 
 
@@ -1025,6 +1038,9 @@
 
 LandscapeSpherical::LandscapeSpherical(float _radius)
 	: Landscape(_radius)
+	, mapTex(StelTextureSP())
+	, mapTexFog(StelTextureSP())
+	, mapTexIllum(StelTextureSP())
 	, mapTexTop(0.)
 	, mapTexBottom(0.)
 	, fogTexTop(0.)
@@ -1032,6 +1048,7 @@
 	, illumTexTop(0.)
 	, illumTexBottom(0.)
 	, mapImage(NULL)
+	, memorySize(sizeof(LandscapeSpherical))
 {}
 
 LandscapeSpherical::~LandscapeSpherical()
@@ -1054,7 +1071,7 @@
 		qWarning() << "Landscape type mismatch for landscape "<< landscapeId
 			<< ", expected spherical, found " << type
 			<< ".  No landscape in use.\n";
-		validLandscape = 0;
+		validLandscape = false;
 		return;
 	}
 
@@ -1069,6 +1086,7 @@
 	       landscapeIni.value("landscape/maptex_fog_bottom"  , -90.f).toFloat(),
 	       landscapeIni.value("landscape/maptex_illum_top"   ,  90.f).toFloat(),
 	       landscapeIni.value("landscape/maptex_illum_bottom", -90.f).toFloat());
+	//qDebug() << "SphericalLandscape" << landscapeId << "loaded, mem size:" << memorySize;
 }
 
 
@@ -1079,7 +1097,7 @@
 								const float _illumTexTop, const float _illumTexBottom)
 {
 	//qDebug() << "LandscapeSpherical::create():"<< _name << " : " << _maptex << " : " << _maptexFog << " : " << _maptexIllum << " : " << _angleRotateZ;
-	validLandscape = 1;  // assume ok...
+	validLandscape = true;  // assume ok...
 	name = _name;
 	angleRotateZ  = _angleRotateZ         *M_PI/180.f; // Defined in ini --> internal prg value
 	mapTexTop     = (90.f-_mapTexTop)     *M_PI/180.f; // top     90     -->   0
@@ -1089,13 +1107,25 @@
 	illumTexTop   = (90.f-_illumTexTop)   *M_PI/180.f;
 	illumTexBottom= (90.f-_illumTexBottom)*M_PI/180.f;
 	if (!horizonPolygon)
+	{
 		mapImage = new QImage(_maptex);
+		memorySize+=mapImage->byteCount();
+	}
 	mapTex = StelApp::getInstance().getTextureManager().createTexture(_maptex, StelTexture::StelTextureParams(true));
+	memorySize+=mapTex.data()->getGlSize();
 
-	if (_maptexIllum.length())
+	if (_maptexIllum.length() && (!_maptexIllum.endsWith("/")))
+	{
 		mapTexIllum = StelApp::getInstance().getTextureManager().createTexture(_maptexIllum, StelTexture::StelTextureParams(true));
-	if (_maptexFog.length())
+		if (mapTexIllum)
+			memorySize+=mapTexIllum.data()->getGlSize();
+	}
+	if (_maptexFog.length() && (!_maptexFog.endsWith("/")))
+	{
 		mapTexFog = StelApp::getInstance().getTextureManager().createTexture(_maptexFog, StelTexture::StelTextureParams(true));
+		if (mapTexFog)
+			memorySize+=mapTexFog.data()->getGlSize();
+	}
 }
 
 void LandscapeSpherical::draw(StelCore* core)

=== modified file 'src/core/modules/Landscape.hpp'
--- src/core/modules/Landscape.hpp	2016-05-22 21:14:58 +0000
+++ src/core/modules/Landscape.hpp	2017-01-19 22:30:07 +0000
@@ -75,6 +75,13 @@
 	//! @param landscapeIni A reference to an existing QSettings object which describes the landscape
 	//! @param landscapeId The name of the directory for the landscape files (e.g. "ocean")
 	virtual void load(const QSettings& landscapeIni, const QString& landscapeId) = 0;
+
+	//! Return approximate memory footprint in bytes (required for cache cost estimate in LandscapeMgr)
+	//! The returned value is only approximate, content of QStrings and other small containers like the horizon polygon are not put in in detail.
+	//! However, texture image sizes must be computed in subclasses.
+	//! The value returned is a sum of RAM and texture memory requirements.
+	virtual unsigned int getMemorySize() const {return sizeof(Landscape);}
+
 	virtual void draw(StelCore* core) = 0;
 	void update(double deltaTime)
 	{
@@ -124,6 +131,8 @@
 	QString getAuthorName() const {return author;}
 	//! Get landscape description
 	QString getDescription() const {return description;}
+	//! Get landscape id. This is the landscape directory name, used for cache handling.
+	QString getId() const {return id;}
 
 	//! Return the associated location (may be empty!)
 	const StelLocation& getLocation() const {return location;}
@@ -202,6 +211,7 @@
 	QString name;          //! Read from landscape.ini:[landscape]name
 	QString author;        //! Read from landscape.ini:[landscape]author
 	QString description;   //! Read from landscape.ini:[landscape]description
+	QString id;            //! Set during load. Required for consistent caching.
 
 	float minBrightness;   //! Read from landscape.ini:[landscape]minimal_brightness. Allows minimum visibility that cannot be underpowered.
 	float landscapeBrightness;  //! brightness [0..1] to draw the landscape. Computed by the LandscapeMgr.
@@ -259,6 +269,7 @@
 	LandscapeOldStyle(float radius = 2.f);
 	virtual ~LandscapeOldStyle();
 	virtual void load(const QSettings& landscapeIni, const QString& landscapeId);
+	virtual unsigned int getMemorySize() const {return memorySize;}
 	virtual void draw(StelCore* core);
 	//void create(bool _fullpath, QMap<QString, QString> param); // still not implemented
 	virtual float getOpacity(Vec3d azalt) const;
@@ -302,6 +313,7 @@
 	};
 
 	QList<LOSSide> precomputedSides;
+	unsigned int memorySize;
 };
 
 /////////////////////////////////////////////////////////
@@ -319,6 +331,7 @@
 	LandscapePolygonal(float radius = 1.f);
 	virtual ~LandscapePolygonal();
 	virtual void load(const QSettings& landscapeIni, const QString& landscapeId);
+	virtual unsigned int getMemorySize() const {return sizeof(LandscapePolygonal);}
 	virtual void draw(StelCore* core);
 	virtual float getOpacity(Vec3d azalt) const;
 private:
@@ -338,6 +351,7 @@
 	LandscapeFisheye(float radius = 1.f);
 	virtual ~LandscapeFisheye();
 	virtual void load(const QSettings& landscapeIni, const QString& landscapeId);
+	virtual unsigned int getMemorySize() const {return memorySize;}
 	virtual void draw(StelCore* core);
 	//! Sample landscape texture for transparency/opacity. May be used for visibility, sunrise etc.
 	//! @param azalt normalized direction in alt-az frame
@@ -360,6 +374,7 @@
 	QImage *mapImage;          //!< The same image as mapTex, but stored in-mem for sampling.
 
 	float texFov;
+	unsigned int memorySize;
 };
 
 //////////////////////////////////////////////////////////////////////////
@@ -378,6 +393,7 @@
 	LandscapeSpherical(float radius = 1.f);
 	virtual ~LandscapeSpherical();
 	virtual void load(const QSettings& landscapeIni, const QString& landscapeId);
+	virtual unsigned int getMemorySize() const {return memorySize;}
 	virtual void draw(StelCore* core);
 	//! Sample landscape texture for transparency/opacity. May be used for visibility, sunrise etc.
 	//! @param azalt normalized direction in alt-az frame
@@ -414,6 +430,7 @@
 	float illumTexTop;	   //!< zenithal top angle of the illumination texture, radians
 	float illumTexBottom;	   //!< zenithal bottom angle of the illumination texture, radians
 	QImage *mapImage;          //!< The same image as mapTex, but stored in-mem for opacity sampling.
+	unsigned int memorySize;   //!< holds an approximate value of memory consumption (for cache cost estimate)
 };
 
 #endif // _LANDSCAPE_HPP_

=== modified file 'src/core/modules/LandscapeMgr.cpp'
--- src/core/modules/LandscapeMgr.cpp	2017-01-08 16:39:11 +0000
+++ src/core/modules/LandscapeMgr.cpp	2017-01-19 22:30:07 +0000
@@ -142,7 +142,8 @@
 
 
 LandscapeMgr::LandscapeMgr()
-	: atmosphere(NULL)
+	: StelModule()
+	, atmosphere(NULL)
 	, cardinalsPoints(NULL)
 	, landscape(NULL)
 	, oldLandscape(NULL)
@@ -154,7 +155,7 @@
 	, flagLandscapeSetsMinimalBrightness(false)
 	, flagAtmosphereAutoEnabling(false)
 {
-	setObjectName("LandscapeMgr");
+	setObjectName("LandscapeMgr"); // should be done by StelModule's constructor.
 
 	//Note: The first entry in the list is used as the default 'default landscape' in removeLandscape().
 	packagedLandscapeIDs = (QStringList() << "guereins");
@@ -165,6 +166,7 @@
 		packagedLandscapeIDs << directories.fileName();
 	}
 	packagedLandscapeIDs.removeDuplicates();
+	landscapeCache.clear();
 }
 
 LandscapeMgr::~LandscapeMgr()
@@ -178,6 +180,8 @@
 	}
 	delete landscape;
 	landscape = NULL;
+	qDebug() << "LandscapeMgr: Clearing cache of" << landscapeCache.size() << "landscapes totalling about " << landscapeCache.totalCost() << "MB.";
+	landscapeCache.clear(); // deletes all objects within.
 }
 
 /*************************************************************************
@@ -198,6 +202,7 @@
 void LandscapeMgr::update(double deltaTime)
 {
 	atmosphere->update(deltaTime);
+
 	if (oldLandscape)
 	{
 		// This is only when transitioning to newly loaded landscape. We must draw the old one until the new one is faded in completely.
@@ -208,7 +213,10 @@
 
 			if (oldLandscape->getEffectiveLandFadeValue()< 0.01f)
 			{
-				delete oldLandscape;
+				// new logic: try to put old landscape to cache.
+				//qDebug() << "LandscapeMgr::update: moving oldLandscape " << oldLandscape->getId() << "to Cache. Cost:" << oldLandscape->getMemorySize()/(1024*1024)+1;
+				landscapeCache.insert(oldLandscape->getId(), oldLandscape, oldLandscape->getMemorySize()/(1024*1024)+1);
+				//qDebug() << "--> LandscapeMgr::update(): cache now contains " << landscapeCache.size() << "landscapes totalling about " << landscapeCache.totalCost() << "MB.";
 				oldLandscape=NULL;
 			}
 		}
@@ -368,8 +376,10 @@
 	QSettings* conf = StelApp::getInstance().getSettings();
 	Q_ASSERT(conf);
 
+	landscapeCache.setMaxCost(conf->value("landscape/cache_size_mb", 100).toInt());
+	qDebug() << "LandscapeMgr: initialized Cache for" << landscapeCache.maxCost() << "MB.";
+
 	atmosphere = new Atmosphere();
-	landscape = new LandscapeOldStyle();
 	defaultLandscapeID = conf->value("init_location/landscape_name").toString();
 	setCurrentLandscapeID(defaultLandscapeID);
 	setFlagLandscape(conf->value("landscape/flag_landscape", conf->value("landscape/flag_ground", true).toBool()).toBool());
@@ -421,13 +431,39 @@
 	if(id==currentLandscapeID)
 		return false;
 
-	// We want to lookup the landscape ID (dir) from the name.
-	Landscape* newLandscape = createFromFile(StelFileMgr::findFile("landscapes/" + id + "/landscape.ini"), id);
-	
-	if (!newLandscape)
-	{
-		qWarning() << "ERROR while loading landscape " << "landscapes/" + id + "/landscape.ini";
-		return false;
+	Landscape* newLandscape;
+
+	// There is a slight chance that we switch back to oldLandscape while oldLandscape is still fading away.
+	// in this case it is not yet stored in cache, but obviously available. So we just swap places.
+	if (oldLandscape && oldLandscape->getId()==id)
+	{
+		newLandscape=oldLandscape;
+	}
+	else
+	{
+		// We want to lookup the landscape ID (dir) from the name.
+		newLandscape= landscapeCache.take(id);
+
+		if (newLandscape)
+		{
+#ifndef NDEBUG
+			qDebug() << "LandscapeMgr::setCurrentLandscapeID():: taken " << id << "from cache...";
+			qDebug() << ".-->LandscapeMgr::setCurrentLandscapeID(): cache contains " << landscapeCache.size() << "landscapes totalling about " << landscapeCache.totalCost() << "MB.";
+#endif
+		}
+		else
+		{
+#ifndef NDEBUG
+			qDebug() << "LandscapeMgr::setCurrentLandscapeID: Loading from file:" << id ;
+#endif
+			newLandscape = createFromFile(StelFileMgr::findFile("landscapes/" + id + "/landscape.ini"), id);
+		}
+
+		if (!newLandscape)
+		{
+			qWarning() << "ERROR while loading landscape " << "landscapes/" + id + "/landscape.ini";
+			return false;
+		}
 	}
 
 	// Keep current landscape for a while, while new landscape fades in!
@@ -439,15 +475,23 @@
 		newLandscape->setFlagShowFog(landscape->getFlagShowFog());
 		newLandscape->setFlagShowIllumination(landscape->getFlagShowIllumination());
 		newLandscape->setFlagShowLabels(landscape->getFlagShowLabels());
-		//in case we already fade out one old landscape (if switching too rapidly): the old one has to go immediately.
-		if (oldLandscape)
-			delete oldLandscape;
+
+		// If we have an oldLandscape that is not just swapped back, put that into cache.
+		if (oldLandscape && oldLandscape!=newLandscape)
+		{
+#ifndef NDEBUG
+			qDebug() << "LandscapeMgr::setCurrent: moving oldLandscape " << oldLandscape->getId() << "to Cache. Cost:" << oldLandscape->getMemorySize()/(1024*1024)+1;
+#endif
+			landscapeCache.insert(oldLandscape->getId(), oldLandscape, oldLandscape->getMemorySize()/(1024*1024)+1);
+#ifndef NDEBUG
+			qDebug() << "-->LandscapeMgr::setCurrentLandscapeId(): cache contains " << landscapeCache.size() << "landscapes totalling about " << landscapeCache.totalCost() << "MB.";
+#endif
+		}
 		oldLandscape = landscape; // keep old while transitioning!
 	}
 	landscape=newLandscape;
 	currentLandscapeID = id;
 
-
 	if (getFlagLandscapeSetsLocation() && landscape->hasLocation())
 	{
 		StelCore *core = StelApp::getInstance().getCore();
@@ -508,6 +552,46 @@
 	}
 }
 
+// Load a landscape into cache.
+// @param id the ID of a landscape
+// @param replace true if existing landscape entry should be replaced (useful during development to reload after edit)
+// @return false if landscape could not be found, or existed already and replace was false.
+bool LandscapeMgr::precacheLandscape(const QString& id, const bool replace)
+{
+	if (landscapeCache.contains(id) && (!replace))
+		return false;
+
+	Landscape* newLandscape = createFromFile(StelFileMgr::findFile("landscapes/" + id + "/landscape.ini"), id);
+	if (!newLandscape)
+	{
+		qWarning() << "ERROR while preloading landscape " << "landscapes/" + id + "/landscape.ini";
+		return false;
+	}
+
+	bool res=landscapeCache.insert(id, newLandscape, newLandscape->getMemorySize()/(1024*1024)+1);
+#ifndef NDEBUG
+	if (res)
+	{
+		qDebug() << "LandscapeMgr::precacheLandscape(): Successfully added landscape with ID " << id << "to cache";
+	}
+	qDebug() << "LandscapeMgr::precacheLandscape(): cache contains " << landscapeCache.size() << "landscapes totalling about " << landscapeCache.totalCost() << "MB.";
+#endif
+	return res;
+}
+
+// Remove a landscape from the cache of loaded landscapes.
+// @param id the ID of a landscape
+// @return false if landscape could not be found
+bool LandscapeMgr::removeCachedLandscape(const QString& id)
+{
+	bool res= landscapeCache.remove(id);
+#ifndef NDEBUG
+	qDebug() << "LandscapeMgr::removeCachedLandscape(): cache contains " << landscapeCache.size() << "landscapes totalling about " << landscapeCache.totalCost() << "MB.";
+#endif
+	return res;
+}
+
+
 // Change the default landscape to the landscape with the ID specified.
 bool LandscapeMgr::setDefaultLandscapeID(const QString& id)
 {
@@ -878,7 +962,7 @@
 }
 
 /****************************************************************************
- get a map of landscape name (from landscape.ini name field) to ID (dir name)
+ get a map of landscape names (from landscape.ini name field) to ID (dir name)
  ****************************************************************************/
 QMap<QString,QString> LandscapeMgr::getNameToDirMap() const
 {

=== modified file 'src/core/modules/LandscapeMgr.hpp'
--- src/core/modules/LandscapeMgr.hpp	2016-12-18 06:38:55 +0000
+++ src/core/modules/LandscapeMgr.hpp	2017-01-19 22:30:07 +0000
@@ -28,6 +28,7 @@
 
 #include <QMap>
 #include <QStringList>
+#include <QCache>
 
 class Atmosphere;
 class Cardinals;
@@ -41,7 +42,7 @@
 //! \note
 //! The Bortle scale index setting was removed from this class, because it was duplicated
 //! from StelSkyDrawer, complicating code that changes it.
-//! It is now only in StelSkyDrawer and can be accessed with
+//! It is now only in StelSkyDrawer and can be accessed
 //! with \link StelSkyDrawer::getBortleScaleIndex getBortleScaleIndex \endlink
 //! and \link StelSkyDrawer::setBortleScaleIndex setBortleScaleIndex \endlink.
 //! Slots setAtmosphereBortleLightPollution and getAtmosphereBortleLightPollution
@@ -141,9 +142,10 @@
 	///////////////////////////////////////////////////////////////////////////
 	// Methods specific to the landscape manager
 
-	//! Load a landscape based on a hash of parameters mirroring the landscape.ini
-	//! file and make it the current landscape.
-	bool loadLandscape(QMap<QString, QString>& param);
+	// Load a landscape based on a hash of parameters mirroring the landscape.ini
+	// file and make it the current landscape.
+	// GZ: This was declared, but not implemented(?)
+	//bool loadLandscape(QMap<QString, QString>& param);
 
 	//! Create a new landscape from the files which describe it.
 	//! Reads a landscape.ini file which is passed as the first parameter, determines
@@ -177,7 +179,7 @@
 	//! this value explicitly to freeze it during image export. To unfreeze, call this again with any negative value.
 	void setAtmosphereAverageLuminance(const float overrideLuminance);
 
-	//! Return a map of landscape name to landscape ID (directory name).
+	//! Return a map of landscape names to landscape IDs (directory names).
 	QMap<QString,QString> getNameToDirMap() const;
 
 	//! Retrieve a list of the names of all the available landscapes in
@@ -212,6 +214,31 @@
 	//! @param changeLocationDuration the duration of the transition animation
 	bool setCurrentLandscapeName(const QString& name, const double changeLocationDuration = 1.0);
 
+	//! Preload a landscape into cache.
+	//! @param id the ID of a landscape
+	//! @param replace true if existing landscape entry should be replaced (useful during development to reload after edit)
+	//! @return false if landscape could not be found, or if it already existed in cache and replace was false.
+	bool precacheLandscape(const QString& id, const bool replace=true);
+	//! Remove a landscape from the cache of landscapes.
+	//! @param id the ID of a landscape
+	//! @return false if landscape could not be found
+	bool removeCachedLandscape(const QString& id);
+	//! Set size of the landscape cache, in MB.
+	//! Default size is 100MB, or configured as [landscape/cache_size_mb] from config.ini.
+	//! The landscape sizes returned in Landscape::getMemorySize() are only approximate, but include image and texture sizes.
+	//! A big landscape may well take 150MB or more.
+	//! On a 32bit system, keep this rather small. On 64bit with 16GB RAM and no other tasks, 4GB is no problem.
+	//! Modern GPUs may have 4 or even 8GB of dedicated texture memory. Most of this may be filled with landscape textures.
+	//! Example: a museum installation with 20 large (16384x2048) old_stype landscapes can require up to 3.5GB. Allow 4GB cache,
+	//! and the system will never have to load a landscape during the show when all have been preloaded.
+	void setCacheSize(int mb) { landscapeCache.setMaxCost(mb);}
+	//! Retrieve total size of cache (MB).
+	int getCacheSize() const {return landscapeCache.maxCost();}
+	//! Retrieve sum of currently used memory in cache (MB, approximate)
+	int getCacheFilledSize() const {return landscapeCache.totalCost();}
+	//! Return number of landscapes already in the cache.
+	int getCacheCount() const {return landscapeCache.count();}
+
 	//! Get the current landscape object.
 	Landscape* getCurrentLandscape() const { return landscape; }
 
@@ -505,16 +532,24 @@
 	//! Indicate auto-enable atmosphere for planets with atmospheres in location window
 	bool flagAtmosphereAutoEnabling;
 
-	// The ID of the currently loaded landscape
+	//! The ID of the currently loaded landscape
 	QString currentLandscapeID;
 
-	// The ID of the default landscape
+	//! The ID of the default landscape
 	QString defaultLandscapeID;
 
 	//! List of the IDs of the landscapes packaged by default with Stellarium.
 	//! (So that they can't be removed.)
 	QStringList packagedLandscapeIDs;
 
+	//! QCache of landscapes kept in memory for faster access, esp. when frequently switching between several big landscapes.
+	//! Example: a 16384-size old_style landscape takes about 10 seconds to load. Kept in cache, it is back instantly.
+	//! Of course, this requires lots of RAM and GPU texture memory, but in the age of 64bit CPUs and 4GB and more GPU
+	//! texture memory, it is no problem to keep even 20 or more landscapes.
+	//! This is esp. useful in a context of automated setup (museum show or such) where a list of landscapes is preloaded
+	//! at system start (e.g. in the startup.ssc script) and then retrieved while script is running.
+	//! The key is just the LandscapeID.
+	QCache<QString,Landscape> landscapeCache;
 };
 
 #endif // _LANDSCAPEMGR_HPP_