Merge lp:~registry/stellarium/scenery3d_Qt5 into lp:stellarium

[gzotti]

A new and I think still unique feature! 3D Foreground landscapes to walk around, study structural alignments with celestial objects/events, study light-and-shadow phenomena, or just look for the best observing location in your garden (once you have created a model of it ;-)

Florian did a marvellous job here, getting all the niceties out of current hardware, large or small! Except for some log messages which will be further reduced, I think it is ready for primetime :-)

[Alexander Wolf (alexwolf)]

Please update .bzrignore file - right now you drop from bzr default settings for planetarium and scripts for installer.

Plus name of project should not change - SET(VERSION "${STELLARIUM_MAJOR}.${STELLARIUM_MINOR}.${STELLARIUM_PATCH}-scenery3D")

review: Needs Fixing

[lp:~registry/stellarium/scenery3d_Qt5]

5100. By gzotti on 2015-03-26

Fix a few CR/LF issues

[gzotti (georg-zotti)]

Huh? Is there a functional difference depending on CR/LF?

$ diff -w trunk5/.bzrignore scenery3d_Qt5/.bzrignore
(empty answer)

OK, we have CR/LF issues. I copied the file over from trunk. Likely a few others.

Project name: sure!

[lp:~registry/stellarium/scenery3d_Qt5]

5101. By gzotti on 2015-03-26

fix CR/LF

5102. By gzotti on 2015-03-26

relocated button icons and resource files

[Alexander Wolf (alexwolf)]

Disabling of landscapes when Scenery3D running - is it normal?

[Fabien Chéreau (xalioth)]

Very good professional work. I really appreciate the good documentation and latex sources included in the code :)

Before merging in trunk I have a couple of requests:
 - Util.hpp/.cpp : try to move part of this in the main Stellarium code. Get rid of useless extern, try to use QString versions instead of including part of the STL
 - there are still some fixed pipeline code in the opengl code (glBegin & co)
 - on real OpenGL ES devices you also need to specify the precision of the variable in the shaders (low, medium, high), they can be added as Qt automatically remove them on desktop platforms

[Fabien Chéreau (xalioth)]

Almost good.
See commetn above.

Also, it would be nice to have more 3D landscapes samples :D

review: Needs Fixing

[gzotti (georg-zotti)]

> Disabling of landscapes when Scenery3D running - is it normal?

We don't disable landscapes. A landscape can be specified in the scenery3d.ini. A complete scenery would require a photo pano landscape taken on-site, reworked to remove the horizon-crossing closeup elements from the photo. In order not to add another landscape, I just defined zero horizon as the landscape here.

[gzotti (georg-zotti)]

> Very good professional work. I really appreciate the good documentation and
> latex sources included in the code :)

Thanks!

> Before merging in trunk I have a couple of requests:
> - Util.hpp/.cpp : try to move part of this in the main Stellarium code. Get
> rid of useless extern, try to use QString versions instead of including part
> of the STL
> - there are still some fixed pipeline code in the opengl code (glBegin & co)
> - on real OpenGL ES devices you also need to specify the precision of the
> variable in the shaders (low, medium, high), they can be added as Qt
> automatically remove them on desktop platforms

OK, I'll see what I can do :-)

[gzotti (georg-zotti)]

> Almost good.
> See commetn above.
>
> Also, it would be nice to have more 3D landscapes samples :D

Sure. Unfortunately creating a good model takes time. There are some good models e.g. in the Google 3D gallery, and I have configured a few for myself. But they are copyrighted, so they cannot be included. Any volunteers, e.g. for Jantar Mantar, some Greek temples, Newgrange, Fajada Butte Sun Dagger, Stonehenge, Augustus Obelisk, Machu Picchu, Dengfeng, ...? There are countless possibilities!

[Florian Schaukowitsch (fschauk)]

Hello, original developer here. Thanks for the kind words!

Some notes:
> - Util.hpp/.cpp : try to move part of this in the main Stellarium code. Get
> rid of useless extern, try to use QString versions instead of including part
> of the STL
Yeah, that is an artifact of some older parts of the codebase (~2012). I was unhappy with that when I started "repairing" the code, but never really found time to change this.

> - there are still some fixed pipeline code in the opengl code (glBegin & co)
The fixed-function stuff is only needed for some debugging output (rendering of bounding boxes/view frusta). During normal usage it will never be called. On pure ES devices or on ANGLE, the code is disabled.

