From 6ccb5835ff55d85156be91473c598eca9d6cb9a6 Mon Sep 17 00:00:00 2001
From: Elias Fleckenstein <eliasfleckenstein@web.de>
Date: Wed, 4 Nov 2020 16:57:41 +0100
Subject: Revert "Make Lint Happy"

This reverts commit ad148587dcf5244c2d2011dba339786c765c54c4.
---
 src/client/sky.cpp | 551 +++++++++++++++++++++++------------------------------
 1 file changed, 239 insertions(+), 312 deletions(-)

(limited to 'src/client/sky.cpp')

diff --git a/src/client/sky.cpp b/src/client/sky.cpp
index fa36f623e..2e0cbca86 100644
--- a/src/client/sky.cpp
+++ b/src/client/sky.cpp
@@ -35,9 +35,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 using namespace irr::core;
 
 Sky::Sky(s32 id, ITextureSource *tsrc) :
-		scene::ISceneNode(
-				RenderingEngine::get_scene_manager()->getRootSceneNode(),
-				RenderingEngine::get_scene_manager(), id)
+		scene::ISceneNode(RenderingEngine::get_scene_manager()->getRootSceneNode(),
+			RenderingEngine::get_scene_manager(), id)
 {
 	setAutomaticCulling(scene::EAC_OFF);
 	m_box.MaxEdge.set(0, 0, 0);
@@ -61,40 +60,33 @@ Sky::Sky(s32 id, ITextureSource *tsrc) :
 	m_materials[0] = mat;
 
 	m_materials[1] = mat;
-	// m_materials[1].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
+	//m_materials[1].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
 	m_materials[1].MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
 
 	m_materials[2] = mat;
 	m_materials[2].setTexture(0, tsrc->getTextureForMesh("sunrisebg.png"));
 	m_materials[2].MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
-	// m_materials[2].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
+	//m_materials[2].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
 
 	// Ensures that sun and moon textures and tonemaps are correct.
 	setSkyDefaults();
-	m_sun_texture = tsrc->isKnownSourceImage(m_sun_params.texture)
-					? tsrc->getTextureForMesh(m_sun_params.texture)
-					: NULL;
-	m_moon_texture = tsrc->isKnownSourceImage(m_moon_params.texture)
-					 ? tsrc->getTextureForMesh(m_moon_params.texture)
-					 : NULL;
-	m_sun_tonemap = tsrc->isKnownSourceImage(m_sun_params.tonemap)
-					? tsrc->getTexture(m_sun_params.tonemap)
-					: NULL;
-	m_moon_tonemap = tsrc->isKnownSourceImage(m_moon_params.tonemap)
-					 ? tsrc->getTexture(m_moon_params.tonemap)
-					 : NULL;
+	m_sun_texture = tsrc->isKnownSourceImage(m_sun_params.texture) ?
+		tsrc->getTextureForMesh(m_sun_params.texture) : NULL;
+	m_moon_texture = tsrc->isKnownSourceImage(m_moon_params.texture) ?
+		tsrc->getTextureForMesh(m_moon_params.texture) : NULL;
+	m_sun_tonemap = tsrc->isKnownSourceImage(m_sun_params.tonemap) ?
+		tsrc->getTexture(m_sun_params.tonemap) : NULL;
+	m_moon_tonemap = tsrc->isKnownSourceImage(m_moon_params.tonemap) ?
+		tsrc->getTexture(m_moon_params.tonemap) : NULL;
 
 	if (m_sun_texture) {
 		m_materials[3] = mat;
 		m_materials[3].setTexture(0, m_sun_texture);
 		m_materials[3].MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
 		// Disables texture filtering
-		m_materials[3].setFlag(
-				video::E_MATERIAL_FLAG::EMF_BILINEAR_FILTER, false);
-		m_materials[3].setFlag(
-				video::E_MATERIAL_FLAG::EMF_TRILINEAR_FILTER, false);
-		m_materials[3].setFlag(
-				video::E_MATERIAL_FLAG::EMF_ANISOTROPIC_FILTER, false);
+		m_materials[3].setFlag(video::E_MATERIAL_FLAG::EMF_BILINEAR_FILTER, false);
+		m_materials[3].setFlag(video::E_MATERIAL_FLAG::EMF_TRILINEAR_FILTER, false);
+		m_materials[3].setFlag(video::E_MATERIAL_FLAG::EMF_ANISOTROPIC_FILTER, false);
 		// Use tonemaps if available
 		if (m_sun_tonemap)
 			m_materials[3].Lighting = true;
@@ -104,12 +96,9 @@ Sky::Sky(s32 id, ITextureSource *tsrc) :
 		m_materials[4].setTexture(0, m_moon_texture);
 		m_materials[4].MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
 		// Disables texture filtering
-		m_materials[4].setFlag(
-				video::E_MATERIAL_FLAG::EMF_BILINEAR_FILTER, false);
-		m_materials[4].setFlag(
-				video::E_MATERIAL_FLAG::EMF_TRILINEAR_FILTER, false);
-		m_materials[4].setFlag(
-				video::E_MATERIAL_FLAG::EMF_ANISOTROPIC_FILTER, false);
+		m_materials[4].setFlag(video::E_MATERIAL_FLAG::EMF_BILINEAR_FILTER, false);
+		m_materials[4].setFlag(video::E_MATERIAL_FLAG::EMF_TRILINEAR_FILTER, false);
+		m_materials[4].setFlag(video::E_MATERIAL_FLAG::EMF_ANISOTROPIC_FILTER, false);
 		// Use tonemaps if available
 		if (m_moon_tonemap)
 			m_materials[4].Lighting = true;
@@ -157,9 +146,9 @@ void Sky::render()
 	if (m_sunlight_seen) {
 		float sunsize = 0.07;
 		video::SColorf suncolor_f(1, 1, 0, 1);
-		// suncolor_f.r = 1;
-		// suncolor_f.g = MYMAX(0.3, MYMIN(1.0, 0.7 + m_time_brightness * 0.5));
-		// suncolor_f.b = MYMAX(0.0, m_brightness * 0.95);
+		//suncolor_f.r = 1;
+		//suncolor_f.g = MYMAX(0.3, MYMIN(1.0, 0.7 + m_time_brightness * 0.5));
+		//suncolor_f.b = MYMAX(0.0, m_brightness * 0.95);
 		video::SColorf suncolor2_f(1, 1, 1, 1);
 		// The values below were probably meant to be suncolor2_f instead of a
 		// reassignment of suncolor_f. However, the resulting colour was chosen
@@ -177,8 +166,7 @@ void Sky::render()
 		float wn = nightlength / 2;
 		float wicked_time_of_day = 0;
 		if (m_time_of_day > wn && m_time_of_day < 1.0 - wn)
-			wicked_time_of_day = (m_time_of_day - wn) / (1.0 - wn * 2) * 0.5 +
-					     0.25;
+			wicked_time_of_day = (m_time_of_day - wn) / (1.0 - wn * 2) * 0.5 + 0.25;
 		else if (m_time_of_day < 0.5)
 			wicked_time_of_day = m_time_of_day / wn * 0.25;
 		else
@@ -192,25 +180,22 @@ void Sky::render()
 		video::SColor mooncolor2 = mooncolor2_f.toSColor();
 
 		// Calculate offset normalized to the X dimension of a 512x1 px tonemap
-		float offset = (1.0 - fabs(sin((m_time_of_day - 0.5) * irr::core::PI))) *
-			       511;
+		float offset = (1.0 - fabs(sin((m_time_of_day - 0.5) * irr::core::PI))) * 511;
 
 		if (m_sun_tonemap) {
-			u8 *texels = (u8 *)m_sun_tonemap->lock();
-			video::SColor *texel =
-					(video::SColor *)(texels + (u32)offset * 4);
-			video::SColor texel_color(255, texel->getRed(), texel->getGreen(),
-					texel->getBlue());
+			u8 * texels = (u8 *)m_sun_tonemap->lock();
+			video::SColor* texel = (video::SColor *)(texels + (u32)offset * 4);
+			video::SColor texel_color (255, texel->getRed(),
+				texel->getGreen(), texel->getBlue());
 			m_sun_tonemap->unlock();
 			m_materials[3].EmissiveColor = texel_color;
 		}
 
 		if (m_moon_tonemap) {
-			u8 *texels = (u8 *)m_moon_tonemap->lock();
-			video::SColor *texel =
-					(video::SColor *)(texels + (u32)offset * 4);
-			video::SColor texel_color(255, texel->getRed(), texel->getGreen(),
-					texel->getBlue());
+			u8 * texels = (u8 *)m_moon_tonemap->lock();
+			video::SColor* texel = (video::SColor *)(texels + (u32)offset * 4);
+			video::SColor texel_color (255, texel->getRed(),
+				texel->getGreen(), texel->getBlue());
 			m_moon_tonemap->unlock();
 			m_materials[4].EmissiveColor = texel_color;
 		}
@@ -236,14 +221,10 @@ void Sky::render()
 				driver->setMaterial(m_materials[j]);
 				// Use 1.05 rather than 1.0 to avoid colliding with the
 				// sun, moon and stars, as this is a background skybox.
-				vertices[0] = video::S3DVertex(
-						-1.05, -1.05, -1.05, 0, 0, 1, c, t, t);
-				vertices[1] = video::S3DVertex(
-						1.05, -1.05, -1.05, 0, 0, 1, c, o, t);
-				vertices[2] = video::S3DVertex(
-						1.05, 1.05, -1.05, 0, 0, 1, c, o, o);
-				vertices[3] = video::S3DVertex(
-						-1.05, 1.05, -1.05, 0, 0, 1, c, t, o);
+				vertices[0] = video::S3DVertex(-1.05, -1.05, -1.05, 0, 0, 1, c, t, t);
+				vertices[1] = video::S3DVertex( 1.05, -1.05, -1.05, 0, 0, 1, c, o, t);
+				vertices[2] = video::S3DVertex( 1.05,  1.05, -1.05, 0, 0, 1, c, o, o);
+				vertices[3] = video::S3DVertex(-1.05,  1.05, -1.05, 0, 0, 1, c, t, o);
 				for (video::S3DVertex &vertex : vertices) {
 					if (j == 5) { // Top texture
 						vertex.Pos.rotateYZBy(90);
@@ -256,16 +237,14 @@ void Sky::render()
 					} else if (j == 8) { // Right texture
 						vertex.Pos.rotateXZBy(-90);
 					} else if (j == 9) { // Front texture, do nothing
-						// Irrlicht doesn't like it when vertexes
-						// are left alone and not rotated for some
-						// reason.
+						// Irrlicht doesn't like it when vertexes are left
+						// alone and not rotated for some reason.
 						vertex.Pos.rotateXZBy(0);
-					} else { // Back texture
+					} else {// Back texture
 						vertex.Pos.rotateXZBy(180);
 					}
 				}
-				driver->drawIndexedTriangleFan(
-						&vertices[0], 4, indices, 2);
+				driver->drawIndexedTriangleFan(&vertices[0], 4, indices, 2);
 			}
 		}
 
@@ -273,19 +252,15 @@ void Sky::render()
 		if (m_visible) {
 			driver->setMaterial(m_materials[1]);
 			for (u32 j = 0; j < 4; j++) {
-				vertices[0] = video::S3DVertex(
-						-1, -0.02, -1, 0, 0, 1, m_bgcolor, t, t);
-				vertices[1] = video::S3DVertex(
-						1, -0.02, -1, 0, 0, 1, m_bgcolor, o, t);
-				vertices[2] = video::S3DVertex(
-						1, 0.45, -1, 0, 0, 1, m_skycolor, o, o);
-				vertices[3] = video::S3DVertex(
-						-1, 0.45, -1, 0, 0, 1, m_skycolor, t, o);
+				vertices[0] = video::S3DVertex(-1, -0.02, -1, 0, 0, 1, m_bgcolor, t, t);
+				vertices[1] = video::S3DVertex( 1, -0.02, -1, 0, 0, 1, m_bgcolor, o, t);
+				vertices[2] = video::S3DVertex( 1, 0.45, -1, 0, 0, 1, m_skycolor, o, o);
+				vertices[3] = video::S3DVertex(-1, 0.45, -1, 0, 0, 1, m_skycolor, t, o);
 				for (video::S3DVertex &vertex : vertices) {
 					if (j == 0)
-					// Don't switch
-					{
-					} else if (j == 1)
+						// Don't switch
+						{}
+					else if (j == 1)
 						// Switch from -Z (south) to +X (east)
 						vertex.Pos.rotateXZBy(90);
 					else if (j == 2)
@@ -295,8 +270,7 @@ void Sky::render()
 						// Switch from -Z (south) to +Z (north)
 						vertex.Pos.rotateXZBy(-180);
 				}
-				driver->drawIndexedTriangleFan(
-						&vertices[0], 4, indices, 2);
+				driver->drawIndexedTriangleFan(&vertices[0], 4, indices, 2);
 			}
 		}
 
@@ -312,15 +286,13 @@ void Sky::render()
 			float mid = wicked_time_of_day < 0.5 ? mid1 : (1.0 - mid1);
 			float a_ = 1.0f - std::fabs(wicked_time_of_day - mid) * 35.0f;
 			float a = easeCurve(MYMAX(0, MYMIN(1, a_)));
-			// std::cerr<<"a_="<<a_<<" a="<<a<<std::endl;
+			//std::cerr<<"a_="<<a_<<" a="<<a<<std::endl;
 			video::SColor c(255, 255, 255, 255);
 			float y = -(1.0 - a) * 0.22;
-			vertices[0] = video::S3DVertex(
-					-1, -0.05 + y, -1, 0, 0, 1, c, t, t);
-			vertices[1] = video::S3DVertex(
-					1, -0.05 + y, -1, 0, 0, 1, c, o, t);
-			vertices[2] = video::S3DVertex(1, 0.2 + y, -1, 0, 0, 1, c, o, o);
-			vertices[3] = video::S3DVertex(-1, 0.2 + y, -1, 0, 0, 1, c, t, o);
+			vertices[0] = video::S3DVertex(-1, -0.05 + y, -1, 0, 0, 1, c, t, t);
+			vertices[1] = video::S3DVertex( 1, -0.05 + y, -1, 0, 0, 1, c, o, t);
+			vertices[2] = video::S3DVertex( 1,   0.2 + y, -1, 0, 0, 1, c, o, o);
+			vertices[3] = video::S3DVertex(-1,   0.2 + y, -1, 0, 0, 1, c, t, o);
 			for (video::S3DVertex &vertex : vertices) {
 				if (wicked_time_of_day < 0.5)
 					// Switch from -Z (south) to +X (east)
@@ -334,13 +306,11 @@ void Sky::render()
 
 		// Draw sun
 		if (m_sun_params.visible)
-			draw_sun(driver, sunsize, suncolor, suncolor2,
-					wicked_time_of_day);
+			draw_sun(driver, sunsize, suncolor, suncolor2, wicked_time_of_day);
 
 		// Draw moon
 		if (m_moon_params.visible)
-			draw_moon(driver, moonsize, mooncolor, mooncolor2,
-					wicked_time_of_day);
+			draw_moon(driver, moonsize, mooncolor, mooncolor2, wicked_time_of_day);
 
 		// Draw far cloudy fog thing below all horizons in front of sun, moon
 		// and stars.
@@ -349,19 +319,15 @@ void Sky::render()
 
 			for (u32 j = 0; j < 4; j++) {
 				video::SColor c = cloudyfogcolor;
-				vertices[0] = video::S3DVertex(
-						-1, -1.0, -1, 0, 0, 1, c, t, t);
-				vertices[1] = video::S3DVertex(
-						1, -1.0, -1, 0, 0, 1, c, o, t);
-				vertices[2] = video::S3DVertex(
-						1, -0.02, -1, 0, 0, 1, c, o, o);
-				vertices[3] = video::S3DVertex(
-						-1, -0.02, -1, 0, 0, 1, c, t, o);
+				vertices[0] = video::S3DVertex(-1, -1.0,  -1, 0, 0, 1, c, t, t);
+				vertices[1] = video::S3DVertex( 1, -1.0,  -1, 0, 0, 1, c, o, t);
+				vertices[2] = video::S3DVertex( 1, -0.02, -1, 0, 0, 1, c, o, o);
+				vertices[3] = video::S3DVertex(-1, -0.02, -1, 0, 0, 1, c, t, o);
 				for (video::S3DVertex &vertex : vertices) {
 					if (j == 0)
-					// Don't switch
-					{
-					} else if (j == 1)
+						// Don't switch
+						{}
+					else if (j == 1)
 						// Switch from -Z (south) to +X (east)
 						vertex.Pos.rotateXZBy(90);
 					else if (j == 2)
@@ -371,24 +337,23 @@ void Sky::render()
 						// Switch from -Z (south) to +Z (north)
 						vertex.Pos.rotateXZBy(-180);
 				}
-				driver->drawIndexedTriangleFan(
-						&vertices[0], 4, indices, 2);
+				driver->drawIndexedTriangleFan(&vertices[0], 4, indices, 2);
 			}
 
-			// Draw bottom far cloudy fog thing in front of sun, moon and
-			// stars
+			// Draw bottom far cloudy fog thing in front of sun, moon and stars
 			video::SColor c = cloudyfogcolor;
 			vertices[0] = video::S3DVertex(-1, -1.0, -1, 0, 1, 0, c, t, t);
-			vertices[1] = video::S3DVertex(1, -1.0, -1, 0, 1, 0, c, o, t);
-			vertices[2] = video::S3DVertex(1, -1.0, 1, 0, 1, 0, c, o, o);
+			vertices[1] = video::S3DVertex( 1, -1.0, -1, 0, 1, 0, c, o, t);
+			vertices[2] = video::S3DVertex( 1, -1.0, 1, 0, 1, 0, c, o, o);
 			vertices[3] = video::S3DVertex(-1, -1.0, 1, 0, 1, 0, c, t, o);
 			driver->drawIndexedTriangleFan(&vertices[0], 4, indices, 2);
 		}
 	}
 }
 
