Isometric-view

Fixed Missing Lighting calls and GL states which was causing stars to render too early

Split Controls should hopefully work on phones now

Chickens should hopefully lay eggs now

CMakeLists.txt

@@ -312,6 +312,7 @@ if(UNIX)
     target_compile_definitions("${PROJECT_NAME}-server" PUBLIC "STANDALONE_SERVER" "SERVER_PROFILER")
 
     target_include_directories("${PROJECT_NAME}-server" PUBLIC 
+        "${CMAKE_SOURCE_DIR}/glad/include/"
         "${CMAKE_SOURCE_DIR}/src/"
         "project/lib_projects/raknet/jni/RaknetSources"
     )

data/lang/en_US.lang

@@ -161,6 +161,18 @@ options.fogType.vanilla=Vanilla
 options.fogType.java=Beta Java
 options.fogType.unused=Unused
 
+options.debugStyle=Debug Menu Style
+options.debugStyle.javaBeta=Java Beta
+options.debugStyle.custom=Custom
+
+options.beautifulSky=Beautiful Skies
+
+options.useVignette=Vignette Overlay
+
+options.tintedSide=Tint Grass Sides
+
+options.betaSky=Java Beta Sky
+
 options.restoredAnims=Restored Animations
 
 options.normalLighting=Java Beta/Normals Shading
@@ -217,6 +229,12 @@ options.fancyGraphics=Fancy graphics
 options.renderDebug=Debug render
 options.anaglyph3d=3D anaglyph
 
+options.windowScale =Window Scaling
+
+options.menuStyle =Menu Style 
+options.menuStyle.pocket =Pocket Edition
+options.menuStyle.xperia =Xperia/Pi
+options.menuStyle.java =Java Beta
 
 performance.max=Max FPS
 performance.balanced=Balanced

src/client/Minecraft.cpp

@@ -8,12 +8,13 @@
 #include <string>
 #include <cstdlib>
 
+
 #if defined(APPLE_DEMO_PROMOTION)
-    #define NO_NETWORK
+#define NO_NETWORK
 #endif
 
 #if defined(RPI)
-	#define CREATORMODE
+#define CREATORMODE
 #endif
 #include "../network/RakNetInstance.h"
 #include "../network/ClientSideNetworkHandler.h"
@@ -91,11 +92,14 @@
 #include "gamemode/CreatorMode.h"
 
 #include "../world/level/GrassColor.h"
