.h -> .hpp everything

src/App.cpp

@@ -1,8 +1,8 @@
-#include "App.h"
+#include "App.hpp"
-#include "IPlatform.h"
+#include "IPlatform.hpp"
 
-#include "platform/server/PlatformServer.h"
+#include "platform/server/PlatformServer.hpp"
-#include "platform/glfw/PlatformGlfw.h"
+#include "platform/glfw/PlatformGlfw.hpp"
 
 std::unique_ptr<IPlatform> App::CreatePlatform() {
 #if defined(STANDALONE_SERVER)

src/App.hpp

@@ -8,7 +8,7 @@
 #define NO_EGL
 #endif
 
-#include <IPlatform.h>
+#include <IPlatform.hpp>
 #ifndef NO_EGL 
     #include <EGL/egl.h>
 #endif

src/IPlatform.cpp

@@ -1,5 +1,5 @@
-#include <IPlatform.h>
+#include <IPlatform.hpp>
-#include <App.h>
+#include <App.hpp>
 #include <fstream>
 
 void IPlatform::runMainLoop(App& app) {

src/IPlatform.hpp

@@ -1,81 +1,81 @@
-#pragma once
+#pragma once
-#include <vector>
+#include <vector>
-#include <string>
+#include <string>
-#include "client/renderer/TextureData.h"
+#include "client/renderer/TextureData.hpp"
-#include <cstdint>
+#include <cstdint>
-
+
-typedef std::vector<std::string> StringVector;
+typedef std::vector<std::string> StringVector;
-typedef std::vector<uint8_t> ByteVector; 
+typedef std::vector<uint8_t> ByteVector; 
-
+
-class App;
+class App;
-
+
-class IPlatform {
+class IPlatform {
-public:
+public:
-	IPlatform() : keyboardVisible(false), windowSizeChanged(false), m_targetFrametime(0.f) {}
+	IPlatform() : keyboardVisible(false), windowSizeChanged(false), m_targetFrametime(0.f) {}
-    virtual ~IPlatform() {}
+    virtual ~IPlatform() {}
-
+
-	virtual bool init() { return true; }
+	virtual bool init() { return true; }
-	virtual void swapBuffers() {}
+	virtual void swapBuffers() {}
-
+
-	virtual void runMainLoop(App& app);
+	virtual void runMainLoop(App& app);
-
+
-	virtual ByteVector readAssetFile(const std::string& path);
+	virtual ByteVector readAssetFile(const std::string& path);
-
+
-
+
-	// Mojang functions here
+	// Mojang functions here
-	virtual TextureData loadTexture(const std::string& filename_, bool textureFolder) { return TextureData(); }
+	virtual TextureData loadTexture(const std::string& filename_, bool textureFolder) { return TextureData(); }
-	virtual TextureData loadTextureFromMemory(const unsigned char* data, size_t size) { return TextureData(); }
+	virtual TextureData loadTextureFromMemory(const unsigned char* data, size_t size) { return TextureData(); }
-
+
-    virtual void playSound(const std::string& fn, float volume, float pitch) {}
+    virtual void playSound(const std::string& fn, float volume, float pitch) {}
-	
+	
-	virtual void hideCursor(bool hide) {}
+	virtual void hideCursor(bool hide) {}
-
+
-	virtual std::string getDateString(int s) = 0;
+	virtual std::string getDateString(int s) = 0;
-
+
-	virtual void uploadPlatformDependentData(int id, void* data) {}
+	virtual void uploadPlatformDependentData(int id, void* data) {}
-	// virtual BinaryBlob readAssetFile(const std::string& filename) { return BinaryBlob(); }
+	// virtual BinaryBlob readAssetFile(const std::string& filename) { return BinaryBlob(); }
-	virtual void _tick() {}
+	virtual void _tick() {}
-
+
-	virtual int getScreenWidth() { return 854; }
+	virtual int getScreenWidth() { return 854; }
-	virtual int getScreenHeight() { return 480; }
+	virtual int getScreenHeight() { return 480; }
-    virtual float getPixelsPerMillimeter() { return 10; }
+    virtual float getPixelsPerMillimeter() { return 10; }
-
+
-	virtual bool isNetworkEnabled(bool onlyWifiAllowed) { return true; }
+	virtual bool isNetworkEnabled(bool onlyWifiAllowed) { return true; }
-
+
-	virtual bool isPowerVR() {
+	virtual bool isPowerVR() {
-		return false;
+		return false;
-	}
+	}
-	virtual int getKeyFromKeyCode(int keyCode, int metaState, int deviceId) {return 0;}
+	virtual int getKeyFromKeyCode(int keyCode, int metaState, int deviceId) {return 0;}
-#ifdef __APPLE__
+#ifdef __APPLE__
-    virtual bool isSuperFast() = 0;
+    virtual bool isSuperFast() = 0;
-#endif
+#endif
-
+
-	virtual void openURL(const std::string& url) {}
+	virtual void openURL(const std::string& url) {}
-
+
-	virtual void finish() {}
+	virtual void finish() {}
-	
+	
-	virtual bool supportsTouchscreen() { return false; }
+	virtual bool supportsTouchscreen() { return false; }
-	
+	
-	virtual void vibrate(int milliSeconds) {}
+	virtual void vibrate(int milliSeconds) {}
-
+
-	virtual std::string getPlatformStringVar(int stringId) = 0;
+	virtual std::string getPlatformStringVar(int stringId) = 0;
-
+
-	virtual void showKeyboard() { keyboardVisible = true; }
+	virtual void showKeyboard() { keyboardVisible = true; }
-
+
-	virtual void hideKeyboard() { keyboardVisible = false; }
+	virtual void hideKeyboard() { keyboardVisible = false; }
-
+
-	virtual bool isKeyboardVisible() { return keyboardVisible; }
+	virtual bool isKeyboardVisible() { return keyboardVisible; }
-
+
-	virtual void setTargetFPS(int fps) { m_targetFrametime = 1.0 / fps; }
+	virtual void setTargetFPS(int fps) { m_targetFrametime = 1.0 / fps; }
-
+
-	bool isWindowSizeChanged() { return windowSizeChanged; }
+	bool isWindowSizeChanged() { return windowSizeChanged; }
-
+
-	virtual void setVSync(bool on) { vsync = on; }
+	virtual void setVSync(bool on) { vsync = on; }
-
+
-protected:
+protected:
-	bool keyboardVisible;
+	bool keyboardVisible;
-	bool windowSizeChanged;
+	bool windowSizeChanged;
-	bool vsync;
+	bool vsync;
-
+
-	double m_targetFrametime;
+	double m_targetFrametime;
-};
+};

src/Minecraft.hpp

@@ -1,12 +1,12 @@
 #pragma once
 
-#include "client/Options.h"
+#include "client/Options.hpp"
-#include "client/Timer.h"
+#include "client/Timer.hpp"
 
-//#include "../network/RakNetInstance.h"
+//#include "../network/RakNetInstance.hpp"
-#include "world/phys/HitResult.h"
+#include "world/phys/HitResult.hpp"
 
-#include "App.h"
+#include "App.hpp"
 #include <cstddef>
 
 class Level;

src/MinecraftClient.cpp

@@ -1,36 +1,36 @@
-#include "Minecraft.h"
+#include "Minecraft.hpp"
-#include "client/Options.h"
+#include "client/Options.hpp"
-#include "client/gamemode/GameMode.h"
+#include "client/gamemode/GameMode.hpp"
-#include "client/gui/screens/ChatScreen.h"
+#include "client/gui/screens/ChatScreen.hpp"
-#include "client/gui/screens/ConsoleScreen.h"
+#include "client/gui/screens/ConsoleScreen.hpp"
-#include "client/gui/screens/DeathScreen.h"
+#include "client/gui/screens/DeathScreen.hpp"
-#include "client/gui/screens/UsernameScreen.h"
+#include "client/gui/screens/UsernameScreen.hpp"
-#include "client/player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
-#include "client/player/input/IBuildInput.h"
+#include "client/player/input/IBuildInput.hpp"
-#include "client/player/input/IInputHolder.h"
+#include "client/player/input/IInputHolder.hpp"
-#include "client/player/input/KeyboardInput.h"
+#include "client/player/input/KeyboardInput.hpp"
-#include "client/player/input/MouseBuildInput.h"
+#include "client/player/input/MouseBuildInput.hpp"
-#include "client/player/input/MouseTurnInput.h"
+#include "client/player/input/MouseTurnInput.hpp"
-#include "client/player/input/touchscreen/TouchscreenInput.h"
+#include "client/player/input/touchscreen/TouchscreenInput.hpp"
-#include "client/player/input/touchscreen/TouchInputHolder.h"
+#include "client/player/input/touchscreen/TouchInputHolder.hpp"
-#include "client/renderer/Chunk.h"
+#include "client/renderer/Chunk.hpp"
-#include "client/renderer/EntityTileRenderer.h"
+#include "client/renderer/EntityTileRenderer.hpp"
-#include "client/renderer/ItemInHandRenderer.h"
+#include "client/renderer/ItemInHandRenderer.hpp"
-#include "client/renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "client/renderer/entity/EntityRenderDispatcher.h"
+#include "client/renderer/entity/EntityRenderDispatcher.hpp"
-#include "client/renderer/entity/ItemRenderer.h"
+#include "client/renderer/entity/ItemRenderer.hpp"
-#include "client/renderer/ptexture/DynamicTexture.h"
+#include "client/renderer/ptexture/DynamicTexture.hpp"
-#include "network/RakNetInstance.h"
+#include "network/RakNetInstance.hpp"
-#include "network/ServerSideNetworkHandler.h"
+#include "network/ServerSideNetworkHandler.hpp"
-#include "network/packet/InteractPacket.h"
+#include "network/packet/InteractPacket.hpp"
-#include "network/packet/RespawnPacket.h"
+#include "network/packet/RespawnPacket.hpp"
-#include "platform/CThread.h"
+#include "platform/CThread.hpp"
-#include "platform/input/Multitouch.h"
+#include "platform/input/Multitouch.hpp"
-#include "util/PerfRenderer.h"
+#include "util/PerfRenderer.hpp"
-#include "util/PerfTimer.h"
+#include "util/PerfTimer.hpp"
-#include "world/level/Level.h"
+#include "world/level/Level.hpp"
-#include "world/level/chunk/ChunkSource.h"
+#include "world/level/chunk/ChunkSource.hpp"
-#include <MinecraftClient.h>
+#include <MinecraftClient.hpp>
 
 static void checkGlError(const char* tag) {
 #ifdef GLDEBUG

src/MinecraftClient.hpp

@@ -1,18 +1,18 @@
 #pragma once
-#include "client/gui/Font.h"
+#include "client/gui/Font.hpp"
-#include "client/gui/Screen.h"
+#include "client/gui/Screen.hpp"
-#include "client/particle/ParticleEngine.h"
+#include "client/particle/ParticleEngine.hpp"
-#include "client/player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
-#include "client/renderer/GameRenderer.h"
+#include "client/renderer/GameRenderer.hpp"
-#include "client/renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-#include "client/sound/SoundEngine.h"
+#include "client/sound/SoundEngine.hpp"
-#include <Minecraft.h>
+#include <Minecraft.hpp>
 
-#include <client/MouseHandler.h>
+#include <client/MouseHandler.hpp>
-#include <client/gui/Gui.h>
+#include <client/gui/Gui.hpp>
-#include <client/gui/screens/ScreenChooser.h>
+#include <client/gui/screens/ScreenChooser.hpp>
-#include <client/PixelCalc.h>
+#include <client/PixelCalc.hpp>
-#include <client/renderer/LevelRenderer.h>
+#include <client/renderer/LevelRenderer.hpp>
 
 class MinecraftClient : public Minecraft {
 public:

src/MinecraftServer.cpp

@@ -1,6 +1,6 @@
-#include "MinecraftServer.h"
+#include "MinecraftServer.hpp"
-#include <Minecraft.h>
+#include <Minecraft.hpp>
-#include <network/RakNetInstance.h>
+#include <network/RakNetInstance.hpp>
 
 
 void MinecraftServer::hostMultiplayer(int port) {

src/MinecraftServer.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include <Minecraft.h>
+#include <Minecraft.hpp>
 
 class MinecraftServer : public Minecraft { 
 public:

src/Performance.cpp

@@ -1,4 +1,4 @@
-#include "Performance.h"
+#include "Performance.hpp"
-
+
-/*static*/
+/*static*/
-StopwatchHandler Performance::watches;
+StopwatchHandler Performance::watches;

src/Performance.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "platform/time.h"
+#include "platform/time.hpp"
 
 class Performance
 {

src/SharedConstants.cpp

@@ -1,16 +1,16 @@
-#include "SharedConstants.h"
+#include "SharedConstants.hpp"
-
+
-namespace Common {
+namespace Common {
-
+
-std::string getGameVersionString(const std::string& versionSuffix /* = "" */)
+std::string getGameVersionString(const std::string& versionSuffix /* = "" */)
-{
+{
-	std::string result = std::string("v0.6.1") + versionSuffix;
+	std::string result = std::string("v0.6.1") + versionSuffix;
-	// append 64-bit port marker only on Android 64‑bit targets
+	// append 64-bit port marker only on Android 64‑bit targets
-	#if defined(ANDROID) && (defined(__aarch64__) || defined(__x86_64__))
+	#if defined(ANDROID) && (defined(__aarch64__) || defined(__x86_64__))
-		result += " (64-bit port)";
+		result += " (64-bit port)";
-	#endif
+	#endif
-	result += " alpha";
+	result += " alpha";
-	return result;
+	return result;
-}
+}
-
+
-};
+};

src/client/IConfigListener.cpp

@@ -1,16 +1,16 @@
-#include "IConfigListener.h"
+#include "IConfigListener.hpp"
-#include "Minecraft.h"
+#include "Minecraft.hpp"
-#ifndef STANDALONE_SERVER
+#ifndef STANDALONE_SERVER
-#include "gui/Gui.h"
+#include "gui/Gui.hpp"
-#endif /* STANDALONE_SERVER */
+#endif /* STANDALONE_SERVER */
-Config createConfig(Minecraft* mc) {
+Config createConfig(Minecraft* mc) {
-	Config c;
+	Config c;
-	#ifndef STANDALONE_SERVER
+	#ifndef STANDALONE_SERVER
-	c.setScreenSize(mc->width, mc->height, Gui::GuiScale);
+	c.setScreenSize(mc->width, mc->height, Gui::GuiScale);
-	#endif
+	#endif
-	c.pixelCalc   = mc->pixelCalc;
+	c.pixelCalc   = mc->pixelCalc;
-	c.pixelCalcUi = mc->pixelCalcUi;
+	c.pixelCalcUi = mc->pixelCalcUi;
-	c.minecraft = mc;
+	c.minecraft = mc;
-	c.options   = &mc->options;
+	c.options   = &mc->options;
-	return c;
+	return c;
-}
+}

src/client/IConfigListener.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "PixelCalc.h"
+#include "PixelCalc.hpp"
 class Minecraft;
 class Options;
 

src/client/MouseHandler.cpp

@@ -1,60 +1,60 @@
-#include "MouseHandler.h"
+#include "MouseHandler.hpp"
-#include "player/input/ITurnInput.h"
+#include "player/input/ITurnInput.hpp"
-
+
-#ifdef RPI
+#ifdef RPI
-#include <SDL/SDL.h>
+#include <SDL/SDL.h>
-#endif
+#endif
-
+
-#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
-#include <GLFW/glfw3.h>
+#include <GLFW/glfw3.h>
-#endif
+#endif
-
+
-MouseHandler::MouseHandler( ITurnInput* turnInput )
+MouseHandler::MouseHandler( ITurnInput* turnInput )
-:	_turnInput(turnInput)
+:	_turnInput(turnInput)
-{}
+{}
-
+
-MouseHandler::MouseHandler()
+MouseHandler::MouseHandler()
-:	_turnInput(0)
+:	_turnInput(0)
-{}
+{}
-
+
-MouseHandler::~MouseHandler() {
+MouseHandler::~MouseHandler() {
-}
+}
-
+
-void MouseHandler::setTurnInput( ITurnInput* turnInput ) {
+void MouseHandler::setTurnInput( ITurnInput* turnInput ) {
-	_turnInput = turnInput;
+	_turnInput = turnInput;
-}
+}
-
+
-void MouseHandler::grab() {
+void MouseHandler::grab() {
-	xd = 0;
+	xd = 0;
-	yd = 0;
+	yd = 0;
-
+
-#if defined(RPI)
+#if defined(RPI)
-	//LOGI("Grabbing input!\n");
+	//LOGI("Grabbing input!\n");
-	SDL_WM_GrabInput(SDL_GRAB_ON);
+	SDL_WM_GrabInput(SDL_GRAB_ON);
-	SDL_ShowCursor(0);
+	SDL_ShowCursor(0);
-#endif
+#endif
-
+
-#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
-	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_DISABLED);
-#endif
+#endif
-}
+}
-
+
-void MouseHandler::release() {
+void MouseHandler::release() {
-#if defined(RPI)
+#if defined(RPI)
-	//LOGI("Releasing input!\n");
+	//LOGI("Releasing input!\n");
-	SDL_WM_GrabInput(SDL_GRAB_OFF);
+	SDL_WM_GrabInput(SDL_GRAB_OFF);
-	SDL_ShowCursor(1);
+	SDL_ShowCursor(1);
-#endif
+#endif
-
+
-#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
-	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+	glfwSetInputMode(glfwGetCurrentContext(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
-#endif
+#endif
-}
+}
-
+
-void MouseHandler::poll() {
+void MouseHandler::poll() {
-	if (_turnInput != 0) {
+	if (_turnInput != 0) {
-		TurnDelta td = _turnInput->getTurnDelta();
+		TurnDelta td = _turnInput->getTurnDelta();
-		xd = td.x;
+		xd = td.x;
-		yd = td.y;
+		yd = td.y;
-	}
+	}
-}
+}

src/client/Option.cpp

@@ -1,4 +1,4 @@
-#include "Option.h"
+#include "Option.hpp"
 #include <sstream>
 #include <cstdio>
 

src/client/Option.hpp

@@ -1,7 +1,7 @@
 #pragma once 
 #include <sstream>
 #include <type_traits>
-#include <util/Mth.h>
+#include <util/Mth.hpp>
 /*
 template<typename T>
 struct is_option_type : std::false_type {};

src/client/OptionStrings.cpp

@@ -1,4 +1,4 @@
-#include "OptionStrings.h"
+#include "OptionStrings.hpp"
 
 const char* OptionStrings::Multiplayer_Username        = "mp_username";
 const char* OptionStrings::Multiplayer_ServerVisible   = "mp_server_visible_default";

src/client/Options.cpp

@@ -1,297 +1,297 @@
-#include "Options.h"
+#include "Options.hpp"
-#include "../world/Difficulty.h"
+#include "world/Difficulty.hpp"
-#include <MinecraftClient.h>
+#include <MinecraftClient.hpp>
-
+
-bool Options::debugGl = false;
+bool Options::debugGl = false;
-
+
-// OPTIONS TABLE
+// OPTIONS TABLE
-
+
-OptionInt difficulty("difficulty", Difficulty::NORMAL, 0, Difficulty::COUNT);
+OptionInt difficulty("difficulty", Difficulty::NORMAL, 0, Difficulty::COUNT);
-OptionBool hidegui("hidegui", false);
+OptionBool hidegui("hidegui", false);
-OptionBool thirdPersonView("thirdperson", false);
+OptionBool thirdPersonView("thirdperson", false);
-OptionBool renderDebug("renderDebug", false);
+OptionBool renderDebug("renderDebug", false);
-OptionBool smoothCamera("smoothCamera", false);
+OptionBool smoothCamera("smoothCamera", false);
-OptionBool fixedCamera("fixedCamera", false);
+OptionBool fixedCamera("fixedCamera", false);
-OptionBool isFlying("isflying", false);
+OptionBool isFlying("isflying", false);
-OptionBool barOnTop("barOnTop", false);
+OptionBool barOnTop("barOnTop", false);
-OptionBool allowSprint("allowSprint", true);
+OptionBool allowSprint("allowSprint", true);
-OptionBool rpiCursor("rpiCursor", false);
+OptionBool rpiCursor("rpiCursor", false);
-OptionBool autoJump("autoJump", true);
+OptionBool autoJump("autoJump", true);
-
+
-
+
-OptionFloat flySpeed("flySpeed", 1.f);
+OptionFloat flySpeed("flySpeed", 1.f);
-OptionFloat cameraSpeed("cameraSpeed", 1.f);
+OptionFloat cameraSpeed("cameraSpeed", 1.f);
-
+
-OptionInt guiScale("guiScale", 0, 0, 5);
+OptionInt guiScale("guiScale", 0, 0, 5);
-
+
-OptionString skin("skin", "Default");
+OptionString skin("skin", "Default");
-
+
-#ifdef RPI
+#ifdef RPI
-OptionString username("username", "StevePi");
+OptionString username("username", "StevePi");
-#else 
+#else 
-OptionString username("username", "Steve");
+OptionString username("username", "Steve");
-#endif
+#endif
-
+
-OptionBool destroyVibration("destroyVibration", true);
+OptionBool destroyVibration("destroyVibration", true);
-OptionBool isLeftHanded("isLeftHanded", false);
+OptionBool isLeftHanded("isLeftHanded", false);
-OptionBool isJoyTouchArea("isJoyTouchArea", false);
+OptionBool isJoyTouchArea("isJoyTouchArea", false);
-
+
-OptionFloat musicVolume("music", 1.f, MUSIC_MIN_VALUE, MUSIC_MAX_VALUE);
+OptionFloat musicVolume("music", 1.f, MUSIC_MIN_VALUE, MUSIC_MAX_VALUE);
-OptionFloat soundVolume("sound", 1.f, SOUND_MIN_VALUE, SOUND_MAX_VALUE);
+OptionFloat soundVolume("sound", 1.f, SOUND_MIN_VALUE, SOUND_MAX_VALUE);
-
+
-OptionFloat sensitivityOpt("sensitivity", 0.5f, SENSITIVITY_MIN_VALUE, SENSITIVITY_MAX_VALUE);
+OptionFloat sensitivityOpt("sensitivity", 0.5f, SENSITIVITY_MIN_VALUE, SENSITIVITY_MAX_VALUE);
-
+
-OptionBool invertYMouse("invertMouse", false);
+OptionBool invertYMouse("invertMouse", false);
-OptionInt viewDistance("renderDistance", 2, 0, 4);
+OptionInt viewDistance("renderDistance", 2, 0, 4);
-
+
-OptionBool anaglyph3d("anaglyph3d", false);
+OptionBool anaglyph3d("anaglyph3d", false);
-OptionBool limitFramerate("limitFramerate", false);
+OptionBool limitFramerate("limitFramerate", false);
-OptionBool vsync("vsync", true);
+OptionBool vsync("vsync", true);
-OptionBool fancyGraphics("fancyGraphics", true);
+OptionBool fancyGraphics("fancyGraphics", true);
-OptionBool viewBobbing("viewBobbing", true);
+OptionBool viewBobbing("viewBobbing", true);
-OptionBool ambientOcclusion("ao", false);
+OptionBool ambientOcclusion("ao", false);
-
+
-OptionBool useTouchscreen("useTouchscreen", true);
+OptionBool useTouchscreen("useTouchscreen", true);
-
+
-OptionBool serverVisible("servervisible", true);
+OptionBool serverVisible("servervisible", true);
-
+
-OptionInt keyForward("key.forward", Keyboard::KEY_W);
+OptionInt keyForward("key.forward", Keyboard::KEY_W);
-OptionInt keyLeft("key.left", Keyboard::KEY_A);
+OptionInt keyLeft("key.left", Keyboard::KEY_A);
-OptionInt keyBack("key.back", Keyboard::KEY_S);
+OptionInt keyBack("key.back", Keyboard::KEY_S);
-OptionInt keyRight("key.right", Keyboard::KEY_D);
+OptionInt keyRight("key.right", Keyboard::KEY_D);
-OptionInt keyJump("key.jump", Keyboard::KEY_SPACE);
+OptionInt keyJump("key.jump", Keyboard::KEY_SPACE);
-OptionInt keyInventory("key.inventory", Keyboard::KEY_E);
+OptionInt keyInventory("key.inventory", Keyboard::KEY_E);
-OptionInt keySneak("key.sneak", Keyboard::KEY_LSHIFT);
+OptionInt keySneak("key.sneak", Keyboard::KEY_LSHIFT);
-OptionInt keyDrop("key.drop", Keyboard::KEY_Q);
+OptionInt keyDrop("key.drop", Keyboard::KEY_Q);
-OptionInt keyChat("key.chat", Keyboard::KEY_T);
+OptionInt keyChat("key.chat", Keyboard::KEY_T);
-OptionInt keyFog("key.fog", Keyboard::KEY_F);
+OptionInt keyFog("key.fog", Keyboard::KEY_F);
-OptionInt keyUse("key.use", Keyboard::KEY_U);
+OptionInt keyUse("key.use", Keyboard::KEY_U);
-
+
-// TODO: make human readable keycodes here
+// TODO: make human readable keycodes here
-OptionInt keyMenuNext("key.menu.next", 40);
+OptionInt keyMenuNext("key.menu.next", 40);
-OptionInt keyMenuPrev("key.menu.previous", 38);
+OptionInt keyMenuPrev("key.menu.previous", 38);
-OptionInt keyMenuOk("key.menu.ok", 13);
+OptionInt keyMenuOk("key.menu.ok", 13);
-OptionInt keyMenuCancel("key.menu.cancel", 8);
+OptionInt keyMenuCancel("key.menu.cancel", 8);
-
+
-OptionBool firstLaunch("firstLaunch", true);
+OptionBool firstLaunch("firstLaunch", true);
-
+
-OptionString lastIp("lastip");
+OptionString lastIp("lastip");
-
+
-void Options::initTable() {
+void Options::initTable() {
-    m_options[OPTIONS_DIFFICULTY] = &difficulty;
+    m_options[OPTIONS_DIFFICULTY] = &difficulty;
-    m_options[OPTIONS_HIDEGUI] = &hidegui;
+    m_options[OPTIONS_HIDEGUI] = &hidegui;
-    m_options[OPTIONS_THIRD_PERSON_VIEW] = &thirdPersonView;
+    m_options[OPTIONS_THIRD_PERSON_VIEW] = &thirdPersonView;
-    m_options[OPTIONS_RENDER_DEBUG] = &renderDebug;
+    m_options[OPTIONS_RENDER_DEBUG] = &renderDebug;
-    m_options[OPTIONS_SMOOTH_CAMERA] = &smoothCamera;
+    m_options[OPTIONS_SMOOTH_CAMERA] = &smoothCamera;
-    m_options[OPTIONS_FIXED_CAMERA] = &fixedCamera;
+    m_options[OPTIONS_FIXED_CAMERA] = &fixedCamera;
-	m_options[OPTIONS_IS_FLYING] = &isFlying;
+	m_options[OPTIONS_IS_FLYING] = &isFlying;
-
+
-	m_options[OPTIONS_FLY_SPEED] = &flySpeed;
+	m_options[OPTIONS_FLY_SPEED] = &flySpeed;
-	m_options[OPTIONS_CAMERA_SPEED] = &cameraSpeed;
+	m_options[OPTIONS_CAMERA_SPEED] = &cameraSpeed;
-
+
-	m_options[OPTIONS_GUI_SCALE] = &guiScale;
+	m_options[OPTIONS_GUI_SCALE] = &guiScale;
-
+
-	m_options[OPTIONS_DESTROY_VIBRATION] = &destroyVibration;
+	m_options[OPTIONS_DESTROY_VIBRATION] = &destroyVibration;
-
+
-	m_options[OPTIONS_IS_LEFT_HANDED] = &isLeftHanded;
+	m_options[OPTIONS_IS_LEFT_HANDED] = &isLeftHanded;
-	m_options[OPTIONS_IS_JOY_TOUCH_AREA] = &isJoyTouchArea;
+	m_options[OPTIONS_IS_JOY_TOUCH_AREA] = &isJoyTouchArea;
-
+
-	m_options[OPTIONS_MUSIC_VOLUME] = &musicVolume;
+	m_options[OPTIONS_MUSIC_VOLUME] = &musicVolume;
-	m_options[OPTIONS_SOUND_VOLUME] = &soundVolume;
+	m_options[OPTIONS_SOUND_VOLUME] = &soundVolume;
-
+
-	#if defined(PLATFORM_DESKTOP) || defined(RPI)
+	#if defined(PLATFORM_DESKTOP) || defined(RPI)
-		float sensitivity = sensitivityOpt.get();
+		float sensitivity = sensitivityOpt.get();
-		sensitivity *= 0.4f;
+		sensitivity *= 0.4f;
-		sensitivityOpt.set(sensitivity);
+		sensitivityOpt.set(sensitivity);
-	#endif
+	#endif
-
+
-
+
-    m_options[OPTIONS_GUI_SCALE] = &guiScale;
+    m_options[OPTIONS_GUI_SCALE] = &guiScale;
-
+
-	m_options[OPTIONS_SKIN] = &skin;
+	m_options[OPTIONS_SKIN] = &skin;
-	m_options[OPTIONS_USERNAME] = &username;
+	m_options[OPTIONS_USERNAME] = &username;
-
+
-    m_options[OPTIONS_DESTROY_VIBRATION] = &destroyVibration;
+    m_options[OPTIONS_DESTROY_VIBRATION] = &destroyVibration;
-    m_options[OPTIONS_IS_LEFT_HANDED] = &isLeftHanded;
+    m_options[OPTIONS_IS_LEFT_HANDED] = &isLeftHanded;
-
+
-    m_options[OPTIONS_MUSIC_VOLUME] = &musicVolume;
+    m_options[OPTIONS_MUSIC_VOLUME] = &musicVolume;
-    m_options[OPTIONS_SOUND_VOLUME] = &soundVolume;
+    m_options[OPTIONS_SOUND_VOLUME] = &soundVolume;
-
+
-    m_options[OPTIONS_SENSITIVITY] = &sensitivityOpt;
+    m_options[OPTIONS_SENSITIVITY] = &sensitivityOpt;
-
+
-    m_options[OPTIONS_INVERT_Y_MOUSE] = &invertYMouse;
+    m_options[OPTIONS_INVERT_Y_MOUSE] = &invertYMouse;
-    m_options[OPTIONS_VIEW_DISTANCE] = &viewDistance;
+    m_options[OPTIONS_VIEW_DISTANCE] = &viewDistance;
-
+
-    m_options[OPTIONS_ANAGLYPH_3D] = &anaglyph3d;
+    m_options[OPTIONS_ANAGLYPH_3D] = &anaglyph3d;
-    m_options[OPTIONS_LIMIT_FRAMERATE] = &limitFramerate;
+    m_options[OPTIONS_LIMIT_FRAMERATE] = &limitFramerate;
-    m_options[OPTIONS_VSYNC] = &vsync;
+    m_options[OPTIONS_VSYNC] = &vsync;
-    m_options[OPTIONS_FANCY_GRAPHICS] = &fancyGraphics;
+    m_options[OPTIONS_FANCY_GRAPHICS] = &fancyGraphics;
-	m_options[OPTIONS_VIEW_BOBBING] = &viewBobbing;
+	m_options[OPTIONS_VIEW_BOBBING] = &viewBobbing;
-	m_options[OPTIONS_AMBIENT_OCCLUSION] = &ambientOcclusion;
+	m_options[OPTIONS_AMBIENT_OCCLUSION] = &ambientOcclusion;
-
+
-    m_options[OPTIONS_USE_TOUCHSCREEN] = &useTouchscreen;
+    m_options[OPTIONS_USE_TOUCHSCREEN] = &useTouchscreen;
-
+
-    m_options[OPTIONS_SERVER_VISIBLE] = &serverVisible;
+    m_options[OPTIONS_SERVER_VISIBLE] = &serverVisible;
-
+
-    m_options[OPTIONS_KEY_FORWARD] = &keyForward;
+    m_options[OPTIONS_KEY_FORWARD] = &keyForward;
-    m_options[OPTIONS_KEY_LEFT] = &keyLeft;
+    m_options[OPTIONS_KEY_LEFT] = &keyLeft;
-    m_options[OPTIONS_KEY_BACK] = &keyBack;
+    m_options[OPTIONS_KEY_BACK] = &keyBack;
-    m_options[OPTIONS_KEY_RIGHT] = &keyRight;
+    m_options[OPTIONS_KEY_RIGHT] = &keyRight;
-    m_options[OPTIONS_KEY_JUMP] = &keyJump;
+    m_options[OPTIONS_KEY_JUMP] = &keyJump;
-    m_options[OPTIONS_KEY_INVENTORY] = &keyInventory;
+    m_options[OPTIONS_KEY_INVENTORY] = &keyInventory;
-    m_options[OPTIONS_KEY_SNEAK] = &keySneak;
+    m_options[OPTIONS_KEY_SNEAK] = &keySneak;
-    m_options[OPTIONS_KEY_DROP] = &keyDrop;
+    m_options[OPTIONS_KEY_DROP] = &keyDrop;
-    m_options[OPTIONS_KEY_CHAT] = &keyChat;
+    m_options[OPTIONS_KEY_CHAT] = &keyChat;
-    m_options[OPTIONS_KEY_FOG] = &keyFog;
+    m_options[OPTIONS_KEY_FOG] = &keyFog;
-    m_options[OPTIONS_KEY_USE] = &keyUse;
+    m_options[OPTIONS_KEY_USE] = &keyUse;
-
+
-    m_options[OPTIONS_KEY_MENU_NEXT] = &keyMenuNext;
+    m_options[OPTIONS_KEY_MENU_NEXT] = &keyMenuNext;
-    m_options[OPTIONS_KEY_MENU_PREV] = &keyMenuPrev;
+    m_options[OPTIONS_KEY_MENU_PREV] = &keyMenuPrev;
-    m_options[OPTIONS_KEY_MENU_OK] = &keyMenuOk;
+    m_options[OPTIONS_KEY_MENU_OK] = &keyMenuOk;
-    m_options[OPTIONS_KEY_MENU_CANCEL] = &keyMenuCancel;
+    m_options[OPTIONS_KEY_MENU_CANCEL] = &keyMenuCancel;
-
+
-	m_options[OPTIONS_FIRST_LAUNCH] = &firstLaunch;
+	m_options[OPTIONS_FIRST_LAUNCH] = &firstLaunch;
-
+
-	m_options[OPTIONS_BAR_ON_TOP] = &barOnTop;
+	m_options[OPTIONS_BAR_ON_TOP] = &barOnTop;
-	m_options[OPTIONS_ALLOW_SPRINT] = &allowSprint;
+	m_options[OPTIONS_ALLOW_SPRINT] = &allowSprint;
-	m_options[OPTIONS_RPI_CURSOR] = &rpiCursor;
+	m_options[OPTIONS_RPI_CURSOR] = &rpiCursor;
-
+
-	m_options[OPTIONS_AUTOJUMP] = &autoJump;
+	m_options[OPTIONS_AUTOJUMP] = &autoJump;
-	m_options[OPTIONS_LAST_IP] = &lastIp;
+	m_options[OPTIONS_LAST_IP] = &lastIp;
-}
+}
-
+
-void Options::set(OptionId key, const std::string& value) {
+void Options::set(OptionId key, const std::string& value) {
-	auto option = opt<OptionString>(key);
+	auto option = opt<OptionString>(key);
-
+
-	if (option) {
+	if (option) {
-		option->set(value);
+		option->set(value);
-		notifyOptionUpdate(key, value);
+		notifyOptionUpdate(key, value);
-	}
+	}
-}
+}
-
+
-void Options::set(OptionId key, float value) {
+void Options::set(OptionId key, float value) {
-	auto option = opt<OptionFloat>(key);
+	auto option = opt<OptionFloat>(key);
-
+
-	if (option) {
+	if (option) {
-		option->set(value);
+		option->set(value);
-		notifyOptionUpdate(key, value);
+		notifyOptionUpdate(key, value);
-	}
+	}
-}
+}
-
+
-void Options::set(OptionId key, int value) {
+void Options::set(OptionId key, int value) {
-	auto option = opt<OptionInt>(key);
+	auto option = opt<OptionInt>(key);
-
+
-	if (option) {
+	if (option) {
-		option->set(value);
+		option->set(value);
-		notifyOptionUpdate(key, value);
+		notifyOptionUpdate(key, value);
-	}
+	}
-}
+}
-
+
-void Options::toggle(OptionId key) {
+void Options::toggle(OptionId key) {
-	auto option = opt<OptionBool>(key);
+	auto option = opt<OptionBool>(key);
-
+
-	if (option) {
+	if (option) {
-		option->toggle();
+		option->toggle();
-		notifyOptionUpdate(key, option->get());
+		notifyOptionUpdate(key, option->get());
-	}
+	}
-}
+}
-
+
-void Options::load() {
+void Options::load() {
-	StringVector optionStrings = optionsFile.getOptionStrings();
+	StringVector optionStrings = optionsFile.getOptionStrings();
-
+
-	for (auto i = 0; i < optionStrings.size(); i += 2) {
+	for (auto i = 0; i < optionStrings.size(); i += 2) {
-		const std::string& key = optionStrings[i];
+		const std::string& key = optionStrings[i];
-		const std::string& value = optionStrings[i+1];
+		const std::string& value = optionStrings[i+1];
-
+
-		// FIXME: woah this is so slow 
+		// FIXME: woah this is so slow 
-		auto opt = std::find_if(m_options.begin(), m_options.end(), [&](auto& it) {
+		auto opt = std::find_if(m_options.begin(), m_options.end(), [&](auto& it) {
-			return it != nullptr && it->getStringId() == key;
+			return it != nullptr && it->getStringId() == key;
-		});
+		});
-
+
-		if (opt == m_options.end()) continue;
+		if (opt == m_options.end()) continue;
-
+
-		(*opt)->parse(value);
+		(*opt)->parse(value);
-/*
+/*
-        // //LOGI("reading key: %s (%s)\n", key.c_str(), value.c_str());
+        // //LOGI("reading key: %s (%s)\n", key.c_str(), value.c_str());
-        
+        
-		// // Multiplayer
+		// // Multiplayer
-		// // if (key == OptionStrings::Multiplayer_Username) username = value;
+		// // if (key == OptionStrings::Multiplayer_Username) username = value;
-		// if (key == OptionStrings::Multiplayer_ServerVisible) {
+		// if (key == OptionStrings::Multiplayer_ServerVisible) {
-		// 	m_options[OPTIONS_SERVER_VISIBLE] = readBool(value);
+		// 	m_options[OPTIONS_SERVER_VISIBLE] = readBool(value);
-		// }
+		// }
-
+
-		// // Controls
+		// // Controls
-        // if (key == OptionStrings::Controls_Sensitivity) {
+        // if (key == OptionStrings::Controls_Sensitivity) {
-		// 	float sens = readFloat(value);
+		// 	float sens = readFloat(value);
-
+
-		// 	// sens is in range [0,1] with default/center at 0.5 (for aesthetics)
+		// 	// sens is in range [0,1] with default/center at 0.5 (for aesthetics)
-        //     // We wanna map it to something like [0.3, 0.9] BUT keep 0.5 @ ~0.5...
+        //     // We wanna map it to something like [0.3, 0.9] BUT keep 0.5 @ ~0.5...
-        //     m_options[OPTIONS_SENSITIVITY] = 0.3f + std::pow(1.1f * sens, 1.3f) * 0.42f;
+        //     m_options[OPTIONS_SENSITIVITY] = 0.3f + std::pow(1.1f * sens, 1.3f) * 0.42f;
-        // }
+        // }
-
+
-		// if (key == OptionStrings::Controls_InvertMouse) {
+		// if (key == OptionStrings::Controls_InvertMouse) {
-		// 	m_options[OPTIONS_INVERT_Y_MOUSE] = readBool(value);
+		// 	m_options[OPTIONS_INVERT_Y_MOUSE] = readBool(value);
-		// }
+		// }
-
+
-		// if (key == OptionStrings::Controls_IsLefthanded) {
+		// if (key == OptionStrings::Controls_IsLefthanded) {
-		// 	m_options[OPTIONS_IS_LEFT_HANDED] = readBool(value);
+		// 	m_options[OPTIONS_IS_LEFT_HANDED] = readBool(value);
-		// }
+		// }
-		
+		
-		// if (key == OptionStrings::Controls_UseTouchJoypad) {
+		// if (key == OptionStrings::Controls_UseTouchJoypad) {
-		// 	m_options[OPTIONS_IS_JOY_TOUCH_AREA] = readBool(value) && minecraft->useTouchscreen();
+		// 	m_options[OPTIONS_IS_JOY_TOUCH_AREA] = readBool(value) && minecraft->useTouchscreen();
-		// }
+		// }
-
+
-		// // Feedback
+		// // Feedback
-		// if (key == OptionStrings::Controls_FeedbackVibration) {
+		// if (key == OptionStrings::Controls_FeedbackVibration) {
-		// 	m_options[OPTIONS_DESTROY_VIBRATION] = readBool(value);
+		// 	m_options[OPTIONS_DESTROY_VIBRATION] = readBool(value);
-		// }
+		// }
-
+
-		// // Graphics
+		// // Graphics
-		// if (key == OptionStrings::Graphics_Fancy) {
+		// if (key == OptionStrings::Graphics_Fancy) {
-		// 	m_options[OPTIONS_FANCY_GRAPHICS] = readBool(value);
+		// 	m_options[OPTIONS_FANCY_GRAPHICS] = readBool(value);
-		// }
+		// }
-
+
-		// // Graphics extras
+		// // Graphics extras
-		// if (key == OptionStrings::Graphics_Vsync) {
+		// if (key == OptionStrings::Graphics_Vsync) {
-		// 	m_options[OPTIONS_VSYNC] = readBool(value);
+		// 	m_options[OPTIONS_VSYNC] = readBool(value);
-		// }
+		// }
-
+
-		// if (key == OptionStrings::Graphics_GUIScale) {
+		// if (key == OptionStrings::Graphics_GUIScale) {
-		// 	m_options[OPTIONS_GUI_SCALE] = readInt(value) % 5;
+		// 	m_options[OPTIONS_GUI_SCALE] = readInt(value) % 5;
-		// }
+		// }
-
+
-		// // Game
+		// // Game
-		// if (key == OptionStrings::Game_DifficultyLevel) {
+		// if (key == OptionStrings::Game_DifficultyLevel) {
-		// 	readInt(value, difficulty);
+		// 	readInt(value, difficulty);
-		// 	// Only support peaceful and normal right now
+		// 	// Only support peaceful and normal right now
-		// 	if (difficulty != Difficulty::PEACEFUL && difficulty != Difficulty::NORMAL)
+		// 	if (difficulty != Difficulty::PEACEFUL && difficulty != Difficulty::NORMAL)
-		// 		difficulty = Difficulty::NORMAL;
+		// 		difficulty = Difficulty::NORMAL;
-		// }*/
+		// }*/
-	}
+	}
-}
+}
-
+
-void Options::save() {
+void Options::save() {
-	StringVector stringVec;
+	StringVector stringVec;
-	
+	
-	for (auto& it : m_options) {
+	for (auto& it : m_options) {
-		if (it) stringVec.push_back(it->serialize());
+		if (it) stringVec.push_back(it->serialize());
-	}
+	}
-
+
-	optionsFile.save(stringVec);
+	optionsFile.save(stringVec);
-}
+}
-
+
-void Options::setOptionsFilePath(const std::string& path) {
+void Options::setOptionsFilePath(const std::string& path) {
-	optionsFile.setOptionsPath(path + "/options.txt");
+	optionsFile.setOptionsPath(path + "/options.txt");
-}
+}
-
+
-void Options::notifyOptionUpdate(OptionId key, bool value) {
+void Options::notifyOptionUpdate(OptionId key, bool value) {
-	minecraft.optionUpdated(key, value);
+	minecraft.optionUpdated(key, value);
-}
+}
-
+
-void Options::notifyOptionUpdate(OptionId key, float value) {
+void Options::notifyOptionUpdate(OptionId key, float value) {
-	minecraft.optionUpdated(key, value);
+	minecraft.optionUpdated(key, value);
-}
+}
-
+
-void Options::notifyOptionUpdate(OptionId key, int value) {
+void Options::notifyOptionUpdate(OptionId key, int value) {
-	minecraft.optionUpdated(key, value);
+	minecraft.optionUpdated(key, value);
-}
+}

src/client/Options.hpp

@@ -11,13 +11,13 @@
 
 //package net.minecraft.client;
 
-//#include "locale/Language.h"
+//#include "locale/Language.hpp"
 
 #include <string>
-#include <platform/input/Keyboard.h>
+#include <platform/input/Keyboard.hpp>
-#include <util/StringUtils.h>
+#include <util/StringUtils.hpp>
-#include "OptionsFile.h"
+#include "OptionsFile.hpp"
-#include "Option.h"
+#include "Option.hpp"
 #include <array>
 
 enum OptionId {

src/client/OptionsFile.cpp

@@ -1,98 +1,98 @@
-#include "OptionsFile.h"
+#include "OptionsFile.hpp"
-#include <stdio.h>
+#include <stdio.h>
-#include <string.h>
+#include <string.h>
-#include <errno.h>
+#include <errno.h>
-#include <platform/log.h>
+#include <platform/log.hpp>
-
+
-#if defined(_WIN32)
+#if defined(_WIN32)
-    #include <direct.h>
+    #include <direct.h>
-#else
+#else
-    #include <sys/stat.h>
+    #include <sys/stat.h>
-    #include <sys/types.h>
+    #include <sys/types.h>
-#endif
+#endif
-
+
-OptionsFile::OptionsFile() {
+OptionsFile::OptionsFile() {
-#ifdef __APPLE__
+#ifdef __APPLE__
-	settingsPath = "./Documents/options.txt";
+	settingsPath = "./Documents/options.txt";
-#elif defined(ANDROID)
+#elif defined(ANDROID)
-	settingsPath = "options.txt";
+	settingsPath = "options.txt";
-#elif defined(__EMSCRIPTEN__)
+#elif defined(__EMSCRIPTEN__)
-    settingsPath = "/games/com.mojang/options.txt";
+    settingsPath = "/games/com.mojang/options.txt";
-#else
+#else
-	settingsPath = "options.txt";
+	settingsPath = "options.txt";
-#endif
+#endif
-}
+}
-
+
-void OptionsFile::setOptionsPath(const std::string& path) {
+void OptionsFile::setOptionsPath(const std::string& path) {
-	settingsPath = path;
+	settingsPath = path;
-}
+}
-
+
-std::string OptionsFile::getOptionsPath() const {
+std::string OptionsFile::getOptionsPath() const {
-	return settingsPath;
+	return settingsPath;
-}
+}
-void OptionsFile::save(const StringVector& settings) {
+void OptionsFile::save(const StringVector& settings) {
-    FILE* pFile = fopen(settingsPath.c_str(), "w");
+    FILE* pFile = fopen(settingsPath.c_str(), "w");
-
+
-    if (!pFile && errno == ENOENT) {
+    if (!pFile && errno == ENOENT) {
-        std::string dir = settingsPath;
+        std::string dir = settingsPath;
-        size_t fpos = dir.find_last_of("/\\");
+        size_t fpos = dir.find_last_of("/\\");
-        if (fpos != std::string::npos) {
+        if (fpos != std::string::npos) {
-            dir.resize(fpos);
+            dir.resize(fpos);
-
+
-            std::string toCreate;
+            std::string toCreate;
-            for (size_t i = 0; i <= dir.size(); ++i) {
+            for (size_t i = 0; i <= dir.size(); ++i) {
-                if (i == dir.size() || dir[i] == '/' || dir[i] == '\\') {
+                if (i == dir.size() || dir[i] == '/' || dir[i] == '\\') {
-                    if (!toCreate.empty()) {
+                    if (!toCreate.empty()) {
-#if defined(_WIN32)
+#if defined(_WIN32)
-                        _mkdir(toCreate.c_str());
+                        _mkdir(toCreate.c_str());
-#else
+#else
-                        mkdir(toCreate.c_str(), 0755);
+                        mkdir(toCreate.c_str(), 0755);
-#endif
+#endif
-                    }
+                    }
-                }
+                }
-                if (i < dir.size())
+                if (i < dir.size())
-                    toCreate.push_back(dir[i]);
+                    toCreate.push_back(dir[i]);
-            }
+            }
-        }
+        }
-
+
-        pFile = fopen(settingsPath.c_str(), "w");
+        pFile = fopen(settingsPath.c_str(), "w");
-    }
+    }
-
+
-    if (!pFile) {
+    if (!pFile) {
-        LOGI("OptionsFile::save failed: %s", strerror(errno));
+        LOGI("OptionsFile::save failed: %s", strerror(errno));
-        return;
+        return;
-    }
+    }
-
+
-    for (const auto& s : settings) {
+    for (const auto& s : settings) {
-        fprintf(pFile, "%s\n", s.c_str());
+        fprintf(pFile, "%s\n", s.c_str());
-    }
+    }
-
+
-    fclose(pFile);
+    fclose(pFile);
-}
+}
-
+
-
+
-StringVector OptionsFile::getOptionStrings() {
+StringVector OptionsFile::getOptionStrings() {
-	StringVector returnVector;
+	StringVector returnVector;
-	FILE* pFile = fopen(settingsPath.c_str(), "r");
+	FILE* pFile = fopen(settingsPath.c_str(), "r");
-	if(pFile != NULL) {
+	if(pFile != NULL) {
-		char lineBuff[128];
+		char lineBuff[128];
-		while(fgets(lineBuff, sizeof lineBuff, pFile)) {
+		while(fgets(lineBuff, sizeof lineBuff, pFile)) {
-			// Strip trailing newline
+			// Strip trailing newline
-			size_t len = strlen(lineBuff);
+			size_t len = strlen(lineBuff);
-			while(len > 0 && (lineBuff[len-1] == '\n' || lineBuff[len-1] == '\r'))
+			while(len > 0 && (lineBuff[len-1] == '\n' || lineBuff[len-1] == '\r'))
-				lineBuff[--len] = '\0';
+				lineBuff[--len] = '\0';
-			if(len < 3) continue;
+			if(len < 3) continue;
-			// Split "key:value" into two separate entries to match update() pairing
+			// Split "key:value" into two separate entries to match update() pairing
-			char* colon = strchr(lineBuff, ':');
+			char* colon = strchr(lineBuff, ':');
-			if(colon) {
+			if(colon) {
-				returnVector.push_back(std::string(lineBuff, colon - lineBuff));
+				returnVector.push_back(std::string(lineBuff, colon - lineBuff));
-				returnVector.push_back(std::string(colon + 1));
+				returnVector.push_back(std::string(colon + 1));
-			}
+			}
-		}
+		}
-		fclose(pFile);
+		fclose(pFile);
-	} else {
+	} else {
-		if (errno != ENOENT)
+		if (errno != ENOENT)
-			LOGI("OptionsFile::getOptionStrings failed to open '%s' for reading: %s", settingsPath.c_str(), strerror(errno));
+			LOGI("OptionsFile::getOptionStrings failed to open '%s' for reading: %s", settingsPath.c_str(), strerror(errno));
-	}
+	}
-	return returnVector;
+	return returnVector;
-}
+}

src/client/Timer.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 //package net.minecraft.client;
-#include "../platform/time.h"
+#include "platform/time.hpp"
 
 class Timer
 {

src/client/gui/Font.cpp

@@ -1,372 +1,372 @@
-#include "Font.h"
+#include "Font.hpp"
-
+
-//#include "SharedConstants.h"
+//#include "SharedConstants.hpp"
-#include "../Options.h"
+#include "client/Options.hpp"
-#include "../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-#include "../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../util/Mth.h"
+#include "util/Mth.hpp"
-#include <cstring>
+#include <cstring>
-
+
-Font::Font( Options* options, const std::string& name, Textures* textures )
+Font::Font( Options* options, const std::string& name, Textures* textures )
-:	options(options),
+:	options(options),
-	fontTexture(0),
+	fontTexture(0),
-	fontName(name),
+	fontName(name),
-	index(0),
+	index(0),
-	count(0),
+	count(0),
-	_textures(textures),
+	_textures(textures),
-	_x(0), _y(0),
+	_x(0), _y(0),
-	_cols(16), _rows(16),
+	_cols(16), _rows(16),
-	_charOffset(0),
+	_charOffset(0),
-	lineHeight(DefaultLineHeight)
+	lineHeight(DefaultLineHeight)
-{
+{
-	init(options);
+	init(options);
-}
+}
-
+
-
+
-//Font::Font( Options* options, const std::string& name, Textures* textures, int imgW, int imgH, int x, int y, int cols, int rows, unsigned char charOffset )
+//Font::Font( Options* options, const std::string& name, Textures* textures, int imgW, int imgH, int x, int y, int cols, int rows, unsigned char charOffset )
-//:	options(options),
+//:	options(options),
-//	fontTexture(0),
+//	fontTexture(0),
-//	fontName(name),
+//	fontName(name),
-//	index(0),
+//	index(0),
-//	count(0),
+//	count(0),
-//	_textures(textures),
+//	_textures(textures),
-//	_x(x), _y(y),
+//	_x(x), _y(y),
-//	_cols(cols), _rows(rows),
+//	_cols(cols), _rows(rows),
-//	_charOffset(charOffset)
+//	_charOffset(charOffset)
-//{
+//{
-//	init(options);
+//	init(options);
-//}
+//}
-
+
-void Font::onGraphicsReset()
+void Font::onGraphicsReset()
-{
+{
-	init(options);
+	init(options);
-}
+}
-
+
-void Font::init( Options* options )
+void Font::init( Options* options )
-{
+{
-	TextureId fontTexture = _textures->loadTexture(fontName);
+	TextureId fontTexture = _textures->loadTexture(fontName);
-	const TextureData* tex = _textures->getTemporaryTextureData(fontTexture);
+	const TextureData* tex = _textures->getTemporaryTextureData(fontTexture);
-
+
-	if (!tex)
+	if (!tex)
-		return;
+		return;
-
+
-	unsigned char* rawPixels = tex->data;
+	unsigned char* rawPixels = tex->data;
-
+
-	const int numChars = _rows * _cols;
+	const int numChars = _rows * _cols;
-	for (int i = 0; i < numChars; i++) {
+	for (int i = 0; i < numChars; i++) {
-		int xt = i % _cols;
+		int xt = i % _cols;
-		int yt = i / _cols;
+		int yt = i / _cols;
-
+
-		int x = 7;
+		int x = 7;
-		for (; x >= 0; x--) {
+		for (; x >= 0; x--) {
-			int xPixel = _x + xt * 8 + x;
+			int xPixel = _x + xt * 8 + x;
-			bool emptyColumn = true;
+			bool emptyColumn = true;
-			for (int y = 0; y < 8 && emptyColumn; y++) {
+			for (int y = 0; y < 8 && emptyColumn; y++) {
-				int yPixel = _y + (yt * 8 + y) * tex->w;
+				int yPixel = _y + (yt * 8 + y) * tex->w;
-				unsigned char pixelalpha = rawPixels[(xPixel + yPixel) << 2];
+				unsigned char pixelalpha = rawPixels[(xPixel + yPixel) << 2];
-				if (pixelalpha > 0) emptyColumn = false;
+				if (pixelalpha > 0) emptyColumn = false;
-			}
+			}
-			if (!emptyColumn) {
+			if (!emptyColumn) {
-				break;
+				break;
-			}
+			}
-		}
+		}
-
+
-		if (i == ' ') x = 4 - 2;
+		if (i == ' ') x = 4 - 2;
-		charWidths[i] = x + 2;
+		charWidths[i] = x + 2;
-		fcharWidths[i] = (float) charWidths[i];
+		fcharWidths[i] = (float) charWidths[i];
-	}
+	}
-
+
-#ifdef USE_VBO
+#ifdef USE_VBO
-	return; // this <1
+	return; // this <1
-#endif
+#endif
-
+
-#ifndef USE_VBO
+#ifndef USE_VBO
-	listPos = glGenLists(256 + 32);
+	listPos = glGenLists(256 + 32);
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	for (int i = 0; i < 256; i++) {
+	for (int i = 0; i < 256; i++) {
-		glNewList(listPos + i, GL_COMPILE);
+		glNewList(listPos + i, GL_COMPILE);
-		// @attn @huge @note: This is some dangerous code right here / Aron, added ^1
+		// @attn @huge @note: This is some dangerous code right here / Aron, added ^1
-		t.begin();
+		t.begin();
-		buildChar(i);
+		buildChar(i);
-		t.end(false, -1);
+		t.end(false, -1);
-
+
-		glTranslatef2((GLfloat)charWidths[i], 0.0f, 0.0f);
+		glTranslatef2((GLfloat)charWidths[i], 0.0f, 0.0f);
-		glEndList();
+		glEndList();
-	}
+	}
-
+
-	for (int i = 0; i < 32; i++) {
+	for (int i = 0; i < 32; i++) {
-		int br = ((i >> 3) & 1) * 0x55;
+		int br = ((i >> 3) & 1) * 0x55;
-		int r = ((i >> 2) & 1) * 0xaa + br;
+		int r = ((i >> 2) & 1) * 0xaa + br;
-		int g = ((i >> 1) & 1) * 0xaa + br;
+		int g = ((i >> 1) & 1) * 0xaa + br;
-		int b = ((i >> 0) & 1) * 0xaa + br;
+		int b = ((i >> 0) & 1) * 0xaa + br;
-		if (i == 6) {
+		if (i == 6) {
-			r += 0x55;
+			r += 0x55;
-		}
+		}
-		bool darken = i >= 16;
+		bool darken = i >= 16;
-
+
-		if (options->anaglyph3d) {
+		if (options->anaglyph3d) {
-			int cr = (r * 30 + g * 59 + b * 11) / 100;
+			int cr = (r * 30 + g * 59 + b * 11) / 100;
-			int cg = (r * 30 + g * 70) / (100);
+			int cg = (r * 30 + g * 70) / (100);
-			int cb = (r * 30 + b * 70) / (100);
+			int cb = (r * 30 + b * 70) / (100);
-
+
-			r = cr;
+			r = cr;
-			g = cg;
+			g = cg;
-			b = cb;
+			b = cb;
-		}
+		}
-
+
-		// color = r << 16 | g << 8 | b;
+		// color = r << 16 | g << 8 | b;
-		if (darken) {
+		if (darken) {
-			r /= 4;
+			r /= 4;
-			g /= 4;
+			g /= 4;
-			b /= 4;
+			b /= 4;
-		}
+		}
-
+
-		glNewList(listPos + 256 + i, GL_COMPILE);
+		glNewList(listPos + 256 + i, GL_COMPILE);
-		glColor3f(r / 255.0f, g / 255.0f, b / 255.0f);
+		glColor3f(r / 255.0f, g / 255.0f, b / 255.0f);
-		glEndList();
+		glEndList();
-	}
+	}
-#endif
+#endif
-}
+}
-
+
-void Font::drawShadow( const std::string& str, float x, float y, int color )
+void Font::drawShadow( const std::string& str, float x, float y, int color )
-{
+{
-	draw(str, x + 1, y + 1, color, true);
+	draw(str, x + 1, y + 1, color, true);
-	draw(str, x, y, color);
+	draw(str, x, y, color);
-}
+}
-void Font::drawShadow( const char* str, float x, float y, int color )
+void Font::drawShadow( const char* str, float x, float y, int color )
-{
+{
-	draw(str, x + 1, y + 1, color, true);
+	draw(str, x + 1, y + 1, color, true);
-	draw(str, x, y, color);
+	draw(str, x, y, color);
-}
+}
-
+
-void Font::draw( const std::string& str, float x, float y, int color )
+void Font::draw( const std::string& str, float x, float y, int color )
-{
+{
-	draw(str, x, y, color, false);
+	draw(str, x, y, color, false);
-}
+}
-
+
-void Font::draw( const char* str, float x, float y, int color )
+void Font::draw( const char* str, float x, float y, int color )
-{
+{
-	draw(str, x, y, color, false);
+	draw(str, x, y, color, false);
-}
+}
-
+
-void Font::draw( const char* str, float x, float y, int color, bool darken )
+void Font::draw( const char* str, float x, float y, int color, bool darken )
-{
+{
-#ifdef USE_VBO
+#ifdef USE_VBO
-	drawSlow(str, x, y, color, darken);
+	drawSlow(str, x, y, color, darken);
-#endif
+#endif
-}
+}
-
+
-void Font::draw( const std::string& str, float x, float y, int color, bool darken )
+void Font::draw( const std::string& str, float x, float y, int color, bool darken )
-{
+{
-#ifdef USE_VBO
+#ifdef USE_VBO
-	drawSlow(str, x, y, color, darken);
+	drawSlow(str, x, y, color, darken);
-	return;
+	return;
-#endif
+#endif
-
+
-	if (str.empty()) return;
+	if (str.empty()) return;
-
+
-	if (darken) {
+	if (darken) {
-		int oldAlpha = color & 0xff000000;
+		int oldAlpha = color & 0xff000000;
-		color = (color & 0xfcfcfc) >> 2;
+		color = (color & 0xfcfcfc) >> 2;
-		color += oldAlpha;
+		color += oldAlpha;
-	}
+	}
-
+
-	_textures->loadAndBindTexture(fontName);
+	_textures->loadAndBindTexture(fontName);
-	float r = ((color >> 16) & 0xff) / 255.0f;
+	float r = ((color >> 16) & 0xff) / 255.0f;
-	float g = ((color >> 8) & 0xff) / 255.0f;
+	float g = ((color >> 8) & 0xff) / 255.0f;
-	float b = ((color) & 0xff) / 255.0f;
+	float b = ((color) & 0xff) / 255.0f;
-	float a = ((color >> 24) & 0xff) / 255.0f;
+	float a = ((color >> 24) & 0xff) / 255.0f;
-	if (a == 0) a = 1;
+	if (a == 0) a = 1;
-	glColor4f2(r, g, b, a);
+	glColor4f2(r, g, b, a);
-
+
-	static const std::string hex("0123456789abcdef");
+	static const std::string hex("0123456789abcdef");
-
+
-	index = 0;
+	index = 0;
-	glPushMatrix2();
+	glPushMatrix2();
-	glTranslatef2((GLfloat)x, (GLfloat)y, 0.0f);
+	glTranslatef2((GLfloat)x, (GLfloat)y, 0.0f);
-	for (unsigned int i = 0; i < str.length(); i++) {
+	for (unsigned int i = 0; i < str.length(); i++) {
-		while (str.length() > i + 1 && str[i] == '\xa7') {
+		while (str.length() > i + 1 && str[i] == '\xa7') {
-			int cc = hex.find((char)tolower(str[i + 1]));
+			int cc = hex.find((char)tolower(str[i + 1]));
-			if (cc < 0 || cc > 15) cc = 15;
+			if (cc < 0 || cc > 15) cc = 15;
-			lists[index++] = listPos + 256 + cc + (darken ? 16 : 0);
+			lists[index++] = listPos + 256 + cc + (darken ? 16 : 0);
-
+
-			if (index == 1024) {
+			if (index == 1024) {
-				count = index;
+				count = index;
-				index = 0;
+				index = 0;
-#ifndef USE_VBO
+#ifndef USE_VBO
-				glCallLists(count, GL_UNSIGNED_INT, lists);
+				glCallLists(count, GL_UNSIGNED_INT, lists);
-#endif
+#endif
-				count = 1024;
+				count = 1024;
-			}
+			}
-
+
-			i += 2;
+			i += 2;
-		}
+		}
-
+
-		if (i < str.length()) {
+		if (i < str.length()) {
-			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
+			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
-			char ch = str[i];
+			char ch = str[i];
-			if (ch >= 0) {
+			if (ch >= 0) {
-				//ib.put(listPos + ch + 32);
+				//ib.put(listPos + ch + 32);
-				lists[index++] = listPos + ch;
+				lists[index++] = listPos + ch;
-			}
+			}
-		}
+		}
-
+
-		if (index == 1024) {
+		if (index == 1024) {
-			count = index;
+			count = index;
-			index = 0;
+			index = 0;
-#ifndef USE_VBO
+#ifndef USE_VBO
-			glCallLists(count, GL_UNSIGNED_INT, lists);
+			glCallLists(count, GL_UNSIGNED_INT, lists);
-#endif
+#endif
-			count = 1024;
+			count = 1024;
-		}
+		}
-	}
+	}
-	count = index;
+	count = index;
-	index = 0;
+	index = 0;
-#ifndef USE_VBO
+#ifndef USE_VBO
-	glCallLists(count, GL_UNSIGNED_INT, lists);
+	glCallLists(count, GL_UNSIGNED_INT, lists);
-#endif
+#endif
-	glPopMatrix2();
+	glPopMatrix2();
-}
+}
-
+
-int Font::width( const std::string& str )
+int Font::width( const std::string& str )
-{
+{
-	int maxLen = 0;
+	int maxLen = 0;
-	int len = 0;
+	int len = 0;
-
+
-	for (unsigned int i = 0; i < str.length(); i++) {
+	for (unsigned int i = 0; i < str.length(); i++) {
-		if (str[i] == '\xa7') {
+		if (str[i] == '\xa7') {
-			i++;
+			i++;
-		} else {
+		} else {
-			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
+			//int ch = SharedConstants.acceptableLetters.indexOf(str.charAt(i));
-			//if (ch >= 0) {
+			//if (ch >= 0) {
-			//    len += charWidths[ch + 32];
+			//    len += charWidths[ch + 32];
-			//}
+			//}
-			if (str[i] == '\n') {
+			if (str[i] == '\n') {
-				if (len > maxLen) maxLen = len;
+				if (len > maxLen) maxLen = len;
-				len = 0;
+				len = 0;
-			}
+			}
-			else {
+			else {
-				int charWidth = charWidths[ (unsigned char) str[i] ];
+				int charWidth = charWidths[ (unsigned char) str[i] ];
-				len += charWidth;
+				len += charWidth;
-			}
+			}
-		}
+		}
-	}
+	}
-	return maxLen>len? maxLen : len;
+	return maxLen>len? maxLen : len;
-}
+}
-
+
-int Font::height( const std::string& str ) {
+int Font::height( const std::string& str ) {
-	int h = 0;
+	int h = 0;
-	bool hasLine = false;
+	bool hasLine = false;
-	for (unsigned int i = 0; i < str.length(); ++i) {
+	for (unsigned int i = 0; i < str.length(); ++i) {
-		if (str[i] == '\n') hasLine = true;
+		if (str[i] == '\n') hasLine = true;
-		else {
+		else {
-			if (hasLine) h += lineHeight;
+			if (hasLine) h += lineHeight;
-			hasLine = false;
+			hasLine = false;
-		}
+		}
-	}
+	}
-	return h;
+	return h;
-}
+}
-
+
-std::string Font::sanitize( const std::string& str )
+std::string Font::sanitize( const std::string& str )
-{
+{
-	std::string sanitized(str.length() + 1, 0);
+	std::string sanitized(str.length() + 1, 0);
-	int j = 0;
+	int j = 0;
-
+
-	for (unsigned int i = 0; i < str.length(); i++) {
+	for (unsigned int i = 0; i < str.length(); i++) {
-		if (str[i] == '\xa7') {
+		if (str[i] == '\xa7') {
-			i++;
+			i++;
-			//} else if (SharedConstants.acceptableLetters.indexOf(str.charAt(i)) >= 0) {
+			//} else if (SharedConstants.acceptableLetters.indexOf(str.charAt(i)) >= 0) {
-		} else {
+		} else {
-			sanitized[j++] = str[i];
+			sanitized[j++] = str[i];
-		}
+		}
-	}
+	}
-	return sanitized.erase(j);
+	return sanitized.erase(j);
-}
+}
-
+
-void Font::drawWordWrap( const std::string& str, float x, float y, float w, int col )
+void Font::drawWordWrap( const std::string& str, float x, float y, float w, int col )
-{
+{
-	char* cstr = new char[str.length() + 1];
+	char* cstr = new char[str.length() + 1];
-	strncpy(cstr, str.c_str(), str.length());
+	strncpy(cstr, str.c_str(), str.length());
-	cstr[str.length()] = 0;
+	cstr[str.length()] = 0;
-
+
-	const char* lims = " \n\t\r";
+	const char* lims = " \n\t\r";
-	char* ptok = strtok(cstr, lims);
+	char* ptok = strtok(cstr, lims);
-
+
-	std::vector<std::string> words;
+	std::vector<std::string> words;
-	while (ptok != NULL) {
+	while (ptok != NULL) {
-		words.push_back( ptok );
+		words.push_back( ptok );
-		ptok = strtok(NULL, lims);
+		ptok = strtok(NULL, lims);
-	}
+	}
-
+
-	delete[] cstr;
+	delete[] cstr;
-
+
-	int pos = 0;
+	int pos = 0;
-	while (pos < (int)words.size()) {
+	while (pos < (int)words.size()) {
-		std::string line = words[pos++] + " ";
+		std::string line = words[pos++] + " ";
-		while (pos < (int)words.size() && width(line + words[pos]) < w) {
+		while (pos < (int)words.size() && width(line + words[pos]) < w) {
-			line += words[pos++] + " ";
+			line += words[pos++] + " ";
-		}
+		}
-		drawShadow(line, x, y, col);
+		drawShadow(line, x, y, col);
-		y += lineHeight;
+		y += lineHeight;
-	}
+	}
-}
+}
-
+
-void Font::drawSlow( const std::string& str, float x, float y, int color, bool darken /*= false*/ ) {
+void Font::drawSlow( const std::string& str, float x, float y, int color, bool darken /*= false*/ ) {
-	drawSlow(str.c_str(), x, y, color, darken);
+	drawSlow(str.c_str(), x, y, color, darken);
-}
+}
-void Font::drawSlow( const char* str, float x, float y, int color, bool darken /*= false*/ )
+void Font::drawSlow( const char* str, float x, float y, int color, bool darken /*= false*/ )
-{
+{
-	if (!str) return;
+	if (!str) return;
-
+
-	if (darken) {
+	if (darken) {
-		int oldAlpha = color & 0xff000000;
+		int oldAlpha = color & 0xff000000;
-		color = (color & 0xfcfcfc) >> 2;
+		color = (color & 0xfcfcfc) >> 2;
-		color += oldAlpha;
+		color += oldAlpha;
-	}
+	}
-
+
-	_textures->loadAndBindTexture(fontName);
+	_textures->loadAndBindTexture(fontName);
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	t.begin();
+	t.begin();
-	int alpha = (0xff000000 & color) >> 24;
+	int alpha = (0xff000000 & color) >> 24;
-	if (!alpha) alpha = 0xff;
+	if (!alpha) alpha = 0xff;
-	t.color((color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff, alpha);
+	t.color((color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff, alpha);
-	
+	
-	t.addOffset((float)x, (float)y, 0);
+	t.addOffset((float)x, (float)y, 0);
-	float xOffset = 0;
+	float xOffset = 0;
-	float yOffset = 0;
+	float yOffset = 0;
-
+
-	while (unsigned char ch = *(str++)) {
+	while (unsigned char ch = *(str++)) {
-		if (ch == '\n') {
+		if (ch == '\n') {
-			xOffset = 0;
+			xOffset = 0;
-			yOffset += lineHeight;
+			yOffset += lineHeight;
-		} else {
+		} else {
-			buildChar(ch, xOffset, yOffset);
+			buildChar(ch, xOffset, yOffset);
-			xOffset += fcharWidths[ch];
+			xOffset += fcharWidths[ch];
-		}
+		}
-	}
+	}
-	t.draw();
+	t.draw();
-	t.addOffset(-(float)x, -(float)y, 0);
+	t.addOffset(-(float)x, -(float)y, 0);
-}
+}
-
+
-void Font::buildChar( unsigned char i, float x /*= 0*/, float y /*=0*/ )
+void Font::buildChar( unsigned char i, float x /*= 0*/, float y /*=0*/ )
-{
+{
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-
+
-	//i -= _charOffset;
+	//i -= _charOffset;
-	//int ix = (i % _cols) * 8 + _x;
+	//int ix = (i % _cols) * 8 + _x;
-	//int iy = (i / _cols) * 8 + _y;
+	//int iy = (i / _cols) * 8 + _y;
-	float ix = (float)((i & 15) * 8);
+	float ix = (float)((i & 15) * 8);
-	float iy = (float)((i >> 4) * 8);
+	float iy = (float)((i >> 4) * 8);
-	float s = 7.99f;
+	float s = 7.99f;
-
+
-	float uo = (0.0f) / 128.0f;
+	float uo = (0.0f) / 128.0f;
-	float vo = (0.0f) / 128.0f;
+	float vo = (0.0f) / 128.0f;
-
+
-	t.vertexUV(x, y + s, 0, ix / 128.0f + uo, (iy + s) / 128.0f + vo);
+	t.vertexUV(x, y + s, 0, ix / 128.0f + uo, (iy + s) / 128.0f + vo);
-	t.vertexUV(x + s, y + s, 0, (ix + s) / 128.0f + uo, (iy + s) / 128.0f + vo);
+	t.vertexUV(x + s, y + s, 0, (ix + s) / 128.0f + uo, (iy + s) / 128.0f + vo);
-	t.vertexUV(x + s, y, 0, (ix + s) / 128.0f + uo, iy / 128.0f + vo);
+	t.vertexUV(x + s, y, 0, (ix + s) / 128.0f + uo, iy / 128.0f + vo);
-	t.vertexUV(x, y, 0, ix / 128.0f + uo, iy / 128.0f + vo);
+	t.vertexUV(x, y, 0, ix / 128.0f + uo, iy / 128.0f + vo);
-}
+}
-
+

src/client/gui/Font.hpp

@@ -5,7 +5,7 @@
 #include <string>
 #include <cctype>
 
-#include "../renderer/gles.h"
+#include "client/renderer/gles.hpp"
 
 class Textures;
 class Options;

src/client/gui/Gui.cpp

@@ -1,31 +1,31 @@
-#include "Gui.h"
+#include "Gui.hpp"
-#include "Font.h"
+#include "Font.hpp"
-#include "MinecraftClient.h"
+#include "MinecraftClient.hpp"
-#include "client/Options.h"
+#include "client/Options.hpp"
-#include "platform/input/Keyboard.h"
+#include "platform/input/Keyboard.hpp"
-#include "screens/IngameBlockSelectionScreen.h"
+#include "screens/IngameBlockSelectionScreen.hpp"
-#include "screens/ChatScreen.h"
+#include "screens/ChatScreen.hpp"
-#include "screens/ConsoleScreen.h"
+#include "screens/ConsoleScreen.hpp"
-#include <Minecraft.h>
+#include <Minecraft.hpp>
-#include "../player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
-#include "../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../renderer/TileRenderer.h"
+#include "client/renderer/TileRenderer.hpp"
-#include "../renderer/LevelRenderer.h"
+#include "client/renderer/LevelRenderer.hpp"
-#include "../renderer/GameRenderer.h"
+#include "client/renderer/GameRenderer.hpp"
-#include "../renderer/entity/ItemRenderer.h"
+#include "client/renderer/entity/ItemRenderer.hpp"
-#include "../player/input/IInputHolder.h"
+#include "client/player/input/IInputHolder.hpp"
-#include "../gamemode/GameMode.h"
+#include "client/gamemode/GameMode.hpp"
-#include "../gamemode/CreativeMode.h"
+#include "client/gamemode/CreativeMode.hpp"
-#include "../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-#include "../../AppConstants.h"
+#include "AppConstants.hpp"
-#include "../../world/entity/player/Inventory.h"
+#include "world/entity/player/Inventory.hpp"
-#include "../../world/level/material/Material.h"
+#include "world/level/material/Material.hpp"
-#include "../../world/item/Item.h"
+#include "world/item/Item.hpp"
-#include "../../world/item/ItemInstance.h"
+#include "world/item/ItemInstance.hpp"
-#include "../../platform/input/Mouse.h"
+#include "platform/input/Mouse.hpp"
-#include "../../world/level/Level.h"
+#include "world/level/Level.hpp"
-#include "../../world/PosTranslator.h"
+#include "world/PosTranslator.hpp"
-#include "../../platform/time.h"
+#include "platform/time.hpp"
 #include <cmath>
 #include <algorithm>
 #include <sstream>

src/client/gui/Gui.hpp

@@ -2,12 +2,12 @@
 
 //package net.minecraft.client.gui;
 
-#include "GuiComponent.h"
+#include "GuiComponent.hpp"
-#include "Font.h"
+#include "Font.hpp"
-#include "../player/input/touchscreen/TouchAreaModel.h"
+#include "client/player/input/touchscreen/TouchAreaModel.hpp"
-#include "../renderer/RenderChunk.h"
+#include "client/renderer/RenderChunk.hpp"
-#include "../../util/Random.h"
+#include "util/Random.hpp"
-#include "../IConfigListener.h"
+#include "client/IConfigListener.hpp"
 
 class MinecraftClient;
 class ItemInstance;

src/client/gui/GuiComponent.cpp

@@ -1,156 +1,156 @@
-#include "GuiComponent.h"
+#include "GuiComponent.hpp"
-
+
-#include "../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../renderer/gles.h"
+#include "client/renderer/gles.hpp"
-#include "Font.h"
+#include "Font.hpp"
-
+
-
+
-GuiComponent::GuiComponent()
+GuiComponent::GuiComponent()
-:	blitOffset(0)
+:	blitOffset(0)
-{
+{
-}
+}
-
+
-GuiComponent::~GuiComponent()
+GuiComponent::~GuiComponent()
-{
+{
-}
+}
-
+
-void GuiComponent::drawCenteredString( Font* font, const std::string& str, int x, int y, int color )
+void GuiComponent::drawCenteredString( Font* font, const std::string& str, int x, int y, int color )
-{
+{
-	font->drawShadow(str, (float)(x - font->width(str) / 2), (float)(y - font->height(str) / 2), color);
+	font->drawShadow(str, (float)(x - font->width(str) / 2), (float)(y - font->height(str) / 2), color);
-}
+}
-
+
-void GuiComponent::drawString( Font* font, const std::string& str, int x, int y, int color )
+void GuiComponent::drawString( Font* font, const std::string& str, int x, int y, int color )
-{
+{
-	font->drawShadow(str, (float)x, (float)y /*- font->height(str)/2*/, color);
+	font->drawShadow(str, (float)x, (float)y /*- font->height(str)/2*/, color);
-}
+}
-
+
-void GuiComponent::blit( int x, int y, int sx, int sy, int w, int h, int sw/*=0*/, int sh/*=0*/ )
+void GuiComponent::blit( int x, int y, int sx, int sy, int w, int h, int sw/*=0*/, int sh/*=0*/ )
-{
+{
-	if (!sw) sw = w;
+	if (!sw) sw = w;
-	if (!sh) sh = h;
+	if (!sh) sh = h;
-	float us = 1 / 256.0f;
+	float us = 1 / 256.0f;
-	float vs = 1 / 256.0f;
+	float vs = 1 / 256.0f;
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	t.begin();
+	t.begin();
-	t.vertexUV((float)(x)    , (float)(y + h), blitOffset, (float)(sx    ) * us, (float)(sy + sh) * vs);
+	t.vertexUV((float)(x)    , (float)(y + h), blitOffset, (float)(sx    ) * us, (float)(sy + sh) * vs);
-	t.vertexUV((float)(x + w), (float)(y + h), blitOffset, (float)(sx + sw) * us, (float)(sy + sh) * vs);
+	t.vertexUV((float)(x + w), (float)(y + h), blitOffset, (float)(sx + sw) * us, (float)(sy + sh) * vs);
-	t.vertexUV((float)(x + w), (float)(y)    , blitOffset, (float)(sx + sw) * us, (float)(sy    ) * vs);
+	t.vertexUV((float)(x + w), (float)(y)    , blitOffset, (float)(sx + sw) * us, (float)(sy    ) * vs);
-	t.vertexUV((float)(x)    , (float)(y)    , blitOffset, (float)(sx    ) * us, (float)(sy    ) * vs);
+	t.vertexUV((float)(x)    , (float)(y)    , blitOffset, (float)(sx    ) * us, (float)(sy    ) * vs);
-	t.draw();
+	t.draw();
-}
+}
-void GuiComponent::blit( float x, float y, int sx, int sy, float w, float h, int sw/*=0*/, int sh/*=0*/ )
+void GuiComponent::blit( float x, float y, int sx, int sy, float w, float h, int sw/*=0*/, int sh/*=0*/ )
-{
+{
-	if (!sw) sw = (int)w;
+	if (!sw) sw = (int)w;
-	if (!sh) sh = (int)h;
+	if (!sh) sh = (int)h;
-	float us = 1 / 256.0f;
+	float us = 1 / 256.0f;
-	float vs = 1 / 256.0f;
+	float vs = 1 / 256.0f;
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	t.begin();
+	t.begin();
-	t.vertexUV(x    , y + h, blitOffset, (float)(sx    ) * us, (float)(sy + sh) * vs);
+	t.vertexUV(x    , y + h, blitOffset, (float)(sx    ) * us, (float)(sy + sh) * vs);
-	t.vertexUV(x + w, y + h, blitOffset, (float)(sx + sw) * us, (float)(sy + sh) * vs);
+	t.vertexUV(x + w, y + h, blitOffset, (float)(sx + sw) * us, (float)(sy + sh) * vs);
-	t.vertexUV(x + w, y    , blitOffset, (float)(sx + sw) * us, (float)(sy    ) * vs);
+	t.vertexUV(x + w, y    , blitOffset, (float)(sx + sw) * us, (float)(sy    ) * vs);
-	t.vertexUV(x    , y    , blitOffset, (float)(sx    ) * us, (float)(sy    ) * vs);
+	t.vertexUV(x    , y    , blitOffset, (float)(sx    ) * us, (float)(sy    ) * vs);
-	t.draw();
+	t.draw();
-}
+}
-
+
-void GuiComponent::fill( int x0, int y0, int x1, int y1, int col ) {
+void GuiComponent::fill( int x0, int y0, int x1, int y1, int col ) {
-	fill((float)x0, (float)y0, (float)x1, (float)y1, col);
+	fill((float)x0, (float)y0, (float)x1, (float)y1, col);
-}
+}
-void GuiComponent::fill( float x0, float y0, float x1, float y1, int col )
+void GuiComponent::fill( float x0, float y0, float x1, float y1, int col )
-{
+{
-	//float a = ((col >> 24) & 0xff) / 255.0f;
+	//float a = ((col >> 24) & 0xff) / 255.0f;
-	//float r = ((col >> 16) & 0xff) / 255.0f;
+	//float r = ((col >> 16) & 0xff) / 255.0f;
-	//float g = ((col >> 8) & 0xff) / 255.0f;
+	//float g = ((col >> 8) & 0xff) / 255.0f;
-	//float b = ((col) & 0xff) / 255.0f;
+	//float b = ((col) & 0xff) / 255.0f;
-	//glColor4f2(r, g, b, a);
+	//glColor4f2(r, g, b, a);
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	glEnable2(GL_BLEND);
+	glEnable2(GL_BLEND);
-	glDisable2(GL_TEXTURE_2D);
+	glDisable2(GL_TEXTURE_2D);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	
+	
-	//LOGI("col: %f, %f, %f, %f\n", r, g, b, a);
+	//LOGI("col: %f, %f, %f, %f\n", r, g, b, a);
-	t.begin();
+	t.begin();
-	const int color = (col&0xff00ff00) | ((col&0xff0000) >> 16) | ((col&0xff) << 16);
+	const int color = (col&0xff00ff00) | ((col&0xff0000) >> 16) | ((col&0xff) << 16);
-	t.colorABGR(color);
+	t.colorABGR(color);
-	t.vertex(x0, y1, 0);
+	t.vertex(x0, y1, 0);
-	t.vertex(x1, y1, 0);
+	t.vertex(x1, y1, 0);
-	t.vertex(x1, y0, 0);
+	t.vertex(x1, y0, 0);
-	t.vertex(x0, y0, 0);
+	t.vertex(x0, y0, 0);
-	t.draw();
+	t.draw();
-	glEnable2(GL_TEXTURE_2D);
+	glEnable2(GL_TEXTURE_2D);
-	glDisable2(GL_BLEND);
+	glDisable2(GL_BLEND);
-}
+}
-
+
-void GuiComponent::fillGradient( int x0, int y0, int x1, int y1, int col1, int col2 ) {
+void GuiComponent::fillGradient( int x0, int y0, int x1, int y1, int col1, int col2 ) {
-	fillGradient((float)x0, (float)y0, (float)x1, (float)y1, col1, col2);
+	fillGradient((float)x0, (float)y0, (float)x1, (float)y1, col1, col2);
-}
+}
-void GuiComponent::fillGradient( float x0, float y0, float x1, float y1, int col1, int col2 )
+void GuiComponent::fillGradient( float x0, float y0, float x1, float y1, int col1, int col2 )
-{
+{
-	float a1 = ((col1 >> 24) & 0xff) / 255.0f;
+	float a1 = ((col1 >> 24) & 0xff) / 255.0f;
-	float r1 = ((col1 >> 16) & 0xff) / 255.0f;
+	float r1 = ((col1 >> 16) & 0xff) / 255.0f;
-	float g1 = ((col1 >> 8) & 0xff) / 255.0f;
+	float g1 = ((col1 >> 8) & 0xff) / 255.0f;
-	float b1 = ((col1) & 0xff) / 255.0f;
+	float b1 = ((col1) & 0xff) / 255.0f;
-
+
-	float a2 = ((col2 >> 24) & 0xff) / 255.0f;
+	float a2 = ((col2 >> 24) & 0xff) / 255.0f;
-	float r2 = ((col2 >> 16) & 0xff) / 255.0f;
+	float r2 = ((col2 >> 16) & 0xff) / 255.0f;
-	float g2 = ((col2 >> 8) & 0xff) / 255.0f;
+	float g2 = ((col2 >> 8) & 0xff) / 255.0f;
-	float b2 = ((col2) & 0xff) / 255.0f;
+	float b2 = ((col2) & 0xff) / 255.0f;
-	glDisable2(GL_TEXTURE_2D);
+	glDisable2(GL_TEXTURE_2D);
-	glEnable2(GL_BLEND);
+	glEnable2(GL_BLEND);
-	glDisable2(GL_ALPHA_TEST);
+	glDisable2(GL_ALPHA_TEST);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glShadeModel2(GL_SMOOTH);
+	glShadeModel2(GL_SMOOTH);
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	t.begin();
+	t.begin();
-	t.color(r1, g1, b1, a1);
+	t.color(r1, g1, b1, a1);
-	t.vertex(x1, y0, 0);
+	t.vertex(x1, y0, 0);
-	t.vertex(x0, y0, 0);
+	t.vertex(x0, y0, 0);
-	t.color(r2, g2, b2, a2);
+	t.color(r2, g2, b2, a2);
-	t.vertex(x0, y1, 0);
+	t.vertex(x0, y1, 0);
-	t.vertex(x1, y1, 0);
+	t.vertex(x1, y1, 0);
-	t.draw();
+	t.draw();
-
+
-	glShadeModel2(GL_FLAT);
+	glShadeModel2(GL_FLAT);
-	glDisable2(GL_BLEND);
+	glDisable2(GL_BLEND);
-	glEnable2(GL_ALPHA_TEST);
+	glEnable2(GL_ALPHA_TEST);
-	glEnable2(GL_TEXTURE_2D);
+	glEnable2(GL_TEXTURE_2D);
-}
+}
-void GuiComponent::fillHorizontalGradient( int x0, int y0, int x1, int y1, int col1, int col2 ) {
+void GuiComponent::fillHorizontalGradient( int x0, int y0, int x1, int y1, int col1, int col2 ) {
-	fillHorizontalGradient((float)x0, (float)y0, (float)x1, (float)y1, col1, col2);
+	fillHorizontalGradient((float)x0, (float)y0, (float)x1, (float)y1, col1, col2);
-}
+}
-void GuiComponent::fillHorizontalGradient( float x0, float y0, float x1, float y1, int col1, int col2 )
+void GuiComponent::fillHorizontalGradient( float x0, float y0, float x1, float y1, int col1, int col2 )
-{
+{
-	float a1 = ((col1 >> 24) & 0xff) / 255.0f;
+	float a1 = ((col1 >> 24) & 0xff) / 255.0f;
-	float r1 = ((col1 >> 16) & 0xff) / 255.0f;
+	float r1 = ((col1 >> 16) & 0xff) / 255.0f;
-	float g1 = ((col1 >> 8) & 0xff) / 255.0f;
+	float g1 = ((col1 >> 8) & 0xff) / 255.0f;
-	float b1 = ((col1) & 0xff) / 255.0f;
+	float b1 = ((col1) & 0xff) / 255.0f;
-
+
-	float a2 = ((col2 >> 24) & 0xff) / 255.0f;
+	float a2 = ((col2 >> 24) & 0xff) / 255.0f;
-	float r2 = ((col2 >> 16) & 0xff) / 255.0f;
+	float r2 = ((col2 >> 16) & 0xff) / 255.0f;
-	float g2 = ((col2 >> 8) & 0xff) / 255.0f;
+	float g2 = ((col2 >> 8) & 0xff) / 255.0f;
-	float b2 = ((col2) & 0xff) / 255.0f;
+	float b2 = ((col2) & 0xff) / 255.0f;
-	glDisable2(GL_TEXTURE_2D);
+	glDisable2(GL_TEXTURE_2D);
-	glEnable2(GL_BLEND);
+	glEnable2(GL_BLEND);
-	glDisable2(GL_ALPHA_TEST);
+	glDisable2(GL_ALPHA_TEST);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glShadeModel2(GL_SMOOTH);
+	glShadeModel2(GL_SMOOTH);
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	t.begin();
+	t.begin();
-	t.color(r2, g2, b2, a2);
+	t.color(r2, g2, b2, a2);
-	t.vertex(x1, y0, 0);
+	t.vertex(x1, y0, 0);
-	t.color(r1, g1, b1, a1);
+	t.color(r1, g1, b1, a1);
-	t.vertex(x0, y0, 0);
+	t.vertex(x0, y0, 0);
-	t.color(r1, g1, b1, a1);
+	t.color(r1, g1, b1, a1);
-	t.vertex(x0, y1, 0);
+	t.vertex(x0, y1, 0);
-	t.color(r2, g2, b2, a2);
+	t.color(r2, g2, b2, a2);
-	t.vertex(x1, y1, 0);
+	t.vertex(x1, y1, 0);
-	t.draw();
+	t.draw();
-
+
-	glShadeModel2(GL_FLAT);
+	glShadeModel2(GL_FLAT);
-	glDisable2(GL_BLEND);
+	glDisable2(GL_BLEND);
-	glEnable2(GL_ALPHA_TEST);
+	glEnable2(GL_ALPHA_TEST);
-	glEnable2(GL_TEXTURE_2D);
+	glEnable2(GL_TEXTURE_2D);
-}
+}

src/client/gui/Screen.cpp

@@ -1,291 +1,291 @@
-#include "Screen.h"
+#include "Screen.hpp"
-#include "components/Button.h"
+#include "components/Button.hpp"
-#include "components/TextBox.h"
+#include "components/TextBox.hpp"
-#include <Minecraft.h>
+#include <Minecraft.hpp>
-#include "../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../sound/SoundEngine.h"
+#include "client/sound/SoundEngine.hpp"
-#include "../../platform/input/Keyboard.h"
+#include "platform/input/Keyboard.hpp"
-#include "../../platform/input/Mouse.h"
+#include "platform/input/Mouse.hpp"
-#include "../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-
+
-Screen::Screen()
+Screen::Screen()
-:   passEvents(false),
+:   passEvents(false),
-	clickedButton(NULL),
+	clickedButton(NULL),
-	tabButtonIndex(0),
+	tabButtonIndex(0),
-	width(1),
+	width(1),
-	height(1),
+	height(1),
-	minecraft(NULL),
+	minecraft(NULL),
-	font(NULL)
+	font(NULL)
-{
+{
-}
+}
-
+
-void Screen::render( int xm, int ym, float a )
+void Screen::render( int xm, int ym, float a )
-{
+{
-	for (unsigned int i = 0; i < buttons.size(); i++) {
+	for (unsigned int i = 0; i < buttons.size(); i++) {
-		Button* button = buttons[i];
+		Button* button = buttons[i];
-		button->render(minecraft, xm, ym);
+		button->render(minecraft, xm, ym);
-	}
+	}
-
+
-	// render any text boxes after buttons
+	// render any text boxes after buttons
-	for (unsigned int i = 0; i < textBoxes.size(); i++) {
+	for (unsigned int i = 0; i < textBoxes.size(); i++) {
-		TextBox* textbox = textBoxes[i];
+		TextBox* textbox = textBoxes[i];
-		textbox->render(minecraft, xm, ym);
+		textbox->render(minecraft, xm, ym);
-	}
+	}
-}
+}
-
+
-void Screen::init( Minecraft* minecraft, int width, int height )
+void Screen::init( Minecraft* minecraft, int width, int height )
-{
+{
-	//particles = /*new*/ GuiParticles(minecraft);
+	//particles = /*new*/ GuiParticles(minecraft);
-	this->minecraft = minecraft;
+	this->minecraft = minecraft;
-	this->font = minecraft->font;
+	this->font = minecraft->font;
-	this->width = width;
+	this->width = width;
-	this->height = height;
+	this->height = height;
-	init();
+	init();
-	setupPositions();
+	setupPositions();
-	updateTabButtonSelection();
+	updateTabButtonSelection();
-}
+}
-
+
-void Screen::init()
+void Screen::init()
-{
+{
-}
+}
-
+
-void Screen::setSize( int width, int height )
+void Screen::setSize( int width, int height )
-{
+{
-	this->width = width;
+	this->width = width;
-	this->height = height;
+	this->height = height;
-	setupPositions();
+	setupPositions();
-}
+}
-
+
-bool Screen::handleBackEvent( bool isDown )
+bool Screen::handleBackEvent( bool isDown )
-{
+{
-	return false;
+	return false;
-}
+}
-
+
-void Screen::updateEvents()
+void Screen::updateEvents()
-{
+{
-	if (passEvents)
+	if (passEvents)
-		return;
+		return;
-
+
-	while (Mouse::next())
+	while (Mouse::next())
-		mouseEvent();
+		mouseEvent();
-
+
-	while (Keyboard::next())
+	while (Keyboard::next())
-		keyboardEvent();
+		keyboardEvent();
-	while (Keyboard::nextTextChar())
+	while (Keyboard::nextTextChar())
-		keyboardTextEvent();
+		keyboardTextEvent();
-}
+}
-
+
-void Screen::mouseEvent()
+void Screen::mouseEvent()
-{
+{
-	const MouseAction& e = Mouse::getEvent();
+	const MouseAction& e = Mouse::getEvent();
-	// forward wheel events to subclasses
+	// forward wheel events to subclasses
-	if (e.action == MouseAction::ACTION_WHEEL) {
+	if (e.action == MouseAction::ACTION_WHEEL) {
-		int xm = e.x * width / minecraft->width;
+		int xm = e.x * width / minecraft->width;
-		int ym = e.y * height / minecraft->height - 1;
+		int ym = e.y * height / minecraft->height - 1;
-		mouseWheel(e.dx, e.dy, xm, ym);
+		mouseWheel(e.dx, e.dy, xm, ym);
-		return;
+		return;
-	}
+	}
-
+
-	if (!e.isButton())
+	if (!e.isButton())
-		return;
+		return;
-
+
-	if (Mouse::getEventButtonState()) {
+	if (Mouse::getEventButtonState()) {
-		int xm = e.x * width / minecraft->width;
+		int xm = e.x * width / minecraft->width;
-		int ym = e.y * height / minecraft->height - 1;
+		int ym = e.y * height / minecraft->height - 1;
-		mouseClicked(xm, ym, Mouse::getEventButton());
+		mouseClicked(xm, ym, Mouse::getEventButton());
-	} else {
+	} else {
-		int xm = e.x * width / minecraft->width;
+		int xm = e.x * width / minecraft->width;
-		int ym = e.y * height / minecraft->height - 1;
+		int ym = e.y * height / minecraft->height - 1;
-		mouseReleased(xm, ym, Mouse::getEventButton());
+		mouseReleased(xm, ym, Mouse::getEventButton());
-	}
+	}
-}
+}
-
+
-void Screen::keyboardEvent()
+void Screen::keyboardEvent()
-{
+{
-	if (Keyboard::getEventKeyState()) {
+	if (Keyboard::getEventKeyState()) {
-		//if (Keyboard.getEventKey() == Keyboard.KEY_F11) {
+		//if (Keyboard.getEventKey() == Keyboard.KEY_F11) {
-		//    minecraft->toggleFullScreen();
+		//    minecraft->toggleFullScreen();
-		//    return;
+		//    return;
-		//}
+		//}
-		keyPressed(Keyboard::getEventKey());
+		keyPressed(Keyboard::getEventKey());
-	}
+	}
-}
+}
-void Screen::keyboardTextEvent()
+void Screen::keyboardTextEvent()
-{
+{
-	charPressed(Keyboard::getChar());
+	charPressed(Keyboard::getChar());
-}
+}
-void Screen::renderBackground()
+void Screen::renderBackground()
-{
+{
-	renderBackground(0);
+	renderBackground(0);
-}
+}
-
+
-void Screen::renderBackground( int vo )
+void Screen::renderBackground( int vo )
-{
+{
-	if (minecraft->isLevelGenerated()) {
+	if (minecraft->isLevelGenerated()) {
-		fillGradient(0, 0, width, height, 0xc0101010, 0xd0101010);
+		fillGradient(0, 0, width, height, 0xc0101010, 0xd0101010);
-	} else {
+	} else {
-		renderDirtBackground(vo);
+		renderDirtBackground(vo);
-	}
+	}
-}
+}
-
+
-void Screen::renderDirtBackground( int vo )
+void Screen::renderDirtBackground( int vo )
-{
+{
-	//glDisable2(GL_LIGHTING);
+	//glDisable2(GL_LIGHTING);
-	glDisable2(GL_FOG);
+	glDisable2(GL_FOG);
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	minecraft->textures->loadAndBindTexture("gui/background.png");
+	minecraft->textures->loadAndBindTexture("gui/background.png");
-	glColor4f2(1, 1, 1, 1);
+	glColor4f2(1, 1, 1, 1);
-	float s = 32;
+	float s = 32;
-	float fvo = (float) vo;
+	float fvo = (float) vo;
-	t.begin();
+	t.begin();
-	t.color(0x404040);
+	t.color(0x404040);
-	t.vertexUV(0, (float)height, 0, 0, height / s + fvo);
+	t.vertexUV(0, (float)height, 0, 0, height / s + fvo);
-	t.vertexUV((float)width, (float)height, 0, width / s, (float)height / s + fvo);
+	t.vertexUV((float)width, (float)height, 0, width / s, (float)height / s + fvo);
-	t.vertexUV((float)width, 0, 0, (float)width / s, 0 + fvo);
+	t.vertexUV((float)width, 0, 0, (float)width / s, 0 + fvo);
-	t.vertexUV(0, 0, 0, 0, 0 + fvo);
+	t.vertexUV(0, 0, 0, 0, 0 + fvo);
-	t.draw();
+	t.draw();
-}
+}
-
+
-bool Screen::isPauseScreen()
+bool Screen::isPauseScreen()
-{
+{
-	return true;
+	return true;
-}
+}
-
+
-bool Screen::isErrorScreen()
+bool Screen::isErrorScreen()
-{
+{
-	return false;
+	return false;
-}
+}
-
+
-bool Screen::isInGameScreen()
+bool Screen::isInGameScreen()
-{
+{
-	return true;
+	return true;
-}
+}
-
+
-bool Screen::closeOnPlayerHurt() {
+bool Screen::closeOnPlayerHurt() {
-    return false;
+    return false;
-}
+}
-
+
-void Screen::keyPressed( int eventKey )
+void Screen::keyPressed( int eventKey )
-{
+{
-	if (eventKey == Keyboard::KEY_ESCAPE) {
+	if (eventKey == Keyboard::KEY_ESCAPE) {
-		minecraft->setScreen(NULL);
+		minecraft->setScreen(NULL);
-		//minecraft->grabMouse();
+		//minecraft->grabMouse();
-	}
+	}
-
+
-	// pass key events to any text boxes first
+	// pass key events to any text boxes first
-	for (auto& textbox : textBoxes) {
+	for (auto& textbox : textBoxes) {
-		textbox->keyPressed(minecraft, eventKey);
+		textbox->keyPressed(minecraft, eventKey);
-	}
+	}
-
+
-#ifdef TABBING
+#ifdef TABBING
-	if (minecraft->useTouchscreen())
+	if (minecraft->useTouchscreen())
-		return;
+		return;
-
+
-
+
-	// "Tabbing" the buttons (walking with keys)
+	// "Tabbing" the buttons (walking with keys)
-	const int tabButtonCount = tabButtons.size();
+	const int tabButtonCount = tabButtons.size();
-	if (!tabButtonCount)
+	if (!tabButtonCount)
-		return;
+		return;
-
+
-	Options& o = minecraft->options;
+	Options& o = minecraft->options;
-	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_NEXT))
+	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_NEXT))
-		if (++tabButtonIndex == tabButtonCount) tabButtonIndex = 0;
+		if (++tabButtonIndex == tabButtonCount) tabButtonIndex = 0;
-	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_PREV))
+	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_PREV))
-		if (--tabButtonIndex == -1) tabButtonIndex = tabButtonCount-1;
+		if (--tabButtonIndex == -1) tabButtonIndex = tabButtonCount-1;
-	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_OK)) {
+	if (eventKey == o.getIntValue(OPTIONS_KEY_MENU_OK)) {
-		Button* button = tabButtons[tabButtonIndex];
+		Button* button = tabButtons[tabButtonIndex];
-		if (button->active) {
+		if (button->active) {
-			minecraft->soundEngine->playUI("random.click", 1, 1);
+			minecraft->soundEngine->playUI("random.click", 1, 1);
-			buttonClicked(button);
+			buttonClicked(button);
-		}
+		}
-	}
+	}
-
+
-	updateTabButtonSelection();
+	updateTabButtonSelection();
-#endif
+#endif
-}
+}
-
+
-void Screen::charPressed(char inputChar) {
+void Screen::charPressed(char inputChar) {
-	for (auto& textbox : textBoxes) {
+	for (auto& textbox : textBoxes) {
-		textbox->charPressed(minecraft, inputChar);
+		textbox->charPressed(minecraft, inputChar);
-	}
+	}
-}
+}
-
+
-void Screen::updateTabButtonSelection()
+void Screen::updateTabButtonSelection()
-{
+{
-#ifdef TABBING
+#ifdef TABBING
-	if (minecraft->useTouchscreen())
+	if (minecraft->useTouchscreen())
-		return;
+		return;
-
+
-	for (unsigned int i = 0; i < tabButtons.size(); ++i)
+	for (unsigned int i = 0; i < tabButtons.size(); ++i)
-		tabButtons[i]->selected = (i == tabButtonIndex);
+		tabButtons[i]->selected = (i == tabButtonIndex);
-#endif
+#endif
-}
+}
-
+
-void Screen::mouseClicked( int x, int y, int buttonNum )
+void Screen::mouseClicked( int x, int y, int buttonNum )
-{
+{
-	if (buttonNum == MouseAction::ACTION_LEFT) {
+	if (buttonNum == MouseAction::ACTION_LEFT) {
-		for (unsigned int i = 0; i < buttons.size(); ++i) {
+		for (unsigned int i = 0; i < buttons.size(); ++i) {
-			Button* button = buttons[i];
+			Button* button = buttons[i];
-            //LOGI("Hit-testing button: %p\n", button);
+            //LOGI("Hit-testing button: %p\n", button);
-			if (button->clicked(minecraft, x, y)) {
+			if (button->clicked(minecraft, x, y)) {
-                button->setPressed();
+                button->setPressed();
-
+
-                //LOGI("Hit-test successful: %p\n", button);
+                //LOGI("Hit-test successful: %p\n", button);
-				clickedButton = button;
+				clickedButton = button;
-/*
+/*
-#if !defined(ANDROID) && !defined(__APPLE__) //if (!minecraft->isTouchscreen()) {
+#if !defined(ANDROID) && !defined(__APPLE__) //if (!minecraft->isTouchscreen()) {
-					minecraft->soundEngine->playUI("random.click", 1, 1);
+					minecraft->soundEngine->playUI("random.click", 1, 1);
-					buttonClicked(button);
+					buttonClicked(button);
-#endif }
+#endif }
-*/
+*/
-			}
+			}
-		}
+		}
-	}
+	}
-
+
-	// let textboxes see the click regardless
+	// let textboxes see the click regardless
-	for (auto& textbox : textBoxes) {
+	for (auto& textbox : textBoxes) {
-		textbox->mouseClicked(minecraft, x, y, buttonNum);
+		textbox->mouseClicked(minecraft, x, y, buttonNum);
-	}
+	}
-}
+}
-
+
-void Screen::mouseReleased( int x, int y, int buttonNum )
+void Screen::mouseReleased( int x, int y, int buttonNum )
-{
+{
-	//LOGI("b_id: %d, (%p), text: %s\n", buttonNum, clickedButton, clickedButton?clickedButton->msg.c_str():"<null>");
+	//LOGI("b_id: %d, (%p), text: %s\n", buttonNum, clickedButton, clickedButton?clickedButton->msg.c_str():"<null>");
-	if (!clickedButton || buttonNum != MouseAction::ACTION_LEFT) return;
+	if (!clickedButton || buttonNum != MouseAction::ACTION_LEFT) return;
-
+
-#if 1
+#if 1
-//#if defined(ANDROID) || defined(__APPLE__) //if (minecraft->isTouchscreen()) {
+//#if defined(ANDROID) || defined(__APPLE__) //if (minecraft->isTouchscreen()) {
-		for (unsigned int i = 0; i < buttons.size(); ++i) {
+		for (unsigned int i = 0; i < buttons.size(); ++i) {
-			Button* button = buttons[i];
+			Button* button = buttons[i];
-			if (clickedButton == button && button->clicked(minecraft, x, y)) {
+			if (clickedButton == button && button->clicked(minecraft, x, y)) {
-				buttonClicked(button);
+				buttonClicked(button);
-				minecraft->soundEngine->playUI("random.click", 1, 1);
+				minecraft->soundEngine->playUI("random.click", 1, 1);
-				clickedButton->released(x, y);
+				clickedButton->released(x, y);
-			}
+			}
-		}
+		}
-# else //	} else {
+# else //	} else {
-		clickedButton->released(x, y);
+		clickedButton->released(x, y);
-#endif // }
+#endif // }
-	clickedButton = NULL;
+	clickedButton = NULL;
-}
+}
-
+
-bool Screen::renderGameBehind() {
+bool Screen::renderGameBehind() {
-	return true;
+	return true;
-}
+}
-
+
-bool Screen::hasClippingArea( IntRectangle& out )
+bool Screen::hasClippingArea( IntRectangle& out )
-{
+{
-	return false;
+	return false;
-}
+}
-
+
-void Screen::lostFocus() {
+void Screen::lostFocus() {
-	for(std::vector<TextBox*>::iterator it = textBoxes.begin(); it != textBoxes.end(); ++it) {
+	for(std::vector<TextBox*>::iterator it = textBoxes.begin(); it != textBoxes.end(); ++it) {
-		TextBox* tb = *it;
+		TextBox* tb = *it;
-		tb->loseFocus(minecraft);
+		tb->loseFocus(minecraft);
-	}
+	}
-}
+}
-
+
-void Screen::toGUICoordinate( int& x, int& y ) {
+void Screen::toGUICoordinate( int& x, int& y ) {
-	x = x * width / minecraft->width;
+	x = x * width / minecraft->width;
-	y = y * height / minecraft->height - 1;
+	y = y * height / minecraft->height - 1;
-}
+}

src/client/gui/Screen.hpp

@@ -3,7 +3,7 @@
 //package net.minecraft.client.gui;
 
 #include <vector>
-#include "GuiComponent.h"
+#include "GuiComponent.hpp"
 
 class Font;
 class Minecraft;

src/client/gui/components/Button.cpp

@@ -1,219 +1,219 @@
-#include "Button.h"
+#include "Button.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-
+
-Button::Button(int id, const std::string& msg)
+Button::Button(int id, const std::string& msg)
-:	GuiElement(true, true, 0, 0, 200, 24),
+:	GuiElement(true, true, 0, 0, 200, 24),
-    id(id),
+    id(id),
-	msg(msg),
+	msg(msg),
-	selected(false),
+	selected(false),
-    _currentlyDown(false)
+    _currentlyDown(false)
-{
+{
-}
+}
-
+
-Button::Button( int id, int x, int y, const std::string& msg )
+Button::Button( int id, int x, int y, const std::string& msg )
-:	GuiElement(true, true, x, y, 200, 24),
+:	GuiElement(true, true, x, y, 200, 24),
-    id(id),
+    id(id),
-	msg(msg),
+	msg(msg),
-	selected(false),
+	selected(false),
-    _currentlyDown(false)
+    _currentlyDown(false)
-{
+{
-}
+}
-
+
-Button::Button( int id, int x, int y, int w, int h, const std::string& msg )
+Button::Button( int id, int x, int y, int w, int h, const std::string& msg )
-:	GuiElement(true, true, x, y, w, h),
+:	GuiElement(true, true, x, y, w, h),
-    id(id),
+    id(id),
-	msg(msg),
+	msg(msg),
-	selected(false),
+	selected(false),
-    _currentlyDown(false)
+    _currentlyDown(false)
-{
+{
-}
+}
-
+
-void Button::render( Minecraft* minecraft, int xm, int ym )
+void Button::render( Minecraft* minecraft, int xm, int ym )
-{
+{
-	if (!visible) return;
+	if (!visible) return;
-
+
-	/*
+	/*
-	minecraft->textures->loadAndBindTexture("gui/gui.png");
+	minecraft->textures->loadAndBindTexture("gui/gui.png");
-	glColor4f2(1, 1, 1, 1);
+	glColor4f2(1, 1, 1, 1);
-
+
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	int yImage = getYImage(hovered || selected);
+	int yImage = getYImage(hovered || selected);
-
+
-	blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
+	blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
-	blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
+	blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
-	*/
+	*/
-
+
-	renderBg(minecraft, xm, ym);
+	renderBg(minecraft, xm, ym);
-	renderFace(minecraft, xm , ym);
+	renderFace(minecraft, xm , ym);
-}
+}
-
+
-void Button::released( int mx, int my ) {
+void Button::released( int mx, int my ) {
-    _currentlyDown = false;
+    _currentlyDown = false;
-}
+}
-
+
-bool Button::clicked( Minecraft* minecraft, int mx, int my )
+bool Button::clicked( Minecraft* minecraft, int mx, int my )
-{
+{
-	return active && mx >= x && my >= y && mx < x + width && my < y + height;
+	return active && mx >= x && my >= y && mx < x + width && my < y + height;
-}
+}
-
+
-void Button::setPressed() {
+void Button::setPressed() {
-    _currentlyDown = true;
+    _currentlyDown = true;
-}
+}
-
+
-int Button::getYImage( bool hovered )
+int Button::getYImage( bool hovered )
-{
+{
-	int res = 1;
+	int res = 1;
-	if (!active) res = 0;
+	if (!active) res = 0;
-	else if (hovered) res = 2;
+	else if (hovered) res = 2;
-	return res;
+	return res;
-}
+}
-
+
-void Button::renderFace(Minecraft* mc, int xm, int ym) {
+void Button::renderFace(Minecraft* mc, int xm, int ym) {
-	Font* font = mc->font;
+	Font* font = mc->font;
-	if (!active) {
+	if (!active) {
-		drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xffa0a0a0);
+		drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xffa0a0a0);
-	} else {
+	} else {
-		if (hovered(mc, xm, ym) || selected) {
+		if (hovered(mc, xm, ym) || selected) {
-			drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xffffa0);
+			drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xffffa0);
-		} else {
+		} else {
-			drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xe0e0e0);
+			drawCenteredString(font, msg, x + width / 2, y + (height - 8) / 2, 0xe0e0e0);
-		}
+		}
-	}
+	}
-}
+}
-
+
-void Button::renderBg( Minecraft* minecraft, int xm, int ym )
+void Button::renderBg( Minecraft* minecraft, int xm, int ym )
-{
+{
-	minecraft->textures->loadAndBindTexture("gui/gui.png");
+	minecraft->textures->loadAndBindTexture("gui/gui.png");
-	glColor4f2(1, 1, 1, 1);
+	glColor4f2(1, 1, 1, 1);
-
+
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	int yImage = getYImage(selected || hovered(minecraft, xm, ym));;
+	int yImage = getYImage(selected || hovered(minecraft, xm, ym));;
-
+
-	blit(x, y, 0, 46 + yImage * 20, width / 2, height, 0, 20);
+	blit(x, y, 0, 46 + yImage * 20, width / 2, height, 0, 20);
-	blit(x + width / 2, y, 200 - width / 2, 46 + yImage * 20, width / 2, height, 0, 20);
+	blit(x + width / 2, y, 200 - width / 2, 46 + yImage * 20, width / 2, height, 0, 20);
-}
+}
-
+
-bool Button::hovered(Minecraft* minecraft, int xm , int ym) {
+bool Button::hovered(Minecraft* minecraft, int xm , int ym) {
-	return minecraft->useTouchscreen()? (_currentlyDown && isInside(xm, ym)) : isInside(xm, ym);
+	return minecraft->useTouchscreen()? (_currentlyDown && isInside(xm, ym)) : isInside(xm, ym);
-}
+}
-
+
-bool Button::isInside( int xm, int ym ) {
+bool Button::isInside( int xm, int ym ) {
-	return xm >= x && ym >= y && xm < x + width && ym < y + height;
+	return xm >= x && ym >= y && xm < x + width && ym < y + height;
-}
+}
-
+
-//
+//
-// BlankButton
+// BlankButton
-//
+//
-BlankButton::BlankButton(int id)
+BlankButton::BlankButton(int id)
-:	super(id, "")
+:	super(id, "")
-{
+{
-	visible = false;
+	visible = false;
-}
+}
-
+
-BlankButton::BlankButton(int id, int x, int y, int w, int h)
+BlankButton::BlankButton(int id, int x, int y, int w, int h)
-:	super(id, x, y, w, h, "")
+:	super(id, x, y, w, h, "")
-{
+{
-	visible = false;
+	visible = false;
-}
+}
-
+
-//
+//
-// The Touch-interface button
+// The Touch-interface button
-//
+//
-namespace Touch {
+namespace Touch {
-
+
-TButton::TButton(int id, const std::string& msg)
+TButton::TButton(int id, const std::string& msg)
-:	super(id, msg)
+:	super(id, msg)
-{
+{
-	width = 66;
+	width = 66;
-	height = 26;
+	height = 26;
-}
+}
-
+
-TButton::TButton( int id, int x, int y, const std::string& msg )
+TButton::TButton( int id, int x, int y, const std::string& msg )
-:	super(id, x, y, msg)
+:	super(id, x, y, msg)
-{
+{
-	width = 66;
+	width = 66;
-	height = 26;
+	height = 26;
-}
+}
-
+
-TButton::TButton( int id, int x, int y, int w, int h, const std::string& msg )
+TButton::TButton( int id, int x, int y, int w, int h, const std::string& msg )
-:	super(id, x, y, w, h, msg)
+:	super(id, x, y, w, h, msg)
-{
+{
-}
+}
-
+
-void TButton::renderBg( Minecraft* minecraft, int xm, int ym )
+void TButton::renderBg( Minecraft* minecraft, int xm, int ym )
-{
+{
-	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : isInside(xm, ym));
+	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : isInside(xm, ym));
-	// bool hovered = active && (_currentlyDown && isInside(xm, ym));
+	// bool hovered = active && (_currentlyDown && isInside(xm, ym));
-
+
-	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
+	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
-
+
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	if (active)
+	if (active)
-		glColor4f2(1, 1, 1, 1);
+		glColor4f2(1, 1, 1, 1);
-	else
+	else
-		glColor4f2(0.5f, 0.5f, 0.5f, 1);
+		glColor4f2(0.5f, 0.5f, 0.5f, 1);
-
+
-	blit(x, y, hovered?66:0, 0, width, height, 66, 26);
+	blit(x, y, hovered?66:0, 0, width, height, 66, 26);
-	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
+	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
-}
+}
-
+
-
+
-//
+//
-// Header spacing in Touchscreen mode
+// Header spacing in Touchscreen mode
-//
+//
-THeader::THeader(int id, const std::string& msg)
+THeader::THeader(int id, const std::string& msg)
-:	super(id, msg),
+:	super(id, msg),
-	xText(-99999)
+	xText(-99999)
-{
+{
-	active = false;
+	active = false;
-	width = 66;
+	width = 66;
-	height = 26;
+	height = 26;
-}
+}
-
+
-THeader::THeader( int id, int x, int y, const std::string& msg )
+THeader::THeader( int id, int x, int y, const std::string& msg )
-:	super(id, x, y, msg),
+:	super(id, x, y, msg),
-	xText(-99999)
+	xText(-99999)
-{
+{
-	active = false;
+	active = false;
-	width = 66;
+	width = 66;
-	height = 26;
+	height = 26;
-}
+}
-
+
-THeader::THeader( int id, int x, int y, int w, int h, const std::string& msg )
+THeader::THeader( int id, int x, int y, int w, int h, const std::string& msg )
-:	super(id, x, y, w, h, msg),
+:	super(id, x, y, w, h, msg),
-	xText(-99999)
+	xText(-99999)
-{
+{
-	active = false;
+	active = false;
-}
+}
-
+
-void THeader::render( Minecraft* minecraft, int xm, int ym ) {
+void THeader::render( Minecraft* minecraft, int xm, int ym ) {
-	Font* font = minecraft->font;
+	Font* font = minecraft->font;
-	renderBg(minecraft, xm, ym);
+	renderBg(minecraft, xm, ym);
-	
+	
-	int xx = x + width/2;
+	int xx = x + width/2;
-	if (xText != -99999)
+	if (xText != -99999)
-		xx = xText;
+		xx = xText;
-	drawCenteredString(font, msg, xx, y + (height - 8) / 2, 0xe0e0e0);
+	drawCenteredString(font, msg, xx, y + (height - 8) / 2, 0xe0e0e0);
-}
+}
-
+
-void THeader::renderBg( Minecraft* minecraft, int xm, int ym )
+void THeader::renderBg( Minecraft* minecraft, int xm, int ym )
-{
+{
-	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
+	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
-
+
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	glColor4f2(1, 1, 1, 1);
+	glColor4f2(1, 1, 1, 1);
-
+
-	// Left cap
+	// Left cap
-	blit(x, y, 150, 26, 2, height-1, 2, 25);
+	blit(x, y, 150, 26, 2, height-1, 2, 25);
-	// Middle
+	// Middle
-	blit(x+2, y, 153, 26, width-3, height-1, 8, 25);
+	blit(x+2, y, 153, 26, width-3, height-1, 8, 25);
-	// Right cap
+	// Right cap
-	blit(x+width-2, y, 162, 26, 2, height-1, 2, 25);
+	blit(x+width-2, y, 162, 26, 2, height-1, 2, 25);
-	// Shadow
+	// Shadow
-	glEnable2(GL_BLEND);
+	glEnable2(GL_BLEND);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	blit(x, y+height-1, 153, 52, width, 3, 8, 3);
+	blit(x, y+height-1, 153, 52, width, 3, 8, 3);
-}
+}
-
+
-};
+};

src/client/gui/components/Button.hpp

@@ -3,8 +3,8 @@
 //package net.minecraft.client.gui;
 
 #include <string>
-#include "GuiElement.h"
+#include "GuiElement.hpp"
-#include "../../Options.h"
+#include "client/Options.hpp"
 
 class Font;
 class Minecraft;

src/client/gui/components/GButton.cpp

@@ -1 +1 @@
-#include "GuiElement.h"
+#include "GuiElement.hpp"

src/client/gui/components/GButton.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include "Button.h"
+#include "Button.hpp"
 
 class GButton: public Button {
 	typedef Button super;

src/client/gui/components/GuiElement.cpp

@@ -1,20 +1,20 @@
-#include "GuiElement.h"
+#include "GuiElement.hpp"
-
+
-GuiElement::GuiElement( bool active/*=false*/, bool visible/*=true*/, int x /*= 0*/, int y /*= 0*/, int width/*=24*/, int height/*=24*/ )
+GuiElement::GuiElement( bool active/*=false*/, bool visible/*=true*/, int x /*= 0*/, int y /*= 0*/, int width/*=24*/, int height/*=24*/ )
-: active(active),
+: active(active),
-  visible(visible),
+  visible(visible),
-  x(x),
+  x(x),
-  y(y),
+  y(y),
-  width(width),
+  width(width),
-  height(height) {
+  height(height) {
-		
+		
-}
+}
-
+
-bool GuiElement::pointInside( int x, int y ) {
+bool GuiElement::pointInside( int x, int y ) {
-	if(x >= this->x && x < this->x + this->width) {
+	if(x >= this->x && x < this->x + this->width) {
-		if(y >= this->y && y < this->y + this->height) {
+		if(y >= this->y && y < this->y + this->height) {
-			return true;
+			return true;
-		}
+		}
-	}
+	}
-	return false;
+	return false;
-}
+}

src/client/gui/components/GuiElement.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include "../GuiComponent.h"
+#include "client/gui/GuiComponent.hpp"
 
 class Tesselator;
 class Minecraft;

src/client/gui/components/GuiElementContainer.cpp

@@ -1,66 +1,66 @@
-#include "GuiElementContainer.h"
+#include "GuiElementContainer.hpp"
-#include <algorithm>
+#include <algorithm>
-GuiElementContainer::GuiElementContainer( bool active/*=false*/, bool visible/*=true*/, int x /*= 0*/, int y /*= 0*/, int width/*=24*/, int height/*=24*/ )
+GuiElementContainer::GuiElementContainer( bool active/*=false*/, bool visible/*=true*/, int x /*= 0*/, int y /*= 0*/, int width/*=24*/, int height/*=24*/ )
-: GuiElement(active, visible, x, y, width, height) {
+: GuiElement(active, visible, x, y, width, height) {
-
+
-}
+}
-
+
-GuiElementContainer::~GuiElementContainer() {
+GuiElementContainer::~GuiElementContainer() {
-	while(!children.empty()) {
+	while(!children.empty()) {
-		GuiElement* element = children.back();
+		GuiElement* element = children.back();
-		children.pop_back();
+		children.pop_back();
-		delete element;
+		delete element;
-	}
+	}
-}
+}
-
+
-void GuiElementContainer::render( Minecraft* minecraft, int xm, int ym ) {
+void GuiElementContainer::render( Minecraft* minecraft, int xm, int ym ) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->render(minecraft, xm, ym);
+		(*it)->render(minecraft, xm, ym);
-	}
+	}
-}
+}
-
+
-void GuiElementContainer::setupPositions() {
+void GuiElementContainer::setupPositions() {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->setupPositions();
+		(*it)->setupPositions();
-	}
+	}
-}
+}
-
+
-void GuiElementContainer::addChild( GuiElement* element ) {
+void GuiElementContainer::addChild( GuiElement* element ) {
-	children.push_back(element);
+	children.push_back(element);
-}
+}
-
+
-void GuiElementContainer::removeChild( GuiElement* element ) {
+void GuiElementContainer::removeChild( GuiElement* element ) {
-	std::vector<GuiElement*>::iterator it = std::find(children.begin(), children.end(), element);
+	std::vector<GuiElement*>::iterator it = std::find(children.begin(), children.end(), element);
-	if(it != children.end())
+	if(it != children.end())
-		children.erase(it);
+		children.erase(it);
-}
+}
-
+
-void GuiElementContainer::tick( Minecraft* minecraft ) {
+void GuiElementContainer::tick( Minecraft* minecraft ) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->tick(minecraft);
+		(*it)->tick(minecraft);
-	}
+	}
-}
+}
-
+
-void GuiElementContainer::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
+void GuiElementContainer::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->mouseClicked(minecraft, x, y, buttonNum);
+		(*it)->mouseClicked(minecraft, x, y, buttonNum);
-	}
+	}
-}
+}
-
+
-void GuiElementContainer::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
+void GuiElementContainer::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->mouseReleased(minecraft, x, y, buttonNum);
+		(*it)->mouseReleased(minecraft, x, y, buttonNum);
-	}
+	}
-}
+}
-
+
-void GuiElementContainer::keyPressed(Minecraft* minecraft, int key) {
+void GuiElementContainer::keyPressed(Minecraft* minecraft, int key) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->keyPressed(minecraft, key);
+		(*it)->keyPressed(minecraft, key);
-	}
+	}
-}
+}
-
+
-void GuiElementContainer::charPressed(Minecraft* minecraft, char key) {
+void GuiElementContainer::charPressed(Minecraft* minecraft, char key) {
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->charPressed(minecraft, key);
+		(*it)->charPressed(minecraft, key);
-	}
+	}
 }

src/client/gui/components/GuiElementContainer.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include "GuiElement.h"
+#include "GuiElement.hpp"
 #include <vector>
 class Tesselator;
 class Minecraft;

src/client/gui/components/ImageButton.cpp

@@ -1,135 +1,135 @@
-#include "ImageButton.h"
+#include "ImageButton.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../../platform/log.h"
+#include "platform/log.hpp"
-#include "../../../util/Mth.h"
+#include "util/Mth.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-#include <client/Option.h>
+#include <client/Option.hpp>
-
+
-
+
-ImageButton::ImageButton(int id, const std::string& msg)
+ImageButton::ImageButton(int id, const std::string& msg)
-:	super(id, msg)
+:	super(id, msg)
-{
+{
-	setupDefault();
+	setupDefault();
-}
+}
-
+
-ImageButton::ImageButton(int id, const std::string& msg, const ImageDef& imagedef)
+ImageButton::ImageButton(int id, const std::string& msg, const ImageDef& imagedef)
-:	super(id, msg),
+:	super(id, msg),
-	_imageDef(imagedef)
+	_imageDef(imagedef)
-{
+{
-	setupDefault();
+	setupDefault();
-}
+}
-
+
-void ImageButton::setupDefault() {
+void ImageButton::setupDefault() {
-	width = 48;
+	width = 48;
-	height = 48;
+	height = 48;
-	scaleWhenPressed = true;
+	scaleWhenPressed = true;
-}
+}
-
+
-void ImageButton::setImageDef(const ImageDef& imageDef, bool setButtonSize) {
+void ImageButton::setImageDef(const ImageDef& imageDef, bool setButtonSize) {
-	_imageDef = imageDef;
+	_imageDef = imageDef;
-	if (setButtonSize) {
+	if (setButtonSize) {
-		width = (int)_imageDef.width;
+		width = (int)_imageDef.width;
-		height = (int)_imageDef.height;
+		height = (int)_imageDef.height;
-	}
+	}
-}
+}
-
+
-void ImageButton::render(Minecraft* minecraft, int xm, int ym) {
+void ImageButton::render(Minecraft* minecraft, int xm, int ym) {
-	if (!visible) return;
+	if (!visible) return;
-
+
-	Font* font = minecraft->font;
+	Font* font = minecraft->font;
-
+
-	//minecraft->textures->loadAndBindTexture("gui/gui.png");
+	//minecraft->textures->loadAndBindTexture("gui/gui.png");
-	glColor4f2(1, 1, 1, 1);
+	glColor4f2(1, 1, 1, 1);
-
+
-	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : isInside(xm, ym));
+	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : isInside(xm, ym));
-	bool IsSecondImage = isSecondImage(hovered);
+	bool IsSecondImage = isSecondImage(hovered);
-
+
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	//int yImage = getYImage(hovered || selected);
+	//int yImage = getYImage(hovered || selected);
-
+
-	//blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
+	//blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
-	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
+	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
-
+
-	renderBg(minecraft, xm, ym);
+	renderBg(minecraft, xm, ym);
-
+
-	TextureId texId = (_imageDef.name.length() > 0)? minecraft->textures->loadAndBindTexture(_imageDef.name) : Textures::InvalidId;
+	TextureId texId = (_imageDef.name.length() > 0)? minecraft->textures->loadAndBindTexture(_imageDef.name) : Textures::InvalidId;
-	if ( Textures::isTextureIdValid(texId) ) {
+	if ( Textures::isTextureIdValid(texId) ) {
-		const ImageDef& d = _imageDef;
+		const ImageDef& d = _imageDef;
-		Tesselator& t = Tesselator::instance;
+		Tesselator& t = Tesselator::instance;
-		
+		
-		t.begin();
+		t.begin();
-			if (!active)				t.color(0xff808080);
+			if (!active)				t.color(0xff808080);
-			//else if (hovered||selected) t.color(0xffffffff);
+			//else if (hovered||selected) t.color(0xffffffff);
-			//else						t.color(0xffe0e0e0);
+			//else						t.color(0xffe0e0e0);
-			else t.color(0xffffffff);
+			else t.color(0xffffffff);
-
+
-			float hx = ((float) d.width) * 0.5f;
+			float hx = ((float) d.width) * 0.5f;
-			float hy = ((float) d.height) * 0.5f;
+			float hy = ((float) d.height) * 0.5f;
-			const float cx = ((float)x+d.x) + hx;
+			const float cx = ((float)x+d.x) + hx;
-			const float cy = ((float)y+d.y) + hy;
+			const float cy = ((float)y+d.y) + hy;
-			if (scaleWhenPressed && hovered) {
+			if (scaleWhenPressed && hovered) {
-				hx *= 0.95f;
+				hx *= 0.95f;
-				hy *= 0.95f;
+				hy *= 0.95f;
-			}
+			}
-
+
-			const IntRectangle* src = _imageDef.getSrc();
+			const IntRectangle* src = _imageDef.getSrc();
-			if (src) {
+			if (src) {
-				const TextureData* d = minecraft->textures->getTemporaryTextureData(texId);
+				const TextureData* d = minecraft->textures->getTemporaryTextureData(texId);
-				if (d != NULL) {
+				if (d != NULL) {
-					float u0 = (src->x+(IsSecondImage?src->w:0)) / (float)d->w;
+					float u0 = (src->x+(IsSecondImage?src->w:0)) / (float)d->w;
-					float u1 = (src->x+(IsSecondImage?2*src->w:src->w)) / (float)d->w;
+					float u1 = (src->x+(IsSecondImage?2*src->w:src->w)) / (float)d->w;
-					float v0 = src->y / (float)d->h;
+					float v0 = src->y / (float)d->h;
-					float v1 = (src->y+src->h) / (float)d->h;
+					float v1 = (src->y+src->h) / (float)d->h;
-					t.vertexUV(cx-hx, cy-hy, blitOffset, u0, v0);
+					t.vertexUV(cx-hx, cy-hy, blitOffset, u0, v0);
-					t.vertexUV(cx-hx, cy+hy, blitOffset, u0, v1);
+					t.vertexUV(cx-hx, cy+hy, blitOffset, u0, v1);
-					t.vertexUV(cx+hx, cy+hy, blitOffset, u1, v1);
+					t.vertexUV(cx+hx, cy+hy, blitOffset, u1, v1);
-					t.vertexUV(cx+hx, cy-hy, blitOffset, u1, v0);
+					t.vertexUV(cx+hx, cy-hy, blitOffset, u1, v0);
-				}
+				}
-			} else {
+			} else {
-				t.vertexUV(cx-hx, cy-hy, blitOffset, 0, 0);
+				t.vertexUV(cx-hx, cy-hy, blitOffset, 0, 0);
-				t.vertexUV(cx-hx, cy+hy, blitOffset, 0, 1);
+				t.vertexUV(cx-hx, cy+hy, blitOffset, 0, 1);
-				t.vertexUV(cx+hx, cy+hy, blitOffset, 1, 1);
+				t.vertexUV(cx+hx, cy+hy, blitOffset, 1, 1);
-				t.vertexUV(cx+hx, cy-hy, blitOffset, 1, 0);
+				t.vertexUV(cx+hx, cy-hy, blitOffset, 1, 0);
-			}
+			}
-		t.draw();
+		t.draw();
-	}
+	}
-	//blit(0, 0, 0, 0, 64, 64, 256, 256);
+	//blit(0, 0, 0, 0, 64, 64, 256, 256);
-
+
-	//LOGI("%d %d\n", x+d.x, x+d.x+d.w);
+	//LOGI("%d %d\n", x+d.x, x+d.x+d.w);
-
+
-	if (!active) {
+	if (!active) {
-		drawCenteredString(font, msg, x + width / 2, y + 16/*(h - 16)*/, 0xffa0a0a0);
+		drawCenteredString(font, msg, x + width / 2, y + 16/*(h - 16)*/, 0xffa0a0a0);
-	} else {
+	} else {
-		if (hovered || selected) {
+		if (hovered || selected) {
-			drawCenteredString(font, msg, x + width / 2, y + 17/*(h - 16)*/, 0xffffa0);
+			drawCenteredString(font, msg, x + width / 2, y + 17/*(h - 16)*/, 0xffffa0);
-		} else {
+		} else {
-			drawCenteredString(font, msg, x + width / 2, y + 16/*(h - 48)*/, 0xe0e0e0);
+			drawCenteredString(font, msg, x + width / 2, y + 16/*(h - 48)*/, 0xe0e0e0);
-		}
+		}
-	}
+	}
-}
+}
-
+
-
+
-//
+//
-// A toggleable Button
+// A toggleable Button
-//
+//
-OptionButton::OptionButton(OptionId option) : m_optId(option), super(ButtonId, "") {}
+OptionButton::OptionButton(OptionId option) : m_optId(option), super(ButtonId, "") {}
-
+
-void OptionButton::toggle(Options* options) {
+void OptionButton::toggle(Options* options) {
-	options->toggle(m_optId);
+	options->toggle(m_optId);
-
+
-	// Update graphics here
+	// Update graphics here
-	updateImage(options);
+	updateImage(options);
-}
+}
-
+
-void OptionButton::updateImage(Options* options) {
+void OptionButton::updateImage(Options* options) {
-	_secondImage = options->getBooleanValue(m_optId);
+	_secondImage = options->getBooleanValue(m_optId);
-}
+}
-
+
-void OptionButton::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
+void OptionButton::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	if(buttonNum == MouseAction::ACTION_LEFT) {
+	if(buttonNum == MouseAction::ACTION_LEFT) {
-		if(clicked(minecraft, x, y)) {
+		if(clicked(minecraft, x, y)) {
-			toggle(&minecraft->options);
+			toggle(&minecraft->options);
-		}
+		}
-	}
+	}
-}
+}

src/client/gui/components/ImageButton.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Button.h"
+#include "Button.hpp"
 
 typedef struct IntRectangle {
 	IntRectangle()

src/client/gui/components/InventoryPane.cpp

@@ -1,206 +1,206 @@
-#include "InventoryPane.h"
+#include "InventoryPane.hpp"
-#include "../Gui.h"
+#include "client/gui/Gui.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../player/input/touchscreen/TouchAreaModel.h"
+#include "client/player/input/touchscreen/TouchAreaModel.hpp"
-#include "../../renderer/entity/ItemRenderer.h"
+#include "client/renderer/entity/ItemRenderer.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-#include "../../../world/item/ItemInstance.h"
+#include "world/item/ItemInstance.hpp"
-#include "../../../world/entity/player/Inventory.h"
+#include "world/entity/player/Inventory.hpp"
-
+
-namespace Touch {
+namespace Touch {
-
+
-static const int By = 6; // Border Frame height
+static const int By = 6; // Border Frame height
-
+
-InventoryPane::InventoryPane( IInventoryPaneCallback* screen, Minecraft* mc, const IntRectangle& rect, int paneWidth, float clickMarginH, int numItems, int itemSize, int itemBorderSize)
+InventoryPane::InventoryPane( IInventoryPaneCallback* screen, Minecraft* mc, const IntRectangle& rect, int paneWidth, float clickMarginH, int numItems, int itemSize, int itemBorderSize)
-:	screen(screen),
+:	screen(screen),
-	mc(mc),
+	mc(mc),
-	paneWidth(paneWidth),
+	paneWidth(paneWidth),
-	rect(rect),
+	rect(rect),
-	super(
+	super(
-	SF_LockX|/*SF_Scissor|*/SF_ShowScrollbar|SF_NoHoldSelect,
+	SF_LockX|/*SF_Scissor|*/SF_ShowScrollbar|SF_NoHoldSelect,
-	rect,  // Pane rect
+	rect,  // Pane rect
-	IntRectangle(0, 0, itemSize, itemSize), // Item rect
+	IntRectangle(0, 0, itemSize, itemSize), // Item rect
-	0, numItems, Gui::GuiScale),
+	0, numItems, Gui::GuiScale),
-    BorderPixels(itemBorderSize),
+    BorderPixels(itemBorderSize),
-	lastItemIndex(-1),
+	lastItemIndex(-1),
-	lastItemTicks(-1),
+	lastItemTicks(-1),
-	fillMarginX(2),
+	fillMarginX(2),
-	fillMarginY(4),
+	fillMarginY(4),
-	markerType(1),
+	markerType(1),
-	markerIndex(-1),
+	markerIndex(-1),
-	markerShare(0),
+	markerShare(0),
-	renderDecorations(true)
+	renderDecorations(true)
-{
+{
-	_clickArea = new RectangleArea(0, 0, 0, 0);
+	_clickArea = new RectangleArea(0, 0, 0, 0);
-	area._x0 = rect.x - clickMarginH;
+	area._x0 = rect.x - clickMarginH;
-	area._x1 = rect.x + rect.w + clickMarginH;
+	area._x1 = rect.x + rect.w + clickMarginH;
-	area._y0 -= By;
+	area._y0 -= By;
-	area._y1 += By;
+	area._y1 += By;
-
+
-	/*
+	/*
-	const int left = bbox.x + (bbox.w - paneWidth) / 2;
+	const int left = bbox.x + (bbox.w - paneWidth) / 2;
-	bg.x = left;
+	bg.x = left;
-	bg.w = left + paneWidth; // @note: read as x1, not width
+	bg.w = left + paneWidth; // @note: read as x1, not width
-	bg.y = bbox.y - fillMarginY;
+	bg.y = bbox.y - fillMarginY;
-	bg.h = bbox.y + bbox.h + fillMarginY; // @note: read as y1, not width
+	bg.h = bbox.y + bbox.h + fillMarginY; // @note: read as y1, not width
-	*/
+	*/
-}
+}
-
+
-InventoryPane::~InventoryPane() {
+InventoryPane::~InventoryPane() {
-	delete _clickArea;
+	delete _clickArea;
-}
+}
-
+
-void InventoryPane::renderBatch( std::vector<GridItem>& items, float alpha )
+void InventoryPane::renderBatch( std::vector<GridItem>& items, float alpha )
-{
+{
-	//fill(bg.x, bg.y, bg.w, bg.h, 0xff333333);
+	//fill(bg.x, bg.y, bg.w, bg.h, 0xff333333);
-	fill((float)(bbox.x-fillMarginX-1), (float)(bbox.y-fillMarginY), (float)(bbox.x + bbox.w + fillMarginX+1), (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);
+	fill((float)(bbox.x-fillMarginX-1), (float)(bbox.y-fillMarginY), (float)(bbox.x + bbox.w + fillMarginX+1), (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);
-	//fill(0.0f, (float)(bbox.y-fillMarginY), 400.0f, (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);//(float)(bbox.x-fillMarginX), (float)(bbox.y-fillMarginY), (float)(bbox.x + bbox.w + fillMarginX), (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);
+	//fill(0.0f, (float)(bbox.y-fillMarginY), 400.0f, (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);//(float)(bbox.x-fillMarginX), (float)(bbox.y-fillMarginY), (float)(bbox.x + bbox.w + fillMarginX), (float)(bbox.y + bbox.h + fillMarginY), 0xff333333);
-	glEnable2(GL_BLEND);
+	glEnable2(GL_BLEND);
-	glDisable2(GL_ALPHA_TEST);
+	glDisable2(GL_ALPHA_TEST);
-	std::vector<const ItemInstance*> inventoryItems = screen->getItems(this);
+	std::vector<const ItemInstance*> inventoryItems = screen->getItems(this);
-
+
-	glEnable2(GL_SCISSOR_TEST);
+	glEnable2(GL_SCISSOR_TEST);
-	GLuint x = (GLuint)(screenScale * bbox.x);
+	GLuint x = (GLuint)(screenScale * bbox.x);
-	GLuint y = mc->height - (GLuint)(screenScale * (bbox.y + bbox.h));
+	GLuint y = mc->height - (GLuint)(screenScale * (bbox.y + bbox.h));
-	GLuint w = (GLuint)(screenScale * bbox.w);
+	GLuint w = (GLuint)(screenScale * bbox.w);
-	GLuint h = (GLuint)(screenScale * bbox.h);
+	GLuint h = (GLuint)(screenScale * bbox.h);
-	glScissor(x, y, w, h);
+	glScissor(x, y, w, h);
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-
+
-	t.beginOverride();
+	t.beginOverride();
-	t.colorABGR(0xffffffff);
+	t.colorABGR(0xffffffff);
-	for (unsigned int i = 0; i < items.size(); ++i) {
+	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
+		GridItem& item = items[i];
-		blit(item.xf, item.yf, 200, 46, (float)itemBbox.w, (float)itemBbox.h, 16, 16);
+		blit(item.xf, item.yf, 200, 46, (float)itemBbox.w, (float)itemBbox.h, 16, 16);
-	}
+	}
-	mc->textures->loadAndBindTexture("gui/gui.png");
+	mc->textures->loadAndBindTexture("gui/gui.png");
-	t.endOverrideAndDraw();
+	t.endOverrideAndDraw();
-
+
-	GridItem* marked = NULL;
+	GridItem* marked = NULL;
-	float mxx, myy;
+	float mxx, myy;
-
+
-	t.beginOverride();
+	t.beginOverride();
-	for (unsigned int i = 0; i < items.size(); ++i) {
+	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
+		GridItem& item = items[i];
-		int j = item.id;
+		int j = item.id;
-		const ItemInstance* citem = inventoryItems[j];
+		const ItemInstance* citem = inventoryItems[j];
-		if (!citem) continue;
+		if (!citem) continue;
-
+
-		bool allowed = true;
+		bool allowed = true;
-
+
-		t.enableColor();
+		t.enableColor();
-		//#ifdef DEMO_MODE //@huge @attn
+		//#ifdef DEMO_MODE //@huge @attn
-		if (!screen->isAllowed(j)) { allowed = false; t.color( 64,  64,  64); }
+		if (!screen->isAllowed(j)) { allowed = false; t.color( 64,  64,  64); }
-		else
+		else
-			//#endif
+			//#endif
-			if (lastItemTicks > 0 && lastItemIndex == j) {
+			if (lastItemTicks > 0 && lastItemIndex == j) {
-				int gv = 255 - lastItemTicks * 15;
+				int gv = 255 - lastItemTicks * 15;
-				t.color(gv, gv, gv, (allowed && citem->count <= 0)?0x60:0xff);
+				t.color(gv, gv, gv, (allowed && citem->count <= 0)?0x60:0xff);
-			} else {
+			} else {
-				t.color(255, 255, 255, (allowed && citem->count <= 0)?0x60:0xff);
+				t.color(255, 255, 255, (allowed && citem->count <= 0)?0x60:0xff);
-			}          
+			}          
-			t.noColor();
+			t.noColor();
-			float xx = Gui::floorAlignToScreenPixel(item.xf + BorderPixels + 4);
+			float xx = Gui::floorAlignToScreenPixel(item.xf + BorderPixels + 4);
-			float yy = Gui::floorAlignToScreenPixel(item.yf + BorderPixels + 4);
+			float yy = Gui::floorAlignToScreenPixel(item.yf + BorderPixels + 4);
-			ItemRenderer::renderGuiItem(NULL, mc->textures, citem, xx, yy, 16, 16, false);
+			ItemRenderer::renderGuiItem(NULL, mc->textures, citem, xx, yy, 16, 16, false);
-
+
-			if (j == markerIndex && markerShare >= 0)
+			if (j == markerIndex && markerShare >= 0)
-				marked = &item, mxx = xx, myy = yy;
+				marked = &item, mxx = xx, myy = yy;
-
+
-	}
+	}
-	t.endOverrideAndDraw();
+	t.endOverrideAndDraw();
-
+
-	if (marked) {
+	if (marked) {
-		glDisable2(GL_TEXTURE_2D);
+		glDisable2(GL_TEXTURE_2D);
-		const float yy0 = myy - 5.0f;
+		const float yy0 = myy - 5.0f;
-		const float yy1 = yy0 + 2;
+		const float yy1 = yy0 + 2;
-		fill(mxx, yy0, mxx + 16.0f, yy1, 0xff606060);
+		fill(mxx, yy0, mxx + 16.0f, yy1, 0xff606060);
-		fill(mxx, yy0, mxx + markerShare * 16.0f, yy1, markerType==1?0xff00ff00:0xff476543);
+		fill(mxx, yy0, mxx + markerShare * 16.0f, yy1, markerType==1?0xff00ff00:0xff476543);
-		glEnable2(GL_BLEND);
+		glEnable2(GL_BLEND);
-		glEnable2(GL_TEXTURE_2D);
+		glEnable2(GL_TEXTURE_2D);
-	}
+	}
-
+
-
+
-	if (!mc->isCreativeMode()) {
+	if (!mc->isCreativeMode()) {
-		const float ikText = Gui::InvGuiScale + Gui::InvGuiScale;
+		const float ikText = Gui::InvGuiScale + Gui::InvGuiScale;
-		const float kText = 0.5f * Gui::GuiScale;
+		const float kText = 0.5f * Gui::GuiScale;
-		t.beginOverride();
+		t.beginOverride();
-		t.scale2d(ikText, ikText);
+		t.scale2d(ikText, ikText);
-		for (unsigned int i = 0; i < items.size(); ++i) {
+		for (unsigned int i = 0; i < items.size(); ++i) {
-			GridItem& item = items[i];
+			GridItem& item = items[i];
-			const ItemInstance* citem = inventoryItems[item.id];
+			const ItemInstance* citem = inventoryItems[item.id];
-			if (!citem) continue;
+			if (!citem) continue;
-
+
-			char buf[64] = {0};
+			char buf[64] = {0};
-			/*int c = */ Gui::itemCountItoa(buf, citem->count);
+			/*int c = */ Gui::itemCountItoa(buf, citem->count);
-
+
-			float tx = Gui::floorAlignToScreenPixel(kText * (item.xf + BorderPixels + 3));
+			float tx = Gui::floorAlignToScreenPixel(kText * (item.xf + BorderPixels + 3));
-			float ty = Gui::floorAlignToScreenPixel(kText * (item.yf + BorderPixels + 3));
+			float ty = Gui::floorAlignToScreenPixel(kText * (item.yf + BorderPixels + 3));
-			mc->gui.renderSlotText(citem, tx, ty, true, true);
+			mc->gui.renderSlotText(citem, tx, ty, true, true);
-		}
+		}
-		t.resetScale();
+		t.resetScale();
-		glEnable2(GL_BLEND);
+		glEnable2(GL_BLEND);
-		t.endOverrideAndDraw();
+		t.endOverrideAndDraw();
-	}
+	}
-
+
-	if (renderDecorations) {
+	if (renderDecorations) {
-		t.beginOverride();
+		t.beginOverride();
-		for (unsigned int i = 0; i < items.size(); ++i) {
+		for (unsigned int i = 0; i < items.size(); ++i) {
-			GridItem& item = items[i];
+			GridItem& item = items[i];
-			const ItemInstance* citem = inventoryItems[item.id];
+			const ItemInstance* citem = inventoryItems[item.id];
-			if (!citem || citem->isNull()) continue;
+			if (!citem || citem->isNull()) continue;
-
+
-			if (citem->isDamaged()) {
+			if (citem->isDamaged()) {
-				ItemRenderer::renderGuiItemDecorations(citem, item.xf + 8, item.yf + 12);
+				ItemRenderer::renderGuiItemDecorations(citem, item.xf + 8, item.yf + 12);
-			}
+			}
-		}
+		}
-
+
-		glDisable2(GL_TEXTURE_2D);
+		glDisable2(GL_TEXTURE_2D);
-		t.endOverrideAndDraw();
+		t.endOverrideAndDraw();
-		glEnable2(GL_TEXTURE_2D);
+		glEnable2(GL_TEXTURE_2D);
-	}
+	}
-	glDisable2(GL_SCISSOR_TEST);
+	glDisable2(GL_SCISSOR_TEST);
-
+
-	//fillGradient(bbox.x - 1, bbox.y, bbox.x + bbox.w + 1, bbox.y + 20, 0x99000000, 0x00000000);
+	//fillGradient(bbox.x - 1, bbox.y, bbox.x + bbox.w + 1, bbox.y + 20, 0x99000000, 0x00000000);
-	//fillGradient(bbox.x - 1, bbox.y + bbox.h - 20, bbox.x + bbox.w + 1, bbox.y + bbox.h, 0x00000000, 0x99000000);
+	//fillGradient(bbox.x - 1, bbox.y + bbox.h - 20, bbox.x + bbox.w + 1, bbox.y + bbox.h, 0x00000000, 0x99000000);
-	fillGradient(bg.x - fillMarginX, bbox.y, bg.w + fillMarginX, bbox.y + 20, 0x99000000, 0x00000000);
+	fillGradient(bg.x - fillMarginX, bbox.y, bg.w + fillMarginX, bbox.y + 20, 0x99000000, 0x00000000);
-	fillGradient(bg.x - fillMarginX, bbox.y + bbox.h - 20, bg.w + fillMarginX, bbox.y + bbox.h, 0x00000000, 0x99000000);
+	fillGradient(bg.x - fillMarginX, bbox.y + bbox.h - 20, bg.w + fillMarginX, bbox.y + bbox.h, 0x00000000, 0x99000000);
-
+
-	drawScrollBar(hScroll);
+	drawScrollBar(hScroll);
-	drawScrollBar(vScroll);
+	drawScrollBar(vScroll);
-}
+}
-
+
-bool InventoryPane::onSelect( int gridId, bool selected )
+bool InventoryPane::onSelect( int gridId, bool selected )
-{
+{
-	//screen->onItemSelected(gridId);
+	//screen->onItemSelected(gridId);
-	if (screen->isAllowed(gridId))
+	if (screen->isAllowed(gridId))
-		if (screen->addItem(this, gridId)) {
+		if (screen->addItem(this, gridId)) {
-			lastItemIndex = gridId;
+			lastItemIndex = gridId;
-			lastItemTicks = 7;
+			lastItemTicks = 7;
-		}
+		}
-
+
-		return false;
+		return false;
-}
+}
-
+
-void InventoryPane::drawScrollBar( ScrollBar& sb ) {
+void InventoryPane::drawScrollBar( ScrollBar& sb ) {
-	if (sb.alpha <= 0)
+	if (sb.alpha <= 0)
-		return;
+		return;
-
+
-	const int color = ((int)(255.0f * sb.alpha) << 24) | 0xaaaaaa;
+	const int color = ((int)(255.0f * sb.alpha) << 24) | 0xaaaaaa;
-	const float xx = (float)(bbox.x + bbox.w);
+	const float xx = (float)(bbox.x + bbox.w);
-	fill(xx - sb.w, sb.y, xx, sb.y + sb.h, color);
+	fill(xx - sb.w, sb.y, xx, sb.y + sb.h, color);
-}
+}
-
+
-void InventoryPane::tick()
+void InventoryPane::tick()
-{
+{
-	--lastItemTicks;
+	--lastItemTicks;
-	super::tick();
+	super::tick();
-}
+}
-
+
-void InventoryPane::setRenderDecorations( bool value ) {
+void InventoryPane::setRenderDecorations( bool value ) {
-	renderDecorations = value;
+	renderDecorations = value;
-}
+}
-
+
-}
+}

src/client/gui/components/InventoryPane.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "ScrollingPane.h"
+#include "ScrollingPane.hpp"
-#include "ImageButton.h"
+#include "ImageButton.hpp"
 
 class Minecraft;
 class ItemInstance;

src/client/gui/components/ItemPane.cpp

@@ -1,148 +1,148 @@
-#include "ItemPane.h"
+#include "ItemPane.hpp"
-#include "../Gui.h"
+#include "client/gui/Gui.hpp"
-#include "../../renderer/gles.h"
+#include "client/renderer/gles.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "NinePatch.h"
+#include "NinePatch.hpp"
-#include "../../renderer/entity/ItemRenderer.h"
+#include "client/renderer/entity/ItemRenderer.hpp"
-
+
-const int rgbActive = 0xfff0f0f0;
+const int rgbActive = 0xfff0f0f0;
-const int rgbInactive = 0xc0635558;
+const int rgbInactive = 0xc0635558;
-const int rgbInactiveShadow = 0xc0aaaaaa;
+const int rgbInactiveShadow = 0xc0aaaaaa;
-
+
-ItemPane::ItemPane( IItemPaneCallback* screen,
+ItemPane::ItemPane( IItemPaneCallback* screen,
-					Textures* textures,
+					Textures* textures,
-					const IntRectangle& rect,
+					const IntRectangle& rect,
-					int numItems,
+					int numItems,
-					int guiHeight,
+					int guiHeight,
-					int physicalScreenHeight,
+					int physicalScreenHeight,
-					bool isVertical /*= true*/)
+					bool isVertical /*= true*/)
-:	super(
+:	super(
-	(isVertical?SF_LockX:SF_LockY)/*|SF_Scissor*/|SF_ShowScrollbar,
+	(isVertical?SF_LockX:SF_LockY)/*|SF_Scissor*/|SF_ShowScrollbar,
-	rect,							// Pane rect
+	rect,							// Pane rect
-	isVertical?IntRectangle(0, 0, rect.w, 22)  // Item rect if vertical
+	isVertical?IntRectangle(0, 0, rect.w, 22)  // Item rect if vertical
-			  :IntRectangle(0, 0, 32, rect.h), // Item rect if horizontal
+			  :IntRectangle(0, 0, 32, rect.h), // Item rect if horizontal
-	isVertical?1:numItems, numItems, Gui::GuiScale),
+	isVertical?1:numItems, numItems, Gui::GuiScale),
-	screen(screen),
+	screen(screen),
-	textures(textures),
+	textures(textures),
-	physicalScreenHeight(physicalScreenHeight),
+	physicalScreenHeight(physicalScreenHeight),
-	guiSlotItem(NULL),
+	guiSlotItem(NULL),
-	guiSlotItemSelected(NULL),
+	guiSlotItemSelected(NULL),
-	isVertical(isVertical)
+	isVertical(isVertical)
-{
+{
-	// Expand the area to make it easier to scroll
+	// Expand the area to make it easier to scroll
-	area._x0 -= 4;
+	area._x0 -= 4;
-	area._x1 += 4;
+	area._x1 += 4;
-	area._y0 = 0;
+	area._y0 = 0;
-	area._y1 = (float)guiHeight;
+	area._y1 = (float)guiHeight;
-
+
-	// GUI
+	// GUI
-	NinePatchFactory builder(textures, "gui/spritesheet.png");
+	NinePatchFactory builder(textures, "gui/spritesheet.png");
-	guiSlotItem = builder.createSymmetrical(IntRectangle(20, 32, 8, 8), 2, 2);
+	guiSlotItem = builder.createSymmetrical(IntRectangle(20, 32, 8, 8), 2, 2);
-	guiSlotItemSelected = builder.createSymmetrical(IntRectangle(28, 32, 8, 8), 2, 2);
+	guiSlotItemSelected = builder.createSymmetrical(IntRectangle(28, 32, 8, 8), 2, 2);
-	guiSlotItem->setSize((float)rect.w + 4, 22);
+	guiSlotItem->setSize((float)rect.w + 4, 22);
-	guiSlotItemSelected->setSize((float)rect.w + 4, 22);
+	guiSlotItemSelected->setSize((float)rect.w + 4, 22);
-}
+}
-
+
-ItemPane::~ItemPane() {
+ItemPane::~ItemPane() {
-	delete guiSlotItem;
+	delete guiSlotItem;
-	delete guiSlotItemSelected;
+	delete guiSlotItemSelected;
-}
+}
-
+
-void ItemPane::renderBatch( std::vector<GridItem>& items, float alpha )
+void ItemPane::renderBatch( std::vector<GridItem>& items, float alpha )
-{
+{
-	//fill(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h, 0xff666666);
+	//fill(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h, 0xff666666);
-	const std::vector<CItem*>& cat = screen->getItems(this);
+	const std::vector<CItem*>& cat = screen->getItems(this);
-	if (cat.empty()) return;
+	if (cat.empty()) return;
-
+
-	glEnable2(GL_SCISSOR_TEST);
+	glEnable2(GL_SCISSOR_TEST);
-	GLuint x = (GLuint)(screenScale * bbox.x);
+	GLuint x = (GLuint)(screenScale * bbox.x);
-	GLuint y = physicalScreenHeight - (GLuint)(screenScale * (bbox.y + bbox.h));
+	GLuint y = physicalScreenHeight - (GLuint)(screenScale * (bbox.y + bbox.h));
-	GLuint w = (GLuint)(screenScale * bbox.w);
+	GLuint w = (GLuint)(screenScale * bbox.w);
-	GLuint h = (GLuint)(screenScale * bbox.h);
+	GLuint h = (GLuint)(screenScale * bbox.h);
-	glScissor(x, y, w, h);
+	glScissor(x, y, w, h);
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-
+
-	t.beginOverride();
+	t.beginOverride();
-	for (unsigned int i = 0; i < items.size(); ++i) {
+	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
+		GridItem& item = items[i];
-		(item.selected? guiSlotItemSelected : guiSlotItem)->draw(t, Gui::floorAlignToScreenPixel(item.xf-1), Gui::floorAlignToScreenPixel(item.yf));
+		(item.selected? guiSlotItemSelected : guiSlotItem)->draw(t, Gui::floorAlignToScreenPixel(item.xf-1), Gui::floorAlignToScreenPixel(item.yf));
-	}
+	}
-	t.endOverrideAndDraw();
+	t.endOverrideAndDraw();
-
+
-	t.beginOverride();
+	t.beginOverride();
-	for (unsigned int i = 0; i < items.size(); ++i) {
+	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
+		GridItem& item = items[i];
-		CItem* citem = cat[item.id];
+		CItem* citem = cat[item.id];
-
+
-		ItemRenderer::renderGuiItem(NULL, textures, &citem->item,
+		ItemRenderer::renderGuiItem(NULL, textures, &citem->item,
-			Gui::floorAlignToScreenPixel(item.xf + itemBbox.w - 16),
+			Gui::floorAlignToScreenPixel(item.xf + itemBbox.w - 16),
-			Gui::floorAlignToScreenPixel(2 + item.yf), 16, 16, false);
+			Gui::floorAlignToScreenPixel(2 + item.yf), 16, 16, false);
-	}
+	}
-	t.endOverrideAndDraw();
+	t.endOverrideAndDraw();
-
+
-	t.beginOverride();
+	t.beginOverride();
-	for (unsigned int i = 0; i < items.size(); ++i) {
+	for (unsigned int i = 0; i < items.size(); ++i) {
-		GridItem& item = items[i];
+		GridItem& item = items[i];
-		CItem* citem = cat[item.id];
+		CItem* citem = cat[item.id];
-
+
-		char buf[64] = {0};
+		char buf[64] = {0};
-		int c = Gui::itemCountItoa(buf, citem->inventoryCount);
+		int c = Gui::itemCountItoa(buf, citem->inventoryCount);
-
+
-		float xf = item.xf - 1;
+		float xf = item.xf - 1;
-		if (citem->canCraft()) {
+		if (citem->canCraft()) {
-			f->drawShadow(citem->text,
+			f->drawShadow(citem->text,
-				Gui::floorAlignToScreenPixel(xf + 2),
+				Gui::floorAlignToScreenPixel(xf + 2),
-				Gui::floorAlignToScreenPixel(item.yf + 6), rgbActive);
+				Gui::floorAlignToScreenPixel(item.yf + 6), rgbActive);
-			t.scale2d(0.6667f, 0.6667f);
+			t.scale2d(0.6667f, 0.6667f);
-			f->drawShadow(buf,
+			f->drawShadow(buf,
-				Gui::floorAlignToScreenPixel(1.5f * (xf + itemBbox.w - c*4)),
+				Gui::floorAlignToScreenPixel(1.5f * (xf + itemBbox.w - c*4)),
-				Gui::floorAlignToScreenPixel(1.5f * (item.yf + itemBbox.h - 8)), rgbActive);
+				Gui::floorAlignToScreenPixel(1.5f * (item.yf + itemBbox.h - 8)), rgbActive);
-			t.resetScale();
+			t.resetScale();
-		} else {
+		} else {
-			f->draw(citem->text,
+			f->draw(citem->text,
-				Gui::floorAlignToScreenPixel(xf + 3),
+				Gui::floorAlignToScreenPixel(xf + 3),
-				Gui::floorAlignToScreenPixel(item.yf + 7), rgbInactiveShadow);
+				Gui::floorAlignToScreenPixel(item.yf + 7), rgbInactiveShadow);
-			f->draw(citem->text,
+			f->draw(citem->text,
-				Gui::floorAlignToScreenPixel(xf + 2),
+				Gui::floorAlignToScreenPixel(xf + 2),
-				Gui::floorAlignToScreenPixel(item.yf + 6), rgbInactive);
+				Gui::floorAlignToScreenPixel(item.yf + 6), rgbInactive);
-			t.scale2d(0.6667f, 0.6667f);
+			t.scale2d(0.6667f, 0.6667f);
-			f->draw(buf,
+			f->draw(buf,
-				Gui::floorAlignToScreenPixel(1.5f * (xf + itemBbox.w - c*4)),
+				Gui::floorAlignToScreenPixel(1.5f * (xf + itemBbox.w - c*4)),
-				Gui::floorAlignToScreenPixel(1.5f * (item.yf + itemBbox.h - 8)), rgbInactive);
+				Gui::floorAlignToScreenPixel(1.5f * (item.yf + itemBbox.h - 8)), rgbInactive);
-			t.resetScale();
+			t.resetScale();
-		}
+		}
-	}
+	}
-	t.endOverrideAndDraw();
+	t.endOverrideAndDraw();
-
+
-	//fillGradient(bbox.x, bbox.y, bbox.x + bbox.w, 20, 0x00000000, 0x80ff0000)
+	//fillGradient(bbox.x, bbox.y, bbox.x + bbox.w, 20, 0x00000000, 0x80ff0000)
-	if (isVertical) {
+	if (isVertical) {
-		fillGradient(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + 28, 0xbb000000, 0x00000000);
+		fillGradient(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + 28, 0xbb000000, 0x00000000);
-		fillGradient(bbox.x, bbox.y + bbox.h - 28, bbox.x + bbox.w, bbox.y + bbox.h, 0x00000000, 0xbb000000);//0xbb2A272B);
+		fillGradient(bbox.x, bbox.y + bbox.h - 28, bbox.x + bbox.w, bbox.y + bbox.h, 0x00000000, 0xbb000000);//0xbb2A272B);
-	} else {
+	} else {
-		fillHorizontalGradient(bbox.x, bbox.y, bbox.x + 28, bbox.y + bbox.h, 0xbb000000, 0x00000000);
+		fillHorizontalGradient(bbox.x, bbox.y, bbox.x + 28, bbox.y + bbox.h, 0xbb000000, 0x00000000);
-		fillHorizontalGradient(bbox.x + bbox.w - 28, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h, 0x00000000, 0xbb000000);//0xbb2A272B);
+		fillHorizontalGradient(bbox.x + bbox.w - 28, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h, 0x00000000, 0xbb000000);//0xbb2A272B);
-	}
+	}
-
+
-	//LOGI("scroll: %f - %f, %f :: %f, %f\n", hScroll.alpha, hScroll.x, hScroll.y, hScroll.w, hScroll.h);
+	//LOGI("scroll: %f - %f, %f :: %f, %f\n", hScroll.alpha, hScroll.x, hScroll.y, hScroll.w, hScroll.h);
-	glDisable2(GL_SCISSOR_TEST);
+	glDisable2(GL_SCISSOR_TEST);
-
+
-	drawScrollBar(hScroll);
+	drawScrollBar(hScroll);
-	drawScrollBar(vScroll);
+	drawScrollBar(vScroll);
-}
+}
-
+
-bool ItemPane::onSelect( int gridId, bool selected )
+bool ItemPane::onSelect( int gridId, bool selected )
-{
+{
-	if (selected)
+	if (selected)
-		screen->onItemSelected(this, gridId);
+		screen->onItemSelected(this, gridId);
-
+
-	return selected;
+	return selected;
-}
+}
-
+
-void ItemPane::drawScrollBar( ScrollBar& sb ) {
+void ItemPane::drawScrollBar( ScrollBar& sb ) {
-	if (sb.alpha <= 0)
+	if (sb.alpha <= 0)
-		return;
+		return;
-
+
-	int color = ((int)(255.0f * sb.alpha) << 24) | 0xffffff;
+	int color = ((int)(255.0f * sb.alpha) << 24) | 0xffffff;
-	fill(2 + sb.x, sb.y, 2 + sb.x + sb.w, sb.y + sb.h, color);
+	fill(2 + sb.x, sb.y, 2 + sb.x + sb.w, sb.y + sb.h, color);
-}
+}

src/client/gui/components/ItemPane.hpp

@@ -2,8 +2,8 @@
 
 #include <string>
 #include <vector>
-#include "ScrollingPane.h"
+#include "ScrollingPane.hpp"
-#include "../../../world/item/ItemInstance.h"
+#include "world/item/ItemInstance.hpp"
 
 class Font;
 class Textures;

src/client/gui/components/KeyOption.cpp

@@ -1,5 +1,5 @@
-#include "KeyOption.h"
+#include "KeyOption.hpp"
-#include <client/Minecraft.h>
+#include <client/Minecraft.hpp>
 
 KeyOption::KeyOption(Minecraft* minecraft, OptionId optId) 
     : Touch::TButton((int)optId, Keyboard::getKeyName(minecraft->options.getIntValue(optId))) {}

src/client/gui/components/KeyOption.hpp

@@ -1,6 +1,6 @@
 #pragma once
-#include "Button.h"
+#include "Button.hpp"
-#include <client/Options.h>
+#include <client/Options.hpp>
 
 class KeyOption : public Touch::TButton {
 public:

src/client/gui/components/LargeImageButton.cpp

@@ -1,104 +1,104 @@
-#include "LargeImageButton.h"
+#include "LargeImageButton.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../../util/Mth.h"
+#include "util/Mth.hpp"
-#include "../../../platform/log.h"
+#include "platform/log.hpp"
-#include "../../../util/Mth.h"
+#include "util/Mth.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-
+
-
+
-LargeImageButton::LargeImageButton(int id, const std::string& msg)
+LargeImageButton::LargeImageButton(int id, const std::string& msg)
-:	super(id, msg)
+:	super(id, msg)
-{
+{
-	setupDefault();
+	setupDefault();
-}
+}
-
+
-LargeImageButton::LargeImageButton(int id, const std::string& msg, ImageDef& imagedef)
+LargeImageButton::LargeImageButton(int id, const std::string& msg, ImageDef& imagedef)
-:	super(id, msg)
+:	super(id, msg)
-{
+{
-	_imageDef = imagedef;
+	_imageDef = imagedef;
-	setupDefault();
+	setupDefault();
-}
+}
-
+
-void LargeImageButton::setupDefault() {
+void LargeImageButton::setupDefault() {
-	_buttonScale = 1;
+	_buttonScale = 1;
-	width = 72;
+	width = 72;
-	height = 72;
+	height = 72;
-}
+}
-
+
-void LargeImageButton::render(Minecraft* minecraft, int xm, int ym) {
+void LargeImageButton::render(Minecraft* minecraft, int xm, int ym) {
-	if (!visible) return;
+	if (!visible) return;
-
+
-	Font* font = minecraft->font;
+	Font* font = minecraft->font;
-
+
-	//minecraft->textures->loadAndBindTexture("gui/gui.png");
+	//minecraft->textures->loadAndBindTexture("gui/gui.png");
-	glColor4f2(1, 1, 1, 1);
+	glColor4f2(1, 1, 1, 1);
-	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : isInside(xm, ym));
+	bool hovered = active && (minecraft->useTouchscreen()? (_currentlyDown && xm >= x && ym >= y && xm < x + width && ym < y + height) : isInside(xm, ym));
-
+
-	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
+	//printf("ButtonId: %d - Hovered? %d (cause: %d, %d, %d, %d, <> %d, %d)\n", id, hovered, x, y, x+w, y+h, xm, ym);
-	//int yImage = getYImage(hovered || selected);
+	//int yImage = getYImage(hovered || selected);
-
+
-	//blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
+	//blit(x, y, 0, 46 + yImage * 20, w / 2, h, 0, 20);
-	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
+	//blit(x + w / 2, y, 200 - w / 2, 46 + yImage * 20, w / 2, h, 0, 20);
-
+
-	renderBg(minecraft, xm, ym);
+	renderBg(minecraft, xm, ym);
-
+
-	TextureId texId = (_imageDef.name.length() > 0)? minecraft->textures->loadAndBindTexture(_imageDef.name) : Textures::InvalidId;
+	TextureId texId = (_imageDef.name.length() > 0)? minecraft->textures->loadAndBindTexture(_imageDef.name) : Textures::InvalidId;
-	if ( Textures::isTextureIdValid(texId) ) {
+	if ( Textures::isTextureIdValid(texId) ) {
-		const ImageDef& d = _imageDef;
+		const ImageDef& d = _imageDef;
-		Tesselator& t = Tesselator::instance;
+		Tesselator& t = Tesselator::instance;
-		
+		
-		t.begin();
+		t.begin();
-			if (!active)				t.color(0xff808080);
+			if (!active)				t.color(0xff808080);
-			//else if (hovered||selected) t.color(0xffffffff);
+			//else if (hovered||selected) t.color(0xffffffff);
-			//else						t.color(0xffe0e0e0);
+			//else						t.color(0xffe0e0e0);
-			else t.color(0xffffffff);
+			else t.color(0xffffffff);
-
+
-			float hx = ((float) d.width) * 0.5f;
+			float hx = ((float) d.width) * 0.5f;
-			float hy = ((float) d.height) * 0.5f;
+			float hy = ((float) d.height) * 0.5f;
-			const float cx = ((float)x+d.x) + hx;
+			const float cx = ((float)x+d.x) + hx;
-			const float cy = ((float)y+d.y) + hy;
+			const float cy = ((float)y+d.y) + hy;
-
+
-			if (hovered)
+			if (hovered)
-				_buttonScale = Mth::Max(0.95f, _buttonScale-0.025f);
+				_buttonScale = Mth::Max(0.95f, _buttonScale-0.025f);
-			else
+			else
-				_buttonScale = Mth::Min(1.00f, _buttonScale+0.025f);
+				_buttonScale = Mth::Min(1.00f, _buttonScale+0.025f);
-
+
-			hx *= _buttonScale;
+			hx *= _buttonScale;
-			hy *= _buttonScale;
+			hy *= _buttonScale;
-
+
-			const IntRectangle* src = _imageDef.getSrc();
+			const IntRectangle* src = _imageDef.getSrc();
-			if (src) {
+			if (src) {
-				const TextureData* d = minecraft->textures->getTemporaryTextureData(texId);
+				const TextureData* d = minecraft->textures->getTemporaryTextureData(texId);
-				if (d != NULL) {
+				if (d != NULL) {
-					float u0 = (src->x+(hovered?src->w:0)) / (float)d->w;
+					float u0 = (src->x+(hovered?src->w:0)) / (float)d->w;
-					float u1 = (src->x+(hovered?2*src->w:src->w)) / (float)d->w;
+					float u1 = (src->x+(hovered?2*src->w:src->w)) / (float)d->w;
-					float v0 =  src->y / (float)d->h;
+					float v0 =  src->y / (float)d->h;
-					float v1 = (src->y+src->h) / (float)d->h;
+					float v1 = (src->y+src->h) / (float)d->h;
-					t.vertexUV(cx-hx, cy-hy, blitOffset, u0, v0);
+					t.vertexUV(cx-hx, cy-hy, blitOffset, u0, v0);
-					t.vertexUV(cx-hx, cy+hy, blitOffset, u0, v1);
+					t.vertexUV(cx-hx, cy+hy, blitOffset, u0, v1);
-					t.vertexUV(cx+hx, cy+hy, blitOffset, u1, v1);
+					t.vertexUV(cx+hx, cy+hy, blitOffset, u1, v1);
-					t.vertexUV(cx+hx, cy-hy, blitOffset, u1, v0);
+					t.vertexUV(cx+hx, cy-hy, blitOffset, u1, v0);
-				}
+				}
-			} else {
+			} else {
-				t.vertexUV(cx-hx, cy-hy, blitOffset, 0, 0);
+				t.vertexUV(cx-hx, cy-hy, blitOffset, 0, 0);
-				t.vertexUV(cx-hx, cy+hy, blitOffset, 0, 1);
+				t.vertexUV(cx-hx, cy+hy, blitOffset, 0, 1);
-				t.vertexUV(cx+hx, cy+hy, blitOffset, 1, 1);
+				t.vertexUV(cx+hx, cy+hy, blitOffset, 1, 1);
-				t.vertexUV(cx+hx, cy-hy, blitOffset, 1, 0);
+				t.vertexUV(cx+hx, cy-hy, blitOffset, 1, 0);
-			}
+			}
-		t.draw();
+		t.draw();
-	}
+	}
-	//blit(0, 0, 0, 0, 64, 64, 256, 256);
+	//blit(0, 0, 0, 0, 64, 64, 256, 256);
-
+
-	//LOGI("%d %d\n", x+d.x, x+d.x+d.w);
+	//LOGI("%d %d\n", x+d.x, x+d.x+d.w);
-
+
-	if (!active) {
+	if (!active) {
-		drawCenteredString(font, msg, x + width / 2, y + 11/*(h - 16)*/, 0xffa0a0a0);
+		drawCenteredString(font, msg, x + width / 2, y + 11/*(h - 16)*/, 0xffa0a0a0);
-	} else {
+	} else {
-		if (hovered || selected) {
+		if (hovered || selected) {
-			drawCenteredString(font, msg, x + width / 2, y + 11/*(h - 16)*/, 0xffffa0);
+			drawCenteredString(font, msg, x + width / 2, y + 11/*(h - 16)*/, 0xffffa0);
-		} else {
+		} else {
-			drawCenteredString(font, msg, x + width / 2, y + 11/*(h - 48)*/, 0xe0e0e0);
+			drawCenteredString(font, msg, x + width / 2, y + 11/*(h - 48)*/, 0xe0e0e0);
-		}
+		}
-	}
+	}
-}
+}

src/client/gui/components/LargeImageButton.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "ImageButton.h"
+#include "ImageButton.hpp"
 
 class LargeImageButton: public ImageButton
 {

src/client/gui/components/NinePatch.cpp

@@ -1,141 +1,141 @@
-#include "NinePatch.h"
+#include "NinePatch.hpp"
-
+
-NinePatchDescription::NinePatchDescription( float x, float y, float x1, float x2, float x3, float y1, float y2, float y3, float w, float e, float n, float s ) :   u0(x), u1(x + x1), u2(x + x2), u3(x + x3),
+NinePatchDescription::NinePatchDescription( float x, float y, float x1, float x2, float x3, float y1, float y2, float y3, float w, float e, float n, float s ) :   u0(x), u1(x + x1), u2(x + x2), u3(x + x3),
-	v0(y), v1(y + y1), v2(y + y2), v3(y + y3),
+	v0(y), v1(y + y1), v2(y + y2), v3(y + y3),
-	w(w), e(e), n(n), s(s),
+	w(w), e(e), n(n), s(s),
-	imgW(-1),
+	imgW(-1),
-	imgH(-1) {
+	imgH(-1) {
-
+
-}
+}
-
+
-NinePatchDescription& NinePatchDescription::transformUVForImage( const TextureData& d ) {
+NinePatchDescription& NinePatchDescription::transformUVForImage( const TextureData& d ) {
-	return transformUVForImageSize(d.w, d.h);
+	return transformUVForImageSize(d.w, d.h);
-}
+}
-
+
-NinePatchDescription& NinePatchDescription::transformUVForImageSize( int w, int h ) {
+NinePatchDescription& NinePatchDescription::transformUVForImageSize( int w, int h ) {
-	if (imgW < 0)
+	if (imgW < 0)
-		imgW = imgH = 1;
+		imgW = imgH = 1;
-
+
-	const float us = (float) imgW / w; // @todo: prepare for normal blit? (e.g. mult by 256)
+	const float us = (float) imgW / w; // @todo: prepare for normal blit? (e.g. mult by 256)
-	const float vs = (float) imgH / h;
+	const float vs = (float) imgH / h;
-	u0 *= us; u1 *= us; u2 *= us; u3 *= us;
+	u0 *= us; u1 *= us; u2 *= us; u3 *= us;
-	v0 *= vs; v1 *= vs; v2 *= vs; v3 *= vs;
+	v0 *= vs; v1 *= vs; v2 *= vs; v3 *= vs;
-
+
-	imgW = w;
+	imgW = w;
-	imgH = h;
+	imgH = h;
-
+
-	return *this;
+	return *this;
-}
+}
-
+
-NinePatchDescription NinePatchDescription::createSymmetrical( int texWidth, int texHeight, const IntRectangle& src, int xCutAt, int yCutAt ) {
+NinePatchDescription NinePatchDescription::createSymmetrical( int texWidth, int texHeight, const IntRectangle& src, int xCutAt, int yCutAt ) {
-	NinePatchDescription patch((float)src.x, (float)src.y,// width and height of src
+	NinePatchDescription patch((float)src.x, (float)src.y,// width and height of src
-		(float)xCutAt, (float)(src.w-xCutAt), (float)src.w,		// u tex coordinates
+		(float)xCutAt, (float)(src.w-xCutAt), (float)src.w,		// u tex coordinates
-		(float)yCutAt, (float)(src.h-yCutAt), (float)src.h,		// v tex coordinates
+		(float)yCutAt, (float)(src.h-yCutAt), (float)src.h,		// v tex coordinates
-		(float)xCutAt, (float)xCutAt, (float)yCutAt, (float)yCutAt);	// border width and heights
+		(float)xCutAt, (float)xCutAt, (float)yCutAt, (float)yCutAt);	// border width and heights
-	if (texWidth > 0) patch.transformUVForImageSize(texWidth, texHeight);
+	if (texWidth > 0) patch.transformUVForImageSize(texWidth, texHeight);
-	return patch;
+	return patch;
-}
+}
-
+
-NinePatchLayer::NinePatchLayer(const NinePatchDescription& desc, const std::string& imageName, Textures* textures, float w, float h)
+NinePatchLayer::NinePatchLayer(const NinePatchDescription& desc, const std::string& imageName, Textures* textures, float w, float h)
-	:	desc(desc),
+	:	desc(desc),
-	imageName(imageName),
+	imageName(imageName),
-	textures(textures),
+	textures(textures),
-	w(-1), h(-1),
+	w(-1), h(-1),
-	excluded(0)
+	excluded(0)
-{
+{
-	setSize(w, h);
+	setSize(w, h);
-}
+}
-
+
-void NinePatchLayer::setSize( float w, float h ) {
+void NinePatchLayer::setSize( float w, float h ) {
-	if (w == this->w && h == this->h)
+	if (w == this->w && h == this->h)
-		return;
+		return;
-
+
-	this->w = w;
+	this->w = w;
-	this->h = h;
+	this->h = h;
-
+
-	for (int i = 0; i < 9; ++i)
+	for (int i = 0; i < 9; ++i)
-		buildQuad(i);
+		buildQuad(i);
-}
+}
-
+
-void NinePatchLayer::draw( Tesselator& t, float x, float y ) {
+void NinePatchLayer::draw( Tesselator& t, float x, float y ) {
-	textures->loadAndBindTexture(imageName);
+	textures->loadAndBindTexture(imageName);
-	t.begin();
+	t.begin();
-	t.addOffset(x, y, 0);
+	t.addOffset(x, y, 0);
-	for (int i = 0, b = 1; i < 9; ++i, b += b)
+	for (int i = 0, b = 1; i < 9; ++i, b += b)
-		if ((b & excluded) == 0)
+		if ((b & excluded) == 0)
-			d(t, quads[i]);
+			d(t, quads[i]);
-	t.addOffset(-x, -y, 0);
+	t.addOffset(-x, -y, 0);
-	t.draw();
+	t.draw();
-}
+}
-
+
-NinePatchLayer* NinePatchLayer::exclude( int excludeId ) {
+NinePatchLayer* NinePatchLayer::exclude( int excludeId ) {
-	return setExcluded(excluded | (1 << excludeId));
+	return setExcluded(excluded | (1 << excludeId));
-}
+}
-
+
-NinePatchLayer* NinePatchLayer::setExcluded( int exludeBits ) {
+NinePatchLayer* NinePatchLayer::setExcluded( int exludeBits ) {
-	excluded = exludeBits;
+	excluded = exludeBits;
-	return this;
+	return this;
-}
+}
-
+
-void NinePatchLayer::buildQuad( int qid ) {
+void NinePatchLayer::buildQuad( int qid ) {
-	//@attn; fix
+	//@attn; fix
-	CachedQuad& q = quads[qid];
+	CachedQuad& q = quads[qid];
-	const int yid = qid / 3;
+	const int yid = qid / 3;
-	const int xid = qid - 3 * yid;
+	const int xid = qid - 3 * yid;
-	q.u0 = (&desc.u0)[xid];
+	q.u0 = (&desc.u0)[xid];
-	q.u1 = (&desc.u0)[xid + 1];
+	q.u1 = (&desc.u0)[xid + 1];
-	q.v0 = (&desc.v0)[yid];
+	q.v0 = (&desc.v0)[yid];
-	q.v1 = (&desc.v0)[yid + 1];
+	q.v1 = (&desc.v0)[yid + 1];
-	q.z = 0;
+	q.z = 0;
-	getPatchInfo(xid, yid, q.x0, q.x1, q.y0, q.y1);
+	getPatchInfo(xid, yid, q.x0, q.x1, q.y0, q.y1);
-	/*		q.x0 = w * (q.u0 - desc.u0);
+	/*		q.x0 = w * (q.u0 - desc.u0);
-	q.y0 = h * (q.v0 - desc.v0);
+	q.y0 = h * (q.v0 - desc.v0);
-	q.x1 = w * (q.u1 - desc.u0);
+	q.x1 = w * (q.u1 - desc.u0);
-	q.y1 = h * (q.v1 - desc.v0);
+	q.y1 = h * (q.v1 - desc.v0);
-	*/
+	*/
-}
+}
-
+
-void NinePatchLayer::getPatchInfo( int xc, int yc, float& x0, float& x1, float& y0, float& y1 ) {
+void NinePatchLayer::getPatchInfo( int xc, int yc, float& x0, float& x1, float& y0, float& y1 ) {
-	if		(xc == 0) { x0 = 0; x1 = desc.w; }
+	if		(xc == 0) { x0 = 0; x1 = desc.w; }
-	else if (xc == 1) { x0 = desc.w; x1 = w - desc.e; }
+	else if (xc == 1) { x0 = desc.w; x1 = w - desc.e; }
-	else if (xc == 2) { x0 = w-desc.e; x1 = w; }
+	else if (xc == 2) { x0 = w-desc.e; x1 = w; }
-	if      (yc == 0) { y0 = 0; y1 = desc.n; }
+	if      (yc == 0) { y0 = 0; y1 = desc.n; }
-	else if (yc == 1) { y0 = desc.n; y1 = h - desc.s; }
+	else if (yc == 1) { y0 = desc.n; y1 = h - desc.s; }
-	else if (yc == 2) { y0 = h-desc.s; y1 = h; }
+	else if (yc == 2) { y0 = h-desc.s; y1 = h; }
-}
+}
-
+
-void NinePatchLayer::d( Tesselator& t, const CachedQuad& q ) {
+void NinePatchLayer::d( Tesselator& t, const CachedQuad& q ) {
-	/*
+	/*
-	t.vertexUV(x    , y + h, blitOffset, (float)(sx    ), (float)(sy + sh));
+	t.vertexUV(x    , y + h, blitOffset, (float)(sx    ), (float)(sy + sh));
-	t.vertexUV(x + w, y + h, blitOffset, (float)(sx + sw), (float)(sy + sh));
+	t.vertexUV(x + w, y + h, blitOffset, (float)(sx + sw), (float)(sy + sh));
-	t.vertexUV(x + w, y    , blitOffset, (float)(sx + sw), (float)(sy    ));
+	t.vertexUV(x + w, y    , blitOffset, (float)(sx + sw), (float)(sy    ));
-	t.vertexUV(x    , y    , blitOffset, (float)(sx    ), (float)(sy    ));
+	t.vertexUV(x    , y    , blitOffset, (float)(sx    ), (float)(sy    ));
-	*/
+	*/
-
+
-	t.vertexUV(q.x0, q.y1, q.z, q.u0, q.v1);
+	t.vertexUV(q.x0, q.y1, q.z, q.u0, q.v1);
-	t.vertexUV(q.x1, q.y1, q.z, q.u1, q.v1);
+	t.vertexUV(q.x1, q.y1, q.z, q.u1, q.v1);
-	t.vertexUV(q.x1, q.y0, q.z, q.u1, q.v0);
+	t.vertexUV(q.x1, q.y0, q.z, q.u1, q.v0);
-	t.vertexUV(q.x0, q.y0, q.z, q.u0, q.v0);
+	t.vertexUV(q.x0, q.y0, q.z, q.u0, q.v0);
-}
+}
-
+
-NinePatchFactory::NinePatchFactory( Textures* textures, const std::string& imageName ) :	textures(textures),
+NinePatchFactory::NinePatchFactory( Textures* textures, const std::string& imageName ) :	textures(textures),
-	imageName(imageName),
+	imageName(imageName),
-	width(1),
+	width(1),
-	height(1) {
+	height(1) {
-		TextureId id = textures->loadTexture(imageName);
+		TextureId id = textures->loadTexture(imageName);
-		if (id != Textures::InvalidId) {
+		if (id != Textures::InvalidId) {
-			const TextureData* data = textures->getTemporaryTextureData(id);
+			const TextureData* data = textures->getTemporaryTextureData(id);
-			if (data) { // This should never be false
+			if (data) { // This should never be false
-				width = data->w;
+				width = data->w;
-				height = data->h;
+				height = data->h;
-			}
+			}
-		} else {
+		} else {
-			LOGE("Error @ NinePatchFactory::ctor - Couldn't find texture: %s\n", imageName.c_str());
+			LOGE("Error @ NinePatchFactory::ctor - Couldn't find texture: %s\n", imageName.c_str());
-		}
+		}
-}
+}
-
+
-NinePatchLayer* NinePatchFactory::createSymmetrical( const IntRectangle& src, int xCutAt, int yCutAt, float w /*= 32.0f*/, float h /*= 32.0f*/ ) {
+NinePatchLayer* NinePatchFactory::createSymmetrical( const IntRectangle& src, int xCutAt, int yCutAt, float w /*= 32.0f*/, float h /*= 32.0f*/ ) {
-	return new NinePatchLayer(
+	return new NinePatchLayer(
-		NinePatchDescription::createSymmetrical(width, height, src, xCutAt, yCutAt),
+		NinePatchDescription::createSymmetrical(width, height, src, xCutAt, yCutAt),
-		imageName, textures, w, h);
+		imageName, textures, w, h);
-}
+}

src/client/gui/components/NinePatch.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "ImageButton.h"
+#include "ImageButton.hpp"
-#include "../../renderer/TextureData.h"
+#include "client/renderer/TextureData.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
 
 class Tesselator;
 

src/client/gui/components/OptionsGroup.cpp

@@ -1,115 +1,115 @@
-#include "OptionsGroup.h"
+#include "OptionsGroup.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "ImageButton.h"
+#include "ImageButton.hpp"
-#include "OptionsItem.h"
+#include "OptionsItem.hpp"
-#include "Slider.h"
+#include "Slider.hpp"
-#include "../../../locale/I18n.h"
+#include "locale/I18n.hpp"
-#include "TextOption.h"
+#include "TextOption.hpp"
-#include "KeyOption.h"
+#include "KeyOption.hpp"
-
+
-OptionsGroup::OptionsGroup( std::string labelID )  {
+OptionsGroup::OptionsGroup( std::string labelID )  {
-	label = I18n::get(labelID);
+	label = I18n::get(labelID);
-}
+}
-
+
-void OptionsGroup::setupPositions() {
+void OptionsGroup::setupPositions() {
-	// First we write the header and then we add the items
+	// First we write the header and then we add the items
-	int curY = y + 18;
+	int curY = y + 18;
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->width = width - 5;
+		(*it)->width = width - 5;
-		
+		
-		(*it)->y = curY;
+		(*it)->y = curY;
-		(*it)->x = x + 10;
+		(*it)->x = x + 10;
-		(*it)->setupPositions();
+		(*it)->setupPositions();
-		curY += (*it)->height + 3;
+		curY += (*it)->height + 3;
-	}
+	}
-	height = curY;
+	height = curY;
-}
+}
-
+
-void OptionsGroup::render( Minecraft* minecraft, int xm, int ym ) {
+void OptionsGroup::render( Minecraft* minecraft, int xm, int ym ) {
-	float padX = 10.0f;
+	float padX = 10.0f;
-	float padY = 5.0f;
+	float padY = 5.0f;
-	
+	
-	minecraft->font->draw(label, (float)x + padX, (float)y + padY, 0xffffffff, false);
+	minecraft->font->draw(label, (float)x + padX, (float)y + padY, 0xffffffff, false);
-
+
-	super::render(minecraft, xm, ym);
+	super::render(minecraft, xm, ym);
-}
+}
-
+
-OptionsGroup& OptionsGroup::addOptionItem(OptionId optId, Minecraft* minecraft ) {
+OptionsGroup& OptionsGroup::addOptionItem(OptionId optId, Minecraft* minecraft ) {
-	auto option = minecraft->options.getOpt(optId);
+	auto option = minecraft->options.getOpt(optId);
-
+
-	if (option == nullptr) return *this;
+	if (option == nullptr) return *this;
-
+
-	// TODO: do a options key class to check it faster via dynamic_cast
+	// TODO: do a options key class to check it faster via dynamic_cast
-	if (option->getStringId().find("options.key") != std::string::npos) createKey(optId, minecraft);
+	if (option->getStringId().find("options.key") != std::string::npos) createKey(optId, minecraft);
-	else if (dynamic_cast<OptionBool*>(option)) createToggle(optId, minecraft);
+	else if (dynamic_cast<OptionBool*>(option)) createToggle(optId, minecraft);
-	else if (dynamic_cast<OptionFloat*>(option)) createProgressSlider(optId, minecraft);
+	else if (dynamic_cast<OptionFloat*>(option)) createProgressSlider(optId, minecraft);
-	else if (dynamic_cast<OptionInt*>(option)) createStepSlider(optId, minecraft);
+	else if (dynamic_cast<OptionInt*>(option)) createStepSlider(optId, minecraft);
-	else if (dynamic_cast<OptionString*>(option)) createTextbox(optId, minecraft);
+	else if (dynamic_cast<OptionString*>(option)) createTextbox(optId, minecraft);
-
+
-	return *this;
+	return *this;
-}
+}
-
+
-// TODO: wrap this copypaste shit into templates
+// TODO: wrap this copypaste shit into templates
-
+
-void OptionsGroup::createToggle(OptionId optId, Minecraft* minecraft ) {
+void OptionsGroup::createToggle(OptionId optId, Minecraft* minecraft ) {
-	ImageDef def;
+	ImageDef def;
-
+
-	def.setSrc(IntRectangle(160, 206, 39, 20));
+	def.setSrc(IntRectangle(160, 206, 39, 20));
-	def.name = "gui/touchgui.png";
+	def.name = "gui/touchgui.png";
-	def.width = 39 * 0.7f;
+	def.width = 39 * 0.7f;
-	def.height = 20 * 0.7f;
+	def.height = 20 * 0.7f;
-	
+	
-	OptionButton* element = new OptionButton(optId);
+	OptionButton* element = new OptionButton(optId);
-	element->setImageDef(def, true);
+	element->setImageDef(def, true);
-	element->updateImage(&minecraft->options);
+	element->updateImage(&minecraft->options);
-	
+	
-	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
+	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	
+	
-	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
-	
+	
-	addChild(item);
+	addChild(item);
-	setupPositions();
+	setupPositions();
-}
+}
-
+
-void OptionsGroup::createProgressSlider(OptionId optId, Minecraft* minecraft ) {
+void OptionsGroup::createProgressSlider(OptionId optId, Minecraft* minecraft ) {
-	Slider* element = new SliderFloat(minecraft, optId);
+	Slider* element = new SliderFloat(minecraft, optId);
-	element->width = 100;
+	element->width = 100;
-	element->height = 20;
+	element->height = 20;
-
+
-	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
+	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
-	addChild(item);
+	addChild(item);
-	setupPositions();
+	setupPositions();
-}
+}
-
+
-void OptionsGroup::createStepSlider(OptionId optId, Minecraft* minecraft ) {
+void OptionsGroup::createStepSlider(OptionId optId, Minecraft* minecraft ) {
-	Slider* element = new SliderInt(minecraft, optId);
+	Slider* element = new SliderInt(minecraft, optId);
-	element->width = 100;
+	element->width = 100;
-	element->height = 20;
+	element->height = 20;
-	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
+	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
-	addChild(item);
+	addChild(item);
-	setupPositions();
+	setupPositions();
-}
+}
-
+
-void OptionsGroup::createTextbox(OptionId optId, Minecraft* minecraft) {
+void OptionsGroup::createTextbox(OptionId optId, Minecraft* minecraft) {
-	TextBox* element = new TextOption(minecraft, optId);
+	TextBox* element = new TextOption(minecraft, optId);
-	element->width = 100;
+	element->width = 100;
-	element->height = 20;
+	element->height = 20;
-
+
-	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
+	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
-	addChild(item);
+	addChild(item);
-	setupPositions();
+	setupPositions();
-}
+}
-
+
-void OptionsGroup::createKey(OptionId optId, Minecraft* minecraft) {
+void OptionsGroup::createKey(OptionId optId, Minecraft* minecraft) {
-	KeyOption* element = new KeyOption(minecraft, optId);
+	KeyOption* element = new KeyOption(minecraft, optId);
-	element->width = 50;
+	element->width = 50;
-	element->height = 20;
+	element->height = 20;
-
+
-	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
+	std::string itemLabel = I18n::get(minecraft->options.getOpt(optId)->getStringId());
-	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
+	OptionsItem* item = new OptionsItem(optId, itemLabel, element);
-	addChild(item);
+	addChild(item);
-	setupPositions();
+	setupPositions();
 }

src/client/gui/components/OptionsGroup.hpp

@@ -3,9 +3,9 @@
 //package net.minecraft.client.gui;
 
 #include <string>
-#include "GuiElementContainer.h"
+#include "GuiElementContainer.hpp"
-#include "ScrollingPane.h"
+#include "ScrollingPane.hpp"
-#include "../../Options.h"
+#include "client/Options.hpp"
 
 class Font;
 class Minecraft;

src/client/gui/components/OptionsItem.cpp

@@ -1,42 +1,42 @@
-#include "OptionsItem.h"
+#include "OptionsItem.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../../locale/I18n.h"
+#include "locale/I18n.hpp"
-#include "../../../util/Mth.h"
+#include "util/Mth.hpp"
-OptionsItem::OptionsItem( OptionId optionId, std::string label, GuiElement* element )
+OptionsItem::OptionsItem( OptionId optionId, std::string label, GuiElement* element )
-: GuiElementContainer(false, true, 0, 0, 24, 12),
+: GuiElementContainer(false, true, 0, 0, 24, 12),
-  m_optionId(optionId),
+  m_optionId(optionId),
-  m_label(label) {
+  m_label(label) {
-	  addChild(element);
+	  addChild(element);
-}
+}
-
+
-void OptionsItem::setupPositions() {
+void OptionsItem::setupPositions() {
-	int currentHeight = 0;
+	int currentHeight = 0;
-	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
+	for(std::vector<GuiElement*>::iterator it = children.begin(); it != children.end(); ++it) {
-		(*it)->x = x + width - (*it)->width - 15;
+		(*it)->x = x + width - (*it)->width - 15;
-		(*it)->y = y + currentHeight;
+		(*it)->y = y + currentHeight;
-		currentHeight += (*it)->height;
+		currentHeight += (*it)->height;
-	}
+	}
-	height = currentHeight;
+	height = currentHeight;
-}
+}
-
+
-void OptionsItem::render( Minecraft* minecraft, int xm, int ym ) {
+void OptionsItem::render( Minecraft* minecraft, int xm, int ym ) {
-	int yOffset = (height - 8) / 2;
+	int yOffset = (height - 8) / 2;
-	std::string text = m_label;
+	std::string text = m_label;
-	if (m_optionId == OPTIONS_GUI_SCALE) {
+	if (m_optionId == OPTIONS_GUI_SCALE) {
-		int value = minecraft->options.getIntValue(OPTIONS_GUI_SCALE);
+		int value = minecraft->options.getIntValue(OPTIONS_GUI_SCALE);
-		std::string scaleText;
+		std::string scaleText;
-		switch (value) {
+		switch (value) {
-		case 0: scaleText = I18n::get("options.guiScale.auto"); break;
+		case 0: scaleText = I18n::get("options.guiScale.auto"); break;
-		case 1: scaleText = I18n::get("options.guiScale.small"); break;
+		case 1: scaleText = I18n::get("options.guiScale.small"); break;
-		case 2: scaleText = I18n::get("options.guiScale.medium"); break;
+		case 2: scaleText = I18n::get("options.guiScale.medium"); break;
-		case 3: scaleText = I18n::get("options.guiScale.large"); break;
+		case 3: scaleText = I18n::get("options.guiScale.large"); break;
-		case 4: scaleText = I18n::get("options.guiScale.larger"); break;
+		case 4: scaleText = I18n::get("options.guiScale.larger"); break;
-		case 5: scaleText = I18n::get("options.guiScale.largest"); break;
+		case 5: scaleText = I18n::get("options.guiScale.largest"); break;
-		default: scaleText = I18n::get("options.guiScale.auto"); break;
+		default: scaleText = I18n::get("options.guiScale.auto"); break;
-		}
+		}
-		text += ": " + scaleText;
+		text += ": " + scaleText;
-	}
+	}
-
+
-	minecraft->font->draw(text, (float)x, (float)y + yOffset, 0x909090, false);
+	minecraft->font->draw(text, (float)x, (float)y + yOffset, 0x909090, false);
-	super::render(minecraft, xm, ym);
+	super::render(minecraft, xm, ym);
 }

src/client/gui/components/OptionsItem.hpp

@@ -2,9 +2,9 @@
 
 #include <string>
 #include <vector>
-#include "GuiElementContainer.h"
+#include "GuiElementContainer.hpp"
-#include "../../../world/item/ItemInstance.h"
+#include "world/item/ItemInstance.hpp"
-#include "../../../client/Options.h"
+#include "client/Options.hpp"
 class Font; 
 class Textures;
 class NinePatchLayer;

src/client/gui/components/RolledSelectionListH.cpp

@@ -1,299 +1,299 @@
-#include "RolledSelectionListH.h"
+#include "RolledSelectionListH.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../renderer/gles.h"
+#include "client/renderer/gles.hpp"
-#include "../../../platform/input/Mouse.h"
+#include "platform/input/Mouse.hpp"
-#include "../../../platform/input/Multitouch.h"
+#include "platform/input/Multitouch.hpp"
-#include "../../../util/Mth.h"
+#include "util/Mth.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-#include "MinecraftClient.h"
+#include "MinecraftClient.hpp"
-
+
-
+
-RolledSelectionListH::RolledSelectionListH( MinecraftClient& minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth )
+RolledSelectionListH::RolledSelectionListH( MinecraftClient& minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth )
-:	minecraft(minecraft),
+:	minecraft(minecraft),
-	width(width),
+	width(width),
-	height(height),
+	height(height),
-	x0((float)x0),
+	x0((float)x0),
-	x1((float)x1),
+	x1((float)x1),
-	y0((float)y0),
+	y0((float)y0),
-	y1((float)y1),
+	y1((float)y1),
-	itemWidth(itemWidth),
+	itemWidth(itemWidth),
-	selectionX(-1),
+	selectionX(-1),
-	lastSelectionTime(0),
+	lastSelectionTime(0),
-	lastSelection(-1),
+	lastSelection(-1),
-	renderSelection(true),
+	renderSelection(true),
-	doRenderHeader(false),
+	doRenderHeader(false),
-	headerWidth(0),
+	headerWidth(0),
-	dragState(DRAG_OUTSIDE),
+	dragState(DRAG_OUTSIDE),
-	xDrag(0.0f),
+	xDrag(0.0f),
-	xo(0.0f),
+	xo(0.0f),
-	xoo(0.0f),
+	xoo(0.0f),
-	xInertia(0.0f),
+	xInertia(0.0f),
-	_componentSelected(false),
+	_componentSelected(false),
-	_renderTopBorder(true),
+	_renderTopBorder(true),
-	_renderBottomBorder(true),
+	_renderBottomBorder(true),
-	_lastxoo(0),
+	_lastxoo(0),
-	_xinertia(0)
+	_xinertia(0)
-{
+{
-	xo = xoo = (float)(itemWidth-width) * 0.5f;
+	xo = xoo = (float)(itemWidth-width) * 0.5f;
-	_lastxoo = xoo;
+	_lastxoo = xoo;
-}
+}
-
+
-void RolledSelectionListH::setRenderSelection( bool _renderSelection )
+void RolledSelectionListH::setRenderSelection( bool _renderSelection )
-{
+{
-	renderSelection = _renderSelection;
+	renderSelection = _renderSelection;
-}
+}
-
+
-void RolledSelectionListH::setComponentSelected(bool selected) {
+void RolledSelectionListH::setComponentSelected(bool selected) {
-	_componentSelected = selected;
+	_componentSelected = selected;
-}
+}
-
+
-void RolledSelectionListH::setRenderHeader( bool _renderHeader, int _headerHeight )
+void RolledSelectionListH::setRenderHeader( bool _renderHeader, int _headerHeight )
-{
+{
-	doRenderHeader = _renderHeader;
+	doRenderHeader = _renderHeader;
-	headerWidth = _headerHeight;
+	headerWidth = _headerHeight;
-
+
-	if (!doRenderHeader) {
+	if (!doRenderHeader) {
-		headerWidth = 0;
+		headerWidth = 0;
-	}
+	}
-}
+}
-
+
-int RolledSelectionListH::getMaxPosition()
+int RolledSelectionListH::getMaxPosition()
-{
+{
-	return getNumberOfItems() * itemWidth + headerWidth;
+	return getNumberOfItems() * itemWidth + headerWidth;
-}
+}
-
+
-int RolledSelectionListH::getItemAtPosition( int x, int y )
+int RolledSelectionListH::getItemAtPosition( int x, int y )
-{
+{
-	int clickSlotPos = (int)(x - x0 - headerWidth + (int) xo - 4);
+	int clickSlotPos = (int)(x - x0 - headerWidth + (int) xo - 4);
-	int isInsideY = y >= y0 && y <= y1;
+	int isInsideY = y >= y0 && y <= y1;
-	return isInsideY? getItemAtXPositionRaw(clickSlotPos) : -1;
+	return isInsideY? getItemAtXPositionRaw(clickSlotPos) : -1;
-}
+}
-
+
-int RolledSelectionListH::getItemAtXPositionRaw(int x) {
+int RolledSelectionListH::getItemAtXPositionRaw(int x) {
-	int slot = x / itemWidth;
+	int slot = x / itemWidth;
-	bool isInsideX = slot >= 0 && x >= 0 && slot < getNumberOfItems();
+	bool isInsideX = slot >= 0 && x >= 0 && slot < getNumberOfItems();
-	return isInsideX? slot : -1;
+	return isInsideX? slot : -1;
-}
+}
-
+
-bool RolledSelectionListH::capXPosition()
+bool RolledSelectionListH::capXPosition()
-{
+{
-	const float MinX = (float)(itemWidth-width)/2;
+	const float MinX = (float)(itemWidth-width)/2;
-	const float MaxX = MinX + (getNumberOfItems()-1) * itemWidth;
+	const float MaxX = MinX + (getNumberOfItems()-1) * itemWidth;
-	if (xo < MinX) { xo = MinX; xInertia = 0; return true; }
+	if (xo < MinX) { xo = MinX; xInertia = 0; return true; }
-	if (xo > MaxX) { xo = MaxX; xInertia = 0; return true; }
+	if (xo > MaxX) { xo = MaxX; xInertia = 0; return true; }
-	return false;
+	return false;
-}
+}
-
+
-void RolledSelectionListH::tick() {
+void RolledSelectionListH::tick() {
-
+
-	//if (Mouse::isButtonDown(MouseAction::ACTION_LEFT))
+	//if (Mouse::isButtonDown(MouseAction::ACTION_LEFT))
-	{
+	{
-		_xinertia = _lastxoo - xoo;
+		_xinertia = _lastxoo - xoo;
-	}
+	}
-	_lastxoo = xoo;
+	_lastxoo = xoo;
-	xoo = xo - xInertia;
+	xoo = xo - xInertia;
-}
+}
-
+
-float RolledSelectionListH::getPos(float alpha) {
+float RolledSelectionListH::getPos(float alpha) {
-	return xoo - xInertia * alpha;
+	return xoo - xInertia * alpha;
-}
+}
-
+
-void RolledSelectionListH::render( int xm, int ym, float a )
+void RolledSelectionListH::render( int xm, int ym, float a )
-{
+{
-	renderBackground();
+	renderBackground();
-
+
-	int itemCount = getNumberOfItems();
+	int itemCount = getNumberOfItems();
-
+
-	//float yy0 = height / 2.0f + 124;
+	//float yy0 = height / 2.0f + 124;
-	//float yy1 = yy0 + 6;
+	//float yy1 = yy0 + 6;
-
+
-	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT)) {
+	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT)) {
-		touched();
+		touched();
-		//LOGI("DOWN ym: %d\n", ym);
+		//LOGI("DOWN ym: %d\n", ym);
-		if (ym >= y0 && ym <= y1) {
+		if (ym >= y0 && ym <= y1) {
-			if (dragState == NO_DRAG) {
+			if (dragState == NO_DRAG) {
-				lastSelectionTime = getTimeMs();
+				lastSelectionTime = getTimeMs();
-				lastSelection = getItemAtPosition(xm, height/2);
+				lastSelection = getItemAtPosition(xm, height/2);
-				//float localX = (float)(xm*Gui::InvGuiScale - x0 - xo + lastSelection * itemWidth + headerWidth);
+				//float localX = (float)(xm*Gui::InvGuiScale - x0 - xo + lastSelection * itemWidth + headerWidth);
-				selectStart(lastSelection, 0, 0);//localX, ym-y0);
+				selectStart(lastSelection, 0, 0);//localX, ym-y0);
-				selectionX = xm;
+				selectionX = xm;
-			} 
+			} 
-			else if (dragState >= 0) {
+			else if (dragState >= 0) {
-				xo -= (xm - xDrag);
+				xo -= (xm - xDrag);
-				xoo = xo;
+				xoo = xo;
-			}
+			}
-			dragState = DRAG_NORMAL;
+			dragState = DRAG_NORMAL;
-			//const int* ids;
+			//const int* ids;
-			//LOGI("mtouch: %d\n", Multitouch::getActivePointerIds(&ids));
+			//LOGI("mtouch: %d\n", Multitouch::getActivePointerIds(&ids));
-		}
+		}
-	} else {
+	} else {
-		if (dragState >= 0) {
+		if (dragState >= 0) {
-			if (dragState >= 0) {
+			if (dragState >= 0) {
-				xInertia = _xinertia < 0? Mth::Max(-20.0f, _xinertia) : Mth::Min(20.0f, _xinertia);
+				xInertia = _xinertia < 0? Mth::Max(-20.0f, _xinertia) : Mth::Min(20.0f, _xinertia);
-			}
+			}
-			//LOGI("Inertia: %f. Time: %d, delta-x: %d, (xm, sel: %d, %d)\n", xInertia, getTimeMs() - lastSelectionTime, std::abs(selectionX - xm), xm, selectionX);
+			//LOGI("Inertia: %f. Time: %d, delta-x: %d, (xm, sel: %d, %d)\n", xInertia, getTimeMs() - lastSelectionTime, std::abs(selectionX - xm), xm, selectionX);
-			// kill small inertia values when releasing scrollist
+			// kill small inertia values when releasing scrollist
-			if (std::abs(xInertia) <= 2.0001f) {
+			if (std::abs(xInertia) <= 2.0001f) {
-				xInertia = 0.0f;
+				xInertia = 0.0f;
-			}
+			}
-
+
-			if (std::abs(xInertia) <= 10 && getTimeMs() - lastSelectionTime < 300)
+			if (std::abs(xInertia) <= 10 && getTimeMs() - lastSelectionTime < 300)
-			{
+			{
-				int slot = getItemAtPosition(xm, height/2);
+				int slot = getItemAtPosition(xm, height/2);
-				//LOGI("slot: %d, lt: %d. diff: %d - %d\n", slot, lastSelection, selectionX, xm);
+				//LOGI("slot: %d, lt: %d. diff: %d - %d\n", slot, lastSelection, selectionX, xm);
-				if (slot >= 0 && slot == lastSelection && std::abs(selectionX - xm) < 10)
+				if (slot >= 0 && slot == lastSelection && std::abs(selectionX - xm) < 10)
-					selectItem(slot, false);
+					selectItem(slot, false);
-				else
+				else
-					selectCancel();
+					selectCancel();
-			} else {
+			} else {
-				selectCancel();
+				selectCancel();
-			}
+			}
-		}
+		}
-
+
-		//	if (slot >= 0 && std::abs(selectionX - xm) < itemWidth)
+		//	if (slot >= 0 && std::abs(selectionX - xm) < itemWidth)
-		//	{
+		//	{
-		//		bool doubleClick = false;
+		//		bool doubleClick = false;
-		//		selectItem(slot, doubleClick);
+		//		selectItem(slot, doubleClick);
-		//		//xInertia = 0.0f;
+		//		//xInertia = 0.0f;
-		//	}
+		//	}
-		//}
+		//}
-		dragState = NO_DRAG;
+		dragState = NO_DRAG;
-
+
-		xo = getPos(a);
+		xo = getPos(a);
-	}
+	}
-	xDrag = (float)xm;
+	xDrag = (float)xm;
-
+
-	capXPosition();
+	capXPosition();
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-
+
-	float by0 = _renderTopBorder?    y0 : 0;
+	float by0 = _renderTopBorder?    y0 : 0;
-	float by1 = _renderBottomBorder? y1 : height;
+	float by1 = _renderBottomBorder? y1 : height;
-
+
-	//LOGI("x: %f\n", xo);
+	//LOGI("x: %f\n", xo);
-
+
-	minecraft.textures().loadAndBindTexture("gui/background.png");
+	minecraft.textures().loadAndBindTexture("gui/background.png");
-	glColor4f2(1.0f, 1, 1, 1);
+	glColor4f2(1.0f, 1, 1, 1);
-	float s = 32;
+	float s = 32;
-	t.begin();
+	t.begin();
-	t.color(0x202020);
+	t.color(0x202020);
-	t.vertexUV(x0, by1, 0, (x0 + (int) xo) / s, by1 / s);
+	t.vertexUV(x0, by1, 0, (x0 + (int) xo) / s, by1 / s);
-	t.vertexUV(x1, by1, 0, (x1 + (int) xo) / s, by1 / s);
+	t.vertexUV(x1, by1, 0, (x1 + (int) xo) / s, by1 / s);
-	t.vertexUV(x1, by0, 0, (x1 + (int) xo) / s, by0 / s);
+	t.vertexUV(x1, by0, 0, (x1 + (int) xo) / s, by0 / s);
-	t.vertexUV(x0, by0, 0, (x0 + (int) xo) / s, by0 / s);
+	t.vertexUV(x0, by0, 0, (x0 + (int) xo) / s, by0 / s);
-	t.draw();
+	t.draw();
-
+
-	const int HalfHeight = 48;
+	const int HalfHeight = 48;
-
+
-	if (getNumberOfItems() == 0) xo = 0;
+	if (getNumberOfItems() == 0) xo = 0;
-
+
-	int rowY = (int)(height / 2 - HalfHeight + 8);
+	int rowY = (int)(height / 2 - HalfHeight + 8);
-	int rowBaseX = (int)(x0 /*+ 4*/ - (int) xo);
+	int rowBaseX = (int)(x0 /*+ 4*/ - (int) xo);
-
+
-	if (doRenderHeader) {
+	if (doRenderHeader) {
-		renderHeader(rowBaseX, rowY, t);
+		renderHeader(rowBaseX, rowY, t);
-	}
+	}
-
+
-	for (int i = 0; i < itemCount; i++) {
+	for (int i = 0; i < itemCount; i++) {
-
+
-		float x = (float)(rowBaseX + (i) * itemWidth + headerWidth);
+		float x = (float)(rowBaseX + (i) * itemWidth + headerWidth);
-		float h = (float)itemWidth;
+		float h = (float)itemWidth;
-
+
-		if (x > x1 || (x + h) < x0) {
+		if (x > x1 || (x + h) < x0) {
-			continue;
+			continue;
-		}
+		}
-
+
-		if (renderSelection && isSelectedItem(i)) {
+		if (renderSelection && isSelectedItem(i)) {
-			float y0 = height / 2.0f - HalfHeight - 4; //@kindle-res:+2
+			float y0 = height / 2.0f - HalfHeight - 4; //@kindle-res:+2
-			float y1 = height / 2.0f + HalfHeight - 4; //@kindle-res:-6
+			float y1 = height / 2.0f + HalfHeight - 4; //@kindle-res:-6
-			glColor4f2(1, 1, 1, 1);
+			glColor4f2(1, 1, 1, 1);
-			glDisable2(GL_TEXTURE_2D);
+			glDisable2(GL_TEXTURE_2D);
-
+
-			int ew = 0;
+			int ew = 0;
-			int color = 0x808080;
+			int color = 0x808080;
-			if (_componentSelected) {
+			if (_componentSelected) {
-				ew = 0;
+				ew = 0;
-				color = 0x7F89BF;
+				color = 0x7F89BF;
-			}
+			}
-			t.begin();
+			t.begin();
-			t.color(color);
+			t.color(color);
-			t.vertex(x - 1 - ew, y0 - ew, 0);
+			t.vertex(x - 1 - ew, y0 - ew, 0);
-			t.vertex(x - 1 - ew, y1 + ew, 0);
+			t.vertex(x - 1 - ew, y1 + ew, 0);
-			t.vertex(x + h + 1 + ew, y1 + ew, 0);
+			t.vertex(x + h + 1 + ew, y1 + ew, 0);
-			t.vertex(x + h + 1 + ew, y0 - ew, 0);
+			t.vertex(x + h + 1 + ew, y0 - ew, 0);
-
+
-			t.color(0x000000);
+			t.color(0x000000);
-			t.vertex(x, y0 + 1,  0);
+			t.vertex(x, y0 + 1,  0);
-			t.vertex(x, y1 - 1,  0);
+			t.vertex(x, y1 - 1,  0);
-			t.vertex(x + h, y1 - 1, 0);
+			t.vertex(x + h, y1 - 1, 0);
-			t.vertex(x + h, y0 + 1, 0);
+			t.vertex(x + h, y0 + 1, 0);
-
+
-			t.draw();
+			t.draw();
-			glEnable2(GL_TEXTURE_2D);
+			glEnable2(GL_TEXTURE_2D);
-		}
+		}
-		renderItem(i, (int)x, rowY, (int)h, t);
+		renderItem(i, (int)x, rowY, (int)h, t);
-	}
+	}
-
+
-	glDisable2(GL_DEPTH_TEST);
+	glDisable2(GL_DEPTH_TEST);
-
+
-	if (_renderTopBorder)
+	if (_renderTopBorder)
-		renderHoleBackground(0, y0, 255, 255);
+		renderHoleBackground(0, y0, 255, 255);
-	if (_renderBottomBorder)
+	if (_renderBottomBorder)
-		renderHoleBackground(y1, (float)height, 255, 255);
+		renderHoleBackground(y1, (float)height, 255, 255);
-
+
-	//glEnable2(GL_BLEND);
+	//glEnable2(GL_BLEND);
-	//glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	//glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	//glDisable2(GL_ALPHA_TEST);
+	//glDisable2(GL_ALPHA_TEST);
-	//glShadeModel2(GL_SMOOTH);
+	//glShadeModel2(GL_SMOOTH);
-
+
-	//glDisable2(GL_TEXTURE_2D);
+	//glDisable2(GL_TEXTURE_2D);
-
+
-	//const int d = 4;
+	//const int d = 4;
-	//t.begin();
+	//t.begin();
-	//t.color(0x000000, 0);
+	//t.color(0x000000, 0);
-	//t.vertexUV(y0, x0 + d, 0, 0, 1);
+	//t.vertexUV(y0, x0 + d, 0, 0, 1);
-	//t.vertexUV(y1, x0 + d, 0, 1, 1);
+	//t.vertexUV(y1, x0 + d, 0, 1, 1);
-	//t.color(0x000000, 255);
+	//t.color(0x000000, 255);
-	//t.vertexUV(y1, x0, 0, 1, 0);
+	//t.vertexUV(y1, x0, 0, 1, 0);
-	//t.vertexUV(y0, x0, 0, 0, 0);
+	//t.vertexUV(y0, x0, 0, 0, 0);
-	//t.draw();
+	//t.draw();
-
+
-	//t.begin();
+	//t.begin();
-	//t.color(0x000000, 255);
+	//t.color(0x000000, 255);
-	//t.vertexUV(y0, x1, 0, 0, 1);
+	//t.vertexUV(y0, x1, 0, 0, 1);
-	//t.vertexUV(y1, x1, 0, 1, 1);
+	//t.vertexUV(y1, x1, 0, 1, 1);
-	//t.color(0x000000, 0);
+	//t.color(0x000000, 0);
-	//t.vertexUV(y1, x1 - d, 0, 1, 0);
+	//t.vertexUV(y1, x1 - d, 0, 1, 0);
-	//t.vertexUV(y0, x1 - d, 0, 0, 0);
+	//t.vertexUV(y0, x1 - d, 0, 0, 0);
-	//t.draw();
+	//t.draw();
-
+
-	//renderDecorations(xm, ym);
+	//renderDecorations(xm, ym);
-
+
-	//glEnable2(GL_TEXTURE_2D);
+	//glEnable2(GL_TEXTURE_2D);
-	glEnable2(GL_DEPTH_TEST);
+	glEnable2(GL_DEPTH_TEST);
-
+
-	//glShadeModel2(GL_FLAT);
+	//glShadeModel2(GL_FLAT);
-	//glEnable2(GL_ALPHA_TEST);
+	//glEnable2(GL_ALPHA_TEST);
-	//glDisable2(GL_BLEND);
+	//glDisable2(GL_BLEND);
-}
+}
-
+
-void RolledSelectionListH::renderHoleBackground( /*float x0, float x1,*/ float y0, float y1, int a0, int a1 )
+void RolledSelectionListH::renderHoleBackground( /*float x0, float x1,*/ float y0, float y1, int a0, int a1 )
-{
+{
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	minecraft.textures().loadAndBindTexture("gui/background.png");
+	minecraft.textures().loadAndBindTexture("gui/background.png");
-	glColor4f2(1.0f, 1, 1, 1);
+	glColor4f2(1.0f, 1, 1, 1);
-	float s = 32;
+	float s = 32;
-	t.begin();
+	t.begin();
-	t.color(0x505050, a1);
+	t.color(0x505050, a1);
-	t.vertexUV(0, y1, 0, 0, y1 / s);
+	t.vertexUV(0, y1, 0, 0, y1 / s);
-	t.vertexUV((float)width, y1, 0, width / s, y1 / s);
+	t.vertexUV((float)width, y1, 0, width / s, y1 / s);
-	t.color(0x505050, a0);
+	t.color(0x505050, a0);
-	t.vertexUV((float)width, y0, 0, width / s, y0 / s);
+	t.vertexUV((float)width, y0, 0, width / s, y0 / s);
-	t.vertexUV(0, y0, 0, 0, y0 / s);
+	t.vertexUV(0, y0, 0, 0, y0 / s);
-	t.draw();
+	t.draw();
-	//printf("x, y, x1, y1: %d, %d, %d, %d\n", 0, (int)y0, width, (int)y1);
+	//printf("x, y, x1, y1: %d, %d, %d, %d\n", 0, (int)y0, width, (int)y1);
-}
+}
-
+
-void RolledSelectionListH::touched()
+void RolledSelectionListH::touched()
-{
+{
-}
+}

src/client/gui/components/RolledSelectionListH.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../GuiComponent.h"
+#include "client/gui/GuiComponent.hpp"
 class MinecraftClient;
 class Tesselator;
 

src/client/gui/components/RolledSelectionListV.cpp

@@ -1,352 +1,352 @@
-#include "RolledSelectionListV.h"
+#include "RolledSelectionListV.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../renderer/gles.h"
+#include "client/renderer/gles.hpp"
-#include "../../../platform/input/Mouse.h"
+#include "platform/input/Mouse.hpp"
-#include "../../../util/Mth.h"
+#include "util/Mth.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-
+
-
+
-RolledSelectionListV::RolledSelectionListV( Minecraft* minecraft_, int width_, int height_, int x0_, int x1_, int y0_, int y1_, int itemHeight_ )
+RolledSelectionListV::RolledSelectionListV( Minecraft* minecraft_, int width_, int height_, int x0_, int x1_, int y0_, int y1_, int itemHeight_ )
-:	minecraft(minecraft_),
+:	minecraft(minecraft_),
-	width(width_),
+	width(width_),
-	height(height_),
+	height(height_),
-	x0((float)x0_),
+	x0((float)x0_),
-	x1((float)x1_),
+	x1((float)x1_),
-	y0((float)y0_),
+	y0((float)y0_),
-	y1((float)y1_),
+	y1((float)y1_),
-	itemHeight(itemHeight_),
+	itemHeight(itemHeight_),
-	selectionY(-1),
+	selectionY(-1),
-	lastSelectionTime(0),
+	lastSelectionTime(0),
-	lastSelection(-1),
+	lastSelection(-1),
-	renderSelection(true),
+	renderSelection(true),
-	doRenderHeader(false),
+	doRenderHeader(false),
-	headerHeight(0),
+	headerHeight(0),
-	dragState(DRAG_OUTSIDE),
+	dragState(DRAG_OUTSIDE),
-	yDrag(0.0f),
+	yDrag(0.0f),
-	yo(0.0f),
+	yo(0.0f),
-	yoo(0.0f),
+	yoo(0.0f),
-	yInertia(0.0f),
+	yInertia(0.0f),
-	_componentSelected(false),
+	_componentSelected(false),
-	_renderDirtBackground(true),
+	_renderDirtBackground(true),
-	_renderTopBorder(true),
+	_renderTopBorder(true),
-	_renderBottomBorder(true),
+	_renderBottomBorder(true),
-	_lastyoo(0),
+	_lastyoo(0),
-	_yinertia(0),
+	_yinertia(0),
-	_stickPixels(0),
+	_stickPixels(0),
-	_lastxm(0),
+	_lastxm(0),
-	_lastym(0)
+	_lastym(0)
-{
+{
-	yo = yoo = 0;//(float)(-itemHeight) * 0.5f;
+	yo = yoo = 0;//(float)(-itemHeight) * 0.5f;
-	_lastyoo = yoo;
+	_lastyoo = yoo;
-}
+}
-
+
-void RolledSelectionListV::setRenderSelection( bool _renderSelection )
+void RolledSelectionListV::setRenderSelection( bool _renderSelection )
-{
+{
-	renderSelection = _renderSelection;
+	renderSelection = _renderSelection;
-}
+}
-
+
-void RolledSelectionListV::setComponentSelected(bool selected) {
+void RolledSelectionListV::setComponentSelected(bool selected) {
-	_componentSelected = selected;
+	_componentSelected = selected;
-}
+}
-
+
-void RolledSelectionListV::setRenderHeader( bool _renderHeader, int _headerHeight )
+void RolledSelectionListV::setRenderHeader( bool _renderHeader, int _headerHeight )
-{
+{
-	doRenderHeader = _renderHeader;
+	doRenderHeader = _renderHeader;
-	headerHeight = _headerHeight;
+	headerHeight = _headerHeight;
-
+
-	if (!doRenderHeader) {
+	if (!doRenderHeader) {
-		headerHeight = 0;
+		headerHeight = 0;
-	}
+	}
-}
+}
-
+
-int RolledSelectionListV::getMaxPosition()
+int RolledSelectionListV::getMaxPosition()
-{
+{
-	return getNumberOfItems() * itemHeight + headerHeight;
+	return getNumberOfItems() * itemHeight + headerHeight;
-}
+}
-
+
-int RolledSelectionListV::getItemAtPosition( int x, int y )
+int RolledSelectionListV::getItemAtPosition( int x, int y )
-{
+{
-	int clickSlotPos = (int)(y - y0 - headerHeight + (int) yo - 4);
+	int clickSlotPos = (int)(y - y0 - headerHeight + (int) yo - 4);
-	int isInsideX = x >= x0 && x <= x1;
+	int isInsideX = x >= x0 && x <= x1;
-	return isInsideX? getItemAtYPositionRaw(clickSlotPos) : -1;
+	return isInsideX? getItemAtYPositionRaw(clickSlotPos) : -1;
-}
+}
-
+
-int RolledSelectionListV::getItemAtYPositionRaw(int y) {
+int RolledSelectionListV::getItemAtYPositionRaw(int y) {
-	int slot = y / itemHeight;
+	int slot = y / itemHeight;
-	bool isInsideX = slot >= 0 && y >= 0 && slot < getNumberOfItems();
+	bool isInsideX = slot >= 0 && y >= 0 && slot < getNumberOfItems();
-	return isInsideX? slot : -1;
+	return isInsideX? slot : -1;
-}
+}
-
+
-bool RolledSelectionListV::capYPosition()
+bool RolledSelectionListV::capYPosition()
-{
+{
-	float max = getMaxPosition() - (y1 - y0 - 4);
+	float max = getMaxPosition() - (y1 - y0 - 4);
-	if (max < 0) max /= 2;
+	if (max < 0) max /= 2;
-	if (yo < 0) yo = 0;
+	if (yo < 0) yo = 0;
-	if (yo > max) yo = max;
+	if (yo > max) yo = max;
-	return false;
+	return false;
-/*
+/*
-	const float MinY = -itemHeight/2;//(float)(itemHeight-height)/2;
+	const float MinY = -itemHeight/2;//(float)(itemHeight-height)/2;
-	const float MaxY = MinY + (getNumberOfItems()-1) * itemHeight;
+	const float MaxY = MinY + (getNumberOfItems()-1) * itemHeight;
-	if (yo < MinY) { yo = MinY; yInertia = 0; return true; }
+	if (yo < MinY) { yo = MinY; yInertia = 0; return true; }
-	if (yo > MaxY) { yo = MaxY; yInertia = 0; return true; }
+	if (yo > MaxY) { yo = MaxY; yInertia = 0; return true; }
-	return false;
+	return false;
-	*/
+	*/
-}
+}
-
+
-void RolledSelectionListV::tick() {
+void RolledSelectionListV::tick() {
-
+
-	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT))
+	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT))
-	{
+	{
-		_yinertia = _lastyoo - yoo;
+		_yinertia = _lastyoo - yoo;
-	}
+	}
-	_lastyoo = yoo;
+	_lastyoo = yoo;
-	
+	
-	//yInertia = Mth::absDecrease(yInertia, 1.0f, 0);
+	//yInertia = Mth::absDecrease(yInertia, 1.0f, 0);
-
+
-	yoo = yo - yInertia;
+	yoo = yo - yInertia;
-
+
-	//LOGI("tick: %f, %f, %f\n", yo, yInertia, _yinertia);
+	//LOGI("tick: %f, %f, %f\n", yo, yInertia, _yinertia);
-}
+}
-
+
-float RolledSelectionListV::getPos(float alpha) {
+float RolledSelectionListV::getPos(float alpha) {
-	return yoo - yInertia * alpha;
+	return yoo - yInertia * alpha;
-}
+}
-
+
-void RolledSelectionListV::render( int xm, int ym, float a )
+void RolledSelectionListV::render( int xm, int ym, float a )
-{
+{
-	_lastxm = xm;
+	_lastxm = xm;
-	_lastym = ym;
+	_lastym = ym;
-	renderBackground();
+	renderBackground();
-
+
-	int itemCount = getNumberOfItems();
+	int itemCount = getNumberOfItems();
-
+
-	//float yy0 = height / 2.0f + 124;
+	//float yy0 = height / 2.0f + 124;
-	//float yy1 = yy0 + 6;
+	//float yy1 = yy0 + 6;
-
+
-	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT)) {
+	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT)) {
-		touched();
+		touched();
-		//LOGI("DOWN ym: %d\n", ym);
+		//LOGI("DOWN ym: %d\n", ym);
-		if (ym >= y0 && ym <= y1) {
+		if (ym >= y0 && ym <= y1) {
-			if (dragState == NO_DRAG) {
+			if (dragState == NO_DRAG) {
-				lastSelectionTime = getTimeMs();
+				lastSelectionTime = getTimeMs();
-				lastSelection = convertSelection( getItemAtPosition(width/2, ym), xm, ym );
+				lastSelection = convertSelection( getItemAtPosition(width/2, ym), xm, ym );
-				selectStart(lastSelection);
+				selectStart(lastSelection);
-				//LOGI("Sel : %d\n", lastSelection);
+				//LOGI("Sel : %d\n", lastSelection);
-				selectionY = ym;
+				selectionY = ym;
-				_stickPixels = 10;
+				_stickPixels = 10;
-			} 
+			} 
-			else if (dragState >= 0) {
+			else if (dragState >= 0) {
-				float delta = (ym - yDrag);
+				float delta = (ym - yDrag);
-				float absDelta = Mth::abs(delta);
+				float absDelta = Mth::abs(delta);
-				if (absDelta > _stickPixels) {
+				if (absDelta > _stickPixels) {
-					_stickPixels = 0;
+					_stickPixels = 0;
-					delta -= delta>0? _stickPixels : -_stickPixels;
+					delta -= delta>0? _stickPixels : -_stickPixels;
-				} else {
+				} else {
-					delta = 0;
+					delta = 0;
-					_stickPixels -= absDelta;
+					_stickPixels -= absDelta;
-				}
+				}
-				yo -= delta;
+				yo -= delta;
-				yoo = yo;
+				yoo = yo;
-			}
+			}
-			dragState = DRAG_NORMAL;
+			dragState = DRAG_NORMAL;
-		}
+		}
-	} else {
+	} else {
-		if (dragState >= 0) {
+		if (dragState >= 0) {
-			if (dragState >= 0) {
+			if (dragState >= 0) {
-				yInertia = _yinertia < 0? Mth::Max(-10.0f, _yinertia) : Mth::Min(10.0f, _yinertia);
+				yInertia = _yinertia < 0? Mth::Max(-10.0f, _yinertia) : Mth::Min(10.0f, _yinertia);
-			}
+			}
-			// kill small inertia values when releasing scrollist
+			// kill small inertia values when releasing scrollist
-			if (std::abs(yInertia) <= 2.0001f) {
+			if (std::abs(yInertia) <= 2.0001f) {
-				yInertia = 0.0f;
+				yInertia = 0.0f;
-			}
+			}
-
+
-			if (std::abs(yInertia) <= 10 /*&& getTimeMs() - lastSelectionTime < 300 */)
+			if (std::abs(yInertia) <= 10 /*&& getTimeMs() - lastSelectionTime < 300 */)
-			{
+			{
-				//float clickSlotPos = (ym - x0 - headerHeight + (int) yo - 4);
+				//float clickSlotPos = (ym - x0 - headerHeight + (int) yo - 4);
-				int slot = convertSelection( getItemAtPosition(width/2, ym), xm, ym);
+				int slot = convertSelection( getItemAtPosition(width/2, ym), xm, ym);
-				//LOGI("slot: %d, lt: %d. diff: %d - %d\n", slot, lastSelection, selectionX, xm);
+				//LOGI("slot: %d, lt: %d. diff: %d - %d\n", slot, lastSelection, selectionX, xm);
-				if (xm >= x0 && xm <= x1 && slot >= 0 && slot == lastSelection && std::abs(selectionY - ym) < 10)
+				if (xm >= x0 && xm <= x1 && slot >= 0 && slot == lastSelection && std::abs(selectionY - ym) < 10)
-					selectItem(slot, false);
+					selectItem(slot, false);
-			} else {
+			} else {
-				selectCancel();
+				selectCancel();
-			}
+			}
-		}
+		}
-
+
-		//	if (slot >= 0 && std::abs(selectionX - xm) < itemWidth)
+		//	if (slot >= 0 && std::abs(selectionX - xm) < itemWidth)
-		//	{
+		//	{
-		//		bool doubleClick = false;
+		//		bool doubleClick = false;
-		//		selectItem(slot, doubleClick);
+		//		selectItem(slot, doubleClick);
-		//		//xInertia = 0.0f;
+		//		//xInertia = 0.0f;
-		//	}
+		//	}
-		//}
+		//}
-		dragState = NO_DRAG;
+		dragState = NO_DRAG;
-
+
-		yo = getPos(a);
+		yo = getPos(a);
-	}
+	}
-	yDrag = (float)ym;
+	yDrag = (float)ym;
-
+
-	evaluate(xm, ym);
+	evaluate(xm, ym);
-	capYPosition();
+	capYPosition();
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-
+
-	const int HalfWidth = 48;
+	const int HalfWidth = 48;
-	int rowX = (int)(width / 2 - HalfWidth + 8);
+	int rowX = (int)(width / 2 - HalfWidth + 8);
-	int rowBaseY = (int)(y0 + 4 - (int) yo);
+	int rowBaseY = (int)(y0 + 4 - (int) yo);
-
+
-	if (_renderDirtBackground)
+	if (_renderDirtBackground)
-		renderDirtBackground();
+		renderDirtBackground();
-
+
-	if (getNumberOfItems() == 0) yo = 0;
+	if (getNumberOfItems() == 0) yo = 0;
-
+
-	//int rowY = (int)(height / 2 - HalfHeight + 8);
+	//int rowY = (int)(height / 2 - HalfHeight + 8);
-	if (doRenderHeader) {
+	if (doRenderHeader) {
-		const int HalfWidth = 48;
+		const int HalfWidth = 48;
-		int rowX = (int)(width / 2 - HalfWidth + 8);
+		int rowX = (int)(width / 2 - HalfWidth + 8);
-		int rowBaseY = (int)(y0 + 4 - (int) yo);
+		int rowBaseY = (int)(y0 + 4 - (int) yo);
-		renderHeader(rowX, rowBaseY, t);
+		renderHeader(rowX, rowBaseY, t);
-	}
+	}
-
+
-	onPreRender();
+	onPreRender();
-	for (int i = 0; i < itemCount; i++) {
+	for (int i = 0; i < itemCount; i++) {
-
+
-		float y = (float)(rowBaseY + (i) * itemHeight + headerHeight);
+		float y = (float)(rowBaseY + (i) * itemHeight + headerHeight);
-		float h = itemHeight - 4.0f;
+		float h = itemHeight - 4.0f;
-
+
-		if (y > y1 || (y + h) < y0) {
+		if (y > y1 || (y + h) < y0) {
-			continue;
+			continue;
-		}
+		}
-
+
-		if (renderSelection && isSelectedItem(i)) {
+		if (renderSelection && isSelectedItem(i)) {
-			//float y0 = height / 2.0f - HalfHeight - 4;
+			//float y0 = height / 2.0f - HalfHeight - 4;
-			//float y1 = height / 2.0f + HalfHeight - 4;
+			//float y1 = height / 2.0f + HalfHeight - 4;
-			//glColor4f2(1, 1, 1, 1);
+			//glColor4f2(1, 1, 1, 1);
-			//glDisable2(GL_TEXTURE_2D);
+			//glDisable2(GL_TEXTURE_2D);
-
+
-			//int ew = 0;
+			//int ew = 0;
-			//int color = 0x808080;
+			//int color = 0x808080;
-			//if (_componentSelected) {
+			//if (_componentSelected) {
-			//	ew = 0;
+			//	ew = 0;
-			//	color = 0x7F89BF;
+			//	color = 0x7F89BF;
-			//}
+			//}
-			//t.begin();
+			//t.begin();
-			//t.color(color);
+			//t.color(color);
-			//t.vertex(x - 2 - ew, y0 - ew, 0);
+			//t.vertex(x - 2 - ew, y0 - ew, 0);
-			//t.vertex(x - 2 - ew, y1 + ew, 0);
+			//t.vertex(x - 2 - ew, y1 + ew, 0);
-			//t.vertex(x + h + 2 + ew, y1 + ew, 0);
+			//t.vertex(x + h + 2 + ew, y1 + ew, 0);
-			//t.vertex(x + h + 2 + ew, y0 - ew, 0);
+			//t.vertex(x + h + 2 + ew, y0 - ew, 0);
-
+
-			//t.color(0x000000);
+			//t.color(0x000000);
-			//t.vertex(x - 1, y0 + 1,  0);
+			//t.vertex(x - 1, y0 + 1,  0);
-			//t.vertex(x - 1, y1 - 1,  0);
+			//t.vertex(x - 1, y1 - 1,  0);
-			//t.vertex(x + h + 1, y1 - 1, 0);
+			//t.vertex(x + h + 1, y1 - 1, 0);
-			//t.vertex(x + h + 1, y0 + 1, 0);
+			//t.vertex(x + h + 1, y0 + 1, 0);
-
+
-			//t.draw();
+			//t.draw();
-			//glEnable2(GL_TEXTURE_2D);
+			//glEnable2(GL_TEXTURE_2D);
-		}
+		}
-		renderItem(i, rowX, (int)y, (int)h, t);
+		renderItem(i, rowX, (int)y, (int)h, t);
-	}
+	}
-	onPostRender();
+	onPostRender();
-
+
-	glDisable2(GL_DEPTH_TEST);
+	glDisable2(GL_DEPTH_TEST);
-
+
-	if (_renderTopBorder)
+	if (_renderTopBorder)
-		renderHoleBackground(0, y0, 255, 255);
+		renderHoleBackground(0, y0, 255, 255);
-	if (_renderBottomBorder)
+	if (_renderBottomBorder)
-		renderHoleBackground(y1, (float)height, 255, 255);
+		renderHoleBackground(y1, (float)height, 255, 255);
-	renderForeground();
+	renderForeground();
-
+
-	//glEnable2(GL_BLEND);
+	//glEnable2(GL_BLEND);
-	//glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	//glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	//glDisable2(GL_ALPHA_TEST);
+	//glDisable2(GL_ALPHA_TEST);
-	//glShadeModel2(GL_SMOOTH);
+	//glShadeModel2(GL_SMOOTH);
-
+
-	//glDisable2(GL_TEXTURE_2D);
+	//glDisable2(GL_TEXTURE_2D);
-
+
-	//const int d = 4;
+	//const int d = 4;
-	//t.begin();
+	//t.begin();
-	//t.color(0x000000, 0);
+	//t.color(0x000000, 0);
-	//t.vertexUV(y0, x0 + d, 0, 0, 1);
+	//t.vertexUV(y0, x0 + d, 0, 0, 1);
-	//t.vertexUV(y1, x0 + d, 0, 1, 1);
+	//t.vertexUV(y1, x0 + d, 0, 1, 1);
-	//t.color(0x000000, 255);
+	//t.color(0x000000, 255);
-	//t.vertexUV(y1, x0, 0, 1, 0);
+	//t.vertexUV(y1, x0, 0, 1, 0);
-	//t.vertexUV(y0, x0, 0, 0, 0);
+	//t.vertexUV(y0, x0, 0, 0, 0);
-	//t.draw();
+	//t.draw();
-
+
-	//t.begin();
+	//t.begin();
-	//t.color(0x000000, 255);
+	//t.color(0x000000, 255);
-	//t.vertexUV(y0, x1, 0, 0, 1);
+	//t.vertexUV(y0, x1, 0, 0, 1);
-	//t.vertexUV(y1, x1, 0, 1, 1);
+	//t.vertexUV(y1, x1, 0, 1, 1);
-	//t.color(0x000000, 0);
+	//t.color(0x000000, 0);
-	//t.vertexUV(y1, x1 - d, 0, 1, 0);
+	//t.vertexUV(y1, x1 - d, 0, 1, 0);
-	//t.vertexUV(y0, x1 - d, 0, 0, 0);
+	//t.vertexUV(y0, x1 - d, 0, 0, 0);
-	//t.draw();
+	//t.draw();
-
+
-	//renderDecorations(xm, ym);
+	//renderDecorations(xm, ym);
-
+
-	//glEnable2(GL_TEXTURE_2D);
+	//glEnable2(GL_TEXTURE_2D);
-	//glEnable2(GL_DEPTH_TEST);
+	//glEnable2(GL_DEPTH_TEST);
-
+
-	//glShadeModel2(GL_FLAT);
+	//glShadeModel2(GL_FLAT);
-	//glEnable2(GL_ALPHA_TEST);
+	//glEnable2(GL_ALPHA_TEST);
-	//glDisable2(GL_BLEND);
+	//glDisable2(GL_BLEND);
-}
+}
-
+
-void RolledSelectionListV::renderHoleBackground( /*float x0, float x1,*/ float y0, float y1, int a0, int a1 )
+void RolledSelectionListV::renderHoleBackground( /*float x0, float x1,*/ float y0, float y1, int a0, int a1 )
-{
+{
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	minecraft->textures->loadAndBindTexture("gui/background.png");
+	minecraft->textures->loadAndBindTexture("gui/background.png");
-	glColor4f2(1.0f, 1, 1, 1);
+	glColor4f2(1.0f, 1, 1, 1);
-	float s = 32;
+	float s = 32;
-	t.begin();
+	t.begin();
-	t.color(0x505050, a1);
+	t.color(0x505050, a1);
-	t.vertexUV(0, y1, 0, 0, y1 / s);
+	t.vertexUV(0, y1, 0, 0, y1 / s);
-	t.vertexUV((float)width, y1, 0, width / s, y1 / s);
+	t.vertexUV((float)width, y1, 0, width / s, y1 / s);
-	t.color(0x505050, a0);
+	t.color(0x505050, a0);
-	t.vertexUV((float)width, y0, 0, width / s, y0 / s);
+	t.vertexUV((float)width, y0, 0, width / s, y0 / s);
-	t.vertexUV(0, y0, 0, 0, y0 / s);
+	t.vertexUV(0, y0, 0, 0, y0 / s);
-	t.draw();
+	t.draw();
-	//printf("x, y, x1, y1: %d, %d, %d, %d\n", 0, (int)y0, width, (int)y1);
+	//printf("x, y, x1, y1: %d, %d, %d, %d\n", 0, (int)y0, width, (int)y1);
-}
+}
-
+
-void RolledSelectionListV::touched()
+void RolledSelectionListV::touched()
-{
+{
-}
+}
-
+
-void RolledSelectionListV::evaluate(int xm, int ym)
+void RolledSelectionListV::evaluate(int xm, int ym)
-{
+{
-	if (std::abs(selectionY - ym) >= 10) {
+	if (std::abs(selectionY - ym) >= 10) {
-		lastSelection = -1;
+		lastSelection = -1;
-		selectCancel();
+		selectCancel();
-	}
+	}
-}
+}
-
+
-void RolledSelectionListV::onPreRender()
+void RolledSelectionListV::onPreRender()
-{
+{
-}
+}
-
+
-void RolledSelectionListV::onPostRender()
+void RolledSelectionListV::onPostRender()
-{
+{
-}
+}
-
+
-void RolledSelectionListV::renderDirtBackground()
+void RolledSelectionListV::renderDirtBackground()
-{
+{
-	float by0 = _renderTopBorder?    y0 : 0;
+	float by0 = _renderTopBorder?    y0 : 0;
-	float by1 = _renderBottomBorder? y1 : height;
+	float by1 = _renderBottomBorder? y1 : height;
-
+
-	minecraft->textures->loadAndBindTexture("gui/background.png");
+	minecraft->textures->loadAndBindTexture("gui/background.png");
-	glColor4f2(1.0f, 1, 1, 1);
+	glColor4f2(1.0f, 1, 1, 1);
-	float s = 32;
+	float s = 32;
-	const float uvy = (float)((int) yo);
+	const float uvy = (float)((int) yo);
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	t.begin();
+	t.begin();
-	t.color(0x202020);
+	t.color(0x202020);
-	t.vertexUV(x0, by1, 0, x0 / s, (by1+uvy) / s);
+	t.vertexUV(x0, by1, 0, x0 / s, (by1+uvy) / s);
-	t.vertexUV(x1, by1, 0, x1 / s, (by1+uvy) / s);
+	t.vertexUV(x1, by1, 0, x1 / s, (by1+uvy) / s);
-	t.vertexUV(x1, by0, 0, x1 / s, (by0+uvy) / s);
+	t.vertexUV(x1, by0, 0, x1 / s, (by0+uvy) / s);
-	t.vertexUV(x0, by0, 0, x0 / s, (by0+uvy) / s);
+	t.vertexUV(x0, by0, 0, x0 / s, (by0+uvy) / s);
-	t.draw();
+	t.draw();
-	//LOGI("%f, %f - %f, %f\n", x0, by0, x1, by1);
+	//LOGI("%f, %f - %f, %f\n", x0, by0, x1, by1);
-}
+}

src/client/gui/components/RolledSelectionListV.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../GuiComponent.h"
+#include "client/gui/GuiComponent.hpp"
 class Minecraft;
 class Tesselator;
 

src/client/gui/components/ScrolledSelectionList.cpp

@@ -1,296 +1,296 @@
-#include "ScrolledSelectionList.h"
+#include "ScrolledSelectionList.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../renderer/gles.h"
+#include "client/renderer/gles.hpp"
-#include "../../../platform/input/Mouse.h"
+#include "platform/input/Mouse.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-
+
-static int Abs(int d) {
+static int Abs(int d) {
-	return d >= 0? d : -d;
+	return d >= 0? d : -d;
-}
+}
-
+
-ScrolledSelectionList::ScrolledSelectionList( Minecraft* _minecraft, int _width, int _height, int _y0, int _y1, int _itemHeight )
+ScrolledSelectionList::ScrolledSelectionList( Minecraft* _minecraft, int _width, int _height, int _y0, int _y1, int _itemHeight )
-:	minecraft(_minecraft),
+:	minecraft(_minecraft),
-	width(_width),
+	width(_width),
-	height(_height),
+	height(_height),
-	y0((float)_y0),
+	y0((float)_y0),
-	y1((float)_y1),
+	y1((float)_y1),
-	itemHeight(_itemHeight),
+	itemHeight(_itemHeight),
-	x0(0.0f),
+	x0(0.0f),
-	x1((float)_width),
+	x1((float)_width),
-	selectionY(-1),
+	selectionY(-1),
-	lastSelectionTime(0),
+	lastSelectionTime(0),
-	renderSelection(true),
+	renderSelection(true),
-	doRenderHeader(false),
+	doRenderHeader(false),
-	headerHeight(0),
+	headerHeight(0),
-	dragState(DRAG_OUTSIDE),
+	dragState(DRAG_OUTSIDE),
-	yDrag(0.0f),
+	yDrag(0.0f),
-	yo(0.0f),
+	yo(0.0f),
-	yInertia(0.0f)
+	yInertia(0.0f)
-{
+{
-}
+}
-
+
-void ScrolledSelectionList::setRenderSelection( bool _renderSelection )
+void ScrolledSelectionList::setRenderSelection( bool _renderSelection )
-{
+{
-	renderSelection = _renderSelection;
+	renderSelection = _renderSelection;
-}
+}
-
+
-void ScrolledSelectionList::setRenderHeader( bool _renderHeader, int _headerHeight )
+void ScrolledSelectionList::setRenderHeader( bool _renderHeader, int _headerHeight )
-{
+{
-	doRenderHeader = _renderHeader;
+	doRenderHeader = _renderHeader;
-	headerHeight = _headerHeight;
+	headerHeight = _headerHeight;
-
+
-	if (!doRenderHeader) {
+	if (!doRenderHeader) {
-		headerHeight = 0;
+		headerHeight = 0;
-	}
+	}
-}
+}
-
+
-int ScrolledSelectionList::getMaxPosition()
+int ScrolledSelectionList::getMaxPosition()
-{
+{
-	return getNumberOfItems() * itemHeight + headerHeight;
+	return getNumberOfItems() * itemHeight + headerHeight;
-}
+}
-
+
-int ScrolledSelectionList::getItemAtPosition( int x, int y )
+int ScrolledSelectionList::getItemAtPosition( int x, int y )
-{
+{
-	int x0 = width / 2 - (92 + 16 + 2);
+	int x0 = width / 2 - (92 + 16 + 2);
-	int x1 = width / 2 + (92 + 16 + 2);
+	int x1 = width / 2 + (92 + 16 + 2);
-
+
-	int clickSlotPos = (int)(y - y0 - headerHeight + (int) yo - 4);
+	int clickSlotPos = (int)(y - y0 - headerHeight + (int) yo - 4);
-	int slot = clickSlotPos / itemHeight;
+	int slot = clickSlotPos / itemHeight;
-	if (x >= x0 && x <= x1 && slot >= 0 && clickSlotPos >= 0 && slot < getNumberOfItems()) {
+	if (x >= x0 && x <= x1 && slot >= 0 && clickSlotPos >= 0 && slot < getNumberOfItems()) {
-		return slot;
+		return slot;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-
+
-void ScrolledSelectionList::capYPosition()
+void ScrolledSelectionList::capYPosition()
-{
+{
-	float max = getMaxPosition() - (y1 - y0 - 4);
+	float max = getMaxPosition() - (y1 - y0 - 4);
-	if (max < 0) max /= 2;
+	if (max < 0) max /= 2;
-	if (yo < 0) yo = 0;
+	if (yo < 0) yo = 0;
-	if (yo > max) yo = max;
+	if (yo > max) yo = max;
-}
+}
-
+
-void ScrolledSelectionList::render( int xm, int ym, float a )
+void ScrolledSelectionList::render( int xm, int ym, float a )
-{
+{
-	renderBackground();
+	renderBackground();
-
+
-	int itemCount = getNumberOfItems();
+	int itemCount = getNumberOfItems();
-
+
-	//float xx0 = width / 2.0f + 124;
+	//float xx0 = width / 2.0f + 124;
-	//float xx1 = xx0 + 6;
+	//float xx1 = xx0 + 6;
-
+
-
+
-	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT)) {
+	if (Mouse::isButtonDown(MouseAction::ACTION_LEFT)) {
-		//LOGI("DOWN ym: %d\n", ym);
+		//LOGI("DOWN ym: %d\n", ym);
-		if (ym >= y0 && ym <= y1 && ym != ignoreY) {
+		if (ym >= y0 && ym <= y1 && ym != ignoreY) {
-			if (dragState == NO_DRAG) {
+			if (dragState == NO_DRAG) {
-				dragState = DRAG_SKIP;
+				dragState = DRAG_SKIP;
-			} 
+			} 
-			else if (dragState >= 0)
+			else if (dragState >= 0)
-			{
+			{
-				if (dragState == DRAG_SKIP)
+				if (dragState == DRAG_SKIP)
-				{
+				{
-					lastSelectionTime = getTimeMs();
+					lastSelectionTime = getTimeMs();
-					selectionY = ym;
+					selectionY = ym;
-				}
+				}
-				else if (dragState == DRAG_NORMAL)
+				else if (dragState == DRAG_NORMAL)
-				{
+				{
-					yo -= (ym - yDrag);
+					yo -= (ym - yDrag);
-					yInertia += (float)(ym - yDrag);
+					yInertia += (float)(ym - yDrag);
-				}
+				}
-				dragState = DRAG_NORMAL;
+				dragState = DRAG_NORMAL;
-			}
+			}
-			ignoreY = -1;
+			ignoreY = -1;
-		}
+		}
-
+
-	} else {
+	} else {
-		if (dragState != NO_DRAG)
+		if (dragState != NO_DRAG)
-		{
+		{
-			//LOGI("UP ym: %d\n", ym);
+			//LOGI("UP ym: %d\n", ym);
-		}
+		}
-		//ignoreY = ym;
+		//ignoreY = ym;
-
+
-		// kill small inertia values when releasing scrollist
+		// kill small inertia values when releasing scrollist
-		if (dragState >= 0 && std::abs(yInertia) < 2)
+		if (dragState >= 0 && std::abs(yInertia) < 2)
-		{
+		{
-			yInertia = 0.0f;
+			yInertia = 0.0f;
-		}
+		}
-
+
-		if (dragState >= 0 && getTimeMs() - lastSelectionTime < 300)
+		if (dragState >= 0 && getTimeMs() - lastSelectionTime < 300)
-		{
+		{
-			float clickSlotPos = (ym - y0 - headerHeight + (int) yo - 4);
+			float clickSlotPos = (ym - y0 - headerHeight + (int) yo - 4);
-			int slot = (int)clickSlotPos / itemHeight;
+			int slot = (int)clickSlotPos / itemHeight;
-
+
-			if (slot >= 0 && Abs(selectionY - ym) < itemHeight)
+			if (slot >= 0 && Abs(selectionY - ym) < itemHeight)
-			{
+			{
-				bool doubleClick = false;
+				bool doubleClick = false;
-				selectItem(slot, doubleClick);
+				selectItem(slot, doubleClick);
-				yInertia = 0.0f;
+				yInertia = 0.0f;
-			}
+			}
-		}
+		}
-		dragState = NO_DRAG;
+		dragState = NO_DRAG;
-
+
-		yo -= yInertia;
+		yo -= yInertia;
-	}
+	}
-	yInertia = yInertia * .75f;
+	yInertia = yInertia * .75f;
-	yDrag = (float)ym;
+	yDrag = (float)ym;
-
+
-	capYPosition();
+	capYPosition();
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-
+
-	renderDirtBackground();
+	renderDirtBackground();
-
+
-	int rowX = (int)(width / 2 - 92 - 16);
+	int rowX = (int)(width / 2 - 92 - 16);
-	int rowBaseY = (int)(y0 + 4 - (int) yo);
+	int rowBaseY = (int)(y0 + 4 - (int) yo);
-
+
-	if (doRenderHeader) {
+	if (doRenderHeader) {
-		renderHeader(rowX, rowBaseY, t);
+		renderHeader(rowX, rowBaseY, t);
-	}
+	}
-
+
-	for (int i = 0; i < itemCount; i++) {
+	for (int i = 0; i < itemCount; i++) {
-
+
-		float y = (float)(rowBaseY + (i) * itemHeight + headerHeight);
+		float y = (float)(rowBaseY + (i) * itemHeight + headerHeight);
-		float h = itemHeight - 4.0f;
+		float h = itemHeight - 4.0f;
-
+
-		if (y > y1 || (y + h) < y0) {
+		if (y > y1 || (y + h) < y0) {
-			continue;
+			continue;
-		}
+		}
-
+
-		if (renderSelection && isSelectedItem(i)) {
+		if (renderSelection && isSelectedItem(i)) {
-			float x0 = width / 2.0f - (92 + 16 + 2);
+			float x0 = width / 2.0f - (92 + 16 + 2);
-			float x1 = width / 2.0f + (92 + 16 + 2);
+			float x1 = width / 2.0f + (92 + 16 + 2);
-			glColor4f2(1, 1, 1, 1);
+			glColor4f2(1, 1, 1, 1);
-			glDisable2(GL_TEXTURE_2D);
+			glDisable2(GL_TEXTURE_2D);
-			t.begin();
+			t.begin();
-			t.color(0x808080);
+			t.color(0x808080);
-			t.vertexUV(x0, y + h + 2, 0, 0, 1);
+			t.vertexUV(x0, y + h + 2, 0, 0, 1);
-			t.vertexUV(x1, y + h + 2, 0, 1, 1);
+			t.vertexUV(x1, y + h + 2, 0, 1, 1);
-			t.vertexUV(x1, y - 2, 0, 1, 0);
+			t.vertexUV(x1, y - 2, 0, 1, 0);
-			t.vertexUV(x0, y - 2, 0, 0, 0);
+			t.vertexUV(x0, y - 2, 0, 0, 0);
-
+
-			t.color(0x000000);
+			t.color(0x000000);
-			t.vertexUV(x0 + 1, y + h + 1, 0, 0, 1);
+			t.vertexUV(x0 + 1, y + h + 1, 0, 0, 1);
-			t.vertexUV(x1 - 1, y + h + 1, 0, 1, 1);
+			t.vertexUV(x1 - 1, y + h + 1, 0, 1, 1);
-			t.vertexUV(x1 - 1, y - 1, 0, 1, 0);
+			t.vertexUV(x1 - 1, y - 1, 0, 1, 0);
-			t.vertexUV(x0 + 1, y - 1, 0, 0, 0);
+			t.vertexUV(x0 + 1, y - 1, 0, 0, 0);
-
+
-			t.draw();
+			t.draw();
-			glEnable2(GL_TEXTURE_2D);
+			glEnable2(GL_TEXTURE_2D);
-		}
+		}
-
+
-		renderItem(i, rowX, (int)y, (int)h, t);
+		renderItem(i, rowX, (int)y, (int)h, t);
-
+
-	}
+	}
-
+
-	glDisable2(GL_DEPTH_TEST);
+	glDisable2(GL_DEPTH_TEST);
-
+
-
+
-	int d = 4;
+	int d = 4;
-
+
-	renderHoleBackground(0, y0, 255, 255);
+	renderHoleBackground(0, y0, 255, 255);
-	renderHoleBackground(y1, (float)height, 255, 255);
+	renderHoleBackground(y1, (float)height, 255, 255);
-
+
-	glEnable2(GL_BLEND);
+	glEnable2(GL_BLEND);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glDisable2(GL_ALPHA_TEST);
+	glDisable2(GL_ALPHA_TEST);
-	glShadeModel2(GL_SMOOTH);
+	glShadeModel2(GL_SMOOTH);
-
+
-	glDisable2(GL_TEXTURE_2D);
+	glDisable2(GL_TEXTURE_2D);
-
+
-	t.begin();
+	t.begin();
-	t.color(0x000000, 0);
+	t.color(0x000000, 0);
-	t.vertexUV(x0, y0 + d, 0, 0, 1);
+	t.vertexUV(x0, y0 + d, 0, 0, 1);
-	t.vertexUV(x1, y0 + d, 0, 1, 1);
+	t.vertexUV(x1, y0 + d, 0, 1, 1);
-	t.color(0x000000, 255);
+	t.color(0x000000, 255);
-	t.vertexUV(x1, y0, 0, 1, 0);
+	t.vertexUV(x1, y0, 0, 1, 0);
-	t.vertexUV(x0, y0, 0, 0, 0);
+	t.vertexUV(x0, y0, 0, 0, 0);
-	t.draw();
+	t.draw();
-
+
-	t.begin();
+	t.begin();
-	t.color(0x000000, 255);
+	t.color(0x000000, 255);
-	t.vertexUV(x0, y1, 0, 0, 1);
+	t.vertexUV(x0, y1, 0, 0, 1);
-	t.vertexUV(x1, y1, 0, 1, 1);
+	t.vertexUV(x1, y1, 0, 1, 1);
-	t.color(0x000000, 0);
+	t.color(0x000000, 0);
-	t.vertexUV(x1, y1 - d, 0, 1, 0);
+	t.vertexUV(x1, y1 - d, 0, 1, 0);
-	t.vertexUV(x0, y1 - d, 0, 0, 0);
+	t.vertexUV(x0, y1 - d, 0, 0, 0);
-	t.draw();
+	t.draw();
-
+
-	// 		{
+	// 		{
-	// 			float max = getMaxPosition() - (y1 - y0 - 4);
+	// 			float max = getMaxPosition() - (y1 - y0 - 4);
-	// 			if (max > 0) {
+	// 			if (max > 0) {
-	// 				float barHeight = (y1 - y0) * (y1 - y0) / (getMaxPosition());
+	// 				float barHeight = (y1 - y0) * (y1 - y0) / (getMaxPosition());
-	// 				if (barHeight < 32) barHeight = 32;
+	// 				if (barHeight < 32) barHeight = 32;
-	// 				if (barHeight > (y1 - y0 - 8)) barHeight = (y1 - y0 - 8);
+	// 				if (barHeight > (y1 - y0 - 8)) barHeight = (y1 - y0 - 8);
-	// 
+	// 
-	// 				float yp = (int) yo * (y1 - y0 - barHeight) / max + y0;
+	// 				float yp = (int) yo * (y1 - y0 - barHeight) / max + y0;
-	// 				if (yp < y0) yp = y0;
+	// 				if (yp < y0) yp = y0;
-	// 
+	// 
-	// 				t.begin();
+	// 				t.begin();
-	// 				t.color(0x000000, 255);
+	// 				t.color(0x000000, 255);
-	// 				t.vertexUV(xx0, y1, 0.0f, 0.0f, 1.0f);
+	// 				t.vertexUV(xx0, y1, 0.0f, 0.0f, 1.0f);
-	// 				t.vertexUV(xx1, y1, 0.0f, 1.0f, 1.0f);
+	// 				t.vertexUV(xx1, y1, 0.0f, 1.0f, 1.0f);
-	// 				t.vertexUV(xx1, y0, 0.0f, 1.0f, 0.0f);
+	// 				t.vertexUV(xx1, y0, 0.0f, 1.0f, 0.0f);
-	// 				t.vertexUV(xx0, y0, 0.0f, 0.0f, 0.0f);
+	// 				t.vertexUV(xx0, y0, 0.0f, 0.0f, 0.0f);
-	// 				t.draw();
+	// 				t.draw();
-	// 
+	// 
-	// 				t.begin();
+	// 				t.begin();
-	// 				t.color(0x808080, 255);
+	// 				t.color(0x808080, 255);
-	// 				t.vertexUV(xx0, yp + barHeight, 0, 0, 1);
+	// 				t.vertexUV(xx0, yp + barHeight, 0, 0, 1);
-	// 				t.vertexUV(xx1, yp + barHeight, 0, 1, 1);
+	// 				t.vertexUV(xx1, yp + barHeight, 0, 1, 1);
-	// 				t.vertexUV(xx1, yp, 0, 1, 0);
+	// 				t.vertexUV(xx1, yp, 0, 1, 0);
-	// 				t.vertexUV(xx0, yp, 0, 0, 0);
+	// 				t.vertexUV(xx0, yp, 0, 0, 0);
-	// 				t.draw();
+	// 				t.draw();
-	// 
+	// 
-	// 				t.begin();
+	// 				t.begin();
-	// 				t.color(0xc0c0c0, 255);
+	// 				t.color(0xc0c0c0, 255);
-	// 				t.vertexUV(xx0, yp + barHeight - 1, 0, 0, 1);
+	// 				t.vertexUV(xx0, yp + barHeight - 1, 0, 0, 1);
-	// 				t.vertexUV(xx1 - 1, yp + barHeight - 1, 0, 1, 1);
+	// 				t.vertexUV(xx1 - 1, yp + barHeight - 1, 0, 1, 1);
-	// 				t.vertexUV(xx1 - 1, yp, 0, 1, 0);
+	// 				t.vertexUV(xx1 - 1, yp, 0, 1, 0);
-	// 				t.vertexUV(xx0, yp, 0, 0, 0);
+	// 				t.vertexUV(xx0, yp, 0, 0, 0);
-	// 				t.draw();
+	// 				t.draw();
-	// 			}
+	// 			}
-	// 		}
+	// 		}
-
+
-	renderDecorations(xm, ym);
+	renderDecorations(xm, ym);
-
+
-
+
-	glEnable2(GL_TEXTURE_2D);
+	glEnable2(GL_TEXTURE_2D);
-	glEnable2(GL_DEPTH_TEST);
+	glEnable2(GL_DEPTH_TEST);
-
+
-	glShadeModel2(GL_FLAT);
+	glShadeModel2(GL_FLAT);
-	glEnable2(GL_ALPHA_TEST);
+	glEnable2(GL_ALPHA_TEST);
-	glDisable2(GL_BLEND);
+	glDisable2(GL_BLEND);
-}
+}
-
+
-void ScrolledSelectionList::renderHoleBackground( float y0, float y1, int a0, int a1 )
+void ScrolledSelectionList::renderHoleBackground( float y0, float y1, int a0, int a1 )
-{
+{
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	minecraft->textures->loadAndBindTexture("gui/background.png");
+	minecraft->textures->loadAndBindTexture("gui/background.png");
-	glColor4f2(1.0f, 1, 1, 1);
+	glColor4f2(1.0f, 1, 1, 1);
-	float s = 32;
+	float s = 32;
-	t.begin();
+	t.begin();
-	t.color(0x505050, a1);
+	t.color(0x505050, a1);
-	t.vertexUV(0, y1, 0, 0, y1 / s);
+	t.vertexUV(0, y1, 0, 0, y1 / s);
-	t.vertexUV((float)width, y1, 0, width / s, y1 / s);
+	t.vertexUV((float)width, y1, 0, width / s, y1 / s);
-	t.color(0x505050, a0);
+	t.color(0x505050, a0);
-	t.vertexUV((float)width, y0, 0, width / s, y0 / s);
+	t.vertexUV((float)width, y0, 0, width / s, y0 / s);
-	t.vertexUV(0, y0, 0, 0, y0 / s);
+	t.vertexUV(0, y0, 0, 0, y0 / s);
-	t.draw();
+	t.draw();
-}
+}
-
+
-void ScrolledSelectionList::renderDirtBackground()
+void ScrolledSelectionList::renderDirtBackground()
-{
+{
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	minecraft->textures->loadAndBindTexture("gui/background.png");
+	minecraft->textures->loadAndBindTexture("gui/background.png");
-	glColor4f2(1.0f, 1, 1, 1);
+	glColor4f2(1.0f, 1, 1, 1);
-	float s = 32;
+	float s = 32;
-	t.begin();
+	t.begin();
-	t.color(0x202020);
+	t.color(0x202020);
-	t.vertexUV(x0, y1, 0, x0 / s, (y1 + (int) yo) / s);
+	t.vertexUV(x0, y1, 0, x0 / s, (y1 + (int) yo) / s);
-	t.vertexUV(x1, y1, 0, x1 / s, (y1 + (int) yo) / s);
+	t.vertexUV(x1, y1, 0, x1 / s, (y1 + (int) yo) / s);
-	t.vertexUV(x1, y0, 0, x1 / s, (y0 + (int) yo) / s);
+	t.vertexUV(x1, y0, 0, x1 / s, (y0 + (int) yo) / s);
-	t.vertexUV(x0, y0, 0, x0 / s, (y0 + (int) yo) / s);
+	t.vertexUV(x0, y0, 0, x0 / s, (y0 + (int) yo) / s);
-	t.draw();
+	t.draw();
-}
+}

src/client/gui/components/ScrolledSelectionList.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../GuiComponent.h"
+#include "client/gui/GuiComponent.hpp"
 class Minecraft;
 class Tesselator;
 

src/client/gui/components/ScrollingPane.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "../GuiComponent.h"
+#include "client/gui/GuiComponent.hpp"
-#include "ImageButton.h"
+#include "ImageButton.hpp"
-#include "../../player/input/touchscreen/TouchAreaModel.h"
+#include "client/player/input/touchscreen/TouchAreaModel.hpp"
-#include "../../../world/phys/Vec3.h"
+#include "world/phys/Vec3.hpp"
-#include "../../Timer.h"
+#include "client/Timer.hpp"
 
 enum ScrollingPaneFlags {
 	SF_LockX		= 1 << 0,

src/client/gui/components/Slider.cpp

@@ -1,94 +1,94 @@
-#include "Slider.h"
+#include "Slider.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../renderer/Textures.h"
+#include "client/renderer/Textures.hpp"
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
-#include "../../../locale/I18n.h"
+#include "locale/I18n.hpp"
-#include "../../../util/Mth.h"
+#include "util/Mth.hpp"
-#include <algorithm>
+#include <algorithm>
-#include <assert.h>
+#include <assert.h>
-
+
-Slider::Slider(OptionId optId) : m_mouseDownOnElement(false), m_optId(optId), m_numSteps(0) {}
+Slider::Slider(OptionId optId) : m_mouseDownOnElement(false), m_optId(optId), m_numSteps(0) {}
-
+
-void Slider::render( Minecraft* minecraft, int xm, int ym ) {
+void Slider::render( Minecraft* minecraft, int xm, int ym ) {
-	int xSliderStart = x + 5;
+	int xSliderStart = x + 5;
-	int xSliderEnd = x + width - 5;
+	int xSliderEnd = x + width - 5;
-	int ySliderStart = y + 6;
+	int ySliderStart = y + 6;
-	int ySliderEnd = y + 9;
+	int ySliderEnd = y + 9;
-	int handleSizeX = 9;
+	int handleSizeX = 9;
-	int handleSizeY = 15;
+	int handleSizeY = 15;
-	int barWidth = xSliderEnd - xSliderStart;
+	int barWidth = xSliderEnd - xSliderStart;
-	//fill(x, y + 8, x + (int)(width * percentage), y + height, 0xffff00ff);
+	//fill(x, y + 8, x + (int)(width * percentage), y + height, 0xffff00ff);
-	fill(xSliderStart, ySliderStart, xSliderEnd, ySliderEnd, 0xff606060);
+	fill(xSliderStart, ySliderStart, xSliderEnd, ySliderEnd, 0xff606060);
-
+
-	if (m_numSteps > 2) {
+	if (m_numSteps > 2) {
-		int stepDistance = barWidth / (m_numSteps-1);
+		int stepDistance = barWidth / (m_numSteps-1);
-		for(int a = 0; a < m_numSteps; ++a) {
+		for(int a = 0; a < m_numSteps; ++a) {
-			int renderSliderStepPosX = xSliderStart + a * stepDistance + 1;
+			int renderSliderStepPosX = xSliderStart + a * stepDistance + 1;
-			fill(renderSliderStepPosX - 1, ySliderStart - 2, renderSliderStepPosX + 1, ySliderEnd + 2, 0xff606060);
+			fill(renderSliderStepPosX - 1, ySliderStart - 2, renderSliderStepPosX + 1, ySliderEnd + 2, 0xff606060);
-		}
+		}
-	}
+	}
-
+
-	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
+	minecraft->textures->loadAndBindTexture("gui/touchgui.png");
-	blit(xSliderStart + (int)(m_percentage * barWidth) - handleSizeX / 2, y, 226, 126, handleSizeX, handleSizeY, handleSizeX, handleSizeY);
+	blit(xSliderStart + (int)(m_percentage * barWidth) - handleSizeX / 2, y, 226, 126, handleSizeX, handleSizeY, handleSizeX, handleSizeY);
-}
+}
-
+
-void Slider::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
+void Slider::mouseClicked( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	if(pointInside(x, y)) {
+	if(pointInside(x, y)) {
-		m_mouseDownOnElement = true;
+		m_mouseDownOnElement = true;
-	}
+	}
-}
+}
-
+
-void Slider::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
+void Slider::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	m_mouseDownOnElement = false;
+	m_mouseDownOnElement = false;
-} 
+} 
-
+
-void Slider::tick(Minecraft* minecraft) {
+void Slider::tick(Minecraft* minecraft) {
-	if(minecraft->screen != NULL) {
+	if(minecraft->screen != NULL) {
-		int xm = Mouse::getX();
+		int xm = Mouse::getX();
-		int ym = Mouse::getY();
+		int ym = Mouse::getY();
-		
+		
-		minecraft->screen->toGUICoordinate(xm, ym);
+		minecraft->screen->toGUICoordinate(xm, ym);
-
+
-		if(m_mouseDownOnElement) {
+		if(m_mouseDownOnElement) {
-			m_percentage = float(xm - x) / float(width);
+			m_percentage = float(xm - x) / float(width);
-			m_percentage = Mth::clamp(m_percentage, 0.0f, 1.0f);
+			m_percentage = Mth::clamp(m_percentage, 0.0f, 1.0f);
-		}
+		}
-	}
+	}
-}
+}
-
+
-SliderFloat::SliderFloat(Minecraft* minecraft, OptionId option) 
+SliderFloat::SliderFloat(Minecraft* minecraft, OptionId option) 
-: Slider(option), m_option(dynamic_cast<OptionFloat*>(minecraft->options.getOpt(option)))
+: Slider(option), m_option(dynamic_cast<OptionFloat*>(minecraft->options.getOpt(option)))
-{
+{
-	m_percentage = Mth::clamp((m_option->get() - m_option->getMin()) / (m_option->getMax() - m_option->getMin()), 0.f, 1.f);
+	m_percentage = Mth::clamp((m_option->get() - m_option->getMin()) / (m_option->getMax() - m_option->getMin()), 0.f, 1.f);
-}
+}
-
+
-SliderInt::SliderInt(Minecraft* minecraft, OptionId option) 
+SliderInt::SliderInt(Minecraft* minecraft, OptionId option) 
-: Slider(option), m_option(dynamic_cast<OptionInt*>(minecraft->options.getOpt(option)))
+: Slider(option), m_option(dynamic_cast<OptionInt*>(minecraft->options.getOpt(option)))
-{
+{
-	m_numSteps = m_option->getMax() - m_option->getMin() + 1;
+	m_numSteps = m_option->getMax() - m_option->getMin() + 1;
-	m_percentage = float(m_option->get() - m_option->getMin()) / (m_numSteps-1);
+	m_percentage = float(m_option->get() - m_option->getMin()) / (m_numSteps-1);
-}
+}
-
+
-void SliderInt::render( Minecraft* minecraft, int xm, int ym ) {
+void SliderInt::render( Minecraft* minecraft, int xm, int ym ) {
-	Slider::render(minecraft, xm, ym);
+	Slider::render(minecraft, xm, ym);
-}
+}
-
+
-void SliderInt::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
+void SliderInt::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	Slider::mouseReleased(minecraft, x, y, buttonNum);
+	Slider::mouseReleased(minecraft, x, y, buttonNum);
-
+
-	if (pointInside(x, y)) {
+	if (pointInside(x, y)) {
-		int curStep = int(m_percentage * (m_numSteps-1) + 0.5f);
+		int curStep = int(m_percentage * (m_numSteps-1) + 0.5f);
-		curStep = Mth::clamp(curStep + m_option->getMin(), m_option->getMin(), m_option->getMax());
+		curStep = Mth::clamp(curStep + m_option->getMin(), m_option->getMin(), m_option->getMax());
-		m_percentage = float(curStep - m_option->getMin()) / (m_numSteps-1);
+		m_percentage = float(curStep - m_option->getMin()) / (m_numSteps-1);
-
+
-		minecraft->options.set(m_optId, curStep);
+		minecraft->options.set(m_optId, curStep);
-	}
+	}
-}
+}
-
+
-void SliderFloat::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
+void SliderFloat::mouseReleased( Minecraft* minecraft, int x, int y, int buttonNum ) {
-	Slider::mouseReleased(minecraft, x, y, buttonNum);
+	Slider::mouseReleased(minecraft, x, y, buttonNum);
-
+
-	if (pointInside(x, y)) {
+	if (pointInside(x, y)) {
-		minecraft->options.set(m_optId, m_percentage * (m_option->getMax() - m_option->getMin()) + m_option->getMin());
+		minecraft->options.set(m_optId, m_percentage * (m_option->getMax() - m_option->getMin()) + m_option->getMin());
-	}
+	}
 }

src/client/gui/components/Slider.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "GuiElement.h"
+#include "GuiElement.hpp"
-#include "../../../client/Options.h"
+#include "client/Options.hpp"
-#include <client/Option.h>
+#include <client/Option.hpp>
 
 class Slider : public GuiElement {
 	typedef GuiElement super;

src/client/gui/components/TextBox.cpp

@@ -1,102 +1,102 @@
-#include "TextBox.h"
+#include "TextBox.hpp"
-#include "../Gui.h"
+#include "client/gui/Gui.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../../AppPlatform.h"
+#include "AppPlatform.hpp"
-#include "../../../platform/input/Mouse.h"
+#include "platform/input/Mouse.hpp"
-
+
-// delegate constructors
+// delegate constructors
-TextBox::TextBox(int id, const std::string& msg)
+TextBox::TextBox(int id, const std::string& msg)
- : TextBox(id, 0, 0, msg)
+ : TextBox(id, 0, 0, msg)
-{
+{
-}
+}
-
+
-TextBox::TextBox(int id, int x, int y, const std::string& msg)
+TextBox::TextBox(int id, int x, int y, const std::string& msg)
- : TextBox(id, x, y, 24, Font::DefaultLineHeight + 4, msg)
+ : TextBox(id, x, y, 24, Font::DefaultLineHeight + 4, msg)
-{
+{
-}
+}
-
+
-TextBox::TextBox(int id, int x, int y, int w, int h, const std::string& msg)
+TextBox::TextBox(int id, int x, int y, int w, int h, const std::string& msg)
- : GuiElement(true, true, x, y, w, h),
+ : GuiElement(true, true, x, y, w, h),
-   id(id), hint(msg), focused(false), blink(false), blinkTicks(0)
+   id(id), hint(msg), focused(false), blink(false), blinkTicks(0)
-{
+{
-}
+}
-
+
-void TextBox::setFocus(Minecraft* minecraft) {
+void TextBox::setFocus(Minecraft* minecraft) {
-    if (!focused) {
+    if (!focused) {
-        minecraft->platform()->showKeyboard();
+        minecraft->platform()->showKeyboard();
-        focused = true;
+        focused = true;
-        blinkTicks = 0;
+        blinkTicks = 0;
-        blink = false;
+        blink = false;
-    }
+    }
-}
+}
-
+
-bool TextBox::loseFocus(Minecraft* minecraft) {
+bool TextBox::loseFocus(Minecraft* minecraft) {
-    if (focused) {
+    if (focused) {
-        minecraft->platform()->hideKeyboard();
+        minecraft->platform()->hideKeyboard();
-        focused = false;
+        focused = false;
-        return true;
+        return true;
-    }
+    }
-    return false;
+    return false;
-}
+}
-
+
-void TextBox::mouseClicked(Minecraft* minecraft, int x, int y, int buttonNum) {
+void TextBox::mouseClicked(Minecraft* minecraft, int x, int y, int buttonNum) {
-    if (buttonNum == MouseAction::ACTION_LEFT) {
+    if (buttonNum == MouseAction::ACTION_LEFT) {
-        if (pointInside(x, y)) {
+        if (pointInside(x, y)) {
-            setFocus(minecraft);
+            setFocus(minecraft);
-        } else {
+        } else {
-            loseFocus(minecraft);
+            loseFocus(minecraft);
-        }
+        }
-    }
+    }
-}
+}
-
+
-void TextBox::charPressed(Minecraft* minecraft, char c)  {
+void TextBox::charPressed(Minecraft* minecraft, char c)  {
-    if (focused && c >= 32 && c < 127 && (int)text.size() < 256) {
+    if (focused && c >= 32 && c < 127 && (int)text.size() < 256) {
-        text.push_back(c);
+        text.push_back(c);
-    }
+    }
-}
+}
-
+
-void TextBox::keyPressed(Minecraft* minecraft, int key) {
+void TextBox::keyPressed(Minecraft* minecraft, int key) {
-    if (focused && key == Keyboard::KEY_BACKSPACE && !text.empty()) {
+    if (focused && key == Keyboard::KEY_BACKSPACE && !text.empty()) {
-        text.pop_back();
+        text.pop_back();
-    }
+    }
-}
+}
-
+
-void TextBox::tick(Minecraft* minecraft) {
+void TextBox::tick(Minecraft* minecraft) {
-    blinkTicks++;
+    blinkTicks++;
-    if (blinkTicks >= 5) {
+    if (blinkTicks >= 5) {
-        blink = !blink;
+        blink = !blink;
-        blinkTicks = 0;
+        blinkTicks = 0;
-    }
+    }
-}
+}
-
+
-void TextBox::render(Minecraft* minecraft, int xm, int ym) {
+void TextBox::render(Minecraft* minecraft, int xm, int ym) {
-    // textbox like in beta 1.7.3
+    // textbox like in beta 1.7.3
-    // change appearance when focused so the user can tell it's active
+    // change appearance when focused so the user can tell it's active
-    // active background darker gray with a subtle border
+    // active background darker gray with a subtle border
-    uint32_t bgColor = focused ? 0xffa0a0a0 : 0xffa0a0a0;
+    uint32_t bgColor = focused ? 0xffa0a0a0 : 0xffa0a0a0;
-    uint32_t borderColor = focused ? 0xff000000 : 0xff000000;
+    uint32_t borderColor = focused ? 0xff000000 : 0xff000000;
-    fill(x, y, x + width, y + height, bgColor);
+    fill(x, y, x + width, y + height, bgColor);
-    fill(x + 1, y + 1, x + width - 1, y + height - 1, borderColor);
+    fill(x + 1, y + 1, x + width - 1, y + height - 1, borderColor);
-
+
-    glEnable2(GL_SCISSOR_TEST);
+    glEnable2(GL_SCISSOR_TEST);
-    glScissor(
+    glScissor(
-        Gui::GuiScale * (x + 2), 
+        Gui::GuiScale * (x + 2), 
-        minecraft->height - Gui::GuiScale * (y + height - 2), 
+        minecraft->height - Gui::GuiScale * (y + height - 2), 
-        Gui::GuiScale * (width - 2), 
+        Gui::GuiScale * (width - 2), 
-        Gui::GuiScale * (height - 2)
+        Gui::GuiScale * (height - 2)
-    );
+    );
-
+
-	int _y = y + (height - Font::DefaultLineHeight) / 2;
+	int _y = y + (height - Font::DefaultLineHeight) / 2;
-
+
-    if (text.empty() && !focused) {
+    if (text.empty() && !focused) {
-        drawString(minecraft->font, hint, x + 2, _y, 0xff5e5e5e);
+        drawString(minecraft->font, hint, x + 2, _y, 0xff5e5e5e);
-    }
+    }
-
+
-    if (focused && blink) text.push_back('_');
+    if (focused && blink) text.push_back('_');
-
+
-    drawString(minecraft->font, text, x + 2, _y, 0xffffffff);
+    drawString(minecraft->font, text, x + 2, _y, 0xffffffff);
-
+
-    if (focused && blink) text.pop_back();
+    if (focused && blink) text.pop_back();
-
+
-    glDisable2(GL_SCISSOR_TEST);
+    glDisable2(GL_SCISSOR_TEST);
-}
+}

src/client/gui/components/TextBox.hpp

@@ -3,10 +3,10 @@
 //package net.minecraft.client.gui;
 
 #include <string>
-#include "GuiElement.h"
+#include "GuiElement.hpp"
-#include "../../Options.h"
+#include "client/Options.hpp"
-#include "../../../platform/input/Mouse.h"
+#include "platform/input/Mouse.hpp"
-#include "../../../platform/input/Keyboard.h"
+#include "platform/input/Keyboard.hpp"
 
 class Font;
 class Minecraft;

src/client/gui/components/TextOption.cpp

@@ -1,5 +1,5 @@
-#include "TextOption.h"
+#include "TextOption.hpp"
-#include <client/Minecraft.h>
+#include <client/Minecraft.hpp>
 
 TextOption::TextOption(Minecraft* minecraft, OptionId optId) 
     : TextBox((int)optId, minecraft->options.getOpt(optId)->getStringId()) 

src/client/gui/components/TextOption.hpp

@@ -1,6 +1,6 @@
 #pragma once
-#include "TextBox.h"
+#include "TextBox.hpp"
-#include <client/Options.h>
+#include <client/Options.hpp>
 
 class TextOption : public TextBox {
 public:

src/client/gui/screens/ArmorScreen.cpp

@@ -1,370 +1,370 @@
-#include "ArmorScreen.h"
+#include "ArmorScreen.hpp"
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
-#include "../components/NinePatch.h"
+#include "client/gui/components/NinePatch.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../renderer/entity/ItemRenderer.h"
+#include "client/renderer/entity/ItemRenderer.hpp"
-#include "../../../world/item/Item.h"
+#include "world/item/Item.hpp"
-#include "../../../world/item/ItemCategory.h"
+#include "world/item/ItemCategory.hpp"
-#include "../../../world/entity/player/Inventory.h"
+#include "world/entity/player/Inventory.hpp"
-#include "../../../world/entity/item/ItemEntity.h"
+#include "world/entity/item/ItemEntity.hpp"
-#include "../../../world/level/Level.h"
+#include "world/level/Level.hpp"
-#include "../../../network/RakNetInstance.h"
+#include "network/RakNetInstance.hpp"
-#include "../../renderer/entity/EntityRenderDispatcher.h"
+#include "client/renderer/entity/EntityRenderDispatcher.hpp"
-#include "../../../world/item/ArmorItem.h"
+#include "world/item/ArmorItem.hpp"
-
+
-static void setIfNotSet(bool& ref, bool condition) {
+static void setIfNotSet(bool& ref, bool condition) {
-	ref = (ref || condition);
+	ref = (ref || condition);
-}
+}
-
+
-const int   descFrameWidth = 100;
+const int   descFrameWidth = 100;
-
+
-const int rgbActive = 0xfff0f0f0;
+const int rgbActive = 0xfff0f0f0;
-const int rgbInactive = 0xc0635558;
+const int rgbInactive = 0xc0635558;
-const int rgbInactiveShadow = 0xc0aaaaaa;
+const int rgbInactiveShadow = 0xc0aaaaaa;
-
+
-#ifdef __APPLE__
+#ifdef __APPLE__
-	static const float BorderPixels = 4;
+	static const float BorderPixels = 4;
-	#ifdef DEMO_MODE
+	#ifdef DEMO_MODE
-		static const float BlockPixels = 22;
+		static const float BlockPixels = 22;
-	#else
+	#else
-		static const float BlockPixels = 22;
+		static const float BlockPixels = 22;
-	#endif
+	#endif
-#else
+#else
-	static const float BorderPixels = 4;
+	static const float BorderPixels = 4;
-	static const float BlockPixels = 24;
+	static const float BlockPixels = 24;
-#endif
+#endif
-static const int ItemSize = (int)(BlockPixels + 2*BorderPixels);
+static const int ItemSize = (int)(BlockPixels + 2*BorderPixels);
-
+
-static const int Bx = 10; // Border Frame width
+static const int Bx = 10; // Border Frame width
-static const int By = 6; // Border Frame height
+static const int By = 6; // Border Frame height
-
+
-
+
-ArmorScreen::ArmorScreen():
+ArmorScreen::ArmorScreen():
-	inventoryPane(NULL),
+	inventoryPane(NULL),
-	btnArmor0(0),
+	btnArmor0(0),
-	btnArmor1(1),
+	btnArmor1(1),
-	btnArmor2(2),
+	btnArmor2(2),
-	btnArmor3(3),
+	btnArmor3(3),
-	btnClose(4, ""),
+	btnClose(4, ""),
-	bHeader (5, "Armor"),
+	bHeader (5, "Armor"),
-	guiBackground(NULL),
+	guiBackground(NULL),
-	guiSlot(NULL),
+	guiSlot(NULL),
-	guiPaneFrame(NULL),
+	guiPaneFrame(NULL),
-	guiPlayerBg(NULL),
+	guiPlayerBg(NULL),
-	doRecreatePane(false),
+	doRecreatePane(false),
-	descWidth(90)
+	descWidth(90)
-	//guiSlotItem(NULL),
+	//guiSlotItem(NULL),
-	//guiSlotItemSelected(NULL)
+	//guiSlotItemSelected(NULL)
-{
+{
-	//LOGI("Creating ArmorScreen with %p, %d\n", furnace, furnace->runningId);
+	//LOGI("Creating ArmorScreen with %p, %d\n", furnace, furnace->runningId);
-}
+}
-
+
-ArmorScreen::~ArmorScreen() {
+ArmorScreen::~ArmorScreen() {
-	delete inventoryPane;
+	delete inventoryPane;
-
+
-	delete guiBackground;
+	delete guiBackground;
-	delete guiSlot;
+	delete guiSlot;
-	delete guiPaneFrame;
+	delete guiPaneFrame;
-	delete guiPlayerBg;
+	delete guiPlayerBg;
-}
+}
-
+
-void ArmorScreen::init() {
+void ArmorScreen::init() {
-	super::init();
+	super::init();
-
+
-	player = minecraft->player;
+	player = minecraft->player;
-
+
-	ImageDef def;
+	ImageDef def;
-	def.name = "gui/spritesheet.png";
+	def.name = "gui/spritesheet.png";
-	def.x = 0;
+	def.x = 0;
-	def.y = 1;
+	def.y = 1;
-	def.width = def.height = 18;
+	def.width = def.height = 18;
-	def.setSrc(IntRectangle(60, 0, 18, 18));
+	def.setSrc(IntRectangle(60, 0, 18, 18));
-	btnClose.setImageDef(def, true);
+	btnClose.setImageDef(def, true);
-	btnClose.scaleWhenPressed = false;
+	btnClose.scaleWhenPressed = false;
-
+
-	buttons.push_back(&bHeader);
+	buttons.push_back(&bHeader);
-	buttons.push_back(&btnClose);
+	buttons.push_back(&btnClose);
-
+
-	armorButtons[0] = &btnArmor0;
+	armorButtons[0] = &btnArmor0;
-	armorButtons[1] = &btnArmor1;
+	armorButtons[1] = &btnArmor1;
-	armorButtons[2] = &btnArmor2;
+	armorButtons[2] = &btnArmor2;
-	armorButtons[3] = &btnArmor3;
+	armorButtons[3] = &btnArmor3;
-	for (int i = 0; i < NUM_ARMORBUTTONS; ++i)
+	for (int i = 0; i < NUM_ARMORBUTTONS; ++i)
-		buttons.push_back(armorButtons[i]);
+		buttons.push_back(armorButtons[i]);
-
+
-	// GUI - nine patches
+	// GUI - nine patches
-	NinePatchFactory builder(minecraft->textures, "gui/spritesheet.png");
+	NinePatchFactory builder(minecraft->textures, "gui/spritesheet.png");
-
+
-	guiBackground   = builder.createSymmetrical(IntRectangle(0, 0, 16, 16), 4, 4);
+	guiBackground   = builder.createSymmetrical(IntRectangle(0, 0, 16, 16), 4, 4);
-	guiSlot         = builder.createSymmetrical(IntRectangle(0, 32, 8, 8), 3, 3, 20, 20);
+	guiSlot         = builder.createSymmetrical(IntRectangle(0, 32, 8, 8), 3, 3, 20, 20);
-	guiPaneFrame    = builder.createSymmetrical(IntRectangle(28, 42, 4, 4), 1, 1)->setExcluded(1 << 4);
+	guiPaneFrame    = builder.createSymmetrical(IntRectangle(28, 42, 4, 4), 1, 1)->setExcluded(1 << 4);
-	guiPlayerBg     = builder.createSymmetrical(IntRectangle(0, 20, 8, 8), 3, 3);
+	guiPlayerBg     = builder.createSymmetrical(IntRectangle(0, 20, 8, 8), 3, 3);
-
+
-	updateItems();
+	updateItems();
-}
+}
-
+
-void ArmorScreen::setupPositions() {
+void ArmorScreen::setupPositions() {
-	// Left  - Categories
+	// Left  - Categories
-	bHeader.x = bHeader.y = 0;
+	bHeader.x = bHeader.y = 0;
-	bHeader.width = width;// -  bDone.w;
+	bHeader.width = width;// -  bDone.w;
-
+
-	btnClose.width = btnClose.height = 19;
+	btnClose.width = btnClose.height = 19;
-	btnClose.x = width - btnClose.width;
+	btnClose.x = width - btnClose.width;
-	btnClose.y = 0;
+	btnClose.y = 0;
-
+
-	// Inventory pane
+	// Inventory pane
-	const int maxWidth = (int)(width/1.8f) - Bx - Bx;
+	const int maxWidth = (int)(width/1.8f) - Bx - Bx;
-	const int InventoryColumns = maxWidth / ItemSize;
+	const int InventoryColumns = maxWidth / ItemSize;
-	const int realWidth = InventoryColumns * ItemSize;
+	const int realWidth = InventoryColumns * ItemSize;
-	const int paneWidth = realWidth + Bx + Bx;
+	const int paneWidth = realWidth + Bx + Bx;
-	const int realBx = (paneWidth - realWidth) / 2;
+	const int realBx = (paneWidth - realWidth) / 2;
-
+
-	inventoryPaneRect = IntRectangle(realBx,
+	inventoryPaneRect = IntRectangle(realBx,
-#ifdef __APPLE__
+#ifdef __APPLE__
-		26 + By - ((width==240)?1:0), realWidth, ((width==240)?1:0) + height-By-By-28);
+		26 + By - ((width==240)?1:0), realWidth, ((width==240)?1:0) + height-By-By-28);
-#else
+#else
-		26 + By, realWidth, height-By-By-28);
+		26 + By, realWidth, height-By-By-28);
-#endif
+#endif
-
+
-	for (int i = 0; i < NUM_ARMORBUTTONS; ++i) {
+	for (int i = 0; i < NUM_ARMORBUTTONS; ++i) {
-		Button& b = *armorButtons[i];
+		Button& b = *armorButtons[i];
-		b.x = paneWidth;
+		b.x = paneWidth;
-        b.y = inventoryPaneRect.y + 24 * i;
+        b.y = inventoryPaneRect.y + 24 * i;
-		b.width = 20;
+		b.width = 20;
-		b.height = 20;
+		b.height = 20;
-	}
+	}
-
+
-	guiPlayerBgRect.y = inventoryPaneRect.y;
+	guiPlayerBgRect.y = inventoryPaneRect.y;
-	int xx = armorButtons[0]->x + armorButtons[0]->width;
+	int xx = armorButtons[0]->x + armorButtons[0]->width;
-	int xw = width - xx;
+	int xw = width - xx;
-	guiPlayerBgRect.x = xx + xw / 10;
+	guiPlayerBgRect.x = xx + xw / 10;
-	guiPlayerBgRect.w = xw - (xw / 10) * 2;
+	guiPlayerBgRect.w = xw - (xw / 10) * 2;
-	guiPlayerBgRect.h = inventoryPaneRect.h;
+	guiPlayerBgRect.h = inventoryPaneRect.h;
-
+
-	guiPaneFrame->setSize((float)inventoryPaneRect.w + 2, (float)inventoryPaneRect.h + 2);
+	guiPaneFrame->setSize((float)inventoryPaneRect.w + 2, (float)inventoryPaneRect.h + 2);
-	guiPlayerBg->setSize((float)guiPlayerBgRect.w, (float)guiPlayerBgRect.h);
+	guiPlayerBg->setSize((float)guiPlayerBgRect.w, (float)guiPlayerBgRect.h);
-	guiBackground->setSize((float)width, (float)height);
+	guiBackground->setSize((float)width, (float)height);
-
+
-	updateItems();
+	updateItems();
-	setupInventoryPane();
+	setupInventoryPane();
-}
+}
-
+
-void ArmorScreen::tick() {
+void ArmorScreen::tick() {
-	if (inventoryPane)
+	if (inventoryPane)
-		inventoryPane->tick();
+		inventoryPane->tick();
-
+
-	if (doRecreatePane) {
+	if (doRecreatePane) {
-		updateItems();
+		updateItems();
-		setupInventoryPane();
+		setupInventoryPane();
-		doRecreatePane = false;
+		doRecreatePane = false;
-	}
+	}
-}
+}
-
+
-void ArmorScreen::handleRenderPane(Touch::InventoryPane* pane, Tesselator& t, int xm, int ym, float a) {
+void ArmorScreen::handleRenderPane(Touch::InventoryPane* pane, Tesselator& t, int xm, int ym, float a) {
-	if (pane) {
+	if (pane) {
-		pane->render(xm, ym, a);
+		pane->render(xm, ym, a);
-		guiPaneFrame->draw(t, (float)(pane->rect.x - 1), (float)(pane->rect.y - 1));
+		guiPaneFrame->draw(t, (float)(pane->rect.x - 1), (float)(pane->rect.y - 1));
-	}
+	}
-}
+}
-
+
-void ArmorScreen::render(int xm, int ym, float a) {
+void ArmorScreen::render(int xm, int ym, float a) {
-	//renderBackground();
+	//renderBackground();
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-
+
-    t.addOffset(0, 0, -500);
+    t.addOffset(0, 0, -500);
-	guiBackground->draw(t, 0, 0);
+	guiBackground->draw(t, 0, 0);
-    t.addOffset(0, 0, 500);
+    t.addOffset(0, 0, 500);
-	glEnable2(GL_ALPHA_TEST);
+	glEnable2(GL_ALPHA_TEST);
-
+
-	// Buttons (Left side + crafting)
+	// Buttons (Left side + crafting)
-	super::render(xm, ym, a);
+	super::render(xm, ym, a);
-
+
-	handleRenderPane(inventoryPane, t, xm, ym, a);
+	handleRenderPane(inventoryPane, t, xm, ym, a);
-
+
-	t.colorABGR(0xffffffff);
+	t.colorABGR(0xffffffff);
-	glColor4f2(1, 1, 1, 1);
+	glColor4f2(1, 1, 1, 1);
-
+
-	t.addOffset(0, 0, -490);
+	t.addOffset(0, 0, -490);
-	guiPlayerBg->draw(t, (float)guiPlayerBgRect.x, (float)guiPlayerBgRect.y);
+	guiPlayerBg->draw(t, (float)guiPlayerBgRect.x, (float)guiPlayerBgRect.y);
-	t.addOffset(0, 0, 490);
+	t.addOffset(0, 0, 490);
-	renderPlayer((float)(guiPlayerBgRect.x + guiPlayerBgRect.w / 2), 0.85f * height);
+	renderPlayer((float)(guiPlayerBgRect.x + guiPlayerBgRect.w / 2), 0.85f * height);
-
+
-	for (int i = 0; i < NUM_ARMORBUTTONS; ++i) {
+	for (int i = 0; i < NUM_ARMORBUTTONS; ++i) {
-		drawSlotItemAt(t, i, player->getArmor(i), armorButtons[i]->x, armorButtons[i]->y);
+		drawSlotItemAt(t, i, player->getArmor(i), armorButtons[i]->x, armorButtons[i]->y);
-	}
+	}
-	glDisable2(GL_ALPHA_TEST);
+	glDisable2(GL_ALPHA_TEST);
-}
+}
-
+
-void ArmorScreen::buttonClicked(Button* button) {
+void ArmorScreen::buttonClicked(Button* button) {
-	if (button == &btnClose) {
+	if (button == &btnClose) {
-		minecraft->setScreen(NULL);
+		minecraft->setScreen(NULL);
-	}
+	}
-
+
-	if (button->id >= 0 && button->id <= 3) {
+	if (button->id >= 0 && button->id <= 3) {
-		takeAndClearSlot(button->id);
+		takeAndClearSlot(button->id);
-	}
+	}
-}
+}
-
+
-bool ArmorScreen::addItem(const Touch::InventoryPane* forPane, int itemIndex) {
+bool ArmorScreen::addItem(const Touch::InventoryPane* forPane, int itemIndex) {
-	const ItemInstance* instance = armorItems[itemIndex];
+	const ItemInstance* instance = armorItems[itemIndex];
-	if (!ItemInstance::isArmorItem(instance))
+	if (!ItemInstance::isArmorItem(instance))
-		return false;
+		return false;
-
+
-	ArmorItem* item = (ArmorItem*) instance->getItem();
+	ArmorItem* item = (ArmorItem*) instance->getItem();
-	ItemInstance* old = player->getArmor(item->slot);
+	ItemInstance* old = player->getArmor(item->slot);
-	ItemInstance oldArmor;
+	ItemInstance oldArmor;
-
+
-	if (ItemInstance::isArmorItem(old)) {
+	if (ItemInstance::isArmorItem(old)) {
-		oldArmor = *old;
+		oldArmor = *old;
-	}
+	}
-
+
-	player->setArmor(item->slot, instance);
+	player->setArmor(item->slot, instance);
-
+
-	player->inventory->removeItem(instance);
+	player->inventory->removeItem(instance);
-	//@attn: this is hugely important
+	//@attn: this is hugely important
-	armorItems[itemIndex] = NULL;
+	armorItems[itemIndex] = NULL;
-
+
-	if (!oldArmor.isNull()) {
+	if (!oldArmor.isNull()) {
-		if (!player->inventory->add(&oldArmor)) {
+		if (!player->inventory->add(&oldArmor)) {
-			player->drop(new ItemInstance(oldArmor), false);
+			player->drop(new ItemInstance(oldArmor), false);
-		}
+		}
-	}
+	}
-
+
-	doRecreatePane = true;
+	doRecreatePane = true;
-	return true;
+	return true;
-}
+}
-
+
-bool ArmorScreen::isAllowed( int slot ) {
+bool ArmorScreen::isAllowed( int slot ) {
-	return true;
+	return true;
-}
+}
-
+
-bool ArmorScreen::renderGameBehind() {
+bool ArmorScreen::renderGameBehind() {
-	return false;
+	return false;
-}
+}
-
+
-std::vector<const ItemInstance*> ArmorScreen::getItems( const Touch::InventoryPane* forPane ) {
+std::vector<const ItemInstance*> ArmorScreen::getItems( const Touch::InventoryPane* forPane ) {
-	return armorItems;
+	return armorItems;
-}
+}
-
+
-void ArmorScreen::updateItems() {
+void ArmorScreen::updateItems() {
-	armorItems.clear();
+	armorItems.clear();
-
+
-	for (int i = Inventory::MAX_SELECTION_SIZE; i < minecraft->player->inventory->getContainerSize(); ++i) {
+	for (int i = Inventory::MAX_SELECTION_SIZE; i < minecraft->player->inventory->getContainerSize(); ++i) {
-		ItemInstance* item = minecraft->player->inventory->getItem(i);
+		ItemInstance* item = minecraft->player->inventory->getItem(i);
-		if (ItemInstance::isArmorItem(item))
+		if (ItemInstance::isArmorItem(item))
-			armorItems.push_back(item);
+			armorItems.push_back(item);
-	}
+	}
-}
+}
-
+
-bool ArmorScreen::canMoveToSlot(int slot, const ItemInstance* item) {
+bool ArmorScreen::canMoveToSlot(int slot, const ItemInstance* item) {
-	return ItemInstance::isArmorItem(item)
+	return ItemInstance::isArmorItem(item)
-		&& ((ArmorItem*)item)->slot == slot;
+		&& ((ArmorItem*)item)->slot == slot;
-}
+}
-
+
-void ArmorScreen::setupInventoryPane() {
+void ArmorScreen::setupInventoryPane() {
-	// IntRectangle(0, 0, 100, 100)
+	// IntRectangle(0, 0, 100, 100)
-	if (inventoryPane) delete inventoryPane;
+	if (inventoryPane) delete inventoryPane;
-	inventoryPane = new Touch::InventoryPane(this, minecraft, inventoryPaneRect, inventoryPaneRect.w, BorderPixels, armorItems.size(), ItemSize, (int)BorderPixels);
+	inventoryPane = new Touch::InventoryPane(this, minecraft, inventoryPaneRect, inventoryPaneRect.w, BorderPixels, armorItems.size(), ItemSize, (int)BorderPixels);
-	inventoryPane->fillMarginX = 0;
+	inventoryPane->fillMarginX = 0;
-	inventoryPane->fillMarginY = 0;
+	inventoryPane->fillMarginY = 0;
-	//LOGI("Creating new pane: %d %p\n", inventoryItems.size(), inventoryPane);
+	//LOGI("Creating new pane: %d %p\n", inventoryItems.size(), inventoryPane);
-}
+}
-
+
-void ArmorScreen::drawSlotItemAt( Tesselator& t, int slot, const ItemInstance* item, int x, int y)
+void ArmorScreen::drawSlotItemAt( Tesselator& t, int slot, const ItemInstance* item, int x, int y)
-{
+{
-	float xx = (float)x;
+	float xx = (float)x;
-	float yy = (float)y;
+	float yy = (float)y;
-
+
-	guiSlot->draw(t, xx, yy);
+	guiSlot->draw(t, xx, yy);
-
+
-	if (item && !item->isNull()) {
+	if (item && !item->isNull()) {
-		ItemRenderer::renderGuiItem(minecraft->font, minecraft->textures, item, xx + 2, yy, true);
+		ItemRenderer::renderGuiItem(minecraft->font, minecraft->textures, item, xx + 2, yy, true);
-        glDisable2(GL_TEXTURE_2D);
+        glDisable2(GL_TEXTURE_2D);
-        ItemRenderer::renderGuiItemDecorations(item, xx + 2, yy + 3);
+        ItemRenderer::renderGuiItemDecorations(item, xx + 2, yy + 3);
-        glEnable2(GL_TEXTURE_2D);
+        glEnable2(GL_TEXTURE_2D);
-		//minecraft->gui.renderSlotText(item, xx + 3, yy + 3, true, true);
+		//minecraft->gui.renderSlotText(item, xx + 3, yy + 3, true, true);
-	} else {
+	} else {
-        minecraft->textures->loadAndBindTexture("gui/items.png");
+        minecraft->textures->loadAndBindTexture("gui/items.png");
-        blit(x + 2, y, 15 * 16, slot * 16, 16, 16, 16, 16);
+        blit(x + 2, y, 15 * 16, slot * 16, 16, 16, 16, 16);
-    }
+    }
-}
+}
-
+
-void ArmorScreen::takeAndClearSlot( int slot ) {
+void ArmorScreen::takeAndClearSlot( int slot ) {
-	ItemInstance* item = player->getArmor(slot);
+	ItemInstance* item = player->getArmor(slot);
-	if (!item)
+	if (!item)
-		return;
+		return;
-
+
-	int oldSize = minecraft->player->inventory->getNumEmptySlots();
+	int oldSize = minecraft->player->inventory->getNumEmptySlots();
-
+
-	if (!minecraft->player->inventory->add(item))
+	if (!minecraft->player->inventory->add(item))
-		minecraft->player->drop(new ItemInstance(*item), false);
+		minecraft->player->drop(new ItemInstance(*item), false);
-
+
-	player->setArmor(slot, NULL);
+	player->setArmor(slot, NULL);
-
+
-	int newSize = minecraft->player->inventory->getNumEmptySlots();
+	int newSize = minecraft->player->inventory->getNumEmptySlots();
-	setIfNotSet(doRecreatePane, newSize != oldSize);
+	setIfNotSet(doRecreatePane, newSize != oldSize);
-}
+}
-
+
-void ArmorScreen::renderPlayer(float xo, float yo) {
+void ArmorScreen::renderPlayer(float xo, float yo) {
-	// Push GL and player state
+	// Push GL and player state
-	glPushMatrix();
+	glPushMatrix();
-
+
-	glTranslatef(xo, yo, -200);
+	glTranslatef(xo, yo, -200);
-	float ss = 45;
+	float ss = 45;
-	glScalef(-ss, ss, ss);
+	glScalef(-ss, ss, ss);
-
+
-	glRotatef(180, 0, 0, 1);
+	glRotatef(180, 0, 0, 1);
-	//glDisable(GL_DEPTH_TEST);
+	//glDisable(GL_DEPTH_TEST);
-
+
-	Player* player = (Player*) minecraft->player;
+	Player* player = (Player*) minecraft->player;
-	float oybr = player->yBodyRot;
+	float oybr = player->yBodyRot;
-	float oyr = player->yRot;
+	float oyr = player->yRot;
-	float oxr = player->xRot;
+	float oxr = player->xRot;
-
+
-	float t = getTimeS();
+	float t = getTimeS();
-
+
-	float xd = 10 * Mth::sin(t);//(xo + 51) - xm;
+	float xd = 10 * Mth::sin(t);//(xo + 51) - xm;
-	float yd = 10 * Mth::cos(t * 0.05f);//(yo + 75 - 50) - ym;
+	float yd = 10 * Mth::cos(t * 0.05f);//(yo + 75 - 50) - ym;
-
+
-	glRotatef(45 + 90, 0, 1, 0);
+	glRotatef(45 + 90, 0, 1, 0);
-	glRotatef(-45 - 90, 0, 1, 0);
+	glRotatef(-45 - 90, 0, 1, 0);
-
+
-	const float xtan = Mth::atan(xd / 40.0f) * +20;
+	const float xtan = Mth::atan(xd / 40.0f) * +20;
-	const float ytan = Mth::atan(yd / 40.0f) * -20;
+	const float ytan = Mth::atan(yd / 40.0f) * -20;
-
+
-	glRotatef(ytan, 1, 0, 0);
+	glRotatef(ytan, 1, 0, 0);
-
+
-	player->yBodyRot = xtan;
+	player->yBodyRot = xtan;
-	player->yRot = xtan + xtan;
+	player->yRot = xtan + xtan;
-	player->xRot = ytan;
+	player->xRot = ytan;
-	glTranslatef(0, player->heightOffset, 0);
+	glTranslatef(0, player->heightOffset, 0);
-
+
-	// Push walking anim
+	// Push walking anim
-	float oldWAP = player->walkAnimPos;
+	float oldWAP = player->walkAnimPos;
-	float oldWAS = player->walkAnimSpeed;
+	float oldWAS = player->walkAnimSpeed;
-	float oldWASO = player->walkAnimSpeedO;
+	float oldWASO = player->walkAnimSpeedO;
-
+
-	// Set new walking anim
+	// Set new walking anim
-	player->walkAnimSpeedO = player->walkAnimSpeed = 0.25f;
+	player->walkAnimSpeedO = player->walkAnimSpeed = 0.25f;
-	player->walkAnimPos = getTimeS() * player->walkAnimSpeed * SharedConstants::TicksPerSecond;
+	player->walkAnimPos = getTimeS() * player->walkAnimSpeed * SharedConstants::TicksPerSecond;
-
+
-	EntityRenderDispatcher* rd = EntityRenderDispatcher::getInstance();
+	EntityRenderDispatcher* rd = EntityRenderDispatcher::getInstance();
-	rd->playerRotY = 180;
+	rd->playerRotY = 180;
-	rd->render(player, 0, 0, 0, 0, 1);
+	rd->render(player, 0, 0, 0, 0, 1);
-
+
-	// Pop walking anim
+	// Pop walking anim
-	player->walkAnimPos = oldWAP;
+	player->walkAnimPos = oldWAP;
-	player->walkAnimSpeed = oldWAS;
+	player->walkAnimSpeed = oldWAS;
-	player->walkAnimSpeedO = oldWASO;
+	player->walkAnimSpeedO = oldWASO;
-
+
-	//glEnable(GL_DEPTH_TEST);
+	//glEnable(GL_DEPTH_TEST);
-	// Pop GL and player state
+	// Pop GL and player state
-	player->yBodyRot = oybr;
+	player->yBodyRot = oybr;
-	player->yRot = oyr;
+	player->yRot = oyr;
-	player->xRot = oxr;
+	player->xRot = oxr;
-
+
-	glPopMatrix();
+	glPopMatrix();
-}
+}

src/client/gui/screens/ArmorScreen.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "BaseContainerScreen.h"
+#include "BaseContainerScreen.hpp"
 
-#include "../components/InventoryPane.h"
+#include "client/gui/components/InventoryPane.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
 
 class Font;
 class CItem;

src/client/gui/screens/BaseContainerScreen.hpp

@@ -3,9 +3,9 @@
 //package net.minecraft.client.gui.screens;
 
 #include <vector>
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
 
 class BaseContainerMenu;
 

src/client/gui/screens/ChatScreen.cpp

@@ -1,24 +1,24 @@
-#include "ChatScreen.h"
+#include "ChatScreen.hpp"
-#include "DialogDefinitions.h"
+#include "DialogDefinitions.hpp"
-#include "../Gui.h"
+#include "client/gui/Gui.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../../AppPlatform.h"
+#include "AppPlatform.hpp"
-#include "../../../platform/log.h"
+#include "platform/log.hpp"
-
+
-void ChatScreen::init() {
+void ChatScreen::init() {
-	minecraft->platform()->createUserInput(DialogDefinitions::DIALOG_NEW_CHAT_MESSAGE);
+	minecraft->platform()->createUserInput(DialogDefinitions::DIALOG_NEW_CHAT_MESSAGE);
-}
+}
-
+
-void ChatScreen::render(int xm, int ym, float a)
+void ChatScreen::render(int xm, int ym, float a)
-{
+{
-	int status = minecraft->platform()->getUserInputStatus();
+	int status = minecraft->platform()->getUserInputStatus();
-	if (status > -1) {
+	if (status > -1) {
-		if (status == 1) {
+		if (status == 1) {
-			std::vector<std::string> v = minecraft->platform()->getUserInput();
+			std::vector<std::string> v = minecraft->platform()->getUserInput();
-			if (v.size() && v[0].length() > 0)
+			if (v.size() && v[0].length() > 0)
-				minecraft->gui.addMessage(v[0]);
+				minecraft->gui.addMessage(v[0]);
-		}
+		}
-
+
-		minecraft->setScreen(NULL);
+		minecraft->setScreen(NULL);
-	}
+	}
-}
+}

src/client/gui/screens/ChatScreen.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
 
 class ChatScreen: public Screen
 {

src/client/gui/screens/ChestScreen.cpp

@@ -1,474 +1,474 @@
-#include "ChestScreen.h"
+#include "ChestScreen.hpp"
-#include "touch/TouchStartMenuScreen.h"
+#include "touch/TouchStartMenuScreen.hpp"
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
-#include "../components/NinePatch.h"
+#include "client/gui/components/NinePatch.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
-#include "../../renderer/Tesselator.h"
+#include "client/renderer/Tesselator.hpp"
-#include "../../renderer/entity/ItemRenderer.h"
+#include "client/renderer/entity/ItemRenderer.hpp"
-#include "../../../world/item/Item.h"
+#include "world/item/Item.hpp"
-#include "../../../world/item/ItemCategory.h"
+#include "world/item/ItemCategory.hpp"
-#include "../../../world/entity/player/Inventory.h"
+#include "world/entity/player/Inventory.hpp"
-#include "../../../world/entity/item/ItemEntity.h"
+#include "world/entity/item/ItemEntity.hpp"
-#include "../../../world/level/Level.h"
+#include "world/level/Level.hpp"
-#include "../../../locale/I18n.h"
+#include "locale/I18n.hpp"
-#include "../../../util/StringUtils.h"
+#include "util/StringUtils.hpp"
-#include "../../../network/packet/ContainerSetSlotPacket.h"
+#include "network/packet/ContainerSetSlotPacket.hpp"
-#include "../../../network/RakNetInstance.h"
+#include "network/RakNetInstance.hpp"
-#include "../../../world/level/tile/entity/TileEntity.h"
+#include "world/level/tile/entity/TileEntity.hpp"
-#include "../../../world/level/tile/entity/ChestTileEntity.h"
+#include "world/level/tile/entity/ChestTileEntity.hpp"
-#include "../../../world/inventory/ContainerMenu.h"
+#include "world/inventory/ContainerMenu.hpp"
-#include "../../../util/Mth.h"
+#include "util/Mth.hpp"
-
+
-//static NinePatchLayer* guiPaneFrame = NULL;
+//static NinePatchLayer* guiPaneFrame = NULL;
-
+
-static inline void setIfNotSet(bool& ref, bool condition) {
+static inline void setIfNotSet(bool& ref, bool condition) {
-	ref = (ref || condition);
+	ref = (ref || condition);
-}
+}
-
+
-template<typename T,typename V>
+template<typename T,typename V>
-T* upcast(V* x) { return x; }
+T* upcast(V* x) { return x; }
-
+
-static int heldMs = -1;
+static int heldMs = -1;
-static int percent = -1;
+static int percent = -1;
-static const float MaxHoldMs = 500.0f;
+static const float MaxHoldMs = 500.0f;
-static const int MinChargeMs = 200;
+static const int MinChargeMs = 200;
-
+
-class ItemDiffer {
+class ItemDiffer {
-public:
+public:
-	ItemDiffer(int size)
+	ItemDiffer(int size)
-	:	size(size),
+	:	size(size),
-		count(0)
+		count(0)
-	{
+	{
-		base = new ItemInstance[size];
+		base = new ItemInstance[size];
-	}
+	}
-	ItemDiffer(const std::vector<const ItemInstance*>& v)
+	ItemDiffer(const std::vector<const ItemInstance*>& v)
-	:	size(v.size()),
+	:	size(v.size()),
-		count(0)
+		count(0)
-	{
+	{
-		base = new ItemInstance[size];
+		base = new ItemInstance[size];
-		init(v);
+		init(v);
-	}
+	}
-
+
-	~ItemDiffer() {
+	~ItemDiffer() {
-		delete[] base;
+		delete[] base;
-	}
+	}
-
+
-	void init(const std::vector<const ItemInstance*>& v) {
+	void init(const std::vector<const ItemInstance*>& v) {
-		for (int i = 0; i < size; ++i) {
+		for (int i = 0; i < size; ++i) {
-			if (v[i]) base[i] = *v[i];
+			if (v[i]) base[i] = *v[i];
-			else      base[i].setNull();
+			else      base[i].setNull();
-		}
+		}
-	}
+	}
-
+
-	int getDiff(const std::vector<const ItemInstance*>& v, std::vector<int>& outIndices) {
+	int getDiff(const std::vector<const ItemInstance*>& v, std::vector<int>& outIndices) {
-		int diffLen = v.size() - size;
+		int diffLen = v.size() - size;
-		int minLen = Mth::Max((int)v.size(), size);
+		int minLen = Mth::Max((int)v.size(), size);
-		for (int i = 0; i < minLen; ++i) {
+		for (int i = 0; i < minLen; ++i) {
-			//LOGI("%s, %s\n", base[i].toString().c_str(), v[i]?v[i]->toString().c_str() : "null");
+			//LOGI("%s, %s\n", base[i].toString().c_str(), v[i]?v[i]->toString().c_str() : "null");
-			if (!ItemInstance::matchesNulls(&base[i], v[i]))
+			if (!ItemInstance::matchesNulls(&base[i], v[i]))
-				outIndices.push_back(i);
+				outIndices.push_back(i);
-		}
+		}
-		return diffLen;
+		return diffLen;
-	}
+	}
-
+
-private:
+private:
-	int size;
+	int size;
-	int count;
+	int count;
-	ItemInstance* base;
+	ItemInstance* base;
-};
+};
-
+
-const int   descFrameWidth = 100;
+const int   descFrameWidth = 100;
-
+
-const int rgbActive = 0xfff0f0f0;
+const int rgbActive = 0xfff0f0f0;
-const int rgbInactive = 0xc0635558;
+const int rgbInactive = 0xc0635558;
-const int rgbInactiveShadow = 0xc0aaaaaa;
+const int rgbInactiveShadow = 0xc0aaaaaa;
-
+
-#ifdef __APPLE__
+#ifdef __APPLE__
-	static const float BorderPixels = 3;
+	static const float BorderPixels = 3;
-	#ifdef DEMO_MODE
+	#ifdef DEMO_MODE
-		static const float BlockPixels = 22;
+		static const float BlockPixels = 22;
-	#else
+	#else
-		static const float BlockPixels = 22;
+		static const float BlockPixels = 22;
-	#endif
+	#endif
-#else
+#else
-	static const float BorderPixels = 4;
+	static const float BorderPixels = 4;
-	static const float BlockPixels = 24;
+	static const float BlockPixels = 24;
-#endif
+#endif
-static const int ItemSize = (int)(BlockPixels + 2*BorderPixels);
+static const int ItemSize = (int)(BlockPixels + 2*BorderPixels);
-
+
-static const int Bx = 10; // Border Frame width
+static const int Bx = 10; // Border Frame width
-static const int By = 6; // Border Frame height
+static const int By = 6; // Border Frame height
-
+
-typedef struct FlyingItem {
+typedef struct FlyingItem {
-	ItemInstance item;
+	ItemInstance item;
-	float startTime;
+	float startTime;
-	float sx, sy;
+	float sx, sy;
-	float dx, dy;
+	float dx, dy;
-} FlyingItem ;
+} FlyingItem ;
-
+
-static std::vector<FlyingItem> flyingItems;
+static std::vector<FlyingItem> flyingItems;
-
+
-ChestScreen::ChestScreen(Player* player, ChestTileEntity* chest)
+ChestScreen::ChestScreen(Player* player, ChestTileEntity* chest)
-:	super(new ContainerMenu(chest, chest->runningId)), //@huge @attn
+:	super(new ContainerMenu(chest, chest->runningId)), //@huge @attn
-	inventoryPane(NULL),
+	inventoryPane(NULL),
-	chestPane(NULL),
+	chestPane(NULL),
-	btnClose(4, ""),
+	btnClose(4, ""),
-	bHeader (5, "Inventory"),
+	bHeader (5, "Inventory"),
-	bHeaderChest (6, "Chest"),
+	bHeaderChest (6, "Chest"),
-	guiBackground(NULL),
+	guiBackground(NULL),
-	guiSlot(NULL),
+	guiSlot(NULL),
-	guiSlotMarked(NULL),
+	guiSlotMarked(NULL),
-	guiSlotMarker(NULL),
+	guiSlotMarker(NULL),
-	player(player),
+	player(player),
-	chest(chest),
+	chest(chest),
-	selectedSlot(-1),
+	selectedSlot(-1),
-	doRecreatePane(false)
+	doRecreatePane(false)
-	//guiSlotItem(NULL),
+	//guiSlotItem(NULL),
-	//guiSlotItemSelected(NULL)
+	//guiSlotItemSelected(NULL)
-{
+{
-}
+}
-
+
-ChestScreen::~ChestScreen() {
+ChestScreen::~ChestScreen() {
-	delete inventoryPane;
+	delete inventoryPane;
-	delete chestPane;
+	delete chestPane;
-
+
-	delete guiBackground;
+	delete guiBackground;
-	delete guiSlot;
+	delete guiSlot;
-	delete guiSlotMarked;
+	delete guiSlotMarked;
-	delete guiSlotMarker;
+	delete guiSlotMarker;
-	delete guiPaneFrame;
+	delete guiPaneFrame;
-
+
-	delete menu;
+	delete menu;
-
+
-	if (chest->clientSideOnly)
+	if (chest->clientSideOnly)
-		delete chest;
+		delete chest;
-}
+}
-
+
-void ChestScreen::init() {
+void ChestScreen::init() {
-	super::init();
+	super::init();
-	//printf("-> %d\n", width/2);
+	//printf("-> %d\n", width/2);
-
+
-	ImageDef def;
+	ImageDef def;
-	def.name = "gui/spritesheet.png";
+	def.name = "gui/spritesheet.png";
-	def.x = 0;
+	def.x = 0;
-	def.y = 1;
+	def.y = 1;
-	def.width = def.height = 18;
+	def.width = def.height = 18;
-	def.setSrc(IntRectangle(60, 0, 18, 18));
+	def.setSrc(IntRectangle(60, 0, 18, 18));
-	btnClose.setImageDef(def, true);
+	btnClose.setImageDef(def, true);
-	btnClose.scaleWhenPressed = false;
+	btnClose.scaleWhenPressed = false;
-
+
-	buttons.push_back(&bHeader);
+	buttons.push_back(&bHeader);
-	buttons.push_back(&bHeaderChest);
+	buttons.push_back(&bHeaderChest);
-	buttons.push_back(&btnClose);
+	buttons.push_back(&btnClose);
-
+
-	// GUI - nine patches
+	// GUI - nine patches
-	NinePatchFactory builder(minecraft->textures, "gui/spritesheet.png");
+	NinePatchFactory builder(minecraft->textures, "gui/spritesheet.png");
-
+
-	guiBackground   = builder.createSymmetrical(IntRectangle(0, 0, 16, 16), 4, 4);
+	guiBackground   = builder.createSymmetrical(IntRectangle(0, 0, 16, 16), 4, 4);
-	guiSlot         = builder.createSymmetrical(IntRectangle(0, 32, 8, 8), 3, 3);
+	guiSlot         = builder.createSymmetrical(IntRectangle(0, 32, 8, 8), 3, 3);
-	guiSlotMarked   = builder.createSymmetrical(IntRectangle(0, 44, 8, 8), 3, 3);
+	guiSlotMarked   = builder.createSymmetrical(IntRectangle(0, 44, 8, 8), 3, 3);
-	guiSlotMarker   = builder.createSymmetrical(IntRectangle(10, 42, 16, 16), 5, 5);
+	guiSlotMarker   = builder.createSymmetrical(IntRectangle(10, 42, 16, 16), 5, 5);
-	guiPaneFrame    = builder.createSymmetrical(IntRectangle(28, 42, 4, 4), 1, 1)->exclude(4);
+	guiPaneFrame    = builder.createSymmetrical(IntRectangle(28, 42, 4, 4), 1, 1)->exclude(4);
-}
+}
-
+
-void ChestScreen::setupPositions() {
+void ChestScreen::setupPositions() {
-	// Left  - Categories
+	// Left  - Categories
-	bHeader.x = 0;
+	bHeader.x = 0;
-	bHeader.y = bHeaderChest.y = 0;
+	bHeader.y = bHeaderChest.y = 0;
-	bHeader.width = bHeaderChest.width = width / 2;// -  bDone.w;
+	bHeader.width = bHeaderChest.width = width / 2;// -  bDone.w;
-	bHeaderChest.x = bHeader.x + bHeader.width;
+	bHeaderChest.x = bHeader.x + bHeader.width;
-
+
-	// Right  - Description
+	// Right  - Description
-	btnClose.width = btnClose.height = 19;
+	btnClose.width = btnClose.height = 19;
-	btnClose.x = width - btnClose.width;
+	btnClose.x = width - btnClose.width;
-	btnClose.y = 0;
+	btnClose.y = 0;
-
+
-	//guiPaneFrame->setSize((float)paneFuelRect.w + 2, (float)paneFuelRect.h + 4);
+	//guiPaneFrame->setSize((float)paneFuelRect.w + 2, (float)paneFuelRect.h + 4);
-	guiBackground->setSize((float)width, (float)height);
+	guiBackground->setSize((float)width, (float)height);
-	//guiSlotItem->setSize((float)width, 22); //@todo
+	//guiSlotItem->setSize((float)width, 22); //@todo
-	//guiSlotItemSelected->setSize((float)width, 22);
+	//guiSlotItemSelected->setSize((float)width, 22);
-
+
-	setupPane();
+	setupPane();
-}
+}
-
+
-void ChestScreen::tick() {
+void ChestScreen::tick() {
-	if (inventoryPane)
+	if (inventoryPane)
-		inventoryPane->tick();
+		inventoryPane->tick();
-
+
-	if (chestPane)
+	if (chestPane)
-		chestPane->tick();
+		chestPane->tick();
-
+
-	if (doRecreatePane) {
+	if (doRecreatePane) {
-		setupPane();
+		setupPane();
-		doRecreatePane = false;
+		doRecreatePane = false;
-	}
+	}
-}
+}
-
+
-void ChestScreen::handleRenderPane(Touch::InventoryPane* pane, Tesselator& t, int xm, int ym, float a) {
+void ChestScreen::handleRenderPane(Touch::InventoryPane* pane, Tesselator& t, int xm, int ym, float a) {
-	if (pane) {
+	if (pane) {
-		int ms, id;
+		int ms, id;
-		pane->markerIndex = -1;
+		pane->markerIndex = -1;
-		if (pane->queryHoldTime(&id, &ms)) {
+		if (pane->queryHoldTime(&id, &ms)) {
-			heldMs = ms;
+			heldMs = ms;
-
+
-			FillingContainer* c = (pane == inventoryPane)?
+			FillingContainer* c = (pane == inventoryPane)?
-					upcast<FillingContainer>(minecraft->player->inventory)
+					upcast<FillingContainer>(minecraft->player->inventory)
-				:	upcast<FillingContainer>(chest);
+				:	upcast<FillingContainer>(chest);
-
+
-			const int slotIndex = id + c->getNumLinkedSlots();
+			const int slotIndex = id + c->getNumLinkedSlots();
-			ItemInstance* item = c->getItem(slotIndex);
+			ItemInstance* item = c->getItem(slotIndex);
-			int count = (item && !item->isNull())? item->count : 0;
+			int count = (item && !item->isNull())? item->count : 0;
-			float maxHoldMs = item? 700 + 10 * item->count: MaxHoldMs;
+			float maxHoldMs = item? 700 + 10 * item->count: MaxHoldMs;
-
+
-			if (count > 1) {
+			if (count > 1) {
-				float share = (heldMs-MinChargeMs) / maxHoldMs;
+				float share = (heldMs-MinChargeMs) / maxHoldMs;
-				pane->markerType = 1;//(heldMs >= MinChargeMs)? 1 : 0;
+				pane->markerType = 1;//(heldMs >= MinChargeMs)? 1 : 0;
-				pane->markerIndex = id;
+				pane->markerIndex = id;
-				pane->markerShare = Mth::Max(share, 0.0f);
+				pane->markerShare = Mth::Max(share, 0.0f);
-
+
-				percent = (int)Mth::clamp(100.0f * share, 0.0f, 100.0f);
+				percent = (int)Mth::clamp(100.0f * share, 0.0f, 100.0f);
-				if (percent >= 100) {
+				if (percent >= 100) {
-					addItem(pane, id);
+					addItem(pane, id);
-				}
+				}
-			}
+			}
-		}
+		}
-
+
-		pane->render(xm, ym, a);
+		pane->render(xm, ym, a);
-		guiPaneFrame->draw(t, (float)(pane->rect.x - 1), (float)(pane->rect.y - 1));
+		guiPaneFrame->draw(t, (float)(pane->rect.x - 1), (float)(pane->rect.y - 1));
-		//LOGI("query-iv: %d, %d\n", gridId, heldMs);
+		//LOGI("query-iv: %d, %d\n", gridId, heldMs);
-
+
-	}
+	}
-}
+}
-
+
-void ChestScreen::render(int xm, int ym, float a) {
+void ChestScreen::render(int xm, int ym, float a) {
-	const int N = 5;
+	const int N = 5;
-	static StopwatchNLast r(N);
+	static StopwatchNLast r(N);
-	//renderBackground();
+	//renderBackground();
-
+
-	Tesselator& t = Tesselator::instance;
+	Tesselator& t = Tesselator::instance;
-	guiBackground->draw(t, 0, 0);
+	guiBackground->draw(t, 0, 0);
-	glEnable2(GL_ALPHA_TEST);
+	glEnable2(GL_ALPHA_TEST);
-
+
-	// Buttons (Left side + crafting)
+	// Buttons (Left side + crafting)
-	super::render(xm, ym, a);
+	super::render(xm, ym, a);
-
+
-	heldMs = -1;
+	heldMs = -1;
-
+
-	handleRenderPane(inventoryPane, t, xm, ym, a);
+	handleRenderPane(inventoryPane, t, xm, ym, a);
-	handleRenderPane(chestPane, t, xm, ym, a);
+	handleRenderPane(chestPane, t, xm, ym, a);
-
+
-	float now = getTimeS();
+	float now = getTimeS();
-	float MaxTime = 0.3f;
+	float MaxTime = 0.3f;
-	std::vector<FlyingItem> flyingToSave;
+	std::vector<FlyingItem> flyingToSave;
-
+
-	glEnable2(GL_BLEND);
+	glEnable2(GL_BLEND);
-	glColor4f(1, 1, 1, 0.2f);
+	glColor4f(1, 1, 1, 0.2f);
-	t.beginOverride();
+	t.beginOverride();
-	//t.color(1.0f, 0.0f, 0.0f, 0.2f);
+	//t.color(1.0f, 0.0f, 0.0f, 0.2f);
-	//t.noColor();
+	//t.noColor();
-
+
-	glEnable2(GL_SCISSOR_TEST);
+	glEnable2(GL_SCISSOR_TEST);
-	//LOGI("panesBox: %d, %d - %d, %d\n", panesBbox.x, panesBbox.y, panesBbox.w, panesBbox.h);
+	//LOGI("panesBox: %d, %d - %d, %d\n", panesBbox.x, panesBbox.y, panesBbox.w, panesBbox.h);
-	minecraft->gui.setScissorRect(panesBbox);
+	minecraft->gui.setScissorRect(panesBbox);
-	for (unsigned int i = 0; i < flyingItems.size(); ++i) {
+	for (unsigned int i = 0; i < flyingItems.size(); ++i) {
-		FlyingItem& fi = flyingItems[i];
+		FlyingItem& fi = flyingItems[i];
-		float since = (now - fi.startTime);
+		float since = (now - fi.startTime);
-		if (since > MaxTime) continue;
+		if (since > MaxTime) continue;
-		float t = since / MaxTime;
+		float t = since / MaxTime;
-		t *= t;
+		t *= t;
-		//float xx = fi.sx + t * 100.0f;
+		//float xx = fi.sx + t * 100.0f;
-
+
-		float xx = Mth::lerp(fi.sx, fi.dx, t);
+		float xx = Mth::lerp(fi.sx, fi.dx, t);
-		float yy = Mth::lerp(fi.sy, fi.dy, t);
+		float yy = Mth::lerp(fi.sy, fi.dy, t);
-		ItemRenderer::renderGuiItem(minecraft->font, minecraft->textures, &fi.item, xx + 7, yy + 8, true);
+		ItemRenderer::renderGuiItem(minecraft->font, minecraft->textures, &fi.item, xx + 7, yy + 8, true);
-		//minecraft->gui.renderSlotText(&fi.item, xx + 3, yy + 3, true, true);
+		//minecraft->gui.renderSlotText(&fi.item, xx + 3, yy + 3, true, true);
-
+
-		flyingToSave.push_back(fi);
+		flyingToSave.push_back(fi);
-	}
+	}
-	t.enableColor();
+	t.enableColor();
-	t.endOverrideAndDraw();
+	t.endOverrideAndDraw();
-	glDisable2(GL_SCISSOR_TEST);
+	glDisable2(GL_SCISSOR_TEST);
-
+
-	flyingItems = flyingToSave;
+	flyingItems = flyingToSave;
-
+
-	t.colorABGR(0xffffffff);
+	t.colorABGR(0xffffffff);
-	glDisable2(GL_BLEND);
+	glDisable2(GL_BLEND);
-
+
-	minecraft->textures->loadAndBindTexture("gui/spritesheet.png");
+	minecraft->textures->loadAndBindTexture("gui/spritesheet.png");
-}
+}
-
+
-void ChestScreen::buttonClicked(Button* button) {
+void ChestScreen::buttonClicked(Button* button) {
-	if (button == &btnClose) {
+	if (button == &btnClose) {
-		minecraft->player->closeContainer();
+		minecraft->player->closeContainer();
-	}
+	}
-}
+}
-
+
-bool ChestScreen::handleAddItem(FillingContainer* from, FillingContainer* to, int itemIndex) {
+bool ChestScreen::handleAddItem(FillingContainer* from, FillingContainer* to, int itemIndex) {
-	const int itemOffset = from->getNumLinkedSlots();
+	const int itemOffset = from->getNumLinkedSlots();
-	const int slotIndex = itemIndex + itemOffset;
+	const int slotIndex = itemIndex + itemOffset;
-	ItemInstance* item = from->getItem(slotIndex);
+	ItemInstance* item = from->getItem(slotIndex);
-
+
-	bool added = false;
+	bool added = false;
-	bool fromChest = (from == chest);
+	bool fromChest = (from == chest);
-	Touch::InventoryPane* pane = fromChest? chestPane : inventoryPane;
+	Touch::InventoryPane* pane = fromChest? chestPane : inventoryPane;
-	Touch::InventoryPane* toPane = fromChest? inventoryPane : chestPane;
+	Touch::InventoryPane* toPane = fromChest? inventoryPane : chestPane;
-
+
-	int wantedCount = (item && !item->isNull())? item->count * percent / 100 : 0;
+	int wantedCount = (item && !item->isNull())? item->count * percent / 100 : 0;
-	if ((item && !item->isNull()) && (!wantedCount || heldMs < MinChargeMs)) {
+	if ((item && !item->isNull()) && (!wantedCount || heldMs < MinChargeMs)) {
-		wantedCount = 1;
+		wantedCount = 1;
-	}
+	}
-
+
-	if (wantedCount > 0) {
+	if (wantedCount > 0) {
-		ItemInstance takenItem(*item);
+		ItemInstance takenItem(*item);
-		takenItem.count = wantedCount;
+		takenItem.count = wantedCount;
-
+
-		ItemDiffer differ(getItems(toPane));
+		ItemDiffer differ(getItems(toPane));
-		to->add(&takenItem);
+		to->add(&takenItem);
-
+
-		added = (takenItem.count != wantedCount);
+		added = (takenItem.count != wantedCount);
-
+
-		if (added) {
+		if (added) {
-			item->count -= (wantedCount - takenItem.count);
+			item->count -= (wantedCount - takenItem.count);
-			std::vector<int> changed;
+			std::vector<int> changed;
-			std::vector<const ItemInstance*> items = getItems(toPane);
+			std::vector<const ItemInstance*> items = getItems(toPane);
-			differ.getDiff(items, changed);
+			differ.getDiff(items, changed);
-
+
-			ScrollingPane::GridItem g, gTo;
+			ScrollingPane::GridItem g, gTo;
-			pane->getGridItemFor_slow(itemIndex, g);
+			pane->getGridItemFor_slow(itemIndex, g);
-
+
-			//LOGI("Changed: %d\n", changed.size());
+			//LOGI("Changed: %d\n", changed.size());
-			for (unsigned int i = 0; i < changed.size(); ++i) {
+			for (unsigned int i = 0; i < changed.size(); ++i) {
-				FlyingItem fi;
+				FlyingItem fi;
-				fi.startTime = getTimeS();
+				fi.startTime = getTimeS();
-				fi.item = *item;
+				fi.item = *item;
-
+
-				fi.sx = g.xf;
+				fi.sx = g.xf;
-				fi.sy = g.yf;
+				fi.sy = g.yf;
-
+
-				int toIndex = changed[i];
+				int toIndex = changed[i];
-				toPane->getGridItemFor_slow(toIndex, gTo);
+				toPane->getGridItemFor_slow(toIndex, gTo);
-
+
-				fi.dx = gTo.xf;
+				fi.dx = gTo.xf;
-				fi.dy = gTo.yf;
+				fi.dy = gTo.yf;
-				flyingItems.push_back(fi);
+				flyingItems.push_back(fi);
-
+
-				if (!fromChest && minecraft->level->isClientSide) {
+				if (!fromChest && minecraft->level->isClientSide) {
-					int j = toIndex;
+					int j = toIndex;
-					ItemInstance item = items[j]? *items[j] : ItemInstance();
+					ItemInstance item = items[j]? *items[j] : ItemInstance();
-					ContainerSetSlotPacket p(menu->containerId, j, item);
+					ContainerSetSlotPacket p(menu->containerId, j, item);
-					minecraft->raknetInstance->send(p);
+					minecraft->raknetInstance->send(p);
-				}
+				}
-			}
+			}
-		}
+		}
-
+
-		// Send to server, needs a bit special handling
+		// Send to server, needs a bit special handling
-		if (fromChest) {
+		if (fromChest) {
-			ItemInstance ins(item->count <= 0? ItemInstance() : *item);
+			ItemInstance ins(item->count <= 0? ItemInstance() : *item);
-			ContainerSetSlotPacket p(menu->containerId, slotIndex, ins);
+			ContainerSetSlotPacket p(menu->containerId, slotIndex, ins);
-			minecraft->raknetInstance->send(p);
+			minecraft->raknetInstance->send(p);
-		}
+		}
-		if (item->count <= 0)
+		if (item->count <= 0)
-			from->clearSlot(slotIndex);
+			from->clearSlot(slotIndex);
-	}
+	}
-	// Clear the marker indices
+	// Clear the marker indices
-	pane->markerIndex = toPane->markerIndex = -1;
+	pane->markerIndex = toPane->markerIndex = -1;
-
+
-	return added;
+	return added;
-}
+}
-
+
-bool ChestScreen::addItem(const Touch::InventoryPane* forPane, int itemIndex) {
+bool ChestScreen::addItem(const Touch::InventoryPane* forPane, int itemIndex) {
-	//LOGI("items.size, index: %d, %d\n", inventoryItems.size(), itemIndex);
+	//LOGI("items.size, index: %d, %d\n", inventoryItems.size(), itemIndex);
-	bool l2r = (forPane == inventoryPane);
+	bool l2r = (forPane == inventoryPane);
-	return handleAddItem(	l2r? upcast<FillingContainer>(minecraft->player->inventory) : upcast<FillingContainer>(chest),
+	return handleAddItem(	l2r? upcast<FillingContainer>(minecraft->player->inventory) : upcast<FillingContainer>(chest),
-							l2r? upcast<FillingContainer>(chest) : upcast<FillingContainer>(minecraft->player->inventory),
+							l2r? upcast<FillingContainer>(chest) : upcast<FillingContainer>(minecraft->player->inventory),
-							itemIndex);
+							itemIndex);
-}
+}
-
+
-bool ChestScreen::isAllowed( int slot )
+bool ChestScreen::isAllowed( int slot )
-{
+{
-	return true;
+	return true;
-}
+}
-
+
-bool ChestScreen::renderGameBehind()
+bool ChestScreen::renderGameBehind()
-{
+{
-	return false;
+	return false;
-}
+}
-
+
-std::vector<const ItemInstance*> ChestScreen::getItems( const Touch::InventoryPane* forPane )
+std::vector<const ItemInstance*> ChestScreen::getItems( const Touch::InventoryPane* forPane )
-{
+{
-	if (forPane == inventoryPane) {
+	if (forPane == inventoryPane) {
-		for (int i = Inventory::MAX_SELECTION_SIZE, j = 0; i < minecraft->player->inventory->getContainerSize(); ++i, ++j)
+		for (int i = Inventory::MAX_SELECTION_SIZE, j = 0; i < minecraft->player->inventory->getContainerSize(); ++i, ++j)
-			inventoryItems[j] = minecraft->player->inventory->getItem(i);
+			inventoryItems[j] = minecraft->player->inventory->getItem(i);
-		return inventoryItems;
+		return inventoryItems;
-	}
+	}
-	else {
+	else {
-		for (int i = 0; i < chest->getContainerSize(); ++i)
+		for (int i = 0; i < chest->getContainerSize(); ++i)
-			chestItems[i] = chest->getItem(i);
+			chestItems[i] = chest->getItem(i);
-		return chestItems;
+		return chestItems;
-	}
+	}
-}
+}
-
+
-
+
-void ChestScreen::setupPane()
+void ChestScreen::setupPane()
-{
+{
-	inventoryItems.clear();
+	inventoryItems.clear();
-	for (int i = Inventory::MAX_SELECTION_SIZE; i < minecraft->player->inventory->getContainerSize(); ++i) {
+	for (int i = Inventory::MAX_SELECTION_SIZE; i < minecraft->player->inventory->getContainerSize(); ++i) {
-		ItemInstance* item = minecraft->player->inventory->getItem(i);
+		ItemInstance* item = minecraft->player->inventory->getItem(i);
-		/*if (!item || item->isNull()) continue;*/
+		/*if (!item || item->isNull()) continue;*/
-		inventoryItems.push_back(item);
+		inventoryItems.push_back(item);
-	}
+	}
-	chestItems.clear();
+	chestItems.clear();
-	for (int i = 0; i < chest->getContainerSize(); ++i) {
+	for (int i = 0; i < chest->getContainerSize(); ++i) {
-		ItemInstance* item = chest->getItem(i);
+		ItemInstance* item = chest->getItem(i);
-		/*if (!item || item->isNull()) continue;*/
+		/*if (!item || item->isNull()) continue;*/
-		chestItems.push_back(item);
+		chestItems.push_back(item);
-	}
+	}
-
+
-	int maxWidth = width/2 - Bx/2;//- Bx - Bx/*- Bx*/;
+	int maxWidth = width/2 - Bx/2;//- Bx - Bx/*- Bx*/;
-	int InventoryColumns = maxWidth / ItemSize;
+	int InventoryColumns = maxWidth / ItemSize;
-	const int realWidth = InventoryColumns * ItemSize;
+	const int realWidth = InventoryColumns * ItemSize;
-	int paneWidth = realWidth;// + Bx + Bx;
+	int paneWidth = realWidth;// + Bx + Bx;
-	const int realBx = (width/2 - realWidth) / 2;
+	const int realBx = (width/2 - realWidth) / 2;
-    
+    
-	IntRectangle rect(realBx,
+	IntRectangle rect(realBx,
-#ifdef __APPLE__
+#ifdef __APPLE__
-		24 + By - ((width==240)?1:0), realWidth, ((width==240)?1:0) + height-By-By-24);
+		24 + By - ((width==240)?1:0), realWidth, ((width==240)?1:0) + height-By-By-24);
-#else
+#else
-		24 + By, realWidth, height-By-By-24);
+		24 + By, realWidth, height-By-By-24);
-#endif
+#endif
-	// IntRectangle(0, 0, 100, 100)
+	// IntRectangle(0, 0, 100, 100)
-	if (inventoryPane) delete inventoryPane;
+	if (inventoryPane) delete inventoryPane;
-	inventoryPane = new Touch::InventoryPane(this, minecraft, rect, paneWidth, BorderPixels, minecraft->player->inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE, ItemSize, (int)BorderPixels);
+	inventoryPane = new Touch::InventoryPane(this, minecraft, rect, paneWidth, BorderPixels, minecraft->player->inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE, ItemSize, (int)BorderPixels);
-	inventoryPane->fillMarginX = 0;
+	inventoryPane->fillMarginX = 0;
-	inventoryPane->fillMarginY = 0;
+	inventoryPane->fillMarginY = 0;
-	guiPaneFrame->setSize((float)rect.w + 2, (float)rect.h + 2);
+	guiPaneFrame->setSize((float)rect.w + 2, (float)rect.h + 2);
-
+
-	panesBbox = rect;
+	panesBbox = rect;
-	rect.x += width/2;// - rect.w - Bx;
+	rect.x += width/2;// - rect.w - Bx;
-	panesBbox.w += (rect.x - panesBbox.x);
+	panesBbox.w += (rect.x - panesBbox.x);
-
+
-	if (chestPane) delete chestPane;
+	if (chestPane) delete chestPane;
-	chestPane = new Touch::InventoryPane(this, minecraft, rect, paneWidth, BorderPixels, chest->getContainerSize(), ItemSize, (int)BorderPixels);
+	chestPane = new Touch::InventoryPane(this, minecraft, rect, paneWidth, BorderPixels, chest->getContainerSize(), ItemSize, (int)BorderPixels);
-	chestPane->fillMarginX = 0;
+	chestPane->fillMarginX = 0;
-	chestPane->fillMarginY = 0;
+	chestPane->fillMarginY = 0;
-	LOGI("Creating new panes\n:"
+	LOGI("Creating new panes\n:"
-		"          Inventory %d %p\n"
+		"          Inventory %d %p\n"
-		"          Chest     %d %p\n", (int)inventoryItems.size(), inventoryPane, (int)chestItems.size(), chestPane);
+		"          Chest     %d %p\n", (int)inventoryItems.size(), inventoryPane, (int)chestItems.size(), chestPane);
-}
+}
-
+
-void ChestScreen::drawSlotItemAt( Tesselator& t, const ItemInstance* item, int x, int y, bool selected)
+void ChestScreen::drawSlotItemAt( Tesselator& t, const ItemInstance* item, int x, int y, bool selected)
-{
+{
-	float xx = (float)x;
+	float xx = (float)x;
-	float yy = (float)y;
+	float yy = (float)y;
-
+
-	(selected? guiSlot/*Marked*/ : guiSlot)->draw(t, xx, yy);
+	(selected? guiSlot/*Marked*/ : guiSlot)->draw(t, xx, yy);
-
+
-	if (selected)
+	if (selected)
-		guiSlotMarker->draw(t, xx - 2, yy - 2);
+		guiSlotMarker->draw(t, xx - 2, yy - 2);
-
+
-	if (item && !item->isNull()) {
+	if (item && !item->isNull()) {
-		ItemRenderer::renderGuiItem(minecraft->font, minecraft->textures, item, xx + 7, yy + 8, true);
+		ItemRenderer::renderGuiItem(minecraft->font, minecraft->textures, item, xx + 7, yy + 8, true);
-		minecraft->gui.renderSlotText(item, xx + 3, yy + 3, true, true);
+		minecraft->gui.renderSlotText(item, xx + 3, yy + 3, true, true);
-	}
+	}
-}
+}

src/client/gui/screens/ChestScreen.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "BaseContainerScreen.h"
+#include "BaseContainerScreen.hpp"
 
-#include "../components/InventoryPane.h"
+#include "client/gui/components/InventoryPane.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
 
 class Font;
 class CItem;

src/client/gui/screens/ChooseLevelScreen.cpp

@@ -1,26 +1,26 @@
-#include "ChooseLevelScreen.h"
+#include "ChooseLevelScreen.hpp"
-#include <algorithm>
+#include <algorithm>
-#include <set>
+#include <set>
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-
+
-void ChooseLevelScreen::init() {
+void ChooseLevelScreen::init() {
-	loadLevelSource();
+	loadLevelSource();
-}
+}
-
+
-void ChooseLevelScreen::loadLevelSource()
+void ChooseLevelScreen::loadLevelSource()
-{
+{
-	LevelStorageSource* levelSource = minecraft->getLevelSource();
+	LevelStorageSource* levelSource = minecraft->getLevelSource();
-	levelSource->getLevelList(levels);
+	levelSource->getLevelList(levels);
-	std::sort(levels.begin(), levels.end());
+	std::sort(levels.begin(), levels.end());
-}
+}
-
+
-std::string ChooseLevelScreen::getUniqueLevelName( const std::string& level ) {
+std::string ChooseLevelScreen::getUniqueLevelName( const std::string& level ) {
-	std::set<std::string> Set;
+	std::set<std::string> Set;
-	for (unsigned int i = 0; i < levels.size(); ++i)
+	for (unsigned int i = 0; i < levels.size(); ++i)
-		Set.insert(levels[i].id);
+		Set.insert(levels[i].id);
-
+
-	std::string s = level;
+	std::string s = level;
-	while ( Set.find(s) != Set.end() )
+	while ( Set.find(s) != Set.end() )
-		s += "-";
+		s += "-";
-	return s;
+	return s;
-}
+}

src/client/gui/screens/ChooseLevelScreen.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
-#include "../../../world/level/storage/LevelStorageSource.h"
+#include "world/level/storage/LevelStorageSource.hpp"
 
 class ChooseLevelScreen: public Screen
 {

src/client/gui/screens/ConfirmScreen.cpp

@@ -1,84 +1,84 @@
-#include "ConfirmScreen.h"
+#include "ConfirmScreen.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-
+
-ConfirmScreen::ConfirmScreen(Screen* parent_, const std::string& title1_, const std::string& title2_, int id_)
+ConfirmScreen::ConfirmScreen(Screen* parent_, const std::string& title1_, const std::string& title2_, int id_)
-:   parent(parent_),
+:   parent(parent_),
-	title1(title1_),
+	title1(title1_),
-	title2(title2_),
+	title2(title2_),
-	id(id_),
+	id(id_),
-	yesButtonText("Ok"),
+	yesButtonText("Ok"),
-	noButtonText("Cancel"),
+	noButtonText("Cancel"),
-	yesButton(0),
+	yesButton(0),
-	noButton(0)
+	noButton(0)
-{
+{
-}
+}
-
+
-ConfirmScreen::ConfirmScreen(Screen* parent_, const std::string& title1_, const std::string& title2_, const std::string& yesButton_, const std::string& noButton_, int id_ )
+ConfirmScreen::ConfirmScreen(Screen* parent_, const std::string& title1_, const std::string& title2_, const std::string& yesButton_, const std::string& noButton_, int id_ )
-:   parent(parent_),
+:   parent(parent_),
-	title1(title1_),
+	title1(title1_),
-	title2(title2_),
+	title2(title2_),
-	id(id_),
+	id(id_),
-	yesButtonText(yesButton_),
+	yesButtonText(yesButton_),
-	noButtonText(noButton_)
+	noButtonText(noButton_)
-{
+{
-}
+}
-
+
-ConfirmScreen::~ConfirmScreen() {
+ConfirmScreen::~ConfirmScreen() {
-	delete yesButton;
+	delete yesButton;
-	delete noButton;
+	delete noButton;
-}
+}
-
+
-void ConfirmScreen::init()
+void ConfirmScreen::init()
-{
+{
-	if (/* minecraft->useTouchscreen() */ true) {
+	if (/* minecraft->useTouchscreen() */ true) {
-		yesButton = new Touch::TButton(0, 0, 0, yesButtonText),
+		yesButton = new Touch::TButton(0, 0, 0, yesButtonText),
-		noButton  = new Touch::TButton(1, 0, 0, noButtonText);
+		noButton  = new Touch::TButton(1, 0, 0, noButtonText);
-	} else {
+	} else {
-		yesButton = new Button(0, 0, 0, yesButtonText),
+		yesButton = new Button(0, 0, 0, yesButtonText),
-		noButton  = new Button(1, 0, 0, noButtonText);
+		noButton  = new Button(1, 0, 0, noButtonText);
-	}
+	}
-
+
-	buttons.push_back(yesButton);
+	buttons.push_back(yesButton);
-	buttons.push_back(noButton);
+	buttons.push_back(noButton);
-
+
-	tabButtons.push_back(yesButton);
+	tabButtons.push_back(yesButton);
-	tabButtons.push_back(noButton);
+	tabButtons.push_back(noButton);
-}
+}
-
+
-void ConfirmScreen::setupPositions() {
+void ConfirmScreen::setupPositions() {
-	const int ButtonWidth = 120;
+	const int ButtonWidth = 120;
-	const int ButtonHeight = 24;
+	const int ButtonHeight = 24;
-	yesButton->x = width / 2 - ButtonWidth - 4;
+	yesButton->x = width / 2 - ButtonWidth - 4;
-	yesButton->y = height / 6 + 72;
+	yesButton->y = height / 6 + 72;
-	noButton->x = width / 2 + 4;
+	noButton->x = width / 2 + 4;
-	noButton->y = height / 6 + 72;
+	noButton->y = height / 6 + 72;
-	yesButton->width = noButton->width = ButtonWidth;
+	yesButton->width = noButton->width = ButtonWidth;
-	yesButton->height = noButton->height = ButtonHeight;
+	yesButton->height = noButton->height = ButtonHeight;
-}
+}
-
+
-bool ConfirmScreen::handleBackEvent(bool isDown) {
+bool ConfirmScreen::handleBackEvent(bool isDown) {
-	if (!isDown)
+	if (!isDown)
-		postResult(false);
+		postResult(false);
-	return true;
+	return true;
-}
+}
-
+
-void ConfirmScreen::render( int xm, int ym, float a )
+void ConfirmScreen::render( int xm, int ym, float a )
-{
+{
-	renderBackground();
+	renderBackground();
-
+
-	drawCenteredString(font, title1, width / 2, 50, 0xffffff);
+	drawCenteredString(font, title1, width / 2, 50, 0xffffff);
-	drawCenteredString(font, title2, width / 2, 70, 0xffffff);
+	drawCenteredString(font, title2, width / 2, 70, 0xffffff);
-
+
-	super::render(xm, ym, a);
+	super::render(xm, ym, a);
-}
+}
-
+
-void ConfirmScreen::buttonClicked( Button* button )
+void ConfirmScreen::buttonClicked( Button* button )
-{
+{
-	postResult(button->id == 0);
+	postResult(button->id == 0);
-}
+}
-
+
-void ConfirmScreen::postResult(bool isOk)
+void ConfirmScreen::postResult(bool isOk)
-{
+{
-	parent->confirmResult(isOk, id);
+	parent->confirmResult(isOk, id);
-}
+}

src/client/gui/screens/ConfirmScreen.hpp

@@ -2,7 +2,7 @@
 
 //package net.minecraft.client.gui;
 
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
 #include <string>
 
 class ConfirmScreen: public Screen

src/client/gui/screens/ConsoleScreen.cpp

@@ -1,13 +1,13 @@
-#include "ConsoleScreen.h"
+#include "ConsoleScreen.hpp"
-#include "../Gui.h"
+#include "client/gui/Gui.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
-#include "../../../platform/input/Keyboard.h"
+#include "platform/input/Keyboard.hpp"
-#include "../../../world/level/Level.h"
+#include "world/level/Level.hpp"
-#include "../../../network/RakNetInstance.h"
+#include "network/RakNetInstance.hpp"
-#include "../../../network/ServerSideNetworkHandler.h"
+#include "network/ServerSideNetworkHandler.hpp"
-#include "../../../network/packet/ChatPacket.h"
+#include "network/packet/ChatPacket.hpp"
-#include "../../../platform/log.h"
+#include "platform/log.hpp"
 
 #include <sstream>
 #include <cstdlib>

src/client/gui/screens/ConsoleScreen.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
 #include <string>
 
 class ConsoleScreen: public Screen

src/client/gui/screens/CreditsScreen.cpp

@@ -1,10 +1,10 @@
-#include "CreditsScreen.h"
+#include "CreditsScreen.hpp"
-#include "StartMenuScreen.h"
+#include "StartMenuScreen.hpp"
-#include "OptionsScreen.h"
+#include "OptionsScreen.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
-#include "../components/ImageButton.h"
+#include "client/gui/components/ImageButton.hpp"
-#include "platform/input/Mouse.h"
+#include "platform/input/Mouse.hpp"
 
 CreditsScreen::CreditsScreen()
 : bHeader(NULL), btnBack(NULL)

src/client/gui/screens/CreditsScreen.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
 
 class ImageButton;
 

src/client/gui/screens/DeathScreen.cpp

@@ -1,83 +1,83 @@
-#include "DeathScreen.h"
+#include "DeathScreen.hpp"
-#include "ScreenChooser.h"
+#include "ScreenChooser.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
-#include "../../../platform/time.h"
+#include "platform/time.hpp"
-
+
-static const int WAIT_TICKS = 30;
+static const int WAIT_TICKS = 30;
-
+
-DeathScreen::DeathScreen()
+DeathScreen::DeathScreen()
-:	bRespawn(0),
+:	bRespawn(0),
-	bTitle(0),
+	bTitle(0),
-	_hasChosen(false),
+	_hasChosen(false),
-	_tick(0)
+	_tick(0)
-{
+{
-}
+}
-
+
-DeathScreen::~DeathScreen()
+DeathScreen::~DeathScreen()
-{
+{
-	delete bRespawn;
+	delete bRespawn;
-	delete bTitle;
+	delete bTitle;
-}
+}
-
+
-void DeathScreen::init()
+void DeathScreen::init()
-{
+{
-	if (/* minecraft->useTouchscreen() */ true) {
+	if (/* minecraft->useTouchscreen() */ true) {
-		bRespawn = new Touch::TButton(1, "Respawn!");
+		bRespawn = new Touch::TButton(1, "Respawn!");
-		bTitle = new Touch::TButton(2, "Main menu");
+		bTitle = new Touch::TButton(2, "Main menu");
-	} else {
+	} else {
-		bRespawn = new Button(1, "Respawn!");
+		bRespawn = new Button(1, "Respawn!");
-		bTitle = new Button(2, "Main menu");
+		bTitle = new Button(2, "Main menu");
-	}
+	}
-	buttons.push_back(bRespawn);
+	buttons.push_back(bRespawn);
-	buttons.push_back(bTitle);
+	buttons.push_back(bTitle);
-
+
-	tabButtons.push_back(bRespawn);
+	tabButtons.push_back(bRespawn);
-	tabButtons.push_back(bTitle);
+	tabButtons.push_back(bTitle);
-}
+}
-
+
-void DeathScreen::setupPositions()
+void DeathScreen::setupPositions()
-{
+{
-	bRespawn->width = bTitle->width = width / 4;
+	bRespawn->width = bTitle->width = width / 4;
-
+
-	bRespawn->y = bTitle->y = height / 2;
+	bRespawn->y = bTitle->y = height / 2;
-	bRespawn->x = width/2 - bRespawn->width - 10;
+	bRespawn->x = width/2 - bRespawn->width - 10;
-	bTitle->x = width/2 + 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() {
+void DeathScreen::tick() {
-	++_tick;
+	++_tick;
-}
+}
-
+
-void DeathScreen::render( int xm, int ym, float a )
+void DeathScreen::render( int xm, int ym, float a )
-{
+{
-	fillGradient(0, 0, width, height, 0x60500000, 0xa0803030);
+	fillGradient(0, 0, width, height, 0x60500000, 0xa0803030);
-
+
-	glPushMatrix2();
+	glPushMatrix2();
-	glScalef2(2, 2, 2);
+	glScalef2(2, 2, 2);
-	drawCenteredString(font, "You died!", width / 2 / 2, height / 8, 0xffffff);
+	drawCenteredString(font, "You died!", width / 2 / 2, height / 8, 0xffffff);
-	glPopMatrix2();
+	glPopMatrix2();
-
+
-	if (_tick >= WAIT_TICKS)
+	if (_tick >= WAIT_TICKS)
-		Screen::render(xm, ym, a);
+		Screen::render(xm, ym, a);
-}
+}
-
+
-void DeathScreen::buttonClicked( Button* button )
+void DeathScreen::buttonClicked( Button* button )
-{
+{
-	if (_tick < WAIT_TICKS) return;
+	if (_tick < WAIT_TICKS) return;
-
+
-	if (button == bRespawn) {
+	if (button == bRespawn) {
-		//RespawnPacket packet();
+		//RespawnPacket packet();
-		//minecraft->raknetInstance->send(packet);
+		//minecraft->raknetInstance->send(packet);
-
+
-		minecraft->player->respawn();
+		minecraft->player->respawn();
-		//minecraft->raknetInstance->send();
+		//minecraft->raknetInstance->send();
-		minecraft->setScreen(NULL);
+		minecraft->setScreen(NULL);
-	}
+	}
-
+
-	if (button == bTitle)
+	if (button == bTitle)
-		minecraft->leaveGame();
+		minecraft->leaveGame();
-}
+}

src/client/gui/screens/DeathScreen.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
 class Button;
 
 class DeathScreen: public Screen

src/client/gui/screens/DisconnectionScreen.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
-#include "../Font.h"
+#include "client/gui/Font.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
 #include <string>
 
 class DisconnectionScreen: public Screen

src/client/gui/screens/FurnaceScreen.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "BaseContainerScreen.h"
+#include "BaseContainerScreen.hpp"
 
-#include "../components/InventoryPane.h"
+#include "client/gui/components/InventoryPane.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
 
 class Font;
 class CItem;

src/client/gui/screens/InBedScreen.cpp

@@ -1,49 +1,49 @@
-#include "InBedScreen.h"
+#include "InBedScreen.hpp"
-#include "ScreenChooser.h"
+#include "ScreenChooser.hpp"
-#include "../components/Button.h"
+#include "client/gui/components/Button.hpp"
-#include "../../Minecraft.h"
+#include "client/Minecraft.hpp"
-#include "../../player/LocalPlayer.h"
+#include "client/player/LocalPlayer.hpp"
-#include "../../../platform/time.h"
+#include "platform/time.hpp"
-
+
-static const int WAIT_TICKS = 30;
+static const int WAIT_TICKS = 30;
-
+
-InBedScreen::InBedScreen()
+InBedScreen::InBedScreen()
-	: bWakeUp(0)
+	: bWakeUp(0)
-{
+{
-}
+}
-
+
-InBedScreen::~InBedScreen() {
+InBedScreen::~InBedScreen() {
-	delete bWakeUp;
+	delete bWakeUp;
-}
+}
-
+
-void InBedScreen::init() {
+void InBedScreen::init() {
-	if (/* minecraft->useTouchscreen() */ true) {
+	if (/* minecraft->useTouchscreen() */ true) {
-		bWakeUp = new Touch::TButton(1, "Leave Bed");
+		bWakeUp = new Touch::TButton(1, "Leave Bed");
-	} else {
+	} else {
-		bWakeUp = new Button(1, "Leave Bed");
+		bWakeUp = new Button(1, "Leave Bed");
-	}
+	}
-	buttons.push_back(bWakeUp);
+	buttons.push_back(bWakeUp);
-
+
-	tabButtons.push_back(bWakeUp);
+	tabButtons.push_back(bWakeUp);
-}
+}
-
+
-void InBedScreen::setupPositions() {
+void InBedScreen::setupPositions() {
-	bWakeUp->width = width / 2;
+	bWakeUp->width = width / 2;
-	bWakeUp->height = int(height * 0.2f);
+	bWakeUp->height = int(height * 0.2f);
-	bWakeUp->y = height - int(bWakeUp->height * 1.5);
+	bWakeUp->y = height - int(bWakeUp->height * 1.5);
-	bWakeUp->x = width/2 - bWakeUp->width/2;
+	bWakeUp->x = width/2 - bWakeUp->width/2;
-}
+}
-
+
-void InBedScreen::render( int xm, int ym, float a ) {
+void InBedScreen::render( int xm, int ym, float a ) {
-	glEnable(GL_BLEND);
+	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	Screen::render(xm, ym, a);
+	Screen::render(xm, ym, a);
-	glDisable(GL_BLEND);
+	glDisable(GL_BLEND);
-}
+}
-
+
-void InBedScreen::buttonClicked( Button* button ) {
+void InBedScreen::buttonClicked( Button* button ) {
-	if (button == bWakeUp) {
+	if (button == bWakeUp) {
-		minecraft->player->stopSleepInBed(true, true, true);
+		minecraft->player->stopSleepInBed(true, true, true);
-		minecraft->setScreen(NULL);
+		minecraft->setScreen(NULL);
-	}
+	}
-}
+}

src/client/gui/screens/InBedScreen.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../Screen.h"
+#include "client/gui/Screen.hpp"
 class Button;
 
 class InBedScreen: public Screen