-void Sky::update(float time_of_day, float time_brightness, float direct_brightness,
-		bool sunlight_seen, CameraMode cam_mode, float yaw, float pitch)
+void Sky::update(float time_of_day, float time_brightness,
+	float direct_brightness, bool sunlight_seen,
+	CameraMode cam_mode, float yaw, float pitch)
 {
 	// Stabilize initial brightness and color values by flooding updates
 	if (m_first_update) {
@@ -415,8 +380,8 @@ void Sky::update(float time_of_day, float time_brightness, float direct_brightne
 	Development colours
 
 	video::SColorf bgcolor_bright_normal_f(170. / 255, 200. / 255, 230. / 255, 1.0);
-	video::SColorf bgcolor_bright_dawn_f(0.666, 200. / 255 * 0.7, 230. / 255 *
-	0.5, 1.0); video::SColorf bgcolor_bright_dawn_f(0.666, 0.549, 0.220, 1.0);
+	video::SColorf bgcolor_bright_dawn_f(0.666, 200. / 255 * 0.7, 230. / 255 * 0.5, 1.0);
+	video::SColorf bgcolor_bright_dawn_f(0.666, 0.549, 0.220, 1.0);
 	video::SColorf bgcolor_bright_dawn_f(0.666 * 1.2, 0.549 * 1.0, 0.220 * 1.0, 1.0);
 	video::SColorf bgcolor_bright_dawn_f(0.666 * 1.2, 0.549 * 1.0, 0.220 * 1.2, 1.0);
 
@@ -457,58 +422,58 @@ void Sky::update(float time_of_day, float time_brightness, float direct_brightne
 	if (sunlight_seen) {
 		if (is_dawn) { // Dawn
 			m_bgcolor_bright_f = m_bgcolor_bright_f.getInterpolated(
-					bgcolor_bright_dawn_f, color_change_fraction);
+				bgcolor_bright_dawn_f, color_change_fraction);
 			m_skycolor_bright_f = m_skycolor_bright_f.getInterpolated(
-					skycolor_bright_dawn_f, color_change_fraction);
+				skycolor_bright_dawn_f, color_change_fraction);
 			m_cloudcolor_bright_f = m_cloudcolor_bright_f.getInterpolated(
-					cloudcolor_bright_dawn_f, color_change_fraction);
+				cloudcolor_bright_dawn_f, color_change_fraction);
 		} else {
 			if (time_brightness < 0.13f) { // Night
 				m_bgcolor_bright_f = m_bgcolor_bright_f.getInterpolated(
-						bgcolor_bright_night_f,
-						color_change_fraction);
+					bgcolor_bright_night_f, color_change_fraction);
 				m_skycolor_bright_f = m_skycolor_bright_f.getInterpolated(
-						skycolor_bright_night_f,
-						color_change_fraction);
+					skycolor_bright_night_f, color_change_fraction);
 			} else { // Day
 				m_bgcolor_bright_f = m_bgcolor_bright_f.getInterpolated(
-						bgcolor_bright_normal_f,
-						color_change_fraction);
+					bgcolor_bright_normal_f, color_change_fraction);
 				m_skycolor_bright_f = m_skycolor_bright_f.getInterpolated(
-						skycolor_bright_normal_f,
-						color_change_fraction);
+					skycolor_bright_normal_f, color_change_fraction);
 			}
 
 			m_cloudcolor_bright_f = m_cloudcolor_bright_f.getInterpolated(
-					cloudcolor_bright_normal_f,
-					color_change_fraction);
+				cloudcolor_bright_normal_f, color_change_fraction);
 		}
 	} else {
 		m_bgcolor_bright_f = m_bgcolor_bright_f.getInterpolated(
-				bgcolor_bright_indoor_f, color_change_fraction);
+			bgcolor_bright_indoor_f, color_change_fraction);
 		m_skycolor_bright_f = m_skycolor_bright_f.getInterpolated(
-				bgcolor_bright_indoor_f, color_change_fraction);
+			bgcolor_bright_indoor_f, color_change_fraction);
 		m_cloudcolor_bright_f = m_cloudcolor_bright_f.getInterpolated(
-				cloudcolor_bright_normal_f, color_change_fraction);
+			cloudcolor_bright_normal_f, color_change_fraction);
 		m_clouds_visible = false;
 	}
 
 	video::SColor bgcolor_bright = m_bgcolor_bright_f.toSColor();