+#include "renderer/LevelRenderer.h"
+#include "particle/ParticleEngine.h"
+#include "../world/level/Level.h"
 static void checkGlError(const char* tag) {
 #ifdef GLDEBUG
 	while (1) {
-        const int errCode = glGetError();
-        if (errCode == GL_NO_ERROR) break;
+		const int errCode = glGetError();
+		if (errCode == GL_NO_ERROR) break;
 
 		LOGE("################\nOpenGL-error @ %s : #%d\n", tag, errCode);
 	}
@@ -113,7 +117,7 @@ const char* Minecraft::progressMessages[] = {
 int Minecraft::customDebugId = Minecraft::CDI_NONE;
 
 #if defined(_MSC_VER)
-	#pragma warning( disable : 4355 ) // 'this' pointer in initialization list which is perfectly legal
+#pragma warning( disable : 4355 ) // 'this' pointer in initialization list which is perfectly legal
 #endif
 
 bool Minecraft::useAmbientOcclusion = false;
@@ -171,17 +175,17 @@ Minecraft::Minecraft() :
 	width(1), height(1),
 	//_respawnPlayerTicks(-1),
 #ifdef __APPLE__
-    _isSuperFast(false),
+	_isSuperFast(false),
 #endif
 	_powerVr(false),
 	commandPort(4711),
 	reserved_d1(0),reserved_d2(0),
 	reserved_f1(0),reserved_f2(0), options(this)
 {
-//#ifdef ANDROID
+	//#ifdef ANDROID
 
 #if defined(NO_NETWORK)
-    raknetInstance = new IRakNetInstance();
+	raknetInstance = new IRakNetInstance();
 #else
 	raknetInstance = new RakNetInstance();
 #endif
@@ -261,7 +265,7 @@ void Minecraft::setLevel(Level* level, const std::string& message /* ="" */, Loc
 
 	if (level != NULL) {
 		level->raknetInstance = raknetInstance;
-        gameMode->initLevel(level);
+		gameMode->initLevel(level);
 
 		if (!player && forceInsertPlayer)
 		{
@@ -292,19 +296,19 @@ void Minecraft::setLevel(Level* level, const std::string& message /* ="" */, Loc
 			// Non-threaded
 			generateLevel("Currently not used", level);
 		}
-    } else {
-        player = NULL;
-    }
+	} else {
+		player = NULL;
+	}
 
-    this->lastTickTime = 0;
+	this->lastTickTime = 0;
 	this->_running = true;
 }
 
 void Minecraft::leaveGame(bool renameLevel /*=false*/)
 {
-    if (isGeneratingLevel || !_hasSignaledGeneratingLevelFinished)
-        return;
-    
+	if (isGeneratingLevel || !_hasSignaledGeneratingLevelFinished)
+		return;
+
 	isGeneratingLevel = false;
 	bool saveLevel = level && (!level->isClientSide || renameLevel);
 
@@ -362,19 +366,19 @@ void Minecraft::prepareLevel(const std::string& title) {
 	int Max = CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
 	int pp = 0;
 	for (int x = 8; x < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); x += CHUNK_WIDTH) {
-        for (int z = 8; z < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); z += CHUNK_WIDTH) {
-            progressStagePercentage = 100 * pp++ / Max;
-            //printf("level generation progress %d\n", progressStagePercentage);
+		for (int z = 8; z < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); z += CHUNK_WIDTH) {
+			progressStagePercentage = 100 * pp++ / Max;
+			//printf("level generation progress %d\n", progressStagePercentage);
 			B.start();
-            level->getTile(x, 64, z);
+			level->getTile(x, 64, z);
 			B.stop();
 			L.start();
 			if (level->isNew())
 				while (level->updateLights())
 					;
 			L.stop();
-        }
-    }
+		}
+	}
 	A.stop();
 	level->setUpdateLights(true);
 
@@ -462,32 +466,33 @@ void Minecraft::update() {
 	}
 	TIMER_POP();
 
-	#ifndef STANDALONE_SERVER
-		if (gameMode != NULL) gameMode->render(timer.a);
-		TIMER_PUSH("sound");
-		soundEngine->update(player, timer.a);
-		TIMER_POP_PUSH("render");
-		gameRenderer->render(timer.a);
-		TIMER_POP();
-	#else
+#ifndef STANDALONE_SERVER
+	if (gameMode != NULL) gameMode->render(timer.a);
+	TIMER_PUSH("sound");
+	soundEngine->update(player, timer.a);
+	TIMER_POP_PUSH("render");
+	gameRenderer->render(timer.a);
+	TIMER_POP();
+#else
 	CThread::sleep(1);
-	#endif
+#endif
 #ifndef STANDALONE_SERVER
 	Multitouch::resetThisUpdate();
 #endif
-	TIMER_POP();
+
 #ifndef STANDALONE_SERVER
+	TIMER_POP();
 	checkGlError("Update finished");
 
 	if (options.getBooleanValue(OPTIONS_RENDER_DEBUG)) {
-#ifndef PLATFORM_DESKTOP
+		//#ifndef PLATFORM_DESKTOP
 		if (!PerfTimer::enabled) {
 			PerfTimer::reset();
 			PerfTimer::enabled = true;
 		}
 		_perfRenderer->renderFpsMeter(1);
 		checkGlError("render debug");
-#endif
+		//#endif
 	} else {
 		PerfTimer::enabled = false;
 	}
@@ -564,17 +569,17 @@ void Minecraft::tick(int nTick, int maxTick) {
 #ifndef STANDALONE_SERVER
 	textures->loadAndBindTexture("terrain.png");
 	if (!pause && !(screen && !screen->renderGameBehind())) {
-		#if !defined(RPI)
-			#ifdef __APPLE__
-			if (isSuperFast())
-			#endif
-			{
+#if !defined(RPI)
+#ifdef __APPLE__
+		if (isSuperFast())
+#endif
+		{
 			if (nTick == maxTick) {
 				TIMER_POP_PUSH("textures");
 				textures->tick(true);
 			}
-			}
-		#endif
+		}
+#endif
 	}
 	TIMER_POP_PUSH("particles");
 	if (!pause) {
@@ -636,8 +641,8 @@ void Minecraft::tickInput() {
 	while (Mouse::next()) {
 		//if (Mouse::getButtonState(MouseAction::ACTION_LEFT))
 		//	LOGI("mouse-down-at: %d, %d\n", Mouse::getX(), Mouse::getY());
-        	int passedTime = getTimeMs() - lastTickTime;
-        	if (passedTime > 200) continue; // @note: As long Mouse::clear CLEARS the whole buffer, it's safe to break here
+		int passedTime = getTimeMs() - lastTickTime;
+		if (passedTime > 200) continue; // @note: As long Mouse::clear CLEARS the whole buffer, it's safe to break here
 		// But since it might be rewritten anyway (and hopefully there aren't a lot of messages, we just continue.
 
 		const MouseAction& e = Mouse::getEvent();
@@ -668,14 +673,14 @@ void Minecraft::tickInput() {
 		}
 		/*
 		if (mouseDiggable && options.useMouseForDigging) {
-			if (Mouse::getEventButton() == MouseAction::ACTION_LEFT && Mouse::getEventButtonState()) {
-				handleMouseClick(MouseAction::ACTION_LEFT);
-				lastClickTick = ticks;
-			}
-			if (Mouse::getEventButton() == MouseAction::ACTION_RIGHT && Mouse::getEventButtonState()) {
-				handleMouseClick(MouseAction::ACTION_RIGHT);
-				lastClickTick = ticks;
-			}
+		if (Mouse::getEventButton() == MouseAction::ACTION_LEFT && Mouse::getEventButtonState()) {
+		handleMouseClick(MouseAction::ACTION_LEFT);
+		lastClickTick = ticks;
+		}
+		if (Mouse::getEventButton() == MouseAction::ACTION_RIGHT && Mouse::getEventButtonState()) {
+		handleMouseClick(MouseAction::ACTION_RIGHT);
+		lastClickTick = ticks;
+		}
 		}
 		*/
 	}
@@ -696,20 +701,20 @@ void Minecraft::tickInput() {
 				if (slot >= 0 && slot < gui.getNumSlots())
 					player->inventory->selectSlot(slot);
 
-				#if defined(WIN32)
-					if (digit >= 1 && GetAsyncKeyState(VK_CONTROL) < 0) {
-						// Set adventure settings here!
-						AdventureSettingsPacket p(level->adventureSettings);
-						p.toggle((AdventureSettingsPacket::Flags)(1 << slot));
-						p.fillIn(level->adventureSettings);
-						raknetInstance->send(p);
-					}
-					if (digit == 0) {
-						Pos pos((int)player->x, (int)player->y-1, (int)player->z);
-						SetSpawnPositionPacket p(pos);
-						raknetInstance->send(p);
-					}
-				#endif
+#if defined(WIN32)
+				if (digit >= 1 && GetAsyncKeyState(VK_CONTROL) < 0) {
+					// Set adventure settings here!
+					AdventureSettingsPacket p(level->adventureSettings);
+					p.toggle((AdventureSettingsPacket::Flags)(1 << slot));
+					p.fillIn(level->adventureSettings);
+					raknetInstance->send(p);
+				}
+				if (digit == 0) {
+					Pos pos((int)player->x, (int)player->y-1, (int)player->z);
+					SetSpawnPositionPacket p(pos);
+					raknetInstance->send(p);
+				}
+#endif
 			}
 
 			if (key == Keyboard::KEY_LEFT_CTRL) {
@@ -733,7 +738,7 @@ void Minecraft::tickInput() {
 				/*
 				ImprovedNoise noise;
 				for (int i = 0; i < 16; ++i)
-					printf("%d\t%f\n", i, noise.grad2(i, 3, 8));
+				printf("%d\t%f\n", i, noise.grad2(i, 3, 8));
 				*/
 			}
 
@@ -746,119 +751,127 @@ void Minecraft::tickInput() {
 				options.set(OPTIONS_VIEW_DISTANCE, (dst + 1) % 4);
 			}
 
-			#ifdef CHEATS
-				if (key == Keyboard::KEY_U) {
-					onGraphicsReset();
-					player->heal(100);
+#ifdef CHEATS
+			if (key == Keyboard::KEY_U) {
+				onGraphicsReset();
+				player->heal(100);
+			}
+
+			if (key == Keyboard::KEY_B || key == 108) // Toggle the game mode
+				setIsCreativeMode(!isCreativeMode());
+
+			if (key == Keyboard::KEY_P) // Step forward in time
+				level->setTime( level->getTime() + 1000);
+
+			if (key == Keyboard::KEY_G) {
+				setScreen(new ArmorScreen());
+				/*
+				std::vector<AABB>& boxs = level->getCubes(NULL, AABB(128.1f, 73, 128.1f, 128.9f, 74.9f, 128.9f));
+				LOGI("boxes: %d\n", (int)boxs.size());
+				*/
+			}
+
+			if (key == Keyboard::KEY_Y) {
+				textures->reloadAll();
+				player->hurtTo(2);
+			}
+			if (key == Keyboard::KEY_Z || key == 108) {
+				for (int i = 0; i < 1; ++i) {
+					Mob* mob = NULL;
+					int forceId = 0;//MobTypes::Sheep;
+
+					int types[] = {
+						MobTypes::Sheep,
+						MobTypes::Pig,
+						MobTypes::Chicken,
+						MobTypes::Cow,
+					};
+
+					int mobType = (forceId > 0)? forceId : types[Mth::random(sizeof(types) / sizeof(int))];
+					mob = MobFactory::CreateMob(mobType, level);
+
+					//((Animal*)mob)->setAge(-1000);
+					float dx = 4 - 8 * Mth::random() + 4 * Mth::sin(Mth::DEGRAD * player->yRot);
+					float dz = 4 - 8 * Mth::random() + 4 * Mth::cos(Mth::DEGRAD * player->yRot);
+					if (mob && !MobSpawner::addMob(level, mob, player->x + dx, player->y, player->z + dz, Mth::random()*360, 0, true))
+						delete mob;
 				}
+			}
 
-				if (key == Keyboard::KEY_B || key == 108) // Toggle the game mode
-					setIsCreativeMode(!isCreativeMode());
-
-				if (key == Keyboard::KEY_P) // Step forward in time
-					level->setTime( level->getTime() + 1000);
-
-				if (key == Keyboard::KEY_G) {
-					setScreen(new ArmorScreen());
-					/*
-					std::vector<AABB>& boxs = level->getCubes(NULL, AABB(128.1f, 73, 128.1f, 128.9f, 74.9f, 128.9f));
-					LOGI("boxes: %d\n", (int)boxs.size());
-					*/
+			if (key == Keyboard::KEY_X) {
+				const EntityList& entities = level->getAllEntities();
+				for (int i = entities.size()-1; i >= 0; --i) {
+					Entity* e = entities[i];
+					if (!e->isPlayer())
+						level->removeEntity(e);
 				}
+			}
 
-				if (key == Keyboard::KEY_Y) {
-					textures->reloadAll();
-					player->hurtTo(2);
-				}
-				if (key == Keyboard::KEY_Z || key == 108) {
-					for (int i = 0; i < 1; ++i) {
-						Mob* mob = NULL;
-						int forceId = 0;//MobTypes::Sheep;
+			if (key == Keyboard::KEY_C /*|| key == 4*/) {
+				player->inventory->clearInventoryWithDefault();
+				// @todo: Add saving here for benchmarking
+			}
+			if (key == Keyboard::KEY_H) {
+				setScreen( new PrerenderTilesScreen() );
+			}
 
-						int types[] = {
-							MobTypes::Sheep,
-							MobTypes::Pig,
-							MobTypes::Chicken,
-							MobTypes::Cow,
-						};
+			if (key == Keyboard::KEY_O) {
+				for (int i = Inventory::MAX_SELECTION_SIZE; i < player->inventory->getContainerSize(); ++i)
+					if (player->inventory->getItem(i))
+						player->inventory->dropSlot(i, false);
+			}
+			if (key == Keyboard::KEY_M) {
+				Difficulty difficulty = (Difficulty)options.getIntValue(OPTIONS_DIFFICULTY);
+				options.set(OPTIONS_DIFFICULTY, (difficulty == Difficulty::PEACEFUL)?
+					Difficulty::NORMAL : Difficulty::PEACEFUL);
+				//setIsCreativeMode( !isCreativeMode() );
+			}
 
-						int mobType = (forceId > 0)? forceId : types[Mth::random(sizeof(types) / sizeof(int))];
-						mob = MobFactory::CreateMob(mobType, level);
+			if (options.getBooleanValue(OPTIONS_RENDER_DEBUG)) {
+				if (key >= '0' && key <= '9') {
+					_perfRenderer->debugFpsMeterKeyPress(key - '0');
+				}
+			}
+#endif
 
-						//((Animal*)mob)->setAge(-1000);
-						float dx = 4 - 8 * Mth::random() + 4 * Mth::sin(Mth::DEGRAD * player->yRot);
-						float dz = 4 - 8 * Mth::random() + 4 * Mth::cos(Mth::DEGRAD * player->yRot);
-						if (mob && !MobSpawner::addMob(level, mob, player->x + dx, player->y, player->z + dz, Mth::random()*360, 0, true))
-							delete mob;
-					}
+			if (options.getBooleanValue(OPTIONS_RENDER_DEBUG)) {
+				if (key >= '0' && key <= '9') {
+					_perfRenderer->debugFpsMeterKeyPress(key - '0');
 				}
-
-				if (key == Keyboard::KEY_X) {
-					const EntityList& entities = level->getAllEntities();
-					for (int i = entities.size()-1; i >= 0; --i) {
-						Entity* e = entities[i];
-						if (!e->isPlayer())
-							level->removeEntity(e);
-					}
-				}
-
-				if (key == Keyboard::KEY_C /*|| key == 4*/) {
-					player->inventory->clearInventoryWithDefault();
-					// @todo: Add saving here for benchmarking
-				}
-				if (key == Keyboard::KEY_H) {
-					setScreen( new PrerenderTilesScreen() );
-				}
-
-				if (key == Keyboard::KEY_O) {
-					for (int i = Inventory::MAX_SELECTION_SIZE; i < player->inventory->getContainerSize(); ++i)
-						if (player->inventory->getItem(i))
-							player->inventory->dropSlot(i, false);
-				}
-				if (key == Keyboard::KEY_M) {
-					Difficulty difficulty = (Difficulty)options.getIntValue(OPTIONS_DIFFICULTY);
-					options.set(OPTIONS_DIFFICULTY, (difficulty == Difficulty::PEACEFUL)?
-						Difficulty::NORMAL : Difficulty::PEACEFUL);
-					//setIsCreativeMode( !isCreativeMode() );
-				}
-
-				if (options.getBooleanValue(OPTIONS_RENDER_DEBUG)) {
-					if (key >= '0' && key <= '9') {
-						_perfRenderer->debugFpsMeterKeyPress(key - '0');
-					}
-				}
-			#endif
+			}
 
 			if (key == Keyboard::KEY_ESCAPE)
 				pauseGame(false);
 
-			#ifndef OPENGL_ES
-				if (key == Keyboard::KEY_P) {
-					static bool isWireFrame = false;
-					isWireFrame = !isWireFrame;
-					glPolygonMode(GL_FRONT, isWireFrame? GL_LINE : GL_FILL);
-					//glPolygonMode(GL_BACK, isWireFrame? GL_LINE : GL_FILL);
-				}
-			#endif
-		}
-		#ifdef WIN32
-			if (key == Keyboard::KEY_M) {
-				for (int i = 0; i < 5 * SharedConstants::TicksPerSecond; ++i)
-					level->tick();
+#ifdef PLATFORM_DESKTOP
+			if (key == Keyboard::KEY_P) {
+				static bool isWireFrame = false;
+				isWireFrame = !isWireFrame;
+				glPolygonMode(GL_FRONT, isWireFrame? GL_LINE : GL_FILL);
+				//glPolygonMode(GL_BACK, isWireFrame? GL_LINE : GL_FILL);
 			}
-		#endif
+#endif
+		}
+#ifdef WIN32
+		if (key == Keyboard::KEY_M) {
+			for (int i = 0; i < 5 * SharedConstants::TicksPerSecond; ++i)
+				level->tick();
+		}
+#endif
 	}
 
 	TIMER_POP_PUSH("handlemouse");
-	
+
 	static bool prevMouseDownLeft = false;
 
-	if (Mouse::getButtonState(MouseAction::ACTION_LEFT) == 0) {
-		gameMode->stopDestroyBlock();
-	}
+	if (!useTouchscreen()) {
+		if (Mouse::getButtonState(MouseAction::ACTION_LEFT) == 0) {
+			gameMode->stopDestroyBlock();
+		}
 
-	if (!Mouse::isButtonDown(MouseAction::ACTION_RIGHT)) {
-		gameMode->releaseUsingItem(player);
+		if (!Mouse::isButtonDown(MouseAction::ACTION_RIGHT)) {
+			gameMode->releaseUsingItem(player);
+		}
 	}
 
 	if (useTouchscreen()) {
@@ -921,35 +934,35 @@ void Minecraft::handleBuildAction(BuildActionIntention* action) {
 	}
 	if(player->isUsingItem())
 		return;
-    bool mayUse = true;
+	bool mayUse = true;
 
 	if (!hitResult.isHit()) {
 		if (action->isRemove() && !gameMode->isCreativeType()) {
 			missTime = 10;
 		}
-    } else if (hitResult.type == ENTITY) {
-        if (action->isAttack()) {
+	} else if (hitResult.type == ENTITY) {
+		if (action->isAttack()) {
 			player->swing();
 			//LOGI("attacking!\n");
 			InteractPacket packet(InteractPacket::Attack, player->entityId, hitResult.entity->entityId);
 			raknetInstance->send(packet);
-            gameMode->attack(player, hitResult.entity);
+			gameMode->attack(player, hitResult.entity);
 		} else if (action->isInteract()) {
 			if (hitResult.entity->interactPreventDefault())
 				mayUse = false;
 			//LOGI("interacting!\n");
 			InteractPacket packet(InteractPacket::Interact, player->entityId, hitResult.entity->entityId);
 			raknetInstance->send(packet);
-            gameMode->interact(player, hitResult.entity);
-        }
-    } else if (hitResult.type == TILE) {
+			gameMode->interact(player, hitResult.entity);
+		}
+	} else if (hitResult.type == TILE) {
 		int x = hitResult.x;
-        int y = hitResult.y;
-        int z = hitResult.z;
-        int face = hitResult.f;
+		int y = hitResult.y;
+		int z = hitResult.z;
+		int face = hitResult.f;
 
 		int oldTileId = level->getTile(x, y, z);
-        Tile* oldTile = Tile::tiles[oldTileId];
+		Tile* oldTile = Tile::tiles[oldTileId];
 
 		//bool tryDestroyBlock = false;
 
@@ -958,8 +971,8 @@ void Minecraft::handleBuildAction(BuildActionIntention* action) {
 				return;
 
 			//LOGI("tile: %s - %d, %d, %d. b: %f - %f\n", oldTile->getDescriptionId().c_str(), x, y, z, oldTile->getBrightness(level, x, y, z), oldTile->getBrightness(level, x, y+1, z));
-            level->extinguishFire(x, y, z, hitResult.f);
-			
+			level->extinguishFire(x, y, z, hitResult.f);
+
 			if (action->isFirstRemove()) {
 				gameMode->startDestroyBlock(x, y, z, hitResult.f);
 			} else {
@@ -968,16 +981,16 @@ void Minecraft::handleBuildAction(BuildActionIntention* action) {
 
 			particleEngine->crack(x, y, z, hitResult.f);
 			player->swing();
-        }
+		}
 		else {
 			ItemInstance* item = player->inventory->getSelected();
- 			if (gameMode->useItemOn(player, level, item, x, y, z, face, hitResult.pos)) {
-			    mayUse = false;
-			    player->swing();
-			#ifdef RPI
-				} else if (item && item->id == ((Item*)Item::sword_iron)->id) {
-					player->swing();
-			#endif
+			if (gameMode->useItemOn(player, level, item, x, y, z, face, hitResult.pos)) {
+				mayUse = false;
+				player->swing();
+#ifdef RPI
+			} else if (item && item->id == ((Item*)Item::sword_iron)->id) {
+				player->swing();
+#endif
 			}
 			if (item && item->count <= 0) {
 				player->inventory->clearSlot(player->inventory->selected);
@@ -1003,7 +1016,7 @@ void Minecraft::handleBuildAction(BuildActionIntention* action) {
 
 bool Minecraft::isOnlineClient()
 {
-    return (level != NULL && level->isClientSide);
+	return (level != NULL && level->isClientSide);
 }
 
 bool Minecraft::isOnline()
@@ -1070,8 +1083,8 @@ void Minecraft::setScreen( Screen* screen )
 
 		if (screen->isInGameScreen() && level) {
 			level->saveLevelData();
-            level->saveGame();
-        }
+			level->saveGame();
+		}
 
 		//noRender = false;
 	} else {
@@ -1108,7 +1121,7 @@ void Minecraft::releaseMouse()
 
 bool Minecraft::useTouchscreen() {
 #if defined(TARGET_OS_IPHONE)
-    return true;
+	return true;
 #elif defined(RPI)
 	return false;
 #endif
@@ -1131,7 +1144,8 @@ void Minecraft::init()
 	textures->addDynamicTexture(new WaterSideTexture());
 	textures->addDynamicTexture(new LavaTexture());
 	textures->addDynamicTexture(new LavaSideTexture());
-	textures->addDynamicTexture(new FireTexture());
+	textures->addDynamicTexture(new FireTexture(0));
+	textures->addDynamicTexture(new FireTexture(1));
 	gui.texturesLoaded(textures);
 
 	levelRenderer = new LevelRenderer(this);
@@ -1139,7 +1153,7 @@ void Minecraft::init()
 	particleEngine = new ParticleEngine(level, textures);
 
 	// 4j's code for reference
-//	FoliageColor::init(textures->loadTexturePixels(L"misc/foliagecolor.png"));
+	//	FoliageColor::init(textures->loadTexturePixels(L"misc/foliagecolor.png"));
 
 
 	// my code
@@ -1148,14 +1162,18 @@ void Minecraft::init()
 	// now i can finally initialize foliage color, probably not the best way to handle this but i cant be arsed rn
 	FoliageColor::init(foliagePixels);
 
-	TextureId grassId = (textures->loadTexture("misc/foliagecolor.png")); // loading the uh png for foliage color
-	int* grassPixels = textures->loadTexturePixels(grassId, "misc/foliagecolor.png");
+	TextureId grassId = (textures->loadTexture("misc/grasscolor.png")); // loading the uh png for foliage color
+	int* grassPixels = textures->loadTexturePixels(grassId, "misc/grasscolor.png");
 	GrassColor::init(grassPixels);
-	
+
 	bool tint = options.getBooleanValue(OPTIONS_FOLIAGE_TINT); // finally, toggleable foliage color
 	FoliageColor::setUseTint(tint);
 	GrassColor::setUseTint(tint);
 
+	bool sideTint = options.getBooleanValue(OPTIONS_TINTED_SIDE);
+	TileRenderer::setUseTint(sideTint);
+
+
 	// Platform specific initialization here
 	font = new Font(&options, "font/default8.png", textures);
 
@@ -1172,59 +1190,82 @@ void Minecraft::init()
 
 void Minecraft::setSize(int w, int h) {
 #ifndef STANDALONE_SERVER
-    transformResolution(&w, &h);
+	transformResolution(&w, &h);
 
 	width  = w;
 	height = h;
-
-	int guiScale = options.getIntValue(OPTIONS_GUI_SCALE);
-
-	// determine gui scale, optionally overriding auto
-	if (guiScale != 0) {
-		// manual selection: 1->small, 2->medium, 3->large, 4->larger, 5->largest
-		switch (guiScale) {
-		case 1: Gui::GuiScale = 2.0f; break;
-		case 2: Gui::GuiScale = 3.0f; break;
-		case 3: Gui::GuiScale = 4.0f; break;
-		case 4: Gui::GuiScale = 5.0f; break;
-		case 5: Gui::GuiScale = 6.0f; break;
-		default: Gui::GuiScale = 1.0f; break; // auto
+	int screenWidth;
+	int screenHeight;
+	//#ifdef PLATFORM_DESKTOP
+	if (options.getBooleanValue(OPTIONS_WINDOW_SCALE)){ // scales with resolution using a formula instead of having hardcoded if checks
+		int guiScale = options.getIntValue(OPTIONS_GUI_SCALE);
+		if (guiScale == 0) {
+			guiScale = 1000;
 		}
+
+		// determine gui scale, optionally overriding auto
+
+
+		Gui::GuiScale = (float)Mth::Min(guiScale, Mth::Max(1, Mth::Min(width / 320, height / 240)));
+
+
+
 	} else {
-		// auto compute from resolution
-		if (width >= 1000) {
-        #ifdef __APPLE__
-            Gui::GuiScale = (width > 2000)? 8.0f : 4.0f;
-        #else
-            Gui::GuiScale = 4.0f;
-        #endif
-    }
-		else if (width >= 800) {
+
+
+		int guiScale = options.getIntValue(OPTIONS_GUI_SCALE);
+
+		// determine gui scale, optionally overriding auto
+		if (guiScale != 0) {
+			// manual selection: 1->small, 2->medium, 3->large, 4->larger, 5->largest
+			switch (guiScale) {
+			case 1: Gui::GuiScale = 2.0f; break;
+			case 2: Gui::GuiScale = 3.0f; break;
+			case 3: Gui::GuiScale = 4.0f; break;
+			case 4: Gui::GuiScale = 5.0f; break;
+			case 5: Gui::GuiScale = 6.0f; break;
+			default: Gui::GuiScale = 1.0f; break; // auto
+			}
+		} else {
+			// auto compute from resolution
+			if (width >= 1000) {
 #ifdef __APPLE__
-        Gui::GuiScale = 4.0f;
+				Gui::GuiScale = (width > 2000)? 8.0f : 4.0f;
 #else
-		Gui::GuiScale = 3.0f;
+				Gui::GuiScale = 4.0f;
 #endif
-    }
-		else if (width >= 400)
-			Gui::GuiScale = 2.0f;
-		else
-			Gui::GuiScale = 1.0f;
+			}
+			else if (width >= 800) {
+#ifdef __APPLE__
+				Gui::GuiScale = 4.0f;
+#else
+				Gui::GuiScale = 3.0f;
+#endif
+			}
+			else if (width >= 400)
+				Gui::GuiScale = 2.0f;
+			else
+				Gui::GuiScale = 1.0f;
+		}
+
+
+
+		// if (platform()) {
+		// 	float pixelsPerMillimeter = options.getProgressValue(&Option::PIXELS_PER_MILLIMETER);
+		// 	pixelCalc.setPixelsPerMillimeter(pixelsPerMillimeter);
+		// 	pixelCalcUi.setPixelsPerMillimeter(pixelsPerMillimeter * Gui::InvGuiScale);
+		// }
+
 	}
 
-	Gui::InvGuiScale = 1.0f / Gui::GuiScale;
-	int screenWidth  = (int)(width  * Gui::InvGuiScale);
-	int screenHeight = (int)(height * Gui::InvGuiScale);
 
-	// if (platform()) {
-	// 	float pixelsPerMillimeter = options.getProgressValue(&Option::PIXELS_PER_MILLIMETER);
-	// 	pixelCalc.setPixelsPerMillimeter(pixelsPerMillimeter);
-	// 	pixelCalcUi.setPixelsPerMillimeter(pixelsPerMillimeter * Gui::InvGuiScale);
-	// }
+	Gui::InvGuiScale = 1.0f / Gui::GuiScale;
+	screenWidth  = (int)(width  * Gui::InvGuiScale);
+	screenHeight = (int)(height * Gui::InvGuiScale);
 
 	Config config = createConfig(this);
 	gui.onConfigChanged(config);
-    
+
 	if (screen)
 		screen->setSize(screenWidth, screenHeight);
 
@@ -1253,9 +1294,9 @@ void Minecraft::reloadOptions() {
 
 	LOGI("Reloading-options\n");
 
-    // @todo @fix Android and iOS behaves a bit differently when leaving
-    //            an options screen (Android recreates OpenGL surface)
-    setSize(width, height);
+	// @todo @fix Android and iOS behaves a bit differently when leaving
+	//            an options screen (Android recreates OpenGL surface)
+	setSize(width, height);
 }
 
 void Minecraft::_reloadInput() {
@@ -1266,17 +1307,17 @@ void Minecraft::_reloadInput() {
 	if (useTouchHolder) {
 		inputHolder = new TouchInputHolder(this, &options);
 	} else {
-		#if defined(ANDROID) || defined(__APPLE__) 
-			inputHolder = new CustomInputHolder(
-				new XperiaPlayInput(&options),
-				new ControllerTurnInput(2, ControllerTurnInput::MODE_DELTA),
-				new IBuildInput());
-		#else
-			inputHolder = new CustomInputHolder(
-				new KeyboardInput(&options),
-				new MouseTurnInput(MouseTurnInput::MODE_DELTA, width/2, height/2),
-				new MouseBuildInput());
-		#endif
+#if defined(ANDROID) || defined(__APPLE__) 
+		inputHolder = new CustomInputHolder(
+			new XperiaPlayInput(&options),
+			new ControllerTurnInput(2, ControllerTurnInput::MODE_DELTA),
+			new IBuildInput());
+#else
+		inputHolder = new CustomInputHolder(
+			new KeyboardInput(&options),
+			new MouseTurnInput(MouseTurnInput::MODE_DELTA, width/2, height/2),
+			new MouseBuildInput());
+#endif
 	}
 
 	mouseHandler.setTurnInput(inputHolder->getTurnInput());
@@ -1319,7 +1360,7 @@ bool Minecraft::joinMultiplayerFromString( const std::string& server )
 {	
 	std::string ip = "";
 	std::string port = "19132";
-	
+
 	size_t pos = server.find(":");
 
 	if (pos != std::string::npos) {
@@ -1330,7 +1371,7 @@ bool Minecraft::joinMultiplayerFromString( const std::string& server )
 	}
 
 	printf("%s \n", port.c_str());
-	
+
 	if (isLookingForMultiplayer && netCallback) {
 		isLookingForMultiplayer = false;
 		printf("test");
@@ -1341,18 +1382,18 @@ bool Minecraft::joinMultiplayerFromString( const std::string& server )
 }
 
 void Minecraft::hostMultiplayer(int port) {
-    // Tear down last instance
-    raknetInstance->disconnect();
-    delete netCallback;
-    netCallback = NULL;
+	// Tear down last instance
+	raknetInstance->disconnect();
+	delete netCallback;
+	netCallback = NULL;
 
 #if !defined(NO_NETWORK)
 	netCallback = new ServerSideNetworkHandler(this, raknetInstance);
-    #ifdef STANDALONE_SERVER
-        raknetInstance->host("Server", port, 16);
-    #else
-        raknetInstance->host(options.getStringValue(OPTIONS_USERNAME), port);
-    #endif
+#ifdef STANDALONE_SERVER
+	raknetInstance->host("Server", port, 16);
+#else
+	raknetInstance->host(options.getStringValue(OPTIONS_USERNAME), port);
+#endif
 #endif
 }
 
@@ -1406,10 +1447,10 @@ void Minecraft::_levelGenerated()
 		player->resetPos(false);
 	}
 
-	    if (level && level->dimension) {
-        // For example, if you want FogType or any other option
-        level->dimension->FogType = options.getBooleanValue(OPTIONS_FOG_TYPE);
-		}
+	if (level && level->dimension) {
+
+		level->dimension->FogType = options.getIntValue(OPTIONS_FOG_TYPE);
+	}
 
 
 	this->cameraTargetPlayer = player;
@@ -1437,6 +1478,34 @@ void Minecraft::_levelGenerated()
 	_hasSignaledGeneratingLevelFinished = true;
 }
 
+std::string Minecraft::gatherStats1() {
+#ifndef STANDALONE_SERVER
+	return levelRenderer->gatherStats1();
+#endif
+	return "Blank";
+}
+
+std::string Minecraft::gatherStats2() {
+#ifndef STANDALONE_SERVER
+	return levelRenderer->gatherStats2();
+#endif
+	return "Blank";
+}
+
+std::string Minecraft::gatherStats3() {
+#ifndef STANDALONE_SERVER
+	return ("P: " + particleEngine->countParticles() + ". T: " + (level->gatherStats()));
+#endif
+	return "Blank";
+}
+
+std::string Minecraft::gatherStats4() {
+	return level->gatherChunkSourceStats();
+}
+
+
+
+
 Player* Minecraft::respawnPlayer(int playerId) {
 	for (unsigned int i = 0; i < level->players.size(); ++i) {
 		if (level->players[i]->entityId == playerId) {
@@ -1484,7 +1553,7 @@ void Minecraft::onGraphicsReset()
 {
 #ifndef STANDALONE_SERVER
 	textures->clear();
-	
+
 	font->onGraphicsReset();
 	gui.onGraphicsReset();
 
@@ -1523,12 +1592,12 @@ LevelStorageSource* Minecraft::getLevelSource()
 
 void Minecraft::audioEngineOn() {
 #ifndef STANDALONE_SERVER
-    soundEngine->enable(true);
+	soundEngine->enable(true);
 #endif
 }
 void Minecraft::audioEngineOff() {
 #ifndef STANDALONE_SERVER
-    soundEngine->enable(false);
+	soundEngine->enable(false);
 #endif
 }
 
@@ -1599,17 +1668,17 @@ void Minecraft::optionUpdated(OptionId option, bool value ) {
 }
 
 void Minecraft::optionUpdated(OptionId option, float value ) {
-// #ifndef STANDALONE_SERVER
-// 	if(option == OPTIONS_PIXELS_PER_MILLIMETER) {
-// 		pixelCalcUi.setPixelsPerMillimeter(value * Gui::InvGuiScale);
-// 		pixelCalc.setPixelsPerMillimeter(value);
-// 	}
-// #endif
+	// #ifndef STANDALONE_SERVER
+	// 	if(option == OPTIONS_PIXELS_PER_MILLIMETER) {
+	// 		pixelCalcUi.setPixelsPerMillimeter(value * Gui::InvGuiScale);
+	// 		pixelCalc.setPixelsPerMillimeter(value);
+	// 	}
+	// #endif
 }
 
 void Minecraft::optionUpdated(OptionId option, int value ) {
-    if(option == OPTIONS_GUI_SCALE) {
-        // reapply screen scaling using current window size
-        setSize(width, height);
-    }
+	if(option == OPTIONS_GUI_SCALE) {
+		// reapply screen scaling using current window size
+		setSize(width, height);
+	}
 }

src/client/Minecraft.h

@@ -87,6 +87,14 @@ public:
 
 	void update();
 
+	 std::string  gatherStats1();
+
+	 std::string  gatherStats2();
+
+     std::string  gatherStats4();
+
+     std::string  gatherStats3();
+
 	void tick(int nTick, int maxTick);
 	void tickInput();
 

src/client/Options.cpp

@@ -58,6 +58,10 @@ OptionBool ambientOcclusion("ao", true);
 
 OptionBool useNormalLighting("normalLighting", true);
 
+OptionBool beautifulSky("beautifulSky", true);
+
+OptionBool useVignette("useVignette", true);
+
 OptionBool useTouchscreen("useTouchscreen", true);
 
 OptionBool serverVisible("servervisible", true);
@@ -68,10 +72,20 @@ OptionInt fogType("fogType", 0, 0, 2);
 
 OptionBool javaHud("javaHud", false);
 
+OptionBool betaSky("betaSky", false);
+
+OptionBool tintedSide("tintedSide", false);
+
 OptionBool blockOutline("blockOutline", false);
 
 OptionBool restoredAnims("restoredAnims", true);
 
+OptionInt debugStyle("debugStyle", 0, 0, 1);
+
+OptionInt menuStyle("menuStyle",0, 0, 2);
+
+OptionBool windowScale("windowScale", false);
+
 OptionInt keyForward("key.forward", Keyboard::KEY_W);
 OptionInt keyLeft("key.left", Keyboard::KEY_A);
 OptionInt keyBack("key.back", Keyboard::KEY_S);
@@ -124,6 +138,7 @@ void Options::initTable() {
 
 
     m_options[OPTIONS_GUI_SCALE] = &guiScale;
+	m_options[OPTIONS_WINDOW_SCALE] = &windowScale;
 
 	m_options[OPTIONS_SKIN] = &skin;
 	m_options[OPTIONS_USERNAME] = &username;
@@ -150,12 +165,18 @@ void Options::initTable() {
 
 	m_options[OPTIONS_BLOCK_OUTLINE] = &blockOutline;
 
+	m_options[OPTIONS_VIGNETTE] = &useVignette;
+
+	m_options[OPTIONS_BEAUTIFUL_SKY] = &beautifulSky;
+
 	m_options[OPTIONS_NORMAL_LIGHTING] = &useNormalLighting;
 
 	m_options[OPTIONS_RESTORED_ANIMS] = &restoredAnims;
 
     m_options[OPTIONS_SERVER_VISIBLE] = &serverVisible;
 
+	m_options[OPTIONS_MENU_STYLE] = &menuStyle;
+
     m_options[OPTIONS_KEY_FORWARD] = &keyForward;
     m_options[OPTIONS_KEY_LEFT] = &keyLeft;
     m_options[OPTIONS_KEY_BACK] = &keyBack;
@@ -183,6 +204,12 @@ void Options::initTable() {
 	// more options yay
 	m_options[OPTIONS_FOG_TYPE] = &fogType;
 
+	m_options[OPTIONS_DEBUG_STYLE] = &debugStyle;
+
+	m_options[OPTIONS_BETA_SKY] = &betaSky;
+
+	m_options[OPTIONS_TINTED_SIDE] = &tintedSide;
+
 	m_options[OPTIONS_JAVA_HUD] = &javaHud;
 
 	m_options[OPTIONS_AUTOJUMP] = &autoJump;

src/client/Options.h

@@ -37,6 +37,7 @@ enum OptionId {
     OPTIONS_BAR_ON_TOP,
     OPTIONS_ALLOW_SPRINT,
     OPTIONS_AUTOJUMP,
+	OPTIONS_WINDOW_SCALE,
 
     // Graphics
     OPTIONS_RENDER_DEBUG,
@@ -51,6 +52,7 @@ enum OptionId {
     OPTIONS_FANCY_GRAPHICS,
 	OPTIONS_NORMAL_LIGHTING,
 
+
     // Cheats / debug
     OPTIONS_FLY_SPEED,
     OPTIONS_CAMERA_SPEED,
@@ -90,6 +92,13 @@ enum OptionId {
 	OPTIONS_FOG_TYPE,
 	OPTIONS_JAVA_HUD,
 	OPTIONS_RESTORED_ANIMS,
+	OPTIONS_TINTED_SIDE,
+	OPTIONS_BETA_SKY,
+	OPTIONS_BEAUTIFUL_SKY,
+	OPTIONS_VIGNETTE,
+	OPTIONS_DEBUG_STYLE,
+	OPTIONS_COMPLETE_LIGHTING,
+	OPTIONS_MENU_STYLE,
 	// Should be last!
 	OPTIONS_COUNT
 };

src/client/gui/Gui.cpp

@@ -7,6 +7,7 @@
 #include "screens/ConsoleScreen.h"
 #include "../Minecraft.h"
 #include "../player/LocalPlayer.h"
+#include "../renderer/Chunk.h"
 #include "../renderer/Tesselator.h"
 #include "../renderer/TileRenderer.h"
 #include "../renderer/LevelRenderer.h"
@@ -103,10 +104,10 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
 		}
 	}
 
-	// @todo - Shredder: I added this here but currently viginette is broken so i cant do much about it.
-	//	if (minecraft->options.getBooleanValue(OPTIONS_FANCY_GRAPHICS)){
-	//		this->renderVignette(this->minecraft->player->getBrightness(a), screenWidth, screenHeight);
-	//	}
+	// viginette has been fixed, was due to gl_blend not being enabled, my bad
+	if (minecraft->options.getBooleanValue(OPTIONS_FANCY_GRAPHICS) && minecraft->options.getBooleanValue(OPTIONS_VIGNETTE)){
+			renderVignette(this->minecraft->player->getBrightness(a), screenWidth, screenHeight);
+		}
 	// shredder end
 
 	if(minecraft->player->getSleepTimer() > 0) {
@@ -121,6 +122,9 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
 	if (!minecraft->options.getBooleanValue(OPTIONS_HIDEGUI)) {
 		renderToolBar(a, ySlot, screenWidth);
 
+	//	font->drawShadow("Minecraft - Pocket Edition ", 2, 2, 0xffffffff);
+//	font->drawShadow("This is a demo, not the finished product", 2, 10 + 2, 0xffffffff);
+
 		glEnable(GL_BLEND);
 		bool isChatting = (minecraft->screen && (dynamic_cast<ChatScreen*>(minecraft->screen) || dynamic_cast<ConsoleScreen*>(minecraft->screen)));
 		unsigned int max = 10;
@@ -360,6 +364,7 @@ void Gui::renderVignette(float br, int w, int h) {
 
 	glDisable(GL_DEPTH_TEST);
 	glDepthMask(false);
+	glEnable(GL_BLEND);
 	glBlendFunc2(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
 	glColor4f2(tbr, tbr, tbr, 1);
 
@@ -376,6 +381,7 @@ void Gui::renderVignette(float br, int w, int h) {
 	t.draw();
 	glDepthMask(true);
 	glEnable(GL_DEPTH_TEST);
+	glDisable(GL_BLEND);
 	glColor4f2(1, 1, 1, 1);
 	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
@@ -726,13 +732,20 @@ void Gui::onLevelGenerated() {
 
 void Gui::renderDebugInfo() {
 	// FPS counter (updates once per second)
-	static float fps = 0.0f;
-	static float fpsLastTime = 0.0f;
+	static int fps = 0;
+	static int fpsLastTime = 0;
 	static int   fpsFrames = 0;
+	static int   displayChunkUpdates = 0;
 	float now = getTimeS();
 	fpsFrames++;
-	if (now - fpsLastTime >= 1.0f) {
+	if (now - fpsLastTime >= 1) {
 		fps = fpsFrames / (now - fpsLastTime);
+
+		displayChunkUpdates = Chunk::updates;
+    
+    // 3. RESET the actual game counter to 0 for the next second
+		Chunk::updates = 0;
+
 		fpsFrames = 0;
 		fpsLastTime = now;
 	}
@@ -770,6 +783,47 @@ void Gui::renderDebugInfo() {
 	long seed      = lvl ? lvl->getSeed() : 0;
 
 	// Build lines (NULL entry = blank gap)
+	Font* font = minecraft->font;
+
+	// @todo - add our own debug screen as an option alongside the restored java one, why does renderdebug have to be so jank - shredder
+
+	// if java beta's restored debug menu is enabled
+	if (minecraft->options.getIntValue(OPTIONS_DEBUG_STYLE) == 0){
+
+	char buf[128];
+
+	sprintf(buf, "Minecraft - Pocket Edition (%d fps, %d chunk updates)", (int)fps, displayChunkUpdates);
+	font->drawShadow(buf, 2, 2, 0xffffff);
+
+	font->drawShadow(minecraft->gatherStats1(), 2, 12, 0xFFFFFF);
+	font->drawShadow(minecraft->gatherStats2(), 2, 22, 0xFFFFFF);
+    font->drawShadow(minecraft->gatherStats3(), 2, 32, 0xFFFFFF);
+    font->drawShadow(minecraft->gatherStats4(), 2, 42, 0xFFFFFF);
+
+	sprintf(buf, "x: %.8f", minecraft->player->x);
+	drawString(font, buf, 2, 64, 0xE0E0E0);
+
+	sprintf(buf, "y: %.8f", minecraft->player->y);
+	drawString(font, buf, 2, 72, 0xE0E0E0);
+
+	sprintf(buf, "z: %.8f", minecraft->player->z);
+	drawString(font, buf, 2, 80, 0xE0E0E0);
+
+	sprintf(buf, "f: %d",Mth::floor(minecraft->player->yRot * 4.0f / 360.0f + 0.5) & 0x3);
+	drawString(font, buf, 2, 88, 0xE0E0E0);
+
+	sprintf(buf, "Seed: %.ld", lvl->getSeed());
+	drawString(font, buf, 2, 104, 0xE0E0E0);
+
+	sprintf(buf, "Dimension: %d (%s)", lvl->dimension->id, lvl->dimension->getDimension().c_str());
+	drawString(font, buf, 2, 114, 0xE0E0E0);
+
+	sprintf(buf, "Biome: %s", biomeName);
+	drawString(font, buf, 2, 124, 0xE0E0E0);
+	}
+	else if (minecraft->options.getIntValue(OPTIONS_DEBUG_STYLE) == 1){
+	
+
 	static char ln[8][96];
 	sprintf(ln[0], "Minecraft PE 0.6.1 alpha (mcpe64)");
 	sprintf(ln[1], "%.1f fps", fps);
@@ -784,8 +838,8 @@ void Gui::renderDebugInfo() {
 	const float LH  = (float)Font::DefaultLineHeight; // 10 font-pixels
 	const float MGN = 2.0f;  // left/top margin in font-pixels
 	const float PAD = 2.0f;  // horizontal padding for background
-	Font* font = minecraft->font;
-
+//	Font* font = minecraft->font;
+	
 	// 1) Draw semi-transparent background boxes behind each line
 	for (int i = 0; i < N; i++) {
 		if (ln[i][0] == '\0') continue;
@@ -807,6 +861,7 @@ void Gui::renderDebugInfo() {
 		font->draw(ln[i], MGN, y, col);
 	}
 	t.endOverrideAndDraw();
+	}
 }
 
 void Gui::renderPlayerList(Font* font, int screenWidth, int screenHeight) {

src/client/gui/components/OptionsItem.cpp

@@ -36,7 +36,7 @@ void OptionsItem::render( Minecraft* minecraft, int xm, int ym ) {
 		}
 		text += ": " + scaleText;
 	}
-		if (m_optionId == OPTIONS_FOG_TYPE) {
+	if (m_optionId == OPTIONS_FOG_TYPE) {
 		int value = minecraft->options.getIntValue(OPTIONS_FOG_TYPE);
 		std::string scaleText;
 		switch (value) {
@@ -46,6 +46,38 @@ void OptionsItem::render( Minecraft* minecraft, int xm, int ym ) {
 		}
 		text += ": " + scaleText;
 	}
+	if (m_optionId == OPTIONS_DEBUG_STYLE) {
+		int value = minecraft->options.getIntValue(OPTIONS_DEBUG_STYLE);
+		std::string scaleText;
+		switch (value) {
+		case 0: scaleText = I18n::get("options.debugStyle.javaBeta"); break;
+		case 1: scaleText = I18n::get("options.debugStyle.custom"); break;
+		case 2: scaleText = I18n::get("options.fogType.unused"); break;
+		}
+		text += ": " + scaleText;
+	}
+	if (m_optionId == OPTIONS_MENU_STYLE) {
+		int value = minecraft->options.getIntValue(OPTIONS_MENU_STYLE);
+		std::string scaleText;
+		switch (value) {
+		case 0: scaleText = I18n::get("options.menuStyle.pocket"); break;
+		case 1: scaleText = I18n::get("options.menuStyle.xperia"); break;
+		case 2: scaleText = I18n::get("options.menuStyle.java"); break;
+		}
+		text += ": " + scaleText;
+	}
+	if (m_optionId == OPTIONS_VIEW_DISTANCE) {
+		int value = minecraft->options.getIntValue(OPTIONS_VIEW_DISTANCE);
+		std::string scaleText;
+		switch (value) {
+		case 0: scaleText = I18n::get("options.renderDistance.far"); break;
+		case 1: scaleText = I18n::get("options.renderDistance.normal"); break;
+		case 2: scaleText = I18n::get("options.renderDistance.short"); break;
+		case 3: scaleText = I18n::get("options.renderDistance.tiny"); break;
+		default: scaleText = "Debug"; break;
+		}
+		text += ": " + scaleText;
+	}
 
 	minecraft->font->draw(text, (float)x, (float)y + yOffset, 0x909090, false);
 	super::render(minecraft, xm, ym);

src/client/gui/screens/DeathScreen.cpp

@@ -23,12 +23,15 @@ DeathScreen::~DeathScreen()
 
 void DeathScreen::init()
 {
-	if (/* minecraft->useTouchscreen() */ true) {
+	if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 0) {
 		bRespawn = new Touch::TButton(1, "Respawn!");
 		bTitle = new Touch::TButton(2, "Main menu");
-	} else {
+	} else if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 1) {
 		bRespawn = new Button(1, "Respawn!");
 		bTitle = new Button(2, "Main menu");
+	} else {
+		bRespawn = new Button(1, 0, 0, 200, 20, "Respawn");
+		bTitle = new Button(2, 0, 0, 200, 20, "Title menu");
 	}
 	buttons.push_back(bRespawn);
 	buttons.push_back(bTitle);
@@ -39,13 +42,23 @@ void DeathScreen::init()
 
 void DeathScreen::setupPositions()
 {
-	bRespawn->width = bTitle->width = width / 4;
+if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 2){
+    bRespawn->width = 200;
+    bTitle->width = 200;
 
+    int centerX = (width / 2) - (bRespawn->width / 2);
+    bRespawn->x = centerX;
+    bTitle->x = centerX;
+
+    bRespawn->y = (height / 2);
+    bTitle->y = bRespawn->y + 24;
+} else {
+	bRespawn->width = bTitle->width = width / 4;
 	bRespawn->y = bTitle->y = height / 2;
 	bRespawn->x = width/2 - bRespawn->width - 10;
 	bTitle->x = width/2 + 10;
-
-	LOGI("xyz: %d, %d (%d, %d)\n", bTitle->x, bTitle->y, width, height);
+}
+//	LOGI("xyz: %d, %d (%d, %d)\n", bTitle->x, bTitle->y, width, height);
 }
 
 void DeathScreen::tick() {
@@ -56,10 +69,20 @@ void DeathScreen::render( int xm, int ym, float a )
 {
 	fillGradient(0, 0, width, height, 0x60500000, 0xa0803030);
 
+if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 2){
+	glPushMatrix2();
+	glScalef2(2, 2, 2);
+	drawCenteredString(font, "Game over!", width / 2 / 2, height / 8, 0xffffff);
+	glPopMatrix2();
+	std::stringstream ss;
+	ss << "Score: &e" << minecraft->player->getScore();
+	drawCenteredString(font, ss.str(), width / 2, (height / 4) + 32, 0xffffff);
+} else {
 	glPushMatrix2();
 	glScalef2(2, 2, 2);
 	drawCenteredString(font, "You died!", width / 2 / 2, height / 8, 0xffffff);
 	glPopMatrix2();
+}
 
 	if (_tick >= WAIT_TICKS)
 		Screen::render(xm, ym, a);

src/client/gui/screens/IngameBlockSelectionScreen.cpp

@@ -12,6 +12,7 @@
 #include "../../renderer/Textures.h"
 #include "../../gamemode/GameMode.h"
 #include "ArmorScreen.h"
+#include "crafting/WorkbenchScreen.h"
 #include "../components/Button.h"
 
 #if defined(__APPLE__)
@@ -27,7 +28,8 @@ IngameBlockSelectionScreen::IngameBlockSelectionScreen()
 	InventoryRows(1),
 	InventoryCols(1),
 	InventorySize(1),
-	bArmor(1, "Armor")
+	bArmor(1, "Armor"),
+	bCrafting(1, "Crafting")
 {
 }
 
@@ -42,6 +44,19 @@ void IngameBlockSelectionScreen::init()
 							(float)getSlotPosY(0) - 4,
 							(float)getSlotPosX(InventoryCols) + 4, 
 							(float)getSlotPosY(InventoryRows) + 4);
+	
+	if (!minecraft->isCreativeMode()) {
+		bArmor.width = 42;
+		bCrafting.width = 42;
+
+		bArmor.x = 0;
+		bArmor.y = height - bArmor.height;
+
+		bCrafting.x = 0;
+		bCrafting.y = height - bCrafting.height - 30;
+		buttons.push_back(&bArmor);
+		buttons.push_back(&bCrafting);
+	}
 
 	ItemInstance* selected = inventory->getSelected();
 	if (!selected || selected->isNull()) {
@@ -58,13 +73,6 @@ void IngameBlockSelectionScreen::init()
 	}
 	if (!isAllowed(selectedItem))
 		selectedItem = 0;
-
-	if (!minecraft->isCreativeMode()) {
-		bArmor.width = 42;
-		bArmor.x = 0;
-		bArmor.y = height - bArmor.height;
-		buttons.push_back(&bArmor);
-	}
 }
 
 void IngameBlockSelectionScreen::removed()
@@ -124,7 +132,7 @@ void IngameBlockSelectionScreen::renderSlots()
 	//w.printEvery(1000, "render-blocksel");
 
 	glDisable2(GL_RESCALE_NORMAL);
-	Lighting::turnOn(minecraft);
+	Lighting::turnOff();
 }
 
 int IngameBlockSelectionScreen::getSlotPosX(int slotX) {
@@ -249,7 +257,7 @@ void IngameBlockSelectionScreen::mouseClicked(int x, int y, int buttonNum)
 			//minecraft->soundEngine->playUI("random.click", 1, 1);
 		} else {
 			_pendingQuit = !_area.isInside((float)x, (float)y)
-			            && !bArmor.isInside(x, y);
+			            && !bArmor.isInside(x, y) && !bCrafting.isInside(x, y);
 		}
 	}
 	if (!_pendingQuit)
@@ -338,5 +346,8 @@ void IngameBlockSelectionScreen::buttonClicked( Button* button )
 	if (button == &bArmor) {
 		minecraft->setScreen(new ArmorScreen());
 	}
+	if (button == &bCrafting) {
+		minecraft->setScreen(new WorkbenchScreen(Recipe::SIZE_2X2));
+	}
 	super::buttonClicked(button);
 }

src/client/gui/screens/IngameBlockSelectionScreen.h

@@ -52,6 +52,7 @@ private:
 	bool _pendingQuit;
 
 	Button bArmor;
+	Button bCrafting;
 
 	RectangleArea _area;
 };

src/client/gui/screens/OptionsScreen.cpp

@@ -197,6 +197,7 @@ void OptionsScreen::generateOptionScreens() {
 	optionPanes[1]->addOptionItem(OPTIONS_DIFFICULTY, minecraft)
 		.addOptionItem(OPTIONS_SERVER_VISIBLE, minecraft)
 		.addOptionItem(OPTIONS_THIRD_PERSON_VIEW, minecraft)
+		.addOptionItem(OPTIONS_WINDOW_SCALE, minecraft)
 		.addOptionItem(OPTIONS_GUI_SCALE, minecraft)
 		.addOptionItem(OPTIONS_SENSITIVITY, minecraft)
 		.addOptionItem(OPTIONS_MUSIC_VOLUME, minecraft)
@@ -223,19 +224,26 @@ void OptionsScreen::generateOptionScreens() {
 		// .addOptionItem(&Option::ANAGLYPH, minecraft)
 		.addOptionItem(OPTIONS_LIMIT_FRAMERATE, minecraft)
 		.addOptionItem(OPTIONS_VSYNC, minecraft)
+		.addOptionItem(OPTIONS_VIEW_DISTANCE, minecraft)
 		.addOptionItem(OPTIONS_RENDER_DEBUG, minecraft)
 		.addOptionItem(OPTIONS_ANAGLYPH_3D, minecraft)
 		.addOptionItem(OPTIONS_VIEW_BOBBING, minecraft)
 		.addOptionItem(OPTIONS_AMBIENT_OCCLUSION, minecraft)
-		.addOptionItem(OPTIONS_NORMAL_LIGHTING, minecraft);
+		.addOptionItem(OPTIONS_NORMAL_LIGHTING, minecraft)
+		.addOptionItem(OPTIONS_BEAUTIFUL_SKY, minecraft)
+		.addOptionItem(OPTIONS_VIGNETTE, minecraft);
 
 	optionPanes[4]->addOptionItem(OPTIONS_ALLOW_SPRINT, minecraft)
 		.addOptionItem(OPTIONS_BAR_ON_TOP, minecraft)
+		.addOptionItem(OPTIONS_MENU_STYLE, minecraft)
 		.addOptionItem(OPTIONS_RPI_CURSOR, minecraft)
 		.addOptionItem(OPTIONS_FOLIAGE_TINT, minecraft)
+		.addOptionItem(OPTIONS_TINTED_SIDE, minecraft)
 		.addOptionItem(OPTIONS_JAVA_HUD, minecraft)
 		.addOptionItem(OPTIONS_FOG_TYPE, minecraft)
-		.addOptionItem(OPTIONS_RESTORED_ANIMS, minecraft);
+		.addOptionItem(OPTIONS_BETA_SKY, minecraft)
+		.addOptionItem(OPTIONS_RESTORED_ANIMS, minecraft)
+		.addOptionItem(OPTIONS_DEBUG_STYLE, minecraft);
 		
 }
 

src/client/gui/screens/PauseScreen.cpp

@@ -8,20 +8,22 @@
 #include "client/Options.h"
 #include "client/gui/components/Button.h"
 #include "client/gui/screens/OptionsScreen.h"
+#include "UploadPhotoScreen.h"
 
 PauseScreen::PauseScreen(bool wasBackPaused)
-:	saveStep(0),
+	:	saveStep(0),
 	visibleTime(0),
 	bContinue(0),
 	bQuit(0),
 	bOptions(0),
 	bQuitAndSaveLocally(0),
 	bServerVisibility(0),
-//	bThirdPerson(0),
+	bPhotoMode(0),
+	//	bThirdPerson(0),
 	wasBackPaused(wasBackPaused),
 	// bSound(OPTIONS_SOUND_VOLUME, 1, 0),
 	bThirdPerson(OPTIONS_THIRD_PERSON_VIEW),
-    bHideGui(OPTIONS_HIDEGUI)
+	bHideGui(OPTIONS_HIDEGUI)
 {
 	ImageDef def;
 	def.setSrc(IntRectangle(160, 144, 39, 31));
@@ -34,7 +36,7 @@ PauseScreen::PauseScreen(bool wasBackPaused)
 	// bSound.setImageDef(def, true);
 	defSrc.y += defSrc.h;
 	bThirdPerson.setImageDef(def, true);
-    bHideGui.setImageDef(def, true);
+	bHideGui.setImageDef(def, true);
 	//void setImageDef(ImageDef& imageDef, bool setButtonSize);
 }
 
@@ -43,41 +45,53 @@ PauseScreen::~PauseScreen() {
 	delete bQuit;
 	delete bQuitAndSaveLocally;
 	delete bServerVisibility;
+	delete bPhotoMode;
 	delete bOptions;
-//	delete bThirdPerson;
+	//	delete bThirdPerson;
 }
 
 void PauseScreen::init() {
-	if (/* minecraft->useTouchscreen() */ true) {
+	if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 0) {
 		bContinue = new Touch::TButton(1, "Back to game");
 		bOptions = new Touch::TButton(5, "Options");
+		bPhotoMode = new Touch::TButton(6, "Photo Mode");
 		bQuit = new Touch::TButton(2, "Quit to title");
 		bQuitAndSaveLocally = new Touch::TButton(3, "Quit and copy map");
 		bServerVisibility = new Touch::TButton(4, "");
-//		bThirdPerson = new Touch::TButton(5, "Toggle 3:rd person view");
-	} else {
+		//		bThirdPerson = new Touch::TButton(5, "Toggle 3:rd person view");
+	} else if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 1) {
 		bContinue = new Button(1, "Back to game");
 		bOptions = new Button(5, "Options");
+		bPhotoMode = new Button(6, "Photo Mode");
 		bQuit = new Button(2, "Quit to title");
 		bQuitAndSaveLocally = new Button(3, "Quit and copy map");
 		bServerVisibility = new Button(4, "");
-//		bThirdPerson = new Button(5, "Toggle 3:rd person view");
+		//		bThirdPerson = new Button(5, "Toggle 3:rd person view");
+	} else {
+		bContinue = new Button(1, 0, 0, 200, 20, "Back to game");
+		bServerVisibility = new Button(4, 0, 0, 200, 20, "");
+		bOptions = new Button(5, 0, 0, 200, 20, "Options...");
+		bPhotoMode = new Button(6, 0, 0, 200, 20, "Photo Mode");
+		bQuit = new Button(2, 0, 0, 200, 20, "Save and quit to title");
+		bQuitAndSaveLocally = new Button(3, 0, 0, 200, 20, "Copy and quit map");
+		//		bThirdPerson = new Button(5, "Toggle 3:rd person view");
 	}
 
 	buttons.push_back(bContinue);
 	buttons.push_back(bQuit);
 	buttons.push_back(bOptions);
+	buttons.push_back(bPhotoMode);
 	// bSound.updateImage(&minecraft->options);
 	bThirdPerson.updateImage(&minecraft->options);
 	bHideGui.updateImage(&minecraft->options);
 	// buttons.push_back(&bSound);
 	buttons.push_back(&bThirdPerson);
-    //buttons.push_back(&bHideGui);
+	//buttons.push_back(&bHideGui);
 
 	// If Back wasn't pressed, set up additional items (more than Quit to menu
 	// and Back to game) here
-    
-    #if !defined(APPLE_DEMO_PROMOTION) && !defined(RPI)
+
+#if !defined(APPLE_DEMO_PROMOTION) && !defined(RPI)
 	if (true || !wasBackPaused) {
 		if (minecraft->raknetInstance) {
 			if (minecraft->raknetInstance->isServer()) {
@@ -85,14 +99,14 @@ void PauseScreen::init() {
 				buttons.push_back(bServerVisibility);
 			}
 			else {
-                #if !defined(DEMO_MODE)
-                buttons.push_back(bQuitAndSaveLocally);
-				#endif
+#if !defined(DEMO_MODE)
+				buttons.push_back(bQuitAndSaveLocally);
+#endif
 			}
 		}
 	}
-    #endif
-//	buttons.push_back(bThirdPerson);
+#endif
+	//	buttons.push_back(bThirdPerson);
 
 	for (unsigned int i = 0; i < buttons.size(); ++i) {
 		// if (buttons[i] == &bSound) continue;
@@ -103,27 +117,54 @@ void PauseScreen::init() {
 }
 
 void PauseScreen::setupPositions() {
-    saveStep = 0;
+	saveStep = 0;
 	int yBase = 16;
+	if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 2){
+		yBase = 50;
 
-	bContinue->width = bOptions->width = bQuit->width = /*bThirdPerson->w =*/ 160;
-	bQuitAndSaveLocally->width = bServerVisibility->width = 160;
+		bContinue->width = bOptions->width = bPhotoMode->width = bQuit->width = /*bThirdPerson->w =*/ 200;
+		bQuitAndSaveLocally->width = bServerVisibility->width = 200;
 
-	bContinue->x = (width - bContinue->width) / 2;
-	bContinue->y = yBase + 32 * 1;
+		bContinue->x = (width - bContinue->width) / 2;
+		bContinue->y = yBase + 24 * 1;
 
-	bOptions->x = (width - bOptions->width) / 2;
-	bOptions->y = yBase + 32 * 2;
+		bQuitAndSaveLocally->x = bServerVisibility->x = (width - bQuitAndSaveLocally->width) / 2;
+		bQuitAndSaveLocally->y = bServerVisibility->y = yBase + 24 * 2;
 
-	bQuit->x = (width - bQuit->width) / 2;
-	bQuit->y = yBase + 32 * 3;
+		bPhotoMode->x = (width - bPhotoMode->width) / 2;
+		bPhotoMode->y = yBase + 24 * 3;
+
+		bOptions->x = (width - bOptions->width) / 2;
+		bOptions->y = yBase + 24 * 3 + 24;
+
+		bQuit->x = (width - bQuit->width) / 2;
+		bQuit->y = yBase + 24 * 4 + 24;
+
+	} else {
+		bContinue->width = bOptions->width = bPhotoMode->width = bQuit->width = /*bThirdPerson->w =*/ 160;
+		bQuitAndSaveLocally->width = bServerVisibility->width = 160;
+
+		bContinue->x = (width - bContinue->width) / 2;
+		bContinue->y = yBase + 32 * 1;
+
+		bOptions->x = (width - bOptions->width) / 2;
+		bOptions->y = yBase + 32 * 2;
+
+		bPhotoMode->x = (width - bPhotoMode->width) / 2;
+		bPhotoMode->y = yBase + 32 * 3;
+
+		bQuit->x = (width - bQuit->width) / 2;
+		bQuit->y = yBase + 32 * 4;
 
 #if APPLE_DEMO_PROMOTION
-    bQuit->y += 16;
+		bQuit->y += 16;
 #endif
-    
-	bQuitAndSaveLocally->x = bServerVisibility->x = (width - bQuitAndSaveLocally->width) / 2;
-	bQuitAndSaveLocally->y = bServerVisibility->y = yBase + 32 * 4;
+
+		bQuitAndSaveLocally->x = bServerVisibility->x = (width - bQuitAndSaveLocally->width) / 2;
+		bQuitAndSaveLocally->y = bServerVisibility->y = yBase + 32 * 5;
+	}
+
+
 
 	// bSound.y = bThirdPerson.y = 8;
 	// bSound.x = 4;
@@ -161,9 +202,12 @@ void PauseScreen::buttonClicked(Button* button) {
 		minecraft->setScreen(NULL);
 		//minecraft->grabMouse();
 	}
-    if (button->id == bQuit->id) {
+	if (button->id == bQuit->id) {
 		minecraft->leaveGame();
-    }
+	}
+	if (button->id == bPhotoMode->id) {
+		minecraft->setScreen(new UploadPhotoScreen());
+	}
 	if (button->id == bQuitAndSaveLocally->id) {
 		minecraft->leaveGame(true);
 	}
@@ -197,5 +241,5 @@ void PauseScreen::updateServerVisibilityText()
 	ServerSideNetworkHandler* ss = (ServerSideNetworkHandler*) minecraft->netCallback;
 	bServerVisibility->msg = ss->allowsIncomingConnections()?
 		"Server is visible"
-	:   "Server is invisible";
+		:   "Server is invisible";
 }

src/client/gui/screens/PauseScreen.h

@@ -33,6 +33,7 @@ private:
 	Button* bQuit;
 	Button* bQuitAndSaveLocally;
 	Button* bServerVisibility;
+	Button* bPhotoMode;
 	Button* bOptions;
 
 	//	Button* bThirdPerson;

src/client/gui/screens/ScreenChooser.cpp

@@ -21,7 +21,7 @@ Screen* ScreenChooser::createScreen( ScreenId id )
 	Screen* screen = NULL;
 
 	// :sob:
-	if (/* _mc->useTouchscreen() */ true) {
+	if (_mc->options.getIntValue(OPTIONS_MENU_STYLE) == 0) {
 		switch (id) {
 		case SCREEN_STARTMENU:	     screen = new Touch::StartMenuScreen();	break;
 		case SCREEN_SELECTWORLD:     screen = new Touch::SelectWorldScreen();break;

src/client/gui/screens/StartMenuScreen.cpp

@@ -23,49 +23,62 @@
 
 // Some kind of default settings, might be overridden in ::init
 StartMenuScreen::StartMenuScreen()
-:	bHost(    2, 0, 0, 160, 24, "Start Game"),
-	bJoin(    3, 0, 0, 160, 24, "Join Game"),
-	bOptions( 4, 0, 0, 160, 24, "Options"),
-	bQuit(    5, "")
 {
 }
 
 StartMenuScreen::~StartMenuScreen()
 {
+	delete bHost;
+	delete bJoin;
+	delete bOptions;
+	delete bQuit;
 }
 
 void StartMenuScreen::init()
 {
-	bJoin.active = bHost.active = bOptions.active = true;
+	if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 2){
+		bHost = new Button(    2, 0, 0, 200, 20, "Singleplayer");
+		bJoin = new Button(    3, 0, 0, 200, 20, "Multiplayer");
+		bOptions = new Button( 4, 0, 0, 200, 20, "Options...");
+		bQuit = new Button( 5, 0, 0, 200, 20, "Ouit Game");
+	} else {
+		bHost = new Button(    2, 0, 0, 160, 24, "Start Game");
+		bJoin = new Button(    3, 0, 0, 160, 24, "Join Game");
+		bOptions = new Button( 4, 0, 0, 160, 24, "Options");
+		bQuit = new Button( 5, 0, 0, 160, 24, "Ouit Game");
+	}
+	bJoin->active = bHost->active = bOptions->active = true;
 
 	if (minecraft->options.getStringValue(OPTIONS_USERNAME).empty()) {
 		return; // tick() will redirect to UsernameScreen
 	}
 
-	buttons.push_back(&bHost);
-	buttons.push_back(&bJoin);
+	buttons.push_back(bHost);
+	buttons.push_back(bJoin);
 	//buttons.push_back(&bTest);
+	buttons.push_back(bQuit);
 
-	tabButtons.push_back(&bHost);
-	tabButtons.push_back(&bJoin);
+	tabButtons.push_back(bHost);
+	tabButtons.push_back(bJoin);
+	tabButtons.push_back(bQuit);
 
 	#ifndef RPI
-		buttons.push_back(&bOptions);
-		tabButtons.push_back(&bOptions);
+		buttons.push_back(bOptions);
+		tabButtons.push_back(bOptions);
 	#endif
 
-    // add quit button (top right X icon) – match OptionsScreen style
-    {
-        ImageDef def;
-        def.name = "gui/touchgui.png";
-        def.width = 34;
-        def.height = 26;
-        def.setSrc(IntRectangle(150, 0, (int)def.width, (int)def.height));
-        bQuit.setImageDef(def, true);
-        bQuit.scaleWhenPressed = false;
-        buttons.push_back(&bQuit);
-        // don't include in tab navigation
-    }
+    //// add quit button (top right X icon) – match OptionsScreen style
+    //{
+    //    ImageDef def;
+    //    def.name = "gui/touchgui.png";
+    //    def.width = 34;
+    //    def.height = 26;
+    //    def.setSrc(IntRectangle(150, 0, (int)def.width, (int)def.height));
+    //    bQuit.setImageDef(def, true);
+    //    bQuit.scaleWhenPressed = false;
+    //    buttons.push_back(&bQuit);
+    //    // don't include in tab navigation
+    //}
 
 	copyright = "\xffMojang AB";//. Do not distribute!";
 
@@ -93,20 +106,30 @@ void StartMenuScreen::init()
 }
 
 void StartMenuScreen::setupPositions() {
-	int yBase = height / 2;
+	if (minecraft->options.getIntValue(OPTIONS_MENU_STYLE) == 2){
+		int yBase = (height / 2) - 20;
 
-	bHost.y =	 yBase;
-	bJoin.y =	 bHost.y + 24 + 4;
-	bOptions.y = bJoin.y + 24 + 4;
+		bHost->y =	 yBase;
+		bJoin->y =	 bHost->y + 24;
+		bOptions->y = bJoin->y + 24;
+		bQuit->y = bOptions->y + 24;
+	} else {
+		int yBase = height / 2;
+		bHost->y =	 yBase;
+		bJoin->y =	 bHost->y + 24 + 4;
+		bOptions->y = bJoin->y + 24 + 4;
+		bQuit->y = bOptions->y + 24 + 4;
+	}
 
 	// Center buttons
-	bHost.x = (width - bHost.width) / 2;
-	bJoin.x = (width - bJoin.width) / 2;
-	bOptions.x = (width - bOptions.width) / 2;
+	bHost->x = (width - bHost->width) / 2;
+	bJoin->x = (width - bJoin->width) / 2;
+	bOptions->x = (width - bOptions->width) / 2;
+	bQuit->x = (width - bQuit->width) / 2;
 
-    // position quit icon at top-right (use image-defined size)
-    bQuit.x = width - bQuit.width;
-    bQuit.y = 0;
+    //// position quit icon at top-right (use image-defined size)
+    //bQuit.x = width - bQuit.width;
+    //bQuit.y = 0;
 }
 
 void StartMenuScreen::tick() {
@@ -114,7 +137,7 @@ void StartMenuScreen::tick() {
 
 void StartMenuScreen::buttonClicked(Button* button) {
 
-	if (button->id == bHost.id)
+	if (button->id == bHost->id)
 	{
         #if defined(DEMO_MODE) || defined(APPLE_DEMO_PROMOTION)
 			minecraft->setScreen( new SimpleChooseLevelScreen("_DemoLevel") );
@@ -122,16 +145,16 @@ void StartMenuScreen::buttonClicked(Button* button) {
 			minecraft->screenChooser.setScreen(SCREEN_SELECTWORLD);
 		#endif
 	}
-	if (button->id == bJoin.id)
+	if (button->id == bJoin->id)
 	{
 		minecraft->locateMultiplayer();
 		minecraft->screenChooser.setScreen(SCREEN_JOINGAME);
 	}
-	if (button->id == bOptions.id)
+	if (button->id == bOptions->id)
 	{
 		minecraft->setScreen(new OptionsScreen());
 	}
-	if (button == &bQuit)
+	if (button->id == bQuit->id)
 	{
 		minecraft->quit();
 	}

src/client/gui/screens/StartMenuScreen.h

@@ -23,10 +23,10 @@ public:
 	bool isInGameScreen();
 private:
 
-	Button bHost;
-	Button bJoin;
-	Button bOptions;
-	ImageButton bQuit; // X button in top-right corner
+	Button* bHost;
+	Button* bJoin;
+	Button* bOptions;
+	Button* bQuit; 
 
 	std::string copyright;
 	int copyrightPosX;

src/client/gui/screens/UploadPhotoScreen.cpp

@@ -1,177 +1,160 @@
-#if 0
-
-#include "UploadPhotoScreen.h"
-#include "../renderer/TileRenderer.h"
-#include "../player/LocalPlayer.h"
-#include "../../world/entity/player/Inventory.h"
-
-UploadPhotoScreen::UploadPhotoScreen()
-	:
-selectedItem(0)
-{
-}
-
-void UploadPhotoScreen::init()
-{
-	int currentSelection = minecraft->player->inventory->getSelectedItemId();
-	for (int i = 0; i < Inventory::INVENTORY_SIZE; i++)
-	{
-		if (currentSelection == minecraft->player->inventory->getSelectionSlotItemId(i + Inventory::SELECTION_SIZE))
-		{
-			selectedItem = i;
-			break;
-		}
-	}
-
-}
-
-void UploadPhotoScreen::renderSlots()
-{
-	glColor4f2(1, 1, 1, 1);
-
-	blitOffset = -90;
-
-	minecraft->textures->loadAndBindTexture("gui/gui.png");
-	for (int r = 0; r < Inventory::INVENTORY_ROWS; r++)
-	{
-		blit(width / 2 - 182 / 2, height - 22 * 3 - 22 * r, 0, 0, 182, 22);
-	}
-	if (selectedItem >= 0)
-	{
-		int x = width / 2 - 182 / 2 - 1 + (selectedItem % Inventory::SELECTION_SIZE) * 20;
-		int y = height - 22 * 3 - 1 - (selectedItem / Inventory::SELECTION_SIZE) * 22;
-		blit(x, y, 0, 22, 24, 22);
-	}
-
-	for (int r = 0; r < Inventory::INVENTORY_ROWS; r++)
-	{
-		for (int i = 0; i < 9; i++) {
-			int x = width / 2 - 9 * 10 + i * 20 + 2;
-			int y = height - 16 - 3 - 22 * 2 - 22 * r;
-			renderSlot(r * 9 + i + Inventory::SELECTION_SIZE, x, y, 0);
-		}
-	}
-
-}
-
-void UploadPhotoScreen::renderSlot(int slot, int x, int y, float a)
-{
-	int itemId = minecraft->player->inventory->getSelectionSlotItemId(slot);
-	if (itemId < 0) return;
-
-	const bool fancy = false;
-
-	if (fancy && itemId < 256 && TileRenderer::canRender(Tile::tiles[itemId]->getRenderShape())) {
-
-	} else {
-		if (itemId < 256) {
-			Tile* tile = Tile::tiles[itemId];
-			if (tile == NULL) return;
-
-			minecraft->textures->loadAndBindTexture("terrain.png");
-
-			int textureId = tile->getTexture(2, 0);
-			blit(x, y, textureId % 16 * 16, textureId / 16 * 16, 16, 16);
-		}
-	}
-
-}
-
-void UploadPhotoScreen::keyPressed(int eventKey)
-{
-	int selX = selectedItem % Inventory::SELECTION_SIZE;
-	int selY = selectedItem / Inventory::SELECTION_SIZE;
-
-	Options& o = minecraft->options;
-	if (eventKey == o.keyLeft.key && selX > 0)
-	{
-		selectedItem -= 1;
-	}
-	else if (eventKey == o.keyRight.key && selX < (Inventory::SELECTION_SIZE - 1))
-	{
-		selectedItem += 1;
-	}
-	else if (eventKey == o.keyDown.key && selY > 0)
-	{
-		selectedItem -= Inventory::SELECTION_SIZE;
-	}
-	else if (eventKey == o.keyUp.key && selY < (Inventory::INVENTORY_ROWS - 1))
-	{
-		selectedItem += Inventory::SELECTION_SIZE;
-	}
-
-	if (eventKey == o.keyMenuOk.key)
-	{
-		selectSlotAndClose();
-	}
-}
-
-int UploadPhotoScreen::getSelectedSlot(int x, int y)
-{
-	int left = 3 + width / 2 - Inventory::SELECTION_SIZE * 10;
-	int top = height - 16 - 3 - 22 * 2 - 22 * Inventory::INVENTORY_ROWS;
-
-	if (x >= left && y >= top)
-	{
-		int xSlot = (x - left) / 20;
-		if (xSlot < Inventory::SELECTION_SIZE)
-		{
-			// rows are rendered upsidedown
-			return xSlot + Inventory::INVENTORY_SIZE - ((y - top) / 22) * Inventory::SELECTION_SIZE;
-		}
-	}
-	return -1;
-}
-
-void UploadPhotoScreen::mouseClicked(int x, int y, int buttonNum) {
-	if (buttonNum == MouseAction::ACTION_LEFT) {
-
-		int slot = getSelectedSlot(x, y);
-		if (slot >= 0 && slot < Inventory::INVENTORY_SIZE)
-		{
-			selectedItem = slot;
-			//minecraft->soundEngine->playUI("random.click", 1, 1);
-		}
-	}
-}
-
-void UploadPhotoScreen::mouseReleased(int x, int y, int buttonNum)
-{
-	if (buttonNum == MouseAction::ACTION_LEFT) {
-
-		int slot = getSelectedSlot(x, y);
-		if (slot >= 0 && slot < Inventory::INVENTORY_SIZE && slot == selectedItem)
-		{
-			selectSlotAndClose();
-		}
-	}
-}
-
-void UploadPhotoScreen::selectSlotAndClose()
-{
-	Inventory* inventory = minecraft->player->inventory;
-
-	int itemId = inventory->getSelectionSlotItemId(selectedItem + Inventory::SELECTION_SIZE);
-	int i = 0;
-
-	for (; i < Inventory::SELECTION_SIZE - 2; i++)
-	{
-		if (itemId == inventory->getSelectionSlotItemId(i))
-		{
-			break;
-		}
-	}
-
-	// update selection list
-	for (; i >= 1; i--)
-	{
-		inventory->setSelectionSlotItemId(i, inventory->getSelectionSlotItemId(i - 1));
-	}
-	inventory->setSelectionSlotItemId(0, itemId);
-	inventory->selectSlot(0);
-
-	minecraft->soundEngine->playUI("random.click", 1, 1);
-	minecraft->setScreen(NULL);
-}
-
-#endif
+#include "UploadPhotoScreen.h"
+
+#include "../components/Button.h"
+#include "../../Minecraft.h"
+#include "../../player/LocalPlayer.h"
+#include "../../../world/entity/item/TripodCamera.h"
+#include "../../../world/level/Level.h"
+#include "../../../platform/input/Keyboard.h"
+#include "../../renderer/GameRenderer.h"
+#include "../../renderer/LevelRenderer.h"
+
+UploadPhotoScreen::UploadPhotoScreen()
+: hasAppliedPhotoMode(false),
+  oldHideGui(false),
+  oldThirdPerson(false),
+  oldFixedCamera(false),
+  hasOldPose(false),
+  oldX(0),
+  oldY(0),
+  oldZ(0),
+  oldYaw(0),
+  oldPitch(0),
+  photoCameraTarget(NULL),
+  photoCameraX(0),
+  photoCameraY(0),
+  photoCameraZ(0),
+  bBack(0)
+{
+}
+
+UploadPhotoScreen::~UploadPhotoScreen()
+{
+	restorePhotoMode();
+	delete photoCameraTarget;
+	delete bBack;
+}
+
+void UploadPhotoScreen::init()
+{
+	applyPhotoMode();
+
+	if (minecraft->useTouchscreen()) {
+		bBack = new Touch::TButton(1, "Back");
+	} else {
+		bBack = new Button(1, "Back");
+	}
+
+	buttons.push_back(bBack);
+	tabButtons.push_back(bBack);
+}
+
+void UploadPhotoScreen::removed()
+{
+	restorePhotoMode();
+}
+
+void UploadPhotoScreen::applyPhotoMode()
+{
+	if (hasAppliedPhotoMode || !minecraft || !minecraft->gameRenderer) return;
+
+	if (minecraft->player) {
+		oldX = minecraft->player->x;
+		oldY = minecraft->player->y;
+		oldZ = minecraft->player->z;
+		oldYaw = minecraft->player->yRot;
+		oldPitch = minecraft->player->xRot;
+		hasOldPose = true;
+	}
+
+	oldHideGui = minecraft->options.getBooleanValue(OPTIONS_HIDEGUI);
+	oldThirdPerson = minecraft->options.getBooleanValue(OPTIONS_THIRD_PERSON_VIEW);
+	oldFixedCamera = minecraft->options.getBooleanValue(OPTIONS_FIXED_CAMERA);
+	Pos spawn = minecraft->level->getSharedSpawnPos();
+	photoCameraX = (float) spawn.x;
+	photoCameraY = 128.0f;
+	photoCameraZ = (float) spawn.z;
+	if (!photoCameraTarget) {
+		photoCameraTarget = new TripodCamera(minecraft->level, minecraft->player, photoCameraX, photoCameraY, photoCameraZ);
+	}
+	photoCameraTarget->setPos(photoCameraX, photoCameraY, photoCameraZ);
+	photoCameraTarget->xo = photoCameraTarget->xOld = photoCameraX;
+	photoCameraTarget->yo = photoCameraTarget->yOld = photoCameraY;
+	photoCameraTarget->zo = photoCameraTarget->zOld = photoCameraZ;
+
+	if (!oldHideGui) minecraft->options.toggle(OPTIONS_HIDEGUI);
+	if (!oldThirdPerson) minecraft->options.toggle(OPTIONS_THIRD_PERSON_VIEW);
+	if (!oldFixedCamera) minecraft->options.toggle(OPTIONS_FIXED_CAMERA);
+
+	minecraft->gameRenderer->setPhotoModeIsometric();
+	minecraft->levelRenderer->allChanged();
+	hasAppliedPhotoMode = true;
+}
+
+void UploadPhotoScreen::tick()
+{
+	if (!hasAppliedPhotoMode || !minecraft || !minecraft->player || !minecraft->level) return;
+
+	if (photoCameraTarget) {
+		photoCameraTarget->setPos(photoCameraX, photoCameraY, photoCameraZ);
+		photoCameraTarget->xo = photoCameraTarget->xOld = photoCameraX;
+		photoCameraTarget->yo = photoCameraTarget->yOld = photoCameraY;
+		photoCameraTarget->zo = photoCameraTarget->zOld = photoCameraZ;
+		photoCameraTarget->yRot = photoCameraTarget->yRotO = 45.0f;
+		photoCameraTarget->xRot = photoCameraTarget->xRotO = 68.0f;
+		minecraft->cameraTargetPlayer = photoCameraTarget;
+	}
+}
+
+void UploadPhotoScreen::restorePhotoMode()
+{
+	if (!hasAppliedPhotoMode || !minecraft) return;
+
+	if (minecraft->options.getBooleanValue(OPTIONS_HIDEGUI) != oldHideGui) minecraft->options.toggle(OPTIONS_HIDEGUI);
+	if (minecraft->options.getBooleanValue(OPTIONS_THIRD_PERSON_VIEW) != oldThirdPerson) minecraft->options.toggle(OPTIONS_THIRD_PERSON_VIEW);
+	if (minecraft->options.getBooleanValue(OPTIONS_FIXED_CAMERA) != oldFixedCamera) minecraft->options.toggle(OPTIONS_FIXED_CAMERA);
+	minecraft->gameRenderer->clearPhotoModeIsometric();
+	minecraft->cameraTargetPlayer = minecraft->player;
+
+	if (hasOldPose && minecraft->player) {
+		minecraft->player->yRot = oldYaw;
+		minecraft->player->xRot = oldPitch;
+	}
+
+	hasAppliedPhotoMode = false;
+}
+
+void UploadPhotoScreen::keyPressed(int eventKey)
+{
+	if (eventKey == Keyboard::KEY_ESCAPE) {
+		restorePhotoMode();
+		minecraft->setScreen(NULL);
+		return;
+	}
+
+	Screen::keyPressed(eventKey);
+}
+
+void UploadPhotoScreen::buttonClicked(Button* button)
+{
+	if (!button || button->id != 1) return;
+
+	restorePhotoMode();
+	minecraft->setScreen(NULL);
+}
+
+void UploadPhotoScreen::setupPositions()
+{
+	const int buttonWidth = 120;
+	const int buttonHeight = 24;
+	bBack->width = buttonWidth;
+	bBack->height = buttonHeight;
+	bBack->x = (width - buttonWidth) / 2;
+	bBack->y = height - 32;
+}
+
+void UploadPhotoScreen::render(int xm, int ym, float a)
+{
+	drawCenteredString(font, "Photo Mode - Isometric", width / 2, 12, 0xffffff);
+	Screen::render(xm, ym, a);
+}

src/client/gui/screens/UploadPhotoScreen.h

@@ -1,36 +1,50 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI_SCREENS__UploadPhotoScreen_H__
-#define NET_MINECRAFT_CLIENT_GUI_SCREENS__UploadPhotoScreen_H__
-
-#include "Screen.h"
-
-class UploadPhotoScreen : public Screen
-{
-public:
-
-	UploadPhotoScreen();
-	virtual ~UploadPhotoScreen() {}
-
-	virtual void init();
-
-	void render(int xm, int ym, float a) {
-		Screen::render(xm, ym, a);
-	}
-
-protected:
-
-	virtual void mouseClicked(int x, int y, int buttonNum);
-	virtual void mouseReleased(int x, int y, int buttonNum);
-	virtual void keyPressed(int eventKey);
-
-private:
-
-	int selectedItem;
-
-	void renderSlots();
-	void renderSlot(int slot, int x, int y, float a);
-
-	int getSelectedSlot(int x, int y);
-	void selectSlotAndClose();
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GUI_SCREENS__UploadPhotoScreen_H__*/
+#ifndef NET_MINECRAFT_CLIENT_GUI_SCREENS__UploadPhotoScreen_H__
+#define NET_MINECRAFT_CLIENT_GUI_SCREENS__UploadPhotoScreen_H__
+
+#include "../Screen.h"
+
+class Button;
+class Mob;
+
+class UploadPhotoScreen : public Screen
+{
+public:
+
+	UploadPhotoScreen();
+	virtual ~UploadPhotoScreen();
+
+	virtual void init();
+	virtual void setupPositions();
+	virtual void tick();
+	virtual void removed();
+	virtual void keyPressed(int eventKey);
+
+	virtual void render(int xm, int ym, float a);
+
+protected:
+
+	virtual void buttonClicked(Button* button);
+
+private:
+
+	void applyPhotoMode();
+	void restorePhotoMode();
+
+	bool hasAppliedPhotoMode;
+	bool oldHideGui;
+	bool oldThirdPerson;
+	bool oldFixedCamera;
+	bool hasOldPose;
+	float oldX;
+	float oldY;
+	float oldZ;
+	float oldYaw;
+	float oldPitch;
+	Mob* photoCameraTarget;
+	float photoCameraX;
+	float photoCameraY;
+	float photoCameraZ;
+	Button* bBack;
+};
+
+#endif /*NET_MINECRAFT_CLIENT_GUI_SCREENS__UploadPhotoScreen_H__*/

src/client/renderer/GameRenderer.cpp

@@ -34,6 +34,7 @@ static int _shTicks = -1;
 GameRenderer::GameRenderer( Minecraft* mc )
 	:	mc(mc),
 	renderDistance(0),
+	photoModeIsometric(false),
 	_tick(0),
 	_lastTickT(0),
 	fovOffset(0),
@@ -90,7 +91,7 @@ void renderCursor(float x, float y, Minecraft* minecraft) {
 
 /*private*/
 void GameRenderer::setupCamera(float a, int eye) {
-	renderDistance = (float) (16 * 16 >> (mc->options.getIntValue(OPTIONS_VIEW_DISTANCE)));
+    renderDistance = photoModeIsometric ? 1024.0f : (float) (16 * 16 >> (mc->options.getIntValue(OPTIONS_VIEW_DISTANCE)));
 #if defined(ANDROID)
 	if (mc->isPowerVR() && mc->options.getIntValue(OPTIONS_VIEW_DISTANCE) <= 2)
 		renderDistance *= 0.8f;
@@ -101,12 +102,22 @@ void GameRenderer::setupCamera(float a, int eye) {
 
 	float stereoScale = 0.07f;
 	if (mc->options.getBooleanValue(OPTIONS_ANAGLYPH_3D)) glTranslatef2(-(eye * 2 - 1) * stereoScale, 0, 0);
-	if (zoom != 1) {
-		glTranslatef2((float) zoom_x, (float) -zoom_y, 0);
-		glScalef2(zoom, zoom, 1);
-		gluPerspective(_setupCameraFov = getFov(a, true), mc->width / (float) mc->height, 0.05f, renderDistance);
+	if (mc->options.getBooleanValue(OPTIONS_BETA_SKY)){
+		if (zoom != 1) {
+			glTranslatef2((float) zoom_x, (float) -zoom_y, 0);
+			glScalef2(zoom, zoom, 1);
+			gluPerspective(_setupCameraFov = getFov(a, true), mc->width / (float) mc->height, 0.05f, renderDistance * 2.0f);
+		} else {
+			gluPerspective(_setupCameraFov = getFov(a, true), mc->width / (float) mc->height, 0.05f, renderDistance * 2.0f);
+		}
 	} else {
-		gluPerspective(_setupCameraFov = getFov(a, true), mc->width / (float) mc->height, 0.05f, renderDistance);
+		if (zoom != 1) {
+			glTranslatef2((float) zoom_x, (float) -zoom_y, 0);
+			glScalef2(zoom, zoom, 1);
+			gluPerspective(_setupCameraFov = getFov(a, true), mc->width / (float) mc->height, 0.05f, renderDistance);
+		} else {
+			gluPerspective(_setupCameraFov = getFov(a, true), mc->width / (float) mc->height, 0.05f, renderDistance);
+		}
 	}
 
 	glMatrixMode(GL_MODELVIEW);
@@ -272,17 +283,7 @@ void GameRenderer::renderLevel(float a) {
 				screenScissorArea.w, screenScissorArea.h);
 		}
 
-		if(mc->options.getBooleanValue(OPTIONS_FANCY_GRAPHICS)) {
-			setupFog(-1);
-			TIMER_POP_PUSH("sky");
-			glFogf(GL_FOG_START, renderDistance  * 0.2f);
-			glFogf(GL_FOG_END, renderDistance *0.75);
-			// levelRenderer->renderSky(a); // Removed duplicate call
-			glFogf(GL_FOG_START, renderDistance  * 0.6f);
-			glFogf(GL_FOG_END, renderDistance);
-		}
-		glEnable2(GL_FOG);
-		setupFog(1);
+
 
 		if (mc->options.getBooleanValue(OPTIONS_AMBIENT_OCCLUSION)) {
 			glShadeModel2(GL_SMOOTH);
@@ -295,10 +296,29 @@ void GameRenderer::renderLevel(float a) {
 		TIMER_POP_PUSH("culling");
 		mc->levelRenderer->cull(&frustum, a);
 		mc->levelRenderer->updateDirtyChunks(cameraEntity, false);
+		// this sky rendering code below was originally before the frustrum and culling stuff but sunset color breaks for some reason in that place, so i moved i after those two - shredder
+//		if(mc->options.getBooleanValue(OPTIONS_FANCY_GRAPHICS)) {
+			setupFog(-1);
+			TIMER_POP_PUSH("sky");
+			// @TODO - EXTREME JANK BELOW, it works but i have to do heavy cleanup here, also to test if the glfogf commands even affect fog in anyway.
+			if(mc->options.getBooleanValue(OPTIONS_BETA_SKY) && (mc->options.getIntValue(OPTIONS_VIEW_DISTANCE) < 2)){
+			levelRenderer->renderSky(a); // how java renders the sky instead of how pe doing prepareandrenderclouds.
+			} else if (!mc->options.getBooleanValue(OPTIONS_BETA_SKY)){
+			glFogf(GL_FOG_START, renderDistance  * 0.2f);
+			glFogf(GL_FOG_END, renderDistance *0.75);
 
-		if(mc->options.getBooleanValue(OPTIONS_FANCY_GRAPHICS)) {
+			glFogf(GL_FOG_START, renderDistance  * 0.6f);
+			glFogf(GL_FOG_END, renderDistance);
+			}
+//		}
+		glEnable2(GL_FOG);
+		setupFog(1);
+		// MCPE renders clouds using this, but this method breaks 3d clouds and also breaks 2d clouds transparency viewed from above, add as a Legacy Sky or Fast Sky option. - shredder
+		if(!mc->options.getBooleanValue(OPTIONS_BETA_SKY)){
+		if(mc->options.getBooleanValue(OPTIONS_FANCY_GRAPHICS) && !photoModeIsometric) { 
 			prepareAndRenderClouds(levelRenderer, a);
 		}
+		}
 
 		setupFog(0);
 		glEnable2(GL_FOG);
@@ -306,7 +326,9 @@ void GameRenderer::renderLevel(float a) {
 		mc->textures->loadAndBindTexture("terrain.png");
 		Lighting::turnOff();
 
-		glDisable2(GL_ALPHA_TEST);
+//		glDisable2(GL_ALPHA_TEST); // vanilla pe disables alpha test here, i renable it so grass side textures dont become opaque - shredder
+		glEnable2(GL_ALPHA_TEST); // 
+
 		glDisable2(GL_BLEND);
 		glEnable2(GL_CULL_FACE);
 		TIMER_POP_PUSH("terrain-0");
@@ -329,10 +351,12 @@ void GameRenderer::renderLevel(float a) {
 		setupFog(0);
 		glEnable2(GL_BLEND);
 		glDisable2(GL_CULL_FACE);
-		glDepthMask(GL_FALSE);
+		glDepthMask(GL_FALSE); // @TODO commenting this out fixes Ice transparency and clouds are no longer visilbe underwater like normal beta - shredder
 		glDisable2(GL_ALPHA_TEST);
 		mc->textures->loadAndBindTexture("terrain.png");
-		//if (mc->options.fancyGraphics) {
+		// @TODO - below is a commented out double render system that fixes ice transparency, but probs harm performance, add it as an option - shredder
+
+		//if (mc->options.fancyGraphics) { 
 		//    glColorMask(false, false, false, false);
 		//    int visibleWaterChunks = levelRenderer->render(cameraEntity, 1, a);
 		//    glColorMask(true, true, true, true);
@@ -374,11 +398,14 @@ void GameRenderer::renderLevel(float a) {
 		}
 
 		glDisable2(GL_FOG);
-		//
-		//        setupFog(0);
-		//        glEnable2(GL_FOG);
-		////        levelRenderer->renderClouds(a);
-		//        glDisable2(GL_FOG);
+		// Normally this is commented out, but this is how java does it and should fix both 2d/3d clouds, a
+		if(mc->options.getBooleanValue(OPTIONS_BETA_SKY)){
+		       setupFog(0);
+		       glEnable2(GL_FOG);
+		        levelRenderer->renderClouds(a);
+		        glDisable2(GL_FOG);
+		}
+		// SHREDDER END
 		setupFog(1);
 
 		if (zoom == 1 && !mc->options.getBooleanValue(OPTIONS_HIDEGUI)) {
@@ -547,6 +574,14 @@ void GameRenderer::bobView(float a) {
 
 /*private*/
 void GameRenderer::setupFog(int i) {
+	if (photoModeIsometric) {
+		glDisable2(GL_FOG);
+		glFogf(GL_FOG_START, 0.0f);
+		glFogf(GL_FOG_END, 1024.0f);
+		glEnable2(GL_COLOR_MATERIAL);
+		return;
+	}
+
 	Mob* player = mc->cameraTargetPlayer;
 	float fogBuffer[4] = {fr, fg, fb, 1};
 
@@ -663,7 +698,7 @@ void GameRenderer::pick(float a) {
 	float range = mc->gameMode->getPickRange();
 	bool isPicking = true;
 
-	bool freeform = mc->useTouchscreen(); //&& !mc->options.getBooleanValue(OPTIONS_IS_JOY_TOUCH_AREA);
+	bool freeform = mc->useTouchscreen() && !mc->options.getBooleanValue(OPTIONS_IS_JOY_TOUCH_AREA);
 
 	if (freeform) {
 		isPicking = updateFreeformPickDirection(a, pickDirection);
@@ -803,6 +838,14 @@ void GameRenderer::tick(int nTick, int maxTick) {
 
 /*private*/
 void GameRenderer::setupClearColor(float a) {
+	if (photoModeIsometric) {
+		fr = 0.47f;
+		fg = 0.78f;
+		fb = 1.0f;
+		glClearColor(fr, fg, fb, 1.0f);
+		return;
+	}
+
 	Level* level = mc->level;
 	Mob* player = mc->cameraTargetPlayer;
 
@@ -916,6 +959,28 @@ void GameRenderer::onGraphicsReset()
 	if (itemInHandRenderer) itemInHandRenderer->onGraphicsReset();
 }
 
+void GameRenderer::setPhotoModeIsometric()
+{
+	photoModeIsometric = true;
+	thirdDistance = thirdDistanceO = 128.0f;
+	thirdRotation = thirdRotationO = 45.0f;
+	thirdTilt = thirdTiltO = 56.0f;
+	zoom = 1.0f;
+	zoom_x = 0.0f;
+	zoom_y = 0.0f;
+	cameraRoll = cameraRollO = 0.0f;
+}
+
+void GameRenderer::clearPhotoModeIsometric()
+{
+	photoModeIsometric = false;
+}
+
+bool GameRenderer::isPhotoModeIsometric() const
+{
+	return photoModeIsometric;
+}
+
 void GameRenderer::saveMatrices()
 {
 #if defined(RPI)

src/client/renderer/GameRenderer.h

@@ -33,6 +33,9 @@ public:
 	void renderItemInHand(float a, int eye);
 
 	void onGraphicsReset();
+	void setPhotoModeIsometric();
+	void clearPhotoModeIsometric();
+	bool isPhotoModeIsometric() const;
 
 	void setupCamera(float a, int eye);
 	void moveCameraToPlayer(float a);
@@ -58,6 +61,7 @@ private:
 	Minecraft* mc;
 
 	float renderDistance;
+	bool photoModeIsometric;
 	int _tick;
 	Vec3 pickDirection;
 

src/client/renderer/ItemInHandRenderer.cpp

@@ -443,10 +443,10 @@ void ItemInHandRenderer::renderScreenEffect( float a )
 		}
 	}
 
-	//     if (mc->player->isUnderLiquid(Material::water)) {
-	//mc->textures->loadAndBindTexture("misc/water.png");
-	//         renderWater(a);
-	//     }
+	     if (mc->player->isUnderLiquid(Material::water)) {
+			 mc->textures->loadAndBindTexture("misc/water.png");
+	         renderWater(a);
+	     }
 	glEnable2(GL_ALPHA_TEST);
 }
 

src/client/renderer/LevelRenderer.cpp

@@ -26,6 +26,7 @@
 #include "../../client/player/LocalPlayer.h"
 
 #include "../../world/level/GrassColor.h"
+#include "Lighting.h"
 
 #ifdef GFX_SMALLER_CHUNKS
 /* static */ const int LevelRenderer::CHUNK_SIZE = 8;
@@ -76,6 +77,9 @@ LevelRenderer::LevelRenderer( Minecraft* mc)
 	//for (int i = 0; i < numListsOrBuffers; ++i) printf("bufId %d: %d\t", i, chunkBuffers[i]);
 
 	glGenBuffers2(1, &skyBuffer);
+	glGenBuffers2(1, &voidBuffer);
+	glGenBuffers2(1, &starBuffer);
+	generateStars();
 	generateSky();
 #else
 	int maxChunksWidth = 1024 / CHUNK_SIZE;
@@ -94,6 +98,8 @@ LevelRenderer::~LevelRenderer()
 #ifdef OPENGL_ES
 	glDeleteBuffers(numListsOrBuffers, chunkBuffers);
 	glDeleteBuffers(1, &skyBuffer);
+	glDeleteBuffers(1, &voidBuffer);
+	glDeleteBuffers(1, &starBuffer);
 	delete[] chunkBuffers;
 #else
 	glDeleteLists(numListsOrBuffers, chunkLists);
@@ -121,6 +127,25 @@ void LevelRenderer::generateSky() {
 	}
 
 	t.end(true, skyBuffer);
+
+	yy = (float) (-16);
+	t.begin();
+
+	// pretty much the same thing as the sky one above except uses inverted values to generate the void plane. 
+
+	voidVertexCount = 0;
+	for (int xx = -s * d; xx <= s * d; xx += s) {
+		for (int zz = -s * d; zz <= s * d; zz += s) {
+			t.vertex((float) xx + 0,  yy, (float) zz + s);
+			t.vertex((float)(xx + s), yy, (float) zz + s);
+			t.vertex((float)(xx + s), yy, (float)(zz + 0));
+			t.vertex((float) xx + 0,  yy, (float)(zz + 0));
+			//LOGI("x, z: %d, %d\n", xx, zz);
+			voidVertexCount += 4;
+		}
+	}
+
+	t.end(true, voidBuffer);
 	//LOGI("skyvertexcount: %d\n", skyVertexCount);
 	//glEndList();
 }
@@ -146,10 +171,6 @@ void LevelRenderer::setLevel( Level* level )
 		level->addListener(this);
 		allChanged();
 	}
-	if (mc->options.getBooleanValue(OPTIONS_AMBIENT_OCCLUSION)) {
-		mc->useAmbientOcclusion = !mc->useAmbientOcclusion;
-		allChanged();
-	}
 }
 
 void LevelRenderer::allChanged()
@@ -168,8 +189,13 @@ void LevelRenderer::allChanged()
 	FoliageColor::setUseTint(tint);
 	GrassColor::setUseTint(tint);
 
+	bool sideTint = mc->options.getBooleanValue(OPTIONS_TINTED_SIDE);
+	TileRenderer::setUseTint(sideTint);
 
-	int dist = (512 >> 3) << (3 - lastViewDistance);
+
+	int dist = mc->gameRenderer && mc->gameRenderer->isPhotoModeIsometric()
+		? 1024
+		: (512 >> 3) << (3 - lastViewDistance);
 	if (lastViewDistance <= 2 && mc->isPowerVR())
 		dist = (int)((float)dist * 0.8f);
 	LOGI("last: %d, power: %d\n", lastViewDistance, mc->isPowerVR());
@@ -178,7 +204,9 @@ void LevelRenderer::allChanged()
 	dist *= 0.6f;
 #endif
 
-	if (dist > 400) dist = 400;
+	if (!(mc->gameRenderer && mc->gameRenderer->isPhotoModeIsometric())) {
+		if (dist > 400) dist = 400;
+	}
 	/*
 	* if (Minecraft.FLYBY_MODE) { dist = 512 - CHUNK_SIZE * 2; }
 	*/
@@ -325,6 +353,37 @@ int LevelRenderer::render( Mob* player, int layer, float alpha )
 
 		allChanged(); 
 	}
+	bool SmoothLightState = mc->options.getBooleanValue(OPTIONS_AMBIENT_OCCLUSION);
+	if (SmoothLightState != mc->useAmbientOcclusion){
+		mc->useAmbientOcclusion = SmoothLightState;
+		allChanged();
+	}
+
+
+	bool tint = mc->options.getBooleanValue(OPTIONS_FOLIAGE_TINT);
+	if (tint != LastTint) {
+		LastTint = tint;
+
+
+		FoliageColor::setUseTint(tint);
+		GrassColor::setUseTint(tint);
+
+		allChanged(); 
+	}
+
+
+	bool sideTint = mc->options.getBooleanValue(OPTIONS_TINTED_SIDE);
+
+	if (sideTint != LastSideTint) {
+		LastSideTint = sideTint;
+
+
+		TileRenderer::setUseTint(sideTint);
+
+		allChanged(); 
+	}
+
+
 
 	TIMER_PUSH("sortchunks");
 	for (int i = 0; i < 10; i++) {
@@ -513,15 +572,15 @@ void LevelRenderer::render(const AABB& b) const
 {
 	Tesselator& t = Tesselator::instance;
 
-//	glColor4f2(1, 1, 1, 1);
+	//	glColor4f2(1, 1, 1, 1);
 
-//	textures->loadAndBindTexture("terrain.png"); // uh need to check java - shredder
+	//	textures->loadAndBindTexture("terrain.png"); // uh need to check java - shredder
 
 	//t.begin();
-//	t.color(255, 255, 255, 255); // again not needed, for some reason the vanilla source code tints it... white? maybe this was used for something else in MCPE's dev at one point? - shredder
-
-//	t.offset(((Mob*)mc->player)->getPos(0).negated()); // why does this even exist normally, it just makes the thing... not render
+	//	t.color(255, 255, 255, 255); // again not needed, for some reason the vanilla source code tints it... white? maybe this was used for something else in MCPE's dev at one point? - shredder
 
+	//	t.offset(((Mob*)mc->player)->getPos(0).negated()); // why does this even exist normally, it just makes the thing... not render
+	glLineWidth(2.0f); // make it more thick - shredder
 	t.begin(GL_LINE_STRIP);
 	t.vertex(b.x0, b.y0, b.z0);
 	t.vertex(b.x1, b.y0, b.z0);
@@ -619,9 +678,11 @@ void LevelRenderer::tick()
 
 bool LevelRenderer::updateDirtyChunks( Mob* player, bool force )
 {
-	bool slow = false;
+	bool slow = mc->gameRenderer && mc->gameRenderer->isPhotoModeIsometric();
 
 	if (slow) {
+		const int visibleLimit = 12;
+		const int invisibleLimit = 4;
 		DirtyChunkSorter dirtySorter(player);
 		std::sort(dirtyChunks.begin(), dirtyChunks.end(), dirtySorter);
 		int s = dirtyChunks.size() - 1;
@@ -631,9 +692,9 @@ bool LevelRenderer::updateDirtyChunks( Mob* player, bool force )
 			if (!force) {
 				if (chunk->distanceToSqr(player) > 16 * 16) {
 					if (chunk->visible) {
-						if (i >= MAX_VISIBLE_REBUILDS_PER_FRAME) return false;
+						if (i >= visibleLimit) return false;
 					} else {
-						if (i >= MAX_INVISIBLE_REBUILDS_PER_FRAME) return false;
+						if (i >= invisibleLimit) return false;
 					}
 				}
 			} else {
@@ -647,10 +708,9 @@ bool LevelRenderer::updateDirtyChunks( Mob* player, bool force )
 
 		return dirtyChunks.size() == 0;
 	} else {
-		const int count = 3;
-
+		const int count = (mc->gameRenderer && mc->gameRenderer->isPhotoModeIsometric()) ? 32 : 3;
+		Chunk* toAdd[24] = {NULL};
 		DirtyChunkSorter dirtyChunkSorter(player);
-		Chunk* toAdd[count] = {NULL};
 		std::vector<Chunk*>* nearChunks = NULL;
 
 		int pendingChunkSize = dirtyChunks.size();
@@ -660,7 +720,7 @@ bool LevelRenderer::updateDirtyChunks( Mob* player, bool force )
 			Chunk* chunk = dirtyChunks[i];
 
 			if (!force) {
-				if (chunk->distanceToSqr(player) > 1024.0f) {
+				if (chunk->distanceToSqr(player) > ((mc->gameRenderer && mc->gameRenderer->isPhotoModeIsometric()) ? 65536.0f : 1024.0f)) {
 					int index;
 
 					// is this chunk in the closest <count>?
@@ -699,7 +759,7 @@ bool LevelRenderer::updateDirtyChunks( Mob* player, bool force )
 
 		// if there are nearby chunks that need to be prepared for
 		// rendering, sort them and then process them
-		static const float MaxFrameTime = 1.0f / 100.0f;
+		static const float MaxFrameTime = (mc->gameRenderer && mc->gameRenderer->isPhotoModeIsometric()) ? (1.0f / 75.0f) : (1.0f / 100.0f);
 		Stopwatch chunkWatch;
 		chunkWatch.start();
 
@@ -1009,13 +1069,66 @@ std::string LevelRenderer::gatherStats1() {
 }
 
 //
-//    /*public*/ std::string gatherStats2() {
-//        return "E: " + renderedEntities + "/" + totalEntities + ". B: " + culledEntities + ", I: " + ((totalEntities - culledEntities) - renderedEntities);
-//    }
+    std::string LevelRenderer::gatherStats2() {
+		std::stringstream ss;
+		ss << "E: "<< renderedEntities << "/" << totalEntities << ". B: " << culledEntities << ", I: " << (totalEntities - culledEntities) - renderedEntities <<"\n";
+        return ss.str();
+    }
 //
 //    int[] toRender = new int[50000];
 //    IntBuffer resultBuffer = MemoryTracker.createIntBuffer(64);
 
+   void LevelRenderer::generateStars() {
+	   // ported from java beta again,
+	   // converted the doubles into floats to be consistent, shouldnt affect much - shredder
+
+      Random random = Random(10842L);
+      Tesselator& t = Tesselator::instance;
+      t.begin();
+	  starVertexCount = 0;
+
+      for (int i = 0; i < 1500; i++) {
+         float d = random.nextFloat() * 2.0F - 1.0F;
+         float e = random.nextFloat() * 2.0F - 1.0F;
+         float f = random.nextFloat() * 2.0F - 1.0F;
+         float g = 0.25F + random.nextFloat() * 0.25F;
+         float h = d * d + e * e + f * f;
+         if (h < 1.0 && h > 0.01) {
+            h = 1.0 / Mth::sqrt(h);
+            d *= h;
+            e *= h;
+            f *= h;
+            float j = d * 100.0;
+            float k = e * 100.0;
+            float l = f * 100.0;
+            float m = Mth::atan2(d, f);
+            float n = Mth::sin(m);
+            float o = Mth::cos(m);
+            float p = Mth::atan2(Mth::sqrt(d * d + f * f), e);
+            float q = Mth::sin(p);
+            float r = Mth::cos(p);
+            float s = random.nextDouble() * Mth::PI * 2.0;
+            float t2 = Mth::sin(s);
+            float u = Mth::cos(s);
+
+            for (int v = 0; v < 4; v++) {
+               float w = 0.0;
+               float x = ((v & 2) - 1) * g;
+               float y = ((v + 1 & 2) - 1) * g;
+               float aa = x * u - y * t2;
+               float ab = y * u + x * t2;
+               float ad = aa * q + w * r;
+               float ae = w * q - aa * r;
+               float af = ae * n - ab * o;
+               float ah = ab * n + ae * o;
+               t.vertex(j + af, k + ad, l + ah);
+            }
+			starVertexCount += 4;
+         }
+      }
+
+      t.end(true, starBuffer);
+   }
 void LevelRenderer::renderSky(float alpha) {
 	if (mc->level->dimension->foggy) return;
 
@@ -1036,19 +1149,125 @@ void LevelRenderer::renderSky(float alpha) {
 	}
 	glColor4f2(sr, sg, Mth::Min(1.0f, sb), 1);
 
-	//Tesselator& t = Tesselator::instance;
-
+	Tesselator& t = Tesselator::instance;
+	// @TODO shredder - should not enable or disable depth mask if using legacy sky because mcpe sky rendering is awful and will render clouds above terrain
+	if(mc->options.getBooleanValue(OPTIONS_BETA_SKY)){
+		glDepthMask(false);
+	}
 	glEnable2(GL_FOG);
 	glColor4f2(sr, sg, sb, 1.0f);
 
 #ifdef OPENGL_ES
 	drawArrayVT(skyBuffer, skyVertexCount);
 #endif
-	glEnable2(GL_TEXTURE_2D);
+		glDisable(GL_FOG);
+	glDisable(GL_ALPHA_TEST);
+
+	// re ported this again from beta 1.6.6, thanks to the mcpe 0.1 decomp team's code for some bit of help about the void layer - shredder 
+
+	// Sunrise
+	if (mc->options.getBooleanValue(OPTIONS_BEAUTIFUL_SKY)) {
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	Lighting::turnOff();
+	float* c = level->dimension->getSunriseColor(level->getTimeOfDay(alpha), alpha);
+	if (c != nullptr)
+	{
+		glDisable(GL_TEXTURE_2D);
+//		glShadeModel(GL_SMOOTH); //
+
+		glPushMatrix();
+		glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
+		glRotatef(level->getTimeOfDay(alpha) > 0.5f ? 180 : 0, 0.0f, 0.0f, 1.0f);
+		t.begin(GL_TRIANGLE_FAN);
+		t.color(c[0], c[1], c[2], c[3]);
+		t.vertex(0.0f, 100.0f, 0.0f);
+		t.color(c[0], c[1], c[2], 0.0f);
+
+		int steps = 16;
+		for (int i = 0; i <= steps; i++)
+		{
+			float a = i * 3.1415927f * 2.0f / steps;
+			float sin = Mth::sin(a);
+			float cos = Mth::cos(a);
+			t.vertex((sin * 120.0f), (cos * 120.0f), (-cos * 40.0f * c[3]));
+		}
+
+		t.draw();
+		glPopMatrix();
+//		glShadeModel(GL_FLAT); //
+	}
+
+	// gets the time of day and rotates the sun and moon png based on the time
+	glEnable(GL_TEXTURE_2D);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+	glPushMatrix();
+
+	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+	glTranslatef(sc.x, sc.y, sc.z);
+	glRotatef(0.0f, 0.0f, 0.0f, 1.0f);
+	glRotatef(level->getTimeOfDay(alpha) * 360.0f, 1.0f, 0.0f, 0.0f);
+
+	float ss = 30.0f;
+
+
+		textures->loadAndBindTexture("terrain/sun.png");
+		t.begin();
+		t.vertexUV(-ss, 100.0f, -ss, 0.0f, 0.0f);
+		t.vertexUV(ss, 100.0f, -ss, 1.0f, 0.0f);
+		t.vertexUV(ss, 100.0f, ss, 1.0f, 1.0f);
+		t.vertexUV(-ss, 100.0f, ss, 0.0f, 1.0f);
+		t.draw();
+
+		ss = 20.0f;
+		textures->loadAndBindTexture("terrain/moon.png");
+		t.begin();
+		t.vertexUV(-ss, -100.0f, ss, 1.0f, 1.0f);
+		t.vertexUV(ss, -100.0f, ss, 0.0f, 1.0f);
+		t.vertexUV(ss, -100.0f, -ss, 0.0f, 0.0f);
+		t.vertexUV(-ss, -100.0f, -ss, 1.0f, 0.0f);
+		t.draw();
+	
+
+	glDisable(GL_TEXTURE_2D);
+
+	float a = level->getStarBrightness(alpha);
+	if (a > 0.0f)
+	{
+		glColor4f(a, a, a, a);
+		drawArrayVT(starBuffer, starVertexCount);
+	}
+	}
+
+	
+	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+	glDisable(GL_BLEND);
+	glEnable(GL_ALPHA_TEST);
+	glEnable(GL_FOG);
+	glPopMatrix();
+
+	// ported over void plane (the blue bottom plane seen in java) because pocket edition lacks it @TODO test if it's buggy - shredder
+
+//	glColor3f(sc.x * 0.2f + 0.04f, sc.y * 0.2f + 0.04f, sc.z * 0.6f + 0.1f);
+	glColor4f(sc.x * 0.2f + 0.04f, sc.y * 0.2f + 0.04f, sc.z * 0.6f + 0.1f, 1.0f);
+	glDisable(GL_TEXTURE_2D);
+	if(mc->options.getBooleanValue(OPTIONS_BETA_SKY)){
+		drawArrayVT(voidBuffer, voidVertexCount);
+	}
+	glEnable(GL_TEXTURE_2D);
+
+	// @TODO shredder - should not enable or disable depth mask if using legacy sky because mcpe sky rendering is awful and will render clouds above terrain
+	if(mc->options.getBooleanValue(OPTIONS_BETA_SKY)){
+		glDepthMask(true);
+	}
 }
 
 void LevelRenderer::renderClouds( float alpha ) {
 	//if (!mc->level->dimension->isNaturalDimension()) return;
+	if (mc->options.getBooleanValue(OPTIONS_FANCY_GRAPHICS) && mc->options.getBooleanValue(OPTIONS_BETA_SKY)){
+		renderAdvancedClouds(alpha);
+		return;
+	}
 	glEnable2(GL_TEXTURE_2D);
 	glDisable(GL_CULL_FACE);
 	float yOffs = (float) (mc->player->yOld + (mc->player->y - mc->player->yOld) * alpha);
@@ -1097,6 +1316,142 @@ void LevelRenderer::renderClouds( float alpha ) {
 	glEnable(GL_CULL_FACE);
 }
 
+void LevelRenderer::renderAdvancedClouds(float alpha) {
+
+	// ported from java beta, tesselation code for the 3d clouds, renders broken if mcpe sky rendering option is used - shredder
+
+	glDisable(GL_CULL_FACE);
+
+	float px = mc->player->xOld + (mc->player->x - mc->player->xOld) * alpha;
+	float py = mc->player->yOld + (mc->player->y - mc->player->yOld) * alpha;
+	float pz = mc->player->zOld + (mc->player->z - mc->player->zOld) * alpha;
+
+	Tesselator& t = Tesselator::instance;
+	float ss = 12.0f; 
+	float h = 4.0f;  
+
+	float cloudTime = (float)ticks + alpha;
+
+	float xo = (px + cloudTime * 0.03f) / ss;
+	float zo = pz / ss + 0.33f;
+
+	float yy = 108.0f - py + 0.33f;
+
+	int xWraps = Mth::floor(xo / 2048.0);
+	int zWraps = Mth::floor(zo / 2048.0);
+	xo -= xWraps * 2048;
+	zo -= zWraps * 2048;
+
+	textures->loadAndBindTexture("environment/clouds.png");
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	Vec3 cc = level->getCloudColor(alpha);
+	float cr = cc.x;
+	float cg = cc.y;
+	float cb = cc.z;
+
+	float uvScale = 1.0f / 256.0f;
+	float uo = (float)Mth::floor(xo) * uvScale;
+	float vo = (float)Mth::floor(zo) * uvScale;
+
+	float xOffs = (float)(xo - Mth::floor(xo));
+	float zOffs = (float)(zo - Mth::floor(zo));
+
+	int D = 8;      
+	int radius = 3;  
+	float e = 1.0f / 1024.0f; 
+
+	glPushMatrix();
+	glScalef(ss, 1.0f, ss);
+
+	for (int pass = 0; pass < 2; pass++) {
+
+		if (pass == 0) glColorMask(false, false, false, false);
+		else glColorMask(true, true, true, true);
+
+		for (int xPos = -radius + 1; xPos <= radius; xPos++) {
+			for (int zPos = -radius + 1; zPos <= radius; zPos++) {
+				t.begin();
+				float xx = (float)(xPos * D);
+				float zz = (float)(zPos * D);
+				float xp = xx - xOffs;
+				float zp = zz - zOffs;
+
+
+				if (yy > -h - 1.0f) {
+					t.color(cr * 0.7f, cg * 0.7f, cb * 0.7f, 0.8f);
+					t.normal(0.0f, -1.0f, 0.0f);
+					t.vertexUV(xp + 0, yy + 0, zp + D, (xx + 0) * uvScale + uo, (zz + D) * uvScale + vo);
+					t.vertexUV(xp + D, yy + 0, zp + D, (xx + D) * uvScale + uo, (zz + D) * uvScale + vo);
+					t.vertexUV(xp + D, yy + 0, zp + 0, (xx + D) * uvScale + uo, (zz + 0) * uvScale + vo);
+					t.vertexUV(xp + 0, yy + 0, zp + 0, (xx + 0) * uvScale + uo, (zz + 0) * uvScale + vo);
+				}
+
+
+				if (yy <= h + 1.0f) {
+					t.color(cr, cg, cb, 0.8f);
+					t.normal(0.0f, 1.0f, 0.0f);
+					t.vertexUV(xp + 0, yy + h - e, zp + D, (xx + 0) * uvScale + uo, (zz + D) * uvScale + vo);
+					t.vertexUV(xp + D, yy + h - e, zp + D, (xx + D) * uvScale + uo, (zz + D) * uvScale + vo);
+					t.vertexUV(xp + D, yy + h - e, zp + 0, (xx + D) * uvScale + uo, (zz + 0) * uvScale + vo);
+					t.vertexUV(xp + 0, yy + h - e, zp + 0, (xx + 0) * uvScale + uo, (zz + 0) * uvScale + vo);
+				}
+
+				t.color(cr * 0.9f, cg * 0.9f, cb * 0.9f, 0.8f);
+
+
+				if (xPos > -1) {
+					t.normal(-1.0f, 0.0f, 0.0f);
+					for (int i = 0; i < D; i++) {
+						t.vertexUV(xp + i + 0, yy + 0, zp + D, (xx + i + 0.5f) * uvScale + uo, (zz + D) * uvScale + vo);
+						t.vertexUV(xp + i + 0, yy + h, zp + D, (xx + i + 0.5f) * uvScale + uo, (zz + D) * uvScale + vo);
+						t.vertexUV(xp + i + 0, yy + h, zp + 0, (xx + i + 0.5f) * uvScale + uo, (zz + 0) * uvScale + vo);
+						t.vertexUV(xp + i + 0, yy + 0, zp + 0, (xx + i + 0.5f) * uvScale + uo, (zz + 0) * uvScale + vo);
+					}
+				}
+				if (xPos <= 1) {
+					t.normal(1.0f, 0.0f, 0.0f);
+					for (int i = 0; i < D; i++) {
+						t.vertexUV(xp + i + 1 - e, yy + 0, zp + D, (xx + i + 0.5f) * uvScale + uo, (zz + D) * uvScale + vo);
+						t.vertexUV(xp + i + 1 - e, yy + h, zp + D, (xx + i + 0.5f) * uvScale + uo, (zz + D) * uvScale + vo);
+						t.vertexUV(xp + i + 1 - e, yy + h, zp + 0, (xx + i + 0.5f) * uvScale + uo, (zz + 0) * uvScale + vo);
+						t.vertexUV(xp + i + 1 - e, yy + 0, zp + 0, (xx + i + 0.5f) * uvScale + uo, (zz + 0) * uvScale + vo);
+					}
+				}
+
+				t.color(cr * 0.8f, cg * 0.8f, cb * 0.8f, 0.8f);
+
+
+				if (zPos > -1) {
+					t.normal(0.0f, 0.0f, -1.0f);
+					for (int i = 0; i < D; i++) {
+						t.vertexUV(xp + 0, yy + h, zp + i + 0, (xx + 0) * uvScale + uo, (zz + i + 0.5f) * uvScale + vo);
+						t.vertexUV(xp + D, yy + h, zp + i + 0, (xx + D) * uvScale + uo, (zz + i + 0.5f) * uvScale + vo);
+						t.vertexUV(xp + D, yy + 0, zp + i + 0, (xx + D) * uvScale + uo, (zz + i + 0.5f) * uvScale + vo);
+						t.vertexUV(xp + 0, yy + 0, zp + i + 0, (xx + 0) * uvScale + uo, (zz + i + 0.5f) * uvScale + vo);
+					}
+				}
+				if (zPos <= 1) {
+					t.normal(0.0f, 0.0f, 1.0f);
+					for (int i = 0; i < D; i++) {
+						t.vertexUV(xp + 0, yy + h, zp + i + 1 - e, (xx + 0) * uvScale + uo, (zz + i + 0.5f) * uvScale + vo);
+						t.vertexUV(xp + D, yy + h, zp + i + 1 - e, (xx + D) * uvScale + uo, (zz + i + 0.5f) * uvScale + vo);
+						t.vertexUV(xp + D, yy + 0, zp + i + 1 - e, (xx + D) * uvScale + uo, (zz + i + 0.5f) * uvScale + vo);
+						t.vertexUV(xp + 0, yy + 0, zp + i + 1 - e, (xx + 0) * uvScale + uo, (zz + i + 0.5f) * uvScale + vo);
+					}
+				}
+				t.endOverrideAndDraw();
+			}
+		}
+	}
+
+	glPopMatrix();
+	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+	glDisable(GL_BLEND);
+	glEnable(GL_CULL_FACE);
+}
+
 void LevelRenderer::playSound(const std::string& name, float x, float y, float z, float volume, float pitch) {
 	// @todo: deny sounds here if sound is off (rather than waiting 'til SoundEngine)
 	float dd = 16;
@@ -1259,6 +1614,7 @@ void LevelRenderer::renderHitSelect( Player* player, const HitResult& h, int mod
 
 void LevelRenderer::onGraphicsReset()
 {
+	generateStars();
 	generateSky();
 
 	// Get new buffers

src/client/renderer/LevelRenderer.h

@@ -43,7 +43,9 @@ public:
 	void renderDebug(const AABB& b, float a) const;
 
 	void renderSky(float alpha);
+	void generateStars();
 	void renderClouds(float alpha);
+	void renderAdvancedClouds(float alpha);
 	void renderEntities(Vec3 cam, Culler* culler, float a);
     void renderSameAsLast(int layer, float alpha);
 	void renderHit(Player* player, const HitResult& h, int mode, /*ItemInstance*/void* inventoryItem, float a);
@@ -67,6 +69,7 @@ public:
 	void levelEvent(Player* source, int type, int x, int y, int z, int data);
 
 	std::string gatherStats1();
+	std::string gatherStats2();
 
 	void render(const AABB& b) const;
 	void onGraphicsReset();
@@ -116,6 +119,9 @@ private:
 	// shredder added again...
 	int lastFogType;
 
+	bool LastTint;
+	bool LastSideTint;
+
 	int ticks;
     int starList, skyList, darkList;
 
@@ -124,6 +130,12 @@ private:
 	GLuint skyBuffer;
 	int skyVertexCount;
 
+	GLuint voidBuffer;
+	int voidVertexCount;
+
+	GLuint starBuffer;
+	int starVertexCount;
+
 //    /*public*/ std::vector<TileEntity*> renderableTileEntities;
     Textures* textures;
 //    /*private*/ TileRenderer tileRenderer;

src/client/renderer/TileRenderer.cpp

@@ -19,8 +19,10 @@
 #include "tileentity/TileEntityRenderer.h"
 #include "EntityTileRenderer.h"
 
-TileRenderer::TileRenderer( LevelSource* level /* = NULL */ )
-:	level(level),
+bool TileRenderer::sideTinting = false;
+
+TileRenderer::TileRenderer(LevelSource* level /* = NULL */ )
+	:	level(level),
 	fixedTexture(-1),
 	xFlipTexture(false),
 	noCulling(false),
@@ -58,6 +60,11 @@ bool TileRenderer::tesselateBlockInWorld( Tile* tt, int x, int y, int z, float r
 	float c2 = 0.8f;
 	float c3 = 0.6f;
 
+	// added these to get biome color and save it before its overriden - shredder
+	float biomeR = r;
+	float biomeG = g;
+	float biomeB = b;
+
 
 	float r11 = c11 * r;
 	float g11 = c11 * g;
@@ -101,6 +108,10 @@ bool TileRenderer::tesselateBlockInWorld( Tile* tt, int x, int y, int z, float r
 		if (tt->zz0 > 0) br = centerBrightness;
 		t.color(r2 * br, g2 * br, b2 * br);
 		renderNorth(tt, xf, yf, zf, tt->getTexture(level, x, y, z, 2));
+		if ((tt->getTexture(level, x, y, z, 2) == 3) && sideTinting) { // checking if the texture from terrain.png is the normal grass side texture
+			t.color(c2 * br * biomeR, c2 * br * biomeG, c2 * br * biomeB);
+			renderNorth(tt, xf, yf, zf, 38); // rendering an extra face over the side of the cube that is a grayscale grass fringe tinted by t.color using biome colors, kinda inefficient
+		}
 		changed = true;
 	}
 
@@ -109,6 +120,10 @@ bool TileRenderer::tesselateBlockInWorld( Tile* tt, int x, int y, int z, float r
 		if (tt->zz1 < 1) br = centerBrightness;
 		t.color(r2 * br, g2 * br, b2 * br);
 		renderSouth(tt, xf, yf, zf, tt->getTexture(level, x, y, z, 3));
+		if ((tt->getTexture(level, x, y, z, 3) == 3) && sideTinting){ // checking if the texture from terrain.png is the normal grass side texture
+			t.color(c2 * br * biomeR, c2 * br * biomeG, c2 * br * biomeB);
+			renderSouth(tt, xf, yf, zf, 38); // rendering an extra face over the side of the cube that is a grayscale grass fringe tinted by t.color using biome colors, kinda inefficient
+		}
 		changed = true;
 	}
 
@@ -117,6 +132,10 @@ bool TileRenderer::tesselateBlockInWorld( Tile* tt, int x, int y, int z, float r
 		if (tt->xx0 > 0) br = centerBrightness;
 		t.color(r3 * br, g3 * br, b3 * br);
 		renderWest(tt, xf, yf, zf, tt->getTexture(level, x, y, z, 4));
+		if ((tt->getTexture(level, x, y, z, 4) == 3) && sideTinting) { // checking if the texture from terrain.png is the normal grass side texture
+			t.color(c2 * br * biomeR, c2 * br * biomeG, c2 * br * biomeB);
+			renderWest(tt, xf, yf, zf, 38); // rendering an extra face over the side of the cube that is a grayscale grass fringe tinted by t.color using biome colors, kinda inefficient
+		}
 		changed = true;
 	}
 
@@ -125,6 +144,10 @@ bool TileRenderer::tesselateBlockInWorld( Tile* tt, int x, int y, int z, float r
 		if (tt->xx1 < 1) br = centerBrightness;
 		t.color(r3 * br, g3 * br, b3 * br);
 		renderEast(tt, xf, yf, zf, tt->getTexture(level, x, y, z, 5));
+		if ((tt->getTexture(level, x, y, z, 5) == 3) && sideTinting) { // checking if the texture from terrain.png is the normal grass side texture
+			t.color(c2 * br * biomeR, c2 * br * biomeG, c2 * br * biomeB);
+			renderEast(tt, xf, yf, zf, 38); // rendering an extra face over the side of the cube that is a grayscale grass fringe tinted by t.color using biome colors, kinda inefficient
+		}
 		changed = true;
 	}
 
@@ -148,38 +171,38 @@ bool TileRenderer::tesselateInWorld( Tile* tt, int x, int y, int z )
 		return tesselateBlockInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_WATER) {
 		return tesselateWaterInWorld(tt, x, y, z);
-    } else if (shape == Tile::SHAPE_CACTUS) {
-        return tesselateCactusInWorld(tt, x, y, z);
+	} else if (shape == Tile::SHAPE_CACTUS) {
+		return tesselateCactusInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_CROSS_TEXTURE) {
 		return tesselateCrossInWorld(tt, x, y, z);
 	} else if(shape == Tile::SHAPE_STEM) {
 		return tesselateStemInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_ROWS) {
-        return tesselateRowInWorld(tt, x, y, z);
+		return tesselateRowInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_TORCH) {
 		return tesselateTorchInWorld(tt, x, y, z);
-    } else if (shape == Tile::SHAPE_FIRE) {
-        return tesselateFireInWorld(tt, x, y, z);
-    //} else if (shape == Tile::SHAPE_RED_DUST) {
-    //    return tesselateDustInWorld(tt, x, y, z);
+	} else if (shape == Tile::SHAPE_FIRE) {
+		return tesselateFireInWorld(tt, x, y, z);
+		//} else if (shape == Tile::SHAPE_RED_DUST) {
+		//    return tesselateDustInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_LADDER) {
 		return tesselateLadderInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_DOOR) {
 		return tesselateDoorInWorld(tt, x, y, z);
-    //} else if (shape == Tile::SHAPE_RAIL) {
-    //    return tesselateRailInWorld(tt, x, y, z);
+		//} else if (shape == Tile::SHAPE_RAIL) {
+		//    return tesselateRailInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_STAIRS) {
 		return tesselateStairsInWorld((StairTile*)tt, x, y, z);
-    } else if (shape == Tile::SHAPE_FENCE) {
-        return tesselateFenceInWorld((FenceTile*)tt, x, y, z);
+	} else if (shape == Tile::SHAPE_FENCE) {
+		return tesselateFenceInWorld((FenceTile*)tt, x, y, z);
 	} else if (shape == Tile::SHAPE_FENCE_GATE) {
 		return tesselateFenceGateInWorld((FenceGateTile*) tt, x, y, z);
-    //} else if (shape == Tile::SHAPE_LEVER) {
-    //    return tesselateLeverInWorld(tt, x, y, z);
-    //} else if (shape == Tile::SHAPE_BED) {
-    //    return tesselateBedInWorld(tt, x, y, z);
-    //} else if (shape == Tile::SHAPE_DIODE) {
-    //    return tesselateDiodeInWorld(tt, x, y, z);
+		//} else if (shape == Tile::SHAPE_LEVER) {
+		//    return tesselateLeverInWorld(tt, x, y, z);
+		//} else if (shape == Tile::SHAPE_BED) {
+		//    return tesselateBedInWorld(tt, x, y, z);
+		//} else if (shape == Tile::SHAPE_DIODE) {
+		//    return tesselateDiodeInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_IRON_FENCE) {
 		return tesselateThinFenceInWorld((ThinFenceTile*) tt, x, y, z);
 	} else if(shape == Tile::SHAPE_BED) {
@@ -232,10 +255,10 @@ bool TileRenderer::tesselateFireInWorld( Tile* tt, int x, int y, int z )
 	int tex = tt->getTexture(0);
 
 	if (fixedTexture >= 0) tex = fixedTexture;
-	
+
 	float br = tt->getBrightness( level, x, y, z );
 	t.color( br, br, br );
-	
+
 	int xt = ((tex & 0xf) << 4);
 	int yt = tex & 0xf0;
 
@@ -340,82 +363,82 @@ bool TileRenderer::tesselateFireInWorld( Tile* tt, int x, int y, int z )
 		if ( Tile::fire->canBurn( level, x - 1, y, z ) )
 		{
 			t.vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
-						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+				1.0f ), ( float )( u1 ), ( float )( v0 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+				1.0f ), ( float )( u1 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+				0.0f ), ( float )( u0 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+				0.0f ), ( float )( u0 ), ( float )( v0 ) );
 
 			t.vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+				0.0f ), ( float )( u0 ), ( float )( v0 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+				0.0f ), ( float )( u0 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+				1.0f ), ( float )( u1 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
-						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+				1.0f ), ( float )( u1 ), ( float )( v0 ) );
 		}
 		if ( Tile::fire->canBurn( level, x + 1, y, z ) )
 		{
 			t.vertexUV( ( float )( x + 1 - r ), ( float )( y + h + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+				0.0f ), ( float )( u0 ), ( float )( v0 ) );
 			t.vertexUV( ( float )( x + 1 - 0 ), ( float )( y + 0 + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+				0.0f ), ( float )( u0 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 1 - 0 ), ( float )( y + 0 + yo ), ( float )( z +
-						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+				1.0f ), ( float )( u1 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 1 - r ), ( float )( y + h + yo ), ( float )( z +
-						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+				1.0f ), ( float )( u1 ), ( float )( v0 ) );
 
 			t.vertexUV( ( float )( x + 1.0f - r ), ( float )( y + h + yo ), ( float )( z +
-						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+				1.0f ), ( float )( u1 ), ( float )( v0 ) );
 			t.vertexUV( ( float )( x + 1.0f - 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+				1.0f ), ( float )( u1 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 1.0f - 0 ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+				0.0f ), ( float )( u0 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 1.0f - r ), ( float )( y + h + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+				0.0f ), ( float )( u0 ), ( float )( v0 ) );
 		}
 		if ( Tile::fire->canBurn( level, x, y, z - 1 ) )
 		{
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z +
-						 r ), ( float )( u1 ), ( float )( v0 ) );
+				r ), ( float )( u1 ), ( float )( v0 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+				0.0f ), ( float )( u1 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+				0.0f ), ( float )( u0 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z +
-						 r ), ( float )( u0 ), ( float )( v0 ) );
+				r ), ( float )( u0 ), ( float )( v0 ) );
 
 			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z +
-						 r ), ( float )( u0 ), ( float )( v0 ) );
+				r ), ( float )( u0 ), ( float )( v0 ) );
 			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+				0.0f ), ( float )( u0 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
-						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+				0.0f ), ( float )( u1 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z +
-						 r ), ( float )( u1 ), ( float )( v0 ) );
+				r ), ( float )( u1 ), ( float )( v0 ) );
 		}
 		if ( Tile::fire->canBurn( level, x, y, z + 1 ) )
 		{
 			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
-						 r ), ( float )( u0 ), ( float )( v0 ) );
+				r ), ( float )( u0 ), ( float )( v0 ) );
 			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
-						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+				0.0f ), ( float )( u0 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
-						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+				0.0f ), ( float )( u1 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
-						 r ), ( float )( u1 ), ( float )( v0 ) );
+				r ), ( float )( u1 ), ( float )( v0 ) );
 
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
-						 r ), ( float )( u1 ), ( float )( v0 ) );
+				r ), ( float )( u1 ), ( float )( v0 ) );
 			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
-						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+				0.0f ), ( float )( u1 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
-						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+				0.0f ), ( float )( u0 ), ( float )( v1 ) );
 			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
-						 r ), ( float )( u0 ), ( float )( v0 ) );
+				r ), ( float )( u0 ), ( float )( v0 ) );
 		}
 		if ( Tile::fire->canBurn( level, x, y + 1.0f, z ) )
 		{
@@ -440,13 +463,13 @@ bool TileRenderer::tesselateFireInWorld( Tile* tt, int x, int y, int z )
 			if ( ( ( x + y + z ) & 1 ) == 0 )
 			{
 				t.vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z +
-							 0 ), ( float )( u1 ), ( float )( v0 ) );
+					0 ), ( float )( u1 ), ( float )( v0 ) );
 				t.vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z +
-							 0 ), ( float )( u1 ), ( float )( v1 ) );
+					0 ), ( float )( u1 ), ( float )( v1 ) );
 				t.vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z +
-							 1 ), ( float )( u0 ), ( float )( v1 ) );
+					1 ), ( float )( u0 ), ( float )( v1 ) );
 				t.vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z +
-							 1 ), ( float )( u0 ), ( float )( v0 ) );
+					1 ), ( float )( u0 ), ( float )( v0 ) );
 
 				u0 = (xt) / 256.0f;
 				u1 = (xt + 15.99f) / 256.0f;
@@ -454,24 +477,24 @@ bool TileRenderer::tesselateFireInWorld( Tile* tt, int x, int y, int z )
 				v1 = (yt + 15.99f) / 256.0f;
 
 				t.vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z +
-							 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+					1.0f ), ( float )( u1 ), ( float )( v0 ) );
 				t.vertexUV( ( float )( x1 ), ( float )( y + 0.0f ), ( float )( z +
-							 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+					1.0f ), ( float )( u1 ), ( float )( v1 ) );
 				t.vertexUV( ( float )( x1 ), ( float )( y + 0.0f ), ( float )( z +
-							 0 ), ( float )( u0 ), ( float )( v1 ) );
+					0 ), ( float )( u0 ), ( float )( v1 ) );
 				t.vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z +
-							 0 ), ( float )( u0 ), ( float )( v0 ) );
+					0 ), ( float )( u0 ), ( float )( v0 ) );
 			}
 			else
 			{
 				t.vertexUV( ( float )( x + 0.0f ), ( float )( y +
-							 h ), ( float )( z1_ ), ( float )( u1 ), ( float )( v0 ) );
+					h ), ( float )( z1_ ), ( float )( u1 ), ( float )( v0 ) );
 				t.vertexUV( ( float )( x + 0.0f ), ( float )( y +
-							 0.0f ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+					0.0f ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
 				t.vertexUV( ( float )( x + 1.0f ), ( float )( y +
-							 0.0f ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+					0.0f ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
 				t.vertexUV( ( float )( x + 1.0f ), ( float )( y +
-							 h ), ( float )( z1_ ), ( float )( u0 ), ( float )( v0 ) );
+					h ), ( float )( z1_ ), ( float )( u0 ), ( float )( v0 ) );
 
 				u0 = (xt) / 256.0f;
 				u1 = (xt + 15.99f) / 256.0f;
@@ -479,13 +502,13 @@ bool TileRenderer::tesselateFireInWorld( Tile* tt, int x, int y, int z )
 				v1 = (yt + 15.99f) / 256.0f;
 
 				t.vertexUV( ( float )( x + 1.0f ), ( float )( y +
-							 h ), ( float )( z0_ ), ( float )( u1 ), ( float )( v0 ) );
+					h ), ( float )( z0_ ), ( float )( u1 ), ( float )( v0 ) );
 				t.vertexUV( ( float )( x + 1.0f ), ( float )( y +
-							 0.0f ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+					0.0f ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
 				t.vertexUV( ( float )( x + 0.0f ), ( float )( y +
-							 0.0f ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+					0.0f ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
 				t.vertexUV( ( float )( x + 0.0f ), ( float )( y +
-							 h ), ( float )( z0_ ), ( float )( u0 ), ( float )( v0 ) );
+					h ), ( float )( z0_ ), ( float )( u0 ), ( float )( v0 ) );
 			}
 		}
 	}
