Merge pull request 'added missing audio random.burp when finishing a food item' (#14) from sas3/minecraft-pe-0.6.1:main into main

Reviewed-on: Kolyah35/minecraft-pe-0.6.1#14

.github/workflows/build.yml

@@ -216,16 +216,6 @@ jobs:
           distribution: temurin
           java-version: 25
 
-      - name: Validate environment
-        run: |
-          echo "ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT"
-          echo "ANDROID_NDK_PATH=$ANDROID_NDK_PATH"
-          echo "JAVA_HOME=$JAVA_HOME"
-          echo "MATRIX_ABI=$MATRIX_ABI"
-          $ANDROID_SDK_ROOT/platform-tools/adb version || true
-          java -version
-          javac -version
-
       - name: Run Android build script
         run: |
           chmod +x ./build.sh
@@ -322,17 +312,10 @@ jobs:
           files: mcpe-linux/MinecraftPE-server
           dest: minecraftpe-server-${{ steps.ref.outputs.hash }}.zip
 
-      - name: Zip Android arm64-v8a Artifact
-        uses: vimtor/action-zip@v1.2
-        with:
-          files: minecraftpe-apk-arm64-v8a/minecraftpe-v8a-debug.apk
-          dest: minecraftpe-${{ steps.ref.outputs.hash }}-android-arm64-v8a.zip
-
-      - name: Zip Android armeabi-v7a Artifact
-        uses: vimtor/action-zip@v1.2
-        with:
-          files: minecraftpe-apk-armeabi-v7a/minecraftpe-v7a-debug.apk
-          dest: minecraftpe-${{ steps.ref.outputs.hash }}-android-armeabi-v7a.zip
+      - name: Rename Android Artifacts
+        run: |
+          mv minecraftpe-apk-arm64-v8a/minecraftpe-v8a-debug.apk minecraftpe-${{ steps.ref.outputs.hash }}-android-arm64-v8a.apk
+          mv minecraftpe-apk-armeabi-v7a/minecraftpe-v7a-debug.apk minecraftpe-${{ steps.ref.outputs.hash }}-android-armeabi-v7a.apk
 
       - name: Zip Web Artifact
         uses: vimtor/action-zip@v1.2
@@ -358,9 +341,9 @@ jobs:
             MinecraftPE development release for commit ${{ github.sha }}.
           files: |
             ./data.zip
+            ./minecraftpe-server-${{ steps.ref.outputs.hash }}.zip
             ./minecraftpe-${{ steps.ref.outputs.hash }}-windows.zip
             ./minecraftpe-${{ steps.ref.outputs.hash }}-linux.zip
-            ./minecraftpe-server-${{ steps.ref.outputs.hash }}.zip
-            ./minecraftpe-${{ steps.ref.outputs.hash }}-android-arm64-v8a.zip
-            ./minecraftpe-${{ steps.ref.outputs.hash }}-android-armeabi-v7a.zip
+            ./minecraftpe-${{ steps.ref.outputs.hash }}-android-arm64-v8a.apk
+            ./minecraftpe-${{ steps.ref.outputs.hash }}-android-armeabi-v7a.apk
             ./minecraftpe-${{ steps.ref.outputs.hash }}-web.zip

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

@@ -153,7 +153,32 @@ options.group.tweaks=Tweaks
 options.allowSprint=Allow sprint
 options.barOnTop=HUD above inventory
 options.rpiCursor=Show Raspberry PI cursor
-options.foliageTint=Tint Grass and Leaves
+options.foliagetint=Foliage Tinting
+options.javaHud=Beta Java hotbar tweaks
+options.blockOutline=Block Outline Selection
+options.fogType=Fog/Sky Color
+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
+
+options.isJoyTouchArea=Use Split Controls
+
 options.autoJump=Auto Jump
 options.thirdperson=Third Person
 options.servervisible=Server Visible
@@ -204,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

project/android/jni/Android.mk

@@ -98,6 +98,7 @@ LOCAL_SRC_FILES := ../../../src/main.cpp \
 ../../../src/client/player/RemotePlayer.cpp \
 ../../../src/client/player/input/KeyboardInput.cpp \
 ../../../src/client/player/input/touchscreen/TouchscreenInput.cpp \
+../../../src/client/renderer/Lighting.cpp \
 ../../../src/client/renderer/Chunk.cpp \
 ../../../src/client/renderer/EntityTileRenderer.cpp \
 ../../../src/client/renderer/GameRenderer.cpp \

project/android_java/jni/Android.mk

@@ -75,6 +75,7 @@ LOCAL_SRC_FILES := ../../../src/main.cpp \
 ../../../src/client/player/RemotePlayer.cpp \
 ../../../src/client/player/input/KeyboardInput.cpp \
 ../../../src/client/player/input/touchscreen/TouchscreenInput.cpp \
+../../../src/client/renderer/Lighting.cpp \
 ../../../src/client/renderer/Chunk.cpp \
 ../../../src/client/renderer/EntityTileRenderer.cpp \
 ../../../src/client/renderer/GameRenderer.cpp \

project/android_java/src/com/mojang/minecraftpe/sound/SoundPlayer.java

@@ -129,6 +129,7 @@ public class SoundPlayer
 			new SoundId(R.raw.eat1, "random.eat"),
 			new SoundId(R.raw.eat2, "random.eat"),
 			new SoundId(R.raw.eat3, "random.eat"),
+			new SoundId(R.raw.burp1, "random.burp"),
 			new SoundId(R.raw.fuse, "random.fuse"),
 
 			new SoundId(R.raw.zpig1, "mob.zombiepig.zpig"),

project/iosproj/minecraftpe.xcodeproj/project.pbxproj

@@ -1179,6 +1179,8 @@
 		F99F0FAD2F8436CE00F2B29A /* FoliageColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F99F0FAB2F8436CE00F2B29A /* FoliageColor.cpp */; };
 		F99F0FAF2F8436EB00F2B29A /* Color.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F99F0FAE2F8436EB00F2B29A /* Color.cpp */; };
 		F99F0FB02F8436EB00F2B29A /* Color.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F99F0FAE2F8436EB00F2B29A /* Color.cpp */; };
+		BEEF202614CFF670005F0002 /* Lighting.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BEEF202614CFF670005F0001 /* Lighting.cpp */; };
+		BEEF202614CFF670005F0003 /* Lighting.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BEEF202614CFF670005F0001 /* Lighting.cpp */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
@@ -2466,6 +2468,7 @@
 		F99F0FA82F84369F00F2B29A /* GrassColor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = GrassColor.cpp; sourceTree = "<group>"; };
 		F99F0FAB2F8436CE00F2B29A /* FoliageColor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = FoliageColor.cpp; sourceTree = "<group>"; };
 		F99F0FAE2F8436EB00F2B29A /* Color.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Color.cpp; sourceTree = "<group>"; };
+		BEEF202614CFF670005F0001 /* Lighting.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Lighting.cpp; path = Lighting.cpp; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -3533,6 +3536,7 @@
 				D5B50CF114CFF66F005F7284 /* TileRenderer.cpp */,
 				D5B50CF214CFF66F005F7284 /* TileRenderer.h */,
 				D5B50CF314CFF66F005F7284 /* VertecDecl.h */,
+				BEEF202614CFF670005F0001 /* Lighting.cpp */,
 			);
 			path = renderer;
 			sourceTree = "<group>";
@@ -5439,6 +5443,7 @@
 				D5D8C4C41639341100FD35F0 /* Motive.cpp in Sources */,
 				D5D8C4C8163934BB00FD35F0 /* HangingEntityItem.cpp in Sources */,
 				D5D8C4CC1639362F00FD35F0 /* NetherReactorPattern.cpp in Sources */,
+				BEEF202614CFF670005F0002 /* Lighting.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -5821,6 +5826,7 @@
 				042A91AF16B17517007ABBC6 /* NinePatch.cpp in Sources */,
 				042A91B016B17517007ABBC6 /* OptionsGroup.cpp in Sources */,
 				042A91B216B17517007ABBC6 /* TextBox.cpp in Sources */,
+				BEEF202614CFF670005F0003 /* Lighting.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

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));
 				*/
 			}
 
@@ -745,119 +750,128 @@ void Minecraft::tickInput() {
 				int dst = options.getIntValue(OPTIONS_VIEW_DISTANCE);
 				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()) {
@@ -920,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;
 
@@ -957,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 {
@@ -967,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);
@@ -1002,7 +1016,7 @@ void Minecraft::handleBuildAction(BuildActionIntention* action) {
 
 bool Minecraft::isOnlineClient()
 {
-    return (level != NULL && level->isClientSide);
+	return (level != NULL && level->isClientSide);
 }
 
 bool Minecraft::isOnline()
@@ -1069,8 +1083,8 @@ void Minecraft::setScreen( Screen* screen )
 
 		if (screen->isInGameScreen() && level) {
 			level->saveLevelData();
-            level->saveGame();
-        }
+			level->saveGame();
+		}
 
 		//noRender = false;
 	} else {
@@ -1107,7 +1121,7 @@ void Minecraft::releaseMouse()
 
 bool Minecraft::useTouchscreen() {
 #if defined(TARGET_OS_IPHONE)
-    return true;
+	return true;
 #elif defined(RPI)
 	return false;
 #endif
@@ -1128,7 +1142,10 @@ void Minecraft::init()
 	textures = new Textures(&options, platform());
 	textures->addDynamicTexture(new WaterTexture());
 	textures->addDynamicTexture(new WaterSideTexture());
-	textures->addDynamicTexture(new FireTexture());
+	textures->addDynamicTexture(new LavaTexture());
+	textures->addDynamicTexture(new LavaSideTexture());
+	textures->addDynamicTexture(new FireTexture(0));
+	textures->addDynamicTexture(new FireTexture(1));
 	gui.texturesLoaded(textures);
 
 	levelRenderer = new LevelRenderer(this);
@@ -1136,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
@@ -1145,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);
 
@@ -1169,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);
 
@@ -1250,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() {
@@ -1263,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());
@@ -1316,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) {
@@ -1327,7 +1371,7 @@ bool Minecraft::joinMultiplayerFromString( const std::string& server )
 	}
 
 	printf("%s \n", port.c_str());
-	
+
 	if (isLookingForMultiplayer && netCallback) {
 		isLookingForMultiplayer = false;
 		printf("test");
@@ -1338,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
 }
 
@@ -1403,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;
@@ -1434,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) {
@@ -1481,7 +1553,7 @@ void Minecraft::onGraphicsReset()
 {
 #ifndef STANDALONE_SERVER
 	textures->clear();
-	
+
 	font->onGraphicsReset();
 	gui.onGraphicsReset();
 
@@ -1520,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
 }
 
@@ -1596,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

@@ -54,18 +54,38 @@ OptionBool limitFramerate("limitFramerate", false);
 OptionBool vsync("vsync", true);
 OptionBool fancyGraphics("fancyGraphics", true);
 OptionBool viewBobbing("viewBobbing", true);
-OptionBool ambientOcclusion("ao", false);
+OptionBool ambientOcclusion("ao", true);
+
+OptionBool useNormalLighting("normalLighting", true);
+
+OptionBool beautifulSky("beautifulSky", true);
+
+OptionBool useVignette("useVignette", true);
 
 OptionBool useTouchscreen("useTouchscreen", true);
 
 OptionBool serverVisible("servervisible", true);
 
-OptionBool foliageTint("foliagetint", false);
+OptionBool foliageTint("foliagetint", true);
 
 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);