> - on real OpenGL ES devices you also need to specify the precision of the
> variable in the shaders (low, medium, high), they can be added as Qt
> automatically remove them on desktop platforms
Most of the shaders should be compatible with OpenGL ES2. As far as I know, it is not strictly required to specify precision for everything in a vertex shader (because there is already a default precision for floats, see https://stackoverflow.com/questions/5366416/in-opengl-es-2-0-glsl-where-do-you-need-precision-specifiers ), and the fragment shaders should contain the precision specifiers where needed.

The only shaders which will not work with OpenGL ES2 should be the optional geometry shaders (.geom files, require #version 150/OpenGL 3.2, are completely disabled on ES2 or if 3.2 is not supported) and the s3d_pixellit.frag shader (which uses some #version 120 stuff, but has an alternative simplified implementation for ES2 in s3d_pixellit_es.frag).

The plugin was tested by me on an AMD HD5850, an integrated Intel chip (OpenGL 2.1) and on one of the new NVidia GTX 970. Additionally I tested it on ANGLE builds, and on an OpenGL ES2 emulator (http://malideveloper.arm.com/develop-for-mali/tools/software-tools/opengl-es-emulator/). Georg also tested it on an Odroid C1 (which has embedded Mali graphics with "real" OpenGL ES2), seemingly without problems.

OpenGL ES2/ANGLE has some limitations. To support larger models (with more than 65535 vertices) the plugin depends on the presence of the "GL_OES_element_index_uint" extension. Shadows require "GL_OES_depth_texture" or "GL_ANGLE_depth_texture". The only thing really missing on ES2/ANGLE is shadow filtering (including PCSS).

[lp:~registry/stellarium/scenery3d_Qt5]

5103. By Florian Schaukowitsch on 2015-03-28

Fix a linker error on Qt 5.4 dynamic OpenGL builds

5104. By Florian Schaukowitsch on 2015-03-28

Remove Scenery3d's Util.hpp/.cpp, moving its contents to StelUtils, VecMath.hpp and OBJ. Replaced the std::strings with QStrings, and removed the now useless functions.

[gzotti (georg-zotti)]

Thank you Florian!

So, any more comments/requests? I might have another self-made model to share, must check in the next days if size is small enough. Also, I will add a polygon-reduced model of Sterngarten for "embedded" use (those, like the Odroid C1, are limited to 64k vertices. The Odroid XU3 works much better and with full-size models).

review: Needs Resubmitting

[Alexander Wolf (alexwolf)]

I think we can merge this branch.

review: Approve

[Fabien Chéreau (xalioth)]

OK for me as well

On Wed, Apr 1, 2015 at 5:21 AM, Alexander Wolf <email address hidden>
wrote:

> Review: Approve
>
> I think we can merge this branch.
> --
>
> https://code.launchpad.net/~stellarium-scenery3d/stellarium/scenery3d_Qt5/+merge/254181
> You are reviewing the proposed merge of
> lp:~stellarium-scenery3d/stellarium/scenery3d_Qt5 into lp:stellarium.
>

[lp:~registry/stellarium/scenery3d_Qt5]

5105. By gzotti on 2015-04-01

merge from trunk r7515 (final merge before merging into trunk :-).

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-03-08 17:23:20 +0000
+++ CMakeLists.txt	2015-04-01 10:27:06 +0000
@@ -1,5 +1,5 @@
 
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.11)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0.0)
 
 IF(NOT ("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 3.0))
   CMAKE_POLICY(SET CMP0050 OLD)
@@ -7,6 +7,7 @@
   CMAKE_POLICY(SET CMP0046 OLD)
 ENDIF()
 
+# just avoid a warning mess. 
 IF(NOT ("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}" LESS 3.0.2))
   CMAKE_POLICY(SET CMP0043 OLD)
 ENDIF()
@@ -26,7 +27,7 @@
 SET(PACKAGE_VERSION "${VERSION}")
 ADD_DEFINITIONS(-DPACKAGE_VERSION="${PACKAGE_VERSION}")
 
-SET(MINIMAL_QT_VERSION "5.2.0")
+SET(MINIMAL_QT_VERSION "5.3.0")
 
 # Use customized cmake macros
 SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
@@ -182,6 +183,7 @@
 ADD_PLUGIN(Pulsars 1)
 ADD_PLUGIN(Quasars 1)
 ADD_PLUGIN(Satellites 1)
+ADD_PLUGIN(Scenery3d 1)
 ADD_PLUGIN(SolarSystemEditor 1)
 ADD_PLUGIN(Supernovae 1)
 ADD_PLUGIN(TextUserInterface 1)
@@ -483,5 +485,9 @@
 IF(ENABLE_SCRIPTING)
   ADD_SUBDIRECTORY( scripts )
 ENDIF()
+if(USE_PLUGIN_SCENERY3D)
+  # add scenery3d scenes
+  ADD_SUBDIRECTORY( scenery3d )
+ENDIF()
 ADD_SUBDIRECTORY( stars )
 ADD_SUBDIRECTORY( plugins )

=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2014-11-15 15:44:55 +0000
+++ data/CMakeLists.txt	2015-04-01 10:27:06 +0000
@@ -2,6 +2,10 @@
 
 INSTALL(FILES stellarium.ico ssystem.ini ssystem_1000comets.ini base_locations.bin.gz DejaVuSans.ttf default_config.ini updates.json DejaVuSansMono.ttf iso639-1.utf8 iso3166-1-alpha-2.utf8 countryCodes.dat constellations_boundaries.dat DESTINATION share/${PACKAGE}/data)
 
+# install Scenery3d shaders
+INSTALL(DIRECTORY shaders/ DESTINATION share/${PACKAGE}/data/shaders FILES_MATCHING 
+	PATTERN "s3d_*.vert" PATTERN "s3d_*.geom" PATTERN "s3d_*.frag")
+
 IF (BUILD_FOR_MAEMO)
   INSTALL(FILES maemo/stellarium.desktop DESTINATION /usr/share/applications/hildon)
   INSTALL(FILES maemo/stellarium.png DESTINATION /usr/share/icons/hicolor/48x48/apps)

=== modified file 'data/gui/nightStyle.css'
--- data/gui/nightStyle.css	2015-02-18 22:21:55 +0000
+++ data/gui/nightStyle.css	2015-04-01 10:27:06 +0000
@@ -6,6 +6,10 @@
 	background: none;
 }
 
+QLabel:disabled {
+	color: rgb(100, 0, 0);
+}
+
 QLabel#stelWindowTitle {
 	margin-left: 24px;
 	font-size: 14px;

=== modified file 'data/gui/normalStyle.css'
--- data/gui/normalStyle.css	2015-03-17 14:02:04 +0000
+++ data/gui/normalStyle.css	2015-04-01 10:27:06 +0000
@@ -6,6 +6,10 @@
 	background: none;
 }
 
+QLabel:disabled {
+	color: rgb(50, 50, 50);
+}
+
 QLabel#stelWindowTitle {
 	margin-left: 24px;
 	font-size: 14px;

=== added file 'data/shaders/s3d_cube.frag'
--- data/shaders/s3d_cube.frag	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_cube.frag	2015-04-01 10:27:06 +0000
@@ -0,0 +1,34 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader that applies cubemapping to pre-transformed geometry
+*/
+ 
+//this is a samplerCube instead of a sampler2D here
+uniform samplerCube u_texDiffuse;
+
+varying highp vec3 v_texcoord;
+
+void main(void)
+{
+	gl_FragColor = textureCube(u_texDiffuse, v_texcoord);
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_cube.vert'
--- data/shaders/s3d_cube.vert	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_cube.vert	2015-04-01 10:27:06 +0000
@@ -0,0 +1,39 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader that applies cubemapping to pre-transformed geometry
+*/
+ 
+//matrices
+uniform mat4 u_mProjection;
+
+//Note: they are both vec3 here!
+attribute vec3 a_vertex;
+attribute vec3 a_texcoord;
+
+varying highp vec3 v_texcoord;
+
+void main(void)
+{
+	v_texcoord = a_texcoord;
+	gl_Position = u_mProjection * vec4(a_vertex,1.0);
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_debug.frag'
--- data/shaders/s3d_debug.frag	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_debug.frag	2015-04-01 10:27:06 +0000
@@ -0,0 +1,35 @@
+#version 110
+
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2015 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+/*
+	This is the shader used for debugging bounding boxes, frustums, polyhedra etc.
+	Because the old code extensively uses the immediate GL mode (glBegin/glEnd), this 
+	shader currently uses part of the fixed-function pipeline. This will make this shader
+	fail to compile on OpenGL ES!
+*/
+
+uniform vec4 u_vColor;
+
+void main(void)
+{
+    gl_FragColor = u_vColor * gl_Color;
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_debug.vert'
--- data/shaders/s3d_debug.vert	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_debug.vert	2015-04-01 10:27:06 +0000
@@ -0,0 +1,40 @@
+#version 110
+
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2015 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+/*
+	This is the shader used for debugging bounding boxes, frustums, polyhedra etc.
+	Because the old code extensively uses the immediate GL mode (glBegin/glEnd), this 
+	shader currently uses part of the fixed-function pipeline. This will make this shader
+	fail to compile on OpenGL ES!
+*/
+
+uniform mat4 u_mMVP;
+
+void main(void)
+{
+	//this should result in the vertices specified by glBegin/glEnd
+	//transforms are assumed to be identity matrices
+	vec4 oldVert = ftransform();
+	//we do the "real" transform ourselves using the same matrices as the other shaders use
+    gl_Position = u_mMVP * oldVert;
+	gl_FrontColor = gl_Color;
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_pixellit.frag'
--- data/shaders/s3d_pixellit.frag	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_pixellit.frag	2015-04-01 10:27:06 +0000
@@ -0,0 +1,503 @@
+#version 120
+
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014, 2015 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader for phong/per-pixel lighting.
+Note: This shader currently requires some #version 120 features!
+*/
+
+//macros that can be set by ShaderManager (simple true/false flags)
+#define BLENDING 1
+#define SHADOWS 1
+#define SHADOW_FILTER 0
+#define SHADOW_FILTER_HQ 0
+#define SINGLE_SHADOW_FRUSTUM 1
+#define PCSS 0
+#define MAT_DIFFUSETEX 1
+#define MAT_EMISSIVETEX 1
+#define MAT_SPECULAR 1
+#define BUMP 0
+#define HEIGHT 0
+#define ALPHATEST 1
+#define TORCH 1
+
+#if SHADOW_FILTER_HQ
+#define FILTER_STEPS 64
+//NOTE: Intel does NOT like it for some reason if this is a const array, so we set it as uniform
+uniform vec2 poissonDisk[FILTER_STEPS] = vec2[](
+   vec2(-0.613392, 0.617481),
+   vec2(0.170019, -0.040254),
+   vec2(-0.299417, 0.791925),
+   vec2(0.645680, 0.493210),
+   vec2(-0.651784, 0.717887),
+   vec2(0.421003, 0.027070),
+   vec2(-0.817194, -0.271096),
+   vec2(-0.705374, -0.668203),
+   vec2(0.977050, -0.108615),
+   vec2(0.063326, 0.142369),
+   vec2(0.203528, 0.214331),
+   vec2(-0.667531, 0.326090),
+   vec2(-0.098422, -0.295755),
+   vec2(-0.885922, 0.215369),
+   vec2(0.566637, 0.605213),
+   vec2(0.039766, -0.396100),
+   vec2(0.751946, 0.453352),
+   vec2(0.078707, -0.715323),
+   vec2(-0.075838, -0.529344),
+   vec2(0.724479, -0.580798),
+   vec2(0.222999, -0.215125),
+   vec2(-0.467574, -0.405438),
+   vec2(-0.248268, -0.814753),
+   vec2(0.354411, -0.887570),
+   vec2(0.175817, 0.382366),
+   vec2(0.487472, -0.063082),
+   vec2(-0.084078, 0.898312),
+   vec2(0.488876, -0.783441),
+   vec2(0.470016, 0.217933),
+   vec2(-0.696890, -0.549791),
+   vec2(-0.149693, 0.605762),
+   vec2(0.034211, 0.979980),
+   vec2(0.503098, -0.308878),
+   vec2(-0.016205, -0.872921),
+   vec2(0.385784, -0.393902),
+   vec2(-0.146886, -0.859249),
+   vec2(0.643361, 0.164098),
+   vec2(0.634388, -0.049471),
+   vec2(-0.688894, 0.007843),
+   vec2(0.464034, -0.188818),
+   vec2(-0.440840, 0.137486),
+   vec2(0.364483, 0.511704),
+   vec2(0.034028, 0.325968),
+   vec2(0.099094, -0.308023),
+   vec2(0.693960, -0.366253),
+   vec2(0.678884, -0.204688),
+   vec2(0.001801, 0.780328),
+   vec2(0.145177, -0.898984),
+   vec2(0.062655, -0.611866),
+   vec2(0.315226, -0.604297),
+   vec2(-0.780145, 0.486251),
+   vec2(-0.371868, 0.882138),
+   vec2(0.200476, 0.494430),
+   vec2(-0.494552, -0.711051),
+   vec2(0.612476, 0.705252),
+   vec2(-0.578845, -0.768792),
+   vec2(-0.772454, -0.090976),
+   vec2(0.504440, 0.372295),
+   vec2(0.155736, 0.065157),
+   vec2(0.391522, 0.849605),
+   vec2(-0.620106, -0.328104),
+   vec2(0.789239, -0.419965),
+   vec2(-0.545396, 0.538133),
+   vec2(-0.178564, -0.596057)
+);
+#elif SHADOW_FILTER
+#define FILTER_STEPS 16
+//NOTE: Intel does NOT like it for some reason if this is a const array, so we set it as uniform
+uniform vec2 poissonDisk[FILTER_STEPS] = vec2[]( 
+   vec2( -0.94201624, -0.39906216 ), 
+   vec2( 0.94558609, -0.76890725 ), 
+   vec2( -0.094184101, -0.92938870 ), 
+   vec2( 0.34495938, 0.29387760 ), 
+   vec2( -0.91588581, 0.45771432 ), 
+   vec2( -0.81544232, -0.87912464 ), 
+   vec2( -0.38277543, 0.27676845 ), 
+   vec2( 0.97484398, 0.75648379 ), 
+   vec2( 0.44323325, -0.97511554 ), 
+   vec2( 0.53742981, -0.47373420 ), 
+   vec2( -0.26496911, -0.41893023 ), 
+   vec2( 0.79197514, 0.19090188 ), 
+   vec2( -0.24188840, 0.99706507 ), 
+   vec2( -0.81409955, 0.91437590 ), 
+   vec2( 0.19984126, 0.78641367 ), 
+   vec2( 0.14383161, -0.14100790 ) 
+);
+#else
+#define FILTER_STEPS 0
+#endif
+
+#if MAT_DIFFUSETEX
+uniform sampler2D u_texDiffuse;
+#endif
+#if MAT_EMISSIVETEX
+uniform sampler2D u_texEmissive;
+#endif
+#if BUMP
+uniform sampler2D u_texBump;
+#endif
+#if HEIGHT
+uniform sampler2D u_texHeight;
+#endif
+
+//material info
+uniform vec3 u_vMixAmbient; // = light ambient * mtl ambient/diffuse depending on Illum model
+uniform vec3 u_vMixDiffuse; // light diffuse * mat diffuse
+#if MAT_SPECULAR
+uniform vec3 u_vMixSpecular;
+uniform float u_vMatShininess;
+#endif
+uniform float u_vMatAlpha;
+
+uniform vec3 u_vMixEmissive;
+
+#if SHADOWS
+//in a later version, this may become configurable
+#if SINGLE_SHADOW_FRUSTUM
+#define FRUSTUM_SPLITS 1
+#else
+#define FRUSTUM_SPLITS 4
+#endif
+//shadow related uniforms
+uniform vec4 u_vSplits; //the frustum splits
+#if PCSS
+	#define SHADOWSAMPLER sampler2D
+#else
+	#define SHADOWSAMPLER sampler2DShadow
+#endif
+
+//for some reason, Intel does absolutely not like it if the shadowmaps are passed as an array
+//nothing is drawn, but no error is shown ...
+//therefore, use 4 ugly uniforms
+uniform SHADOWSAMPLER u_texShadow0;
+#if !SINGLE_SHADOW_FRUSTUM
+uniform SHADOWSAMPLER u_texShadow1;
+uniform SHADOWSAMPLER u_texShadow2;
+uniform SHADOWSAMPLER u_texShadow3;
+#endif
+
+//info about scale is needed for filtering
+uniform vec4 u_vLightOrthoScale[FRUSTUM_SPLITS];
+#endif //SHADOWS
+
+#if ALPHATEST
+uniform float u_fAlphaThresh;
+#endif
+
+#if TORCH
+uniform vec3 u_vMixTorchDiffuse;
+uniform float u_fTorchAttenuation;
+#endif
+
+varying vec3 v_normal;
+varying vec2 v_texcoord;
+varying vec3 v_lightVec; //light vector, in VIEW or TBN space according to bump settings
+varying vec3 v_viewPos; //position of fragment in view space
+
+#if SHADOWS
+//varying arrays seem to cause some problems, so we use 4 vecs for now...
+varying vec4 v_shadowCoord0;
+#if !SINGLE_SHADOW_FRUSTUM
+varying vec4 v_shadowCoord1;
+varying vec4 v_shadowCoord2;
+varying vec4 v_shadowCoord3;
+#endif
+#endif
+
+#if SHADOWS
+
+float sampleShadow(in SHADOWSAMPLER tex, in vec4 coord, in vec2 filterRadiusUV)
+{
+	#if FILTER_STEPS
+	// a filter is defined
+	float sum =0.0;
+	
+	vec3 texC = coord.xyz / coord.w;
+	for(int i=0;i<FILTER_STEPS;++i)
+	{
+		vec2 offset = poissonDisk[i] * filterRadiusUV;
+		//TODO offsets should probably depend on light ortho size?
+		#if PCSS
+		//texture is a normal sampler2D because we need depth values in blocker calculation
+		//opengl does not allow to sample this texture in 2 different ways (unless sampler objects are used, but needs version >= 3.3)
+		//so we have to do comparison ourselves 
+		sum+= (texture2D(tex,texC.xy + offset).r > texC.z) ? 1.0f : 0.0f;
+		#else
+		sum+=shadow2D(tex,vec3(texC.xy + offset, texC.z)).x;
+		#endif
+	}
+	return sum / FILTER_STEPS;
+	#else
+	//no filtering performed, just return the sampled tex
+	return shadow2DProj(tex,coord).x;
+	#endif
+}
+
+#if PCSS
+//Based on the PCSS implementation of NVidia, ported to GLSL 
+//see http://developer.download.nvidia.com/whitepapers/2008/PCSS_Integration.pdf
+//Some modifications to work better with directional light are included
+
+//convert shadowmap depth to view-space Z value (for an orthographic projection)
+float depthToViewZ(float depth, float nearPlane, float farPlane)
+{
+	return depth * (farPlane - nearPlane) + nearPlane;
+}
+
+#define LIGHT_SCALE 0.003
+#define SEARCH_WIDTH 0.08
+
+float PenumbraSize(in float zReceiver, in float zBlocker)
+{
+	//this is the classical way as proposed by nvidia, but it does not work well with directional light (it is assumed the light is positioned at the near plane)
+	//return (zReceiver - zBlocker) * LIGHT_SIZE / zBlocker;
+	//instead, just use the distance to the blocker as scaling because the difference between zReceiver and zBlocker is small compared to their difference to the light, so we skip the division
+	//we call this function using view space units, so the scaling should be quite small
+	return (zReceiver - zBlocker) * LIGHT_SCALE;
+}
+
+#define BLOCKER_SEARCH_NUM_SAMPLES 16
+
+void FindBlocker(in SHADOWSAMPLER tex,in vec2 uv, in float zReceiver, in vec2 searchWidth, out float avgBlockerDepth, out float numBlockers)
+{	
+	float blockerSum = 0;
+	numBlockers = 0;
+	
+	//make sure original position is also sampled to avoid artifacts when shadow map resolution is bad or light angle very flat
+	float shadowMapDepth = texture2D(tex,uv).r;
+	if(shadowMapDepth<zReceiver)
+	{
+		blockerSum+=shadowMapDepth;
+		++numBlockers;
+	}
+	
+	for(int i=0;i<BLOCKER_SEARCH_NUM_SAMPLES;++i)
+	{
+		float shadowMapDepth = texture2D(tex,uv + poissonDisk[i] * searchWidth).r;
+		if(shadowMapDepth < zReceiver)
+		{
+			blockerSum+=shadowMapDepth;
+			++numBlockers;
+		}
+	}
+	
+	//divide by zero is ignored here, but basically handled by the calling function
+	avgBlockerDepth = blockerSum / numBlockers;
+}
+
+float ShadowPCSS(in SHADOWSAMPLER tex, in vec4 coords, in vec4 offsetScale)
+{
+	vec3 coordsProj = coords.xyz/coords.w;
+	
+	float avgBlockerDepth = 0.0f;
+	float numBlockers = 0.0f;
+	
+	//convert depths to view space, this makes sure a consistent result is achieved regardless of the near/far planes of the frustum splits
+	float zReceiver = depthToViewZ(coordsProj.z, offsetScale.z, offsetScale.w);
+	
+	//search width estimation is also tricky for directional light, so we just use a constant value
+	vec2 searchWidth = offsetScale.xy * SEARCH_WIDTH;
+
+	FindBlocker(tex,coordsProj.xy,coordsProj.z,searchWidth,avgBlockerDepth,numBlockers);
+	if(numBlockers<1)
+		return 1.0f;
+	
+	//this is the searchwidth in m
+	float penumbraRatio = PenumbraSize(zReceiver, depthToViewZ(avgBlockerDepth,offsetScale.z, offsetScale.w));
+	//multiply with the ortho projection scaling to get the uv radius
+	
+	vec2 filterRadiusUV = penumbraRatio * offsetScale.xy;
+	//constraining seems to not make much difference in our scenes
+	//vec2 filterRadiusUV = min(searchWidth, penumbraRatio * offsetScale.xy);
+	
+	return sampleShadow(tex,coords,filterRadiusUV );
+}
+#endif
+
+float getShadow()
+{
+	//simplification of the smap.f.glsl shader
+	//IMPORTANT: use clip coords here, not distance to camera
+	float dist = gl_FragCoord.z;
+		
+	//check in which split the fragment falls
+	//I tried using indices to simplify the code a bit, but this lead to very strange artifacts...
+	#if PCSS
+	if(dist < u_vSplits.x)
+	{
+		return ShadowPCSS(u_texShadow0,v_shadowCoord0,u_vLightOrthoScale[0]);
+	}
+	#if !SINGLE_SHADOW_FRUSTUM
+	else if(dist < u_vSplits.y)
+	{
+		return ShadowPCSS(u_texShadow1,v_shadowCoord1,u_vLightOrthoScale[1]);
+	}
+	else if(dist < u_vSplits.z)
+	{
+		return ShadowPCSS(u_texShadow2,v_shadowCoord2,u_vLightOrthoScale[2]);
+	}
+	else if(dist < u_vSplits.w)
+	{
+		return ShadowPCSS(u_texShadow3,v_shadowCoord3,u_vLightOrthoScale[3]);
+	}
+	#endif
+	#else
+	//If all calculations are correct, this should be 1cm
+	#define DEFAULT_RADIUS 1.0/100.0
+	if(dist < u_vSplits.x)
+	{
+		return sampleShadow(u_texShadow0,v_shadowCoord0,u_vLightOrthoScale[0].xy * DEFAULT_RADIUS);
+	}
+	#if !SINGLE_SHADOW_FRUSTUM
+	else if(dist < u_vSplits.y)
+	{
+		return sampleShadow(u_texShadow1,v_shadowCoord1,u_vLightOrthoScale[1].xy * DEFAULT_RADIUS);
+	}
+	else if(dist < u_vSplits.z)
+	{
+		return sampleShadow(u_texShadow2,v_shadowCoord2,u_vLightOrthoScale[2].xy * DEFAULT_RADIUS);
+	}
+	else if(dist < u_vSplits.w)
+	{
+		return sampleShadow(u_texShadow3,v_shadowCoord3,u_vLightOrthoScale[3].xy * DEFAULT_RADIUS);
+	}
+	#endif
+	#endif
+	
+	return 1.0;
+}
+#endif
+
+void calcLighting(in vec3 normal,in vec3 eye,out vec3 texCol,out vec3 specCol)
+{
+	vec3 L = v_lightVec; //no normalize here, or it may cause divide by zero
+
+	//basic lambert term
+	float NdotL = clamp(dot(normal, L),0.0,1.0);
+#if BUMP
+	//use the original NdotL (which equals L.z because original normal is (0,0,1) in TBN space!) to modify the result
+	//this hides incorrect illumination on the backside of objects
+	float origNormalFactor = 1.0 - 1.0 / (1.0 + 100.0 * max(L.z,0.0));
+	NdotL *=  origNormalFactor;
+#endif
+	vec3 Idiff = u_vMixDiffuse * NdotL;
+
+	
+#if SHADOWS
+	float shd = getShadow();
+	Idiff *= shd;
+#endif
+	
+#if TORCH
+	//calculate additional diffuse, modeled by a point light centered on the cam pos
+	float camDistSq = dot(v_viewPos,v_viewPos);
+	float att = max(0.0, 1.0 - camDistSq * u_fTorchAttenuation);
+	att *= att;
+	
+	Idiff += att * u_vMixTorchDiffuse * max(0.0, dot(normal,eye));
+#endif
+	
+	#if MAT_SPECULAR
+	if(NdotL>0.001)
+	{
+		//calculate phong reflection vector
+		vec3 R = reflect(-L,normal);
+		
+		float RdotE = dot(normalize(R), eye);
+		
+		if(RdotE>0.0)
+		{
+			//specular term according to Phong model (light specular is assumed to be white for now)
+			specCol = u_vMixSpecular * pow( RdotE, u_vMatShininess);
+			#if SHADOWS
+			specCol *= shd;
+			#endif
+			#if BUMP
+			specCol *= origNormalFactor;
+			#endif
+		}
+		else
+		{
+			specCol = vec3(0,0,0);
+		}
+	}
+	else
+	{
+		specCol = vec3(0,0,0);
+	}
+	#else
+	specCol = vec3(0,0,0);
+	#endif
+		
+	texCol = u_vMixAmbient + Idiff;
+}
+
+#if BUMP
+vec3 getBumpNormal(vec2 texCoords)
+{
+	return texture2D(u_texBump, texCoords).xyz * 2.0 - 1.0;
+}
+#endif
+
+#if HEIGHT
+const float heightScale = 0.015f; //const for now
+#endif
+
+void main(void)
+{
+#if MAT_DIFFUSETEX
+	vec4 texVal = texture2D(u_texDiffuse,v_texcoord);
+	#if ALPHATEST
+	//check if alpha lies below threshold
+	if(texVal.a < u_fAlphaThresh)
+		discard;
+	#endif
+#endif
+
+	vec2 texCoords = v_texcoord;
+	vec3 eye = normalize(-v_viewPos);
+	
+	#if HEIGHT
+	//pertube texture coords with heightmap
+	float height = texture2D(u_texHeight, texCoords).r;
+	//*scale +bias
+	height = height * heightScale - 0.5*heightScale;
+		
+	texCoords = texCoords + (height * eye.xz);
+	#endif
+	
+	#if BUMP
+	vec3 normal = getBumpNormal(texCoords);
+	#else
+	vec3 normal = v_normal;
+	#endif
+
+	vec3 texCol,specCol; //texCol gets multiplied with diffuse map, specCol not
+	calcLighting(normalize(normal),eye,texCol,specCol);
+	
+	#if MAT_EMISSIVETEX
+	//use existing specCol to avoid using another vec3
+	specCol += u_vMixEmissive * texture2D(u_texEmissive,v_texcoord).rgb;
+	#else
+	specCol += u_vMixEmissive;
+	#endif
+	
+#if MAT_DIFFUSETEX
+	#if BLENDING
+	gl_FragColor = vec4(texCol * texVal.rgb + specCol,u_vMatAlpha * texVal.a);
+    #else
+	//gl_FragColor = vec4(texCol * texVal.rgb + specCol, 1.0);
+	gl_FragColor = vec4(texCol * texVal.rgb + specCol, 1.0);
+	#endif
+#else
+	gl_FragColor = vec4(texCol + specCol,u_vMatAlpha); //u_vMatAlpha is automatically set to 1.0 if blending is disabled
+#endif
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_pixellit.geom'
--- data/shaders/s3d_pixellit.geom	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_pixellit.geom	2015-04-01 10:27:06 +0000
@@ -0,0 +1,88 @@
+#version 150
+
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader geometry-shader (using 3.2 core functionality, #version 150) based acceleration of cubemap rendering.
+For vertex-based lighting, this is pretty simple: the lighting is performed in the
+ Vertex shader in a common view space
+*/
+
+#define SHADOWS 1
+#define SINGLE_SHADOW_FRUSTUM 0
+
+layout(triangles) in;
+layout(triangle_strip,max_vertices = 18) out;
+
+in vec2 v_texcoordGS[];
+in vec3 v_normalGS[];
+in vec3 v_lightVecGS[];
+in vec3 v_viewPosGS[];
+out vec2 v_texcoord;
+out vec3 v_normal;
+out vec3 v_lightVec;
+out vec3 v_viewPos;
+
+#if SHADOWS
+in vec4 v_shadowCoord0GS[];
+out vec4 v_shadowCoord0;
+
+#if !SINGLE_SHADOW_FRUSTUM
+in vec4 v_shadowCoord1GS[];
+in vec4 v_shadowCoord2GS[];
+in vec4 v_shadowCoord3GS[];
+out vec4 v_shadowCoord1;
+out vec4 v_shadowCoord2;
+out vec4 v_shadowCoord3;
+#endif
+#endif
+
+uniform mat4 u_mCubeMVP[6];
+
+void main(void)
+{
+	//iterate over cubemap faces
+	for(gl_Layer=0; gl_Layer<6;++gl_Layer)
+	{
+		//iterate over triangle vertices
+		for(int vtx = 0;vtx<3;++vtx)
+		{
+			//calc new position in current cubemap face
+			gl_Position = u_mCubeMVP[gl_Layer] * gl_in[vtx].gl_Position;
+			//pass on other varyings
+			v_texcoord = v_texcoordGS[vtx];
+			v_normal = v_normalGS[vtx];
+			v_lightVec = v_lightVecGS[vtx];
+			v_viewPos = v_viewPosGS[vtx];
+			#if SHADOWS
+			v_shadowCoord0 = v_shadowCoord0GS[vtx];
+			#if !SINGLE_SHADOW_FRUSTUM
+			v_shadowCoord1 = v_shadowCoord1GS[vtx];
+			v_shadowCoord2 = v_shadowCoord2GS[vtx];
+			v_shadowCoord3 = v_shadowCoord3GS[vtx];
+			#endif
+			#endif
+			EmitVertex();
+		}
+		EndPrimitive();
+	}
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_pixellit.vert'
--- data/shaders/s3d_pixellit.vert	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_pixellit.vert	2015-04-01 10:27:06 +0000
@@ -0,0 +1,137 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader for phong/per-pixel lighting.
+*/
+ 
+//macros that can be set by ShaderManager (simple true/false flags)
+#define SHADOWS 1
+#define SINGLE_SHADOW_FRUSTUM 0
+#define BUMP 1
+#define HEIGHT 1
+#define GEOMETRY_SHADER 0
+
+//matrices
+uniform mat4 u_mModelView;
+#if ! GEOMETRY_SHADER
+uniform mat4 u_mProjection;
+#endif
+uniform mat3 u_mNormal;
+
+uniform vec3 u_vLightDirectionView; //in view space, from point to light
+
+#if SHADOWS
+//shadow transforms
+uniform mat4 u_mShadow0;
+#if !SINGLE_SHADOW_FRUSTUM 
+uniform mat4 u_mShadow1;
+uniform mat4 u_mShadow2;
+uniform mat4 u_mShadow3;
+#endif
+#endif
+
+attribute vec4 a_vertex;
+attribute vec3 a_normal;
+attribute vec2 a_texcoord;
+#if BUMP
+attribute vec4 a_tangent;
+#endif
+
+#if GEOMETRY_SHADER
+#define VAR_TEXCOORD v_texcoordGS
+#define VAR_NORMAL v_normalGS
+#define VAR_LIGHTVEC v_lightVecGS
+#define VAR_VIEWPOS v_viewPosGS
+#define VAR_SHADOWCOORD0 v_shadowCoord0GS
+#define VAR_SHADOWCOORD1 v_shadowCoord1GS
+#define VAR_SHADOWCOORD2 v_shadowCoord2GS
+#define VAR_SHADOWCOORD3 v_shadowCoord3GS
+#else
+#define VAR_TEXCOORD v_texcoord
+#define VAR_NORMAL v_normal
+#define VAR_LIGHTVEC v_lightVec
+#define VAR_VIEWPOS v_viewPos
+#define VAR_SHADOWCOORD0 v_shadowCoord0
+#define VAR_SHADOWCOORD1 v_shadowCoord1
+#define VAR_SHADOWCOORD2 v_shadowCoord2
+#define VAR_SHADOWCOORD3 v_shadowCoord3
+#endif
+
+varying vec3 VAR_NORMAL; //normal in view space
+varying vec2 VAR_TEXCOORD;
+varying vec3 VAR_LIGHTVEC; //light vector, in VIEW or TBN space according to bump settings
+varying vec3 VAR_VIEWPOS; //position of fragment in view space
+
+#if SHADOWS
+//varying arrays seem to cause some problems, so we use 4 vecs for now...
+varying vec4 VAR_SHADOWCOORD0;
+#if !SINGLE_SHADOW_FRUSTUM 
+varying vec4 VAR_SHADOWCOORD1;
+varying vec4 VAR_SHADOWCOORD2;
+varying vec4 VAR_SHADOWCOORD3;
+#endif
+#endif
+
+void main(void)
+{
+	//transform normal
+	VAR_NORMAL = normalize(u_mNormal * a_normal);
+	
+	//pass on tex coord
+	VAR_TEXCOORD = a_texcoord;
+	
+	//calc vertex pos in view space
+	vec4 viewPos = u_mModelView * a_vertex;
+	VAR_VIEWPOS = viewPos.xyz;
+	
+	#if SHADOWS
+	//calculate shadowmap coords
+	VAR_SHADOWCOORD0 = u_mShadow0 * a_vertex;
+	#if !SINGLE_SHADOW_FRUSTUM 
+	VAR_SHADOWCOORD1 = u_mShadow1 * a_vertex;
+	VAR_SHADOWCOORD2 = u_mShadow2 * a_vertex;
+	VAR_SHADOWCOORD3 = u_mShadow3 * a_vertex;
+	#endif
+	#endif
+	
+	#if BUMP
+	//create View-->TBN matrix
+	vec3 t = normalize(u_mNormal * a_tangent.xyz);
+	//bitangent recreated from normal and tangent instead passed as attribute for a bit more orthonormality
+	vec3 b = cross(VAR_NORMAL, t) * a_tangent.w; //w coordinate stores handedness of tangent space
+	
+	mat3 TBN = mat3(t.x, b.x, VAR_NORMAL.x,
+					t.y, b.y, VAR_NORMAL.y,
+					t.z, b.z, VAR_NORMAL.z);
+	VAR_LIGHTVEC = TBN * u_vLightDirectionView;
+	VAR_VIEWPOS = TBN * VAR_VIEWPOS;
+	#else
+	VAR_LIGHTVEC = u_vLightDirectionView;
+	#endif
+	
+	//calc final position
+	#if GEOMETRY_SHADER
+	gl_Position = a_vertex; //pass on unchanged
+	#else
+	gl_Position = u_mProjection * viewPos;
+	#endif
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_pixellit_es.frag'
--- data/shaders/s3d_pixellit_es.frag	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_pixellit_es.frag	2015-04-01 10:27:06 +0000
@@ -0,0 +1,277 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014, 2015 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader for phong/per-pixel lighting with shadowing and bumpmapping.
+This is a reduced version of the shader for OpenGL ES2, without shadow filtering/PCSS 
+*/
+
+//macros that can be set by ShaderManager (simple true/false flags)
+#define BLENDING 1
+#define SHADOWS 1
+#define SINGLE_SHADOW_FRUSTUM 1
+#define MAT_DIFFUSETEX 1
+#define MAT_EMISSIVETEX 1
+#define MAT_SPECULAR 1
+#define BUMP 1
+#define HEIGHT 1
+#define ALPHATEST 1
+#define TORCH 1
+
+#if MAT_DIFFUSETEX
+uniform sampler2D u_texDiffuse;
+#endif
+#if MAT_EMISSIVETEX
+uniform sampler2D u_texEmissive;
+#endif
+#if BUMP
+uniform sampler2D u_texBump;
+#endif
+#if HEIGHT
+uniform sampler2D u_texHeight;
+#endif
+
+//material info
+uniform mediump vec3 u_vMixAmbient; // = light ambient * mtl ambient/diffuse depending on Illum model
+uniform mediump vec3 u_vMixDiffuse; // light diffuse * mat diffuse
+#if MAT_SPECULAR
+uniform mediump vec3 u_vMixSpecular;
+uniform mediump float u_vMatShininess;
+#endif
+uniform mediump float u_vMatAlpha;
+
+uniform mediump vec3 u_vMixEmissive;
+
+#if SHADOWS
+//in a later version, this may become configurable
+#if SINGLE_SHADOW_FRUSTUM
+#define FRUSTUM_SPLITS 1
+#else
+#define FRUSTUM_SPLITS 4
+#endif
+//shadow related uniforms
+uniform mediump vec4 u_vSplits; //the frustum splits
+
+//Basic opengl ES2 does not have shadow samplers, so we compare ourselves
+#define SHADOWSAMPLER sampler2D
+
+//for some reason, Intel does absolutely not like it if the shadowmaps are passed as an array
+//nothing is drawn, but no error is shown ...
+//therefore, use 4 ugly uniforms
+uniform mediump SHADOWSAMPLER u_texShadow0;
+#if !SINGLE_SHADOW_FRUSTUM
+uniform mediump SHADOWSAMPLER u_texShadow1;
+uniform mediump SHADOWSAMPLER u_texShadow2;
+uniform mediump SHADOWSAMPLER u_texShadow3;
+#endif
+
+#endif //SHADOWS
+
+#if ALPHATEST
+uniform lowp float u_fAlphaThresh;
+#endif
+
+#if TORCH
+uniform mediump vec3 u_vMixTorchDiffuse;
+uniform mediump float u_fTorchAttenuation;
+#endif
+
+varying mediump vec3 v_normal;
+varying mediump vec2 v_texcoord;
+varying mediump vec3 v_lightVec; //light vector, in VIEW or TBN space according to bump settings
+varying mediump vec3 v_viewPos; //position of fragment in view space
+
+#if SHADOWS
+//varying arrays seem to cause some problems, so we use 4 vecs for now...
+varying mediump vec4 v_shadowCoord0;
+#if !SINGLE_SHADOW_FRUSTUM
+varying mediump vec4 v_shadowCoord1;
+varying mediump vec4 v_shadowCoord2;
+varying mediump vec4 v_shadowCoord3;
+#endif
+#endif
+
+#if SHADOWS
+
+lowp float sampleShadow(in mediump SHADOWSAMPLER tex, in mediump vec4 coord)
+{
+	mediump vec3 texC = coord.xyz / coord.w;
+	//no filtering performed, just return the sampled tex
+	return (texture2D(tex,texC.xy).r > texC.z ? 1.0 : 0.0);
+}
+
+lowp float getShadow()
+{
+	//simplification of the smap.f.glsl shader
+	//IMPORTANT: use clip coords here, not distance to camera
+	mediump float dist = gl_FragCoord.z;
+		
+	//check in which split the fragment falls
+	//I tried using indices to simplify the code a bit, but this lead to very strange artifacts...
+	//If all calculations are correct, this should be 1cm
+	if(dist < u_vSplits.x)
+	{
+		return sampleShadow(u_texShadow0,v_shadowCoord0);
+	}
+	#if !SINGLE_SHADOW_FRUSTUM
+	else if(dist < u_vSplits.y)
+	{
+		return sampleShadow(u_texShadow1,v_shadowCoord1);
+	}
+	else if(dist < u_vSplits.z)
+	{
+		return sampleShadow(u_texShadow2,v_shadowCoord2);
+	}
+	else if(dist < u_vSplits.w)
+	{
+		return sampleShadow(u_texShadow3,v_shadowCoord3);
+	}
+	#endif
+	
+	return 1.0;
+}
+#endif
+
+void calcLighting(in mediump vec3 normal,in mediump vec3 eye,out mediump vec3 texCol,out mediump vec3 specCol)
+{
+	mediump vec3 L = v_lightVec; //no normalize here, or it may cause divide by zero
+
+	//basic lambert term
+	mediump float NdotL = clamp(dot(normal, L),0.0,1.0);
+#if BUMP
+	//use the original NdotL (which equals L.z because original normal is (0,0,1) in TBN space!) to modify the result
+	//this hides incorrect illumination on the backside of objects
+	mediump float origNormalFactor = 1.0 - 1.0 / (1.0 + 100.0 * max(L.z,0.0));
+	NdotL *=  origNormalFactor;
+#endif
+	mediump vec3 Idiff = u_vMixDiffuse * NdotL;
+
+	
+#if SHADOWS
+	lowp float shd = getShadow();
+	Idiff *= shd;
+#endif
+	
+#if TORCH
+	//calculate additional diffuse, modeled by a point light centered on the cam pos
+	mediump float camDistSq = dot(v_viewPos,v_viewPos);
+	mediump float att = max(0.0, 1.0 - camDistSq * u_fTorchAttenuation);
+	att *= att;
+	
+	Idiff += att * u_vMixTorchDiffuse * max(0.0, dot(normal,eye));
+#endif
+	
+	#if MAT_SPECULAR
+	if(NdotL>0.001)
+	{
+		//calculate phong reflection vector
+		mediump vec3 R = reflect(-L,normal);
+		
+		mediump float RdotE = dot(normalize(R), eye);
+		
+		if(RdotE>0.0)
+		{
+			//specular term according to Phong model (light specular is assumed to be white for now)
+			specCol = u_vMixSpecular * pow( RdotE, u_vMatShininess);
+			#if SHADOWS
+			specCol *= shd;
+			#endif
+			#if BUMP
+			specCol *= origNormalFactor;
+			#endif
+		}
+		else
+		{
+			specCol = vec3(0,0,0);
+		}
+	}
+	else
+	{
+		specCol = vec3(0,0,0);
+	}
+	#else
+	specCol = vec3(0,0,0);
+	#endif
+		
+	texCol = u_vMixAmbient + Idiff;
+}
+
+#if BUMP
+mediump vec3 getBumpNormal(mediump vec2 texCoords)
+{
+	return texture2D(u_texBump, texCoords).xyz * 2.0 - 1.0;
+}
+#endif
+
+#if HEIGHT
+const mediump float heightScale = 0.015; //const for now
+#endif
+
+void main(void)
+{
+#if MAT_DIFFUSETEX
+	lowp vec4 texVal = texture2D(u_texDiffuse,v_texcoord);
+	#if ALPHATEST
+	//check if alpha lies below threshold
+	if(texVal.a < u_fAlphaThresh)
+		discard;
+	#endif
+#endif
+
+	mediump vec2 texCoords = v_texcoord;
+	mediump vec3 eye = normalize(-v_viewPos);
+	
+	#if HEIGHT
+	//pertube texture coords with heightmap
+	mediump float height = texture2D(u_texHeight, texCoords).r;
+	//*scale +bias
+	height = height * heightScale - 0.5*heightScale;
+		
+	texCoords = texCoords + (height * eye.xz);
+	#endif
+	
+	#if BUMP
+	mediump vec3 normal = getBumpNormal(texCoords);
+	#else
+	mediump vec3 normal = v_normal;
+	#endif
+
+	mediump vec3 texCol,specCol; //texCol gets multiplied with diffuse map, specCol not
+	calcLighting(normalize(normal),eye,texCol,specCol);
+	
+	#if MAT_EMISSIVETEX
+	//use existing specCol to avoid using another vec3
+	specCol += u_vMixEmissive * texture2D(u_texEmissive,v_texcoord).rgb;
+	#else
+	specCol += u_vMixEmissive;
+	#endif
+	
+#if MAT_DIFFUSETEX
+	#if BLENDING
+	gl_FragColor = vec4(texCol * texVal.rgb + specCol,u_vMatAlpha * texVal.a);
+    #else
+	//gl_FragColor = vec4(texCol * texVal.rgb + specCol, 1.0);
+	gl_FragColor = vec4(texCol * texVal.rgb + specCol, 1.0);
+	#endif
+#else
+	gl_FragColor = vec4(texCol + specCol,u_vMatAlpha); //u_vMatAlpha is automatically set to 1.0 if blending is disabled
+#endif
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_texture.frag'
--- data/shaders/s3d_texture.frag	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_texture.frag	2015-04-01 10:27:06 +0000
@@ -0,0 +1,33 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader that applies a texture to pre-transformed geometry
+*/
+ 
+uniform sampler2D u_texDiffuse;
+
+varying mediump vec2 v_texcoord;
+
+void main(void)
+{
+	gl_FragColor = texture2D(u_texDiffuse, v_texcoord);
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_texture.vert'
--- data/shaders/s3d_texture.vert	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_texture.vert	2015-04-01 10:27:06 +0000
@@ -0,0 +1,38 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader that applies a texture to pre-transformed geometry
+*/
+ 
+//matrices
+uniform mat4 u_mProjection;
+
+attribute vec3 a_vertex;
+attribute mediump vec2 a_texcoord;
+
+varying mediump vec2 v_texcoord;
+
+void main(void)
+{
+	v_texcoord = a_texcoord;
+	gl_Position = u_mProjection * vec4(a_vertex,1.0);
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_transform.frag'
--- data/shaders/s3d_transform.frag	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_transform.frag	2015-04-01 10:27:06 +0000
@@ -0,0 +1,41 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This fragment shader is only used if the material is alpha-tested to allow for better shadows.
+*/
+
+#define ALPHATEST 1
+ 
+#if ALPHATEST
+uniform lowp float u_fAlphaThresh;
+uniform sampler2D u_texDiffuse;
+#endif
+
+varying mediump vec2 v_texcoord;
+
+void main(void)
+{
+#if ALPHATEST
+	if(texture2D(u_texDiffuse,v_texcoord).a < u_fAlphaThresh)
+		discard;
+#endif
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_transform.vert'
--- data/shaders/s3d_transform.vert	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_transform.vert	2015-04-01 10:27:06 +0000
@@ -0,0 +1,43 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader for MVP transformation only. Used to fill depth maps.
+*/
+ 
+#define ALPHATEST 1
+
+//matrices
+uniform mat4 u_mMVP;
+
+attribute vec4 a_vertex;
+#if ALPHATEST
+attribute vec2 a_texcoord;
+varying mediump vec2 v_texcoord;
+#endif
+
+void main(void)
+{
+#if ALPHATEST
+	v_texcoord = a_texcoord;
+#endif
+	gl_Position = u_mMVP * a_vertex;
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_vertexlit.frag'
--- data/shaders/s3d_vertexlit.frag	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_vertexlit.frag	2015-04-01 10:27:06 +0000
@@ -0,0 +1,86 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is the fragment shader for vertex lighting, which does not need to do many things
+*/
+
+#define BLENDING 1
+#define MAT_DIFFUSETEX 1
+#define MAT_EMISSIVETEX 1
+#define MAT_SPECULAR 1
+#define ALPHATEST 1
+
+#if MAT_DIFFUSETEX
+uniform sampler2D u_texDiffuse;
+#endif
+#if MAT_EMISSIVETEX
+uniform sampler2D u_texEmissive;
+#endif
+
+#if ALPHATEST
+uniform lowp float u_fAlphaThresh;
+#endif
+
+uniform mediump vec3 u_vMixEmissive; //material emissive modulated by light angle
+uniform mediump float u_vMatAlpha;
+
+varying mediump vec2 v_texcoord;
+varying mediump vec3 v_texillumination;
+#if MAT_SPECULAR
+varying mediump vec3 v_specillumination;
+#endif
+
+void main(void)
+{
+#if MAT_DIFFUSETEX
+	lowp vec4 texVal = texture2D(u_texDiffuse,v_texcoord);
+	
+	#if ALPHATEST
+	if(texVal.a < u_fAlphaThresh)
+		discard;
+	#endif
+	
+	lowp vec3 color = v_texillumination * texVal.rgb;
+#else
+	lowp vec3 color = v_texillumination;
+#endif
+	
+	#if MAT_SPECULAR
+	color += v_specillumination;
+	#endif
+	
+	#if MAT_EMISSIVETEX
+	color += u_vMixEmissive * texture2D(u_texEmissive,v_texcoord).rgb;
+	#else
+	color += u_vMixEmissive;
+	#endif
+
+#if MAT_DIFFUSETEX
+	#if BLENDING
+	gl_FragColor = vec4(color, texVal.a * u_vMatAlpha);
+	#else
+	gl_FragColor = vec4(color, 1.0);
+	#endif
+#else	
+	gl_FragColor = vec4(color,u_vMatAlpha); //u_vMatAlpha is automatically set to 1.0 if blending is disabled
+#endif
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_vertexlit.geom'
--- data/shaders/s3d_vertexlit.geom	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_vertexlit.geom	2015-04-01 10:27:06 +0000
@@ -0,0 +1,69 @@
+#version 150
+
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a geometry-shader (using 3.2 core functionality, #version 150) based acceleration of cubemap rendering.
+For vertex-based lighting, this is pretty simple: the lighting is performed in the
+ Vertex shader in a common view space
+*/
+
+#define MAT_SPECULAR 1
+
+layout(triangles) in;
+layout(triangle_strip,max_vertices = 18) out;
+
+in vec2 v_texcoordGS[];
+in vec3 v_texilluminationGS[];
+#if MAT_SPECULAR
+in vec3 v_specilluminationGS[];
+#endif
+
+out vec2 v_texcoord;
+out vec3 v_texillumination;
+#if MAT_SPECULAR
+out vec3 v_specillumination;
+#endif
+
+uniform mat4 u_mCubeMVP[6];
+
+void main(void)
+{
+	//iterate over cubemap faces
+	for(gl_Layer=0; gl_Layer<6;++gl_Layer)
+	{
+		//iterate over triangle vertices
+		for(int vtx = 0;vtx<3;++vtx)
+		{
+			//calc new position in current cubemap face
+			gl_Position = u_mCubeMVP[gl_Layer] * gl_in[vtx].gl_Position;
+			//pass on other varyings
+			v_texcoord = v_texcoordGS[vtx];
+			v_texillumination = v_texilluminationGS[vtx];
+			#if MAT_SPECULAR
+			v_specillumination = v_specilluminationGS[vtx];
+			#endif
+			EmitVertex();
+		}
+		EndPrimitive();
+	}
+}
\ No newline at end of file

=== added file 'data/shaders/s3d_vertexlit.vert'
--- data/shaders/s3d_vertexlit.vert	1970-01-01 00:00:00 +0000
+++ data/shaders/s3d_vertexlit.vert	2015-04-01 10:27:06 +0000
@@ -0,0 +1,135 @@
+/*
+ * Stellarium Scenery3d Plug-in
+ *
+ * Copyright (C) 2014 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza, Florian Schaukowitsch
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+ 
+ 
+/*
+This is a shader for basic vertex lighting. This should be the minimum quality supported.
+*/
+
+#define MAT_SPECULAR 1
+#define GEOMETRY_SHADER 1
+#define TORCH 1
+
+//matrices
+#if ! GEOMETRY_SHADER
+uniform mat4 u_mMVP;
+#endif
+uniform mat4 u_mModelView;
+uniform mat3 u_mNormal;
+
+//light info
+uniform mediump vec3 u_vLightDirectionView; //in view space
+
+//material info
+uniform mediump vec3 u_vMixAmbient; // = light ambient * mtl ambient/diffuse depending on Illum model
+uniform mediump vec3 u_vMixDiffuse; // light diffuse * mat diffuse
+#if MAT_SPECULAR
+uniform mediump vec3 u_vMixSpecular;
+uniform mediump float u_vMatShininess;
+#endif
+
+#if TORCH
+uniform mediump vec3 u_vMixTorchDiffuse;
+uniform mediump float u_fTorchAttenuation;
+#endif
+
+attribute vec4 a_vertex;
+attribute vec3 a_normal;
+attribute mediump vec2 a_texcoord;
+
+#if GEOMETRY_SHADER
+#define VAR_TEXCOORD v_texcoordGS
+#define VAR_TEXILLUMINATION v_texilluminationGS
+#define VAR_SPECILLUMINATION v_specilluminationGS
+#else
+#define VAR_TEXCOORD v_texcoord
+#define VAR_TEXILLUMINATION v_texillumination
+#define VAR_SPECILLUMINATION v_specillumination
+#endif
+
+varying mediump vec2 VAR_TEXCOORD;
+varying mediump vec3 VAR_TEXILLUMINATION;
+#if MAT_SPECULAR
+varying mediump vec3 VAR_SPECILLUMINATION;
+#endif
+
+void calcLighting(vec3 normal, vec3 viewPos, out vec3 texIll, out vec3 specIll)
+{
+	//basic lambert term
+	float NdotL = dot(normal, u_vLightDirectionView);
+	vec3 Idiff = u_vMixDiffuse * max(0.0,NdotL);
+	
+#if MAT_SPECULAR || TORCH
+	vec3 eye = normalize(-viewPos);
+#endif
+
+#if TORCH
+	//calculate additional diffuse, modeled by a point light centered on the cam pos
+	float camDistSq = dot(viewPos,viewPos);
+	float att = max(0.0, 1.0 - camDistSq * u_fTorchAttenuation);
+	att *= att;
+	
+	Idiff += att * u_vMixTorchDiffuse * max(0.0, dot(normal,eye));
+#endif
+	
+	specIll = vec3(0,0,0);
+	
+#if MAT_SPECULAR
+	if(NdotL>0.0)
+	{
+		//calculate phong reflection vector
+		vec3 R = reflect(-u_vLightDirectionView,normal);
+		
+		float RdotE = dot(normalize(R), eye);
+		
+		if(RdotE>0.0)
+		{
+			//specular term according to Phong model (light specular is assumed to be white for now)
+			specIll = u_vMixSpecular * pow( RdotE, u_vMatShininess);
+		}
+	}
+#endif
+	
+	texIll = u_vMixAmbient + Idiff;
+}
+
+void main(void)
+{
+	//transform normal
+	vec3 normal = u_mNormal * a_normal;
+	
+	vec4 viewPos = u_mModelView * a_vertex;
+
+	vec3 texIll,specIll;
+	calcLighting(normal,viewPos.xyz,texIll,specIll);
+	
+	VAR_TEXILLUMINATION = texIll;
+	#if MAT_SPECULAR
+	VAR_SPECILLUMINATION = specIll;
+	#endif
+	
+	VAR_TEXCOORD = a_texcoord;
+	
+	#if GEOMETRY_SHADER
+	gl_Position = a_vertex; //pass on unchanged
+	#else
+	gl_Position = u_mMVP * a_vertex;
+	#endif
+}
\ No newline at end of file

=== added directory 'plugins/Scenery3d'
=== added file 'plugins/Scenery3d/CMakeLists.txt'
--- plugins/Scenery3d/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/CMakeLists.txt	2015-04-01 10:27:06 +0000
@@ -0,0 +1,13 @@
+SET(SCENERY3D_VERSION "0.13.0")
+
+ADD_DEFINITIONS(-DSCENERY3D_PLUGIN_VERSION="${SCENERY3D_VERSION}")
+
+ADD_SUBDIRECTORY( src )
+
+IF(APPLE)
+    SET(CMAKE_INSTALL_PREFIX $ENV{HOME}/Library/Application\ Support/Stellarium)
+ElSE(APPLE)
+	SET(CMAKE_INSTALL_PREFIX $ENV{HOME}/.stellarium)
+ENDIF(APPLE)
+
+INSTALL(FILES DESTINATION "modules/Scenery3d")

=== added file 'plugins/Scenery3d/COPYING'
--- plugins/Scenery3d/COPYING	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/COPYING	2015-04-01 10:27:06 +0000
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+

+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+

+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+

+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+

+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+

+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

=== added file 'plugins/Scenery3d/Doxyfile'
--- plugins/Scenery3d/Doxyfile	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/Doxyfile	2015-04-01 10:27:06 +0000
@@ -0,0 +1,1484 @@
+# Doxyfile 1.5.8
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file 
+# that follow. The default is UTF-8 which is also the encoding used for all 
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the 
+# iconv built into libc) for the transcoding. See 
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = "Scenery3d Plug-in"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = 
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = ./doc
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
+# 4096 sub-directories (in 2 levels) under the output directory of each output 
+# format and will distribute the generated files over these directories. 
+# Enabling this option can be useful when feeding doxygen a huge amount of 
+# source files, where putting all generated files in the same directory would 
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, 
+# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek, 
+# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages), 
+# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish, 
+# Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, Slovene, 
+# Spanish, Swedish, and Ukrainian.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator 
+# that is used to form the text in various listings. Each string 
+# in this list, if found as the leading text of the brief description, will be 
+# stripped from the text and the result after processing the whole list, is 
+# used as the annotated text. Otherwise, the brief description is used as-is. 
+# If left blank, the following values are used ("$name" is automatically 
+# replaced with the name of the entity): "The $name class" "The $name widget" 
+# "The $name file" "is" "provides" "specifies" "contains" 
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = 
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = YES
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all 
+# inherited members of a class in the documentation of that class as if those 
+# members were ordinary class members. Constructors, destructors and assignment 
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
+# the path mentioned in the documentation of a class, which tells 
+# the reader which header file to include in order to use a class. 
+# If left blank only the name of the header file containing the class 
+# definition is used. Otherwise one should specify the include paths that 
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful is your file systems 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like regular Qt-style comments 
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will 
+# interpret the first line (until the first dot) of a Qt-style 
+# comment as the brief description. If set to NO, the comments 
+# will behave just like regular Qt-style comments (thus requiring 
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF           = YES
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce 
+# a new page for each member. If set to NO, the documentation of a member will 
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 8
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Doxygen selects the parser to use depending on the extension of the files it parses. 
+# With this tag you can assign which parser to use for a given extension. 
+# Doxygen has a built-in mapping, but you can override or extend it using this tag. 
+# The format is ext=language, where ext is a file extension, and language is one of 
+# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, 
+# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat 
+# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), 
+# use: inc=Fortran f=C
+
+EXTENSION_MAPPING      = 
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want 
+# to include (a tag file for) the STL sources as input, then you should 
+# set this tag to YES in order to let doxygen match functions declarations and 
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. 
+# func(std::string) {}). This also make the inheritance and collaboration 
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to 
+# enable parsing support.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. 
+# Doxygen will parse them like normal C++ but will assume all classes use public 
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter 
+# and setter methods for a property. Setting this option to YES (the default) 
+# will make doxygen to replace the get and set methods by a property in the 
+# documentation. This will only work if the methods are indeed getting or 
+# setting a simple type. If this is not the case, or you want to show the 
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum 
+# is documented as struct, union, or enum with the name of the typedef. So 
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct 
+# with name TypeT. When disabled the typedef will appear as a member of a file, 
+# namespace, or class. And the struct will be named TypeS. This can typically 
+# be useful for C code in case the coding convention dictates that all compound 
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to 
+# determine which symbols to keep in memory and which to flush to disk. 
+# When the cache is full, less often used symbols will be written to disk. 
+# For small to medium size projects (<1000 input files) the default value is 
+# probably good enough. For larger projects a too small cache size can cause 
+# doxygen to be busy swapping symbols to and from disk most of the time 
+# causing a significant performance penality. 
+# If the system has enough physical memory increasing the cache will improve the 
+# performance by keeping more symbols in memory. Note that the value works on 
+# a logarithmic scale so increasing the size by one will rougly double the 
+# memory usage. The cache size is given by this formula: 
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, 
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = YES
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local 
+# methods, which are defined in the implementation section but not in 
+# the interface are included in the documentation. 
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be 
+# extracted and appear in the documentation as a namespace called 
+# 'anonymous_namespace{file}', where file will be replaced with the base 
+# name of the file that contains the anonymous namespace. By default 
+# anonymous namespace are hidden.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
+# brief documentation of file, namespace and class members alphabetically 
+# by member name. If set to NO (the default) the members will appear in 
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the 
+# hierarchy of group names into alphabetical order. If set to NO (the default) 
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
+# sorted by fully-qualified names, including namespaces. If set to 
+# NO (the default), the class list will be sorted only by class name, 
+# not including the namespace part. 
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. 
+# Note: This option applies only to the class list, not to the 
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or define consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and defines in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+# If the sources in your project are distributed over multiple directories 
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy 
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES       = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. 
+# This will remove the Files entry from the Quick Index and from the 
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the 
+# Namespaces page. 
+# This will remove the Namespaces entry from the Quick Index 
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that 
+# doxygen should invoke to get the current version for each file (typically from 
+# the version control system). Doxygen will invoke the program by executing (via 
+# popen()) the command <command> <input-file>, where <command> is the value of 
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file 
+# provided by doxygen. Whatever the program writes to standard output 
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    = 
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by 
+# doxygen. The layout file controls the global structure of the generated output files 
+# in an output format independent way. The create the layout file that represents 
+# doxygen's defaults, run doxygen with the -l option. You can optionally specify a 
+# file name after the option, if omitted DoxygenLayout.xml will be used as the name 
+# of the layout file.
+
+LAYOUT_FILE            = 
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be abled to get warnings for 
+# functions that are documented, but have no documentation for their parameters 
+# or return value. If set to NO (the default) doxygen will only warn about 
+# wrong or incomplete parameter documentation, but not about the absence of 
+# documentation.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. Optionally the format may contain 
+# $version, which will be replaced by the version of the file (if it could 
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces.
+
+INPUT                  = ./src ./src/gui
+
+# This tag can be used to specify the character encoding of the source files 
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
+# also the default input encoding. Doxygen uses libiconv (or the iconv built 
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for 
+# the list of possible encodings.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank the following patterns are tested: 
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
+
+FILE_PATTERNS          = 
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = 
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
+# directories that are symbolic links (a Unix filesystem feature) are excluded 
+# from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. Note that the wildcards are matched 
+# against the file with absolute path, so to exclude all test directories 
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = 
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names 
+# (namespaces, classes, functions, etc.) that should be excluded from the 
+# output. The symbol name can be a fully qualified name, a word, or if the 
+# wildcard * is used, a substring. Examples: ANamespace, AClass, 
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS        = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = 
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output. 
+# If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
+# basis. 
+# Doxygen will compare the file name with each pattern and apply the 
+# filter if there is a match. 
+# The filters are a list of the form: 
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER 
+# is applied to all files.
+
+FILTER_PATTERNS        = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) 
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from 
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will 
+# link to the source code. 
+# Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code 
+# will point to the HTML generated by the htags(1) tool instead of doxygen 
+# built-in source browser. The htags tool is part of GNU's global source 
+# tagging system (see http://www.gnu.org/software/global/global.html). You 
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = ../../stellarium/doc/doxygen.css
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML 
+# documentation will contain sections that can be hidden and shown after the 
+# page has loaded. For this to work a browser that supports 
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox 
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files 
+# will be generated that can be used as input for Apple's Xcode 3 
+# integrated development environment, introduced with OSX 10.5 (Leopard). 
+# To create a documentation set, doxygen will generate a Makefile in the 
+# HTML output directory. Running make will produce the docset in that 
+# directory and running "make install" will install the docset in 
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find 
+# it at startup. 
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information.
+
+GENERATE_DOCSET        = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the 
+# feed. A documentation feed provides an umbrella under which multiple 
+# documentation sets from a single provider (such as a company or product suite) 
+# can be grouped.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that 
+# should uniquely identify the documentation set bundle. This should be a 
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen 
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING 
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file 
+# content.
+
+CHM_INDEX_ENCODING     = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER 
+# are set, an additional index file will be generated that can be used as input for 
+# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated 
+# HTML documentation.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can 
+# be used to specify the file name of the resulting .qch file. 
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE               = 
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating 
+# Qt Help Project output. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE          = 
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating 
+# Qt Help Project output. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. 
+# For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME   = 
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see 
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS  = 
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's 
+# filter section matches. 
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS  = 
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can 
+# be used to specify the location of Qt's qhelpgenerator. 
+# If non-empty doxygen will try to run qhelpgenerator on the generated 
+# .qhp file.
+
+QHG_LOCATION           = 
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [1..20]) 
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index 
+# structure should be generated to display hierarchical information. 
+# If the tag value is set to FRAME, a side panel will be generated 
+# containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, 
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are 
+# probably better off using the HTML help feature. Other possible values 
+# for this tag are: HIERARCHIES, which will generate the Groups, Directories, 
+# and Class Hierarchy pages using a tree view instead of an ordered list; 
+# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which 
+# disables this behavior completely. For backwards compatibility with previous 
+# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE 
+# respectively.
+
+GENERATE_TREEVIEW      = NONE
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+# Use this tag to change the font size of Latex formulas included 
+# as images in the HTML documentation. The default is 10. Note that 
+# when you change the font size after a successful doxygen run you need 
+# to manually remove any form_*.png images from the HTML output directory 
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE       = 10
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
+# dump the program listings (including syntax highlighting 
+# and cross-referencing information) to the XML output. Note that 
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader. 
+# This is useful 
+# if you want to understand what is going on. 
+# On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. To prevent a macro definition from being 
+# undefined via #undef or recursively expanded use the := operator 
+# instead of the = operator.
+
+PREDEFINED             = 
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED      = 
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
+# doxygen's preprocessor will remove all function-like macros that are alone 
+# on a line, have an all uppercase name, and do not end with a semicolon. Such 
+# function macros are typically used for boiler-plate code, and will confuse 
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#  
+# TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#  
+# TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links. 
+# Note that each tag file must have a unique name 
+# (where the name does NOT include the path) 
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
+# or super classes. Setting the tag to NO turns the diagrams off. Note that 
+# this option is superseded by the HAVE_DOT option below. This is only a 
+# fallback. It is recommended to install and use dot, since it yields more 
+# powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc 
+# command. Doxygen will then run the mscgen tool (see 
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the 
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where 
+# the mscgen tool resides. If left empty the tool is assumed to be found in the 
+# default search path.
+
+MSCGEN_PATH            = 
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = NO
+
+# By default doxygen will write a font called FreeSans.ttf to the output 
+# directory and reference it in all dot files that doxygen generates. This 
+# font does not include all possible unicode characters however, so when you need 
+# these (or just want a differently looking font) you can specify the font name 
+# using DOT_FONTNAME. You need need to make sure dot is able to find the font, 
+# which can be done by putting it in a standard location or by setting the 
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory 
+# containing the font.
+
+DOT_FONTNAME           = FreeSans
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. 
+# The default size is 10pt.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the output directory to look for the 
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a 
+# different font using DOT_FONTNAME you can set the path where dot 
+# can find it using this tag.
+
+DOT_FONTPATH           = 
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then 
+# doxygen will generate a call dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable call graphs 
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then 
+# doxygen will generate a caller dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable caller 
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES 
+# then doxygen will show the dependencies a directory has on other directories 
+# in a graphical way. The dependency relations are determined by the #include 
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, jpg, or gif 
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               = 
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of 
+# nodes that will be shown in the graph. If the number of nodes in a graph 
+# becomes larger than this value, doxygen will truncate the graph, which is 
+# visualized by representing a node as a red box. Note that doxygen if the 
+# number of direct children of the root node in a graph is already larger than 
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note 
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the 
+# graphs generated by dot. A depth value of 3 means that only nodes reachable 
+# from the root by following a path via at most 3 edges will be shown. Nodes 
+# that lay further from the root node will be omitted. Note that setting this 
+# option to 1 or 2 may greatly reduce the computation time needed for large 
+# code bases. Also note that the size of a graph can be further restricted by 
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent 
+# background. This is disabled by default, because dot on Windows does not 
+# seem to support this out of the box. Warning: Depending on the platform used, 
+# enabling this option may lead to badly anti-aliased labels on the edges of 
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output 
+# files in one run (i.e. multiple -o and -T options on the command line). This 
+# makes dot run faster, but since only newer versions of dot (>1.8.10) 
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
+
+#---------------------------------------------------------------------------
+# Options related to the search engine
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be 
+# used. If set to NO the values of all tags below this one will be ignored.
+
+SEARCHENGINE           = NO

=== added file 'plugins/Scenery3d/README'
--- plugins/Scenery3d/README	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/README	2015-04-01 10:27:06 +0000
@@ -0,0 +1,34 @@
+Scenery3d plugin for Stellarium
+================================
+
+Trying to render a 3D scene inside Stellarium.
+
+
+BUILDING THE PLUGIN
+===================
+
+Please note, these instructions are only directly applicable to Linux.
+Windows and OSX targets have not been tested yet.
+
+0.  Install and build the SVN version of Stellarium as per the 
+instructions on the Stellarium wiki:
+
+  http://stellarium.org/wiki/index.php/Compilation_on_Linux
+
+1.  Set the environment variable STELROOT to the root of the Stellarium
+source tree.  The Stellarium build directory is expected to be:
+
+  $STELROOT/builds/unix 
+
+2.  Create a sub-directory builds/unix and change into that directory.
+
+3.  Run:
+
+  cmake ../.. 
+  make
+  make install
+
+If all goes well, the relevant files should be built and copied to your 
+~/.stellarium/modules directory.
+
+

=== added directory 'plugins/Scenery3d/doc'
=== added file 'plugins/Scenery3d/doc/Scenery3d.pdf'
Binary files plugins/Scenery3d/doc/Scenery3d.pdf	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/doc/Scenery3d.pdf	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/doc/Scenery3d.tex'
--- plugins/Scenery3d/doc/Scenery3d.tex	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/doc/Scenery3d.tex	2015-04-01 10:27:06 +0000
@@ -0,0 +1,614 @@
+\documentclass[a4paper]{article}
+\usepackage[latin1]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{a4wide}
+\usepackage{hyperref}
+\newcommand{\filename}[1]{\texttt{#1}}
+\newcommand{\cmd}[1]{\texttt{#1}}
+
+\title{Scenery3d - Walkable 3D Models in Stellarium} \author{Georg
+Zotti\thanks{\url{[e-mail]},
+\url{http://astrosim.univie.ac.at}}}
+\begin{document}
+\maketitle
+
+\section{Introduction}
+\label{sec:Introduction}
+
+
+Have you ever wished to be able to walk through Stonehenge or other
+ancient building structures described as being constructed with astronomical
+orientation in mind, and experience such orientation in 3D?
+
+The Stellarium Scenery3d plugin allows you to see architectural 3D models
+embedded in a landscape combined with the excellent representation of a sky
+simulation provided by Stellarium. You can walk around, check for (or
+demonstrate) possible astronomical alignments of ancient architecture, see
+sundials and other shadow casters in action, etc.
+
+\section{Usage}
+\label{sec:Usage}
+
+
+You activate the plugin with the \emph{circular enclosure} button at screen
+bottom or by pressing [Ctrl+3]. The other button with circular enclosure and
+tool icon (or [Ctrl+Shift+3]) opens the settings dialog. Once loaded and
+displaying, you can walk around pressing [Ctrl] plus cursor keys. Change eye
+height with [Ctrl]+[PgUp]/[PgDn] keys. Adding [Shift] key increases speed by 10,
+[Alt] by 5 (pressing both keys multiplies by 50!). If you release [Ctrl] before
+the cursor key, animation will continue. (Press [Ctrl]+any cursor key to stop
+moving.)\footnote{Bug or feature? I (GZ) had to change keyboard handling in the
+main program, somewhat breaking the plugin concept. TBD: Discuss with the core
+team.}
+
+Further key bindings exist which can be configured using the Stellarium default
+key-binding interface. Some options are also available in the Scenery3d dialog.
+For example, coordinate display can be enabled. If you have georeferenced models
+in a true geographical coordinate grid, e.g. UTM or Gauss-Krueger, you will
+especially like this, and this makes the plugin usable for scientific purposes.
+Display shows grid name, Easting, Northing, Altitude of ground, and eye height
+above ground.
+
+Other features include a virtual ``torchlight'', which can be enabled to give
+additional local illumination around the viewer to help to see in the dark.
+Interesting points of view can be saved and restored later by the user,
+including a description of the view. Scene authors can also distribute
+predefined viewpoints in their scene.
+
+The plugin also simulates the shadows of the scene's objects cast by the Sun,
+Moon and even Venus (only the 1 shadow caster shown at a time), so you could use
+it for examining sundials, or archeological structures.
+
+\section{Hardware Requirements \& Performance}
+\label{sec:HardwareRequirements}
+
+In order to work with the non-linear projection models in Stellarium, this
+plugin uses a trick to create the foreground renderings: it renders the scene
+into the six planes of a so-called cubemap, which is then drawn onto a cube
+which has been projected correctly. Your graphics card must be able to do this,
+i.e. it must support the OpenGL extension called
+\texttt{EXT\_framebuffer\_object}. Typical modern 3D cards (by NVidia or
+ATI/AMD) support this extension. In case your graphics hardware does not
+suppport it, the plugin will still work, but you are limited to perspective
+projection.
+
+You can influence rendering quality, but also speed, using the plugin's 
+GUI, which provides some options such as enabling the use
+of shadows, bumpmapping (provides more realistic surface lighting) or 
+configuring the sizes of the textures used
+for the cubemap or shadowmaps. Larger values there improve the quality,
+but require faster hardware and more video memory for smooth results.
+
+Because the ``cubemap trick'' requires quite a large amount of performance (in
+essence, the scene has to be rendered 6 times), there are some options available
+that try to reduce this burden. The first option is to change the type of the
+``cubemap''. The most compatible setting is \emph{6 textures}, which seems to
+work best on older integrated Intel GPUs. The recommended default is the second
+setting, \emph{Cubemap}, which uses a more modern OpenGL feature and generally
+works a bit faster than \emph{6 textures} on more modern graphics card. Finally,
+the \emph{Geometry shader} option tries to render all 6 cube faces at once. This
+requires a more recent GPU + drivers (at least OpenGL 3.2 must be supported),
+the setting is disabled otherwise. Depending on your hardware and the scene's
+complexity, this method may give a speedup, BUT may also give a slowdown.
+
+Another option prevents re-rendering of the cubemap if nothing relevant has
+changed. You can define the interval (in Stellarium's simulation time) in which
+nothing is updated in the GUI. You can still rotate the camera without causing a
+re-draw, giving a subjective performance that is close to Stellarium's
+performance without Scenery3d. When moving, the cubemap will be updated. You can
+enable another option that only causes 1 or 2 sides of the cubemap to be updated
+while you move, giving a speedup but causing some parts of the image to be
+outdated and discontinuous. The whole cubemap will be recreated when you stop
+moving automatically.
+
+Shadow rendering may also cause quite a performance impact. The \emph{Simple
+shadows} option can speed this up a lot, at the cost of shadow quality
+especially in larger scenes. Another performance/quality factor is shadow
+filtering. The sharpest (and fastest) possible shadows are achieved with
+filtering \emph{Off}, but depending on shadowmap resolution and scene size the
+shadows may look quite ``blocky''. \emph{Hardware} shadow filtering is usually
+very fast, but may not improve appearance a lot. Therefore, there are additional
+filter options available, the \emph{High} filter option is relatively expensive.
+Finally, the \emph{PCSS} option allows to approximate the increase of shadow
+penumbras relative to the distance from their shadow casters, i.e. shadows are
+sharp near contact points, and more blurred further away. This again requires
+quite a bit of performance, and only works if the shadow filter option is set to
+\emph{Low} or \emph{High} (without \emph{Hardware}).
+
+The configuration GUI shows tooltips for most of its settings, which can explain
+what a setting does. All settings are saved automatically, and restored when you
+reopen Stellarium.
+
+\section{Model Configuration}
+\label{sec:ModelConfiguration}
+
+\begin{table}[h]
+  \centering
+\begin{tabular}{rl}
+Geometry&Yes\\Lights&Yes\\Clay&No\\Photomatched&Yes\\DefaultUVs&No\\Instanced&No
+\end{tabular}
+\caption{Kerkythea Export Settings}
+  \label{fig:KerkytheaExportSettings}
+\end{table}
+
+The model format supported in Scenery3d is Wavefront .OBJ, which is
+pretty common for 3D models.  You can use several modeling programs to
+build your models. Software such as Blender, Maya, 3D Studio
+Max etc.\ can export OBJ. 
+
+A simple and cost-free modeling program is Google Sketchup, commonly
+used to create the 3D buildings seen in Google Earth. It can be used
+to create georeferenced models.  OBJ is not a native export format for
+the standard version of Google Sketchup. If you are not willing to
+afford Sketchup Pro, you have to find another way to export a textured
+OBJ model.
+
+One good exporter is available in the Kerkythea renderer project
+available at \url{http://www.kerkythea.net/joomla/}.  You need
+\filename{SU2KT~3.17}
+or better, and \filename{KT2OBJ~1.1.0} or better.  Deselect any selection, then
+export your model to the Kerkythea XML format with settings shown in
+~\autoref{fig:KerkytheaExportSettings}.
+
+
+%(Or, with selection enabled, make sure settings are No-Yes-Yes-No-Yes-No-No).  
+You do not have to launch Kerkythea unless you want to create nice renderings of
+your model. 
+Then, use the \filename{KT2OBJ} converter to create an OBJ.  You can delete the
+XML after the conversion.  Note that some texture coordinates may not be
+exported correctly. The setting Photomatched:Yes seems now to have
+corrected this issue, esp. with distorted/manu\-ally shifted textures.
+
+Recently, another free OBJ exporter has been made available by 
+TIG: \filename{OBJexporter.rb}\footnote{Available from
+\url{http://forums.sketchucation.com/viewtopic.php?f=323&t=33448}}. 
+This is the only OBJ exporter capable of handling large TIN landscapes
+($>450.000$ triangles). 
+As of version 2.6 it seems to be the best OBJ exporter available for Sketchup. 
+
+%As of version 1.6 it appears to have valid texture coordinates, but I have
+%experienced problems with black faces which need more
+%investigation. Maybe you can combine two OBJ files with another 3D
+%editor after creating individual OBJs if this is a problem. 
+
+This exporter swaps Y/Z coordinates, but you can add a key to the config file to
+correct swapped axes, see below. Other exporters may also provide coordinates in
+any order of X, Y, Z -- all those can be properly configured.
+
+Another (almost) working alternative: \filename{ObjExporter.rb} by author
+Honing.  Here, export with settings 0xxx00. This will not create a
+\filename{TX...} folder but dump all textures in the same directory as the OBJ
+and MTL files. Unfortunately, this time some material assignments seem to be
+bad.
+
+Yet another exporter, \filename{su2objmtl}, does also not provide good texture
+coordinates and cannot be recommended at this time.
+
+\subsection{Notes on OBJ file format limitations}
+\label{sec:OBJlimitations}
+
+The OBJ format supported is only a subset of the full OBJ format: Only
+(optionally textured) triangle meshes are supported, i.e., only lines containing
+statements: \cmd{mtllib}, \cmd{usemtl}, \cmd{v}, \cmd{vn}, \cmd{vt}, \cmd{f}
+(with three elements only!), \cmd{g}. Negative vertex numbers (i.e., a
+specification of relative positions) are not supported.
+
+A further recommendation for correct illumination is that all vertices should
+have vertex normals. Sketchup models exported with the Kerkythea or TIG plugins
+should have correct normals. If your model does not provide them, default
+normals will be reconstructed from the triangle edges, resulting in a faceted
+look.
+
+If possible, the model should also be triangulated, but the current loader may
+also work with non-triangle geometry. The correct use of objects ('o') and
+groups ('g') will improve performance: it is best if you pre-combine all objects
+that use the same material into a single one. The loader will try to optimize it
+anyways if this is not the case, but can do this only partly (to combine 2
+objects with the same material into 1, it requires them to follow directly after
+each other in the OBJ). A simple guide to use Blender for this task follows:
+
+\begin{itemize}
+\item Import from Wavefront (.obj) - you may need to change the forward/up axes for correct orientation, try -Y for forward and Z for up
+\item Select an object which has a shared material
+\item Press Shift+L and select 'By Material'
+\item Select 'Join' in the left (main) tool window
+\item Repeat for other objects that have shared materials
+\item Export the .obj, making sure to select the same forward/up axes as in the import, also make sure ``Write Normals'', ``Write Materials'' and ``Include UVs'' are checked
+\end{itemize}
+
+For transparent objects (with a 'd' or 'Tr' value, alpha testing does NOT need this), this recommendation does NOT hold: for optimal results, each separate transparent object should be exported as a separate ``OBJ object''. This is because they need to be sorted during rendering to achieve correct transparency. If the objects are combined already, you can separate them using Blender:
+
+\begin{itemize}
+\item Import .obj (see above)
+\item Select the combined transparent object
+\item Enter ``Edit'' mode with TAB and make sure everything is selected (press A if not)
+\item Press P and select ``By loose parts'', this should separate the object into it's unconnected regions
+\item Export .obj (see above), also check ``Objects as OBJ Objects''
+\end{itemize}
+
+\begin{table}[b]
+\begin{tabular}{llll}
+Parameter&Default      &Range     & Meaning\\
+\cmd{Ka}       &set to \cmd{Kd} values & $0\dots1$ each& R/G/B Ambient color\\
+\cmd{Kd}      &0.8 0.8 0.8  & $0\dots1$ each& R/G/B Diffuse color\\
+\cmd{Ke}      &0.0 0.0 0.0  & $0\dots1$ each& R/G/B Emissive color\\
+\cmd{Ks}      &0.0 0.0 0.0  & $0\dots1$ each& R/G/B Specular color\\
+\cmd{Ns}       &8.0          & $0\dots\infty$  & shinyness \\
+\cmd{d} or \cmd{Tr}  &1.0          & $0\dots1$     & opacity \\
+\cmd{bAlphatest}&0           & 0 or 1   & perform alpha test \\
+\cmd{bBackface}&0            & 0 or 1   & render backface \\
+\cmd{map\_Kd}  & (none)      & filename & texture map to be mixed with Ka, Kd \\
+\cmd{map\_Ke}  & (none)      & filename & texture map to be mixed with Ke \\
+\cmd{map\_bump}& (none)      & filename & normal map for surface roughness  
+\end{tabular}
+\caption{MTL parameters evaluated}
+\label{tab:MTL}
+\end{table}
+
+The MTL file specified by ``mtllib'' contains the material parameters. The
+minimum that should be specified is either \cmd{map\_Kd} or a \cmd{Kd} line
+specifying color values used for the respective faces. But there are other
+options in MTL files, and the supported parameters and defaults are listed in
+Table~\ref{tab:MTL}.
+
+If no ambient color is specified, the diffuse color values are taken for the
+ambient color. An optional emissive term \cmd{Ke} can be added, which is
+modulated to only be visible during nighttime. This also requires the
+landscape's self-illumination layer to be enabled. It allows to model
+self-illuminating objects such as street lights, windows etc. It can optionally
+also be modulated by the emissive texture \cmd{map\_Ke}.
+
+If a value for \cmd{Ks} is specified, specularity is evaluated using the
+\href{https://en.wikipedia.org/wiki/Phong_reflection_model}{Phong reflection
+model} with \cmd{Ns} as the exponential shininess constant. Larger shininess
+means smaller specular highlights (more metal-like appearance). Specularity is
+not modulated by the texture maps.
+
+If a value for \cmd{d} or \cmd{Tr} exists, alpha blending is enabled for this
+material. This simulates transparency effects. Transparency can be further
+controlled using the alpha channel of the \cmd{map\_Kd} texture.
+
+A simpler and usually more performant way to achieve simple ``cutout''
+transparency effects is alpha-testing, by setting \cmd{bAlphatest} to 1. This
+simply discards all pixels of the model where the alpha value of the
+\cmd{map\_Kd} is below the \cmd{transparency\_threshold} value from
+\filename{scenery3d.ini}, making ``holes'' in the model. This also produces
+better shadows for such objects. If required, alpha testing can be combined with
+``real'' blending-basded transparency.
+
+Sometimes, some exported objects only have a single side, and are only visible
+from one side when looked at in Scenery3d. This is caused by an optimization
+called \href{https://en.wikipedia.org/wiki/Back-face_culling}{back-face
+culling}, which skips drawing the back sides of objects because they are usually
+not visible anyway. If possible, avoid such ``thin'' geometry, this will also
+produce better shadows on the object. As a workaround, you can also set
+\cmd{bBackface} to 1 to disable back-face culling for this material.
+
+The optional \cmd{map\_bump} enables the use of a tangent-space
+\href{https://en.wikipedia.org/wiki/Normal_mapping}{normal maps}, which provides
+a dramatic improvement in surface detail under illumination.
+
+On reasonably good hardware (tested on a notebook PC with NVidia M9800
+GTS), models up to 100.000 triangles are fluent, up to 250.000 are
+still ``interactive''.  If display is too slow, switch to perspective
+projection: all other projections require almost sixfold effort!
+You can also try if the new ``lazy'' cubemap mode works for you, where
+the scene is only rendered in specific timesteps or when movement happens.
+See \autoref{sec:HardwareRequirements} for details.
+
+
+\subsection{Configuring OBJ for Scenery3d}
+\label{sec:Configuring}
+
+The walkaround in your scene can use a ground level (piece of terrain)
+on which the observer can walk. The observer eye will always stay ``eye
+height'' above ground. Currently, there is no collision detection with
+walls implemented, so you can easily walk through walls, or jump on
+high towers, if their platform or roof is exported in the ground
+layer. If your model has no explicit ground layer, walk will be on the
+highest surface of the scenery layer.  If you use the special name
+NULL as ground layer, walk will be above a zero-height level.
+
+Technically, if your model has cavities or doors, you should export
+your model twice. Once, just the ground plane, i.e. where you will
+walk. Of course, for a temple or other building, this includes its
+socket above soil, and any steps.  This plane is required to compute
+eye position above ground. Note that it is not possible to walk in
+several floors of a building, or in a multi-plane staircase. You may
+have to export several ``ground'' planes and configure several scenery
+directories for those rare cases. For optimal performance, the ground 
+model should consist of as few triangles as you can tolerate.
+
+The second export includes all visible model parts, and will be used for
+rendering. Of course, this requires the ground plane again, but also
+all building elements, walls, roofs, etc. 
+
+If you have not done so by yourself, it is recommended to separate
+ground and buildings into Sketchup layers in order to easily switch
+the model to the right state prior to exporting.
+
+Filename recommendations: 
+\begin{verbatim}
+<Temple>.skp        Name of a Sketchup Model file. 
+                    (The "<>" brackets signal "use your own name here!")
+                    The SKP file is not used by Scenery3d.
+<Temple>.obj        Model in OBJ format. 
+<Temple>_ground.obj Ground layer, if different from Model file. 
+\end{verbatim}
+
+OBJ export may also create folders \verb|TX_<Temple>| and
+\verb|TX_<Temple>_ground|. You can delete the \verb|TX_<Temple>_ground| folder, 
+\verb|<Temple>_ground.obj| is just used to compute vertical height.
+
+Stellarium uses a directory to store additional data per-user. On Windows, this
+defaults to \verb|C:\Documents and Settings\<username>\Application Data\Stellarium|, but you can use another directory by using the command-line
+argument \cmd{--user-dir <USERDATA>}. We will refer to this directory. Put the
+OBJ, MTL and TX directories into a directory, \\
+\verb|<USERDATA>/Stellarium/modules/scenery3d/<Temple>|, and add a text file
+called \texttt{scenery3d.ini} (This name is fixed!) with content described as
+follows.
+
+% A Sketchup plugin "Write scenery3d.ini for Stellarium" will write this
+% file. Locate the directory where the .obj file(s) reside(s), and store
+% scenery3d.ini there. If you have other modelers and models, or if your
+% model is not georeferenced in Sketchup, write the file yourself and
+% use the following format.
+%
+% TBD GZ: Write this Sketchup export plugin!
+
+\begin{verbatim}
+
+[model]
+name=<Temple>                Unique ID within all models in scenery3d directory.
+                             Recommendation: use directory name.
+landscape=<landscapename>    Name of an available Stellarium landscape.
+\end{verbatim}
+This is required if the landscape file includes geographical
+coordinates and your model does not: First, the location coordinates
+of the Landscape file are used, then location coordinates given here.
+The landscape also provides the background image of your scenery. - If
+you want a zero-height (mathematical) horizon, use the provided
+landscape called \filename{Zero landscape}.
+\begin{verbatim}
+scenery=<Temple>.obj         The complete model, including visible ground.
+ground=<Temple>_ground.obj   Optional: separate ground plane. (NULL for zero altitude.)
+description=<Description>    A basic scene description (including HTML)
+\end{verbatim}
+The \filename{scenery3d.ini} may contain a simple scene description, but it is
+recommended to use the new \emph{localizable} description format: in the scene's
+directory (where \filename{scenery3d.ini} lies) create files in the format
+\filename{description.<lang\_code>.utf8} which can contain arbitrary
+\cmd{UTF-8}-encoded HTML content. \cmd{lang\_code} stands for the ISO 639
+language code.
+\begin{verbatim}
+author=<Your Name [e-mail]>
+copyright=<Copyright Info>
+
+obj_order=XYZ      | Use this if you have used an exporter which swaps Y/Z coordinates.
+                   | Defaults to XYZ, other options: XZY, YZX, YXZ, ZXY, ZYX
+camNearZ=0.3       This defines the distance of the camera near plane, default 0.3.
+                   Everything closer than this value to the camera can not be 
+                   displayed. Must be larger than zero. It may seem tempting 
+                   to set this very small, but this will lead to accuracy issues. 
+                   Recommendation is not to go under 0.1
+camFarZ=10000      Defines the maximal viewing distance, default 10000.
+shadowDistance=<val>  The maximal distance shadows are displayed. If left out, the
+                      value from camFarZ is used here. If this is set to a smaller
+                      value, this may increase the quality of the shadows that are
+                      still visible.
+shadowSplitWeight=0..1 Decimal value for further shadow tweaking. If you require
+                       better shadows up close, try setting this to higher values.
+                       The default is calculated using a heuristic that incorporates
+                       scene size.
+
+[general]
+\end{verbatim}
+The general section defines some further import/rendering options.
+\begin{verbatim}
+transparency_threshold=0.5   Defines the alpha threshold for alpha-testing, 
+                             as described in section 4.1. Default 0.5
+scenery_generate_normals=0   Boolean, if true normals are recalculated by the
+                             plugin, instead of imported. Default false
+ground_generate_normals=0   Boolean, same as above, for ground model. Default
+false.
+
+[location]
+\end{verbatim}
+Optional section to specify geographic longitude $\lambda$, latitude $\varphi$,
+and altitude. Required if\\ \verb|coord/convergence_angle==from_grid|, else
+location is inherited from landscape.
+\begin{verbatim}
+planet = Earth
+latitude = +48d31'30.4"      ; Required if coord/convergence_angle==from_grid
+longitude = +16d12'25.5"     ; "--"
+altitude =from_model|<int>   ; 
+\end{verbatim}
+altitude (for astronomical computations) can be computed from the model:  if
+\verb|from_model|, it is computed as $(z_{min}+z_{max})/2+\mathtt{orig\_H}$,
+i.e. from the model bounding box centre height.
+
+\begin{verbatim}
+display_fog = 0
+atmospheric_extinction_coefficient = 0.2
+atmospheric_temperature = 10.0
+atmospheric_pressure = 1013.0
+light_pollution = 1
+
+[coord]
+\end{verbatim}
+
+Entries in the \verb|[coord]| section are again optional, default to zero when
+not specified, but are
+required if you want to display meaningful eye coordinates in your
+survey (world) coordinate system, like UTM or Gauss-Kr\"uger.  
+
+\begin{verbatim}
+grid_name=<string> 
+\end{verbatim}
+Name of grid coordinates, e.g. \texttt{``UTM 33 U (WGS 84)''},
+\texttt{``Gauss-Kr\"uger M34''} or \texttt{``Relative to <Center>''} This name is
+only displayed, there is no evaluation of its contents.
+
+\begin{verbatim}
+orig_E=<double> | (Easting)  East-West-distance to zone central meridian
+orig_N=<double> | (Northing) North distance from Equator
+orig_H=<double> | (Height)   Altitude above Mean Sea Level of model origin
+\end{verbatim}
+These entries describe the offset, in metres, of the model coordinates relative
+to coordinates in a geographic grid, like Gauss-Kr\"uger. If you have your model
+vertices specified in grid coordinates, do not specify \verb|orig_...| data, but
+please add \verb|start_...| data, below.
+
+
+\begin{verbatim}
+convergence_angle=from_grid|<double> 
+grid_meridian=<double>|+<int>d<int>'<float>"      
+\end{verbatim}
+Typically, digital elevation models and building structures built on those are
+survey-grid aligned, so true geographical north will not coincide with grid
+north, the difference is known as meridian convergence.
+\begin{equation}
+\gamma(\lambda, \varphi)=\arctan(\tan(\lambda-\lambda_0)\sin\varphi)
+\end{equation}
+This amount can be given in \verb|convergence_angle| (degrees), so that your
+model will be aligned with True North\footnote{%
+\url{http://en.wikipedia.org/wiki/Transverse_Mercator_projection}}. Central
+meridian $\lambda_0$ of grid zone, e.g. for UTM or Gauss-Kr\"uger.
+\verb|grid_meridian| is  only required to compute convergence angle if
+\verb|convergence_angle="from_grid"|
+
+\begin{verbatim}
+zero_ground_height=<double> 
+\end{verbatim}
+height of terrain outside \filename{ground.OBJ}, or if \verb|ground=NULL|.
+Allows smooth approach from outside.  This value is relative to the model
+origin, or typically close to zero, i.e.,  use a Z value in model coordinates,
+not world coordinates! (If you want the terrain height surrounding your model to
+be \verb|orig_H|, use 0, not the correct mean height above sea level!)  Defaults
+to minimum of height of ground level (or model, resp.) bounding box.
+
+\begin{verbatim}
+start_E=<double> 
+start_N=<double> 
+start_H=<double> /* only meaningful if ground==NULL, else H is derived from ground */
+start_Eye=<double> /* default: 1.65m */
+start_az_alt_fov=<az_deg>,<alt_deg>,<fov_deg> /* initial view direction and field of view.*/
+\end{verbatim}
+\verb|start_...| defines the view position to be set after loading the scenery.
+Defaults to center of model boundingbox.
+
+It is advisable to use the grid coordinates of the location of the panoramic
+photo ("landscape") as \verb|start_...| coordinates, or the correct coordinates
+and some carefully selected \texttt{start\_az\_alt\_fov} in case of certain view
+corridors (temple axes, \ldots).
+
+\subsection{Predefined views}
+You can also distribute some predefined views with your model in a
+\filename{viewpoints.ini} file. See the provided ``Sterngarten'' scene for an
+example. These entries are not editable by the user through the interface. The
+user can always save its own views, they will be saved into the file
+\filename{userviews.ini} in the users home directory, and are editable.
+
+\begin{verbatim}
+[StoredViews]
+size=<int>              Defines how many entries are in this file. 
+                        Prefix each entry with it's index!
+1/label=<string>        The name of this entry
+1/description=<string>  A description of this entry (can include HTML)
+1/position=<x,y,z,h>    The x,y,z grid coordinates (like orig_* or start_*
+                        in scenery3d.ini) + the current eye height
+1/view_fov=<az_deg,alt_deg,fov_deg>  The view direction + FOV
+                                    (like start_az_alt_fov in scenery3d.ini)
+; an example for the second entry (note the 2 at the beginning of each line!)
+2/label       = Signs
+2/description = Two signs that describe the Sterngarten
+2/position    = 593155.2421280354,5333348.6304404084,325.7295809038,0.8805893660
+2/view_fov    = 84.315399,-8.187078,83.000000
+\end{verbatim}
+
+\subsection{Working with non-georeferenced OBJ files}
+\label{sec:NonGeoreferenced}
+
+
+There exists modeling software which produces nice models, but without
+concept of georeference. One spectacular example is AutoDesk PhotoFly,
+a cloud application which delivers 3D models from a bunch of photos
+uploaded via its program interface. This ``technological preview'' is
+in version 2 and free of cost as of mid-2011.
+
+The problem with these models is that you cannot assign surveyed
+coordinates to points in the model, so either you can georeference the
+models in other applications, or you must find the correct
+transformation matrix.  Importing the OBJ in Sketchup may take a long
+time for detailed photo-generated models, and the texturing may
+suffer, so you can cut the model down to the minimum necessary e.g.\ in
+Meshlab, and import just a stub required to georeference the model in
+Sketchup. 
+
+Now, how would you find the proper orientation? The easiest chance
+would be with a structure visible in the photo layer of Google
+Earth. So, start a new model and immediately "add location" from the
+Google Earth interface. Then you can import the OBJ with TIG's importer
+plugin.  If the imported model looks perfect, you may just place the
+model into the Sketchup landscape and export a complete landscape just
+like above. If not, or if you had to cut/simplify the OBJ to be able
+to import it, you can rotate/scale the OBJ (it must be grouped!). If
+you see a shadow in the photos, you may want to set the date/time of
+the photos in the scene and verify that the shadows created by
+Sketchup illuminating the model match those in the model's photo
+texture. When you are satisfied with placement/orientation, you create
+a \filename{scenery3d.ini} like above with the command
+\cmd{Plugins->ASTROSIM/Stellarium scenery3d helpers->Create scenery3d.ini}.
+
+Then, you select the OBJ group, open \cmd{Windows->Ruby Console} and call
+\cmd{Plugins->ASTROSIM/Stellarium scenery3d helpers->Export transformation
+of selected group (e.g., from PhotoFly import)}.
+
+On the Ruby console, you will find a line of numbers (the $4\times4$
+transformation matrix) which you copy/paste (all in one line!) into the
+\filename{[model]} section in \filename{scenery3d.ini}.
+\begin{verbatim}
+obj2grid_trafo=<a11>,<a12>,<a13>,<a14>,<a21>,<a22>,<a23>,<a24>,
+               <a31>,<a32>,<a33>,<a34>,<a41>,<a42>,<a43>,<a44>
+\end{verbatim}
+You edit the \filename{scenery3d.ini} to use your full (unmodified)
+PhotoFly model and, if you don't have a panorama, take \filename{Zero}
+landscape as (no-)background. It depends on the model if you want to
+be able to step on it, or to declare \verb|ground=NULL| for a
+constant-height ground. Run Stellarum once and adjust the
+\verb|start_N|, \verb|start_E| and \verb|zero_ground_height|.
+
+\subsubsection{Rotating OBJs with recognized survey points}
+\label{sec:RotatingOBJ}
+
+If you have survey points measured in a survey grid plus a photomodel
+with those points visible, you can use Meshlab to find the model
+vertex coordinates in the photo model, and some other program like
+CoordTrans in the JavaGraticule3D suite to find either the matrix
+values to enter in \filename{scenery3d.ini} or even rotate the OBJ
+points. However, this involves more math than can be described here;
+if you came that far, you likely know the required steps.  Here it
+really helps if you know how to operate automatic text processors like
+AWK.
+
+\section*{Authors and Acknowledgements}
+\label{Acknowledgments}
+
+
+Scenery3d was conceived by Georg Zotti for the Astrosim project. It was
+implemented originally in 2010/2011 by Simon Parzer and Peter Neubauer as
+student work supervised by Michael Wimmer (TU Wien). Improvements in
+integration, user interaction, .ini option handling, OBJ/MTL loader bugfixes and
+georeference testing by Georg Zotti. Andrei Borza in 2011/12 further improved
+rendering quality (shadow mapping, normal mapping) and speed. In 2014/15,
+Florian Schaukowitsch adapted the code to work with Qt 5 and the current
+Stellarium 0.13 codebase, replaced the renderer with a more efficient, fully
+shader-based system, implemented various performance, quality and usability
+enhancements, and did some code cleanup. Both Andrei and Florian were again
+supervised by Michael Wimmer.
+
+This work has been created during the ASTROSIM project supported 2008-2012 by
+the Austrian Science Fund (FWF) under grant number P~21208-G19.
+
+\end{document}
+

=== added file 'plugins/Scenery3d/doc/classdiagram.dia'
Binary files plugins/Scenery3d/doc/classdiagram.dia	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/doc/classdiagram.dia	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/doc/developer-doc.odt'
Binary files plugins/Scenery3d/doc/developer-doc.odt	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/doc/developer-doc.odt	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/doc/developer-doc.pdf'
Binary files plugins/Scenery3d/doc/developer-doc.pdf	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/doc/developer-doc.pdf	2015-04-01 10:27:06 +0000 differ
=== added directory 'plugins/Scenery3d/resources'
=== added file 'plugins/Scenery3d/resources/Scenery3d.qrc'
--- plugins/Scenery3d/resources/Scenery3d.qrc	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/resources/Scenery3d.qrc	2015-04-01 10:27:06 +0000
@@ -0,0 +1,10 @@
+<RCC>
+    <qresource prefix="/Scenery3d">
+        <file>bt_scenery3d_on.png</file>
+        <file>bt_scenery3d_off.png</file>
+        <file>bt_scenery3d_settings_on.png</file>
+        <file>bt_scenery3d_settings_off.png</file>
+        <file>bt_scenery3d_eyepoint_off.png</file>
+        <file>bt_scenery3d_eyepoint_on.png</file>
+    </qresource>
+</RCC>

=== added file 'plugins/Scenery3d/resources/bt_scenery3d_eyepoint_off.png'
Binary files plugins/Scenery3d/resources/bt_scenery3d_eyepoint_off.png	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/resources/bt_scenery3d_eyepoint_off.png	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/resources/bt_scenery3d_eyepoint_on.png'
Binary files plugins/Scenery3d/resources/bt_scenery3d_eyepoint_on.png	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/resources/bt_scenery3d_eyepoint_on.png	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/resources/bt_scenery3d_icons_master.tif'
Binary files plugins/Scenery3d/resources/bt_scenery3d_icons_master.tif	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/resources/bt_scenery3d_icons_master.tif	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/resources/bt_scenery3d_off.png'
Binary files plugins/Scenery3d/resources/bt_scenery3d_off.png	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/resources/bt_scenery3d_off.png	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/resources/bt_scenery3d_on.png'
Binary files plugins/Scenery3d/resources/bt_scenery3d_on.png	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/resources/bt_scenery3d_on.png	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/resources/bt_scenery3d_settings_off.png'
Binary files plugins/Scenery3d/resources/bt_scenery3d_settings_off.png	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/resources/bt_scenery3d_settings_off.png	2015-04-01 10:27:06 +0000 differ
=== added file 'plugins/Scenery3d/resources/bt_scenery3d_settings_on.png'
Binary files plugins/Scenery3d/resources/bt_scenery3d_settings_on.png	1970-01-01 00:00:00 +0000 and plugins/Scenery3d/resources/bt_scenery3d_settings_on.png	2015-04-01 10:27:06 +0000 differ
=== added directory 'plugins/Scenery3d/src'
=== added file 'plugins/Scenery3d/src/AABB.cpp'
--- plugins/Scenery3d/src/AABB.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/src/AABB.cpp	2015-04-01 10:27:06 +0000
@@ -0,0 +1,304 @@
+#include "AABB.hpp"
+#include "GLFuncs.hpp"
+#include <limits>
+
+Box::Box()
+{
+
+}
+
+void Box::transform(const QMatrix4x4& tf)
+{
+	for(int i =0;i<8;++i)
+	{
+		//this is a bit stupid, but only used for debugging, so...
+		QVector3D vec(vertices[i].v[0],vertices[i].v[1],vertices[i].v[2]);
+		vec = tf * vec;
+		vertices[i] = Vec3f(vec.x(),vec.y(),vec.z());
+	}
+}
+
+void Box::render() const
+{
+// Minimum to avoid trouble when building on pure OpenGL ES systems
+// Not sure about ANGLE!
+#if !defined(QT_OPENGL_ES_2)
+	Vec3f nbl = vertices[0];
+	Vec3f nbr = vertices[1];
+	Vec3f ntr = vertices[2];
+	Vec3f ntl = vertices[3];
+	Vec3f fbl = vertices[4];
+	Vec3f fbr = vertices[5];
+	Vec3f ftr = vertices[6];
+	Vec3f ftl = vertices[7];
+
+	glExtFuncs->glColor3f(1.0f,1.0f,1.0f);
+	glExtFuncs->glLineWidth(5);
+	glExtFuncs->glBegin(GL_LINE_LOOP);
+	    //near plane
+	    glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	    glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]);
+	    glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]);
+	    glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+	glExtFuncs->glEnd();
+
+	glExtFuncs->glBegin(GL_LINE_LOOP);
+	    //far plane
+	    glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]);
+	    glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]);
+	    glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);
+	    glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]);
+	glExtFuncs->glEnd();
+
+	glExtFuncs->glBegin(GL_LINE_LOOP);
+	    //bottom plane
+	    glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+	    glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]);
+	    glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]);
+	    glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);
+	glExtFuncs->glEnd();
+
+	glExtFuncs->glBegin(GL_LINE_LOOP);
+	    //top plane
+	    glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]);
+	    glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	    glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]);
+	    glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]);
+	glExtFuncs->glEnd();
+
+	glExtFuncs->glBegin(GL_LINE_LOOP);
+	    //left plane
+	    glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	    glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+	    glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);
+	    glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]);
+	glExtFuncs->glEnd();
+
+	glExtFuncs->glBegin(GL_LINE_LOOP);
+	    // right plane
+	    glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]);
+	    glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]);
+	    glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]);
+	    glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]);
+	glExtFuncs->glEnd();
+#endif
+}
+
+AABB::AABB()
+{
+	*this = AABB(std::numeric_limits<float>::max(),-std::numeric_limits<float>::max());
+}
+
+AABB::AABB(Vec3f min, Vec3f max)
+{
+    this->min = min;
+    this->max = max;
+}
+
+AABB::~AABB() {}
+
+void AABB::reset()
+{
+	*this = AABB();
+}
+
+void AABB::resetToZero()
+{
+	*this = AABB(Vec3f(0.0f),Vec3f(0.0f));
+}
+
+void AABB::expand(const Vec3f &vec)
+{
+	min = Vec3f(	std::min(vec.v[0], min.v[0]),
+			std::min(vec.v[1], min.v[1]),
+			std::min(vec.v[2], min.v[2]));
+	max = Vec3f(	std::max(vec.v[0], max.v[0]),
+			std::max(vec.v[1], max.v[1]),
+			std::max(vec.v[2], max.v[2]));
+}
+
+Vec3f AABB::getCorner(Corner corner) const
+{
+    Vec3f out;
+
+    switch(corner)
+    {
+    case MinMinMin:
+        out = min;
+        break;
+
+    case MaxMinMin:
+        out = Vec3f(max.v[0], min.v[1], min.v[2]);
+        break;
+
+    case MaxMaxMin:
+        out = Vec3f(max.v[0], max.v[1], min.v[2]);
+        break;
+
+    case MinMaxMin:
+        out = Vec3f(min.v[0], max.v[1], min.v[2]);
+        break;
+
+    case MinMinMax:
+        out = Vec3f(min.v[0], min.v[1], max.v[2]);
+        break;
+
+    case MaxMinMax:
+        out = Vec3f(max.v[0], min.v[1], max.v[2]);
+        break;
+
+    case MaxMaxMax:
+        out = max;
+        break;
+
+    case MinMaxMax:
+        out = Vec3f(min.v[0], max.v[1], max.v[2]);
+        break;
+
+    default:
+        break;
+    }
+
+    return out;
+}
+
+Vec4f AABB::getEquation(AABB::Plane p) const
+{
+    Vec4f out;
+
+    switch(p)
+    {
+    case Front:
+	out = Vec4f(0.0f, -1.0f, 0.0f, -min.v[1]);
+        break;
+
+    case Back:
+	out = Vec4f(0.0f, 1.0f, 0.0f, max.v[1]);
+        break;
+
+    case Bottom:
+	out = Vec4f(0.0f, 0.0f, -1.0f, -min.v[2]);
+        break;
+
+    case Top:
+	out = Vec4f(0.0f, 0.0f, 1.0f, max.v[2]);
+        break;
+
+    case Left:
+	out = Vec4f(-1.0f, 0.0f, 0.0f, -min.v[0]);
+        break;
+
+    case Right:
+	out = Vec4f(1.0f, 0.0f, 0.0f, max.v[0]);
+        break;
+
+    default:
+        break;
+    }
+
+    return out;
+}
+
+Vec3f AABB::positiveVertex(Vec3f& normal) const
+{
+    Vec3f out = min;
+
+    if(normal.v[0] >= 0.0f)
+        out.v[0] = max.v[0];
+    if(normal.v[1] >= 0.0f)
+        out.v[1] = max.v[1];
+    if(normal.v[2] >= 0.0f)
+        out.v[2] = max.v[2];
+
+    return out;
+}
+
+Vec3f AABB::negativeVertex(Vec3f& normal) const
+{
+    Vec3f out = max;
+
+    if(normal.v[0] >= 0.0f)
+        out.v[0] = min.v[0];
+    if(normal.v[1] >= 0.0f)
+        out.v[1] = min.v[1];
+    if(normal.v[2] >= 0.0f)
+        out.v[2] = min.v[2];
+
+    return out;
+}
+
+void AABB::render() const
+{
+// Minimum to avoid trouble when building on pure OpenGL ES systems
+// Not sure about ANGLE!
+#if !defined(QT_OPENGL_ES_2)
+    Vec3f nbl = getCorner(MinMinMin);
+    Vec3f nbr = getCorner(MaxMinMin);
+    Vec3f ntr = getCorner(MaxMinMax);
+    Vec3f ntl = getCorner(MinMinMax);
+    Vec3f fbl = getCorner(MinMaxMin);
+    Vec3f fbr = getCorner(MaxMaxMin);
+    Vec3f ftr = getCorner(MaxMaxMax);
+    Vec3f ftl = getCorner(MinMaxMax);
+
+    glExtFuncs->glColor3f(1.0f, 1.0f, 1.0f);
+    glExtFuncs->glLineWidth(5);
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //near plane
+	glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]);
+	glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]);
+	glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //far plane
+	glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]);
+	glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]);
+	glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);
+	glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //bottom plane
+	glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+	glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]);
+	glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]);
+	glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //top plane
+	glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]);
+	glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]);
+	glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //left plane
+	glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+	glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);
+	glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        // right plane
+	glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]);
+	glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]);
+	glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]);
+	glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]);
+    glExtFuncs->glEnd();
+#endif
+}
+
+Box AABB::toBox()
+{
+	Box ret;
+	for(int i =0;i<CORNERCOUNT;++i)
+	{
+		ret.vertices[i]= getCorner(static_cast<Corner>(i));
+	}
+	return ret;
+}