-	m_bgcolor = video::SColor(255, bgcolor_bright.getRed() * m_brightness,
-			bgcolor_bright.getGreen() * m_brightness,
-			bgcolor_bright.getBlue() * m_brightness);
+	m_bgcolor = video::SColor(
+		255,
+		bgcolor_bright.getRed() * m_brightness,
+		bgcolor_bright.getGreen() * m_brightness,
+		bgcolor_bright.getBlue() * m_brightness
+	);
 
 	video::SColor skycolor_bright = m_skycolor_bright_f.toSColor();
-	m_skycolor = video::SColor(255, skycolor_bright.getRed() * m_brightness,
-			skycolor_bright.getGreen() * m_brightness,
-			skycolor_bright.getBlue() * m_brightness);
+	m_skycolor = video::SColor(
+		255,
+		skycolor_bright.getRed() * m_brightness,
+		skycolor_bright.getGreen() * m_brightness,
+		skycolor_bright.getBlue() * m_brightness
+	);
 
 	// Horizon coloring based on sun and moon direction during sunset and sunrise
 	video::SColor pointcolor = video::SColor(m_bgcolor.getAlpha(), 255, 255, 255);
 	if (m_directional_colored_fog) {
 		if (m_horizon_blend() != 0) {
-			// Calculate hemisphere value from yaw, (inverted in third person
-			// front view)
+			// Calculate hemisphere value from yaw, (inverted in third person front view)
 			s8 dir_factor = 1;
 			if (cam_mode > CAMERA_MODE_THIRD)
 				dir_factor = -1;
@@ -517,14 +482,11 @@ void Sky::update(float time_of_day, float time_brightness, float direct_brightne
 				pointcolor_blend = 360 - pointcolor_blend;
 			pointcolor_blend /= 180;
 			// Bound view angle to determine where transition starts and ends
-			pointcolor_blend = rangelim(1 - pointcolor_blend * 1.375, 0,
-							   1 / 1.375) *
-					   1.375;
-			// Combine the colors when looking up or down, otherwise turning
-			// looks weird
+			pointcolor_blend = rangelim(1 - pointcolor_blend * 1.375, 0, 1 / 1.375) *
+				1.375;
+			// Combine the colors when looking up or down, otherwise turning looks weird
 			pointcolor_blend += (0.5 - pointcolor_blend) *
-					    (1 - MYMIN((90 - std::fabs(pitch)) / 90 * 1.5,
-								 1));
+				(1 - MYMIN((90 - std::fabs(pitch)) / 90 * 1.5, 1));
 			// Invert direction to match where the sun and moon are rising
 			if (m_time_of_day > 0.5)
 				pointcolor_blend = 1 - pointcolor_blend;
@@ -535,142 +497,109 @@ void Sky::update(float time_of_day, float time_brightness, float direct_brightne
 			// Use tonemap only if default sun/moon tinting is used
 			// which keeps previous behaviour.
 			if (m_sun_tonemap && m_default_tint) {
-				pointcolor_sun_f.r =
-						pointcolor_light *
-						(float)m_materials[3]
-								.EmissiveColor.getRed() /
-						255;
-				pointcolor_sun_f.b =
-						pointcolor_light *
-						(float)m_materials[3]
-								.EmissiveColor.getBlue() /
-						255;
+				pointcolor_sun_f.r = pointcolor_light *
+					(float)m_materials[3].EmissiveColor.getRed() / 255;
+				pointcolor_sun_f.b = pointcolor_light *
+					(float)m_materials[3].EmissiveColor.getBlue() / 255;
 				pointcolor_sun_f.g = pointcolor_light *
-						     (float)m_materials[3]
-								     .EmissiveColor
-								     .getGreen() /
-						     255;
+					(float)m_materials[3].EmissiveColor.getGreen() / 255;
 			} else if (!m_default_tint) {
 				pointcolor_sun_f = m_sky_params.fog_sun_tint;
 			} else {
 				pointcolor_sun_f.r = pointcolor_light * 1;
-				pointcolor_sun_f.b =
-						pointcolor_light *
-						(0.25 + (rangelim(m_time_brightness, 0.25,
-									 0.75) -
-									0.25) * 2 *
-										0.75);
-				pointcolor_sun_f.g =
-						pointcolor_light *
-						(pointcolor_sun_f.b * 0.375 +
-								(rangelim(m_time_brightness,
-										 0.05,
-										 0.15) -
-										0.05) *
-										10 *
-										0.625);
+				pointcolor_sun_f.b = pointcolor_light *
+					(0.25 + (rangelim(m_time_brightness, 0.25, 0.75) - 0.25) * 2 * 0.75);
+				pointcolor_sun_f.g = pointcolor_light * (pointcolor_sun_f.b * 0.375 +
+					(rangelim(m_time_brightness, 0.05, 0.15) - 0.05) * 10 * 0.625);
 			}
 
 			video::SColorf pointcolor_moon_f;
 			if (m_default_tint) {
-				pointcolor_moon_f = video::SColorf(0.5 * pointcolor_light,
-						0.6 * pointcolor_light,
-						0.8 * pointcolor_light, 1);
+				pointcolor_moon_f = video::SColorf(
+					0.5 * pointcolor_light,
+					0.6 * pointcolor_light,
+					0.8 * pointcolor_light,
+					1
+				);
 			} else {
 				pointcolor_moon_f = video::SColorf(
-						(m_sky_params.fog_moon_tint.getRed() /
-								255) *
-								pointcolor_light,
-						(m_sky_params.fog_moon_tint.getGreen() /
-								255) *
-								pointcolor_light,
-						(m_sky_params.fog_moon_tint.getBlue() /
-								255) *
-								pointcolor_light,
-						1);
+					(m_sky_params.fog_moon_tint.getRed() / 255) * pointcolor_light,
+					(m_sky_params.fog_moon_tint.getGreen() / 255) * pointcolor_light,
+					(m_sky_params.fog_moon_tint.getBlue() / 255) * pointcolor_light,
+					1
+				);
 			}
 			if (m_moon_tonemap && m_default_tint) {
-				pointcolor_moon_f.r =
-						pointcolor_light *
-						(float)m_materials[4]
-								.EmissiveColor.getRed() /
-						255;
-				pointcolor_moon_f.b =
-						pointcolor_light *
-						(float)m_materials[4]
-								.EmissiveColor.getBlue() /
-						255;
+				pointcolor_moon_f.r = pointcolor_light *
+					(float)m_materials[4].EmissiveColor.getRed() / 255;
+				pointcolor_moon_f.b = pointcolor_light *
+					(float)m_materials[4].EmissiveColor.getBlue() / 255;
 				pointcolor_moon_f.g = pointcolor_light *
-						      (float)m_materials[4]
-								      .EmissiveColor
-								      .getGreen() /
-						      255;
+					(float)m_materials[4].EmissiveColor.getGreen() / 255;
 			}
 
 			video::SColor pointcolor_sun = pointcolor_sun_f.toSColor();
 			video::SColor pointcolor_moon = pointcolor_moon_f.toSColor();
 			// Calculate the blend color
-			pointcolor = m_mix_scolor(pointcolor_moon, pointcolor_sun,
-					pointcolor_blend);
+			pointcolor = m_mix_scolor(pointcolor_moon, pointcolor_sun, pointcolor_blend);
 		}
 		m_bgcolor = m_mix_scolor(m_bgcolor, pointcolor, m_horizon_blend() * 0.5);
-		m_skycolor = m_mix_scolor(
-				m_skycolor, pointcolor, m_horizon_blend() * 0.25);
+		m_skycolor = m_mix_scolor(m_skycolor, pointcolor, m_horizon_blend() * 0.25);
 	}
 
 	float cloud_direct_brightness = 0.0f;
 	if (sunlight_seen) {
 		if (!m_directional_colored_fog) {
 			cloud_direct_brightness = time_brightness;
-			// Boost cloud brightness relative to sky, at dawn, dusk and at
-			// night
+			// Boost cloud brightness relative to sky, at dawn, dusk and at night
 			if (time_brightness < 0.7f)
 				cloud_direct_brightness *= 1.3f;
 		} else {
-			cloud_direct_brightness = std::fmin(
-					m_horizon_blend() * 0.15f + m_time_brightness,
-					1.0f);
+			cloud_direct_brightness = std::fmin(m_horizon_blend() * 0.15f +
+				m_time_brightness, 1.0f);
 			// Set the same minimum cloud brightness at night
 			if (time_brightness < 0.5f)
-				cloud_direct_brightness =
-						std::fmax(cloud_direct_brightness,
-								time_brightness * 1.3f);
+				cloud_direct_brightness = std::fmax(cloud_direct_brightness,
+					time_brightness * 1.3f);
 		}
 	} else {
 		cloud_direct_brightness = direct_brightness;
 	}
 
-	m_cloud_brightness =
-			m_cloud_brightness * cloud_color_change_fraction +
-			cloud_direct_brightness * (1.0 - cloud_color_change_fraction);
-	m_cloudcolor_f = video::SColorf(m_cloudcolor_bright_f.r * m_cloud_brightness,
-			m_cloudcolor_bright_f.g * m_cloud_brightness,
-			m_cloudcolor_bright_f.b * m_cloud_brightness, 1.0);
+	m_cloud_brightness = m_cloud_brightness * cloud_color_change_fraction +
+		cloud_direct_brightness * (1.0 - cloud_color_change_fraction);
+	m_cloudcolor_f = video::SColorf(
+		m_cloudcolor_bright_f.r * m_cloud_brightness,
+		m_cloudcolor_bright_f.g * m_cloud_brightness,
+		m_cloudcolor_bright_f.b * m_cloud_brightness,
+		1.0
+	);
 	if (m_directional_colored_fog) {
-		m_cloudcolor_f = m_mix_scolorf(m_cloudcolor_f, video::SColorf(pointcolor),
-				m_horizon_blend() * 0.25);
+		m_cloudcolor_f = m_mix_scolorf(m_cloudcolor_f,
+			video::SColorf(pointcolor), m_horizon_blend() * 0.25);
 	}
 }
 