@@ -118,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;
@@ -142,10 +163,20 @@ void Options::initTable() {
 
     m_options[OPTIONS_USE_TOUCHSCREEN] = &useTouchscreen;
 
+	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;
@@ -173,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,
@@ -49,6 +50,8 @@ enum OptionId {
     OPTIONS_LIMIT_FRAMERATE,
     OPTIONS_VSYNC,
     OPTIONS_FANCY_GRAPHICS,
+	OPTIONS_NORMAL_LIGHTING,
+
 
     // Cheats / debug
     OPTIONS_FLY_SPEED,
@@ -56,6 +59,7 @@ enum OptionId {
     OPTIONS_IS_FLYING,
 
     // Control
+	OPTIONS_BLOCK_OUTLINE,
     OPTIONS_USE_MOUSE_FOR_DIGGING,
     OPTIONS_IS_LEFT_HANDED,
     OPTIONS_IS_JOY_TOUCH_AREA,
@@ -87,6 +91,14 @@ enum OptionId {
 	OPTIONS_FOLIAGE_TINT,
 	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);
 }
@@ -596,7 +602,8 @@ void Gui::renderProgressIndicator( const bool isTouchInterface, const int screen
 	bool bowEquipped = currentItem != NULL ? currentItem->getItem() == Item::bow : false;
 	bool itemInUse = currentItem != NULL ? currentItem->getItem() == minecraft->player->getUseItem()->getItem() : false;
 	if ((!isTouchInterface || minecraft->options.getBooleanValue(OPTIONS_IS_JOY_TOUCH_AREA) 
-		|| (bowEquipped && itemInUse)) && !minecraft->options.getBooleanValue(OPTIONS_HIDEGUI)) {
+		|| (bowEquipped && itemInUse)) && !minecraft->options.getBooleanValue(OPTIONS_HIDEGUI))
+	{
 			minecraft->textures->loadAndBindTexture("gui/icons.png");
 			glEnable(GL_BLEND);
 			glBlendFunc2(GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR);
@@ -620,7 +627,7 @@ void Gui::renderProgressIndicator( const bool isTouchInterface, const int screen
 			const float x = InvGuiScale * minecraft->inputHolder->mousex;
 			const float y = InvGuiScale * minecraft->inputHolder->mousey;
 			glTranslatef2(x, y, 0);
-			drawArrayVT(rcFeedbackOuter.vboId, rcFeedbackOuter.vertexCount, 24);
+			drawArrayVT(rcFeedbackOuter.vboId, rcFeedbackOuter.vertexCount, 36);
 			glTranslatef2(-x, -y, 0);
 
 			glEnable2(GL_TEXTURE_2D);
@@ -641,12 +648,12 @@ void Gui::renderProgressIndicator( const bool isTouchInterface, const int screen
 			const float y = InvGuiScale * minecraft->inputHolder->mousey;
 			glPushMatrix2();
 			glTranslatef2(x, y, 0);
-			drawArrayVT(rcFeedbackOuter.vboId, rcFeedbackOuter.vertexCount, 24);
+			drawArrayVT(rcFeedbackOuter.vboId, rcFeedbackOuter.vertexCount, 36);
 			glScalef2(0.5f + progress, 0.5f + progress, 1);
 			//glDisable2(GL_CULL_FACE);
 			glColor4f2(1, 1, 1, 1);
 			glBlendFunc2(GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR);
-			drawArrayVT(rcFeedbackInner.vboId, rcFeedbackInner.vertexCount, 24, GL_TRIANGLE_FAN);
+			drawArrayVT(rcFeedbackInner.vboId, rcFeedbackInner.vertexCount, 36, GL_TRIANGLE_FAN);
 			glPopMatrix2();
 
 			glDisable(GL_BLEND);
@@ -725,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;
 	}
@@ -769,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);
@@ -783,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;
@@ -806,6 +861,7 @@ void Gui::renderDebugInfo() {
 		font->draw(ln[i], MGN, y, col);
 	}
 	t.endOverrideAndDraw();
+	}
 }
 
 void Gui::renderPlayerList(Font* font, int screenWidth, int screenHeight) {
@@ -1035,7 +1091,10 @@ void Gui::renderChatMessages( const int screenHeight, unsigned int max, bool isC
 }
 
 void Gui::renderToolBar( float a, int ySlot, const int screenWidth ) {
-	glColor4f2(1, 1, 1, .5);
+	glColor4f2(1, 1, 1, 1);
+	    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
 	minecraft->textures->loadAndBindTexture("gui/gui.png");
 
 	Inventory* inventory = minecraft->player->inventory;

src/client/gui/components/OptionsItem.cpp

@@ -36,6 +36,48 @@ void OptionsItem::render( Minecraft* minecraft, int xm, int ym ) {
 		}
 		text += ": " + scaleText;
 	}
+	if (m_optionId == OPTIONS_FOG_TYPE) {
+		int value = minecraft->options.getIntValue(OPTIONS_FOG_TYPE);
+		std::string scaleText;
+		switch (value) {
+		case 0: scaleText = I18n::get("options.fogType.vanilla"); break;
+		case 1: scaleText = I18n::get("options.fogType.java"); break;
+		case 2: scaleText = I18n::get("options.fogType.unused"); break;
+		}
+		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/CreditsScreen.cpp

@@ -41,6 +41,7 @@ void CreditsScreen::init() {
     _lines.push_back("karson");
     _lines.push_back("deepfriedwaffles");
     _lines.push_back("EpikIzCool");
+	_lines.push_back("fileshredder");
     _lines.push_back("");
     // avoid color tags around the URL so it isn't mangled by the parser please
     _lines.push_back("Join our Discord server: https://discord.gg/c58YesBxve");

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

@@ -1,5 +1,6 @@
 #include "IngameBlockSelectionScreen.h"
 #include "../../renderer/TileRenderer.h"
+#include "../../renderer/Lighting.h"
 #include "../../player/LocalPlayer.h"
 #include "../../renderer/gles.h"
 #include "../../Minecraft.h"
@@ -11,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__)
@@ -26,7 +28,8 @@ IngameBlockSelectionScreen::IngameBlockSelectionScreen()
 	InventoryRows(1),
 	InventoryCols(1),
 	InventorySize(1),
-	bArmor(1, "Armor")
+	bArmor(1, "Armor"),
+	bCrafting(1, "Crafting")
 {
 }
 
@@ -41,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()) {
@@ -57,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()
@@ -80,10 +89,10 @@ void IngameBlockSelectionScreen::renderSlots()
 
 	blitOffset = -90;
 
-	//glEnable2(GL_RESCALE_NORMAL);
+	glEnable2(GL_RESCALE_NORMAL);
 	//glPushMatrix2();
 	//glRotatef2(180, 1, 0, 0);
-	//Lighting::turnOn();
+	Lighting::turnOn(minecraft);
 	//glPopMatrix2();
 
 	minecraft->textures->loadAndBindTexture("gui/gui.png");
@@ -122,8 +131,8 @@ void IngameBlockSelectionScreen::renderSlots()
 	//w.stop();
 	//w.printEvery(1000, "render-blocksel");
 
-	//glDisable2(GL_RESCALE_NORMAL);
-	//Lighting::turnOn();
+	glDisable2(GL_RESCALE_NORMAL);
+	Lighting::turnOff();
 }
 
 int IngameBlockSelectionScreen::getSlotPosX(int slotX) {
@@ -248,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)
@@ -337,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)
@@ -208,7 +209,9 @@ void OptionsScreen::generateOptionScreens() {
 	// // Controls Pane
 	optionPanes[2]->addOptionItem(OPTIONS_INVERT_Y_MOUSE, minecraft)
 		.addOptionItem(OPTIONS_USE_TOUCHSCREEN, minecraft)
-		.addOptionItem(OPTIONS_AUTOJUMP, minecraft);
+		.addOptionItem(OPTIONS_AUTOJUMP, minecraft)	
+		.addOptionItem(OPTIONS_BLOCK_OUTLINE, minecraft)
+		.addOptionItem(OPTIONS_IS_JOY_TOUCH_AREA, minecraft);
 
 	for (int i = OPTIONS_KEY_FORWARD; i <= OPTIONS_KEY_USE; i++) {
 		optionPanes[2]->addOptionItem((OptionId)i, minecraft);
@@ -221,17 +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_AMBIENT_OCCLUSION, 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_FOG_TYPE, minecraft)
+		.addOptionItem(OPTIONS_BETA_SKY, minecraft)
+		.addOptionItem(OPTIONS_RESTORED_ANIMS, minecraft)
+		.addOptionItem(OPTIONS_DEBUG_STYLE, minecraft);
 		
 }
 

src/client/gui/screens/PauseScreen.cpp

@@ -10,18 +10,18 @@
 #include "client/gui/screens/OptionsScreen.h"
 
 PauseScreen::PauseScreen(bool wasBackPaused)
-:	saveStep(0),
+	:	saveStep(0),
 	visibleTime(0),
 	bContinue(0),
 	bQuit(0),
 	bOptions(0),
 	bQuitAndSaveLocally(0),
 	bServerVisibility(0),
-//	bThirdPerson(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 +34,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);
 }
 
@@ -44,24 +44,31 @@ PauseScreen::~PauseScreen() {
 	delete bQuitAndSaveLocally;
 	delete bServerVisibility;
 	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");
 		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");
 		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...");
+		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);
@@ -72,12 +79,12 @@ void PauseScreen::init() {
 	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 +92,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 +110,48 @@ 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 = 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;
+		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 = 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;
+
+		bQuit->x = (width - bQuit->width) / 2;
+		bQuit->y = yBase + 32 * 3;
 
 #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 * 4;
+	}
+
+
 
 	// bSound.y = bThirdPerson.y = 8;
 	// bSound.x = 4;
@@ -161,9 +189,9 @@ 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 == bQuitAndSaveLocally->id) {
 		minecraft->leaveGame(true);
 	}
@@ -197,5 +225,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/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/model/geom/ModelPart.cpp