=== added file 'plugins/Scenery3d/src/AABB.hpp'
--- plugins/Scenery3d/src/AABB.hpp	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/src/AABB.hpp	2015-04-01 10:27:06 +0000
@@ -0,0 +1,67 @@
+#ifndef _AABB_HPP_
+#define _AABB_HPP_
+
+#include <vector>
+#include "VecMath.hpp"
+
+//! A simple "box" class with 8 arbitrary vertices
+class Box
+{
+public:
+	Box();
+
+	Vec3f vertices[8];
+
+	//! Transforms the vertices
+	void transform(const QMatrix4x4 &tf);
+	//! Renders the box
+	void render() const;
+};
+
+//! An axis-aligned bounding-box class
+class AABB
+{
+public:
+    enum Corner
+    {
+        MinMinMin = 0, MaxMinMin, MaxMaxMin, MinMaxMin,
+        MinMinMax, MaxMinMax, MaxMaxMax, MinMaxMax,
+        CORNERCOUNT
+    };
+
+    enum Plane
+    {
+        Front = 0, Back, Bottom, Top, Left, Right,
+        PLANECOUNT
+    };
+
+    Vec3f min, max;
+
+    //! Creates an AABB with minimum vertex set to infinity and maximum vertex set to -infinity
+    AABB();
+    AABB(Vec3f min, Vec3f max);
+    ~AABB();
+
+    //! Resets minimum to infinity and maximum to -infinity
+    void reset();
+    //! Resets minimum and maximum to zero vectors
+    void resetToZero();
+
+    //! Updates the bounding box to include the specified vertex.
+    void expand(const Vec3f& vec);
+
+    Vec3f getCorner(Corner corner) const;
+
+    //! Used for frustum culling
+    Vec3f positiveVertex(Vec3f& normal) const;
+    Vec3f negativeVertex(Vec3f& normal) const;
+
+    void render() const;
+
+    //! Return the plane equation for specified plane as Vec4f
+    Vec4f getEquation(AABB::Plane p) const;
+    //! Returns a box object that represents the AABB.
+    Box toBox();
+};
+
+#endif