-void Sky::draw_sun(video::IVideoDriver *driver, float sunsize,
-		const video::SColor &suncolor, const video::SColor &suncolor2,
-		float wicked_time_of_day)
-/* Draw sun in the sky.
- * driver: Video driver object used to draw
- * sunsize: the default size of the sun
- * suncolor: main sun color
- * suncolor2: second sun color
- * wicked_time_of_day: current time of day, to know where should be the sun in the sky
- */
+void Sky::draw_sun(video::IVideoDriver *driver, float sunsize, const video::SColor &suncolor,
+	const video::SColor &suncolor2, float wicked_time_of_day)
+	/* Draw sun in the sky.
+	 * driver: Video driver object used to draw
+	 * sunsize: the default size of the sun
+	 * suncolor: main sun color
+	 * suncolor2: second sun color
+	 * wicked_time_of_day: current time of day, to know where should be the sun in the sky
+	 */
 {
 	static const u16 indices[4] = {0, 1, 2, 3};
 	std::array<video::S3DVertex, 4> vertices;
 	if (!m_sun_texture) {
 		driver->setMaterial(m_materials[1]);
-		const float sunsizes[4] = {(sunsize * 1.7f) * m_sun_params.scale,
-				(sunsize * 1.2f) * m_sun_params.scale,
-				(sunsize)*m_sun_params.scale,
-				(sunsize * 0.7f) * m_sun_params.scale};
+		const float sunsizes[4] = {
+			(sunsize * 1.7f) * m_sun_params.scale,
+			(sunsize * 1.2f) * m_sun_params.scale,
+			(sunsize) * m_sun_params.scale,
+			(sunsize * 0.7f) * m_sun_params.scale
+		};
 		video::SColor c1 = suncolor;
 		video::SColor c2 = suncolor;
 		c1.setAlpha(0.05 * 255);
@@ -695,39 +624,42 @@ void Sky::draw_sun(video::IVideoDriver *driver, float sunsize,
 	}
 }
 
-void Sky::draw_moon(video::IVideoDriver *driver, float moonsize,
-		const video::SColor &mooncolor, const video::SColor &mooncolor2,
-		float wicked_time_of_day)
+
+void Sky::draw_moon(video::IVideoDriver *driver, float moonsize, const video::SColor &mooncolor,
+	const video::SColor &mooncolor2, float wicked_time_of_day)
 /*
- * Draw moon in the sky.
- * driver: Video driver object used to draw
- * moonsize: the default size of the moon
- * mooncolor: main moon color
- * mooncolor2: second moon color
- * wicked_time_of_day: current time of day, to know where should be the moon in
- * the sky
- */
+	* Draw moon in the sky.
+	* driver: Video driver object used to draw
+	* moonsize: the default size of the moon
+	* mooncolor: main moon color
+	* mooncolor2: second moon color
+	* wicked_time_of_day: current time of day, to know where should be the moon in
+	* the sky
+	*/
 {
 	static const u16 indices[4] = {0, 1, 2, 3};
 	std::array<video::S3DVertex, 4> vertices;
 	if (!m_moon_texture) {
 		driver->setMaterial(m_materials[1]);
-		const float moonsizes_1[4] = {(-moonsize * 1.9f) * m_moon_params.scale,
-				(-moonsize * 1.3f) * m_moon_params.scale,
-				(-moonsize) * m_moon_params.scale,
-				(-moonsize) * m_moon_params.scale};
-		const float moonsizes_2[4] = {(moonsize * 1.9f) * m_moon_params.scale,
-				(moonsize * 1.3f) * m_moon_params.scale,
-				(moonsize)*m_moon_params.scale,
-				(moonsize * 0.6f) * m_moon_params.scale};
+		const float moonsizes_1[4] = {
+			(-moonsize * 1.9f) * m_moon_params.scale,
+			(-moonsize * 1.3f) * m_moon_params.scale,
+			(-moonsize) * m_moon_params.scale,
+			(-moonsize) * m_moon_params.scale
+		};
+		const float moonsizes_2[4] = {
+			(moonsize * 1.9f) * m_moon_params.scale,
+			(moonsize * 1.3f) * m_moon_params.scale,
+			(moonsize) *m_moon_params.scale,
+			(moonsize * 0.6f) * m_moon_params.scale
+		};
 		video::SColor c1 = mooncolor;
 		video::SColor c2 = mooncolor;
 		c1.setAlpha(0.05 * 255);
 		c2.setAlpha(0.15 * 255);
 		const video::SColor colors[4] = {c1, c2, mooncolor, mooncolor2};
 		for (int i = 0; i < 4; i++) {
-			draw_sky_body(vertices, moonsizes_1[i], moonsizes_2[i],
-					colors[i]);
+			draw_sky_body(vertices, moonsizes_1[i], moonsizes_2[i], colors[i]);
 			place_sky_body(vertices, -90, wicked_time_of_day * 360 - 90);
 			driver->drawIndexedTriangleFan(&vertices[0], 4, indices, 2);
 		}
@@ -745,7 +677,7 @@ void Sky::draw_moon(video::IVideoDriver *driver, float moonsize,
 	}
 }
 
-void Sky::draw_stars(video::IVideoDriver *driver, float wicked_time_of_day)
+void Sky::draw_stars(video::IVideoDriver * driver, float wicked_time_of_day)
 {
 	driver->setMaterial(m_materials[1]);
 	// Tune values so that stars first appear just after the sun
@@ -754,8 +686,7 @@ void Sky::draw_stars(video::IVideoDriver *driver, float wicked_time_of_day)
 	// Also tune so that stars are at full brightness from time 20000
 	// to time 4000.
 
-	float tod = wicked_time_of_day < 0.5f ? wicked_time_of_day
-					      : (1.0f - wicked_time_of_day);
+	float tod = wicked_time_of_day < 0.5f ? wicked_time_of_day : (1.0f - wicked_time_of_day);
 	float starbrightness = clamp((0.25f - fabsf(tod)) * 20.0f, 0.0f, 1.0f);
 
 	float f = starbrightness;
@@ -769,7 +700,8 @@ void Sky::draw_stars(video::IVideoDriver *driver, float wicked_time_of_day)
 		return;
 #if ENABLE_GLES
 	u16 *indices = new u16[m_star_params.count * 3];
-	video::S3DVertex *vertices = new video::S3DVertex[m_star_params.count * 3];
+	video::S3DVertex *vertices =
+			new video::S3DVertex[m_star_params.count * 3];
 	for (u32 i = 0; i < m_star_params.count; i++) {
 		indices[i * 3 + 0] = i * 3 + 0;
 		indices[i * 3 + 1] = i * 3 + 1;
@@ -793,13 +725,14 @@ void Sky::draw_stars(video::IVideoDriver *driver, float wicked_time_of_day)
 		vertices[i * 3 + 2].Pos = p2;
 		vertices[i * 3 + 2].Color = starcolor;
 	}
-	driver->drawIndexedTriangleList(
-			vertices, m_star_params.count * 3, indices, m_star_params.count);
+	driver->drawIndexedTriangleList(vertices, m_star_params.count * 3,
+			indices, m_star_params.count);
 	delete[] indices;
 	delete[] vertices;
 #else
 	u16 *indices = new u16[m_star_params.count * 4];
-	video::S3DVertex *vertices = new video::S3DVertex[m_star_params.count * 4];
+	video::S3DVertex *vertices =
+			new video::S3DVertex[m_star_params.count * 4];
 	for (u32 i = 0; i < m_star_params.count; i++) {
 		indices[i * 4 + 0] = i * 4 + 0;
 		indices[i * 4 + 1] = i * 4 + 1;
@@ -829,22 +762,21 @@ void Sky::draw_stars(video::IVideoDriver *driver, float wicked_time_of_day)
 		vertices[i * 4 + 3].Pos = p3;
 		vertices[i * 4 + 3].Color = starcolor;
 	}
-	driver->drawVertexPrimitiveList(vertices, m_star_params.count * 4, indices,
-			m_star_params.count, video::EVT_STANDARD, scene::EPT_QUADS,
-			video::EIT_16BIT);
+	driver->drawVertexPrimitiveList(vertices, m_star_params.count * 4,
+			indices, m_star_params.count, video::EVT_STANDARD,
+			scene::EPT_QUADS, video::EIT_16BIT);
 	delete[] indices;
 	delete[] vertices;
 #endif
 }
 
-void Sky::draw_sky_body(std::array<video::S3DVertex, 4> &vertices, float pos_1,
-		float pos_2, const video::SColor &c)
+void Sky::draw_sky_body(std::array<video::S3DVertex, 4> &vertices, float pos_1, float pos_2, const video::SColor &c)
 {
 	/*
-	 * Create an array of vertices with the dimensions specified.
-	 * pos_1, pos_2: position of the body's vertices
-	 * c: color of the body
-	 */
+	* Create an array of vertices with the dimensions specified.
+	* pos_1, pos_2: position of the body's vertices
+	* c: color of the body
+	*/
 
 	const f32 t = 1.0f;
 	const f32 o = 0.0f;
@@ -854,15 +786,15 @@ void Sky::draw_sky_body(std::array<video::S3DVertex, 4> &vertices, float pos_1,
 	vertices[3] = video::S3DVertex(pos_1, pos_2, -1, 0, 0, 1, c, t, o);
 }
 
-void Sky::place_sky_body(std::array<video::S3DVertex, 4> &vertices,
-		float horizon_position, float day_position)
-/*
- * Place body in the sky.
- * vertices: The body as a rectangle of 4 vertices
- * horizon_position: turn the body around the Y axis
- * day_position: turn the body around the Z axis, to place it depending of the time of the
- * day
- */
+
+void Sky::place_sky_body(
+	std::array<video::S3DVertex, 4> &vertices, float horizon_position, float day_position)
+	/*
+	* Place body in the sky.
+	* vertices: The body as a rectangle of 4 vertices
+	* horizon_position: turn the body around the Y axis
+	* day_position: turn the body around the Z axis, to place it depending of the time of the day
+	*/
 {
 	for (video::S3DVertex &vertex : vertices) {
 		// Body is directed to -Z (south) by default
@@ -871,15 +803,14 @@ void Sky::place_sky_body(std::array<video::S3DVertex, 4> &vertices,
 	}
 }
 
-void Sky::setSunTexture(
-		std::string sun_texture, std::string sun_tonemap, ITextureSource *tsrc)
+void Sky::setSunTexture(std::string sun_texture,
+		std::string sun_tonemap, ITextureSource *tsrc)
 {
 	// Ignore matching textures (with modifiers) entirely,
 	// but lets at least update the tonemap before hand.
 	m_sun_params.tonemap = sun_tonemap;
-	m_sun_tonemap = tsrc->isKnownSourceImage(m_sun_params.tonemap)
-					? tsrc->getTexture(m_sun_params.tonemap)
-					: NULL;
+	m_sun_tonemap = tsrc->isKnownSourceImage(m_sun_params.tonemap) ?
+		tsrc->getTexture(m_sun_params.tonemap) : NULL;
 	m_materials[3].Lighting = !!m_sun_tonemap;
 
 	if (m_sun_params.texture == sun_texture)
@@ -893,45 +824,41 @@ void Sky::setSunTexture(
 		if (m_sun_texture) {
 			m_materials[3] = m_materials[0];
 			m_materials[3].setTexture(0, m_sun_texture);
-			m_materials[3].MaterialType =
-					video::EMT_TRANSPARENT_ALPHA_CHANNEL;
+			m_materials[3].MaterialType = video::
+				EMT_TRANSPARENT_ALPHA_CHANNEL;
 			// Disables texture filtering
 			m_materials[3].setFlag(
-					video::E_MATERIAL_FLAG::EMF_BILINEAR_FILTER,
-					false);
+				video::E_MATERIAL_FLAG::EMF_BILINEAR_FILTER, false);
 			m_materials[3].setFlag(
-					video::E_MATERIAL_FLAG::EMF_TRILINEAR_FILTER,
-					false);
+				video::E_MATERIAL_FLAG::EMF_TRILINEAR_FILTER, false);
 			m_materials[3].setFlag(
-					video::E_MATERIAL_FLAG::EMF_ANISOTROPIC_FILTER,
-					false);
+				video::E_MATERIAL_FLAG::EMF_ANISOTROPIC_FILTER, false);
 		}
 	} else {
 		m_sun_texture = nullptr;
 	}
 }
 
-void Sky::setSunriseTexture(std::string sunglow_texture, ITextureSource *tsrc)
+void Sky::setSunriseTexture(std::string sunglow_texture,
+		ITextureSource* tsrc)
 {
 	// Ignore matching textures (with modifiers) entirely.
 	if (m_sun_params.sunrise == sunglow_texture)
 		return;
 	m_sun_params.sunrise = sunglow_texture;
-	m_materials[2].setTexture(
-			0, tsrc->getTextureForMesh(sunglow_texture.empty()
-								   ? "sunrisebg.png"
-								   : sunglow_texture));
+	m_materials[2].setTexture(0, tsrc->getTextureForMesh(
+		sunglow_texture.empty() ? "sunrisebg.png" : sunglow_texture)
+	);
 }
 
-void Sky::setMoonTexture(
-		std::string moon_texture, std::string moon_tonemap, ITextureSource *tsrc)
+void Sky::setMoonTexture(std::string moon_texture,
+		std::string moon_tonemap, ITextureSource *tsrc)
 {
 	// Ignore matching textures (with modifiers) entirely,
 	// but lets at least update the tonemap before hand.
 	m_moon_params.tonemap = moon_tonemap;
-	m_moon_tonemap = tsrc->isKnownSourceImage(m_moon_params.tonemap)
-					 ? tsrc->getTexture(m_moon_params.tonemap)
-					 : NULL;
+	m_moon_tonemap = tsrc->isKnownSourceImage(m_moon_params.tonemap) ?
+		tsrc->getTexture(m_moon_params.tonemap) : NULL;
 	m_materials[4].Lighting = !!m_moon_tonemap;
 
 	if (m_moon_params.texture == moon_texture)
@@ -945,18 +872,15 @@ void Sky::setMoonTexture(
 		if (m_moon_texture) {
 			m_materials[4] = m_materials[0];
 			m_materials[4].setTexture(0, m_moon_texture);
-			m_materials[4].MaterialType =
-					video::EMT_TRANSPARENT_ALPHA_CHANNEL;
+			m_materials[4].MaterialType = video::
+				EMT_TRANSPARENT_ALPHA_CHANNEL;
 			// Disables texture filtering
 			m_materials[4].setFlag(
-					video::E_MATERIAL_FLAG::EMF_BILINEAR_FILTER,
-					false);
+				video::E_MATERIAL_FLAG::EMF_BILINEAR_FILTER, false);
 			m_materials[4].setFlag(
-					video::E_MATERIAL_FLAG::EMF_TRILINEAR_FILTER,
-					false);
+				video::E_MATERIAL_FLAG::EMF_TRILINEAR_FILTER, false);
 			m_materials[4].setFlag(
-					video::E_MATERIAL_FLAG::EMF_ANISOTROPIC_FILTER,
-					false);
+				video::E_MATERIAL_FLAG::EMF_ANISOTROPIC_FILTER, false);
 		}
 	} else {
 		m_moon_texture = nullptr;
@@ -971,9 +895,11 @@ void Sky::setStarCount(u16 star_count, bool force_update)
 		m_stars.clear();
 		// Rebuild the stars surrounding the camera
 		for (u16 i = 0; i < star_count; i++) {
-			v3f star = v3f(myrand_range(-10000, 10000),
-					myrand_range(-10000, 10000),
-					myrand_range(-10000, 10000));
+			v3f star = v3f(
+				myrand_range(-10000, 10000),
+				myrand_range(-10000, 10000),
+				myrand_range(-10000, 10000)
+			);
 
 			star.normalize();
 			m_stars.emplace_back(star);
@@ -986,8 +912,8 @@ void Sky::setSkyColors(const SkyColor &sky_color)
 	m_sky_params.sky_color = sky_color;
 }
 
-void Sky::setHorizonTint(
-		video::SColor sun_tint, video::SColor moon_tint, std::string use_sun_tint)
+void Sky::setHorizonTint(video::SColor sun_tint, video::SColor moon_tint,
+		std::string use_sun_tint)
 {
 	// Change sun and moon tinting:
 	m_sky_params.fog_sun_tint = sun_tint;
@@ -1001,7 +927,8 @@ void Sky::setHorizonTint(
 		m_default_tint = true;
 }
 
-void Sky::addTextureToSkybox(std::string texture, int material_id, ITextureSource *tsrc)
+void Sky::addTextureToSkybox(std::string texture, int material_id,
+		ITextureSource *tsrc)
 {
 	// Sanity check for more than six textures.
 	if (material_id + 5 >= SKY_MATERIAL_COUNT)
@@ -1009,9 +936,9 @@ void Sky::addTextureToSkybox(std::string texture, int material_id, ITextureSourc
 	// Keep a list of texture names handy.
 	m_sky_params.textures.emplace_back(texture);
 	video::ITexture *result = tsrc->getTextureForMesh(texture);
-	m_materials[material_id + 5] = m_materials[0];
-	m_materials[material_id + 5].setTexture(0, result);
-	m_materials[material_id + 5].MaterialType = video::EMT_SOLID;
+	m_materials[material_id+5] = m_materials[0];
+	m_materials[material_id+5].setTexture(0, result);
+	m_materials[material_id+5].MaterialType = video::EMT_SOLID;
 }
 
 // To be called once at game init to setup default values.
-- 
cgit v1.2.3