@@ -203,7 +203,7 @@ void ModelPart::compile( float scale )
 void ModelPart::draw()
 {
 #ifdef OPENGL_ES
-	drawArrayVT_NoState(vboId, cubes.size() * 2 * 3 * 6, 24);
+	drawArrayVTN_NoState(vboId, cubes.size() * 2 * 3 * 6, 36);
 #else
 	glCallList(list);
 #endif

src/client/model/geom/Polygon.cpp

@@ -43,6 +43,18 @@ void PolygonQuad::mirror() {
 }
 
 void PolygonQuad::render(Tesselator& t, float scale, int vboId /* = -1 */) {
+	Vec3 v0 = vertices[0].pos - vertices[1].pos;
+	Vec3 v1 = vertices[2].pos - vertices[1].pos;
+	Vec3 n = v1.cross(v0).normalized();
+	if (_flipNormal == true)
+	{
+		t.normal(-n.x , -n.y , -n.z );
+	}
+	else
+	{
+		t.normal(n.x , n.y , n.z );
+	}
+
 	for (int i = 0; i < 4; i++) {
 		VertexPT& v = vertices[i];
 		t.vertexUV(v.pos.x * scale, v.pos.y * scale, v.pos.z * scale, v.u, v.v);

src/client/renderer/ItemInHandRenderer.cpp

@@ -21,11 +21,12 @@
 #include "../../world/item/BowItem.h"
 #include "../../world/level/tile/LeafTile.h"
 #include "entity/HumanoidMobRenderer.h"
+#include "Lighting.h"
 
 //static StopwatchHandler handler;
 
 ItemInHandRenderer::ItemInHandRenderer( Minecraft* mc )
-:	mc(mc),
+	:	mc(mc),
 	lastSlot(-1),
 	height(0),
 	oHeight(0),
@@ -49,21 +50,47 @@ ItemInHandRenderer::ItemInHandRenderer( Minecraft* mc )
 void ItemInHandRenderer::tick()
 {
 	oHeight = height;
-	item.id = 0;
+	//item.id = 0;
 
 	ItemInstance* itemInHand = mc->player->inventory->getSelected();
-	if (itemInHand && itemInHand->count > 0) {
-		item.id = itemInHand->id;
-		item.setAuxValue(itemInHand->getAuxValue());
+	bool sameItem = (itemInHand && item.id == itemInHand->id && item.getAuxValue() == itemInHand->getAuxValue());
+
+
+	
+	if (mc->options.getBooleanValue(OPTIONS_RESTORED_ANIMS)) // if enabled, restores and fixes item switching animation
+	{
+		if (!itemInHand && item.id == 0) sameItem = true;
+		float max = 0.4f;
+		float tHeight = sameItem ? 1 : 0;
+		float dd = tHeight - height;
+		if (dd < -max) dd = -max;
+		if (dd > max) dd = max;
+
+		height += dd;
+
+		if (height < 0.1){
+			if (itemInHand && itemInHand->count > 0) {
+				item.id = itemInHand->id;
+				item.setAuxValue(itemInHand->getAuxValue());
+			} else {
+				item.id = 0;
+			}
+		}
+	} else // otherwise use vanilla broken behaviour where it instantly switches items/blocks
+	{
+		if (itemInHand && itemInHand->count > 0) {
+			item.id = itemInHand->id;
+			item.setAuxValue(itemInHand->getAuxValue());
+		}
+
+		float max = 0.4f;
+		float tHeight = 1;//matches ? 1 : 0;
+		float dd = tHeight - height;
+		if (dd < -max) dd = -max;
+		if (dd > max) dd = max;
+
+		height += dd;
 	}
-
-	float max = 0.4f;
-	float tHeight = 1;//matches ? 1 : 0;
-	float dd = tHeight - height;
-	if (dd < -max) dd = -max;
-	if (dd > max) dd = max;
-
-	height += dd;
 }
 
 void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
@@ -92,7 +119,7 @@ void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
 	if(mob != NULL) {
 		itemIcon = mob->getItemInHandIcon(item, 0);
 	}
-	
+
 	bool reTesselate(false);
 	if(itemIcon != lastIconRendered && lastItemRendered == itemId)
 		reTesselate  = true;
@@ -139,9 +166,9 @@ void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
 			float v1 = (vp * 16 + 15.99f) / 256.0f;
 
 			float r = 1.0f;
-//			float xo = 0.0f;
-//			float yo = 0.3f;
-/*
+			//			float xo = 0.0f;
+			//			float yo = 0.3f;
+			/*
 			//glEnable2(GL_RESCALE_NORMAL);
 			glTranslatef2(-xo, -yo, 0);
 			float s = 1.5f;
@@ -150,19 +177,28 @@ void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
 			glRotatef2(50, 0, 1, 0);
 			glRotatef2(45 + 290, 0, 0, 1);
 			glTranslatef2(-15 / 16.0f, -1 / 16.0f, 0);
-*/
+			*/
 			float dd = 1 / 16.0f;
+			float col = 1.0f;
+			float br = mc->player->getBrightness(0);
 
+
+			t.color(col*br,col*br,col*br,1.0f);
+			t.normal(0.0f, 0.0f, 1.0f);
 			t.vertexUV(0, 0, 0, u0, v1);
 			t.vertexUV(r, 0, 0, u1, v1);
 			t.vertexUV(r, 1, 0, u1, v0);
 			t.vertexUV(0, 1, 0, u0, v0);
 
+			t.normal(0.0f, 0.0f, -1.0f);
 			t.vertexUV(0, 1, 0 - dd, u0, v0);
 			t.vertexUV(r, 1, 0 - dd, u1, v0);
 			t.vertexUV(r, 0, 0 - dd, u1, v1);
 			t.vertexUV(0, 0, 0 - dd, u0, v1);
 
+			col = 0.8f;
+			t.color(col*br,col*br,col*br,1.0f);
+			t.normal(-1.0f, 0.0f, 0.0f);
 			for (int i = 0; i < 16; i++) {
 				float p = i / 16.0f;
 				float uu = u0 + (u1 - u0) * p - 0.5f / 256.0f;
@@ -172,6 +208,7 @@ void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
 				t.vertexUV(xx, 1, 0, uu, v0);
 				t.vertexUV(xx, 1, 0 - dd, uu, v0);
 			}
+			t.normal(1.0f, 0.0f, 0.0f);
 			for (int i = 0; i < 16; i++) {
 				float p = i / 16.0f;
 				float uu = u0 + (u1 - u0) * p - 0.5f / 256.0f;
@@ -181,6 +218,10 @@ void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
 				t.vertexUV(xx, 0, 0, uu, v1);
 				t.vertexUV(xx, 0, 0 - dd, uu, v1);
 			}
+
+			col = 0.6f;
+			t.color(col*br,col*br,col*br,1.0f);
+			t.normal(0.0f, 1.0f, 0.0f);
 			for (int i = 0; i < 16; i++) {
 				float p = i / 16.0f;
 				float vv = v1 + (v0 - v1) * p - 0.5f / 256.0f;
@@ -190,6 +231,7 @@ void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
 				t.vertexUV(r, yy, 0 - dd, u1, vv);
 				t.vertexUV(0, yy, 0 - dd, u0, vv);
 			}
+			t.normal(0.0f, -1.0f, 0.0f);
 			for (int i = 0; i < 16; i++) {
 				float p = i / 16.0f;
 				float vv = v1 + (v0 - v1) * p - 0.5f / 256.0f;
@@ -219,7 +261,7 @@ void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
 		}
 		mc->textures->loadAndBindTexture(renderObject.texture);
 
-		drawArrayVT_NoState(renderObject.chunk.vboId, renderObject.chunk.vertexCount);
+		drawArrayVTN_NoState(renderObject.chunk.vboId, renderObject.chunk.vertexCount);
 		if (renderObject.isFlat)
 			glPopMatrix2();
 	}
@@ -227,6 +269,7 @@ void ItemInHandRenderer::renderItem(Mob* mob,  ItemInstance* item )
 	//handler.printEvery(100);
 }
 
+
 void ItemInHandRenderer::render( float a )
 {
 	//return;
@@ -241,6 +284,8 @@ void ItemInHandRenderer::render( float a )
 	glPushMatrix2();
 	glRotatef2(player->xRotO + (player->xRot - player->xRotO) * a, 1, 0, 0);
 	glRotatef2(player->yRotO + (player->yRot - player->yRotO) * a, 0, 1, 0);
+	glEnable(GL_RESCALE_NORMAL);
+	Lighting::turnOn(mc);
 	glPopMatrix2();
 
 	float br = mc->level->getBrightness(Mth::floor(player->x), Mth::floor(player->y), Mth::floor(player->z));
@@ -293,7 +338,7 @@ void ItemInHandRenderer::render( float a )
 		glTranslatef2(0.7f * d, -0.65f * d - (1 - h) * 0.6f, -0.9f * d);
 
 		glRotatef2(45, 0, 1, 0);
-		//glEnable2(GL_RESCALE_NORMAL);
+		glEnable2(GL_RESCALE_NORMAL);
 		glRotatef2(-swing3 * 20, 0, 1, 0);
 		glRotatef2(-swing2 * 20, 0, 0, 1);
 		glRotatef2(-swing2 * 80, 1, 0, 0);
@@ -330,7 +375,9 @@ void ItemInHandRenderer::render( float a )
 		}
 		glEnableClientState2(GL_VERTEX_ARRAY);
 		glEnableClientState2(GL_TEXTURE_COORD_ARRAY);
+		glEnableClientState2(GL_NORMAL_ARRAY);
 		renderItem(player, item);
+		glDisableClientState2(GL_NORMAL_ARRAY);
 		glDisableClientState2(GL_VERTEX_ARRAY);
 		glDisableClientState2(GL_TEXTURE_COORD_ARRAY);
 		glPopMatrix2();
@@ -349,14 +396,15 @@ void ItemInHandRenderer::render( float a )
 		glTranslatef2(0.8f * d, -0.75f * d - (1 - h) * 0.6f, -0.9f * d);
 
 		glRotatef2(45, 0, 1, 0);
-		//glEnable2(GL_RESCALE_NORMAL);
+//		glEnable2(GL_RESCALE_NORMAL);
+		glEnable(GL_NORMALIZE);
 		glRotatef2(swing2 * 70, 0, 1, 0);
 		glRotatef2(-swing3 * 20, 0, 0, 1);
 		// glRotatef2(-swing2 * 80, 1, 0, 0);
 
 		mc->textures->loadAndBindTexture(player->getTexture());
 		glTranslatef2(-1.0f, +3.6f, +3.5f);
-		glRotatef2(120, 0, 0, 1);
+		glRotatef2(120, 0, 0, 1);	
 		glRotatef2(180 + 20, 1, 0, 0);
 		glRotatef2(-90 - 45, 0, 1, 0);
 		glScalef2(1.5f / 24.0f * 16, 1.5f / 24.0f * 16, 1.5f / 24.0f * 16);
@@ -369,8 +417,8 @@ void ItemInHandRenderer::render( float a )
 		playerRenderer->renderHand();
 		glPopMatrix2();
 	}
-	//glDisable2(GL_RESCALE_NORMAL);
-	//Lighting.turnOff();
+	glDisable2(GL_RESCALE_NORMAL);
+	Lighting::turnOff();
 	//w.stop();
 }
 