=== added file 'plugins/Scenery3d/src/CMakeLists.txt'
--- plugins/Scenery3d/src/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/src/CMakeLists.txt	2015-04-01 10:27:06 +0000
@@ -0,0 +1,66 @@
+INCLUDE_DIRECTORIES(
+	.
+	gui
+	${CMAKE_BINARY_DIR}/plugins/Scenery3d/src
+	${CMAKE_BINARY_DIR}/plugins/Scenery3d/src/gui
+)
+
+LINK_DIRECTORIES(${BUILD_DIR}/src)
+
+SET(Scenery3d_SRCS
+    AABB.hpp
+    AABB.cpp
+    Frustum.hpp
+    Frustum.cpp
+    GLFuncs.hpp
+    Line.hpp
+    Line.cpp
+    Plane.hpp
+    Plane.cpp
+    SPolygon.hpp
+    SPolygon.cpp
+    Polyhedron.hpp
+    Polyhedron.cpp
+    S3DEnum.hpp
+    SceneInfo.hpp
+    SceneInfo.cpp
+    Scenery3d.hpp
+    Scenery3d.cpp
+    Scenery3dMgr.hpp
+    Scenery3dMgr.cpp
+    gui/Scenery3dDialog.hpp
+    gui/Scenery3dDialog_p.hpp
+    gui/Scenery3dDialog.cpp
+    gui/StoredViewDialog.hpp
+    gui/StoredViewDialog_p.hpp
+    gui/StoredViewDialog.cpp
+    ShaderManager.hpp
+    ShaderManager.cpp
+    OBJ.hpp
+    OBJ.cpp
+    Heightmap.hpp
+    Heightmap.cpp
+)
+
+################# compiles resources files ############
+SET(Scenery3d_RES ../resources/Scenery3d.qrc)
+QT5_ADD_RESOURCES(Scenery3d_RES_CXX ${Scenery3d_RES})
+
+################# compiles .ui files ############
+SET(Scenery3d_UIS
+  gui/scenery3dDialog.ui
+  gui/storedViewDialog.ui
+)
+QT5_WRAP_UI(Scenery3d_UIS_H ${Scenery3d_UIS})
+
+SET(extLinkerOption  ${QT_LIBRARIES} ${JPEG_LIBRARIES} ${PNG_LIBRARIES} ${OPENGL_LIBRARIES}  )
+
+############### For building the static library ######################
+ADD_LIBRARY(Scenery3d-static STATIC ${Scenery3d_SRCS} ${Scenery3d_RES_CXX} ${Scenery3d_UIS_H} )
+QT5_USE_MODULES(Scenery3d-static Core Concurrent Gui Widgets)
+SET_TARGET_PROPERTIES(Scenery3d-static PROPERTIES OUTPUT_NAME "Scenery3d")
+TARGET_LINK_LIBRARIES(Scenery3d-static ${extLinkerOption})
+SET_TARGET_PROPERTIES(Scenery3d-static PROPERTIES COMPILE_FLAGS "-DQT_STATICPLUGIN")
+ADD_DEPENDENCIES(AllStaticPlugins Scenery3d-static)
+
+