@@ -958,46 +981,46 @@ float TileRenderer::getWaterHeight( int x, int y, int z, const Material* m )
 }
 
 void TileRenderer::renderBlock(Tile* tt, LevelSource* level, int x, int y, int z) {
-    float c10 = 0.5f;
-    float c11 = 1;
-    float c2 = 0.8f;
-    float c3 = 0.6f;
+	float c10 = 0.5f;
+	float c11 = 1;
+	float c2 = 0.8f;
+	float c3 = 0.6f;
 
-    Tesselator& t = Tesselator::instance;
-    t.begin();
+	Tesselator& t = Tesselator::instance;
+	t.begin();
 
-    float center = tt->getBrightness(level, x, y, z);
-    float br = tt->getBrightness(level, x, y - 1, z);
-    if (br < center) br = center;
+	float center = tt->getBrightness(level, x, y, z);
+	float br = tt->getBrightness(level, x, y - 1, z);
+	if (br < center) br = center;
 
-    t.color(c10 * br, c10 * br, c10 * br);
-    renderFaceDown(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(0));
+	t.color(c10 * br, c10 * br, c10 * br);
+	renderFaceDown(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(0));
 
-    br = tt->getBrightness(level, x, y + 1, z);
-    if (br < center) br = center;
-    t.color(c11 * br, c11 * br, c11 * br);
-    renderFaceUp(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(1));
+	br = tt->getBrightness(level, x, y + 1, z);
+	if (br < center) br = center;
+	t.color(c11 * br, c11 * br, c11 * br);
+	renderFaceUp(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(1));
 
-    br = tt->getBrightness(level, x, y, z - 1);
-    if (br < center) br = center;
-    t.color(c2 * br, c2 * br, c2 * br);
-    renderNorth(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(2));
+	br = tt->getBrightness(level, x, y, z - 1);
+	if (br < center) br = center;
+	t.color(c2 * br, c2 * br, c2 * br);
+	renderNorth(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(2));
 
-    br = tt->getBrightness(level, x, y, z + 1);
-    if (br < center) br = center;
-    t.color(c2 * br, c2 * br, c2 * br);
-    renderSouth(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(3));
+	br = tt->getBrightness(level, x, y, z + 1);
+	if (br < center) br = center;
+	t.color(c2 * br, c2 * br, c2 * br);
+	renderSouth(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(3));
 
-    br = tt->getBrightness(level, x - 1, y, z);
-    if (br < center) br = center;
-    t.color(c3 * br, c3 * br, c3 * br);
-    renderWest(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(4));
+	br = tt->getBrightness(level, x - 1, y, z);
+	if (br < center) br = center;
+	t.color(c3 * br, c3 * br, c3 * br);
+	renderWest(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(4));
 
-    br = tt->getBrightness(level, x + 1, y, z);
-    if (br < center) br = center;
-    t.color(c3 * br, c3 * br, c3 * br);
-    renderEast(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(5));
-    t.draw();
+	br = tt->getBrightness(level, x + 1, y, z);
+	if (br < center) br = center;
+	t.color(c3 * br, c3 * br, c3 * br);
+	renderEast(tt, -0.5f, -0.5f, -0.5f, tt->getTexture(5));
+	t.draw();
 }
 
 bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusion( Tile* tt, int pX, int pY, int pZ, float pBaseRed, float pBaseGreen, float pBaseBlue )