@@ -395,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,6 +189,9 @@ 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);
 	if (lastViewDistance <= 2 && mc->isPowerVR())
@@ -325,6 +349,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 +568,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");
+	//	textures->loadAndBindTexture("terrain.png"); // uh need to check java - shredder
 
 	//t.begin();
-	t.color(255, 255, 255, 255);
-
-	t.offset(((Mob*)mc->player)->getPos(0).negated());
+	//	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);
@@ -1009,13 +1064,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 +1144,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 +1311,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 +1609,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/Lighting.cpp

@@ -0,0 +1,49 @@
+#include "Lighting.h"
+#include "gles.h"
+#include "../Minecraft.h"
+
+void Lighting::turnOff() {
+    glDisable(GL_LIGHTING);
+    glDisable(GL_LIGHT0);
+    glDisable(GL_LIGHT1);
+    glDisable(GL_COLOR_MATERIAL);
+}
+
+void Lighting::turnOn(Minecraft* minecraft) {
+	if (!minecraft->options.getBooleanValue(OPTIONS_NORMAL_LIGHTING)){ // if normal lighting is false, then just dont use the lighting system at all like in vanilla - shredder
+	turnOff();
+		return;
+	}
+	glEnable(GL_NORMALIZE);
+	// if normal lighting is true then enable GLES/OpenGL states to setup lighting
+    glEnable(GL_LIGHTING);
+    glEnable(GL_LIGHT0);
+    glEnable(GL_LIGHT1);
+    glEnable(GL_COLOR_MATERIAL);
+ //   glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
+
+    constexpr float a = 0.4f;
+    constexpr float d = 0.6f;
+    constexpr float s = 0.0f;
+
+
+    //Vec3 l = world::phys::Vec3{0.2, 1.0, -0.7}.normalize();
+    constexpr float lightmodel_ambient[] = {a, a, a, 1.0f};
+    constexpr float diffuse[] = {d, d, d, 1.0f};
+    constexpr float ambient[] = {0.0f, 0.0f, 0.0f, 1.0f};
+    constexpr float specular[] = {s, s, s, 1.0f};
+
+    constexpr float pos0[] = {(float)(0.16169041989141428), (float)(0.8084520874101966), (float)(-0.5659164515496377), 0.0f};
+    glLightfv(GL_LIGHT0, GL_POSITION, pos0);
+    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
+    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
+    glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
+
+    constexpr float pos1[] = {(float)(-0.16169041989141428), (float)(0.8084520874101966), (float)(0.5659164515496377), 0.0f};
+    glLightfv(GL_LIGHT1, GL_POSITION, pos1);
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
+    glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
+    glLightfv(GL_LIGHT1, GL_SPECULAR, specular);
+    glShadeModel(GL_FLAT);
+    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightmodel_ambient);
+}

src/client/renderer/Lighting.h

@@ -0,0 +1,12 @@
+#ifndef NET_MINECRAFT_CLIENT_RENDERER__Lighting_H__
+#define NET_MINECRAFT_CLIENT_RENDERER__Lighting_H__
+
+class Minecraft;
+class Lighting
+{
+public:
+	static void turnOff();
+	static void turnOn(Minecraft* minecraft);
+
+};
+#endif /*NET_MINECRAFT_CLIENT_RENDERER__Lighting_H__*/

src/client/renderer/Tesselator.cpp

@@ -8,7 +8,7 @@ Tesselator Tesselator::instance(sizeof(GLfloat) * MAX_FLOATS); // max size in by
 const int VertexSizeBytes = sizeof(VERTEX);
 
 Tesselator::Tesselator( int size )
-:	size(size),
+	:	size(size),
 	vertices(0),
 	u(0), v(0),
 	_color(0),
@@ -20,7 +20,7 @@ Tesselator::Tesselator( int size )
 	_noColor(false),
 	mode(0),
 	xo(0), yo(0), zo(0),
-	_normal(0),
+	_nx(0), _ny(0), _nz(0),
 	_sx(1), _sy(1),
 
 	tesselating(false),
@@ -97,9 +97,9 @@ RenderChunk Tesselator::end( bool useMine, int bufferId )
 		int access = GL_STATIC_DRAW;//(accessMode==ACCESS_DYNAMIC) ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
 		glBindBuffer2(GL_ARRAY_BUFFER, bufferId);
 		glBufferData2(GL_ARRAY_BUFFER, bytes, _varray, access); // GL_STREAM_DRAW
-		
+
 		totalSize += bytes;
-	
+
 #ifndef USE_VBO
 		// 0 1 2 3 4 5 6 7
 		// x y z u v c
@@ -112,7 +112,7 @@ RenderChunk Tesselator::end( bool useMine, int bufferId )
 			glEnableClientState2(GL_COLOR_ARRAY);
 		}
 		if (hasNormal) {
-			glNormalPointer(GL_BYTE, VertexSizeBytes, (GLvoid*) (6 * 4));
+			glNormalPointer(GL_FLOAT, VertexSizeBytes, (GLvoid*) (6 * 4));
 			glEnableClientState2(GL_NORMAL_ARRAY);
 		}
 		glVertexPointer2(3, GL_FLOAT, VertexSizeBytes, 0);
@@ -278,9 +278,11 @@ void Tesselator::vertex( float x, float y, float z )
 			if (hasColor) {
 				dst.color = src.color;
 			}
-			//if (hasNormal) {
-			//	dst.normal = src.normal;
-			//}
+			if (hasNormal) {
+				dst.nx = src.nx;
+				dst.ny = src.ny;
+				dst.nz = src.nz;
+			}
 
 			dst.x = src.x;
 			dst.y = src.y;
@@ -301,9 +303,11 @@ void Tesselator::vertex( float x, float y, float z )
 	if (hasColor) {
 		vertex.color = _color;
 	}
-	//if (hasNormal) {
-	//	vertex.normal = _normal;
-	//}
+	if (hasNormal) {
+		vertex.nx = _nx;
+		vertex.ny = _ny;
+		vertex.nz = _nz;
+	}
 
 	vertex.x = _sx * (x + xo);
 	vertex.y = _sy * (y + yo);
@@ -332,18 +336,22 @@ void Tesselator::setAccessMode(int mode)
 
 void Tesselator::normal( float x, float y, float z )
 {
-	static int _warn_t = 0;
-	if ((++_warn_t & 32767) == 1)
-		LOGI("WARNING: Can't use normals (Tesselator::normal)\n");
-	return;
+	//static int _warn_t = 0;
+	//if ((++_warn_t & 32767) == 1)
+	//	LOGI("WARNING: Can't use normals (Tesselator::normal)\n");
+	//return;
 
 	if (!tesselating) printf("But..");
 	hasNormal = true;
-	char xx = (char) (x * 128);
-	char yy = (char) (y * 127);
-	char zz = (char) (z * 127);
+	//char xx = (char) (x * 128);
+	//char yy = (char) (y * 127);
+	//char zz = (char) (z * 127);
 
-	_normal = xx | (yy << 8) | (zz << 16);
+	//_normal = xx | (yy << 8) | (zz << 16);
+	// trying a new thing hopefully works
+	this->_nx = x;
+	this->_ny = y;
+	this->_nz = z;
 }
 
 void Tesselator::offset( float xo, float yo, float zo ) {
@@ -389,7 +397,7 @@ void Tesselator::draw()
 			vboId = 0;
 
 		int bufferId = vboIds[vboId];
-		
+
 		int access = GL_DYNAMIC_DRAW;//(accessMode==ACCESS_DYNAMIC) ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
 		glBindBuffer2(GL_ARRAY_BUFFER, bufferId);
 		glBufferData2(GL_ARRAY_BUFFER, bytes, _varray, access); // GL_STREAM_DRAW
@@ -404,10 +412,10 @@ void Tesselator::draw()
 			//glColorPointer2(4, GL_UNSIGNED_BYTE, VertexSizeBytes, (GLvoid*) &_varray->color);
 			glEnableClientState2(GL_COLOR_ARRAY);
 		}
-		//if (hasNormal) {
-		//	glNormalPointer(GL_BYTE, VertexSizeBytes, (GLvoid*) (6 * 4));
-		//	glEnableClientState2(GL_NORMAL_ARRAY);
-		//}
+		if (hasNormal) {
+			glNormalPointer(GL_FLOAT, VertexSizeBytes, (GLvoid*) (6 * 4));
+			glEnableClientState2(GL_NORMAL_ARRAY);
+		}
 		//glVertexPointer2(3, GL_FLOAT, VertexSizeBytes, (GLvoid*)&_varray);
 		glVertexPointer2(3, GL_FLOAT, VertexSizeBytes, 0);
 		glEnableClientState2(GL_VERTEX_ARRAY);
@@ -421,7 +429,7 @@ void Tesselator::draw()
 		glDisableClientState2(GL_VERTEX_ARRAY);
 		if (hasTexture) glDisableClientState2(GL_TEXTURE_COORD_ARRAY);
 		if (hasColor) glDisableClientState2(GL_COLOR_ARRAY);
-		//if (hasNormal) glDisableClientState2(GL_NORMAL_ARRAY);
+		if (hasNormal) glDisableClientState2(GL_NORMAL_ARRAY);
 	}
 
 	clear();

src/client/renderer/Tesselator.h

@@ -10,7 +10,7 @@
 
 extern const int VertexSizeBytes;
 
-typedef VertexDeclPTC VERTEX;
+typedef VertexDeclPTCN VERTEX;
 typedef std::map<GLuint, GLsizei> IntGLMap;
 
 
@@ -98,7 +98,9 @@ private:
 	float xo, yo, zo;
 	float u, v;
 	unsigned int _color;
-	int _normal;
+//	int _normal; // trying a new thing
+	float _nx, _ny, _nz; 
+
 	float _sx, _sy;
 
 	bool hasColor;

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/VertecDecl.h

@@ -14,7 +14,8 @@ typedef struct VertexDeclPTCN
 	GLfloat x, y, z;
 	GLfloat u, v;
 	GLuint color;
-	GLuint normal;
+//	GLuint normal; // trying a new thing
+	GLfloat nx, ny, nz;
 
 } VertexDeclPTCN;
 

src/client/renderer/entity/EntityRenderer.cpp

@@ -12,6 +12,7 @@
 #include "../../Minecraft.h"
 #include "../../Option.h"
 
+#include "../Lighting.h"
 EntityRenderDispatcher* EntityRenderer::entityRenderDispatcher = NULL;
 
 EntityRenderer::EntityRenderer()
@@ -129,12 +130,11 @@ 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);
 	int tex = ((Tile*)Tile::fire)->tex;
 
 	int xt = (tex & 0xf) << 4;
@@ -176,7 +176,7 @@ void EntityRenderer::renderFlame(Entity* e, float x, float y, float z, float a)
 	}
 	t.draw();
 	glPopMatrix2();