=== added file 'plugins/Scenery3d/src/Frustum.cpp'
--- plugins/Scenery3d/src/Frustum.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Scenery3d/src/Frustum.cpp	2015-04-01 10:27:06 +0000
@@ -0,0 +1,262 @@
+#include "Frustum.hpp"
+#include "GLFuncs.hpp"
+#include <limits>
+
+Frustum::Frustum() : bbox(Vec3f(0),Vec3f(0)),drawBbox(Vec3f(0),Vec3f(0))
+{
+    for(unsigned int i=0; i<CORNERCOUNT; i++)
+    {
+        corners.push_back(Vec3f(0.0f, 0.0f, 0.0f));
+        drawCorners.push_back(Vec3f(0.0f, 0.0f, 0.0f));
+    }
+
+    for(unsigned int i=0; i<PLANECOUNT; i++)
+    {
+        planes.push_back(new Plane());
+    }
+
+    fov = 0.0f;
+    aspect = 0.0f;
+    zNear = 0.0f;
+    zFar = 0.0f;
+}
+
+Frustum::~Frustum()
+{
+    for(unsigned int i=0; i<planes.size(); i++)
+    {
+        delete planes[i];
+    }
+
+    planes.clear();
+}
+
+const Vec3f &Frustum::getCorner(Corner corner) const
+{
+    return corners[corner];
+}
+
+const Plane &Frustum::getPlane(FrustumPlane plane) const
+{
+    return *planes[plane];
+}
+
+void Frustum::calcFrustum(Vec3d p, Vec3d l, Vec3d u)
+{
+    Vec3d Y = -l;
+    Y.normalize();
+
+    Vec3d X = u^Y;
+    X.normalize();
+
+    Vec3d Z = Y^X;
+    Z.normalize();
+
+    float tang = tanf((static_cast<float>(M_PI)/360.0f)*fov);
+    float nh = zNear * tang;
+    float nw = nh * aspect;
+    float fh = zFar * tang;
+    float fw = fh * aspect;
+
+    Vec3d nc = p - Y*zNear;
+    Vec3d fc = p - Y*zFar;
+
+    Vec3d ntl = nc + Z * nh - X * nw;
+    Vec3d ntr = nc + Z * nh + X * nw;
+    Vec3d nbl = nc - Z * nh - X * nw;
+    Vec3d nbr = nc - Z * nh + X * nw;
+
+    Vec3d ftl = fc + Z * fh - X * fw;
+    Vec3d ftr = fc + Z * fh + X * fw;
+    Vec3d fbl = fc - Z * fh - X * fw;
+    Vec3d fbr = fc - Z * fh + X * fw;
+
+    corners[NTL] = ntl.toVec3f();
+    corners[NTR] = ntr.toVec3f();
+    corners[NBL] = nbl.toVec3f();
+    corners[NBR] = nbr.toVec3f();
+    corners[FTL] = ftl.toVec3f();
+    corners[FTR] = ftr.toVec3f();
+    corners[FBL] = fbl.toVec3f();
+    corners[FBR] = fbr.toVec3f();
+
+    planes[TOP]->setPoints(corners[NTR], corners[NTL], corners[FTL], SPolygon::CCW);
+    planes[BOTTOM]->setPoints(corners[NBL], corners[NBR], corners[FBR], SPolygon::CCW);
+    planes[LEFT]->setPoints(corners[NTL], corners[NBL], corners[FBL], SPolygon::CCW);
+    planes[RIGHT]->setPoints(corners[NBR], corners[NTR], corners[FBR], SPolygon::CCW);
+    planes[NEARP]->setPoints(corners[NTL], corners[NTR], corners[NBR], SPolygon::CCW);
+    planes[FARP]->setPoints(corners[FTR], corners[FTL], corners[FBL], SPolygon::CCW);
+
+
+    //reset bbox
+    bbox.min = Vec3f(std::numeric_limits<float>::max());
+    bbox.max = Vec3f(-std::numeric_limits<float>::max());
+
+    for(unsigned int i=0; i<CORNERCOUNT; i++)
+    {
+        Vec3f curVert = corners[i];
+	bbox.min = Vec3f(std::min(static_cast<float>(curVert[0]), bbox.min[0]),
+			  std::min(static_cast<float>(curVert[1]), bbox.min[1]),
+			  std::min(static_cast<float>(curVert[2]), bbox.min[2]));
+
+	bbox.max = Vec3f(std::max(static_cast<float>(curVert[0]), bbox.max[0]),
+			  std::max(static_cast<float>(curVert[1]), bbox.max[1]),
+			  std::max(static_cast<float>(curVert[2]), bbox.max[2]));
+    }
+}
+
+int Frustum::pointInFrustum(const Vec3f& p)
+{
+    int result = INSIDE;
+    for(int i=0; i<PLANECOUNT; i++)
+    {
+        if(planes[i]->isBehind(p))
+        {
+            return OUTSIDE;
+        }
+    }
+
+    return result;
+}
+
+int Frustum::boxInFrustum(const AABB& bbox)
+{
+    int result = INSIDE;
+    for(unsigned int i=0; i<PLANECOUNT; i++)
+    {
+	if(planes[i]->isBehind(bbox.positiveVertex(planes[i]->normal)))
+        {
+            return OUTSIDE;
+        }
+    }
+
+    return result;
+}
+
+void Frustum::saveDrawingCorners()
+{
+    for(unsigned int i=0; i<CORNERCOUNT; i++)
+        drawCorners[i] = corners[i];
+
+    for(unsigned int i=0; i<PLANECOUNT; i++)
+        planes[i]->saveValues();
+
+    drawBbox = bbox;
+}
+
+void Frustum::resetCorners()
+{
+    for(unsigned int i=0; i<CORNERCOUNT; i++)
+        drawCorners[i] = Vec3f(0.0f, 0.0f, 0.0f);
+
+    for(unsigned int i=0; i<PLANECOUNT; i++)
+        planes[i]->resetValues();
+}
+
+void Frustum::drawFrustum() const
+{
+// Minimum to avoid trouble when building on pure OpenGL ES systems
+// Not sure about ANGLE!
+#if !defined(QT_OPENGL_ES_2)
+
+    Vec3f ntl = drawCorners[NTL];
+    Vec3f ntr = drawCorners[NTR];
+    Vec3f nbr = drawCorners[NBR];
+    Vec3f nbl = drawCorners[NBL];
+    Vec3f ftr = drawCorners[FTR];
+    Vec3f ftl = drawCorners[FTL];
+    Vec3f fbl = drawCorners[FBL];
+    Vec3f fbr = drawCorners[FBR];
+
+    glExtFuncs->glColor3f(0.0f, 0.0f, 1.0f);
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //near plane
+	glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]);
+	glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]);
+	glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //far plane
+	glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]);
+	glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]);
+	glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);
+	glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //bottom plane
+	glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+	glExtFuncs->glVertex3f(nbr.v[0],nbr.v[1],nbr.v[2]);
+	glExtFuncs->glVertex3f(fbr.v[0],fbr.v[1],fbr.v[2]);
+	glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //top plane
+	glExtFuncs->glVertex3f(ntr.v[0],ntr.v[1],ntr.v[2]);
+	glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	glExtFuncs->glVertex3f(ftl.v[0],ftl.v[1],ftl.v[2]);
+	glExtFuncs->glVertex3f(ftr.v[0],ftr.v[1],ftr.v[2]);
+    glExtFuncs->glEnd();
+
+    glExtFuncs->glBegin(GL_LINE_LOOP);
+        //left plane
+	glExtFuncs->glVertex3f(ntl.v[0],ntl.v[1],ntl.v[2]);
+	glExtFuncs->glVertex3f(nbl.v[0],nbl.v[1],nbl.v[2]);
+	glExtFuncs->glVertex3f(fbl.v[0],fbl.v[1],fbl.v[2]);