@@ -1197,6 +1220,15 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusion( Tile* tt, int pX,
 		c4g *= ll4;
 		c4b *= ll4;
 		renderNorth(tt, (float) pX, (float) pY, (float) pZ, tt->getTexture(level, pX, pY, pZ, 2));
+		if (tt->getTexture(level, pX, pY, pZ, 2) == 3 && sideTinting) 
+		{
+			c1r *= pBaseRed; c1g *= pBaseGreen; c1b *= pBaseBlue;
+			c2r *= pBaseRed; c2g *= pBaseGreen; c2b *= pBaseBlue;
+			c3r *= pBaseRed; c3g *= pBaseGreen; c3b *= pBaseBlue;
+			c4r *= pBaseRed; c4g *= pBaseGreen; c4b *= pBaseBlue;
+
+			renderNorth(tt, (float) pX, (float) pY, (float) pZ, 38);
+		}
 		i = true;
 	}
 	if ((noCulling) || (tt->shouldRenderFace(level, pX, pY, pZ + 1, 3))) {
@@ -1250,6 +1282,15 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusion( Tile* tt, int pX,
 		c4g *= ll4;
 		c4b *= ll4;
 		renderSouth(tt, (float) pX, (float) pY, (float) pZ, tt->getTexture(level, pX, pY, pZ, 3));
+		if (tt->getTexture(level, pX, pY, pZ, 3) == 3 && sideTinting) 
+		{
+			c1r *= pBaseRed; c1g *= pBaseGreen; c1b *= pBaseBlue;
+			c2r *= pBaseRed; c2g *= pBaseGreen; c2b *= pBaseBlue;
+			c3r *= pBaseRed; c3g *= pBaseGreen; c3b *= pBaseBlue;
+			c4r *= pBaseRed; c4g *= pBaseGreen; c4b *= pBaseBlue;
+
+			renderSouth(tt, (float) pX, (float) pY, (float) pZ, 38);
+		}
 		i = true;
 	}
 	if ((noCulling) || (tt->shouldRenderFace(level, pX - 1, pY, pZ, 4))) {
@@ -1302,6 +1343,15 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusion( Tile* tt, int pX,
 		c4g *= ll4;
 		c4b *= ll4;
 		renderWest(tt, (float) pX, (float) pY, (float) pZ, tt->getTexture(level, pX, pY, pZ, 4));
+		if (tt->getTexture(level, pX, pY, pZ, 4) == 3 && sideTinting) 
+		{
+			c1r *= pBaseRed; c1g *= pBaseGreen; c1b *= pBaseBlue;
+			c2r *= pBaseRed; c2g *= pBaseGreen; c2b *= pBaseBlue;
+			c3r *= pBaseRed; c3g *= pBaseGreen; c3b *= pBaseBlue;
+			c4r *= pBaseRed; c4g *= pBaseGreen; c4b *= pBaseBlue;
+
+			renderWest(tt, (float) pX, (float) pY, (float) pZ, 38);
+		}
 		i = true;
 	}
 	if ((noCulling) || (tt->shouldRenderFace(level, pX + 1, pY, pZ, 5))) {
@@ -1355,6 +1405,15 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusion( Tile* tt, int pX,
 		c4b *= ll4;
 
 		renderEast(tt, (float) pX, (float) pY, (float) pZ, tt->getTexture(level, pX, pY, pZ, 5));
+		if (tt->getTexture(level, pX, pY, pZ, 5) == 3 && sideTinting) 
+		{
+			c1r *= pBaseRed; c1g *= pBaseGreen; c1b *= pBaseBlue;
+			c2r *= pBaseRed; c2g *= pBaseGreen; c2b *= pBaseBlue;
+			c3r *= pBaseRed; c3g *= pBaseGreen; c3b *= pBaseBlue;
+			c4r *= pBaseRed; c4g *= pBaseGreen; c4b *= pBaseBlue;
+
+			renderEast(tt, (float) pX, (float) pY, (float) pZ, 38);
+		}
 		i = true;
 	}
 	applyAmbienceOcclusion = false;
@@ -1362,124 +1421,124 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusion( Tile* tt, int pX,
 }
 
 bool TileRenderer::tesselateCactusInWorld(Tile* tt, int x, int y, int z) {
-    int col = tt->getColor(level, x, y, z);
-    float r = ((col >> 16) & 0xff) / 255.0f;
-    float g = ((col >> 8) & 0xff) / 255.0f;
-    float b = ((col) & 0xff) / 255.0f;
-    return tesselateCactusInWorld(tt, x, y, z, r, g, b);
+	int col = tt->getColor(level, x, y, z);
+	float r = ((col >> 16) & 0xff) / 255.0f;
+	float g = ((col >> 8) & 0xff) / 255.0f;
+	float b = ((col) & 0xff) / 255.0f;
+	return tesselateCactusInWorld(tt, x, y, z, r, g, b);
 }
 
 bool TileRenderer::tesselateCactusInWorld(Tile* tt, int x, int y, int z, float r, float g, float b) {
-    Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
 
-    bool changed = false;
-    float c10 = 0.5f;
-    float c11 = 1;
-    float c2 = 0.8f;
-    float c3 = 0.6f;
+	bool changed = false;
+	float c10 = 0.5f;
+	float c11 = 1;
+	float c2 = 0.8f;
+	float c3 = 0.6f;
 
-    float r10 = c10 * r;
-    float r11 = c11 * r;
-    float r2 = c2 * r;
-    float r3 = c3 * r;
+	float r10 = c10 * r;
+	float r11 = c11 * r;
+	float r2 = c2 * r;
+	float r3 = c3 * r;
 
-    float g10 = c10 * g;
-    float g11 = c11 * g;
-    float g2 = c2 * g;
-    float g3 = c3 * g;
+	float g10 = c10 * g;
+	float g11 = c11 * g;
+	float g2 = c2 * g;
+	float g3 = c3 * g;
 
-    float b10 = c10 * b;
-    float b11 = c11 * b;
-    float b2 = c2 * b;
-    float b3 = c3 * b;
+	float b10 = c10 * b;
+	float b11 = c11 * b;
+	float b2 = c2 * b;
+	float b3 = c3 * b;
 
-    float s = 1 / 16.0f;
+	float s = 1 / 16.0f;
 	const float X = (float)x;
 	const float Y = (float)y;
 	const float Z = (float)z;
 
-    float centerBrightness = tt->getBrightness(level, x, y, z);
+	float centerBrightness = tt->getBrightness(level, x, y, z);
 
-    if (noCulling || tt->shouldRenderFace(level, x, y - 1, z, 0)) {
-        float br = tt->getBrightness(level, x, y - 1, z);
-        // if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
-// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
-        t.color(r10 * br, g10 * br, b10 * br);
-        renderFaceDown(tt, X, Y, Z, tt->getTexture(level, x, y, z, 0));
-        changed = true;
-    }
+	if (noCulling || tt->shouldRenderFace(level, x, y - 1, z, 0)) {
+		float br = tt->getBrightness(level, x, y - 1, z);
+		// if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
+		// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
+		t.color(r10 * br, g10 * br, b10 * br);
+		renderFaceDown(tt, X, Y, Z, tt->getTexture(level, x, y, z, 0));
+		changed = true;
+	}
 
-    if (noCulling || tt->shouldRenderFace(level, x, y + 1, z, 1)) {
-        float br = tt->getBrightness(level, x, y + 1, z);
-        if (tt->yy1 != 1 && !tt->material->isLiquid()) br = centerBrightness;
-        // if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
-// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
-        t.color(r11 * br, g11 * br, b11 * br);
-        renderFaceUp(tt, X, Y, Z, tt->getTexture(level, x, y, z, 1));
-        changed = true;
-    }
+	if (noCulling || tt->shouldRenderFace(level, x, y + 1, z, 1)) {
+		float br = tt->getBrightness(level, x, y + 1, z);
+		if (tt->yy1 != 1 && !tt->material->isLiquid()) br = centerBrightness;
+		// if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
+		// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
+		t.color(r11 * br, g11 * br, b11 * br);
+		renderFaceUp(tt, X, Y, Z, tt->getTexture(level, x, y, z, 1));
+		changed = true;
+	}
 
-    if (noCulling || tt->shouldRenderFace(level, x, y, z - 1, 2)) {
-        float br = tt->getBrightness(level, x, y, z - 1);
-        if (tt->zz0 > 0) br = centerBrightness;
-        // if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
-// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
-        t.color(r2 * br, g2 * br, b2 * br);
-        t.addOffset(0, 0, s);
-        renderNorth(tt, X, Y, Z, tt->getTexture(level, x, y, z, 2));
-        t.addOffset(0, 0, -s);
-        changed = true;
-    }
+	if (noCulling || tt->shouldRenderFace(level, x, y, z - 1, 2)) {
+		float br = tt->getBrightness(level, x, y, z - 1);
+		if (tt->zz0 > 0) br = centerBrightness;
+		// if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
+		// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
+		t.color(r2 * br, g2 * br, b2 * br);
+		t.addOffset(0, 0, s);
+		renderNorth(tt, X, Y, Z, tt->getTexture(level, x, y, z, 2));
+		t.addOffset(0, 0, -s);
+		changed = true;
+	}
 
-    if (noCulling || tt->shouldRenderFace(level, x, y, z + 1, 3)) {
-        float br = tt->getBrightness(level, x, y, z + 1);
-        if (tt->zz1 < 1) br = centerBrightness;
-        // if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
-// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
-        t.color(r2 * br, g2 * br, b2 * br);
-        t.addOffset(0, 0, -s);
-        renderSouth(tt, X, Y, Z, tt->getTexture(level, x, y, z, 3));
-        t.addOffset(0, 0, s);
-        changed = true;
-    }
+	if (noCulling || tt->shouldRenderFace(level, x, y, z + 1, 3)) {
+		float br = tt->getBrightness(level, x, y, z + 1);
+		if (tt->zz1 < 1) br = centerBrightness;
+		// if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
+		// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
+		t.color(r2 * br, g2 * br, b2 * br);
+		t.addOffset(0, 0, -s);
+		renderSouth(tt, X, Y, Z, tt->getTexture(level, x, y, z, 3));
+		t.addOffset(0, 0, s);
+		changed = true;
+	}
 
-    if (noCulling || tt->shouldRenderFace(level, x - 1, y, z, 4)) {
-        float br = tt->getBrightness(level, x - 1, y, z);
-        if (tt->xx0 > 0) br = centerBrightness;
-        // if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
-// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
-        t.color(r3 * br, g3 * br, b3 * br);
-        t.addOffset(s, 0, 0);
-        renderWest(tt, X, Y, Z, tt->getTexture(level, x, y, z, 4));
-        t.addOffset(-s, 0, 0);
-        changed = true;
-    }
+	if (noCulling || tt->shouldRenderFace(level, x - 1, y, z, 4)) {
+		float br = tt->getBrightness(level, x - 1, y, z);
+		if (tt->xx0 > 0) br = centerBrightness;
+		// if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
+		// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
+		t.color(r3 * br, g3 * br, b3 * br);
+		t.addOffset(s, 0, 0);
+		renderWest(tt, X, Y, Z, tt->getTexture(level, x, y, z, 4));
+		t.addOffset(-s, 0, 0);
+		changed = true;
+	}
 
-    if (noCulling || tt->shouldRenderFace(level, x + 1, y, z, 5)) {
-        float br = tt->getBrightness(level, x + 1, y, z);
-        if (tt->xx1 < 1) br = centerBrightness;
-        // if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
-// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
-        t.color(r3 * br, g3 * br, b3 * br);
-        t.addOffset(-s, 0, 0);
-        renderEast(tt, X, Y, Z, tt->getTexture(level, x, y, z, 5));
-        t.addOffset(s, 0, 0);
-        changed = true;
-    }
+	if (noCulling || tt->shouldRenderFace(level, x + 1, y, z, 5)) {
+		float br = tt->getBrightness(level, x + 1, y, z);
+		if (tt->xx1 < 1) br = centerBrightness;
+		// if (Tile::lightEmission[tt->id] > br*Level.MAX_BRIGHTNESS) br =
+		// Tile::lightEmission[tt->id]/Level.MAX_BRIGHTNESS;
+		t.color(r3 * br, g3 * br, b3 * br);
+		t.addOffset(-s, 0, 0);
+		renderEast(tt, X, Y, Z, tt->getTexture(level, x, y, z, 5));
+		t.addOffset(s, 0, 0);
+		changed = true;
+	}
 
-    return changed;
+	return changed;
 }
 
 bool TileRenderer::tesselateFenceInWorld(FenceTile* tt, int x, int y, int z) {
-    bool changed = true;
+	bool changed = true;
 
-    float a = 6 / 16.0f;
-    float b = 10 / 16.0f;
-    tt->setShape(a, 0, a, b, 1, b);
-    tesselateBlockInWorld(tt, x, y, z);
+	float a = 6 / 16.0f;
+	float b = 10 / 16.0f;
+	tt->setShape(a, 0, a, b, 1, b);
+	tesselateBlockInWorld(tt, x, y, z);
 
-    bool vertical = false;
-    bool horizontal = false;
+	bool vertical = false;
+	bool horizontal = false;
 
 	bool l = tt->connectsTo(level, x - 1, y, z);
 	bool r = tt->connectsTo(level, x + 1, y, z);
@@ -1487,42 +1546,42 @@ bool TileRenderer::tesselateFenceInWorld(FenceTile* tt, int x, int y, int z) {
 	bool d = tt->connectsTo(level, x, y, z + 1);
 
 	if (l || r) vertical = true;
-    if (u || d) horizontal = true;
+	if (u || d) horizontal = true;
 
-    if (!vertical && !horizontal) vertical = true;
+	if (!vertical && !horizontal) vertical = true;
 
-    a = 7 / 16.0f;
-    b = 9 / 16.0f;
-    float h0 = 12 / 16.0f;
-    float h1 = 15 / 16.0f;
+	a = 7 / 16.0f;
+	b = 9 / 16.0f;
+	float h0 = 12 / 16.0f;
+	float h1 = 15 / 16.0f;
 
-    float x0 = l ? 0 : a;
-    float x1 = r ? 1 : b;
-    float z0 = u ? 0 : a;
-    float z1 = d ? 1 : b;
+	float x0 = l ? 0 : a;
+	float x1 = r ? 1 : b;
+	float z0 = u ? 0 : a;
+	float z1 = d ? 1 : b;
 
-    if (vertical) {
-        tt->setShape(x0, h0, a, x1, h1, b);
-        tesselateBlockInWorld(tt, x, y, z);
-    }
-    if (horizontal) {
-        tt->setShape(a, h0, z0, b, h1, z1);
-        tesselateBlockInWorld(tt, x, y, z);
-    }
+	if (vertical) {
+		tt->setShape(x0, h0, a, x1, h1, b);
+		tesselateBlockInWorld(tt, x, y, z);
+	}
+	if (horizontal) {
+		tt->setShape(a, h0, z0, b, h1, z1);
+		tesselateBlockInWorld(tt, x, y, z);
+	}
 
-    h0 = 6 / 16.0f;
-    h1 = 9 / 16.0f;
-    if (vertical) {
-        tt->setShape(x0, h0, a, x1, h1, b);
-        tesselateBlockInWorld(tt, x, y, z);
-    }
-    if (horizontal) {
-        tt->setShape(a, h0, z0, b, h1, z1);
-        tesselateBlockInWorld(tt, x, y, z);
-    }
+	h0 = 6 / 16.0f;
+	h1 = 9 / 16.0f;
+	if (vertical) {
+		tt->setShape(x0, h0, a, x1, h1, b);
+		tesselateBlockInWorld(tt, x, y, z);
+	}
+	if (horizontal) {
+		tt->setShape(a, h0, z0, b, h1, z1);
+		tesselateBlockInWorld(tt, x, y, z);
+	}
 
-    tt->setShape(0, 0, 0, 1, 1, 1);
-    return changed;
+	tt->setShape(0, 0, 0, 1, 1, 1);
+	return changed;
 }
 
 bool TileRenderer::tesselateFenceGateInWorld(FenceGateTile* tt, int x, int y, int z) {
@@ -2308,7 +2367,7 @@ void TileRenderer::renderEast( Tile* tt, float x, float y, float z, int tex )
 void TileRenderer::renderTile( Tile* tile, int data )
 {
 	Tesselator& t = Tesselator::instance;
-		
+
 	t.color(0xff, 0xff, 0xff); // i disabled this, this is normally enabled in normal mcpe see if this fits OPTION_NORMAL_LIGHTING - shredder
 	int shape = tile->getRenderShape();
 
@@ -2324,7 +2383,7 @@ void TileRenderer::renderTile( Tile* tile, int data )
 		t.normal(0.0f, 1.0f, 0.0f); 
 
 		renderFaceUp(tile, 0, 0, 0, tile->getTexture(1, data));
-		
+
 		t.normal(0.0f, 0.0f, -1.0f);
 
 		renderNorth(tile, 0, 0, 0, tile->getTexture(2, data));
@@ -2403,110 +2462,110 @@ void TileRenderer::renderTile( Tile* tile, int data )
 		t.addOffset(s, 0, 0);
 		t.draw();
 		t.offset(0, 0, 0);//0.5f, 0.5f, 0.5f);
-		} else if (shape == Tile::SHAPE_ROWS) {
-			t.begin();
-			t.normal(0, -1, 0);
-			tesselateRowTexture(tile, data, -0.5f, -0.5f, -0.5f);
+	} else if (shape == Tile::SHAPE_ROWS) {
+		t.begin();
+		t.normal(0, -1, 0);
+		tesselateRowTexture(tile, data, -0.5f, -0.5f, -0.5f);
 		//}  else if (shape == Tile::SHAPE_TORCH) {
 		////    t.begin();
 		////    t.normal(0, -1, 0);
 		///    tesselateTorch(tile, -0.5f, -0.5f, -0.5f, 0, 0);
 		////    t.end();
-        } else if (shape == Tile::SHAPE_ENTITYTILE_ANIMATED) {
-            EntityTileRenderer::instance->render(tile, data, 1.0f);
-            //glEnable(GL_RESCALE_NORMAL);
-		} else if (shape == Tile::SHAPE_STAIRS) {
-		    t.addOffset(-0.5f, -0.5f, -0.5f);
-			t.begin();
-			for (int i = 0; i < 2; i++) {
-		        if (i == 0) tile->setShape(0, 0, 0, 1, 1, 0.5f);
-		        if (i == 1) tile->setShape(0, 0, 0.5f, 1, 0.5f, 1);
+	} else if (shape == Tile::SHAPE_ENTITYTILE_ANIMATED) {
+		EntityTileRenderer::instance->render(tile, data, 1.0f);
+		//glEnable(GL_RESCALE_NORMAL);
+	} else if (shape == Tile::SHAPE_STAIRS) {
+		t.addOffset(-0.5f, -0.5f, -0.5f);
+		t.begin();
+		for (int i = 0; i < 2; i++) {
+			if (i == 0) tile->setShape(0, 0, 0, 1, 1, 0.5f);
+			if (i == 1) tile->setShape(0, 0, 0.5f, 1, 0.5f, 1);
 
 
-				t.normal(0.0f, -1.0f, 0.0f);
-		        renderFaceDown(tile, 0, 0, 0, tile->getTexture(0));
+			t.normal(0.0f, -1.0f, 0.0f);
+			renderFaceDown(tile, 0, 0, 0, tile->getTexture(0));
 
-				t.normal(0.0f, 1.0f, 0.0f);
-		        renderFaceUp(tile, 0, 0, 0, tile->getTexture(1));
+			t.normal(0.0f, 1.0f, 0.0f);
+			renderFaceUp(tile, 0, 0, 0, tile->getTexture(1));
 
-				t.normal(0.0f, 0.0f, -1.0f);
-		        renderNorth(tile, 0, 0, 0, tile->getTexture(2));
+			t.normal(0.0f, 0.0f, -1.0f);
+			renderNorth(tile, 0, 0, 0, tile->getTexture(2));
 
-				t.normal(0.0f, 0.0f, 1.0f);
-		        renderSouth(tile, 0, 0, 0, tile->getTexture(3));
+			t.normal(0.0f, 0.0f, 1.0f);
+			renderSouth(tile, 0, 0, 0, tile->getTexture(3));
 
-				t.normal(-1.0f, 0.0f, 0.0f);
-		        renderWest(tile, 0, 0, 0, tile->getTexture(4));
+			t.normal(-1.0f, 0.0f, 0.0f);
+			renderWest(tile, 0, 0, 0, tile->getTexture(4));
 
-				t.normal(1.0f, 0.0f, 0.0f);
-		        renderEast(tile, 0, 0, 0, tile->getTexture(5));
-		    }
-			t.draw();
-			t.addOffset(0.5f, 0.5f, 0.5f);
+			t.normal(1.0f, 0.0f, 0.0f);
+			renderEast(tile, 0, 0, 0, tile->getTexture(5));
 		}
-		else if (shape == Tile::SHAPE_FENCE) {
-			t.addOffset(-0.5f, -0.5f, -0.5f);
-			t.begin();
-			for (int i = 0; i < 4; i++) {
-				float w = 2 / 16.0f;
-				if (i == 0) tile->setShape(0.5f - w, 0, 0, 0.5f + w, 1, w * 2);
-				if (i == 1) tile->setShape(0.5f - w, 0, 1 - w * 2, 0.5f + w, 1, 1);
-				w = 1 / 16.0f;
-				if (i == 2) tile->setShape(0.5f - w, 1 - w * 3, -w * 2, 0.5f + w, 1 - w, 1 + w * 2);
-				if (i == 3) tile->setShape(0.5f - w, 0.5f - w * 3, -w * 2, 0.5f + w, 0.5f - w, 1 + w * 2);
+		t.draw();
+		t.addOffset(0.5f, 0.5f, 0.5f);
+	}
+	else if (shape == Tile::SHAPE_FENCE) {
+		t.addOffset(-0.5f, -0.5f, -0.5f);
+		t.begin();
+		for (int i = 0; i < 4; i++) {
+			float w = 2 / 16.0f;
+			if (i == 0) tile->setShape(0.5f - w, 0, 0, 0.5f + w, 1, w * 2);
+			if (i == 1) tile->setShape(0.5f - w, 0, 1 - w * 2, 0.5f + w, 1, 1);
+			w = 1 / 16.0f;
+			if (i == 2) tile->setShape(0.5f - w, 1 - w * 3, -w * 2, 0.5f + w, 1 - w, 1 + w * 2);
+			if (i == 3) tile->setShape(0.5f - w, 0.5f - w * 3, -w * 2, 0.5f + w, 0.5f - w, 1 + w * 2);
 
-				t.normal(0.0f, -1.0f, 0.0f);
-		        renderFaceDown(tile, 0, 0, 0, tile->getTexture(0));
+			t.normal(0.0f, -1.0f, 0.0f);
+			renderFaceDown(tile, 0, 0, 0, tile->getTexture(0));
 
-				t.normal(0.0f, 1.0f, 0.0f);
-		        renderFaceUp(tile, 0, 0, 0, tile->getTexture(1));
+			t.normal(0.0f, 1.0f, 0.0f);
+			renderFaceUp(tile, 0, 0, 0, tile->getTexture(1));
 
-				t.normal(0.0f, 0.0f, -1.0f);
-		        renderNorth(tile, 0, 0, 0, tile->getTexture(2));
+			t.normal(0.0f, 0.0f, -1.0f);
+			renderNorth(tile, 0, 0, 0, tile->getTexture(2));
 
-				t.normal(0.0f, 0.0f, 1.0f);
-		        renderSouth(tile, 0, 0, 0, tile->getTexture(3));
+			t.normal(0.0f, 0.0f, 1.0f);
+			renderSouth(tile, 0, 0, 0, tile->getTexture(3));
 
-				t.normal(-1.0f, 0.0f, 0.0f);
-		        renderWest(tile, 0, 0, 0, tile->getTexture(4));
+			t.normal(-1.0f, 0.0f, 0.0f);
+			renderWest(tile, 0, 0, 0, tile->getTexture(4));
 
-				t.normal(1.0f, 0.0f, 0.0f);
-		        renderEast(tile, 0, 0, 0, tile->getTexture(5));
-			}
-			t.draw();
-			t.addOffset(0.5f, 0.5f, 0.5f);
-			tile->setShape(0, 0, 0, 1, 1, 1);
-		} else if (shape == Tile::SHAPE_FENCE_GATE) {
-			t.addOffset(-0.5f, -0.5f, -0.5f);
-			t.begin();
-			for (int i = 0; i < 3; i++) {
-				float w = 1 / 16.0f;
-				if (i == 0) tile->setShape(0.5f - w, .3f, 0, 0.5f + w, 1, w * 2);
-				if (i == 1) tile->setShape(0.5f - w, .3f, 1 - w * 2, 0.5f + w, 1, 1);
-				if (i == 2) tile->setShape(0.5f - w, .5f, w * 2, 0.5f + w, 1 - w, 1 - w * 2);
-
-								t.normal(0.0f, -1.0f, 0.0f);
-		        renderFaceDown(tile, 0, 0, 0, tile->getTexture(0));
-
-				t.normal(0.0f, 1.0f, 0.0f);
-		        renderFaceUp(tile, 0, 0, 0, tile->getTexture(1));
-
-				t.normal(0.0f, 0.0f, -1.0f);
-		        renderNorth(tile, 0, 0, 0, tile->getTexture(2));
-
-				t.normal(0.0f, 0.0f, 1.0f);
-		        renderSouth(tile, 0, 0, 0, tile->getTexture(3));
-
-				t.normal(-1.0f, 0.0f, 0.0f);
-		        renderWest(tile, 0, 0, 0, tile->getTexture(4));
-
-				t.normal(1.0f, 0.0f, 0.0f);
-		        renderEast(tile, 0, 0, 0, tile->getTexture(5));
-			}
-			t.draw();
-			t.addOffset(0.5f, 0.5f, 0.5f);
-			tile->setShape(0, 0, 0, 1, 1, 1);
+			t.normal(1.0f, 0.0f, 0.0f);
+			renderEast(tile, 0, 0, 0, tile->getTexture(5));
 		}
+		t.draw();
+		t.addOffset(0.5f, 0.5f, 0.5f);
+		tile->setShape(0, 0, 0, 1, 1, 1);
+	} else if (shape == Tile::SHAPE_FENCE_GATE) {
+		t.addOffset(-0.5f, -0.5f, -0.5f);
+		t.begin();
+		for (int i = 0; i < 3; i++) {
+			float w = 1 / 16.0f;
+			if (i == 0) tile->setShape(0.5f - w, .3f, 0, 0.5f + w, 1, w * 2);
+			if (i == 1) tile->setShape(0.5f - w, .3f, 1 - w * 2, 0.5f + w, 1, 1);
+			if (i == 2) tile->setShape(0.5f - w, .5f, w * 2, 0.5f + w, 1 - w, 1 - w * 2);
+
+			t.normal(0.0f, -1.0f, 0.0f);
+			renderFaceDown(tile, 0, 0, 0, tile->getTexture(0));
+
+			t.normal(0.0f, 1.0f, 0.0f);
+			renderFaceUp(tile, 0, 0, 0, tile->getTexture(1));
+
+			t.normal(0.0f, 0.0f, -1.0f);
+			renderNorth(tile, 0, 0, 0, tile->getTexture(2));
+
+			t.normal(0.0f, 0.0f, 1.0f);
+			renderSouth(tile, 0, 0, 0, tile->getTexture(3));
+
+			t.normal(-1.0f, 0.0f, 0.0f);
+			renderWest(tile, 0, 0, 0, tile->getTexture(4));
+
+			t.normal(1.0f, 0.0f, 0.0f);
+			renderEast(tile, 0, 0, 0, tile->getTexture(5));
+		}
+		t.draw();
+		t.addOffset(0.5f, 0.5f, 0.5f);
+		tile->setShape(0, 0, 0, 1, 1, 1);
+	}
 
 }
 

src/client/renderer/TileRenderer.h

@@ -10,6 +10,7 @@ class ThinFenceTile;
 class StairTile;
 class LevelSource;
 class Material;
+class Minecraft;
 
 class TileRenderer
 {
@@ -60,6 +61,10 @@ public:
     void renderTile(Tile* tile, int data);
 	void renderGuiTile(Tile* tile, int data);
 
+	static void setUseTint(bool value) {
+       sideTinting = value;
+    }
+
     static bool canRender(int renderShape);
 private:
     float getWaterHeight(int x, int y, int z, const Material* m);
@@ -68,6 +73,7 @@ private:
 	int fixedTexture;
 	bool xFlipTexture;
 	bool noCulling;
+	static bool sideTinting;
 
 	bool applyAmbienceOcclusion;
 	float ll000, llx00, ll0y0, ll00z, llX00, ll0Y0, ll00Z;

src/client/renderer/entity/EntityRenderer.cpp

@@ -130,9 +130,8 @@ void EntityRenderer::postRender(Entity* entity, float x, float y, float z, float
 		if (pow > 0) {
 			renderShadow(entity, x, y, z, pow, a);
 		}
-		//}
-		if (entity->isOnFire()) renderFlame(entity, x, y, z, a);
 	}
+		if (entity->isOnFire()) renderFlame(entity, x, y, z, a);
 }
 void EntityRenderer::renderFlame(Entity* e, float x, float y, float z, float a) {
 	glDisable(GL_LIGHTING);
@@ -187,7 +186,11 @@ void EntityRenderer::renderShadow(Entity* e, float x, float y, float z, float po
 	//Textures* textures = entityRenderDispatcher->textures;
 	//textures->bind(textures->loadTexture("%clamp%/environment/shadow.png"));
 	Textures* textures = entityRenderDispatcher->textures;
-
+	textures->loadAndBindTexture("/misc/shadow.png"); 
+    
+    
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
 
 
@@ -221,9 +224,6 @@ void EntityRenderer::renderShadow(Entity* e, float x, float y, float z, float po
 					renderTileShadow(Tile::tiles[t], x, y + e->getShadowHeightOffs(), z, xt, yt, zt, pow, r, xo, yo + e->getShadowHeightOffs(), zo);
 				}
 			}
-			textures->loadAndBindTexture(("/misc/shadow.png"));
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 			tt.draw();
 
 			glColor4f2(1, 1, 1, 1);

src/client/renderer/entity/MobRenderer.cpp

@@ -187,10 +187,12 @@ void MobRenderer::scale(Mob* mob, float a) {
 }
 
 void MobRenderer::renderName(Mob* mob, float x, float y, float z) {
-	/*
+	
 	std::stringstream ss; ss << mob->entityId;
+	if (entityRenderDispatcher->minecraft->options.getBooleanValue(OPTIONS_RENDER_DEBUG)) {
 	renderNameTag(mob, ss.str(), x, y, z, 64);
-	*/
+	}
+	
 }
 
 void MobRenderer::renderNameTag(Mob* mob, const std::string& name, float x, float y, float z, int maxDist) {
@@ -205,7 +207,11 @@ void MobRenderer::renderNameTag(Mob* mob, const std::string& name, float x, floa
 	float s = 1 / 60.0f * size;
 
 	glPushMatrix2();
-	glTranslatef2((float) x + 0, (float) y + 1.0f /*2.3f*/, (float) z);
+	if (mob->isPlayer()){
+		glTranslatef2((float) x + 0, (float) y + 1.0f, (float) z);
+	} else {
+		glTranslatef2((float) x + 0, (float) y + 2.3f, (float) z);
+	}
 
 	glRotatef2(-entityRenderDispatcher->playerRotY, 0, 1, 0);
 	glRotatef2(entityRenderDispatcher->playerRotX, 1, 0, 0);

src/client/renderer/ptexture/DynamicTexture.cpp

@@ -393,8 +393,8 @@ void LavaSideTexture::tick() {
 		}
 }
 
-FireTexture::FireTexture()
-	:   super(((Tile*)Tile::fire)->tex),
+FireTexture::FireTexture(int id)
+	:   super(((Tile*)Tile::fire)->tex + id * 16),
 	_tick(0),
 	_frame(0)
 {

src/client/renderer/ptexture/DynamicTexture.h

@@ -106,7 +106,7 @@ class FireTexture: public DynamicTexture
 	float* heata;
 
 public:
-    FireTexture();
+    FireTexture(int id);
 	~FireTexture();
 
     void tick();

src/util/PerfRenderer.cpp

@@ -75,7 +75,7 @@ void PerfRenderer::renderFpsMeter( float tickTime )
 	glDisable2(GL_TEXTURE_2D);
 	Tesselator& t = Tesselator::instance;
 
-	t.begin(GL_TRIANGLES);
+	t.begin(GL_QUADS);
 	int hh1 = (int) (usPer60Fps / 200);
 	float count = (float)frameTimes.size();
 	t.color(0x20000000);
@@ -117,7 +117,8 @@ void PerfRenderer::renderFpsMeter( float tickTime )
 			t.color(0xff000000 + cc * 256);
 		}
 
-		float time = 10 * 1000 * frameTimes[i] / 200;
+//		float time = 10 * 1000 * frameTimes[i] / 200;
+		float time = frameTimes[i] * 4000.0f;
 		float time2 = 10 * 1000 * tickTimes[i] / 200;
 
 		t.vertex(i + 0.5f, _mc->height - time + 0.5f, 0);
@@ -210,12 +211,12 @@ void PerfRenderer::renderFpsMeter( float tickTime )
 		msg << result.name;
 		float xx = (float)(x - r);
 		float yy = (float)(y + r/2 + i * 8 + 20);
-		_font->drawShadow(msg.str(), xx, yy, result.getColor());
+		_font->drawShadow(msg.str(), xx + 10 + 10, yy, result.getColor());
 		std::string msg2 = toPercentString(result.percentage);
 		//LOGI("name: %s: perc: %f == %s @ %d, %d\n", msg.str().c_str(), result.percentage, msg2.c_str(), xx, yy);
-		_font->drawShadow(msg2, xx - 50 - _font->width(msg2), yy, result.getColor());
+		_font->drawShadow(msg2, xx + 10 + 10 - _font->width(msg2), yy, result.getColor());
 		msg2 = toPercentString(result.globalPercentage);
-		_font->drawShadow(msg2, xx - _font->width(msg2), yy, result.getColor());
+		_font->drawShadow(msg2, xx + 10 + 10 - _font->width(msg2), yy, result.getColor());
 	}
 }
 

src/util/PerfTimer.h

@@ -6,7 +6,7 @@
 #include "StringUtils.h"
 
 //package util;
-#ifdef PROFILER
+//#ifdef PROFILER
 	#define TIMER_PUSH(x)		PerfTimer::push(x)
 	#define TIMER_POP()			PerfTimer::pop()
 	#define TIMER_POP_PUSH(x)	PerfTimer::popPush(x)
@@ -16,11 +16,11 @@
 //     #define TIMER_PUSH(x)       ServerProfiler::push(x)
 //     #define TIMER_POP()         ServerProfiler::pop()
 //     #define TIMER_POP_PUSH(x)	ServerProfiler::popPush(x)
-#else
-	#define TIMER_PUSH(x)		((void*)0)
-	#define TIMER_POP()			((void*)0)
-	#define TIMER_POP_PUSH(x)	((void*)0)
-#endif
+//#else
+//	#define TIMER_PUSH(x)		((void*)0)
+//	#define TIMER_POP()			((void*)0)
+//	#define TIMER_POP_PUSH(x)	((void*)0)
+//#endif
 
 class PerfTimer
 {

src/world/entity/animal/Chicken.cpp

@@ -51,13 +51,13 @@ void Chicken::aiStep()
 	flap += flapping * 2;
 
 	//@todo
-	//if (!isBaby()) {
-	//	if (!level->isClientSide && --eggTime <= 0) {
-	//		level->playSound(this, "mob.chickenplop", 1.0f, (random.nextFloat() - random.nextFloat()) * 0.2f + 1.0f);
-	//		spawnAtLocation(Item::egg->id, 1);
-	//		eggTime = random.nextInt(SharedConstants::TicksPerSecond * 60 * 5) + SharedConstants::TicksPerSecond * 60 * 5;
-	//	}
-	//}
+	if (!isBaby()) {
+		if (!level->isClientSide && --eggTime <= 0) {
+			level->playSound(this, "mob.chickenplop", 1.0f, (random.nextFloat() - random.nextFloat()) * 0.2f + 1.0f);
+			spawnAtLocation(Item::egg->id, 1);
+			eggTime = random.nextInt(SharedConstants::TicksPerSecond * 60 * 5) + SharedConstants::TicksPerSecond * 60 * 5;
+		}
+	}
 }
 
 void Chicken::addAdditonalSaveData( CompoundTag* tag )

src/world/entity/animal/Sheep.cpp

@@ -1,5 +1,6 @@
 #include "Sheep.h"
 #include "../../item/DyePowderItem.h"
+#include "../../level/tile/TallGrass.h"
 #include "../../level/tile/LevelEvent.h"
 
 const float Sheep::COLOR[][3] = {
@@ -198,7 +199,7 @@ void Sheep::updateAi()
 		int yy = Mth::floor(y);
 		int zz = Mth::floor(z);
 
-		if (/*(level->getTile(xx, yy, zz) == Tile::tallgrass->id && level->getData(xx, yy, zz) == TallGrass::TALL_GRASS) || */ level->getTile(xx, yy - 1, zz) == ((Tile*)Tile::grass)->id) {
+		if ((level->getTile(xx, yy, zz) == Tile::tallgrass->id && level->getData(xx, yy, zz) == TallGrass::TALL_GRASS) ||  level->getTile(xx, yy - 1, zz) == ((Tile*)Tile::grass)->id) {
 			eatAnimationTick = EAT_ANIMATION_TICKS;
 			level->broadcastEntityEvent(this, EntityEvent::EAT_GRASS);
 		}
@@ -208,11 +209,11 @@ void Sheep::updateAi()
 		int zz = Mth::floor(z);
 
 		bool ate = false;
-		/*            if (level->getTile(xx, yy, zz) == Tile::tallgrass->id) {
-		level->levelEvent(LevelEvent::PARTICLES_DESTROY_BLOCK, xx, yy, zz, Tile::tallgrass->id + TallGrass::TALL_GRASS * 256);
+		            if (level->getTile(xx, yy, zz) == Tile::tallgrass->id) {
+		level->levelEvent(NULL, LevelEvent::PARTICLES_DESTROY_BLOCK, xx, yy, zz, Tile::tallgrass->id + TallGrass::TALL_GRASS * 256);
 		level->setTile(xx, yy, zz, 0);
 		ate = true;
-		} else */if (level->getTile(xx, yy - 1, zz) == ((Tile*)Tile::grass)->id) {
+		} else if (level->getTile(xx, yy - 1, zz) == ((Tile*)Tile::grass)->id) {
 			level->levelEvent(NULL, LevelEvent::PARTICLES_DESTROY_BLOCK, xx, yy - 1, zz, ((Tile*)Tile::grass)->id);
 			level->setTile(xx, yy - 1, zz, Tile::dirt->id);
 			ate = true;

src/world/item/DyePowderItem.cpp

@@ -10,6 +10,7 @@
 #include "../level/tile/ClothTile.h"
 #include "../level/tile/CropTile.h"
 #include "../level/tile/StemTile.h"
+#include "../level/tile/TallGrass.h"
 
 const std::string DyePowderItem::COLOR_DESCS[] = {
 	"black", "red", "green", "brown", "blue", "purple", "cyan", "silver", "gray", "pink", "lime", "yellow", "lightBlue", "magenta", "orange", "white"
@@ -91,9 +92,9 @@ bool DyePowderItem::useOn( ItemInstance* itemInstance, Player* player, Level* le
 						  continue;
 
 					  if (level->getTile(xx, yy, zz) == 0) {
-						  /*if (random.nextInt(10) != 0) {
-						  level->setTileAndData(xx, yy, zz, Tile::tallgrass.id, TallGrass.TALL_GRASS);
-						  } else*/ if (random.nextInt(3) != 0) {
+						  if (random.nextInt(10) != 0) {
+						  level->setTileAndData(xx, yy, zz, Tile::tallgrass->id, TallGrass::TALL_GRASS);
+						  } else if (random.nextInt(3) != 0) {
 							  level->setTile(xx, yy, zz, Tile::flower->id);
 						  } else {
 							  level->setTile(xx, yy, zz, Tile::rose->id);

src/world/item/ShearsItem.h

@@ -22,7 +22,7 @@ public:
 
     /*@Override*/
     bool mineBlock(ItemInstance* itemInstance, int tile, int x, int y, int z/*, Mob* owner*/) {
-        if (tile == ((Tile*)Tile::leaves)->id || tile == Tile::web->id /*|| tile == Tile::tallgrass->id || tile == Tile::vine->id*/) {
+        if (tile == ((Tile*)Tile::leaves)->id || tile == Tile::web->id || tile == Tile::tallgrass->id /*|| tile == Tile::vine->id*/) {
             itemInstance->hurt(1);//, owner);
             return true;
         }

src/world/level/FoliageColor.h

@@ -43,7 +43,7 @@ public:
 	}
 
 	static int getDefaultColor() {
-		return 0xFFFFFF;
+		return 0x48b518;
 	}
 
 private:

src/world/level/Level.cpp

@@ -1165,7 +1165,13 @@ int Level::getSkyDarken(float a) {
 
 	float br = 1 - (Mth::cos(td * Mth::PI * 2) * 2 + 0.5f);
 	if (br < 0.0f) br = 0.0f;
-	if (br > 0.80f) br = 0.80f; //@note; was 1.0f
+	if (dimension->FogType == 1) // @TODO - probably make this not dependent on dimension type honestly - shredder
+	{
+	if (br > 1.0f) br = 1.0f; //@ uses the normal javasky color ramp when java sky type is choosen,
+	} else 
+	{
+	if (br > 0.8f) br = 0.8f; //@note; was 1.0f
+	}
 	return ((int) (br * 11));
 }
 
@@ -1174,7 +1180,14 @@ Vec3 Level::getSkyColor(Entity* source, float a) {
 
 	float br = Mth::cos(td * Mth::PI * 2) * 2 + 0.5f;
 	if (br < 0.0f) br = 0.0f;
-	if (br > 0.75f) br = 0.75f; //@note; was 1.0f
+	if (dimension->FogType == 1) // @TODO - probably make this not dependent on dimension type honestly - shredder
+	{
+	if (br > 1.0f) br = 1.0f; //@ uses the normal javasky color ramp when java sky type is choosen,
+	} else 
+	{
+	if (br > 0.8f) br = 0.8f; //@note; was 1.0f
+	}
+
 
 	int xx = Mth::floor(source->x);
 	int zz = Mth::floor(source->z);
@@ -1728,13 +1741,15 @@ void Level::extinguishFire(int x, int y, int z, int face) {
 		setTile(x, y, z, 0);
 	}
 }
-//    String gatherStats() {
-//        return "All: " + this.entities.size();
-//    }
-//
-//    String gatherChunkSourceStats() {
-//        return chunkSource.gatherStats();
-//    }
+   std::string Level::gatherStats() {
+	   std::stringstream ss;
+	   ss << "All: " << entities.size();
+       return ss.str();
+    }
+
+    std::string Level::gatherChunkSourceStats() {
+        return _chunkSource->gatherStats();
+   }
 //
 TileEntity* Level::getTileEntity(int x, int y, int z) {
 	LevelChunk* lc = getChunk(x >> 4, z >> 4);

src/world/level/Level.h

@@ -202,6 +202,9 @@ public:
 	bool checkAndHandleWater(const AABB& box, const Material* material, Entity* e);
     void extinguishFire(int x, int y, int z, int face);
 
+	std::string gatherStats();
+	std::string gatherChunkSourceStats();
+
 	//void addEntities(const EntityList& list);
 	//void removeEntities(const EntityList& list);
 	//void ensureAdded(Entity* entity);

src/world/level/biome/Biome.cpp

@@ -9,6 +9,7 @@
 #include "../../level/tile/TallGrass.h"
 
 #include "../../../util/Color.h"
+#include "../GrassColor.h"
 
 Biome* Biome::rainForest	 = NULL;
 Biome* Biome::swampland		 = NULL;
@@ -217,6 +218,26 @@ int Biome::getSkyColor( float temp )
 	return Color::getHSBColor(224 / 360.0f - temp * 0.05f, 0.50f + temp * 0.1f, 1.0f).getRGB();
 }
 
+float Biome::getDownfall()
+{
+	return downfall;
+}
+
+
+float Biome::getTemperature()
+{
+	return temperature;
+}
+
+
+int Biome::getGrassColor()
+{
+    float temp = Mth::clamp(getTemperature(), 0.0f, 1.0f);
+    float rain = Mth::clamp(getDownfall(), 0.0f, 1.0f);
+
+    return GrassColor::get(temp, rain);
+}
+
 Biome::MobList& Biome::getMobs(const MobCategory& category)
 {
     if (&category == &MobCategory::monster)

src/world/level/biome/Biome.h

@@ -78,7 +78,13 @@ public:
     virtual float adjustScale(float scale);
     virtual float adjustDepth(float depth);
 
+	
+
     virtual int getSkyColor(float temp);
+	virtual int getGrassColor();
+
+	virtual float getDownfall();			
+	virtual float getTemperature();			
 
 	virtual MobList& getMobs(const MobCategory& category);
 	virtual float getCreatureProbability();
@@ -88,6 +94,8 @@ public:
 	char topMaterial;
 	char material;
 	int leafColor;
+	float temperature;
+    float downfall;
 private:
 	static Biome* map[64*64];
 };

src/world/level/chunk/ChunkCache.h

@@ -193,7 +193,10 @@ public:
     }
 
     std::string gatherStats() {
-        return "ChunkCache: 1024";
+   //     return "ChunkCache: 1024";
+		std::stringstream ss;
+		ss << "ChunkCache: " << CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
+		return ss.str();
     }
 	
 	void saveAll(bool onlyUnsaved) {

src/world/level/dimension/Dimension.cpp

@@ -133,22 +133,29 @@ Dimension* Dimension::getNew( int id )
 	return NULL;
 }
 
+std::string Dimension::getDimension(){
+	int currentID = this->id;
+	if (currentID == Dimension::NORMAL) return "Overworld";
+	if (currentID == Dimension::NORMAL_DAYCYCLE) return "Overworld";
+	return "Unknown";
+}
+
 //
 // DimensionFactory
 //
 #include "../storage/LevelData.h"
-Dimension* DimensionFactory::createDefaultDimension(LevelData* data )
-{
-	int dimensionId = Dimension::NORMAL;
+	Dimension* DimensionFactory::createDefaultDimension(LevelData* data )
+	{
+		int dimensionId = Dimension::NORMAL;
 
-	switch(data->getGameType()) {
-	case GameType::Survival: dimensionId = Dimension::NORMAL_DAYCYCLE;
-		break;
-	case GameType::Creative:
-	default:
-		dimensionId = Dimension::NORMAL;
-		break;
-	}
+		switch(data->getGameType()) {
+		case GameType::Survival: dimensionId = Dimension::NORMAL_DAYCYCLE;
+			break;
+		case GameType::Creative:
+		default:
+			dimensionId = Dimension::NORMAL;
+			break;
+		}
 
 	return Dimension::getNew(dimensionId);
 }

src/world/level/dimension/Dimension.h

@@ -49,7 +49,7 @@ public:
 	bool hasCeiling;
 	float brightnessRamp[16];//Level::MAX_BRIGHTNESS + 1];
 	int id;
-
+	std::string getDimension();
 	// shredder added
 	int FogType; // lets us choose between what fog we want ig
 protected:

src/world/level/levelgen/RandomLevelSource.cpp

@@ -11,6 +11,7 @@
 #include "../tile/Tile.h"
 #include "../tile/HeavyTile.h"
 #include "../../../util/Random.h"
+#include "../../level/tile/TallGrass.h"
 
 const float RandomLevelSource::SNOW_CUTOFF = 0.5f;
 const float RandomLevelSource::SNOW_SCALE = 0.3f;
@@ -225,7 +226,7 @@ void RandomLevelSource::postProcess(ChunkSource* parent, int xt, int zt) {
 	int zo = zt * 16;
 
 	Biome* biome = level->getBiomeSource()->getBiome(xo + 16, zo + 16);
-	//    Biome* biome = Biome::forest;
+//	    Biome* biome = Biome::forest;
 
 	random.setSeed(level->getSeed());
 	int xScale = random.nextInt() / 2 * 2 + 1;
@@ -419,17 +420,46 @@ void RandomLevelSource::postProcess(ChunkSource* parent, int xt, int zt) {
 		FlowerFeature feature(Tile::mushroom2->id);
 		feature.place(level, &random, x, y, z);
 	}
-	/*int grassCount = 1;
-	for (int i = 0; i < grassCount; i++) {
-	int x = xo + random.nextInt(16) + 8;
-	int y = random.nextInt(Level::genDepth);
-	int z = zo + random.nextInt(16) + 8;
-	Feature* grassFeature = biome->getGrassFeature(&random);
-	if (grassFeature) {
-	grassFeature->place(level, &random, x, y, z);
-	delete grassFeature;
-	}
-	}*/
+	// normally unused in mcpe but how its supposed to do it
+	//int grassCount = 1;
+	//for (int i = 0; i < grassCount; i++) {
+	//int x = xo + random.nextInt(16) + 8;
+	//int y = random.nextInt(Level::genDepth);
+	//int z = zo + random.nextInt(16) + 8;
+	//Feature* grassFeature = biome->getGrassFeature(&random);
+	//if (grassFeature) {
+	//grassFeature->place(level, &random, x, y, z);
+	//delete grassFeature;
+	//}
+	//}
+
+	// reworked code from above to generate ferns and shrubs to just like in beta java
+int grassCount = 0;
+
+if (biome == Biome::forest) { grassCount = 2; }
+else if (biome == Biome::rainForest) { grassCount = 10; }
+else if (biome == Biome::seasonalForest) { grassCount = 2; }
+else if (biome == Biome::taiga) { grassCount = 1; }
+else if (biome == Biome::plains) { grassCount = 10; }
+
+for (int i = 0; i < grassCount; i++) {
+    int grassMetadata = TallGrass::TALL_GRASS;
+    
+    
+    if (biome == Biome::rainForest && random.nextInt(3) != 0) {
+        grassMetadata = TallGrass::FERN;
+    }
+
+    int x = xo + random.nextInt(16) + 8;
+     
+    int z = zo + random.nextInt(16) + 8;
+	int y = level->getHeightmap(x, z);
+
+    TallgrassFeature grassFeature(Tile::tallgrass->id, grassMetadata);
+    grassFeature.place(level, &random, x, y, z);
+}
+
+
 	for (int i = 0; i < 10; i++) {
 		int x = xo + random.nextInt(16) + 8;
 		int y = random.nextInt(128);

src/world/level/levelgen/feature/FeatureInclude.h

@@ -10,5 +10,6 @@
 #include "OreFeature.h"
 #include "ReedsFeature.h"
 #include "SpringFeature.h"
+#include "TallgrassFeature.h"
 
 #endif /*FEATURE_INCLUDE__H__*/

src/world/level/tile/LeafTile.h

@@ -60,6 +60,7 @@ public:
 			return FoliageColor::getDefaultColor();
 		}
 
+		
  //       return FoliageColor::getDefaultColor(); we need to hook this up with OPTION_FOLIAGE_TINT
 		level->getBiomeSource()->getBiomeBlock(x, z, 1, 1);
 		float temperature = level->getBiomeSource()->temperatures[0];

src/world/level/tile/TallGrass.cpp

@@ -1,8 +1,12 @@
 #include "TallGrass.h"
 #include "../FoliageColor.h"
+#include "../GrassColor.h"
 #include "../../entity/player/Player.h"
 #include "../../item/Item.h"
 #include "../../item/ShearsItem.h"
+#include "../Level.h"
+#include "../LevelSource.h"
+#include "../biome/BiomeSource.h"
 
 TallGrass::TallGrass( int id, int tex ) : super(id, tex, Material::replaceable_plant) {
 	float ss = 0.4f;
@@ -17,21 +21,40 @@ int TallGrass::getTexture( int face, int data ) {
 }
 
 int TallGrass::getColor() {
-	/*double temp = 0.5;
-	double rain = 1.0;
-	return GrassColor.get(temp, rain);*/
+	//double temp = 0.5;
+	//double rain = 1.0;
+	// converted to float for consistency - shredder
+	float temp = 0.5;
+	float rain = 1.0;
+	if (GrassColor::useTint){
+		return GrassColor::get(temp, rain);
+	}
 	return 0x339933;
 }
 
 int TallGrass::getColor( int auxData ) {
-	if(auxData == DEAD_SHRUB) return 0xffffffff;
+	if(auxData == DEAD_SHRUB);
+	if (!FoliageColor::useTint && auxData == DEAD_SHRUB){
+		return 0xffffff;
+	}
 	return FoliageColor::getDefaultColor();
 }
 
 int TallGrass::getColor( LevelSource* level, int x, int y, int z ) {
 	int d = level->getData(x, y, z);
-	if (d == DEAD_SHRUB) return 0xffffff;
-
+	if (d == DEAD_SHRUB); //return 0xffffff; // i removed this to make it accurate to beta 1.6.6 instead of early java release versions
+	float temp = level->getBiomeSource()->temperatures[0]; // shredder added
+	float rain = level->getBiomeSource()->downfalls[0]; // shredder added
+	if (!GrassColor::useTint && d == DEAD_SHRUB){
+		return 0xffffff;
+	}
+	if (GrassColor::useTint){
+		return GrassColor::get(temp, rain);
+	}
+	// @TODO port this function from beta 1.6.6 probably, for now im using biomesource to tint it directly above - shredder
+	//if (GrassColor::useTint){ 
+	//return level->getBiome(x, z)->getGrassColor();
+	//}
 	return 0x339933;//level->getBiome(x, z)->getGrassColor();
 }