-	//	glEnable2(GL_LIGHTING);
+	glEnable2(GL_LIGHTING);
 }
 
 void EntityRenderer::renderShadow(Entity* e, float x, float y, float z, float pow, float a) { //
@@ -186,10 +186,13 @@ 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->bind(textures->loadTexture("/misc/shadow.png"));
+	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);
+
 
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
 	Level* level = getLevel();
 

src/client/renderer/entity/ItemRenderer.cpp

@@ -45,7 +45,7 @@ void ItemRenderer::render(Entity* itemEntity_, float x, float y, float z, float
 	else if (item->count > 1) count = 2;
 
 	glTranslatef2((float) x, (float) y + bob, (float) z);
-	//glEnable2(GL_RESCALE_NORMAL);
+	glEnable2(GL_RESCALE_NORMAL);
 	if (item->id < 256 && TileRenderer::canRender(Tile::tiles[item->id]->getRenderShape())) {
 		glRotatef2(spin, 0, 1, 0);
 
@@ -107,7 +107,7 @@ void ItemRenderer::render(Entity* itemEntity_, float x, float y, float z, float
 			}
 			glRotatef2(180 - entityRenderDispatcher->playerRotY, 0, 1, 0);
 			t.begin();
-			//t.normal(0, 1, 0);
+			t.normal(0, 1, 0);
 			t.vertexUV(0 - xo, 0 - yo, 0, u0, v1);
 			t.vertexUV(r - xo, 0 - yo, 0, u1, v1);
 			t.vertexUV(r - xo, 1 - yo, 0, u1, v0);
@@ -118,7 +118,7 @@ void ItemRenderer::render(Entity* itemEntity_, float x, float y, float z, float
 			glPopMatrix2();
 		}
 	}
-	//glDisable2(GL_RESCALE_NORMAL);
+	glDisable2(GL_RESCALE_NORMAL);
 	glPopMatrix2();
 }
 

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/entity/PaintingRenderer.cpp

@@ -9,7 +9,7 @@ void PaintingRenderer::render( Entity* entity, float x, float y, float z, float
 	glPushMatrix();
 	glTranslatef(float(x), float(y), float(z));
 	glRotatef(rot, 0, 1.0f, 0);
-	//glEnable(GL_RESCALE_NORMAL);
+	glEnable(GL_RESCALE_NORMAL);
 	bindTexture("art/kz.png");
 	Painting* painting = (Painting*)entity;
 	const Motive* motive = painting->motive;
@@ -17,7 +17,7 @@ void PaintingRenderer::render( Entity* entity, float x, float y, float z, float
 	float s = 1.0f / 16.0f;
 	glScalef(s, s, s);
 	renderPainting(painting, motive->w, motive->h, motive->uo, motive->vo, a);
-	//glDisable(GL_RESCALE_NORMAL);
+	glDisable(GL_RESCALE_NORMAL);
 	glPopMatrix();
 }
 

src/client/renderer/entity/PlayerRenderer.cpp

@@ -77,10 +77,10 @@ void PlayerRenderer::render(Entity* mob_, float x, float y, float z, float rot,
 		model = desired;
 		humanoidModel = desired;
 	}
-	LOGI("[PlayerRenderer] %s: skin=%s, modelTex=%dx%d, desired=%s\n", 
-		((Player*)mob)->name.c_str(), mob->getTexture().c_str(), 
-		humanoidModel->texWidth, humanoidModel->texHeight,
-		(desired == playerModel64 ? "64" : "32"));
+//	LOGI("[PlayerRenderer] %s: skin=%s, modelTex=%dx%d, desired=%s\n", // don't log it always, only for debug - shredder
+//		((Player*)mob)->name.c_str(), mob->getTexture().c_str(), 
+//		humanoidModel->texWidth, humanoidModel->texHeight,
+//		(desired == playerModel64 ? "64" : "32"));
 	HumanoidMobRenderer::render(mob_, x, y, z, rot, a);
 }
 

src/client/renderer/gles.cpp

@@ -115,6 +115,41 @@ void drawArrayVTC_NoState(int bufferId, int vertices, int vertexSize /* = 24 */)
 }
 #endif
 
+void drawArrayVTN(int bufferId, int vertices, int vertexSize /* = 24 */) {
+	//if (Options::debugGl) LOGI("drawArray\n");
+	//LOGI("draw-vtc: %d, %d, %d\n", bufferId, vertices, vertexSize);
+	glEnableClientState2(GL_VERTEX_ARRAY);
+	glEnableClientState2(GL_TEXTURE_COORD_ARRAY);
+	//glEnableClientState2(GL_COLOR_ARRAY);
+	glEnableClientState2(GL_NORMAL_ARRAY);
+
+	glBindBuffer2(GL_ARRAY_BUFFER, bufferId);
+
+	glVertexPointer2(  3, GL_FLOAT, vertexSize, 0);
+	glTexCoordPointer2(2, GL_FLOAT, vertexSize, (GLvoid*) (3 * 4));
+	//glColorPointer2(4, GL_UNSIGNED_BYTE, vertexSize, (GLvoid*) (5*4));
+	glNormalPointer(GL_FLOAT, vertexSize, (GLvoid*) (6 * 4));
+
+	glDrawArrays2(GL_TRIANGLES, 0, vertices);
+
+	glDisableClientState2(GL_VERTEX_ARRAY);
+	glDisableClientState2(GL_TEXTURE_COORD_ARRAY);
+	//glDisableClientState2(GL_COLOR_ARRAY); 
+	glDisableClientState2(GL_NORMAL_ARRAY);
+}
+
+#ifndef drawArrayVTN_NoState
+void drawArrayVTCN_NoState(int bufferId, int vertices, int vertexSize /* = 24 */) {
+	glBindBuffer2(GL_ARRAY_BUFFER, bufferId);
+
+	glVertexPointer2(  3, GL_FLOAT, vertexSize, 0);
+	glTexCoordPointer2(2, GL_FLOAT, vertexSize, (GLvoid*) (3 * 4));
+	//glColorPointer2(4, GL_UNSIGNED_BYTE, vertexSize, (GLvoid*) (5*4));
+	glNormalPointer(GL_FLOAT, vertexSize, (GLvoid*) (6 * 4));
+
+	glDrawArrays2(GL_TRIANGLES, 0, vertices);
+}
+#endif
 #endif
 
 

src/client/renderer/gles.h

@@ -4,11 +4,15 @@
 #include "../../platform/log.h"
 #include "../Options.h"
 
+#if defined(__APPLE__)
+    #define GLES_SILENCE_DEPRECATION
+#endif
+
 // Android should always run OPENGL_ES
 #if defined(ANDROID) || defined(__APPLE__) || defined(RPI)
     #define OPENGL_ES
 #endif
-
+#define GLES_SILENCE_DEPRECATION
 // Other systems might run it, if they #define OPENGL_ES
 // #if defined(OPENGL_ES) // || defined(ANDROID)
 	#define USE_VBO
@@ -55,13 +59,18 @@ void anGenBuffers(GLsizei n, GLuint* buffer);
 #ifdef USE_VBO
 #define drawArrayVT_NoState drawArrayVT
 #define drawArrayVTC_NoState drawArrayVTC
-void drawArrayVT(int bufferId, int vertices, int vertexSize = 24, unsigned int mode = GL_TRIANGLES);
+#define drawArrayVTN_NoState drawArrayVTN
+void drawArrayVT(int bufferId, int vertices, int vertexSize = 36, unsigned int mode = GL_TRIANGLES);
 #ifndef drawArrayVT_NoState
-//void drawArrayVT_NoState(int bufferId, int vertices, int vertexSize = 24);
+//void drawArrayVT_NoState(int bufferId, int vertices, int vertexSize = 36);
 #endif
-void drawArrayVTC(int bufferId, int vertices, int vertexSize = 24);
+void drawArrayVTC(int bufferId, int vertices, int vertexSize = 36);
 #ifndef drawArrayVTC_NoState
-void drawArrayVTC_NoState(int bufferId, int vertices, int vertexSize = 24);
+void drawArrayVTC_NoState(int bufferId, int vertices, int vertexSize = 36);
+#endif
+void drawArrayVTN(int bufferId, int vertices, int vertexSize = 36);
+#ifndef drawArrayVTN_NoState
+void drawArrayVTCN_NoState(int bufferId, int vertices, int vertexSize = 36);
 #endif
 #endif
 
@@ -114,6 +123,7 @@ int glhUnProjectf(	float winx, float winy, float winz,
 	#define glVertexPointer2	glVertexPointer
 	#define glColorPointer2		glColorPointer
 	#define glTexCoordPointer2  glTexCoordPointer
+	#define glNormalPointer2 glNormalPointer
 	#define glEnableClientState2  glEnableClientState
 	#define glDisableClientState2 glDisableClientState
 	#define glDrawArrays2		glDrawArrays
@@ -137,7 +147,7 @@ int glhUnProjectf(	float winx, float winy, float winz,
 //
 // Extensions
 //
-#ifdef WIN32
+#ifdef WIN32	
 	#define glGetProcAddress(a) wglGetProcAddress(a)
 #else
 	#define glGetProcAddress(a) (void*(0))

src/client/renderer/ptexture/DynamicTexture.cpp

@@ -9,7 +9,7 @@
 // DynamicTexture
 //
 DynamicTexture::DynamicTexture(int tex_)
-:   tex(tex_),
+	:   tex(tex_),
 	replicate(1)
 {
 	memset(pixels, 0, 16*16*4);
@@ -29,8 +29,8 @@ void DynamicTexture::bindTexture(Textures* tex) {
 /*
 WaterTexture::WaterTexture()
 :   super(Tile::water->tex),
-	_tick(0),
-	_frame(0)
+_tick(0),
+_frame(0)
 {
 }
 
@@ -39,7 +39,7 @@ void WaterTexture::tick() {
 */
 
 WaterTexture::WaterTexture()
-:   super(Tile::water->tex),
+	:   super(Tile::water->tex),
 	_tick(0),
 	_frame(0)
 {
@@ -76,55 +76,55 @@ void WaterTexture::tick()
 			next[x + y * 16] = pow / 3.3f + heat[x + y * 16] * 0.8f;
 		}
 
-	for (int x = 0; x < 16; x++)
-		for (int y = 0; y < 16; y++) {
-			heat[x + y * 16] += heata[x + y * 16] * 0.05f;
+		for (int x = 0; x < 16; x++)
+			for (int y = 0; y < 16; y++) {
+				heat[x + y * 16] += heata[x + y * 16] * 0.05f;
 
-			if (heat[x + y * 16] < 0) heat[x + y * 16] = 0;
-			heata[x + y * 16] -= 0.1f;
-			if (Mth::random() < 0.05f) {
-				heata[x + y * 16] = 0.5f;
+				if (heat[x + y * 16] < 0) heat[x + y * 16] = 0;
+				heata[x + y * 16] -= 0.1f;
+				if (Mth::random() < 0.05f) {
+					heata[x + y * 16] = 0.5f;
+				}
 			}
-		}
 
-	float* tmp = next;
-	next = current;
-	current = tmp;
+			float* tmp = next;
+			next = current;
+			current = tmp;
 
-	for (int i = 0; i < 256; i++) {
-		float pow = current[i];
-		if (pow > 1) pow = 1;
-		if (pow < 0) pow = 0;
+			for (int i = 0; i < 256; i++) {
+				float pow = current[i];
+				if (pow > 1) pow = 1;
+				if (pow < 0) pow = 0;
 
-		float pp = pow * pow;
+				float pp = pow * pow;
 
-		int r = (int) (32 + pp * 32);
-		int g = (int) (50 + pp * 64);
-		int b = (int) (255);
-		int a = (int) (146 + pp * 50);
+				int r = (int) (32 + pp * 32);
+				int g = (int) (50 + pp * 64);
+				int b = (int) (255);
+				int a = (int) (146 + pp * 50);
 
-		//if (anaglyph3d) {
-		//	int rr = (r * 30 + g * 59 + b * 11) / 100;
-		//	int gg = (r * 30 + g * 70) / (100);
-		//	int bb = (r * 30 + b * 70) / (100);
+				//if (anaglyph3d) {
+				//	int rr = (r * 30 + g * 59 + b * 11) / 100;
+				//	int gg = (r * 30 + g * 70) / (100);
+				//	int bb = (r * 30 + b * 70) / (100);
 
-		//	r = rr;
-		//	g = gg;
-		//	b = bb;
-		//}
+				//	r = rr;
+				//	g = gg;
+				//	b = bb;
+				//}
 
-		pixels[i * 4 + 0] = r;
-		pixels[i * 4 + 1] = g;
-		pixels[i * 4 + 2] = b;
-		pixels[i * 4 + 3] = a;
-	}
+				pixels[i * 4 + 0] = r;
+				pixels[i * 4 + 1] = g;
+				pixels[i * 4 + 2] = b;
+				pixels[i * 4 + 3] = a;
+			}
 }
 
 //
 // WaterSideTexture
 //
 WaterSideTexture::WaterSideTexture()
-:   super(Tile::water->tex + 1),
+	:   super(Tile::water->tex + 1),
 	_tick(0),
 	_frame(0),
 	_tickCount(0)
@@ -164,51 +164,237 @@ void WaterSideTexture::tick() {
 			next[x + y * 16] = pow / 3.2f + heat[x + y * 16] * 0.8f;
 		}
 
-	for (int x = 0; x < 16; x++)
-		for (int y = 0; y < 16; y++) {
-			heat[x + y * 16] += heata[x + y * 16] * 0.05f;
+		for (int x = 0; x < 16; x++)
+			for (int y = 0; y < 16; y++) {
+				heat[x + y * 16] += heata[x + y * 16] * 0.05f;
 
-			if (heat[x + y * 16] < 0) heat[x + y * 16] = 0;
-			heata[x + y * 16] -= 0.3f;
-			if (Mth::random() < 0.2) {
-				heata[x + y * 16] = 0.5f;
+				if (heat[x + y * 16] < 0) heat[x + y * 16] = 0;
+				heata[x + y * 16] -= 0.3f;
+				if (Mth::random() < 0.2) {
+					heata[x + y * 16] = 0.5f;
+				}
 			}
-		}
-	float* tmp = next;
-	next = current;
-	current = tmp;
+			float* tmp = next;
+			next = current;
+			current = tmp;
 
-	for (int i = 0; i < 256; i++) {
-		float pow = current[(i - _tickCount * 16) & 255];
-		if (pow > 1) pow = 1;
-		if (pow < 0) pow = 0;
+			for (int i = 0; i < 256; i++) {
+				float pow = current[(i - _tickCount * 16) & 255];
+				if (pow > 1) pow = 1;
+				if (pow < 0) pow = 0;
 
-		float pp = pow * pow;
+				float pp = pow * pow;
 
-		int r = (int) (32 + pp * 32);
-		int g = (int) (50 + pp * 64);
-		int b = (int) (255);
-		int a = (int) (146 + pp * 50);
+				int r = (int) (32 + pp * 32);
+				int g = (int) (50 + pp * 64);
+				int b = (int) (255);
+				int a = (int) (146 + pp * 50);
 
-		//if (anaglyph3d) {
-		//	int rr = (r * 30 + g * 59 + b * 11) / 100;
-		//	int gg = (r * 30 + g * 70) / (100);
-		//	int bb = (r * 30 + b * 70) / (100);
+				//if (anaglyph3d) {
+				//	int rr = (r * 30 + g * 59 + b * 11) / 100;
+				//	int gg = (r * 30 + g * 70) / (100);
+				//	int bb = (r * 30 + b * 70) / (100);
 
-		//	r = rr;
-		//	g = gg;
-		//	b = bb;
-		//}
+				//	r = rr;
+				//	g = gg;
+				//	b = bb;
+				//}
 
-		pixels[i * 4 + 0] = r;
-		pixels[i * 4 + 1] = g;
-		pixels[i * 4 + 2] = b;
-		pixels[i * 4 + 3] = a;
+				pixels[i * 4 + 0] = r;
+				pixels[i * 4 + 1] = g;
+				pixels[i * 4 + 2] = b;
+				pixels[i * 4 + 3] = a;
+			}
+}
+
+///
+/// Lava Texture
+///
+
+LavaTexture::LavaTexture()
+	:   super(Tile::lava->tex),
+	_tick(0),
+	_frame(0)
+{
+	current = new float[16*16];
+	next = new float[16*16];
+	heat = new float[16*16];
+	heata = new float[16*16];
+
+	for (int i = 0; i < 256; ++i) {
+		current[i] = 0;
+		next[i] = 0;
+		heat[i] = 0;
+		heata[i] = 0;
 	}
 }
 
-FireTexture::FireTexture()
-:   super(((Tile*)Tile::fire)->tex),
+LavaTexture::~LavaTexture() {
+	delete[] current;
+	delete[] next;
+	delete[] heat;
+	delete[] heata;
+}
+
+void LavaTexture::tick()
+{
+	for (int x = 0; x < 16; x++)
+		for (int y = 0; y < 16; y++) {
+			float pow = 0;
+			int xxo = (int)(Mth::sin((float)(y) * (float)(Mth::PI) * 2.0f / 16.0f) * 1.2f);
+			int yyo = (int)(Mth::sin((float)(x) * (float)(Mth::PI) * 2.0f / 16.0f) * 1.2f);
+			for (int xx = x - 1; xx <= x + 1; xx++) {
+				for (int yy = y - 1; yy <= y + 1; yy++) {
+					int xi = xx + xxo & 15;
+					int yi = yy + yyo & 15;
+					pow += current[xi + yi * 16];
+				}
+			}
+			next[x + y * 16] = pow / 10.0f + (heat[(x + 0 & 15) + (y + 0 & 15) * 16] + heat[(x + 1 & 15) + (y + 0 & 15) * 16] + heat[(x + 1 & 15) + (y + 1 & 15) * 16] + heat[(x + 0 & 15) + (y + 1 & 15) * 16]) / 4.0f * 0.8f;
+			heat[x + y * 16] = heat[x + y * 16] + heata[x + y * 16] * 0.01f;
+			if (heat[x + y * 16] < 0.0f) {
+				heat[x + y * 16] = 0.0f;
+			}
+			heata[x + y * 16] = heata[x + y * 16] - 0.06f;
+			if (Mth::random() < 0.005) {
+				heata[x + y * 16] = 1.5f;
+			}
+		}
+
+
+		float* tmp = next;
+		next = current;
+		current = tmp;
+
+		for (int i = 0; i < 256; i++) {
+			float pow = current[i] * 2.0f;
+			if (pow > 1) pow = 1;
+			if (pow < 0) pow = 0;
+
+			float pp = pow * pow;
+
+			int r = (int) (pow * 100.0f + 155.0f);
+			int g = (int) (pp * 255.0f);
+			int b = (int) (pp * pp * 128.0f);
+
+			//if (anaglyph3d) {
+			//	int rr = (r * 30 + g * 59 + b * 11) / 100;
+			//	int gg = (r * 30 + g * 70) / (100);
+			//	int bb = (r * 30 + b * 70) / (100);
+
+			//	r = rr;
+			//	g = gg;
+			//	b = bb;
+			//}
+
+			pixels[i * 4 + 0] = r;
+			pixels[i * 4 + 1] = g;
+			pixels[i * 4 + 2] = b;
+			pixels[i * 4 + 3] = -1;
+		}
+}
+
+///
+/// Lava Side Texture
+///
+
+LavaSideTexture::LavaSideTexture()
+	:   super(Tile::lava->tex + 1),
+	_tick(0),
+	_frame(0),
+	_tickCount(0)
+{
+	replicate = 2;
+
+	current = new float[16*16];
+	next = new float[16*16];
+	heat = new float[16*16];
+	heata = new float[16*16];
+
+	for (int i = 0; i < 256; ++i) {
+		current[i] = 0;
+		next[i] = 0;
+		heat[i] = 0;
+		heata[i] = 0;
+	}
+}
+
+LavaSideTexture::~LavaSideTexture() {
+	delete[] current;
+	delete[] next;
+	delete[] heat;
+	delete[] heata;
+}
+
+void LavaSideTexture::tick() {
+	++_tickCount;
+	for (int x = 0; x < 16; x++)
+		for (int y = 0; y < 16; y++) {
+			float pow = 0;
+			int yl = (int)(Mth::sin((float)(y) * (float)(Mth::PI)* 2.0f / 16.0f) * 1.2f); // var2 is y
+			int xl = (int)(Mth::sin((float)(x) * (float)(Mth::PI)* 2.0f / 16.0f) * 1.2f); // var1 is x
+			for (int yy = x - 1; yy <= x + 1; yy++) {
+				for (int xx = y - 1; xx <= y + 1; xx++) {
+					int xi = (yy + yl) & 15; // var8
+					int yi = (xx + xl) & 15; //var9
+					pow += current[xi + yi * 16];
+				}
+			}
+			next[x + y * 16] =
+				next[x + y * 16] =
+				pow / 10.0f + (
+				heat[(x + 0 & 15) + (y + 0 & 15) *
+				16] + heat[
+					(x + 1 & 15) + (y + 0 & 15) * 16] + heat[(x + 1 & 15) + (y + 1 & 15) *
+						16] + heat[
+							(x + 0 & 15) + (y + 1 & 15) * 16]) / 4.0f
+								* 0.8f;
+							heat[x + y * 16] = heat[x + y * 16] + heata[x + y * 16] * 0.01f;
+
+							if (heat[x + y * 16] < 0.0f) {
+								heat[x + y * 16] = 0.0f;
+							}
+							heata[x + y * 16] = heata[x + y * 16] - 0.06f;
+
+							if (Mth::random() < 0.005) {
+								heata[x + y * 16] = 1.5f;
+							}
+		}
+		float* tmp = next;
+		next = current;
+		current = tmp;
+
+		for (int i = 0; i < 256; i++) {
+			float pow = current[(i - _tickCount / 3 * 16) & 255] * 2.0f;
+			if (pow > 1) pow = 1;
+			if (pow < 0) pow = 0;
+
+			float pp = pow * pow;
+
+			int r = (int) (pow * 100.0f + 155.0f);
+			int g = (int) (pow * pow * 255.0f);
+			int b = (int) (pow * pow * pow * pow * 128.0f);
+//			int a = (int) (146 + pp * 50);
+
+			//if (anaglyph3d) {
+			//	int rr = (r * 30 + g * 59 + b * 11) / 100;
+			//	int gg = (r * 30 + g * 70) / (100);
+			//	int bb = (r * 30 + b * 70) / (100);
+
+			//	r = rr;
+			//	g = gg;
+			//	b = bb;
+			//}
+
+			pixels[i * 4 + 0] = r;
+			pixels[i * 4 + 1] = g;
+			pixels[i * 4 + 2] = b;
+			pixels[i * 4 + 3] = -1;
+		}
+}
+
+FireTexture::FireTexture(int id)
+	:   super(((Tile*)Tile::fire)->tex + id * 16),
 	_tick(0),
 	_frame(0)
 {
@@ -236,63 +422,63 @@ FireTexture::~FireTexture() {
 // oh boy time to implement fire textures, i am so fucked - shredder
 
 void FireTexture::tick() {
-//  loop generates fire texture  on the empty texture grid, hopefully shouldnt be too taxing on older hardware - shredder
-    for (int x = 0; x < 16; x++) {
-        for (int y = 0; y < 20; y++) {
-            int count = 18;
-            float pow = this->current[x + (y + 1) % 20 * 16] * (float)(count);
-            for (int xx = x - 1; xx <= x + 1; xx++) {
-                for (int yy = y; yy <= y + 1; yy++) {
-                    if (xx >= 0 && yy >= 0 && xx < 16 && yy < 20) {
-                        pow += this->current[xx + yy * 16];
-                    }
-                    count++;
-                }
-            }
-            this->next[x + y * 16] = pow / (float(count) * 1.06f);
-            if (y >= 19) {
-                this->next[x + y * 16] = float(Mth::random() * Mth::random() * Mth::random() * 4.0 + Mth::random() * 0.1f + 0.2f);
-            }
-        }
-    }
+	//  loop generates fire texture  on the empty texture grid, hopefully shouldnt be too taxing on older hardware - shredder
+	for (int x = 0; x < 16; x++) {
+		for (int y = 0; y < 20; y++) {
+			int count = 18;
+			float pow = this->current[x + (y + 1) % 20 * 16] * (float)(count);
+			for (int xx = x - 1; xx <= x + 1; xx++) {
+				for (int yy = y; yy <= y + 1; yy++) {
+					if (xx >= 0 && yy >= 0 && xx < 16 && yy < 20) {
+						pow += this->current[xx + yy * 16];
+					}
+					count++;
+				}
+			}
+			this->next[x + y * 16] = pow / (float(count) * 1.06f);
+			if (y >= 19) {
+				this->next[x + y * 16] = float(Mth::random() * Mth::random() * Mth::random() * 4.0 + Mth::random() * 0.1f + 0.2f);
+			}
+		}
+	}
 
-    // hopefully this doesn't cause any mysterious issues - shredder
+	// hopefully this doesn't cause any mysterious issues - shredder
 	float* tmp = next;
 	next = current;
 	current = tmp;
 
-    for (int i = 0; i < 256; i++) {
-        float pow = this->current[i] * 1.8f;
-        if (pow > 1.0f) {
-            pow = 1.0f;
-        }
-        if (pow < 0.0f) {
-            pow = 0.0f;
-        }
-		
-	
-        int r = (int) (pow * 155.0f + 100.0f);
-        int g = (int)(pow * pow * 255.0f);
-        int b = (int)(pow * pow * pow * pow * pow * pow * pow * pow * pow * pow * 255.0f);
-        int a = 255;
-        if (pow < 0.5f) {
-            a = 0;
-        }
+	for (int i = 0; i < 256; i++) {
+		float pow = this->current[i] * 1.8f;
+		if (pow > 1.0f) {
+			pow = 1.0f;
+		}
+		if (pow < 0.0f) {
+			pow = 0.0f;
+		}
+
+
+		int r = (int) (pow * 155.0f + 100.0f);
+		int g = (int)(pow * pow * 255.0f);
+		int b = (int)(pow * pow * pow * pow * pow * pow * pow * pow * pow * pow * 255.0f);
+		int a = 255;
+		if (pow < 0.5f) {
+			a = 0;
+		}
 
 		// @TODO: cant be arsed rn to implement the anaglyph3d check would be nice to check if it does - shredder
-        //if (this->anaglyph3d) {
-        //    float rr = (r * 30 + g * 59 + b * 11) / 100;
-        //    float gg = (r * 30 + g * 70) / 100;
-        //    float bb = (r * 30 + b * 70) / 100;
-        //    r = rr;
-        //    g = gg;
-        //    b = bb;
-        //}
+		//if (this->anaglyph3d) {
+		//    float rr = (r * 30 + g * 59 + b * 11) / 100;
+		//    float gg = (r * 30 + g * 70) / 100;
+		//    float bb = (r * 30 + b * 70) / 100;
+		//    r = rr;
+		//    g = gg;
+		//    b = bb;
+		//}
 
 		pixels[i * 4 + 0] = r;
 		pixels[i * 4 + 1] = g;
 		pixels[i * 4 + 2] = b;
 		pixels[i * 4 + 3] = a;
 
-    }
+	}
 }

src/client/renderer/ptexture/DynamicTexture.h

@@ -56,6 +56,44 @@ public:
 	void tick();
 };
 
+class LavaTexture: public DynamicTexture
+{
+    typedef DynamicTexture super;
+    int _tick;
+	int _frame;
+
+	float* current;
+	float* next;
+	float* heat;
+	float* heata;
+
+public:
+    LavaTexture();
+	~LavaTexture();
+
+    void tick();
+};
+
+class LavaSideTexture: public DynamicTexture
+{
+	typedef DynamicTexture super;
+	int _tick;
+	int _frame;
+	int _tickCount;
+
+	float* current;
+	float* next;
+	float* heat;
+	float* heata;
+
+public:
+	LavaSideTexture();
+	~LavaSideTexture();
+
+	void tick();
+};
+
+
 class FireTexture: public DynamicTexture
 {
     typedef DynamicTexture super;
@@ -68,7 +106,7 @@ class FireTexture: public DynamicTexture
 	float* heata;
 
 public:
-    FireTexture();
+    FireTexture(int id);
 	~FireTexture();
 
     void tick();

src/client/sound/Sound.cpp

@@ -111,6 +111,7 @@
 #include "data/eat1.pcm"
 #include "data/eat2.pcm"
 #include "data/eat3.pcm"
+#include "data/burp1.pcm"
 #include "data/fuse.pcm"
 
 SoundDesc SA_cloth1((char*)PCM_cloth1);
@@ -221,6 +222,7 @@ SoundDesc SA_creeperdeath((char*)PCM_creeperdeath);
 SoundDesc SA_eat1((char*)PCM_eat1);
 SoundDesc SA_eat2((char*)PCM_eat2);
 SoundDesc SA_eat3((char*)PCM_eat3);
+SoundDesc SA_burp1((char*)PCM_burp1);
 SoundDesc SA_fuse((char*)PCM_fuse);
 
 #endif /*!PRE_ANDROID23 && !__APPLE__*/

src/client/sound/Sound.h

@@ -172,6 +172,7 @@ extern SoundDesc SA_creeperdeath;
 extern SoundDesc SA_eat1;
 extern SoundDesc SA_eat2;
 extern SoundDesc SA_eat3;
+extern SoundDesc SA_burp1;
 extern SoundDesc SA_fuse;
 
 #endif /*!PRE_ANDROID23 && !__APPLE__*/

src/client/sound/SoundEngine.cpp

@@ -144,6 +144,7 @@ void SoundEngine::init( Minecraft* mc, Options* options )
 	sounds.add("random.eat", SA_eat1);
 	sounds.add("random.eat", SA_eat2);
 	sounds.add("random.eat", SA_eat3);
+	sounds.add("random.burp", SA_burp1);
 	sounds.add("random.fuse", SA_fuse);
 
 #endif

src/client/sound/SoundEngine.mm

@@ -227,6 +227,7 @@ void SoundEngine::init( Minecraft* mc, Options* options )
     sounds.add( "random.eat",  _pp("eat1"));
     sounds.add( "random.eat",  _pp("eat2"));
     sounds.add( "random.eat",  _pp("eat3"));
+    sounds.add( "random.burp",  _pp("burp1"));
     sounds.add( "random.fuse", _pp("fuse"));
 
     sounds.add(	"step.cloth", _pp("cloth1"));

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 )
@@ -102,8 +102,8 @@ void Chicken::dropDeathLoot( /*bool wasKilledByPlayer, int playerBonusLevel*/ )
 		spawnAtLocation(Item::feather->id, 1);
 	}
 	//// and some meat
-	//if (isOnFire()) spawnAtLocation(Item::chicken_cooked->id, 1); //@fire
-	//else
+	if (isOnFire()) spawnAtLocation(Item::chicken_cooked->id, 1); //@fire
+	else
 	    spawnAtLocation(Item::chicken_raw->id, 1);
 }
 

src/world/entity/animal/Cow.cpp

@@ -66,11 +66,11 @@ void Cow::dropDeathLoot( /*bool wasKilledByPlayer, int playerBonusLevel*/ ) {
 	// and some meat
 	count = random.nextInt(3) + 1;
 	for (int i = 0; i < count; i++) {
-	//    if (isOnFire()) { //@fire
-	//        spawnAtLocation(Item::beef_cooked->id, 1);
-	//    } else {
+	    if (isOnFire()) { //@fire
+	       spawnAtLocation(Item::beef_cooked->id, 1);
+	    } else {
 	        spawnAtLocation(Item::beef_raw->id, 1);
-	//    }
+	    }
 	}
 }
 

src/world/entity/animal/Pig.cpp

@@ -54,8 +54,8 @@ std::string Pig::getDeathSound()
 int Pig::getDeathLoot()
 {
 	//@fire
-	//if (isOnFire())
-	//	return Item::porkChop_cooked->id;
+	if (isOnFire())
+		return Item::porkChop_cooked->id;
 	return Item::porkChop_raw->id;
 }
 

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;
@@ -143,7 +144,7 @@ void Biome::teardownBiomes() {
 Feature* Biome::getTreeFeature( Random* random )
 {
 	if (random->nextInt(10) == 0) {
-		return new BasicTree(false);
+	//	return new BasicTree(false); // temporarily disabled
 	}
 	return new TreeFeature(false);
 }
@@ -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/biome/ForestBiome.h

@@ -16,7 +16,7 @@ public:
             return new BirchFeature();
         }
         if (random->nextInt(3) == 0) {
-            return new BasicTree(false);
+         //   return new BasicTree(false); // temporarily disabled
         }
         return new TreeFeature(false);
     }

src/world/level/biome/RainforestBiome.h

@@ -13,7 +13,7 @@ class RainforestBiome: public Biome
 public:
     Feature* getTreeFeature(Random* random) {
         if (random->nextInt(3) == 0) {
-            return new BasicTree(false);
+        //    return new BasicTree(false); // temporarily disabled
         }
         return new TreeFeature(false);
     }

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/CanyonFeature.cpp

@@ -138,7 +138,7 @@ void CanyonFeature::addTunnel( int xOffs, int zOffs, unsigned char* blocks, floa
 	}
 }
 
-void CanyonFeature::addFeature(Level* level, int x, int z, int xOffs, int zOffs,unsigned char* blocks)
+void CanyonFeature::addFeature(Level* level, int x, int z, int xOffs, int zOffs, unsigned char* blocks, int blocksSize)
 {
 	if (random.nextInt(15) != 0) return;
 

src/world/level/levelgen/CanyonFeature.h

@@ -11,8 +11,12 @@ class CanyonFeature: public LargeFeature {
 
 	/*protected*/
 	void addTunnel(int xOffs, int zOffs, unsigned char* blocks, float xCave, float yCave, float zCave, float thickness, float yRot, float xRot, int step, int dist, float yScale);
+
     /*protected*/
-	void addFeature(Level* level, int x, int z, int xOffs, int zOffs,unsigned char* blocks);
+	void addFeature(Level* level, int x, int z, int xOffs, int zOffs, unsigned char* blocks, int blocksSize);
+
+
+
 };
 
 

src/world/level/levelgen/RandomLevelSource.h

@@ -25,6 +25,7 @@ class LevelChunk;
 
 #include "../chunk/ChunkSource.h"
 #include "LargeCaveFeature.h"
+#include "CanyonFeature.h"
 #include "synth/PerlinNoise.h"
 #include "../../../SharedConstants.h"
 
@@ -63,6 +64,7 @@ private:
 public:
 	//Biome** biomes;
 	LargeCaveFeature caveFeature;
+	CanyonFeature canyonFeature;
 	int waterDepths[16+16][16+16];
 private:
 	ChunkMap chunkMap;
@@ -92,6 +94,7 @@ private:
 	float* fi;
 	float* fis;
     ///*private*/ float[] temperatures;
+	float* temperatures; // normally unused like above, but restored this maybe might come handy - shredder
 };
 
 class PerformanceTestChunkSource : public ChunkSource

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

@@ -17,7 +17,7 @@ class BasicTree : public Feature
 	typedef Feature super;
 private:
 
-	
+
 
 	unsigned char axisConversionArray[6];
 	Random *rnd;
@@ -25,11 +25,11 @@ private:
 	int origin[3];
 	int height;
 	int trunkHeight;
-	double trunkHeightScale;
-	double branchDensity;
-	double branchSlope;
-	double widthScale;
-	double foliageDensity;
+	float trunkHeightScale;
+	float branchDensity;
+	float branchSlope;
+	float widthScale;
+	float foliageDensity;
 	int trunkWidth;
 	int heightVariance;
 	int foliageHeight;
@@ -38,7 +38,7 @@ private:
 	void prepare(){
 		trunkHeight = (int) (height * trunkHeightScale);
 		if (trunkHeight >= height) trunkHeight = height - 1;
-		int clustersPerY = (int) (1.382 + pow(foliageDensity * height / 13.0, 2));
+		int clustersPerY = (int) (1.382f + pow(foliageDensity * height / 13.0, 2));
 		if (clustersPerY < 1) clustersPerY = 1;
 		int **tempFoliageCoords = new int *[clustersPerY * height];
 		for( int i = 0; i < clustersPerY * height; i++ )
@@ -68,19 +68,19 @@ private:
 				continue;
 			}
 
-			double originOffset = 0.5;
+			float originOffset = 0.5f;
 			while (num < clustersPerY)
 			{
-				double radius = widthScale * (shapefac * (rnd->nextFloat() + 0.328));
-				double angle = rnd->nextFloat() * 2.0 * 3.14159;
+				float radius = widthScale * (shapefac * (rnd->nextFloat() + 0.328f));
+				float angle = rnd->nextFloat() * 2.0f * 3.14159f;
 				int x = Mth::floor(radius * sin(angle) + origin[0] + originOffset);
 				int z = Mth::floor(radius * cos(angle) + origin[2] + originOffset);
 				int checkStart[] = { x, y, z };
 				int checkEnd[] = { x, y + foliageHeight, z };
 				if (checkLine(checkStart, checkEnd) == -1) {
 					int checkBranchBase[] = { origin[0], origin[1], origin[2] };
-					double distance = sqrt(pow(abs(origin[0] - checkStart[0]), 2.0) + pow(abs(origin[2] - checkStart[2]), 2.0));
-					double branchHeight = distance * branchSlope;
+					float distance = sqrt(pow(abs(origin[0] - checkStart[0]), 2.0f) + pow(abs(origin[2] - checkStart[2]), 2.0f));
+					float branchHeight = distance * branchSlope;
 					if ((checkStart[1] - branchHeight) > trunkTop)
 					{
 						checkBranchBase[1] = trunkTop;
@@ -134,7 +134,9 @@ private:
 			offset2 = -rad;
 			while (offset2 <= rad)
 			{
-				double thisdistance = pow(abs(offset1) + 0.5, 2) + pow(abs(offset2) + 0.5, 2);
+				float off1 = (float)offset1 + 0.5f;
+				float off2 = (float)offset2 + 0.5f;
+				float thisdistance = (off1 * off1) + (off2 * off2);
 				if (thisdistance > radius * radius)
 				{
 					offset2++;
@@ -159,14 +161,14 @@ private:
 
 	}
 	float treeShape(int y){
-		if (y < (((float) height) * 0.3)) return (float) -1.618;
-		float radius = ((float) height) / ((float) 2.0);
-		float adjacent = (((float) height) / ((float) 2.0)) - y;
+		if (y < (((float) height) * 0.3f)) return (float) -1.618f;
+		float radius = ((float) height) / ((float) 2.0f);
+		float adjacent = (((float) height) / ((float) 2.0f)) - y;
 		float distance;
 		if (adjacent == 0) distance = radius;
-		else if (abs(adjacent) >= radius) distance = (float) 0.0;
+		else if (abs(adjacent) >= radius) distance = (float) 0.0f;
 		else distance = (float) sqrt(pow(abs(radius), 2) - pow(abs(adjacent), 2));
-		distance *= (float) 0.5;
+		distance *= (float) 0.5f;
 		return distance;
 	}
 	float foliageShape(int y){
@@ -207,8 +209,8 @@ private:
 		char primsign;
 		if (delta[primidx] > 0) primsign = 1;
 		else primsign = -1;
-		double secfac1 = ((double) delta[secidx1]) / ((double) delta[primidx]);
-		double secfac2 = ((double) delta[secidx2]) / ((double) delta[primidx]);
+		float secfac1 = ((float) delta[secidx1]) / ((float) delta[primidx]);
+		float secfac2 = ((float) delta[secidx2]) / ((float) delta[primidx]);
 		int coordinate[] = { 0, 0, 0 };
 		int primoffset = 0;
 		int endoffset = delta[primidx] + primsign;
@@ -312,8 +314,8 @@ private:
 		char primsign; 
 		if (delta[primidx] > 0) primsign = 1;
 		else primsign = -1;
-		double secfac1 = ((double) delta[secidx1]) / ((double) delta[primidx]);
-		double secfac2 = ((double) delta[secidx2]) / ((double) delta[primidx]);
+		float secfac1 = ((float) delta[secidx1]) / ((float) delta[primidx]);
+		float secfac2 = ((float) delta[secidx2]) / ((float) delta[primidx]);
 		int coordinate[] = { 0, 0, 0 };
 		int primoffset = 0;
 		int endoffset = delta[primidx] + primsign;
@@ -331,19 +333,19 @@ private:
 			}
 			primoffset += primsign;
 		}
-	
+
 		if (primoffset == endoffset)
 		{
 			return -1;
 		}
-	
+
 		else
 		{
 			return abs(primoffset);
 		}
 	}
 	bool checkLocation(){
-	
+
 		int startPosition[] = { origin[0], origin[1], origin[2] };
 		int endPosition[] = { origin[0], origin[1] + height - 1, origin[2] };
 
@@ -373,11 +375,11 @@ private:
 public:
 	BasicTree(bool doUpdate){
 		axisConversionArray[0] = 2;
-        axisConversionArray[1] = 0;
-        axisConversionArray[2] = 0;
-        axisConversionArray[3] = 1;
-        axisConversionArray[4] = 2;
-        axisConversionArray[5] = 1;
+		axisConversionArray[1] = 0;
+		axisConversionArray[2] = 0;
+		axisConversionArray[3] = 1;
+		axisConversionArray[4] = 2;
+		axisConversionArray[5] = 1;
 		rnd = new Random();
 		origin[0] = 0;
 		origin[1] = 0;
@@ -405,7 +407,7 @@ public:
 		delete [] foliageCoords;
 	}
 
-	virtual void init(double heightInit, double widthInit, double foliageDensityInit){
+	virtual void init(float heightInit, float widthInit, float foliageDensityInit){
 
 		heightVariance = (int) (heightInit * 12);
 		if (heightInit > 0.5) foliageHeight = 5;
@@ -430,7 +432,7 @@ public:
 			return false;
 		}
 
-	
+
 
 		prepare();
 

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/FireTile.h

@@ -131,6 +131,10 @@ public:
         return false;
     }
 
+		    int getRenderLayer() {
+        return Tile::RENDERLAYER_ALPHATEST;
+    }
+
     bool canBurn(LevelSource* level, int x, int y, int z) {
         return flameOdds[level->getTile(x, y, z)] > 0;
     }

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/Sapling.h

@@ -8,6 +8,7 @@
 #include "../levelgen/feature/SpruceFeature.h"
 #include "../levelgen/feature/BirchFeature.h"
 #include "../levelgen/feature/TreeFeature.h"
+#include "../levelgen/feature/BasicTree.h"
 
 class Sapling: public Bush
 {
@@ -90,9 +91,9 @@ public:
 //                 f = new TreeFeature(true, 4 + random.nextInt(7), TreeTile::JUNGLE_TRUNK, LeafTile::JUNGLE_LEAF, false);
 //             }
         } else {
-            //if (random->nextInt(10) == 0) {
-            //    f = new BasicTree(true);
-            //} else
+            if (random->nextInt(10) == 0) {
+//                f = new BasicTree(true); // temporarily disabled
+            } else
                 f = new TreeFeature(true);
         }
 

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();
 }