Merge branch 'smartcmd:main' into main

26 files changed, 1736 insertions, 803 deletions

diff --git a/Minecraft.Client/Windows64/4JLibs/inc/4J_Input.h b/Minecraft.Client/Windows64/4JLibs/inc/4J_Input.h
index 9ac5c55d..26e88e06 100644
--- a/Minecraft.Client/Windows64/4JLibs/inc/4J_Input.h
+++ b/Minecraft.Client/Windows64/4JLibs/inc/4J_Input.h
@@ -107,8 +107,8 @@ public:
 
 	void				SetMenuDisplayed(int iPad, bool bVal);
 
-// 	EKeyboardResult		RequestKeyboard(UINT uiTitle, UINT uiText, UINT uiDesc, DWORD dwPad, WCHAR *pwchResult, UINT uiResultSize,int( *Func)(LPVOID,const bool),LPVOID lpParam,EKeyboardMode eMode,C4JStringTable *pStringTable=NULL);
-// 	EKeyboardResult		RequestKeyboard(UINT uiTitle, LPCWSTR pwchDefault, UINT uiDesc, DWORD dwPad, WCHAR *pwchResult, UINT uiResultSize,int( *Func)(LPVOID,const bool),LPVOID lpParam, EKeyboardMode eMode,C4JStringTable *pStringTable=NULL);
+// 	EKeyboardResult		RequestKeyboard(UINT uiTitle, UINT uiText, UINT uiDesc, DWORD dwPad, WCHAR *pwchResult, UINT uiResultSize,int( *Func)(LPVOID,const bool),LPVOID lpParam,EKeyboardMode eMode,C4JStringTable *pStringTable=nullptr);
+// 	EKeyboardResult		RequestKeyboard(UINT uiTitle, LPCWSTR pwchDefault, UINT uiDesc, DWORD dwPad, WCHAR *pwchResult, UINT uiResultSize,int( *Func)(LPVOID,const bool),LPVOID lpParam, EKeyboardMode eMode,C4JStringTable *pStringTable=nullptr);
 	EKeyboardResult		RequestKeyboard(LPCWSTR Title, LPCWSTR Text, DWORD dwPad, UINT uiMaxChars, int( *Func)(LPVOID,const bool),LPVOID lpParam,C_4JInput::EKeyboardMode eMode);
 	void GetText(uint16_t *UTF16String);
 
diff --git a/Minecraft.Client/Windows64/4JLibs/inc/4J_Profile.h b/Minecraft.Client/Windows64/4JLibs/inc/4J_Profile.h
index f1bd85bb..6b9cc289 100644
--- a/Minecraft.Client/Windows64/4JLibs/inc/4J_Profile.h
+++ b/Minecraft.Client/Windows64/4JLibs/inc/4J_Profile.h
@@ -100,7 +100,7 @@ public:
 	// ACHIEVEMENTS & AWARDS
 
 	void				RegisterAward(int iAwardNumber,int iGamerconfigID, eAwardType eType, bool bLeaderboardAffected=false, 
-										CXuiStringTable*pStringTable=NULL, int iTitleStr=-1, int iTextStr=-1, int iAcceptStr=-1, char *pszThemeName=NULL, unsigned int uiThemeSize=0L);
+										CXuiStringTable*pStringTable=nullptr, int iTitleStr=-1, int iTextStr=-1, int iAcceptStr=-1, char *pszThemeName=nullptr, unsigned int uiThemeSize=0L);
 	int					GetAwardId(int iAwardNumber);
 	eAwardType			GetAwardType(int iAwardNumber);
 	bool				CanBeAwarded(int iQuadrant, int iAwardNumber);
diff --git a/Minecraft.Client/Windows64/4JLibs/inc/4J_Render.h b/Minecraft.Client/Windows64/4JLibs/inc/4J_Render.h
index 737caa98..fb16ccb3 100644
--- a/Minecraft.Client/Windows64/4JLibs/inc/4J_Render.h
+++ b/Minecraft.Client/Windows64/4JLibs/inc/4J_Render.h
@@ -16,8 +16,8 @@ public:
 	int GetType()			{ return m_type; }
 	void *GetBufferPointer()	{ return m_pBuffer; }
 	int GetBufferSize()			{ return m_bufferSize; }
-	void Release()				{ free(m_pBuffer); m_pBuffer = NULL; }
-	bool Allocated() { return m_pBuffer != NULL; }
+	void Release()				{ free(m_pBuffer); m_pBuffer = nullptr; }
+	bool Allocated() { return m_pBuffer != nullptr; }
 };
 
 typedef struct
@@ -60,7 +60,7 @@ public:
 	void StartFrame();
 	void DoScreenGrabOnNextPresent();
 	void Present();
-	void Clear(int flags, D3D11_RECT *pRect = NULL);
+	void Clear(int flags, D3D11_RECT *pRect = nullptr);
 	void SetClearColour(const float colourRGBA[4]);
 	bool IsWidescreen();
 	bool IsHiDef();
diff --git a/Minecraft.Client/Windows64/4JLibs/inc/4J_Storage.h b/Minecraft.Client/Windows64/4JLibs/inc/4J_Storage.h
index 896f730a..006c3c88 100644
--- a/Minecraft.Client/Windows64/4JLibs/inc/4J_Storage.h
+++ b/Minecraft.Client/Windows64/4JLibs/inc/4J_Storage.h
@@ -15,7 +15,7 @@ typedef struct
 }
 CONTAINER_METADATA;
 
-typedef struct  
+typedef struct
 {
 	char UTF8SaveFilename[MAX_SAVEFILENAME_LENGTH];
 	char UTF8SaveTitle[MAX_DISPLAYNAME_LENGTH];
@@ -24,7 +24,7 @@ typedef struct
 }
 SAVE_INFO,*PSAVE_INFO;
 
-typedef struct  
+typedef struct
 {
 	int iSaveC;
 	PSAVE_INFO SaveInfoA;
@@ -43,7 +43,7 @@ class C4JStorage
 
 public:
 	// Structs defined in the DLC_Creator, but added here to be used in the app
-	typedef struct  
+	typedef struct
 	{
 		unsigned int	uiFileSize;
 		DWORD			dwType;
@@ -61,7 +61,7 @@ public:
 	DLC_FILE_PARAM, *PDLC_FILE_PARAM;
 	// End of DLC_Creator structs
 
-	typedef struct  
+	typedef struct
 	{
  		WCHAR                               wchDisplayName[XCONTENT_MAX_DISPLAYNAME_LENGTH];
  		CHAR                                szFileName[XCONTENT_MAX_FILENAME_LENGTH];
@@ -71,7 +71,7 @@ public:
 	CACHEINFOSTRUCT;
 
 	// structure to hold DLC info in TMS
-	typedef struct  
+	typedef struct
 	{
 		DWORD dwVersion;
 		DWORD dwNewOffers;
@@ -111,7 +111,7 @@ public:
 	enum ESaveGameControlState
 	{
 		ESaveGameControl_Idle=0,
-		ESaveGameControl_Save,	
+		ESaveGameControl_Save,
 		ESaveGameControl_InternalRequestingDevice,
 		ESaveGameControl_InternalGetSaveName,
 		ESaveGameControl_InternalSaving,
@@ -122,16 +122,16 @@ public:
 	enum ESaveGameState
 	{
 		ESaveGame_Idle=0,
-		ESaveGame_Save,	
+		ESaveGame_Save,
 		ESaveGame_InternalRequestingDevice,
 		ESaveGame_InternalGetSaveName,
 		ESaveGame_InternalSaving,
 		ESaveGame_CopySave,
 		ESaveGame_CopyingSave,
-		ESaveGame_Load,	
-		ESaveGame_GetSavesInfo,	
-		ESaveGame_Rename,	
-		ESaveGame_Delete,	
+		ESaveGame_Load,
+		ESaveGame_GetSavesInfo,
+		ESaveGame_Rename,
+		ESaveGame_Delete,
 
 		ESaveGame_GetSaveThumbnail		// Not used as an actual state in the PS4, but the game expects this to be returned to indicate success when getting a thumbnail
 
@@ -210,7 +210,7 @@ public:
 	};
 
 
-	typedef struct  
+	typedef struct
 	{
 		CHAR			szFilename[256];
 		int				iFileSize;
@@ -218,14 +218,14 @@ public:
 	}
 	TMSPP_FILE_DETAILS, *PTMSPP_FILE_DETAILS;
 
-	typedef struct  
+	typedef struct
 	{
 		int iCount;
 		PTMSPP_FILE_DETAILS FileDetailsA;
 	}
 	TMSPP_FILE_LIST, *PTMSPP_FILE_LIST;
 
-	typedef struct  
+	typedef struct
 	{
 		DWORD dwSize;
 		PBYTE pbData;
@@ -239,7 +239,7 @@ public:
 
 	// Messages
 	C4JStorage::EMessageResult			RequestMessageBox(UINT uiTitle, UINT uiText, UINT *uiOptionA,UINT uiOptionC, DWORD dwPad=XUSER_INDEX_ANY,
-		int( *Func)(LPVOID,int,const C4JStorage::EMessageResult)=NULL,LPVOID lpParam=NULL, C4JStringTable *pStringTable=NULL, WCHAR *pwchFormatString=NULL,DWORD dwFocusButton=0);
+		int( *Func)(LPVOID,int,const C4JStorage::EMessageResult)=nullptr,LPVOID lpParam=nullptr, C4JStringTable *pStringTable=nullptr, WCHAR *pwchFormatString=nullptr,DWORD dwFocusButton=0);
 
 
 	C4JStorage::EMessageResult			GetMessageBoxResult();
@@ -264,7 +264,7 @@ public:
 	void						SetSaveImages( PBYTE pbThumbnail,DWORD dwThumbnailBytes,PBYTE pbImage,DWORD dwImageBytes, PBYTE pbTextData ,DWORD dwTextDataBytes);					// Sets the thumbnail & image for the save, optionally setting the metadata in the png
 	C4JStorage::ESaveGameState	SaveSaveData(int( *Func)(LPVOID ,const bool),LPVOID lpParam);
 	void						CopySaveDataToNewSave(PBYTE pbThumbnail,DWORD cbThumbnail,WCHAR *wchNewName,int ( *Func)(LPVOID lpParam, bool), LPVOID lpParam);
-	void						SetSaveDeviceSelected(unsigned int uiPad,bool bSelected);	
+	void						SetSaveDeviceSelected(unsigned int uiPad,bool bSelected);
 	bool						GetSaveDeviceSelected(unsigned int iPad);
 	C4JStorage::ESaveGameState	DoesSaveExist(bool *pbExists);
 	bool						EnoughSpaceForAMinSaveGame();
@@ -286,27 +286,27 @@ public:
 	// DLC
 	void								RegisterMarketplaceCountsCallback(int ( *Func)(LPVOID lpParam, C4JStorage::DLC_TMS_DETAILS *, int), LPVOID lpParam );
 	void								SetDLCPackageRoot(char *pszDLCRoot);
-	C4JStorage::EDLCStatus				GetDLCOffers(int iPad,int( *Func)(LPVOID, int, DWORD, int),LPVOID lpParam, DWORD dwOfferTypesBitmask=XMARKETPLACE_OFFERING_TYPE_CONTENT);	
+	C4JStorage::EDLCStatus				GetDLCOffers(int iPad,int( *Func)(LPVOID, int, DWORD, int),LPVOID lpParam, DWORD dwOfferTypesBitmask=XMARKETPLACE_OFFERING_TYPE_CONTENT);
 	DWORD								CancelGetDLCOffers();
 	void								ClearDLCOffers();
 	XMARKETPLACE_CONTENTOFFER_INFO&		GetOffer(DWORD dw);
 	int									GetOfferCount();
-	DWORD								InstallOffer(int iOfferIDC, __uint64 *ullOfferIDA,int( *Func)(LPVOID, int, int),LPVOID lpParam, bool bTrial=false);
+	DWORD								InstallOffer(int iOfferIDC, uint64_t *ullOfferIDA,int( *Func)(LPVOID, int, int),LPVOID lpParam, bool bTrial=false);
 	DWORD								GetAvailableDLCCount( int iPad);
 
 	C4JStorage::EDLCStatus				GetInstalledDLC(int iPad,int( *Func)(LPVOID, int, int),LPVOID lpParam);
 	XCONTENT_DATA&						GetDLC(DWORD dw);
-	DWORD								MountInstalledDLC(int iPad,DWORD dwDLC,int( *Func)(LPVOID, int, DWORD,DWORD),LPVOID lpParam,LPCSTR szMountDrive=NULL);
-	DWORD								UnmountInstalledDLC(LPCSTR szMountDrive = NULL);
+	DWORD								MountInstalledDLC(int iPad,DWORD dwDLC,int( *Func)(LPVOID, int, DWORD,DWORD),LPVOID lpParam,LPCSTR szMountDrive=nullptr);
+	DWORD								UnmountInstalledDLC(LPCSTR szMountDrive = nullptr);
 	void								GetMountedDLCFileList(const char* szMountDrive, std::vector<std::string>& fileList);
 	std::string							GetMountedPath(std::string szMount);
 
 	// Global title storage
 	C4JStorage::ETMSStatus				ReadTMSFile(int iQuadrant,eGlobalStorage eStorageFacility,C4JStorage::eTMS_FileType eFileType,
-											WCHAR *pwchFilename,BYTE **ppBuffer,DWORD *pdwBufferSize,int( *Func)(LPVOID, WCHAR *,int, bool, int)=NULL,LPVOID lpParam=NULL, int iAction=0);
+											WCHAR *pwchFilename,BYTE **ppBuffer,DWORD *pdwBufferSize,int( *Func)(LPVOID, WCHAR *,int, bool, int)=nullptr,LPVOID lpParam=nullptr, int iAction=0);
 	bool								WriteTMSFile(int iQuadrant,eGlobalStorage eStorageFacility,WCHAR *pwchFilename,BYTE *pBuffer,DWORD dwBufferSize);
 	bool								DeleteTMSFile(int iQuadrant,eGlobalStorage eStorageFacility,WCHAR *pwchFilename);
-	void								StoreTMSPathName(WCHAR *pwchName=NULL);
+	void								StoreTMSPathName(WCHAR *pwchName=nullptr);
 
 	// TMS++
 #ifdef _XBOX
@@ -314,11 +314,11 @@ public:
 	HRESULT								GetUserQuotaInfo(int iPad,TMSCLIENT_CALLBACK Func,LPVOID lpParam);
 #endif
 
-	// 	C4JStorage::ETMSStatus				TMSPP_WriteFile(int iPad,C4JStorage::eGlobalStorage eStorageFacility,C4JStorage::eTMS_FILETYPEVAL eFileTypeVal,C4JStorage::eTMS_UGCTYPE eUGCType,CHAR *pchFilePath,CHAR *pchBuffer,DWORD dwBufferSize,int( *Func)(LPVOID,int,int)=NULL,LPVOID lpParam=NULL, int iUserData=0);
+	// 	C4JStorage::ETMSStatus				TMSPP_WriteFile(int iPad,C4JStorage::eGlobalStorage eStorageFacility,C4JStorage::eTMS_FILETYPEVAL eFileTypeVal,C4JStorage::eTMS_UGCTYPE eUGCType,CHAR *pchFilePath,CHAR *pchBuffer,DWORD dwBufferSize,int( *Func)(LPVOID,int,int)=nullptr,LPVOID lpParam=nullptr, int iUserData=0);
 	// 	C4JStorage::ETMSStatus				TMSPP_GetUserQuotaInfo(int iPad,TMSCLIENT_CALLBACK Func,LPVOID lpParam, int iUserData=0);
-	C4JStorage::ETMSStatus				TMSPP_ReadFile(int iPad,C4JStorage::eGlobalStorage eStorageFacility,C4JStorage::eTMS_FILETYPEVAL eFileTypeVal,LPCSTR szFilename,int( *Func)(LPVOID,int,int,PTMSPP_FILEDATA, LPCSTR)=NULL,LPVOID lpParam=NULL, int iUserData=0);
-	// 	C4JStorage::ETMSStatus				TMSPP_ReadFileList(int iPad,C4JStorage::eGlobalStorage eStorageFacility,CHAR *pchFilePath,int( *Func)(LPVOID,int,int,PTMSPP_FILE_LIST)=NULL,LPVOID lpParam=NULL, int iUserData=0);
-	// 	C4JStorage::ETMSStatus				TMSPP_DeleteFile(int iPad,LPCSTR szFilePath,C4JStorage::eTMS_FILETYPEVAL eFileTypeVal,int( *Func)(LPVOID,int,int),LPVOID lpParam=NULL, int iUserData=0);
+	C4JStorage::ETMSStatus				TMSPP_ReadFile(int iPad,C4JStorage::eGlobalStorage eStorageFacility,C4JStorage::eTMS_FILETYPEVAL eFileTypeVal,LPCSTR szFilename,int( *Func)(LPVOID,int,int,PTMSPP_FILEDATA, LPCSTR)=nullptr,LPVOID lpParam=nullptr, int iUserData=0);
+	// 	C4JStorage::ETMSStatus				TMSPP_ReadFileList(int iPad,C4JStorage::eGlobalStorage eStorageFacility,CHAR *pchFilePath,int( *Func)(LPVOID,int,int,PTMSPP_FILE_LIST)=nullptr,LPVOID lpParam=nullptr, int iUserData=0);
+	// 	C4JStorage::ETMSStatus				TMSPP_DeleteFile(int iPad,LPCSTR szFilePath,C4JStorage::eTMS_FILETYPEVAL eFileTypeVal,int( *Func)(LPVOID,int,int),LPVOID lpParam=nullptr, int iUserData=0);
 	// 	bool								TMSPP_InFileList(eGlobalStorage eStorageFacility, int iPad,const wstring &Filename);
 	// 	unsigned int						CRC(unsigned char *buf, int len);
 
@@ -335,7 +335,7 @@ public:
 	unsigned int						CRC(unsigned char *buf, int len);
 
 // #ifdef _DEBUG
-// 	void SetSaveName(int i);					
+// 	void SetSaveName(int i);
 // #endif
 	// string table for all the Storage problems. Loaded by the application
 	C4JStringTable				*m_pStringTable;
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d10_shaders.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d10_shaders.inl
index d4d2bb22..6ea0d142 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d10_shaders.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d10_shaders.inl
@@ -1364,7 +1364,7 @@ static DWORD pshader_exceptional_blend_12[276] = {
 };
 
 static ProgramWithCachedVariableLocations pshader_exceptional_blend_arr[13] = {
-   { NULL, 0, },
+   { nullptr, 0, },
    { pshader_exceptional_blend_1, 1340, },
    { pshader_exceptional_blend_2, 1444, },
    { pshader_exceptional_blend_3, 1424, },
@@ -2672,10 +2672,10 @@ static ProgramWithCachedVariableLocations pshader_filter_arr[32] = {
    { pshader_filter_9, 708, },
    { pshader_filter_10, 1644, },
    { pshader_filter_11, 1372, },
-   { NULL, 0, },
-   { NULL, 0, },
-   { NULL, 0, },
-   { NULL, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
    { pshader_filter_16, 1740, },
    { pshader_filter_17, 1732, },
    { pshader_filter_18, 1820, },
@@ -2688,10 +2688,10 @@ static ProgramWithCachedVariableLocations pshader_filter_arr[32] = {
    { pshader_filter_25, 1468, },
    { pshader_filter_26, 1820, },
    { pshader_filter_27, 1548, },
-   { NULL, 0, },
-   { NULL, 0, },
-   { NULL, 0, },
-   { NULL, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
 };
 
 static DWORD pshader_blur_2[320] = {
@@ -3193,8 +3193,8 @@ static DWORD pshader_blur_9[621] = {
 };
 
 static ProgramWithCachedVariableLocations pshader_blur_arr[10] = {
-   { NULL, 0, },
-   { NULL, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
    { pshader_blur_2, 1280, },
    { pshader_blur_3, 1452, },
    { pshader_blur_4, 1624, },
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.cpp b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.cpp
index dea9e315..b9fb627b 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.cpp
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.cpp
@@ -56,7 +56,7 @@ typedef ID3D11DeviceContext ID3D1XContext;
 typedef F32 ViewCoord;
 typedef gdraw_d3d11_resourcetype gdraw_resourcetype;
 
-static void report_d3d_error(HRESULT hr, char *call, char *context);
+static void report_d3d_error(HRESULT hr, const char *call, const char *context);
 
 static void *map_buffer(ID3D1XContext *ctx, ID3D11Buffer *buf, bool discard)
 {
@@ -64,7 +64,7 @@ static void *map_buffer(ID3D1XContext *ctx, ID3D11Buffer *buf, bool discard)
    HRESULT hr = ctx->Map(buf, 0, discard ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE_NO_OVERWRITE, 0, &msr);
    if (FAILED(hr)) {
       report_d3d_error(hr, "Map", "of buffer");
-      return NULL;
+      return nullptr;
    } else
       return msr.pData;
 }
@@ -76,12 +76,12 @@ static void unmap_buffer(ID3D1XContext *ctx, ID3D11Buffer *buf)
 
 static RADINLINE void set_pixel_shader(ID3D11DeviceContext *ctx, ID3D11PixelShader *shader)
 {
-   ctx->PSSetShader(shader, NULL, 0);
+   ctx->PSSetShader(shader, nullptr, 0);
 }
 
 static RADINLINE void set_vertex_shader(ID3D11DeviceContext *ctx, ID3D11VertexShader *shader)
 {
-   ctx->VSSetShader(shader, NULL, 0);
+   ctx->VSSetShader(shader, nullptr, 0);
 }
 
 static ID3D11BlendState *create_blend_state(ID3D11Device *dev, BOOL blend, D3D11_BLEND src, D3D11_BLEND dst)
@@ -100,7 +100,7 @@ static ID3D11BlendState *create_blend_state(ID3D11Device *dev, BOOL blend, D3D11
    HRESULT hr = dev->CreateBlendState(&desc, &res);
    if (FAILED(hr)) {
       report_d3d_error(hr, "CreateBlendState", "");
-      res = NULL;
+      res = nullptr;
    }
 
    return res;
@@ -113,10 +113,10 @@ static void create_pixel_shader(ProgramWithCachedVariableLocations *p, ProgramWi
 {
    *p = *src;
    if(p->bytecode) {
-      HRESULT hr = gdraw->d3d_device->CreatePixelShader(p->bytecode, p->size, NULL, &p->pshader);
+      HRESULT hr = gdraw->d3d_device->CreatePixelShader(p->bytecode, p->size, nullptr, &p->pshader);
       if (FAILED(hr)) {
          report_d3d_error(hr, "CreatePixelShader", "");
-         p->pshader = NULL;
+         p->pshader = nullptr;
          return;
       }
    }
@@ -126,10 +126,10 @@ static void create_vertex_shader(ProgramWithCachedVariableLocations *p, ProgramW
 {
    *p = *src;
    if(p->bytecode) {
-      HRESULT hr = gdraw->d3d_device->CreateVertexShader(p->bytecode, p->size, NULL, &p->vshader);
+      HRESULT hr = gdraw->d3d_device->CreateVertexShader(p->bytecode, p->size, nullptr, &p->vshader);
       if (FAILED(hr)) {
          report_d3d_error(hr, "CreateVertexShader", "");
-         p->vshader = NULL;
+         p->vshader = nullptr;
          return;
       }
    }
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.h b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.h
index 7fd7012f..47fe3c29 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.h
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.h
@@ -42,7 +42,7 @@ IDOC extern GDrawFunctions * gdraw_D3D11_CreateContext(ID3D11Device *dev, ID3D11
    There can only be one D3D GDraw context active at any one time.
 
    If initialization fails for some reason (the main reason would be an out of memory condition),
-   NULL is returned. Otherwise, you can pass the return value to IggySetGDraw. */
+   nullptr is returned. Otherwise, you can pass the return value to IggySetGDraw. */
 
 IDOC extern void gdraw_D3D11_DestroyContext(void);
 /* Destroys the current GDraw context, if any. */
@@ -70,7 +70,7 @@ IDOC extern void gdraw_D3D11_SetTileOrigin(ID3D11RenderTargetView *main_rt, ID3D
    If your rendertarget uses multisampling, you also need to specify a shader
    resource view for a non-MSAA rendertarget texture (identically sized to main_rt)
    in non_msaa_rt. This is only used if the Flash content includes non-standard
-   blend modes which have to use a special blend shader, so you can leave it NULL
+   blend modes which have to use a special blend shader, so you can leave it nullptr
    if you forbid such content.
 
    You need to call this before Iggy calls any rendering functions. */
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d1x_shared.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d1x_shared.inl
index df42488c..62e97e0f 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d1x_shared.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d1x_shared.inl
@@ -196,16 +196,16 @@ static void safe_release(T *&p)
 {
    if (p) {
       p->Release();
-      p = NULL;
+      p = nullptr;
    }
 }
 
-static void report_d3d_error(HRESULT hr, char *call, char *context)
+static void report_d3d_error(HRESULT hr, const char *call, const char *context)
 {
    if (hr == E_OUTOFMEMORY)
-      IggyGDrawSendWarning(NULL, "GDraw D3D out of memory in %s%s", call, context);
+      IggyGDrawSendWarning(nullptr, "GDraw D3D out of memory in %s%s", call, context);
    else
-      IggyGDrawSendWarning(NULL, "GDraw D3D error in %s%s: 0x%08x", call, context, hr);
+      IggyGDrawSendWarning(nullptr, "GDraw D3D error in %s%s: 0x%08x", call, context, hr);
 }
 
 static void unbind_resources(void)
@@ -214,13 +214,13 @@ static void unbind_resources(void)
 
    // unset active textures and vertex/index buffers,
    // to make sure there are no dangling refs
-   static ID3D1X(ShaderResourceView) *no_views[3] = { 0 };
-   ID3D1X(Buffer) *no_vb = NULL;
+   static ID3D1X(ShaderResourceView) *no_views[3] = { nullptr };
+   ID3D1X(Buffer) *no_vb = nullptr;
    UINT no_offs = 0;
 
    d3d->PSSetShaderResources(0, 3, no_views);
    d3d->IASetVertexBuffers(0, 1, &no_vb, &no_offs, &no_offs);
-   d3d->IASetIndexBuffer(NULL, DXGI_FORMAT_UNKNOWN, 0);
+   d3d->IASetIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0);
 }
 
 static void api_free_resource(GDrawHandle *r)
@@ -251,11 +251,11 @@ static void RADLINK gdraw_UnlockHandles(GDrawStats * /*stats*/)
 
 static void *start_write_dyn(DynBuffer *buf, U32 size)
 {
-   U8 *ptr = NULL;
+   U8 *ptr = nullptr;
 
    if (size > buf->size) {
-      IggyGDrawSendWarning(NULL, "GDraw dynamic vertex buffer usage of %d bytes in one call larger than buffer size %d", size, buf->size);
-      return NULL;
+      IggyGDrawSendWarning(nullptr, "GDraw dynamic vertex buffer usage of %d bytes in one call larger than buffer size %d", size, buf->size);
+      return nullptr;
    }
 
    // update statistics
@@ -270,7 +270,7 @@ static void *start_write_dyn(DynBuffer *buf, U32 size)
    // discard buffer whenever the current write position is 0;
    // done this way so that if a DISCARD Map() were to fail, we would
    // just keep retrying the next time around.
-   ptr = (U8 *) map_buffer(gdraw->d3d_context, buf->buffer, buf->write_pos == 0);
+   ptr = static_cast<U8 *>(map_buffer(gdraw->d3d_context, buf->buffer, buf->write_pos == 0));
    if (ptr) {
       ptr += buf->write_pos; // we return pointer to write position in buffer
       buf->alloc_pos = buf->write_pos + size; // bump alloc position
@@ -373,19 +373,19 @@ extern GDrawTexture *gdraw_D3D1X_(WrappedTextureCreate)(ID3D1X(ShaderResourceVie
 {
    GDrawStats stats={0};
    GDrawHandle *p = gdraw_res_alloc_begin(gdraw->texturecache, 0, &stats); // it may need to free one item to give us a handle
-   p->handle.tex.d3d = NULL;
+   p->handle.tex.d3d = nullptr;
    p->handle.tex.d3d_view = tex_view;
-   p->handle.tex.d3d_rtview = NULL;
+   p->handle.tex.d3d_rtview = nullptr;
    p->handle.tex.w = 1;
    p->handle.tex.h = 1;
-   gdraw_HandleCacheAllocateEnd(p, 0, NULL, GDRAW_HANDLE_STATE_user_owned);
+   gdraw_HandleCacheAllocateEnd(p, 0, nullptr, GDRAW_HANDLE_STATE_user_owned);
    return (GDrawTexture *) p;
 }
 
 extern void gdraw_D3D1X_(WrappedTextureChange)(GDrawTexture *tex, ID3D1X(ShaderResourceView) *tex_view)
 {
    GDrawHandle *p = (GDrawHandle *) tex;
-   p->handle.tex.d3d = NULL;
+   p->handle.tex.d3d = nullptr;
    p->handle.tex.d3d_view = tex_view;
 }
 
@@ -407,12 +407,12 @@ static void RADLINK gdraw_SetTextureUniqueID(GDrawTexture *tex, void *old_id, vo
 
 static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height, gdraw_texture_format format, U32 flags, GDraw_MakeTexture_ProcessingInfo *p, GDrawStats *stats)
 {
-   GDrawHandle *t = NULL;
+   GDrawHandle *t = nullptr;
    DXGI_FORMAT dxgi_fmt;
    S32 bpp, size = 0, nmips = 0;
 
    if (width >= 16384 || height >= 16384) {
-      IggyGDrawSendWarning(NULL, "GDraw texture size too large (%d x %d), dimension limit is 16384", width, height);
+      IggyGDrawSendWarning(nullptr, "GDraw texture size too large (%d x %d), dimension limit is 16384", width, height);
       return false;
    }
 
@@ -433,7 +433,7 @@ static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height,
    // try to allocate memory for the client to write to
    p->texture_data = (U8 *) IggyGDrawMalloc(size);
    if (!p->texture_data) {
-      IggyGDrawSendWarning(NULL, "GDraw out of memory to store texture data to pass to D3D for %d x %d texture", width, height);
+      IggyGDrawSendWarning(nullptr, "GDraw out of memory to store texture data to pass to D3D for %d x %d texture", width, height);
       return false;
    }
 
@@ -446,9 +446,9 @@ static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height,
 
    t->handle.tex.w = width;
    t->handle.tex.h = height;
-   t->handle.tex.d3d = NULL;
-   t->handle.tex.d3d_view = NULL;
-   t->handle.tex.d3d_rtview = NULL;
+   t->handle.tex.d3d = nullptr;
+   t->handle.tex.d3d_view = nullptr;
+   t->handle.tex.d3d_rtview = nullptr;
 
    p->texture_type = GDRAW_TEXTURE_TYPE_rgba;
    p->p0 = t;
@@ -474,11 +474,11 @@ static rrbool RADLINK gdraw_MakeTextureMore(GDraw_MakeTexture_ProcessingInfo * /
 
 static GDrawTexture * RADLINK gdraw_MakeTextureEnd(GDraw_MakeTexture_ProcessingInfo *p, GDrawStats *stats)
 {
-   GDrawHandle *t = (GDrawHandle *) p->p0;
+   GDrawHandle *t = static_cast<GDrawHandle *>(p->p0);
    D3D1X_(SUBRESOURCE_DATA) mipdata[24];
    S32 i, w, h, nmips, bpp;
    HRESULT hr = S_OK;
-   char *failed_call;
+   const char *failed_call;
    U8 *ptr;
 
    // generate mip maps and set up descriptors for them
@@ -512,7 +512,7 @@ static GDrawTexture * RADLINK gdraw_MakeTextureEnd(GDraw_MakeTexture_ProcessingI
 
    // and create a corresponding shader resource view
    failed_call = "CreateShaderResourceView";
-   hr = gdraw->d3d_device->CreateShaderResourceView(t->handle.tex.d3d, NULL, &t->handle.tex.d3d_view);
+   hr = gdraw->d3d_device->CreateShaderResourceView(t->handle.tex.d3d, nullptr, &t->handle.tex.d3d_view);
 
 done:
    if (!FAILED(hr)) {
@@ -525,7 +525,7 @@ done:
       safe_release(t->handle.tex.d3d_view);
 
       gdraw_HandleCacheAllocateFail(t);
-      t = NULL;
+      t = nullptr;
       report_d3d_error(hr, failed_call, " while creating texture");
    }
 
@@ -554,8 +554,8 @@ static void RADLINK gdraw_UpdateTextureEnd(GDrawTexture *t, void * /*unique_id*/
 static void RADLINK gdraw_FreeTexture(GDrawTexture *tt, void *unique_id, GDrawStats *stats)
 {
    GDrawHandle *t = (GDrawHandle *) tt;
-   assert(t != NULL); // @GDRAW_ASSERT
-   if (t->owner == unique_id || unique_id == NULL) {
+   assert(t != nullptr); // @GDRAW_ASSERT
+   if (t->owner == unique_id || unique_id == nullptr) {
       if (t->cache == &gdraw->rendertargets) {
          gdraw_HandleCacheUnlock(t);
          // cache it by simply not freeing it
@@ -595,7 +595,7 @@ static void RADLINK gdraw_SetAntialiasTexture(S32 width, U8 *rgba)
       return;
    }
 
-   hr = gdraw->d3d_device->CreateShaderResourceView(gdraw->aa_tex, NULL, &gdraw->aa_tex_view);
+   hr = gdraw->d3d_device->CreateShaderResourceView(gdraw->aa_tex, nullptr, &gdraw->aa_tex_view);
    if (FAILED(hr)) {
       report_d3d_error(hr, "CreateShaderResourceView", " while creating texture");
       safe_release(gdraw->aa_tex);
@@ -616,8 +616,8 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
    if (p->vertex_data && p->index_data) {
       GDrawHandle *vb = gdraw_res_alloc_begin(gdraw->vbufcache, vbuf_size + ibuf_size, stats);
       if (vb) {
-         vb->handle.vbuf.verts = NULL;
-         vb->handle.vbuf.inds = NULL;
+         vb->handle.vbuf.verts = nullptr;
+         vb->handle.vbuf.inds = nullptr;
 
          p->vertex_data_length = vbuf_size;
          p->index_data_length = ibuf_size;
@@ -643,7 +643,7 @@ static rrbool RADLINK gdraw_MakeVertexBufferMore(GDraw_MakeVertexBuffer_Processi
 
 static GDrawVertexBuffer * RADLINK gdraw_MakeVertexBufferEnd(GDraw_MakeVertexBuffer_ProcessingInfo *p, GDrawStats * /*stats*/)
 {
-   GDrawHandle *vb = (GDrawHandle *) p->p0;
+   GDrawHandle *vb = static_cast<GDrawHandle *>(p->p0);
 
    HRESULT hr;
    D3D1X_(BUFFER_DESC) vbdesc = { static_cast<U32>(p->vertex_data_length), D3D1X_(USAGE_IMMUTABLE), D3D1X_(BIND_VERTEX_BUFFER), 0U, 0U };
@@ -661,7 +661,7 @@ static GDrawVertexBuffer * RADLINK gdraw_MakeVertexBufferEnd(GDraw_MakeVertexBuf
       safe_release(vb->handle.vbuf.inds);
 
       gdraw_HandleCacheAllocateFail(vb);
-      vb = NULL;
+      vb = nullptr;
 
       report_d3d_error(hr, "CreateBuffer", " creating vertex buffer");
    } else {
@@ -682,7 +682,7 @@ static rrbool RADLINK gdraw_TryLockVertexBuffer(GDrawVertexBuffer *vb, void *uni
 static void RADLINK gdraw_FreeVertexBuffer(GDrawVertexBuffer *vb, void *unique_id, GDrawStats *stats)
 {
    GDrawHandle *h = (GDrawHandle *) vb;
-   assert(h != NULL); // @GDRAW_ASSERT
+   assert(h != nullptr); // @GDRAW_ASSERT
    if (h->owner == unique_id)
       gdraw_res_free(h, stats);
 }
@@ -700,7 +700,7 @@ static void RADLINK gdraw_DescribeVertexBuffer(GDrawVertexBuffer *vbuf, GDraw_Ve
 
 static GDrawHandle *get_color_rendertarget(GDrawStats *stats)
 {
-   char *failed_call;
+   const char *failed_call;
 
    // try to recycle LRU rendertarget
    GDrawHandle *t = gdraw_HandleCacheGetLRU(&gdraw->rendertargets);
@@ -712,31 +712,31 @@ static GDrawHandle *get_color_rendertarget(GDrawStats *stats)
    // ran out of RTs, allocate a new one
    S32 size = gdraw->frametex_width * gdraw->frametex_height * 4;
    if (gdraw->rendertargets.bytes_free < size) {
-      IggyGDrawSendWarning(NULL, "GDraw rendertarget allocation failed: hit size limit of %d bytes", gdraw->rendertargets.total_bytes);
-      return NULL;
+      IggyGDrawSendWarning(nullptr, "GDraw rendertarget allocation failed: hit size limit of %d bytes", gdraw->rendertargets.total_bytes);
+      return nullptr;
    }
 
    t = gdraw_HandleCacheAllocateBegin(&gdraw->rendertargets);
    if (!t) {
-      IggyGDrawSendWarning(NULL, "GDraw rendertarget allocation failed: hit handle limit");
+      IggyGDrawSendWarning(nullptr, "GDraw rendertarget allocation failed: hit handle limit");
       return t;
    }
 
    D3D1X_(TEXTURE2D_DESC) desc = { static_cast<U32>(gdraw->frametex_width), static_cast<U32>(gdraw->frametex_height), 1U, 1U, DXGI_FORMAT_R8G8B8A8_UNORM, { 1, 0 },
       D3D1X_(USAGE_DEFAULT), D3D1X_(BIND_SHADER_RESOURCE) | D3D1X_(BIND_RENDER_TARGET), 0U, 0U };
 
-   t->handle.tex.d3d = NULL;
-   t->handle.tex.d3d_view = NULL;
-   t->handle.tex.d3d_rtview = NULL;
+   t->handle.tex.d3d = nullptr;
+   t->handle.tex.d3d_view = nullptr;
+   t->handle.tex.d3d_rtview = nullptr;
 
-   HRESULT hr = gdraw->d3d_device->CreateTexture2D(&desc, NULL, &t->handle.tex.d3d);
+   HRESULT hr = gdraw->d3d_device->CreateTexture2D(&desc, nullptr, &t->handle.tex.d3d);
    failed_call = "CreateTexture2D";
    if (!FAILED(hr)) {
-      hr = gdraw->d3d_device->CreateShaderResourceView(t->handle.tex.d3d, NULL, &t->handle.tex.d3d_view);
+      hr = gdraw->d3d_device->CreateShaderResourceView(t->handle.tex.d3d, nullptr, &t->handle.tex.d3d_view);
       failed_call = "CreateTexture2D";
    }
    if (!FAILED(hr)) {
-      hr = gdraw->d3d_device->CreateRenderTargetView(t->handle.tex.d3d, NULL, &t->handle.tex.d3d_rtview);
+      hr = gdraw->d3d_device->CreateRenderTargetView(t->handle.tex.d3d, nullptr, &t->handle.tex.d3d_rtview);
       failed_call = "CreateRenderTargetView";
    }
 
@@ -748,7 +748,7 @@ static GDrawHandle *get_color_rendertarget(GDrawStats *stats)
 
       report_d3d_error(hr, failed_call, " creating rendertarget");
 
-      return NULL;
+      return nullptr;
    }
 
    gdraw_HandleCacheAllocateEnd(t, size, (void *) 1, GDRAW_HANDLE_STATE_locked);
@@ -762,16 +762,16 @@ static GDrawHandle *get_color_rendertarget(GDrawStats *stats)
 static ID3D1X(DepthStencilView) *get_rendertarget_depthbuffer(GDrawStats *stats)
 {
    if (!gdraw->depth_buffer[1]) {
-      char *failed_call;
+      const char *failed_call;
       assert(!gdraw->rt_depth_buffer);
 
       D3D1X_(TEXTURE2D_DESC) desc = { static_cast<U32>(gdraw->frametex_width), static_cast<U32>(gdraw->frametex_height), 1U, 1U, DXGI_FORMAT_D24_UNORM_S8_UINT, { 1, 0 },
          D3D1X_(USAGE_DEFAULT), D3D1X_(BIND_DEPTH_STENCIL), 0U, 0U };
 
-      HRESULT hr = gdraw->d3d_device->CreateTexture2D(&desc, NULL, &gdraw->rt_depth_buffer);
+      HRESULT hr = gdraw->d3d_device->CreateTexture2D(&desc, nullptr, &gdraw->rt_depth_buffer);
       failed_call = "CreateTexture2D";
       if (!FAILED(hr)) {
-         hr = gdraw->d3d_device->CreateDepthStencilView(gdraw->rt_depth_buffer, NULL, &gdraw->depth_buffer[1]);
+         hr = gdraw->d3d_device->CreateDepthStencilView(gdraw->rt_depth_buffer, nullptr, &gdraw->depth_buffer[1]);
          failed_call = "CreateDepthStencilView while creating rendertarget";
       }
 
@@ -861,7 +861,7 @@ static void disable_scissor(int force)
 
 static void set_viewport_raw(S32 x, S32 y, S32 w, S32 h)
 {
-   D3D1X_(VIEWPORT) vp = { (ViewCoord) x, (ViewCoord) y, (ViewCoord) w, (ViewCoord) h, 0.0f, 1.0f };
+   D3D1X_(VIEWPORT) vp = { static_cast<ViewCoord>(x), static_cast<ViewCoord>(y), static_cast<ViewCoord>(w), static_cast<ViewCoord>(h), 0.0f, 1.0f };
    gdraw->d3d_context->RSSetViewports(1, &vp);
    gdraw->cview.x = x;
    gdraw->cview.y = y;
@@ -891,8 +891,8 @@ static void set_projection_raw(S32 x0, S32 x1, S32 y0, S32 y1)
 {
    gdraw->projection[0] = 2.0f / (x1-x0);
    gdraw->projection[1] = 2.0f / (y1-y0);
-   gdraw->projection[2] = (x1+x0)/(F32)(x0-x1);
-   gdraw->projection[3] = (y1+y0)/(F32)(y0-y1);
+   gdraw->projection[2] = (x1+x0)/static_cast<F32>(x0 - x1);
+   gdraw->projection[3] = (y1+y0)/static_cast<F32>(y0 - y1);
 
    set_projection_base();
 }
@@ -996,6 +996,9 @@ void gdraw_D3D1X_(SetTileOrigin)(ID3D1X(RenderTargetView) *main_rt, ID3D1X(Depth
 
 static void RADLINK gdraw_SetViewSizeAndWorldScale(S32 w, S32 h, F32 scalex, F32 scaley)
 {
+   static S32 s_lastW = 0, s_lastH = 0;
+   static F32 s_lastSx = 0, s_lastSy = 0;
+
    memset(gdraw->frame, 0, sizeof(gdraw->frame));
    gdraw->cur = gdraw->frame;
    gdraw->fw = w;
@@ -1113,7 +1116,7 @@ static void set_render_target(GDrawStats *stats)
       gdraw->d3d_context->OMSetRenderTargets(1, &target, gdraw->depth_buffer[0]);
       gdraw->d3d_context->RSSetState(gdraw->raster_state[gdraw->main_msaa]);
    } else {
-      ID3D1X(DepthStencilView) *depth = NULL;
+      ID3D1X(DepthStencilView) *depth = nullptr;
       if (gdraw->cur->flags & (GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_id | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_stencil))
          depth = get_rendertarget_depthbuffer(stats);
 
@@ -1128,15 +1131,15 @@ static void set_render_target(GDrawStats *stats)
 static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_texture_format /*format*/, U32 flags, void *owner, GDrawStats *stats)
 {
    GDrawFramebufferState *n = gdraw->cur+1;
-   GDrawHandle *t = NULL;
+   GDrawHandle *t = nullptr;
    if (gdraw->tw == 0 || gdraw->th == 0) {
-      IggyGDrawSendWarning(NULL, "GDraw warning: w=0,h=0 rendertarget");
+      IggyGDrawSendWarning(nullptr, "GDraw warning: w=0,h=0 rendertarget");
       return false;
    }
 
    if (n >= &gdraw->frame[MAX_RENDER_STACK_DEPTH]) {
       assert(0);
-      IggyGDrawSendWarning(NULL, "GDraw rendertarget nesting exceeds MAX_RENDER_STACK_DEPTH");
+      IggyGDrawSendWarning(nullptr, "GDraw rendertarget nesting exceeds MAX_RENDER_STACK_DEPTH");
       return false;
    }
 
@@ -1150,10 +1153,10 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
 
    n->flags = flags;
    n->color_buffer = t;
-   assert(n->color_buffer != NULL); // @GDRAW_ASSERT
+   assert(n->color_buffer != nullptr); // @GDRAW_ASSERT
 
    ++gdraw->cur;
-   gdraw->cur->cached = owner != NULL;
+   gdraw->cur->cached = owner != nullptr;
    if (owner) {
       gdraw->cur->base_x = region->x0;
       gdraw->cur->base_y = region->y0;
@@ -1164,7 +1167,7 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
    set_render_target(stats);
    assert(gdraw->frametex_width >= gdraw->tw && gdraw->frametex_height >= gdraw->th); // @GDRAW_ASSERT
 
-   S32 k = (S32) (t - gdraw->rendertargets.handle);
+   S32 k = static_cast<S32>(t - gdraw->rendertargets.handle);
 
    if (region) {
       gswf_recti r;
@@ -1190,7 +1193,7 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
 
       if (r.x1 <= r.x0 || r.y1 <= r.y0) { // region doesn't intersect with current tile
          --gdraw->cur;
-         gdraw_FreeTexture((GDrawTexture *) t, 0, stats);
+         gdraw_FreeTexture((GDrawTexture *) t, nullptr, stats);
          // note: don't send a warning since this will happen during regular tiled rendering
          return false;
       }
@@ -1224,17 +1227,17 @@ static GDrawTexture *RADLINK gdraw_TextureDrawBufferEnd(GDrawStats *stats)
 {
    GDrawFramebufferState *n =   gdraw->cur;
    GDrawFramebufferState *m = --gdraw->cur;
-   if (gdraw->tw == 0 || gdraw->th == 0) return 0;
+   if (gdraw->tw == 0 || gdraw->th == 0) return nullptr;
 
    if (n >= &gdraw->frame[MAX_RENDER_STACK_DEPTH])
-      return 0; // already returned a warning in Begin
+      return nullptr; // already returned a warning in Begin
 
    assert(m >= gdraw->frame);  // bug in Iggy -- unbalanced
 
    if (m != gdraw->frame) {
-      assert(m->color_buffer != NULL); // @GDRAW_ASSERT
+      assert(m->color_buffer != nullptr); // @GDRAW_ASSERT
    }
-   assert(n->color_buffer != NULL); // @GDRAW_ASSERT
+   assert(n->color_buffer != nullptr); // @GDRAW_ASSERT
 
    // switch back to old render target
    set_render_target(stats);
@@ -1284,15 +1287,15 @@ static void RADLINK gdraw_ClearID(void)
 // assuming the depth buffer has been mappped to 0..1
 static F32 depth_from_id(S32 id)
 {
-   return 1.0f - ((F32) id + 1.0f) / MAX_DEPTH_VALUE;
+   return 1.0f - (static_cast<F32>(id) + 1.0f) / MAX_DEPTH_VALUE;
 }
 
 static void set_texture(S32 texunit, GDrawTexture *tex, rrbool nearest, S32 wrap)
 {
    ID3D1XContext *d3d = gdraw->d3d_context;
 
-   if (tex == NULL) {
-      ID3D1X(ShaderResourceView) *notex = NULL;
+   if (tex == nullptr) {
+      ID3D1X(ShaderResourceView) *notex = nullptr;
       d3d->PSSetShaderResources(texunit, 1, &notex);
    } else {
       GDrawHandle *h = (GDrawHandle *) tex;
@@ -1303,7 +1306,7 @@ static void set_texture(S32 texunit, GDrawTexture *tex, rrbool nearest, S32 wrap
 
 static void RADLINK gdraw_Set3DTransform(F32 *mat)
 {
-   if (mat == NULL)
+   if (mat == nullptr)
       gdraw->use_3d = 0;
    else {
       gdraw->use_3d = 1;
@@ -1319,7 +1322,7 @@ static int set_renderstate_full(S32 vertex_format, GDrawRenderState *r, GDrawSta
    set_vertex_shader(d3d, gdraw->vert[vertex_format].vshader);
    
    // set vertex shader constants
-   if (VertexVars *vvars = (VertexVars *) map_buffer(gdraw->d3d_context, gdraw->cb_vertex, true)) {
+   if (VertexVars *vvars = static_cast<VertexVars *>(map_buffer(gdraw->d3d_context, gdraw->cb_vertex, true))) {
       F32 depth = depth_from_id(r->id);
       if (!r->use_world_space)
          gdraw_ObjectSpace(vvars->world[0], r->o2w, depth, 0.0f);
@@ -1366,9 +1369,9 @@ static int set_renderstate_full(S32 vertex_format, GDrawRenderState *r, GDrawSta
          // in stencil set mode, prefer not doing any shading at all
          // but if alpha test is on, we need to make an exception
 
-#ifndef GDRAW_D3D11_LEVEL9 // level9 can't do NULL PS it seems
+#ifndef GDRAW_D3D11_LEVEL9 // level9 can't do nullptr PS it seems
          if (which != GDRAW_TEXTURE_alpha_test)
-            program = NULL;
+            program = nullptr;
          else
 #endif
          {
@@ -1384,7 +1387,7 @@ static int set_renderstate_full(S32 vertex_format, GDrawRenderState *r, GDrawSta
    set_texture(0, r->tex[0], r->nearest0, r->wrap0);
 
    // pixel shader constants
-   if (PixelCommonVars *pvars = (PixelCommonVars *) map_buffer(gdraw->d3d_context, gdraw->cb_ps_common, true)) {
+   if (PixelCommonVars *pvars = static_cast<PixelCommonVars *>(map_buffer(gdraw->d3d_context, gdraw->cb_ps_common, true))) {
       memcpy(pvars->color_mul, r->color, 4*sizeof(float));
 
       if (r->cxf_add) {
@@ -1478,13 +1481,13 @@ static int vertsize[GDRAW_vformat__basic_count] = {
 //   Draw triangles with a given renderstate
 //
 
-static void tag_resources(void *r1, void *r2=NULL, void *r3=NULL, void *r4=NULL)
+static void tag_resources(void *r1, void *r2=nullptr, void *r3=nullptr, void *r4=nullptr)
 {
    U64 now = gdraw->frame_counter;
-   if (r1) ((GDrawHandle *) r1)->fence.value = now;
-   if (r2) ((GDrawHandle *) r2)->fence.value = now;
-   if (r3) ((GDrawHandle *) r3)->fence.value = now;
-   if (r4) ((GDrawHandle *) r4)->fence.value = now;
+   if (r1) static_cast<GDrawHandle *>(r1)->fence.value = now;
+   if (r2) static_cast<GDrawHandle *>(r2)->fence.value = now;
+   if (r3) static_cast<GDrawHandle *>(r3)->fence.value = now;
+   if (r4) static_cast<GDrawHandle *>(r4)->fence.value = now;
 }
 
 static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimitive *p, GDrawVertexBuffer *buf, GDrawStats *stats)
@@ -1501,10 +1504,10 @@ static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimiti
    d3d->IASetInputLayout(gdraw->inlayout[vfmt]);
 
    if (vb) {
-      UINT offs = (UINT) (UINTa) p->vertices;
+      UINT offs = static_cast<UINT>((UINTa)p->vertices);
 
       d3d->IASetVertexBuffers(0, 1, &vb->handle.vbuf.verts, &stride, &offs);
-      d3d->IASetIndexBuffer(vb->handle.vbuf.inds, DXGI_FORMAT_R16_UINT, (UINT) (UINTa) p->indices);
+      d3d->IASetIndexBuffer(vb->handle.vbuf.inds, DXGI_FORMAT_R16_UINT, static_cast<UINT>((UINTa)p->indices));
       d3d->DrawIndexed(p->num_indices, 0, 0);
    } else if (p->indices) {
       U32 vbytes = p->num_vertices * stride;
@@ -1581,10 +1584,10 @@ static void set_pixel_constant(F32 *constant, F32 x, F32 y, F32 z, F32 w)
 static void do_screen_quad(gswf_recti *s, const F32 *tc, GDrawStats *stats)
 {
    ID3D1XContext *d3d = gdraw->d3d_context;
-   F32 px0 = (F32) s->x0, py0 = (F32) s->y0, px1 = (F32) s->x1, py1 = (F32) s->y1;
+   F32 px0 = static_cast<F32>(s->x0), py0 = static_cast<F32>(s->y0), px1 = static_cast<F32>(s->x1), py1 = static_cast<F32>(s->y1);
 
    // generate vertex data
-   gswf_vertex_xyst *vert = (gswf_vertex_xyst *) start_write_dyn(&gdraw->dyn_vb, 4 * sizeof(gswf_vertex_xyst));
+   gswf_vertex_xyst *vert = static_cast<gswf_vertex_xyst *>(start_write_dyn(&gdraw->dyn_vb, 4 * sizeof(gswf_vertex_xyst)));
    if (!vert)
       return;
 
@@ -1595,7 +1598,7 @@ static void do_screen_quad(gswf_recti *s, const F32 *tc, GDrawStats *stats)
    UINT offs = end_write_dyn(&gdraw->dyn_vb);
    UINT stride = sizeof(gswf_vertex_xyst);
 
-   if (VertexVars *vvars = (VertexVars *) map_buffer(gdraw->d3d_context, gdraw->cb_vertex, true)) {
+   if (VertexVars *vvars = static_cast<VertexVars *>(map_buffer(gdraw->d3d_context, gdraw->cb_vertex, true))) {
       gdraw_PixelSpace(vvars->world[0]);
       memcpy(vvars->x3d, gdraw->projmat, 12*sizeof(F32));
       unmap_buffer(gdraw->d3d_context, gdraw->cb_vertex);
@@ -1629,7 +1632,7 @@ static void manual_clear(gswf_recti *r, GDrawStats *stats)
    set_projection_raw(0, gdraw->frametex_width, gdraw->frametex_height, 0);
    set_pixel_shader(d3d, gdraw->clear_ps.pshader);
 
-   if (PixelCommonVars *pvars = (PixelCommonVars *) map_buffer(gdraw->d3d_context, gdraw->cb_ps_common, true)) {
+   if (PixelCommonVars *pvars = static_cast<PixelCommonVars *>(map_buffer(gdraw->d3d_context, gdraw->cb_ps_common, true))) {
       memset(pvars, 0, sizeof(*pvars));
       unmap_buffer(gdraw->d3d_context, gdraw->cb_ps_common);
       d3d->PSSetConstantBuffers(0, 1, &gdraw->cb_ps_common);
@@ -1643,7 +1646,7 @@ static void gdraw_DriverBlurPass(GDrawRenderState *r, int taps,  float *data, gs
    set_texture(0, r->tex[0], false, GDRAW_WRAP_clamp);
 
    set_pixel_shader(gdraw->d3d_context, gdraw->blur_prog[taps].pshader);
-   PixelParaBlur *para = (PixelParaBlur *) start_ps_constants(gdraw->cb_blur);
+   PixelParaBlur *para = static_cast<PixelParaBlur *>(start_ps_constants(gdraw->cb_blur));
    memcpy(para->clamp, clamp, 4 * sizeof(float));
    memcpy(para->tap, data, taps * 4 * sizeof(float));
    end_ps_constants(gdraw->cb_blur);
@@ -1654,13 +1657,13 @@ static void gdraw_DriverBlurPass(GDrawRenderState *r, int taps,  float *data, gs
 
 static void gdraw_Colormatrix(GDrawRenderState *r, gswf_recti *s, float *tc, GDrawStats *stats)
 {
-   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, 0, stats))
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, nullptr, stats))
       return;
 
    set_texture(0, r->tex[0], false, GDRAW_WRAP_clamp);
    set_pixel_shader(gdraw->d3d_context, gdraw->colormatrix.pshader);
 
-   PixelParaColorMatrix *para = (PixelParaColorMatrix *) start_ps_constants(gdraw->cb_colormatrix);
+   PixelParaColorMatrix *para = static_cast<PixelParaColorMatrix *>(start_ps_constants(gdraw->cb_colormatrix));
    memcpy(para->data, r->shader_data, 5 * 4 * sizeof(float));
    end_ps_constants(gdraw->cb_colormatrix);
 
@@ -1672,7 +1675,7 @@ static void gdraw_Colormatrix(GDrawRenderState *r, gswf_recti *s, float *tc, GDr
 static gswf_recti *get_valid_rect(GDrawTexture *tex)
 {
    GDrawHandle *h = (GDrawHandle *) tex;
-   S32 n = (S32) (h - gdraw->rendertargets.handle);
+   S32 n = static_cast<S32>(h - gdraw->rendertargets.handle);
    assert(n >= 0 && n <= MAX_RENDER_STACK_DEPTH+1);
    return &gdraw->rt_valid[n];
 }
@@ -1690,7 +1693,7 @@ static void set_clamp_constant(F32 *constant, GDrawTexture *tex)
 
 static void gdraw_Filter(GDrawRenderState *r, gswf_recti *s, float *tc, int isbevel, GDrawStats *stats)
 {
-   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, NULL, stats))
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, nullptr, stats))
       return;
 
    set_texture(0, r->tex[0], false, GDRAW_WRAP_clamp);
@@ -1698,12 +1701,12 @@ static void gdraw_Filter(GDrawRenderState *r, gswf_recti *s, float *tc, int isbe
    set_texture(2, r->tex[2], false, GDRAW_WRAP_clamp);
    set_pixel_shader(gdraw->d3d_context, gdraw->filter_prog[isbevel][r->filter_mode].pshader);
 
-   PixelParaFilter *para = (PixelParaFilter *) start_ps_constants(gdraw->cb_filter);
+   PixelParaFilter *para = static_cast<PixelParaFilter *>(start_ps_constants(gdraw->cb_filter));
    set_clamp_constant(para->clamp0, r->tex[0]);
    set_clamp_constant(para->clamp1, r->tex[1]);
    set_pixel_constant(para->color, r->shader_data[0], r->shader_data[1], r->shader_data[2], r->shader_data[3]);
    set_pixel_constant(para->color2, r->shader_data[8], r->shader_data[9], r->shader_data[10], r->shader_data[11]);
-   set_pixel_constant(para->tc_off, -r->shader_data[4] / (F32)gdraw->frametex_width, -r->shader_data[5] / (F32)gdraw->frametex_height, r->shader_data[6], 0);
+   set_pixel_constant(para->tc_off, -r->shader_data[4] / static_cast<F32>(gdraw->frametex_width), -r->shader_data[5] / static_cast<F32>(gdraw->frametex_height), r->shader_data[6], 0);
    end_ps_constants(gdraw->cb_filter);
 
    do_screen_quad(s, tc, stats);
@@ -1725,10 +1728,10 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
    if (s.x1 < s.x0 || s.y1 < s.y0)
       return;
 
-   tc[0] = (s.x0 - gdraw->tx0p) / (F32) gdraw->frametex_width;
-   tc[1] = (s.y0 - gdraw->ty0p) / (F32) gdraw->frametex_height;
-   tc[2] = (s.x1 - gdraw->tx0p) / (F32) gdraw->frametex_width;
-   tc[3] = (s.y1 - gdraw->ty0p) / (F32) gdraw->frametex_height;
+   tc[0] = (s.x0 - gdraw->tx0p) / static_cast<F32>(gdraw->frametex_width);
+   tc[1] = (s.y0 - gdraw->ty0p) / static_cast<F32>(gdraw->frametex_height);
+   tc[2] = (s.x1 - gdraw->tx0p) / static_cast<F32>(gdraw->frametex_width);
+   tc[3] = (s.y1 - gdraw->ty0p) / static_cast<F32>(gdraw->frametex_height);
 
    // clear to known render state
    d3d->OMSetBlendState(gdraw->blend_state[GDRAW_BLEND_none], four_zeros, ~0u);
@@ -1778,7 +1781,7 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
             assert(0);
       }
    } else {
-      GDrawHandle *blend_tex = NULL;
+      GDrawHandle *blend_tex = nullptr;
 
       // for crazy blend modes, we need to read back from the framebuffer
       // and do the blending in the pixel shader. we do this with copies
@@ -1811,10 +1814,10 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
             d3d->PSSetSamplers(1, 1, &gdraw->sampler_state[0][GDRAW_WRAP_clamp]);
 
             // calculate texture coordinate remapping
-            rescale1[0] = gdraw->frametex_width / (F32) texdesc.Width;
-            rescale1[1] = gdraw->frametex_height / (F32) texdesc.Height;
-            rescale1[2] = (gdraw->vx - gdraw->tx0 + gdraw->tx0p) / (F32) texdesc.Width;
-            rescale1[3] = (gdraw->vy - gdraw->ty0 + gdraw->ty0p) / (F32) texdesc.Height;
+            rescale1[0] = gdraw->frametex_width / static_cast<F32>(texdesc.Width);
+            rescale1[1] = gdraw->frametex_height / static_cast<F32>(texdesc.Height);
+            rescale1[2] = (gdraw->vx - gdraw->tx0 + gdraw->tx0p) / static_cast<F32>(texdesc.Width);
+            rescale1[3] = (gdraw->vy - gdraw->ty0 + gdraw->ty0p) / static_cast<F32>(texdesc.Height);
          } else {
             D3D1X_(BOX) box = { 0,0,0,0,0,1 };
             S32 dx = 0, dy = 0;
@@ -1847,7 +1850,7 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
       do_screen_quad(&s, tc, stats);
       tag_resources(r->tex[0], r->tex[1]);
       if (blend_tex)
-         gdraw_FreeTexture((GDrawTexture *) blend_tex, 0, stats);
+         gdraw_FreeTexture((GDrawTexture *) blend_tex, nullptr, stats);
    }
 }
 
@@ -1862,18 +1865,18 @@ static void destroy_shader(ProgramWithCachedVariableLocations *p)
 {
    if (p->pshader) {
       p->pshader->Release();
-      p->pshader = NULL;
+      p->pshader = nullptr;
    }
 }
 
 static ID3D1X(Buffer) *create_dynamic_buffer(U32 size, U32 bind)
 {
    D3D1X_(BUFFER_DESC) desc = { size, D3D1X_(USAGE_DYNAMIC), bind, D3D1X_(CPU_ACCESS_WRITE), 0 };
-   ID3D1X(Buffer) *buf = NULL;
-   HRESULT hr = gdraw->d3d_device->CreateBuffer(&desc, NULL, &buf);
+   ID3D1X(Buffer) *buf = nullptr;
+   HRESULT hr = gdraw->d3d_device->CreateBuffer(&desc, nullptr, &buf);
    if (FAILED(hr)) {
       report_d3d_error(hr, "CreateBuffer", " creating dynamic vertex buffer");
-      buf = NULL;
+      buf = nullptr;
    }
    return buf;
 }
@@ -1910,7 +1913,7 @@ static void create_all_shaders_and_state(void)
       HRESULT hr = d3d->CreateInputLayout(vformats[i].desc, vformats[i].nelem, vsh->bytecode, vsh->size, &gdraw->inlayout[i]);
       if (FAILED(hr)) {
          report_d3d_error(hr, "CreateInputLayout", "");
-         gdraw->inlayout[i] = NULL;
+         gdraw->inlayout[i] = nullptr;
       }
    }
 
@@ -2029,11 +2032,11 @@ static void create_all_shaders_and_state(void)
       hr = gdraw->d3d_device->CreateBuffer(&bufdesc, &data, &gdraw->quad_ib);
       if (FAILED(hr)) {
          report_d3d_error(hr, "CreateBuffer", " for constants");
-         gdraw->quad_ib = NULL;
+         gdraw->quad_ib = nullptr;
       }
       IggyGDrawFree(inds);
    } else
-      gdraw->quad_ib = NULL;
+      gdraw->quad_ib = nullptr;
 }
 
 static void destroy_all_shaders_and_state()
@@ -2106,7 +2109,7 @@ static void free_gdraw()
    if (gdraw->texturecache) IggyGDrawFree(gdraw->texturecache);
    if (gdraw->vbufcache) IggyGDrawFree(gdraw->vbufcache);
    IggyGDrawFree(gdraw);
-   gdraw = NULL;
+   gdraw = nullptr;
 }
 
 static bool alloc_dynbuffer(U32 size)
@@ -2142,7 +2145,7 @@ static bool alloc_dynbuffer(U32 size)
    gdraw->max_quad_vert_count = RR_MIN(size / sizeof(gswf_vertex_xyst), QUAD_IB_COUNT * 4);
    gdraw->max_quad_vert_count &= ~3; // must be multiple of four
 
-   return gdraw->dyn_vb.buffer != NULL && gdraw->dyn_ib.buffer != NULL;
+   return gdraw->dyn_vb.buffer != nullptr && gdraw->dyn_ib.buffer != nullptr;
 }
 
 int gdraw_D3D1X_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S32 num_bytes)
@@ -2181,7 +2184,7 @@ int gdraw_D3D1X_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S3
             IggyGDrawFree(gdraw->texturecache);
          }
          gdraw->texturecache = make_handle_cache(GDRAW_D3D1X_(RESOURCE_texture));
-         return gdraw->texturecache != NULL;
+         return gdraw->texturecache != nullptr;
 
       case GDRAW_D3D1X_(RESOURCE_vertexbuffer):
          if (gdraw->vbufcache) {
@@ -2189,7 +2192,7 @@ int gdraw_D3D1X_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S3
             IggyGDrawFree(gdraw->vbufcache);
          }
          gdraw->vbufcache = make_handle_cache(GDRAW_D3D1X_(RESOURCE_vertexbuffer));
-         return gdraw->vbufcache != NULL;
+         return gdraw->vbufcache != nullptr;
 
       case GDRAW_D3D1X_(RESOURCE_dynbuffer):
          unbind_resources();
@@ -2205,7 +2208,7 @@ int gdraw_D3D1X_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S3
 static GDrawFunctions *create_context(ID3D1XDevice *dev, ID3D1XContext *ctx, S32 w, S32 h)
 {
    gdraw = (GDraw *) IggyGDrawMalloc(sizeof(*gdraw));
-   if (!gdraw) return NULL;
+   if (!gdraw) return nullptr;
 
    memset(gdraw, 0, sizeof(*gdraw));
 
@@ -2220,7 +2223,7 @@ static GDrawFunctions *create_context(ID3D1XDevice *dev, ID3D1XContext *ctx, S32
 
    if (!gdraw->texturecache || !gdraw->vbufcache || !alloc_dynbuffer(gdraw_limits[GDRAW_D3D1X_(RESOURCE_dynbuffer)].num_bytes)) {
       free_gdraw();
-      return NULL;
+      return nullptr;
    }
 
    create_all_shaders_and_state();
@@ -2291,7 +2294,7 @@ void gdraw_D3D1X_(DestroyContext)(void)
       if (gdraw->texturecache)   gdraw_res_flush(gdraw->texturecache, &stats);
       if (gdraw->vbufcache)      gdraw_res_flush(gdraw->vbufcache, &stats);
 
-      gdraw->d3d_device = NULL;
+      gdraw->d3d_device = nullptr;
    }
 
    free_gdraw();
@@ -2354,7 +2357,7 @@ void RADLINK gdraw_D3D1X_(GetResourceUsageStats)(gdraw_resourcetype type, S32 *h
       case GDRAW_D3D1X_(RESOURCE_texture):         cache = gdraw->texturecache; break;
       case GDRAW_D3D1X_(RESOURCE_vertexbuffer):    cache = gdraw->vbufcache; break;
       case GDRAW_D3D1X_(RESOURCE_dynbuffer):       *handles_used = 0; *bytes_used = gdraw->last_dyn_maxalloc; return;
-      default:                                     cache = NULL; break;
+      default:                                     cache = nullptr; break;
    }
 
    *handles_used = *bytes_used = 0;
@@ -2384,15 +2387,15 @@ static S32 num_pixels(S32 w, S32 h, S32 mipmaps)
 
 GDrawTexture * RADLINK gdraw_D3D1X_(MakeTextureFromResource)(U8 *resource_file, S32 /*len*/, IggyFileTextureRaw *texture)
 {
-   char *failed_call="";
-   U8 *free_data = 0;
-   GDrawTexture *t=0;
+   const char *failed_call="";
+   U8 *free_data = nullptr;
+   GDrawTexture *t=nullptr;
    S32 width, height, mipmaps, size, blk;
-   ID3D1X(Texture2D) *tex=0;
-   ID3D1X(ShaderResourceView) *view=0;
+   ID3D1X(Texture2D) *tex=nullptr;
+   ID3D1X(ShaderResourceView) *view=nullptr;
 
    DXGI_FORMAT d3dfmt;
-   D3D1X_(SUBRESOURCE_DATA) mipdata[24] = { 0 };
+   D3D1X_(SUBRESOURCE_DATA) mipdata[24] = { nullptr };
    S32 k;
 
    HRESULT hr = S_OK;
@@ -2405,67 +2408,71 @@ GDrawTexture * RADLINK gdraw_D3D1X_(MakeTextureFromResource)(U8 *resource_file,
    D3D1X_(TEXTURE2D_DESC) desc = { static_cast<U32>(width), static_cast<U32>(height), static_cast<U32>(mipmaps), 1U, DXGI_FORMAT_UNKNOWN, { 1, 0 },
       D3D1X_(USAGE_IMMUTABLE), D3D1X_(BIND_SHADER_RESOURCE), 0U, 0U };
 
+   bool done = false;
+
    switch (texture->format) {
       case IFT_FORMAT_rgba_8888   : size= 4; d3dfmt = DXGI_FORMAT_R8G8B8A8_UNORM; break;
       case IFT_FORMAT_DXT1        : size= 8; d3dfmt = DXGI_FORMAT_BC1_UNORM; blk = 4; break;
       case IFT_FORMAT_DXT3        : size=16; d3dfmt = DXGI_FORMAT_BC2_UNORM; blk = 4; break;
       case IFT_FORMAT_DXT5        : size=16; d3dfmt = DXGI_FORMAT_BC3_UNORM; blk = 4; break;
       default: {
-         IggyGDrawSendWarning(NULL, "GDraw .iggytex raw texture format %d not supported by hardware", texture->format);
-         goto done;
+         IggyGDrawSendWarning(nullptr, "GDraw .iggytex raw texture format %d not supported by hardware", texture->format);
+         done = true;
       }
    }
 
-   desc.Format = d3dfmt;
-
-   U8 *data = resource_file + texture->file_offset;
-
-   if (texture->format == IFT_FORMAT_i_8 || texture->format == IFT_FORMAT_i_4) {
-      // convert from intensity to luma+alpha
-      S32 i;
-      S32 total_size = 2 * num_pixels(width,height,mipmaps);
-
-      free_data = (U8 *) IggyGDrawMalloc(total_size);
-      if (!free_data) {
-         IggyGDrawSendWarning(NULL, "GDraw out of memory to store texture data to pass to D3D for %d x %d texture", width, height);
-         goto done;
+   if (!done) {
+      desc.Format = d3dfmt;
+      
+      U8 *data = resource_file + texture->file_offset;
+      
+      if (texture->format == IFT_FORMAT_i_8 || texture->format == IFT_FORMAT_i_4) {
+         // convert from intensity to luma+alpha
+         S32 i;
+         S32 total_size = 2 * num_pixels(width,height,mipmaps);
+      
+         free_data = (U8 *) IggyGDrawMalloc(total_size);
+         if (!free_data) {
+            IggyGDrawSendWarning(nullptr, "GDraw out of memory to store texture data to pass to D3D for %d x %d texture", width, height);
+            done = true;
+         } else {
+            U8 *cur = free_data;
+            
+            for (k=0; k < mipmaps; ++k) {
+               S32 w = RR_MAX(width >> k, 1);
+               S32 h = RR_MAX(height >> k, 1);
+               for (i=0; i < w*h; ++i) {
+                  cur[0] = cur[1] = *data++;
+                  cur += 2;
+               }
+            }
+            data = free_data;
+         }
       }
-
-      U8 *cur = free_data;
-
-      for (k=0; k < mipmaps; ++k) {
-         S32 w = RR_MAX(width >> k, 1);
-         S32 h = RR_MAX(height >> k, 1);
-         for (i=0; i < w*h; ++i) {
-            cur[0] = cur[1] = *data++;
-            cur += 2;
+      
+      if (!done) {
+         for (k=0; k < mipmaps; ++k) {
+            S32 w = RR_MAX(width >> k, 1);
+            S32 h = RR_MAX(height >> k, 1);
+            S32 blkw = (w + blk-1) / blk;
+            S32 blkh = (h + blk-1) / blk;
+         
+            mipdata[k].pSysMem     = data;
+            mipdata[k].SysMemPitch = blkw * size;
+            data += blkw * blkh * size;
+         }
+         
+         failed_call = "CreateTexture2D";
+         hr = gdraw->d3d_device->CreateTexture2D(&desc, mipdata, &tex);
+         if (!FAILED(hr)) {
+             failed_call = "CreateShaderResourceView for texture creation";
+             hr = gdraw->d3d_device->CreateShaderResourceView(tex, nullptr, &view);
+             if (!FAILED(hr))
+                 t = gdraw_D3D1X_(WrappedTextureCreate)(view);
          }
       }
-      data = free_data;
-   }
-
-   for (k=0; k < mipmaps; ++k) {
-      S32 w = RR_MAX(width >> k, 1);
-      S32 h = RR_MAX(height >> k, 1);
-      S32 blkw = (w + blk-1) / blk;
-      S32 blkh = (h + blk-1) / blk;
-
-      mipdata[k].pSysMem     = data;
-      mipdata[k].SysMemPitch = blkw * size;
-      data += blkw * blkh * size;
    }
 
-   failed_call = "CreateTexture2D";
-   hr = gdraw->d3d_device->CreateTexture2D(&desc, mipdata, &tex);
-   if (FAILED(hr)) goto done;
-
-   failed_call = "CreateShaderResourceView for texture creation";
-   hr = gdraw->d3d_device->CreateShaderResourceView(tex, NULL, &view);
-   if (FAILED(hr)) goto done;
-
-   t = gdraw_D3D1X_(WrappedTextureCreate)(view);
-
-done:
    if (FAILED(hr)) {
       report_d3d_error(hr, failed_call, "");
    }
@@ -2479,14 +2486,14 @@ done:
       if (tex)
          tex->Release();
    } else {
-      ((GDrawHandle *) t)->handle.tex.d3d = tex;
+      reinterpret_cast<GDrawHandle *>(t)->handle.tex.d3d = tex;
    }
    return t;
 }
 
 void RADLINK gdraw_D3D1X_(DestroyTextureFromResource)(GDrawTexture *tex)
 {
-   GDrawHandle *h = (GDrawHandle *) tex;
+   GDrawHandle *h = reinterpret_cast<GDrawHandle *>(tex);
    safe_release(h->handle.tex.d3d_view);
    safe_release(h->handle.tex.d3d);
    gdraw_D3D1X_(WrappedTextureDestroy)(tex);
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shaders.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shaders.inl
index dc8a0484..74a29221 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shaders.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shaders.inl
@@ -181,7 +181,7 @@ static char *pshader_basic_vars[] = {
    "color_mul",
    "color_add",
    "focal",
-   NULL
+   nullptr
 };
 
 static char pshader_general2_frag0[] =
@@ -293,7 +293,7 @@ static char **pshader_general2(void)
 
 static char *pshader_general2_vars[] = {
    "tex0",
-   NULL
+   nullptr
 };
 
 static char pshader_exceptional_blend_frag0[] =
@@ -414,7 +414,7 @@ static char pshader_exceptional_blend_frag13[] =
 
 #define NUMFRAGMENTS_pshader_exceptional_blend 3
 static char *pshader_exceptional_blend_arr[13][NUMFRAGMENTS_pshader_exceptional_blend] = {
-   { NULL, NULL, NULL, },
+   { nullptr, nullptr, nullptr, },
    { pshader_exceptional_blend_frag0, pshader_exceptional_blend_frag1, pshader_exceptional_blend_frag2, },
    { pshader_exceptional_blend_frag0, pshader_exceptional_blend_frag3, pshader_exceptional_blend_frag2, },
    { pshader_exceptional_blend_frag0, pshader_exceptional_blend_frag4, pshader_exceptional_blend_frag2, },
@@ -439,7 +439,7 @@ static char *pshader_exceptional_blend_vars[] = {
    "tex1",
    "color_mul",
    "color_add",
-   NULL
+   nullptr
 };
 
 static char pshader_filter_frag0[] =
@@ -593,10 +593,10 @@ static char *pshader_filter_arr[32][NUMFRAGMENTS_pshader_filter] = {
    { pshader_filter_frag0, pshader_filter_frag1, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag3, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag1, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag1, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag1, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag3, pshader_filter_frag2, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag3, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag1, pshader_filter_frag2, },
@@ -609,10 +609,10 @@ static char *pshader_filter_arr[32][NUMFRAGMENTS_pshader_filter] = {
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag3, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag1, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag3, pshader_filter_frag2, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
 };
 
 static char **pshader_filter(int bevel, int ontop, int inner, int gradient, int knockout)
@@ -629,7 +629,7 @@ static char *pshader_filter_vars[] = {
    "clamp0",
    "clamp1",
    "color2",
-   NULL
+   nullptr
 };
 
 static char pshader_blur_frag0[] =
@@ -701,8 +701,8 @@ static char pshader_blur_frag9[] =
 
 #define NUMFRAGMENTS_pshader_blur 3
 static char *pshader_blur_arr[10][NUMFRAGMENTS_pshader_blur] = {
-   { NULL, NULL, NULL, },
-   { NULL, NULL, NULL, },
+   { nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, },
    { pshader_blur_frag0, pshader_blur_frag1, pshader_blur_frag2, },
    { pshader_blur_frag0, pshader_blur_frag3, pshader_blur_frag2, },
    { pshader_blur_frag0, pshader_blur_frag4, pshader_blur_frag2, },
@@ -722,7 +722,7 @@ static char *pshader_blur_vars[] = {
    "tex0",
    "tap",
    "clampv",
-   NULL
+   nullptr
 };
 
 static char pshader_color_matrix_frag0[] =
@@ -804,7 +804,7 @@ static char **pshader_color_matrix(void)
 static char *pshader_color_matrix_vars[] = {
    "tex0",
    "data",
-   NULL
+   nullptr
 };
 
 static char pshader_manual_clear_frag0[] =
@@ -855,7 +855,7 @@ static char **pshader_manual_clear(void)
 
 static char *pshader_manual_clear_vars[] = {
    "color_mul",
-   NULL
+   nullptr
 };
 
 static char vshader_vsgl_frag0[] =
@@ -966,7 +966,7 @@ static char *vshader_vsgl_vars[] = {
    "texgen_s",
    "texgen_t",
    "viewproj",
-   NULL
+   nullptr
 };
 
 static char vshader_vsglihud_frag0[] =
@@ -1079,6 +1079,6 @@ static char *vshader_vsglihud_vars[] = {
    "worldview",
    "material",
    "textmode",
-   NULL
+   nullptr
 };
 
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shared.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shared.inl
index 9916096a..f134b740 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shared.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shared.inl
@@ -60,7 +60,7 @@ static RADINLINE void break_on_err(GLint e)
 static void report_err(GLint e)
 {
    break_on_err(e);
-   IggyGDrawSendWarning(NULL, "OpenGL glGetError error");
+   IggyGDrawSendWarning(nullptr, "OpenGL glGetError error");
 }
 
 static void compilation_err(const char *msg)
@@ -256,7 +256,7 @@ static void make_texture(GLuint tex)
 static void make_rendertarget(GDrawHandle *t, GLuint tex, GLenum int_type, GLenum ext_type, GLenum data_type, S32 w, S32 h, S32 size)
 {
    glBindTexture(GL_TEXTURE_2D, tex);
-   glTexImage2D(GL_TEXTURE_2D, 0, int_type, w, h, 0, ext_type, data_type, NULL);
+   glTexImage2D(GL_TEXTURE_2D, 0, int_type, w, h, 0, ext_type, data_type, nullptr);
    make_texture(tex);
    glBindTexture(GL_TEXTURE_2D, 0);
 }
@@ -309,7 +309,7 @@ extern GDrawTexture *gdraw_GLx_(WrappedTextureCreate)(S32 gl_texture_handle, S32
    p->handle.tex.w = width;
    p->handle.tex.h = height;
    p->handle.tex.nonpow2 = !(is_pow2(width) && is_pow2(height));
-   gdraw_HandleCacheAllocateEnd(p, 0, NULL, GDRAW_HANDLE_STATE_user_owned);
+   gdraw_HandleCacheAllocateEnd(p, 0, nullptr, GDRAW_HANDLE_STATE_user_owned);
    return (GDrawTexture *) p;
 }
 
@@ -350,7 +350,7 @@ static void RADLINK gdraw_SetTextureUniqueID(GDrawTexture *tex, void *old_id, vo
 static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height, gdraw_texture_format format, U32 flags, GDraw_MakeTexture_ProcessingInfo *p, GDrawStats *gstats)
 {
    S32 size=0, asize, stride;
-   GDrawHandle *t = NULL;
+   GDrawHandle *t = nullptr;
    opengl_check();
 
    stride = width;
@@ -369,7 +369,7 @@ static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height,
    p->texture_data = IggyGDrawMalloc(size);
    if (!p->texture_data) {
       gdraw_HandleCacheAllocateFail(t);
-      IggyGDrawSendWarning(NULL, "GDraw malloc for texture data failed");
+      IggyGDrawSendWarning(nullptr, "GDraw malloc for texture data failed");
       return false;
    }
    
@@ -419,9 +419,9 @@ static GDrawTexture * RADLINK gdraw_MakeTextureEnd(GDraw_MakeTexture_ProcessingI
 
    if (e != 0) {
       gdraw_HandleCacheAllocateFail(t);
-      IggyGDrawSendWarning(NULL, "GDraw OpenGL error creating texture");
+      IggyGDrawSendWarning(nullptr, "GDraw OpenGL error creating texture");
       eat_gl_err();
-      return NULL;
+      return nullptr;
    } else {
       gdraw_HandleCacheAllocateEnd(t, p->i4, p->p1, (flags & GDRAW_MAKETEXTURE_FLAGS_never_flush) ? GDRAW_HANDLE_STATE_pinned : GDRAW_HANDLE_STATE_locked);
       stats->nonzero_flags |= GDRAW_STATS_alloc_tex;
@@ -467,8 +467,8 @@ static void RADLINK gdraw_UpdateTextureEnd(GDrawTexture *tex, void *unique_id, G
 static void RADLINK gdraw_FreeTexture(GDrawTexture *tt, void *unique_id, GDrawStats *gstats)
 {
    GDrawHandle *t = (GDrawHandle *) tt;
-   assert(t != NULL);
-   if (t->owner == unique_id || unique_id == NULL) {
+   assert(t != nullptr);
+   if (t->owner == unique_id || unique_id == nullptr) {
       if (t->cache == &gdraw->rendertargets) {
          gdraw_HandleCacheUnlock(t);
          // cache it by simply not freeing it
@@ -516,7 +516,7 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
    opengl_check();
    vb = gdraw_res_alloc_begin(gdraw->vbufcache, vbuf_size + ibuf_size, gstats);
    if (!vb) {
-      IggyGDrawSendWarning(NULL, "GDraw out of vertex buffer memory");
+      IggyGDrawSendWarning(nullptr, "GDraw out of vertex buffer memory");
       return false;
    }
 
@@ -526,9 +526,9 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
    glGenBuffers(1, &vb->handle.vbuf.base);
    glGenBuffers(1, &vb->handle.vbuf.indices);
    glBindBuffer(GL_ARRAY_BUFFER, vb->handle.vbuf.base);
-   glBufferData(GL_ARRAY_BUFFER, vbuf_size, NULL, GL_STATIC_DRAW);
+   glBufferData(GL_ARRAY_BUFFER, vbuf_size, nullptr, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vb->handle.vbuf.indices);
-   glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibuf_size, NULL, GL_STATIC_DRAW);
+   glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibuf_size, nullptr, GL_STATIC_DRAW);
    if (!e) e = glGetError();
    if (e != GL_NO_ERROR) {
       glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -537,7 +537,7 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
       glDeleteBuffers(1, &vb->handle.vbuf.indices);
       gdraw_HandleCacheAllocateFail(vb);
       eat_gl_err();
-      IggyGDrawSendWarning(NULL, "GDraw OpenGL vertex buffer creation failed");
+      IggyGDrawSendWarning(nullptr, "GDraw OpenGL vertex buffer creation failed");
       return false;
    }
 
@@ -556,7 +556,7 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
       if (!p->vertex_data || !p->index_data) {
          if (p->vertex_data)  IggyGDrawFree(p->vertex_data);
          if (p->index_data)   IggyGDrawFree(p->index_data);
-         IggyGDrawSendWarning(NULL, "GDraw malloc for vertex buffer temporary memory failed");
+         IggyGDrawSendWarning(nullptr, "GDraw malloc for vertex buffer temporary memory failed");
          return false;
       }
    } else {
@@ -602,7 +602,7 @@ static GDrawVertexBuffer * RADLINK gdraw_MakeVertexBufferEnd(GDraw_MakeVertexBuf
       glDeleteBuffers(1, &vb->handle.vbuf.indices);
       gdraw_HandleCacheAllocateFail(vb);
       eat_gl_err();
-      return NULL;
+      return nullptr;
    } else
       gdraw_HandleCacheAllocateEnd(vb, p->i0 + p->i1, p->p1, GDRAW_HANDLE_STATE_locked);
 
@@ -619,7 +619,7 @@ static rrbool RADLINK gdraw_TryToLockVertexBuffer(GDrawVertexBuffer *vb, void *u
 static void RADLINK gdraw_FreeVertexBuffer(GDrawVertexBuffer *vb, void *unique_id, GDrawStats *stats)
 {
    GDrawHandle *h = (GDrawHandle *) vb;
-   assert(h != NULL);
+   assert(h != nullptr);
    if (h->owner == unique_id)
       gdraw_res_free(h, stats);
 }
@@ -678,13 +678,13 @@ static GDrawHandle *get_color_rendertarget(GDrawStats *gstats)
    // ran out of RTs, allocate a new one
    size = gdraw->frametex_width * gdraw->frametex_height * 4;
    if (gdraw->rendertargets.bytes_free < size) {
-      IggyGDrawSendWarning(NULL, "GDraw exceeded available rendertarget memory");
-      return NULL;
+      IggyGDrawSendWarning(nullptr, "GDraw exceeded available rendertarget memory");
+      return nullptr;
    }
 
    t = gdraw_HandleCacheAllocateBegin(&gdraw->rendertargets);
    if (!t) {
-      IggyGDrawSendWarning(NULL, "GDraw exceeded available rendertarget handles");
+      IggyGDrawSendWarning(nullptr, "GDraw exceeded available rendertarget handles");
       return t;
    }
 
@@ -873,7 +873,7 @@ static void RADLINK gdraw_SetViewSizeAndWorldScale(S32 w, S32 h, F32 scalex, F32
 
 static void RADLINK gdraw_Set3DTransform(F32 *mat)
 {
-   if (mat == NULL)
+   if (mat == nullptr)
       gdraw->use_3d = 0;
    else {
       gdraw->use_3d = 1;
@@ -992,30 +992,30 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
    GDrawHandle *t;
    int k;
    if (gdraw->tw == 0 || gdraw->th == 0) {
-      IggyGDrawSendWarning(NULL, "GDraw got a request for an empty rendertarget");
+      IggyGDrawSendWarning(nullptr, "GDraw got a request for an empty rendertarget");
       return false;
    }
 
    if (n >= &gdraw->frame[MAX_RENDER_STACK_DEPTH]) {
-      IggyGDrawSendWarning(NULL, "GDraw rendertarget nesting exceeded MAX_RENDER_STACK_DEPTH");
+      IggyGDrawSendWarning(nullptr, "GDraw rendertarget nesting exceeded MAX_RENDER_STACK_DEPTH");
       return false;
    }
 
    if (owner) {
       t = get_rendertarget_texture(region->x1 - region->x0, region->y1 - region->y0, owner, gstats);
       if (!t) {
-         IggyGDrawSendWarning(NULL, "GDraw ran out of rendertargets for cacheAsBItmap");
+         IggyGDrawSendWarning(nullptr, "GDraw ran out of rendertargets for cacheAsBItmap");
          return false;
       }
    } else {
       t = get_color_rendertarget(gstats);
       if (!t) {
-         IggyGDrawSendWarning(NULL, "GDraw ran out of rendertargets");
+         IggyGDrawSendWarning(nullptr, "GDraw ran out of rendertargets");
          return false;
       }
    }
    n->color_buffer = t;
-   assert(n->color_buffer != NULL);
+   assert(n->color_buffer != nullptr);
 
    if (n == gdraw->frame+1)
       n->stencil_depth = get_depthstencil_renderbuffer(gstats);
@@ -1023,7 +1023,7 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
       n->stencil_depth = (n-1)->stencil_depth;
    ++gdraw->cur;
 
-   gdraw->cur->cached = owner != NULL;
+   gdraw->cur->cached = owner != nullptr;
    if (owner) {
       gdraw->cur->base_x = region->x0;
       gdraw->cur->base_y = region->y0;
@@ -1161,8 +1161,8 @@ static GDrawTexture *RADLINK gdraw_TextureDrawBufferEnd(GDrawStats *gstats)
    assert(m >= gdraw->frame);  // bug in Iggy -- unbalanced
 
    if (m != gdraw->frame)
-      assert(m->color_buffer != NULL);
-   assert(n->color_buffer != NULL);
+      assert(m->color_buffer != nullptr);
+   assert(n->color_buffer != nullptr);
 
    // remove color and stencil buffers
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , GL_RENDERBUFFER, 0);
@@ -1274,7 +1274,7 @@ static float depth_from_id(S32 id)
 static void set_texture(U32 texunit, GDrawTexture *tex)
 {
    glActiveTexture(GL_TEXTURE0 + texunit);
-   if (tex == NULL)
+   if (tex == nullptr)
       glBindTexture(GL_TEXTURE_2D, 0);
    else
       glBindTexture(GL_TEXTURE_2D, ((GDrawHandle *) tex)->handle.tex.gl);
@@ -1575,7 +1575,7 @@ static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimiti
       glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    }
 
-   if (!set_render_state(r,p->vertex_format, NULL, p, gstats)) return;
+   if (!set_render_state(r,p->vertex_format, nullptr, p, gstats)) return;
    gstats->nonzero_flags |= GDRAW_STATS_batches;
    gstats->num_batches += 1;
    gstats->drawn_indices += p->num_indices;
@@ -1593,7 +1593,7 @@ static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimiti
       while (pos < p->num_vertices) {
          S32 vert_count = RR_MIN(p->num_vertices - pos, QUAD_IB_COUNT * 4);
          set_vertex_format(p->vertex_format, p->vertices + pos*stride);
-         glDrawElements(GL_TRIANGLES, (vert_count >> 2) * 6, GL_UNSIGNED_SHORT, NULL);
+         glDrawElements(GL_TRIANGLES, (vert_count >> 2) * 6, GL_UNSIGNED_SHORT, nullptr);
          pos += vert_count;
       }
       
@@ -1719,7 +1719,7 @@ static void gdraw_DriverBlurPass(GDrawRenderState *r, int taps, F32 *data, gswf_
 static void gdraw_Colormatrix(GDrawRenderState *r, gswf_recti *s, float *tc, GDrawStats *gstats)
 {
    ProgramWithCachedVariableLocations *prg = &gdraw->colormatrix;
-   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, NULL, gstats))
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, nullptr, gstats))
       return;
    use_lazy_shader(prg);
    set_texture(0, r->tex[0]);
@@ -1752,7 +1752,7 @@ static void set_clamp_constant(GLint constant, GDrawTexture *tex)
 static void gdraw_Filter(GDrawRenderState *r, gswf_recti *s, float *tc, int isbevel, GDrawStats *gstats)
 {
    ProgramWithCachedVariableLocations *prg = &gdraw->filter_prog[isbevel][r->filter_mode];
-   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, NULL, gstats))
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, nullptr, gstats))
       return;
    use_lazy_shader(prg);
    set_texture(0, r->tex[0]);
@@ -1845,7 +1845,7 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
             assert(0);
       }
    } else {
-      GDrawTexture *blend_tex = NULL;
+      GDrawTexture *blend_tex = nullptr;
       const int *vvars;
 
       // for crazy blend modes, we need to read back from the framebuffer
@@ -1864,7 +1864,7 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
          set_texture(1, blend_tex);
       }
 
-      if (!set_render_state(r, GDRAW_vformat_v2tc2, &vvars, NULL, gstats))
+      if (!set_render_state(r, GDRAW_vformat_v2tc2, &vvars, nullptr, gstats))
          return;
       do_screen_quad(&s, tc, vvars, gstats, 0);
       tag_resources(r->tex[0],r->tex[1],0);
@@ -1932,7 +1932,7 @@ static void make_fragment_program(ProgramWithCachedVariableLocations *p, int num
    }
 
    shad = glCreateShader(GL_FRAGMENT_SHADER);
-   glShaderSource(shad, num_strings, (const GLchar **)strings, NULL);
+   glShaderSource(shad, num_strings, (const GLchar **)strings, nullptr);
    glCompileShader(shad);
    glGetShaderiv(shad, GL_COMPILE_STATUS, &res);
    if (!res) {
@@ -1994,7 +1994,7 @@ static void make_vertex_program(GLuint *vprog, int num_strings, char **strings)
    if(strings[0])
    {
       shad = glCreateShader(GL_VERTEX_SHADER);
-      glShaderSource(shad, num_strings, (const GLchar **)strings, NULL);
+      glShaderSource(shad, num_strings, (const GLchar **)strings, nullptr);
       glCompileShader(shad);
       glGetShaderiv(shad, GL_COMPILE_STATUS, &res);
       if (!res) {
@@ -2154,7 +2154,7 @@ static void free_gdraw()
    if (gdraw->texturecache) IggyGDrawFree(gdraw->texturecache);
    if (gdraw->vbufcache) IggyGDrawFree(gdraw->vbufcache);
    IggyGDrawFree(gdraw);
-   gdraw = NULL;
+   gdraw = nullptr;
 }
 
 int gdraw_GLx_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S32 num_bytes)
@@ -2193,7 +2193,7 @@ int gdraw_GLx_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S32
             IggyGDrawFree(gdraw->texturecache);
          }
          gdraw->texturecache = make_handle_cache(GDRAW_GLx_(RESOURCE_texture));
-         return gdraw->texturecache != NULL;
+         return gdraw->texturecache != nullptr;
 
       case GDRAW_GLx_(RESOURCE_vertexbuffer):
          if (gdraw->vbufcache) {
@@ -2201,7 +2201,7 @@ int gdraw_GLx_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S32
             IggyGDrawFree(gdraw->vbufcache);
          }
          gdraw->vbufcache = make_handle_cache(GDRAW_GLx_(RESOURCE_vertexbuffer));
-         return gdraw->vbufcache != NULL;
+         return gdraw->vbufcache != nullptr;
 
       default:
          return 0;
@@ -2220,12 +2220,12 @@ GDrawTexture * RADLINK gdraw_GLx_(MakeTextureFromResource)(U8 *resource_file, S3
    while (fmt->iggyfmt != texture->format && fmt->blkbytes)
       fmt++;
    if (!fmt->blkbytes) // end of list - i.e. format not supported
-      return NULL;
+      return nullptr;
 
    // prepare texture
    glGenTextures(1, &gl_texture_handle);
    if (gl_texture_handle == 0)
-      return NULL;
+      return nullptr;
 
    opengl_check();
    make_texture(gl_texture_handle);
@@ -2283,7 +2283,7 @@ GDrawTexture * RADLINK gdraw_GLx_(MakeTextureFromResource)(U8 *resource_file, S3
       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mips-1);
 
    tex = gdraw_GLx_(WrappedTextureCreate)(gl_texture_handle, texture->w, texture->h, mips > 1);
-   if (tex == NULL)
+   if (tex == nullptr)
       glDeleteTextures(1, &gl_texture_handle);
    opengl_check();
    return tex;
@@ -2301,7 +2301,7 @@ static rrbool hasext(const char *exts, const char *which)
    size_t len;
 
 #ifdef GDRAW_USE_glGetStringi
-   if (exts == NULL) {
+   if (exts == nullptr) {
       GLint i, num_exts;
       glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts);
       for (i=0; i < num_exts; ++i)
@@ -2316,7 +2316,7 @@ static rrbool hasext(const char *exts, const char *which)
 
    for(;;) {
       where = strstr(where, which);
-      if (where == NULL)
+      if (where == nullptr)
          return false;
 
       if (   (where == exts || *(where - 1) == ' ')   // starts with terminator
@@ -2329,7 +2329,7 @@ static rrbool hasext(const char *exts, const char *which)
 static GDrawFunctions *create_context(S32 w, S32 h)
 {
    gdraw = IggyGDrawMalloc(sizeof(*gdraw));
-   if (!gdraw) return NULL;
+   if (!gdraw) return nullptr;
 
    memset(gdraw, 0, sizeof(*gdraw));
 
@@ -2339,7 +2339,7 @@ static GDrawFunctions *create_context(S32 w, S32 h)
 
    if (!gdraw->texturecache || !gdraw->vbufcache || !make_quad_indices()) {
       free_gdraw();
-      return NULL;
+      return nullptr;
    }
 
    opengl_check();
@@ -2380,7 +2380,7 @@ static GDrawFunctions *create_context(S32 w, S32 h)
    gdraw_funcs.ClearID = gdraw_ClearID;
 
    gdraw_funcs.MakeTextureBegin = gdraw_MakeTextureBegin;
-   gdraw_funcs.MakeTextureMore = NULL;
+   gdraw_funcs.MakeTextureMore = nullptr;
    gdraw_funcs.MakeTextureEnd = gdraw_MakeTextureEnd;
 
    gdraw_funcs.UpdateTextureRect = gdraw_UpdateTextureRect;
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_shared.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_shared.inl
index a60fa520..1790de77 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_shared.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_shared.inl
@@ -226,7 +226,7 @@ static void debug_check_raw_values(GDrawHandleCache *c)
             s = s->next;
          }
          s = c->active;
-         while (s != NULL) {
+         while (s != nullptr) {
             assert(s->raw_ptr != t->raw_ptr);
             s = s->next;
          }
@@ -368,7 +368,7 @@ static void gdraw_HandleTransitionInsertBefore(GDrawHandle *t, GDrawHandleState
 {
    check_lists(t->cache);
    assert(t->state != GDRAW_HANDLE_STATE_sentinel); // sentinels should never get here!
-   assert(t->state != (U32) new_state); // code should never call "transition" if it's not transitioning!
+   assert(t->state != static_cast<U32>(new_state)); // code should never call "transition" if it's not transitioning!
    // unlink from prev state
    t->prev->next = t->next;
    t->next->prev = t->prev;
@@ -433,7 +433,7 @@ static rrbool gdraw_HandleCacheLockStats(GDrawHandle *t, void *owner, GDrawStats
 
 static rrbool gdraw_HandleCacheLock(GDrawHandle *t, void *owner)
 {
-   return gdraw_HandleCacheLockStats(t, owner, NULL);
+   return gdraw_HandleCacheLockStats(t, owner, nullptr);
 }
 
 static void gdraw_HandleCacheUnlock(GDrawHandle *t)
@@ -461,11 +461,11 @@ static void gdraw_HandleCacheInit(GDrawHandleCache *c, S32 num_handles, S32 byte
    c->is_thrashing = false;
    c->did_defragment = false;
    for (i=0; i < GDRAW_HANDLE_STATE__count; i++) {
-      c->state[i].owner = NULL;
-      c->state[i].cache = NULL; // should never follow cache link from sentinels!
+      c->state[i].owner = nullptr;
+      c->state[i].cache = nullptr; // should never follow cache link from sentinels!
       c->state[i].next = c->state[i].prev = &c->state[i];
 #ifdef GDRAW_MANAGE_MEM
-      c->state[i].raw_ptr = NULL;
+      c->state[i].raw_ptr = nullptr;
 #endif
       c->state[i].fence.value = 0;
       c->state[i].bytes = 0;
@@ -478,7 +478,7 @@ static void gdraw_HandleCacheInit(GDrawHandleCache *c, S32 num_handles, S32 byte
       c->handle[i].bytes = 0;
       c->handle[i].state = GDRAW_HANDLE_STATE_free;
 #ifdef GDRAW_MANAGE_MEM
-      c->handle[i].raw_ptr = NULL;
+      c->handle[i].raw_ptr = nullptr;
 #endif
    }
    c->state[GDRAW_HANDLE_STATE_free].next = &c->handle[0];
@@ -486,10 +486,10 @@ static void gdraw_HandleCacheInit(GDrawHandleCache *c, S32 num_handles, S32 byte
    c->prev_frame_start.value = 0;
    c->prev_frame_end.value = 0;
 #ifdef GDRAW_MANAGE_MEM
-   c->alloc = NULL;
+   c->alloc = nullptr;
 #endif
 #ifdef GDRAW_MANAGE_MEM_TWOPOOL
-   c->alloc_other = NULL;
+   c->alloc_other = nullptr;
 #endif
    check_lists(c);
 }
@@ -497,14 +497,14 @@ static void gdraw_HandleCacheInit(GDrawHandleCache *c, S32 num_handles, S32 byte
 static GDrawHandle *gdraw_HandleCacheAllocateBegin(GDrawHandleCache *c)
 {
    GDrawHandle *free_list = &c->state[GDRAW_HANDLE_STATE_free];
-   GDrawHandle *t = NULL;
+   GDrawHandle *t = nullptr;
    if (free_list->next != free_list) {
       t = free_list->next;
       gdraw_HandleTransitionTo(t, GDRAW_HANDLE_STATE_alloc);
       t->bytes = 0;
       t->owner = 0;
 #ifdef GDRAW_MANAGE_MEM
-      t->raw_ptr = NULL;
+      t->raw_ptr = nullptr;
 #endif
 #ifdef GDRAW_CORRUPTION_CHECK
       t->has_check_value = false;
@@ -558,7 +558,7 @@ static GDrawHandle *gdraw_HandleCacheGetLRU(GDrawHandleCache *c)
    // at the front of the LRU list are the oldest ones, since in-use resources
    // will get appended on every transition from "locked" to "live".
    GDrawHandle *sentinel = &c->state[GDRAW_HANDLE_STATE_live];
-   return (sentinel->next != sentinel) ? sentinel->next : NULL;
+   return (sentinel->next != sentinel) ? sentinel->next : nullptr;
 }
 
 static void gdraw_HandleCacheTick(GDrawHandleCache *c, GDrawFence now)
@@ -773,7 +773,7 @@ static GDrawTexture *gdraw_BlurPass(GDrawFunctions *g, GDrawBlurInfo *c, GDrawRe
    if (!g->TextureDrawBufferBegin(draw_bounds, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, 0, gstats))
       return r->tex[0];
 
-   c->BlurPass(r, taps, data, draw_bounds, tc, (F32) c->h / c->frametex_height, clamp, gstats);
+   c->BlurPass(r, taps, data, draw_bounds, tc, static_cast<F32>(c->h) / c->frametex_height, clamp, gstats);
    return g->TextureDrawBufferEnd(gstats);
 }
 
@@ -825,7 +825,7 @@ static GDrawTexture *gdraw_BlurPassDownsample(GDrawFunctions *g, GDrawBlurInfo *
    assert(clamp[0] <= clamp[2]);
    assert(clamp[1] <= clamp[3]);
 
-   c->BlurPass(r, taps, data, &z, tc, (F32) c->h / c->frametex_height, clamp, gstats);
+   c->BlurPass(r, taps, data, &z, tc, static_cast<F32>(c->h) / c->frametex_height, clamp, gstats);
    return g->TextureDrawBufferEnd(gstats);
 }
 
@@ -837,7 +837,7 @@ static void gdraw_BlurAxis(S32 axis, GDrawFunctions *g, GDrawBlurInfo *c, GDrawR
    GDrawTexture *t;
    F32 data[MAX_TAPS][4];
    S32 off_axis = 1-axis;
-   S32 w = ((S32) ceil((blur_width-1)/2))*2+1;  // 1.2 => 3, 2.8 => 3, 3.2 => 5
+   S32 w = static_cast<S32>(ceil((blur_width - 1) / 2))*2+1;  // 1.2 => 3, 2.8 => 3, 3.2 => 5
    F32 edge_weight = 1 - (w - blur_width)/2;   // 3 => 0 => 1;   1.2 => 1.8 => 0.9 => 0.1
    F32 inverse_weight = 1.0f / blur_width;
 
@@ -944,7 +944,7 @@ static void gdraw_BlurAxis(S32 axis, GDrawFunctions *g, GDrawBlurInfo *c, GDrawR
          // max coverage is 25 samples, or a filter width of 13. with 7 taps, we sample
          // 13 samples in one pass, max coverage is 13*13 samples or (13*13-1)/2 width,
          // which is ((2T-1)*(2T-1)-1)/2 or (4T^2 - 4T + 1 -1)/2 or 2T^2 - 2T or 2T*(T-1)
-         S32 w_mip = (S32) ceil(linear_remap(w, MAX_TAPS+1, MAX_TAPS*MAX_TAPS, 2, MAX_TAPS));
+         S32 w_mip = static_cast<S32>(ceil(linear_remap(w, MAX_TAPS+1, MAX_TAPS*MAX_TAPS, 2, MAX_TAPS)));
          S32 downsample = w_mip;
          F32 sample_spacing = texel;
          if (downsample < 2) downsample = 2;
@@ -1090,7 +1090,7 @@ static void make_pool_aligned(void **start, S32 *num_bytes, U32 alignment)
    if (addr_aligned != addr_orig) {
       S32 diff = (S32) (addr_aligned - addr_orig);
       if (*num_bytes < diff) { 
-         *start = NULL;
+         *start = nullptr;
          *num_bytes = 0;
          return;
       } else {
@@ -1127,7 +1127,7 @@ static void *gdraw_arena_alloc(GDrawArena *arena, U32 size, U32 align)
    UINTa remaining = arena->end - arena->current;
    UINTa total_size = (ptr - arena->current) + size;
    if (remaining < total_size) // doesn't fit
-      return NULL;
+      return nullptr;
 
    arena->current = ptr + size;
    return ptr;
@@ -1152,7 +1152,7 @@ static void *gdraw_arena_alloc(GDrawArena *arena, U32 size, U32 align)
 //   (i.e. block->next->prev == block->prev->next == block)
 // - All allocated blocks are also kept in a hash table, indexed by their
 //   pointer (to allow free to locate the corresponding block_info quickly).
-//   There's a single-linked, NULL-terminated list of elements in each hash
+//   There's a single-linked, nullptr-terminated list of elements in each hash
 //   bucket.
 // - The physical block list is ordered. It always contains all currently
 //   active blocks and spans the whole managed memory range. There are no
@@ -1161,7 +1161,7 @@ static void *gdraw_arena_alloc(GDrawArena *arena, U32 size, U32 align)
 //   they are coalesced immediately.
 // - The maximum number of blocks that could ever be necessary is allocated
 //   on initialization. All block_infos not currently in use are kept in a
-//   single-linked, NULL-terminated list of unused blocks. Every block is either
+//   single-linked, nullptr-terminated list of unused blocks. Every block is either
 //   in the physical block list or the unused list, and the total number of
 //   blocks is constant.
 // These invariants always hold before and after an allocation/free.
@@ -1379,7 +1379,7 @@ static void gfxalloc_check2(gfx_allocator *alloc)
 
 static gfx_block_info *gfxalloc_pop_unused(gfx_allocator *alloc)
 {
-   GFXALLOC_ASSERT(alloc->unused_list != NULL);
+   GFXALLOC_ASSERT(alloc->unused_list != nullptr);
    GFXALLOC_ASSERT(alloc->unused_list->is_unused);
    GFXALLOC_IF_CHECK(GFXALLOC_ASSERT(alloc->num_unused);)
 
@@ -1452,7 +1452,7 @@ static gfx_allocator *gfxalloc_create(void *mem, U32 mem_size, U32 align, U32 ma
    U32 i, max_blocks, size;
 
    if (!align || (align & (align - 1)) != 0) // align must be >0 and a power of 2
-      return NULL;
+      return nullptr;
 
    // for <= max_allocs live allocs, there's <= 2*max_allocs+1 blocks. worst case:
    // [free][used][free] .... [free][used][free]
@@ -1460,7 +1460,7 @@ static gfx_allocator *gfxalloc_create(void *mem, U32 mem_size, U32 align, U32 ma
    size = sizeof(gfx_allocator) + max_blocks * sizeof(gfx_block_info);
    a = (gfx_allocator *) IggyGDrawMalloc(size);
    if (!a)
-      return NULL;
+      return nullptr;
 
    memset(a, 0, size);
 
@@ -1501,16 +1501,16 @@ static gfx_allocator *gfxalloc_create(void *mem, U32 mem_size, U32 align, U32 ma
    a->blocks[i].is_unused = 1;
 
    gfxalloc_check(a);
-   debug_complete_check(a, NULL, 0,0);
+   debug_complete_check(a, nullptr, 0,0);
    return a;
 }
 
 static void *gfxalloc_alloc(gfx_allocator *alloc, U32 size_in_bytes)
 {
-   gfx_block_info *cur, *best = NULL;
+   gfx_block_info *cur, *best = nullptr;
    U32 i, best_wasted = ~0u;
    U32 size = size_in_bytes;
-debug_complete_check(alloc, NULL, 0,0);
+debug_complete_check(alloc, nullptr, 0,0);
 gfxalloc_check(alloc);
    GFXALLOC_IF_CHECK(GFXALLOC_ASSERT(alloc->num_blocks == alloc->num_alloc + alloc->num_free + alloc->num_unused);)
    GFXALLOC_IF_CHECK(GFXALLOC_ASSERT(alloc->num_free <= alloc->num_blocks+1);)
@@ -1560,7 +1560,7 @@ gfxalloc_check(alloc);
 debug_check_overlap(alloc->cache, best->ptr, best->size);
       return best->ptr;
    } else
-      return NULL; // not enough space!
+      return nullptr; // not enough space!
 }
 
 static void gfxalloc_free(gfx_allocator *alloc, void *ptr)
@@ -1730,7 +1730,7 @@ static void gdraw_DefragmentMain(GDrawHandleCache *c, U32 flags, GDrawStats *sta
    // (unused for allocated blocks, we'll use it to store a back-pointer to the corresponding handle)
    for (b = alloc->blocks[0].next_phys; b != alloc->blocks; b=b->next_phys)
       if (!b->is_free)
-         b->prev = NULL;
+         b->prev = nullptr;
 
    // go through all handles and store a pointer to the handle in the corresponding memory block
    for (i=0; i < c->max_handles; i++)
@@ -1743,7 +1743,7 @@ static void gdraw_DefragmentMain(GDrawHandleCache *c, U32 flags, GDrawStats *sta
                break;
             }
 
-         GFXALLOC_ASSERT(b != NULL); // didn't find this block anywhere!
+         GFXALLOC_ASSERT(b != nullptr); // didn't find this block anywhere!
       }
 
    // clear alloc hash table (we rebuild it during defrag)
@@ -1905,7 +1905,7 @@ static rrbool gdraw_CanDefragment(GDrawHandleCache *c)
 static rrbool gdraw_MigrateResource(GDrawHandle *t, GDrawStats *stats)
 {
    GDrawHandleCache *c = t->cache;
-   void *ptr = NULL;
+   void *ptr = nullptr;
 
    assert(t->state == GDRAW_HANDLE_STATE_live || t->state == GDRAW_HANDLE_STATE_locked || t->state == GDRAW_HANDLE_STATE_pinned);
    // anything we migrate should be in the "other" (old) pool
@@ -2295,7 +2295,7 @@ static void gdraw_bufring_init(gdraw_bufring * RADRESTRICT ring, void *ptr, U32
 
 static void gdraw_bufring_shutdown(gdraw_bufring * RADRESTRICT ring)
 {
-   ring->cur = NULL;
+   ring->cur = nullptr;
    ring->seg_size = 0;
 }
 
@@ -2305,7 +2305,7 @@ static void *gdraw_bufring_alloc(gdraw_bufring * RADRESTRICT ring, U32 size, U32
    gdraw_bufring_seg *seg;
 
    if (size > ring->seg_size)
-      return NULL; // nope, won't fit
+      return nullptr; // nope, won't fit
 
    assert(align <= ring->align);
 
@@ -2410,7 +2410,7 @@ static rrbool gdraw_res_free_lru(GDrawHandleCache *c, GDrawStats *stats)
    // was it referenced since end of previous frame (=in this frame)?
    // if some, we're thrashing; report it to the user, but only once per frame.
    if (c->prev_frame_end.value < r->fence.value && !c->is_thrashing) {
-      IggyGDrawSendWarning(NULL, c->is_vertex ? "GDraw Thrashing vertex memory" : "GDraw Thrashing texture memory");
+      IggyGDrawSendWarning(nullptr, c->is_vertex ? "GDraw Thrashing vertex memory" : "GDraw Thrashing texture memory");
       c->is_thrashing = true;
    }
 
@@ -2430,8 +2430,8 @@ static GDrawHandle *gdraw_res_alloc_outofmem(GDrawHandleCache *c, GDrawHandle *t
 {
    if (t)
       gdraw_HandleCacheAllocateFail(t);
-   IggyGDrawSendWarning(NULL, c->is_vertex ? "GDraw Out of static vertex buffer %s" : "GDraw Out of texture %s", failed_type);
-   return NULL;
+   IggyGDrawSendWarning(nullptr, c->is_vertex ? "GDraw Out of static vertex buffer %s" : "GDraw Out of texture %s", failed_type);
+   return nullptr;
 }
 
 #ifndef GDRAW_MANAGE_MEM
@@ -2440,7 +2440,7 @@ static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawSt
 {
    GDrawHandle *t;
    if (size > c->total_bytes)
-      gdraw_res_alloc_outofmem(c, NULL, "memory (single resource larger than entire pool)");
+      gdraw_res_alloc_outofmem(c, nullptr, "memory (single resource larger than entire pool)");
    else {
       // given how much data we're going to allocate, throw out
       // data until there's "room" (this basically lets us use
@@ -2448,7 +2448,7 @@ static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawSt
       // packing it and being exact)
       while (c->bytes_free < size) {
          if (!gdraw_res_free_lru(c, stats)) {
-            gdraw_res_alloc_outofmem(c, NULL, "memory");
+            gdraw_res_alloc_outofmem(c, nullptr, "memory");
             break;
          }
       }
@@ -2463,8 +2463,8 @@ static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawSt
       // we'd trade off cost of regenerating)
       if (gdraw_res_free_lru(c, stats)) {
          t = gdraw_HandleCacheAllocateBegin(c);
-         if (t == NULL) {
-            gdraw_res_alloc_outofmem(c, NULL, "handles");
+         if (t == nullptr) {
+            gdraw_res_alloc_outofmem(c, nullptr, "handles");
          }
       }
    }
@@ -2508,7 +2508,7 @@ static void gdraw_res_kill(GDrawHandle *r, GDrawStats *stats)
 {
    GDRAW_FENCE_FLUSH(); // dead list is sorted by fence index - make sure all fence values are current.
 
-   r->owner = NULL;
+   r->owner = nullptr;
    gdraw_HandleCacheInsertDead(r);
    gdraw_res_reap(r->cache, stats);
 }
@@ -2516,11 +2516,11 @@ static void gdraw_res_kill(GDrawHandle *r, GDrawStats *stats)
 static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawStats *stats)
 {
    GDrawHandle *t;
-   void *ptr = NULL;
+   void *ptr = nullptr;
 
    gdraw_res_reap(c, stats); // NB this also does GDRAW_FENCE_FLUSH();
    if (size > c->total_bytes)
-      return gdraw_res_alloc_outofmem(c, NULL, "memory (single resource larger than entire pool)");
+      return gdraw_res_alloc_outofmem(c, nullptr, "memory (single resource larger than entire pool)");
    
    // now try to allocate a handle
    t = gdraw_HandleCacheAllocateBegin(c);
@@ -2532,7 +2532,7 @@ static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawSt
       gdraw_res_free_lru(c, stats);
       t = gdraw_HandleCacheAllocateBegin(c);
       if (!t)
-         return gdraw_res_alloc_outofmem(c, NULL, "handles");
+         return gdraw_res_alloc_outofmem(c, nullptr, "handles");
    }
 
    // try to allocate first
diff --git a/Minecraft.Client/Windows64/Iggy/include/gdraw.h b/Minecraft.Client/Windows64/Iggy/include/gdraw.h
index 404a2642..7cc4ddd0 100644
--- a/Minecraft.Client/Windows64/Iggy/include/gdraw.h
+++ b/Minecraft.Client/Windows64/Iggy/include/gdraw.h
@@ -356,13 +356,13 @@ IDOC typedef struct GDrawPrimitive
 IDOC typedef void RADLINK gdraw_draw_indexed_triangles(GDrawRenderState *r, GDrawPrimitive *prim, GDrawVertexBuffer *buf, GDrawStats *stats);
 /* Draws a collection of indexed triangles, ignoring special filters or blend modes.
 
-   If buf is NULL, then the pointers in 'prim' are machine pointers, and
+   If buf is nullptr, then the pointers in 'prim' are machine pointers, and
    you need to make a copy of the data (note currently all triangles
    implementing strokes (wide lines) go this path).
    
-   If buf is non-NULL, then use the appropriate vertex buffer, and the
+   If buf is non-nullptr, then use the appropriate vertex buffer, and the
    pointers in prim are actually offsets from the beginning of the
-   vertex buffer -- i.e. offset = (char*) prim->whatever - (char*) NULL;
+   vertex buffer -- i.e. offset = (char*) prim->whatever - (char*) nullptr;
    (note there are separate spaces for vertices and indices; e.g. the
    first mesh in a given vertex buffer will normally have a 0 offset
    for the vertices and a 0 offset for the indices)
@@ -455,7 +455,7 @@ IDOC typedef GDrawTexture * RADLINK gdraw_make_texture_end(GDraw_MakeTexture_Pro
 /* Ends specification of a new texture.
    
    $:info The same handle initially passed to $gdraw_make_texture_begin
-   $:return Handle for the newly created texture, or NULL if an error occured
+   $:return Handle for the newly created texture, or nullptr if an error occured
 */
 
 IDOC typedef rrbool RADLINK gdraw_update_texture_begin(GDrawTexture *tex, void *unique_id, GDrawStats *stats);
diff --git a/Minecraft.Client/Windows64/Iggy/include/iggyexpruntime.h b/Minecraft.Client/Windows64/Iggy/include/iggyexpruntime.h
index 1f1a90a1..a42ccbff 100644
--- a/Minecraft.Client/Windows64/Iggy/include/iggyexpruntime.h
+++ b/Minecraft.Client/Windows64/Iggy/include/iggyexpruntime.h
@@ -25,8 +25,8 @@ IDOC RADEXPFUNC HIGGYEXP RADEXPLINK IggyExpCreate(char *ip_address, S32 port, vo
    $:storage A small block of storage that needed to store the $HIGGYEXP, must be at least $IGGYEXP_MIN_STORAGE
    $:storage_size_in_bytes The size of the block pointer to by <tt>storage</tt>
 
-Returns a NULL HIGGYEXP if the IP address/hostname can't be resolved, or no Iggy Explorer
-can be contacted at the specified address/port. Otherwise returns a non-NULL $HIGGYEXP
+Returns a nullptr HIGGYEXP if the IP address/hostname can't be resolved, or no Iggy Explorer
+can be contacted at the specified address/port. Otherwise returns a non-nullptr $HIGGYEXP
 which you can pass to $IggyUseExplorer. */
 
 IDOC RADEXPFUNC void  RADEXPLINK IggyExpDestroy(HIGGYEXP p);
diff --git a/Minecraft.Client/Windows64/Iggy/include/rrCore.h b/Minecraft.Client/Windows64/Iggy/include/rrCore.h
index e88b5f8c..17ebee3a 100644
--- a/Minecraft.Client/Windows64/Iggy/include/rrCore.h
+++ b/Minecraft.Client/Windows64/Iggy/include/rrCore.h
@@ -114,8 +114,8 @@
   #define __RADLITTLEENDIAN__
   #ifdef __i386__
     #define __RADX86__
-  #else 
-    #define __RADARM__       
+  #else
+    #define __RADARM__
   #endif
   #define RADINLINE inline
   #define RADRESTRICT __restrict
@@ -132,7 +132,7 @@
   #define __RADX86__
 #else
   #error Unknown processor
-#endif    
+#endif
   #define __RADLITTLEENDIAN__
   #define RADINLINE inline
   #define RADRESTRICT __restrict
@@ -155,7 +155,7 @@
       #define __RADNACL__
       #define __RAD32__
       #define __RADLITTLEENDIAN__
-      #define __RADX86__           
+      #define __RADX86__
       #define RADINLINE inline
       #define RADRESTRICT __restrict
 
@@ -196,7 +196,7 @@
       #define __RAD64REGS__
       #define __RADLITTLEENDIAN__
       #define RADINLINE inline
-      #define RADRESTRICT __restrict    
+      #define RADRESTRICT __restrict
 
       #undef  RADSTRUCT
       #define RADSTRUCT struct __attribute__((__packed__))
@@ -265,7 +265,7 @@
       #endif
       #undef RADSTRUCT
       #define RADSTRUCT struct __attribute__((__packed__))
-      
+
     #elif defined(CAFE) // has to be before HOLLYWOOD_REV since it also defines it
 
       #define __RADWIIU__
@@ -480,7 +480,7 @@
 
           #undef RADRESTRICT  /* could have been defined above... */
           #define RADRESTRICT __restrict
-        
+
           #undef RADSTRUCT
           #define RADSTRUCT struct __attribute__((__packed__))
         #endif
@@ -885,7 +885,7 @@
       #define RAD_ALIGN(type,var,num) type __declspec(align(num)) var
     #else
       // NOTE: / / is a guaranteed parse error in C/C++.
-      #define RAD_ALIGN(type,var,num) RAD_ALIGN_USED_BUT_NOT_DEFINED / / 
+      #define RAD_ALIGN(type,var,num) RAD_ALIGN_USED_BUT_NOT_DEFINED / /
     #endif
 
 	// WARNING : RAD_TLS should really only be used for debug/tools stuff
@@ -917,8 +917,8 @@
         #define RAD_S32 signed int
         // But pointers are 64 bits.
         #if (_MSC_VER >= 1300 && defined(_Wp64) && _Wp64 )
-          #define RAD_SINTa __w64 signed __int64
-          #define RAD_UINTa __w64 unsigned __int64
+          #define RAD_SINTa __w64 signed long long
+          #define RAD_UINTa __w64 unsigned long long
         #else // non-vc.net compiler or /Wp64 turned off
           #define RAD_UINTa unsigned long long
           #define RAD_SINTa signed long long
@@ -976,8 +976,8 @@
       #define RAD_U64 unsigned long long
       #define RAD_S64 signed long long
     #elif defined(__RADX64__) || defined(__RAD32__)
-      #define RAD_U64 unsigned __int64
-      #define RAD_S64 signed __int64
+      #define RAD_U64 unsigned long long
+      #define RAD_S64 signed long long
     #else
       // 16-bit
       typedef RADSTRUCT RAD_U64  // do this so that we don't accidentally use U64s
@@ -1134,7 +1134,7 @@
 
     // helpers for doing an if ( ) with expect :
     // if ( RAD_LIKELY(expr) ) { ... }
-    
+
     #define RAD_LIKELY(expr)            RAD_EXPECT(expr,1)
     #define RAD_UNLIKELY(expr)          RAD_EXPECT(expr,0)
 
@@ -1324,7 +1324,7 @@
        __pragma(warning(push)) \
       __pragma(warning(disable:4127)) \
     } while(0) \
-    __pragma(warning(pop)) 
+    __pragma(warning(pop))
 
     #define RAD_STATEMENT_END_TRUE \
        __pragma(warning(push)) \
@@ -1333,10 +1333,10 @@
     __pragma(warning(pop))
 
   #else
-    #define RAD_USE_STANDARD_LOOP_CONSTRUCT  
+    #define RAD_USE_STANDARD_LOOP_CONSTRUCT
   #endif
 #else
-    #define RAD_USE_STANDARD_LOOP_CONSTRUCT  
+    #define RAD_USE_STANDARD_LOOP_CONSTRUCT
 #endif
 
 #ifdef RAD_USE_STANDARD_LOOP_CONSTRUCT
@@ -1345,7 +1345,7 @@
 
   #define RAD_STATEMENT_END_FALSE \
     } while ( (void)0,0 )
-    
+
   #define RAD_STATEMENT_END_TRUE \
     } while ( (void)1,1 )
 
@@ -1355,7 +1355,7 @@
   RAD_STATEMENT_START \
     code \
   RAD_STATEMENT_END_FALSE
-  
+
 #define RAD_INFINITE_LOOP( code ) \
   RAD_STATEMENT_START \
     code \
@@ -1363,7 +1363,7 @@
 
 
 // Must be placed after variable declarations for code compiled as .c
-#if defined(_MSC_VER) && _MSC_VER >= 1700 // in 2012 aka 11.0 and later 
+#if defined(_MSC_VER) && _MSC_VER >= 1700 // in 2012 aka 11.0 and later
 #   define RR_UNUSED_VARIABLE(x) (void) x
 #else
 #   define RR_UNUSED_VARIABLE(x) (void)(sizeof(x))
@@ -1473,7 +1473,7 @@
   // just to make gcc shut up about derefing null :
   #define RR_MEMBER_OFFSET_PTR(type,member,ptr)  ( (SINTa) &(((type *)(ptr))->member)  - (SINTa)(ptr) )
   #define RR_MEMBER_SIZE_PTR(type,member,ptr)	( sizeof( ((type *) (ptr))->member) )
-   
+
   // MEMBER_TO_OWNER takes a pointer to a member and gives you back the base of the object
   //  you should then RR_ASSERT( &(ret->member) == ptr );
   #define RR_MEMBER_TO_OWNER(type,member,ptr)    (type *)( ((char *)(ptr)) - RR_MEMBER_OFFSET_PTR(type,member,ptr) )
@@ -1482,7 +1482,7 @@
 // Cache / prefetch macros :
 
 // RR_PREFETCH for various platforms :
-// 
+//
 // RR_PREFETCH_SEQUENTIAL : prefetch memory for reading in a sequential scan
 //		platforms that automatically prefetch sequential (eg. PC) should be a no-op here
 // RR_PREFETCH_WRITE_INVALIDATE : prefetch memory for writing - contents of memory are undefined
@@ -1707,7 +1707,7 @@ extern fp_rrDisplayAssertion * g_fp_rrDisplayAssertion;
 #define rrDisplayAssertion(i,n,l,f,m)	( ( g_fp_rrDisplayAssertion ) ? (*g_fp_rrDisplayAssertion)(i,n,l,f,m) : 1 )
 
 //-----------------------------------------------------------
-      
+
 // RAD_NO_BREAK : option if you don't like your assert to break
 //  CB : RR_BREAK is *always* a break ; RR_ASSERT_BREAK is optional
 #ifdef RAD_NO_BREAK
@@ -1725,7 +1725,7 @@ extern fp_rrDisplayAssertion * g_fp_rrDisplayAssertion;
 #define RR_ASSERT_LITE_ALWAYS(exp)     RAD_STATEMENT_WRAPPER( if ( ! (exp) ) { RR_ASSERT_BREAK(); } )
 
 //-----------------------------------
-#ifdef RR_DO_ASSERTS 
+#ifdef RR_DO_ASSERTS
 
 #define RR_ASSERT(exp)           RR_ASSERT_ALWAYS(exp)
 #define RR_ASSERT_LITE(exp)      RR_ASSERT_LITE_ALWAYS(exp)
@@ -1883,7 +1883,7 @@ unsigned long  __cdecl _byteswap_ulong  (unsigned long  _Long);
 #define RR_BSWAP16   _byteswap_ushort
 #define RR_BSWAP32  _byteswap_ulong
 
-unsigned __int64 __cdecl _byteswap_uint64 (unsigned __int64 val);
+unsigned long long __cdecl _byteswap_uint64 (unsigned long long val);
 #pragma intrinsic(_byteswap_uint64)
 #define RR_BSWAP64  _byteswap_uint64
 
@@ -1909,7 +1909,7 @@ RADFORCEINLINE unsigned long RR_BSWAP32 (unsigned long _Long)
    return _Long;
 }
 
-RADFORCEINLINE unsigned __int64 RR_BSWAP64 (unsigned __int64 _Long)
+RADFORCEINLINE unsigned long long RR_BSWAP64 (unsigned long long _Long)
 {
    __asm {
       mov eax, DWORD PTR _Long
@@ -2250,10 +2250,10 @@ void           __storewordbytereverse (unsigned int   val, int offset, void *bas
 
 #if ( defined(_MSC_VER) && _MSC_VER >= 1300)
 
-unsigned __int64 __cdecl _rotl64(unsigned __int64 _Val, int _Shift);
+unsigned long long __cdecl _rotl64(unsigned long long _Val, int _Shift);
 #pragma intrinsic(_rotl64)
 
-#define RR_ROTL64(x,k)  _rotl64((unsigned __int64)(x),(int)(k))
+#define RR_ROTL64(x,k)  _rotl64((unsigned long long)(x),(int)(k))
 
 #elif defined(__RADCELL__)
 
@@ -2262,7 +2262,7 @@ unsigned __int64 __cdecl _rotl64(unsigned __int64 _Val, int _Shift);
 
 #elif defined(__RADLINUX__) || defined(__RADMACAPI__)
 
-//APTODO: Just to compile linux. Should we be doing better than this? If not, combine with above. 
+//APTODO: Just to compile linux. Should we be doing better than this? If not, combine with above.
 #define RR_ROTL64(u64,num)  ( ( (u64) << (num) ) | ( (u64) >> (64 - (num))) )
 
 #else
diff --git a/Minecraft.Client/Windows64/KeyboardMouseInput.cpp b/Minecraft.Client/Windows64/KeyboardMouseInput.cpp
index fe3c3919..54191ebc 100644
--- a/Minecraft.Client/Windows64/KeyboardMouseInput.cpp
+++ b/Minecraft.Client/Windows64/KeyboardMouseInput.cpp
@@ -125,7 +125,7 @@ void KeyboardMouseInput::Tick()
 		}
 	}
 
-	if ((m_mouseGrabbed || m_cursorHiddenForUI) && g_hWnd)
+	if ((m_mouseGrabbed || m_cursorHiddenForUI) && m_windowFocused && g_hWnd)
 	{
 		RECT rc;
 		GetClientRect(g_hWnd, &rc);
@@ -257,8 +257,8 @@ bool KeyboardMouseInput::IsMouseButtonReleased(int button) const
 
 void KeyboardMouseInput::ConsumeMouseDelta(float &dx, float &dy)
 {
-	dx = (float)m_mouseDeltaAccumX;
-	dy = (float)m_mouseDeltaAccumY;
+	dx = static_cast<float>(m_mouseDeltaAccumX);
+	dy = static_cast<float>(m_mouseDeltaAccumY);
 	m_mouseDeltaAccumX = 0;
 	m_mouseDeltaAccumY = 0;
 }
@@ -288,7 +288,7 @@ void KeyboardMouseInput::SetMouseGrabbed(bool grabbed)
 	else if (!grabbed && !m_cursorHiddenForUI && g_hWnd)
 	{
 		while (ShowCursor(TRUE) < 0) {}
-		ClipCursor(NULL);
+		ClipCursor(nullptr);
 	}
 }
 
@@ -317,7 +317,7 @@ void KeyboardMouseInput::SetCursorHiddenForUI(bool hidden)
 	else if (!hidden && !m_mouseGrabbed && g_hWnd)
 	{
 		while (ShowCursor(TRUE) < 0) {}
-		ClipCursor(NULL);
+		ClipCursor(nullptr);
 	}
 }
 
@@ -347,13 +347,13 @@ void KeyboardMouseInput::SetWindowFocused(bool focused)
 		else
 		{
 			while (ShowCursor(TRUE) < 0) {}
-			ClipCursor(NULL);
+			ClipCursor(nullptr);
 		}
 	}
 	else
 	{
 		while (ShowCursor(TRUE) < 0) {}
-		ClipCursor(NULL);
+		ClipCursor(nullptr);
 	}
 }
 
@@ -375,12 +375,12 @@ float KeyboardMouseInput::GetMoveY() const
 
 float KeyboardMouseInput::GetLookX(float sensitivity) const
 {
-	return (float)m_mouseDeltaX * sensitivity;
+	return static_cast<float>(m_mouseDeltaX) * sensitivity;
 }
 
 float KeyboardMouseInput::GetLookY(float sensitivity) const
 {
-	return (float)(-m_mouseDeltaY) * sensitivity;
+	return static_cast<float>(-m_mouseDeltaY) * sensitivity;
 }
 
 void KeyboardMouseInput::OnChar(wchar_t c)
diff --git a/Minecraft.Client/Windows64/KeyboardMouseInput.h b/Minecraft.Client/Windows64/KeyboardMouseInput.h
index fff924bf..2079a72a 100644
--- a/Minecraft.Client/Windows64/KeyboardMouseInput.h
+++ b/Minecraft.Client/Windows64/KeyboardMouseInput.h
@@ -25,12 +25,20 @@ public:
 	static const int KEY_DROP = 'Q';
 	static const int KEY_CRAFTING = 'C';
 	static const int KEY_CRAFTING_ALT = 'R';
+	static const int KEY_CHAT = 'T';
 	static const int KEY_CONFIRM = VK_RETURN;
 	static const int KEY_CANCEL = VK_ESCAPE;
 	static const int KEY_PAUSE = VK_ESCAPE;
-	static const int KEY_THIRD_PERSON = VK_F5;
+	static const int KEY_TOGGLE_HUD = VK_F1;
 	static const int KEY_DEBUG_INFO = VK_F3;
 	static const int KEY_DEBUG_MENU = VK_F4;
+	static const int KEY_THIRD_PERSON = VK_F5;
+	static const int KEY_DEBUG_CONSOLE = VK_F6;
+	static const int KEY_HOST_SETTINGS = VK_F8;
+	static const int KEY_FULLSCREEN = VK_F11;
+
+	// todo: implement and shi
+	static const int KEY_SCREENSHOT = VK_F2;
 
 	void Init();
 	void Tick();
@@ -143,4 +151,4 @@ private:
 
 extern KeyboardMouseInput g_KBMInput;
 
-#endif // _WINDOWS64
+#endif
diff --git a/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp b/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp
index ca1d62af..981ab3ab 100644
--- a/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp
+++ b/Minecraft.Client/Windows64/Network/WinsockNetLayer.cpp
@@ -8,11 +8,25 @@
 #include "WinsockNetLayer.h"
 #include "..\..\Common\Network\PlatformNetworkManagerStub.h"
 #include "..\..\..\Minecraft.World\Socket.h"
+#if defined(MINECRAFT_SERVER_BUILD)
+#include "..\..\..\Minecraft.Server\Access\Access.h"
+#include "..\..\..\Minecraft.Server\ServerLogManager.h"
+#endif
+#include "..\..\..\Minecraft.World\DisconnectPacket.h"
+#include "..\..\Minecraft.h"
+#include "..\4JLibs\inc\4J_Profile.h"
+
+#include <string>
+
+static bool RecvExact(SOCKET sock, BYTE* buf, int len);
+#if defined(MINECRAFT_SERVER_BUILD)
+static bool TryGetNumericRemoteIp(const sockaddr_in &remoteAddress, std::string *outIp);
+#endif
 
 SOCKET WinsockNetLayer::s_listenSocket = INVALID_SOCKET;
 SOCKET WinsockNetLayer::s_hostConnectionSocket = INVALID_SOCKET;
-HANDLE WinsockNetLayer::s_acceptThread = NULL;
-HANDLE WinsockNetLayer::s_clientRecvThread = NULL;
+HANDLE WinsockNetLayer::s_acceptThread = nullptr;
+HANDLE WinsockNetLayer::s_clientRecvThread = nullptr;
 
 bool WinsockNetLayer::s_isHost = false;
 bool WinsockNetLayer::s_connected = false;
@@ -21,7 +35,7 @@ bool WinsockNetLayer::s_initialized = false;
 
 BYTE WinsockNetLayer::s_localSmallId = 0;
 BYTE WinsockNetLayer::s_hostSmallId = 0;
-BYTE WinsockNetLayer::s_nextSmallId = 1;
+unsigned int WinsockNetLayer::s_nextSmallId = XUSER_MAX_COUNT;
 
 CRITICAL_SECTION WinsockNetLayer::s_sendLock;
 CRITICAL_SECTION WinsockNetLayer::s_connectionsLock;
@@ -29,14 +43,14 @@ CRITICAL_SECTION WinsockNetLayer::s_connectionsLock;
 std::vector<Win64RemoteConnection> WinsockNetLayer::s_connections;
 
 SOCKET WinsockNetLayer::s_advertiseSock = INVALID_SOCKET;
-HANDLE WinsockNetLayer::s_advertiseThread = NULL;
+HANDLE WinsockNetLayer::s_advertiseThread = nullptr;
 volatile bool WinsockNetLayer::s_advertising = false;
 Win64LANBroadcast WinsockNetLayer::s_advertiseData = {};
 CRITICAL_SECTION WinsockNetLayer::s_advertiseLock;
 int WinsockNetLayer::s_hostGamePort = WIN64_NET_DEFAULT_PORT;
 
 SOCKET WinsockNetLayer::s_discoverySock = INVALID_SOCKET;
-HANDLE WinsockNetLayer::s_discoveryThread = NULL;
+HANDLE WinsockNetLayer::s_discoveryThread = nullptr;
 volatile bool WinsockNetLayer::s_discovering = false;
 CRITICAL_SECTION WinsockNetLayer::s_discoveryLock;
 std::vector<Win64LANSession> WinsockNetLayer::s_discoveredSessions;
@@ -46,6 +60,12 @@ std::vector<BYTE> WinsockNetLayer::s_disconnectedSmallIds;
 
 CRITICAL_SECTION WinsockNetLayer::s_freeSmallIdLock;
 std::vector<BYTE> WinsockNetLayer::s_freeSmallIds;
+SOCKET WinsockNetLayer::s_smallIdToSocket[256];
+CRITICAL_SECTION WinsockNetLayer::s_smallIdToSocketLock;
+
+SOCKET WinsockNetLayer::s_splitScreenSocket[XUSER_MAX_COUNT] = { INVALID_SOCKET, INVALID_SOCKET, INVALID_SOCKET, INVALID_SOCKET };
+BYTE WinsockNetLayer::s_splitScreenSmallId[XUSER_MAX_COUNT] = { 0xFF, 0xFF, 0xFF, 0xFF };
+HANDLE WinsockNetLayer::s_splitScreenRecvThread[XUSER_MAX_COUNT] = {nullptr, nullptr, nullptr, nullptr};
 
 bool g_Win64MultiplayerHost = false;
 bool g_Win64MultiplayerJoin = false;
@@ -54,6 +74,7 @@ char g_Win64MultiplayerIP[256] = "127.0.0.1";
 bool g_Win64DedicatedServer = false;
 int g_Win64DedicatedServerPort = WIN64_NET_DEFAULT_PORT;
 char g_Win64DedicatedServerBindIP[256] = "";
+bool g_Win64DedicatedServerLanAdvertise = true;
 
 bool WinsockNetLayer::Initialize()
 {
@@ -73,10 +94,17 @@ bool WinsockNetLayer::Initialize()
 	InitializeCriticalSection(&s_discoveryLock);
 	InitializeCriticalSection(&s_disconnectLock);
 	InitializeCriticalSection(&s_freeSmallIdLock);
+	InitializeCriticalSection(&s_smallIdToSocketLock);
+	for (int i = 0; i < 256; i++)
+		s_smallIdToSocket[i] = INVALID_SOCKET;
 
 	s_initialized = true;
 
-	StartDiscovery();
+	// Dedicated Server does not use LAN session discovery and therefore does not initiate discovery.
+	if (!g_Win64DedicatedServer)
+	{
+		StartDiscovery();
+	}
 
 	return true;
 }
@@ -101,6 +129,15 @@ void WinsockNetLayer::Shutdown()
 		s_hostConnectionSocket = INVALID_SOCKET;
 	}
 
+	// Stop accept loop first so no new RecvThread can be created while shutting down.
+	if (s_acceptThread != nullptr)
+	{
+		WaitForSingleObject(s_acceptThread, 2000);
+		CloseHandle(s_acceptThread);
+		s_acceptThread = nullptr;
+	}
+
+	std::vector<HANDLE> recvThreads;
 	EnterCriticalSection(&s_connectionsLock);
 	for (size_t i = 0; i < s_connections.size(); i++)
 	{
@@ -108,35 +145,67 @@ void WinsockNetLayer::Shutdown()
 		if (s_connections[i].tcpSocket != INVALID_SOCKET)
 		{
 			closesocket(s_connections[i].tcpSocket);
+			s_connections[i].tcpSocket = INVALID_SOCKET;
+		}
+		if (s_connections[i].recvThread != nullptr)
+		{
+			recvThreads.push_back(s_connections[i].recvThread);
+			s_connections[i].recvThread = nullptr;
 		}
 	}
-	s_connections.clear();
 	LeaveCriticalSection(&s_connectionsLock);
 
-	if (s_acceptThread != NULL)
+	// Wait for all host-side receive threads to exit before destroying state.
+	for (size_t i = 0; i < recvThreads.size(); i++)
 	{
-		WaitForSingleObject(s_acceptThread, 2000);
-		CloseHandle(s_acceptThread);
-		s_acceptThread = NULL;
+		WaitForSingleObject(recvThreads[i], 2000);
+		CloseHandle(recvThreads[i]);
 	}
 
-	if (s_clientRecvThread != NULL)
+	EnterCriticalSection(&s_connectionsLock);
+	s_connections.clear();
+	LeaveCriticalSection(&s_connectionsLock);
+
+	if (s_clientRecvThread != nullptr)
 	{
 		WaitForSingleObject(s_clientRecvThread, 2000);
 		CloseHandle(s_clientRecvThread);
-		s_clientRecvThread = NULL;
+		s_clientRecvThread = nullptr;
+	}
+
+	for (int i = 0; i < XUSER_MAX_COUNT; i++)
+	{
+		if (s_splitScreenSocket[i] != INVALID_SOCKET)
+		{
+			closesocket(s_splitScreenSocket[i]);
+			s_splitScreenSocket[i] = INVALID_SOCKET;
+		}
+		if (s_splitScreenRecvThread[i] != nullptr)
+		{
+			WaitForSingleObject(s_splitScreenRecvThread[i], 2000);
+			CloseHandle(s_splitScreenRecvThread[i]);
+			s_splitScreenRecvThread[i] = nullptr;
+		}
+		s_splitScreenSmallId[i] = 0xFF;
 	}
 
 	if (s_initialized)
 	{
+		EnterCriticalSection(&s_disconnectLock);
+		s_disconnectedSmallIds.clear();
+		LeaveCriticalSection(&s_disconnectLock);
+
+		EnterCriticalSection(&s_freeSmallIdLock);
+		s_freeSmallIds.clear();
+		LeaveCriticalSection(&s_freeSmallIdLock);
+
 		DeleteCriticalSection(&s_sendLock);
 		DeleteCriticalSection(&s_connectionsLock);
 		DeleteCriticalSection(&s_advertiseLock);
 		DeleteCriticalSection(&s_discoveryLock);
 		DeleteCriticalSection(&s_disconnectLock);
-		s_disconnectedSmallIds.clear();
 		DeleteCriticalSection(&s_freeSmallIdLock);
-		s_freeSmallIds.clear();
+		DeleteCriticalSection(&s_smallIdToSocketLock);
 		WSACleanup();
 		s_initialized = false;
 	}
@@ -149,30 +218,34 @@ bool WinsockNetLayer::HostGame(int port, const char* bindIp)
 	s_isHost = true;
 	s_localSmallId = 0;
 	s_hostSmallId = 0;
-	s_nextSmallId = 1;
+	s_nextSmallId = XUSER_MAX_COUNT;
 	s_hostGamePort = port;
 
 	EnterCriticalSection(&s_freeSmallIdLock);
 	s_freeSmallIds.clear();
 	LeaveCriticalSection(&s_freeSmallIdLock);
+	EnterCriticalSection(&s_smallIdToSocketLock);
+	for (int i = 0; i < 256; i++)
+		s_smallIdToSocket[i] = INVALID_SOCKET;
+	LeaveCriticalSection(&s_smallIdToSocketLock);
 
 	struct addrinfo hints = {};
-	struct addrinfo* result = NULL;
+	struct addrinfo* result = nullptr;
 
 	hints.ai_family = AF_INET;
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_protocol = IPPROTO_TCP;
-	hints.ai_flags = (bindIp == NULL || bindIp[0] == 0) ? AI_PASSIVE : 0;
+	hints.ai_flags = (bindIp == nullptr || bindIp[0] == 0) ? AI_PASSIVE : 0;
 
 	char portStr[16];
 	sprintf_s(portStr, "%d", port);
 
-	const char* resolvedBindIp = (bindIp != NULL && bindIp[0] != 0) ? bindIp : NULL;
+	const char* resolvedBindIp = (bindIp != nullptr && bindIp[0] != 0) ? bindIp : nullptr;
 	int iResult = getaddrinfo(resolvedBindIp, portStr, &hints, &result);
 	if (iResult != 0)
 	{
 		app.DebugPrintf("getaddrinfo failed for %s:%d - %d\n",
-			resolvedBindIp != NULL ? resolvedBindIp : "*",
+			resolvedBindIp != nullptr ? resolvedBindIp : "*",
 			port,
 			iResult);
 		return false;
@@ -189,7 +262,7 @@ bool WinsockNetLayer::HostGame(int port, const char* bindIp)
 	int opt = 1;
 	setsockopt(s_listenSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt));
 
-	iResult = ::bind(s_listenSocket, result->ai_addr, (int)result->ai_addrlen);
+	iResult = ::bind(s_listenSocket, result->ai_addr, static_cast<int>(result->ai_addrlen));
 	freeaddrinfo(result);
 	if (iResult == SOCKET_ERROR)
 	{
@@ -211,10 +284,10 @@ bool WinsockNetLayer::HostGame(int port, const char* bindIp)
 	s_active = true;
 	s_connected = true;
 
-	s_acceptThread = CreateThread(NULL, 0, AcceptThreadProc, NULL, 0, NULL);
+	s_acceptThread = CreateThread(nullptr, 0, AcceptThreadProc, nullptr, 0, nullptr);
 
 	app.DebugPrintf("Win64 LAN: Hosting on %s:%d\n",
-		resolvedBindIp != NULL ? resolvedBindIp : "*",
+		resolvedBindIp != nullptr ? resolvedBindIp : "*",
 		port);
 	return true;
 }
@@ -234,8 +307,19 @@ bool WinsockNetLayer::JoinGame(const char* ip, int port)
 		s_hostConnectionSocket = INVALID_SOCKET;
 	}
 
+	// Wait for old client recv thread to fully exit before starting a new connection.
+	// Without this, the old thread can read from the new socket (s_hostConnectionSocket
+	// is a global) and steal bytes from the new connection's TCP stream, causing
+	// packet stream misalignment on reconnect.
+	if (s_clientRecvThread != nullptr)
+	{
+		WaitForSingleObject(s_clientRecvThread, 5000);
+		CloseHandle(s_clientRecvThread);
+		s_clientRecvThread = nullptr;
+	}
+
 	struct addrinfo hints = {};
-	struct addrinfo* result = NULL;
+	struct addrinfo* result = nullptr;
 
 	hints.ai_family = AF_INET;
 	hints.ai_socktype = SOCK_STREAM;
@@ -267,7 +351,7 @@ bool WinsockNetLayer::JoinGame(const char* ip, int port)
 		int noDelay = 1;
 		setsockopt(s_hostConnectionSocket, IPPROTO_TCP, TCP_NODELAY, (const char*)&noDelay, sizeof(noDelay));
 
-		iResult = connect(s_hostConnectionSocket, result->ai_addr, (int)result->ai_addrlen);
+		iResult = connect(s_hostConnectionSocket, result->ai_addr, static_cast<int>(result->ai_addrlen));
 		if (iResult == SOCKET_ERROR)
 		{
 			int err = WSAGetLastError();
@@ -289,6 +373,27 @@ bool WinsockNetLayer::JoinGame(const char* ip, int port)
 			continue;
 		}
 
+		if (assignBuf[0] == WIN64_SMALLID_REJECT)
+		{
+			BYTE rejectBuf[5];
+			if (!RecvExact(s_hostConnectionSocket, rejectBuf, 5))
+			{
+				app.DebugPrintf("Failed to receive reject reason from host\n");
+				closesocket(s_hostConnectionSocket);
+				s_hostConnectionSocket = INVALID_SOCKET;
+				Sleep(200);
+				continue;
+			}
+			// rejectBuf[0] = packet id (255), rejectBuf[1..4] = 4-byte big-endian reason
+			int reason = ((rejectBuf[1] & 0xff) << 24) | ((rejectBuf[2] & 0xff) << 16) |
+				((rejectBuf[3] & 0xff) << 8) | (rejectBuf[4] & 0xff);
+			Minecraft::GetInstance()->connectionDisconnected(ProfileManager.GetPrimaryPad(), (DisconnectPacket::eDisconnectReason)reason);
+			closesocket(s_hostConnectionSocket);
+			s_hostConnectionSocket = INVALID_SOCKET;
+			freeaddrinfo(result);
+			return false;
+		}
+
 		assignedSmallId = assignBuf[0];
 		connected = true;
 		break;
@@ -301,27 +406,39 @@ bool WinsockNetLayer::JoinGame(const char* ip, int port)
 	}
 	s_localSmallId = assignedSmallId;
 
+	// Save the host IP and port so JoinSplitScreen can connect to the same host
+	// regardless of how the connection was initiated (UI vs command line).
+	strncpy_s(g_Win64MultiplayerIP, sizeof(g_Win64MultiplayerIP), ip, _TRUNCATE);
+	g_Win64MultiplayerPort = port;
+
 	app.DebugPrintf("Win64 LAN: Connected to %s:%d, assigned smallId=%d\n", ip, port, s_localSmallId);
 
 	s_active = true;
 	s_connected = true;
 
-	s_clientRecvThread = CreateThread(NULL, 0, ClientRecvThreadProc, NULL, 0, NULL);
+	s_clientRecvThread = CreateThread(nullptr, 0, ClientRecvThreadProc, nullptr, 0, nullptr);
 
 	return true;
 }
 
 bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void* data, int dataSize)
 {
-	if (sock == INVALID_SOCKET || dataSize <= 0) return false;
-
+	if (sock == INVALID_SOCKET || dataSize <= 0 || dataSize > WIN64_NET_MAX_PACKET_SIZE) return false;
+
+	// TODO: s_sendLock is a single global lock for ALL sockets. If one client's
+	// send() blocks (TCP window full, slow WiFi), every other write thread stalls
+	// waiting for this lock — no data flows to any player until the slow send
+	// completes. This scales badly with player count (8+ players = noticeable).
+	// Fix: replace with per-socket locks indexed by smallId (s_perSocketSendLock[256]).
+	// The lock only needs to prevent interleaving of header+payload on the SAME socket;
+	// sends to different sockets are independent and should never block each other.
 	EnterCriticalSection(&s_sendLock);
 
 	BYTE header[4];
-	header[0] = (BYTE)((dataSize >> 24) & 0xFF);
-	header[1] = (BYTE)((dataSize >> 16) & 0xFF);
-	header[2] = (BYTE)((dataSize >> 8) & 0xFF);
-	header[3] = (BYTE)(dataSize & 0xFF);
+	header[0] = static_cast<BYTE>((dataSize >> 24) & 0xFF);
+	header[1] = static_cast<BYTE>((dataSize >> 16) & 0xFF);
+	header[2] = static_cast<BYTE>((dataSize >> 8) & 0xFF);
+	header[3] = static_cast<BYTE>(dataSize & 0xFF);
 
 	int totalSent = 0;
 	int toSend = 4;
@@ -339,7 +456,7 @@ bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void* data, int dataSize)
 	totalSent = 0;
 	while (totalSent < dataSize)
 	{
-		int sent = send(sock, (const char*)data + totalSent, dataSize - totalSent, 0);
+		int sent = send(sock, static_cast<const char *>(data) + totalSent, dataSize - totalSent, 0);
 		if (sent == SOCKET_ERROR || sent == 0)
 		{
 			LeaveCriticalSection(&s_sendLock);
@@ -370,18 +487,31 @@ bool WinsockNetLayer::SendToSmallId(BYTE targetSmallId, const void* data, int da
 
 SOCKET WinsockNetLayer::GetSocketForSmallId(BYTE smallId)
 {
-	EnterCriticalSection(&s_connectionsLock);
-	for (size_t i = 0; i < s_connections.size(); i++)
-	{
-		if (s_connections[i].smallId == smallId && s_connections[i].active)
-		{
-			SOCKET sock = s_connections[i].tcpSocket;
-			LeaveCriticalSection(&s_connectionsLock);
-			return sock;
-		}
-	}
-	LeaveCriticalSection(&s_connectionsLock);
-	return INVALID_SOCKET;
+	EnterCriticalSection(&s_smallIdToSocketLock);
+	SOCKET sock = s_smallIdToSocket[smallId];
+	LeaveCriticalSection(&s_smallIdToSocketLock);
+	return sock;
+}
+
+void WinsockNetLayer::ClearSocketForSmallId(BYTE smallId)
+{
+	EnterCriticalSection(&s_smallIdToSocketLock);
+	s_smallIdToSocket[smallId] = INVALID_SOCKET;
+	LeaveCriticalSection(&s_smallIdToSocketLock);
+}
+
+// Send reject handshake: sentinel 0xFF + DisconnectPacket wire format (1 byte id 255 + 4 byte big-endian reason). Then caller closes socket.
+static void SendRejectWithReason(SOCKET clientSocket, DisconnectPacket::eDisconnectReason reason)
+{
+	BYTE buf[6];
+	buf[0] = WIN64_SMALLID_REJECT;
+	buf[1] = (BYTE)255; // DisconnectPacket packet id
+	int r = (int)reason;
+	buf[2] = (BYTE)((r >> 24) & 0xff);
+	buf[3] = (BYTE)((r >> 16) & 0xff);
+	buf[4] = (BYTE)((r >> 8) & 0xff);
+	buf[5] = (BYTE)(r & 0xff);
+	send(clientSocket, (const char*)buf, sizeof(buf), 0);
 }
 
 static bool RecvExact(SOCKET sock, BYTE* buf, int len)
@@ -396,24 +526,54 @@ static bool RecvExact(SOCKET sock, BYTE* buf, int len)
 	return true;
 }
 
+#if defined(MINECRAFT_SERVER_BUILD)
+static bool TryGetNumericRemoteIp(const sockaddr_in &remoteAddress, std::string *outIp)
+{
+	if (outIp == nullptr)
+	{
+		return false;
+	}
+
+	outIp->clear();
+	char ipBuffer[64] = {};
+	const char *ip = inet_ntop(AF_INET, (void *)&remoteAddress.sin_addr, ipBuffer, sizeof(ipBuffer));
+	if (ip == nullptr || ip[0] == 0)
+	{
+		return false;
+	}
+
+	*outIp = ip;
+	return true;
+}
+#endif
+
 void WinsockNetLayer::HandleDataReceived(BYTE fromSmallId, BYTE toSmallId, unsigned char* data, unsigned int dataSize)
 {
 	INetworkPlayer* pPlayerFrom = g_NetworkManager.GetPlayerBySmallId(fromSmallId);
 	INetworkPlayer* pPlayerTo = g_NetworkManager.GetPlayerBySmallId(toSmallId);
 
-	if (pPlayerFrom == NULL || pPlayerTo == NULL) return;
+	if (pPlayerFrom == nullptr || pPlayerTo == nullptr)
+	{
+		app.DebugPrintf("NET RECV: DROPPED %u bytes from=%d to=%d (player NULL: from=%p to=%p)\n",
+			dataSize, fromSmallId, toSmallId, pPlayerFrom, pPlayerTo);
+		return;
+	}
 
 	if (s_isHost)
 	{
 		::Socket* pSocket = pPlayerFrom->GetSocket();
-		if (pSocket != NULL)
+		if (pSocket != nullptr)
 			pSocket->pushDataToQueue(data, dataSize, false);
+		else
+			app.DebugPrintf("NET RECV: DROPPED %u bytes, host pSocket NULL for from=%d\n", dataSize, fromSmallId);
 	}
 	else
 	{
 		::Socket* pSocket = pPlayerTo->GetSocket();
-		if (pSocket != NULL)
+		if (pSocket != nullptr)
 			pSocket->pushDataToQueue(data, dataSize, true);
+		else
+			app.DebugPrintf("NET RECV: DROPPED %u bytes, client pSocket NULL for to=%d\n", dataSize, toSmallId);
 	}
 }
 
@@ -421,7 +581,10 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 {
 	while (s_active)
 	{
-		SOCKET clientSocket = accept(s_listenSocket, NULL, NULL);
+		sockaddr_in remoteAddress;
+		ZeroMemory(&remoteAddress, sizeof(remoteAddress));
+		int remoteAddressLength = sizeof(remoteAddress);
+		SOCKET clientSocket = accept(s_listenSocket, (sockaddr*)&remoteAddress, &remoteAddressLength);
 		if (clientSocket == INVALID_SOCKET)
 		{
 			if (s_active)
@@ -432,10 +595,54 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 		int noDelay = 1;
 		setsockopt(clientSocket, IPPROTO_TCP, TCP_NODELAY, (const char*)&noDelay, sizeof(noDelay));
 
+#if defined(MINECRAFT_SERVER_BUILD)
+		std::string remoteIp;
+		const bool hasRemoteIp = TryGetNumericRemoteIp(remoteAddress, &remoteIp);
+		const char *remoteIpForLog = hasRemoteIp ? remoteIp.c_str() : "unknown";
+		if (g_Win64DedicatedServer)
+		{
+			ServerRuntime::ServerLogManager::OnIncomingTcpConnection(remoteIpForLog);
+			if (hasRemoteIp && ServerRuntime::Access::IsIpBanned(remoteIp))
+			{
+				ServerRuntime::ServerLogManager::OnRejectedTcpConnection(remoteIpForLog, ServerRuntime::ServerLogManager::eTcpRejectReason_BannedIp);
+				SendRejectWithReason(clientSocket, DisconnectPacket::eDisconnect_Banned);
+				closesocket(clientSocket);
+				continue;
+			}
+		}
+#endif
+
 		extern QNET_STATE _iQNetStubState;
 		if (_iQNetStubState != QNET_STATE_GAME_PLAY)
 		{
-			app.DebugPrintf("Win64 LAN: Rejecting connection, game not ready\n");
+#if defined(MINECRAFT_SERVER_BUILD)
+			if (g_Win64DedicatedServer)
+			{
+				ServerRuntime::ServerLogManager::OnRejectedTcpConnection(remoteIpForLog, ServerRuntime::ServerLogManager::eTcpRejectReason_GameNotReady);
+			}
+			else
+#endif
+			{
+				app.DebugPrintf("Win64 LAN: Rejecting connection, game not ready\n");
+			}
+			closesocket(clientSocket);
+			continue;
+		}
+
+		extern CPlatformNetworkManagerStub* g_pPlatformNetworkManager;
+		if (g_pPlatformNetworkManager != nullptr && !g_pPlatformNetworkManager->CanAcceptMoreConnections())
+		{
+#if defined(MINECRAFT_SERVER_BUILD)
+			if (g_Win64DedicatedServer)
+			{
+				ServerRuntime::ServerLogManager::OnRejectedTcpConnection(remoteIpForLog, ServerRuntime::ServerLogManager::eTcpRejectReason_ServerFull);
+			}
+			else
+#endif
+			{
+				app.DebugPrintf("Win64 LAN: Rejecting connection, server at max players\n");
+			}
+			SendRejectWithReason(clientSocket, DisconnectPacket::eDisconnect_ServerFull);
 			closesocket(clientSocket);
 			continue;
 		}
@@ -447,14 +654,24 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 			assignedSmallId = s_freeSmallIds.back();
 			s_freeSmallIds.pop_back();
 		}
-		else if (s_nextSmallId < MINECRAFT_NET_MAX_PLAYERS)
+		else if (s_nextSmallId < (unsigned int)MINECRAFT_NET_MAX_PLAYERS)
 		{
-			assignedSmallId = s_nextSmallId++;
+			assignedSmallId = (BYTE)s_nextSmallId++;
 		}
 		else
 		{
 			LeaveCriticalSection(&s_freeSmallIdLock);
-			app.DebugPrintf("Win64 LAN: Server full, rejecting connection\n");
+#if defined(MINECRAFT_SERVER_BUILD)
+			if (g_Win64DedicatedServer)
+			{
+				ServerRuntime::ServerLogManager::OnRejectedTcpConnection(remoteIpForLog, ServerRuntime::ServerLogManager::eTcpRejectReason_ServerFull);
+			}
+			else
+#endif
+			{
+				app.DebugPrintf("Win64 LAN: Server full, rejecting connection\n");
+			}
+			SendRejectWithReason(clientSocket, DisconnectPacket::eDisconnect_ServerFull);
 			closesocket(clientSocket);
 			continue;
 		}
@@ -466,6 +683,7 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 		{
 			app.DebugPrintf("Failed to send small ID to client\n");
 			closesocket(clientSocket);
+			PushFreeSmallId(assignedSmallId);
 			continue;
 		}
 
@@ -473,14 +691,27 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 		conn.tcpSocket = clientSocket;
 		conn.smallId = assignedSmallId;
 		conn.active = true;
-		conn.recvThread = NULL;
+		conn.recvThread = nullptr;
 
 		EnterCriticalSection(&s_connectionsLock);
 		s_connections.push_back(conn);
-		int connIdx = (int)s_connections.size() - 1;
+		int connIdx = static_cast<int>(s_connections.size()) - 1;
 		LeaveCriticalSection(&s_connectionsLock);
 
-		app.DebugPrintf("Win64 LAN: Client connected, assigned smallId=%d\n", assignedSmallId);
+#if defined(MINECRAFT_SERVER_BUILD)
+		if (g_Win64DedicatedServer)
+		{
+			ServerRuntime::ServerLogManager::OnAcceptedTcpConnection(assignedSmallId, remoteIpForLog);
+		}
+		else
+#endif
+		{
+			app.DebugPrintf("Win64 LAN: Client connected, assigned smallId=%d\n", assignedSmallId);
+		}
+
+		EnterCriticalSection(&s_smallIdToSocketLock);
+		s_smallIdToSocket[assignedSmallId] = clientSocket;
+		LeaveCriticalSection(&s_smallIdToSocketLock);
 
 		IQNetPlayer* qnetPlayer = &IQNet::m_player[assignedSmallId];
 
@@ -492,10 +723,10 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 
 		DWORD* threadParam = new DWORD;
 		*threadParam = connIdx;
-		HANDLE hThread = CreateThread(NULL, 0, RecvThreadProc, threadParam, 0, NULL);
+		HANDLE hThread = CreateThread(nullptr, 0, RecvThreadProc, threadParam, 0, nullptr);
 
 		EnterCriticalSection(&s_connectionsLock);
-		if (connIdx < (int)s_connections.size())
+		if (connIdx < static_cast<int>(s_connections.size()))
 			s_connections[connIdx].recvThread = hThread;
 		LeaveCriticalSection(&s_connectionsLock);
 	}
@@ -504,11 +735,11 @@ DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
 
 DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
 {
-	DWORD connIdx = *(DWORD*)param;
-	delete (DWORD*)param;
+	DWORD connIdx = *static_cast<DWORD *>(param);
+	delete static_cast<DWORD *>(param);
 
 	EnterCriticalSection(&s_connectionsLock);
-	if (connIdx >= (DWORD)s_connections.size())
+	if (connIdx >= static_cast<DWORD>(s_connections.size()))
 	{
 		LeaveCriticalSection(&s_connectionsLock);
 		return 0;
@@ -530,10 +761,10 @@ DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
 		}
 
 		int packetSize =
-			((uint32_t)header[0] << 24) |
-			((uint32_t)header[1] << 16) |
-			((uint32_t)header[2] << 8) |
-			((uint32_t)header[3]);
+			(static_cast<uint32_t>(header[0]) << 24) |
+			(static_cast<uint32_t>(header[1]) << 16) |
+			(static_cast<uint32_t>(header[2]) << 8) |
+			static_cast<uint32_t>(header[3]);
 
 		if (packetSize <= 0 || packetSize > WIN64_NET_MAX_PACKET_SIZE)
 		{
@@ -544,7 +775,7 @@ DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
 			break;
 		}
 
-		if ((int)recvBuf.size() < packetSize)
+		if (static_cast<int>(recvBuf.size()) < packetSize)
 		{
 			recvBuf.resize(packetSize);
 			app.DebugPrintf("Win64 LAN: Resized host recv buffer to %d bytes for client smallId=%d\n", packetSize, clientSmallId);
@@ -598,8 +829,22 @@ bool WinsockNetLayer::PopDisconnectedSmallId(BYTE* outSmallId)
 
 void WinsockNetLayer::PushFreeSmallId(BYTE smallId)
 {
+	// SmallIds 0..(XUSER_MAX_COUNT-1) are permanently reserved for the host's
+	// local pads and must never be recycled to remote clients.
+	if (smallId < (BYTE)XUSER_MAX_COUNT)
+		return;
+
 	EnterCriticalSection(&s_freeSmallIdLock);
-	s_freeSmallIds.push_back(smallId);
+	// Guard against double-recycle: the reconnect path (queueSmallIdForRecycle) and
+	// the DoWork disconnect path can both push the same smallId. If we allow duplicates,
+	// AcceptThread will hand out the same smallId to two different connections.
+	bool alreadyFree = false;
+	for (size_t i = 0; i < s_freeSmallIds.size(); i++)
+	{
+		if (s_freeSmallIds[i] == smallId) { alreadyFree = true; break; }
+	}
+	if (!alreadyFree)
+		s_freeSmallIds.push_back(smallId);
 	LeaveCriticalSection(&s_freeSmallIdLock);
 }
 
@@ -619,6 +864,171 @@ void WinsockNetLayer::CloseConnectionBySmallId(BYTE smallId)
 	LeaveCriticalSection(&s_connectionsLock);
 }
 
+BYTE WinsockNetLayer::GetSplitScreenSmallId(int padIndex)
+{
+	if (padIndex <= 0 || padIndex >= XUSER_MAX_COUNT) return 0xFF;
+	return s_splitScreenSmallId[padIndex];
+}
+
+SOCKET WinsockNetLayer::GetLocalSocket(BYTE senderSmallId)
+{
+	if (senderSmallId == s_localSmallId)
+		return s_hostConnectionSocket;
+	for (int i = 1; i < XUSER_MAX_COUNT; i++)
+	{
+		if (s_splitScreenSmallId[i] == senderSmallId && s_splitScreenSocket[i] != INVALID_SOCKET)
+			return s_splitScreenSocket[i];
+	}
+	return INVALID_SOCKET;
+}
+
+bool WinsockNetLayer::JoinSplitScreen(int padIndex, BYTE* outSmallId)
+{
+	if (!s_active || s_isHost || padIndex <= 0 || padIndex >= XUSER_MAX_COUNT)
+		return false;
+
+	if (s_splitScreenSocket[padIndex] != INVALID_SOCKET)
+	{
+		return false;
+	}
+
+	struct addrinfo hints = {};
+	struct addrinfo* result = nullptr;
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	char portStr[16];
+	sprintf_s(portStr, "%d", g_Win64MultiplayerPort);
+	if (getaddrinfo(g_Win64MultiplayerIP, portStr, &hints, &result) != 0 || result == nullptr)
+	{
+		app.DebugPrintf("Win64 LAN: Split-screen getaddrinfo failed for %s:%d\n", g_Win64MultiplayerIP, g_Win64MultiplayerPort);
+		return false;
+	}
+
+	SOCKET sock = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
+	if (sock == INVALID_SOCKET)
+	{
+		freeaddrinfo(result);
+		return false;
+	}
+
+	int noDelay = 1;
+	setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char*)&noDelay, sizeof(noDelay));
+
+	if (connect(sock, result->ai_addr, (int)result->ai_addrlen) == SOCKET_ERROR)
+	{
+		app.DebugPrintf("Win64 LAN: Split-screen connect() failed: %d\n", WSAGetLastError());
+		closesocket(sock);
+		freeaddrinfo(result);
+		return false;
+	}
+	freeaddrinfo(result);
+
+	BYTE assignBuf[1];
+	if (!RecvExact(sock, assignBuf, 1))
+	{
+		app.DebugPrintf("Win64 LAN: Split-screen failed to receive smallId\n");
+		closesocket(sock);
+		return false;
+	}
+
+	if (assignBuf[0] == WIN64_SMALLID_REJECT)
+	{
+		BYTE rejectBuf[5];
+		RecvExact(sock, rejectBuf, 5);
+		app.DebugPrintf("Win64 LAN: Split-screen connection rejected\n");
+		closesocket(sock);
+		return false;
+	}
+
+	BYTE assignedSmallId = assignBuf[0];
+	s_splitScreenSocket[padIndex] = sock;
+	s_splitScreenSmallId[padIndex] = assignedSmallId;
+	*outSmallId = assignedSmallId;
+
+	app.DebugPrintf("Win64 LAN: Split-screen pad %d connected, assigned smallId=%d\n", padIndex, assignedSmallId);
+
+	int* threadParam = new int;
+	*threadParam = padIndex;
+	s_splitScreenRecvThread[padIndex] = CreateThread(nullptr, 0, SplitScreenRecvThreadProc, threadParam, 0, nullptr);
+	if (s_splitScreenRecvThread[padIndex] == nullptr)
+	{
+		delete threadParam;
+		closesocket(sock);
+		s_splitScreenSocket[padIndex] = INVALID_SOCKET;
+		s_splitScreenSmallId[padIndex] = 0xFF;
+		app.DebugPrintf("Win64 LAN: CreateThread failed for split-screen pad %d\n", padIndex);
+		return false;
+	}
+
+	return true;
+}
+
+void WinsockNetLayer::CloseSplitScreenConnection(int padIndex)
+{
+	if (padIndex <= 0 || padIndex >= XUSER_MAX_COUNT) return;
+
+	if (s_splitScreenSocket[padIndex] != INVALID_SOCKET)
+	{
+		closesocket(s_splitScreenSocket[padIndex]);
+		s_splitScreenSocket[padIndex] = INVALID_SOCKET;
+	}
+	s_splitScreenSmallId[padIndex] = 0xFF;
+	if (s_splitScreenRecvThread[padIndex] != nullptr)
+	{
+		WaitForSingleObject(s_splitScreenRecvThread[padIndex], 2000);
+		CloseHandle(s_splitScreenRecvThread[padIndex]);
+		s_splitScreenRecvThread[padIndex] = nullptr;
+	}
+}
+
+DWORD WINAPI WinsockNetLayer::SplitScreenRecvThreadProc(LPVOID param)
+{
+	int padIndex = *(int*)param;
+	delete (int*)param;
+
+	SOCKET sock = s_splitScreenSocket[padIndex];
+	BYTE localSmallId = s_splitScreenSmallId[padIndex];
+	std::vector<BYTE> recvBuf;
+	recvBuf.resize(WIN64_NET_RECV_BUFFER_SIZE);
+
+	while (s_active && s_splitScreenSocket[padIndex] != INVALID_SOCKET)
+	{
+		BYTE header[4];
+		if (!RecvExact(sock, header, 4))
+		{
+			app.DebugPrintf("Win64 LAN: Split-screen pad %d disconnected from host\n", padIndex);
+			break;
+		}
+
+		int packetSize = ((uint32_t)header[0] << 24) | ((uint32_t)header[1] << 16) |
+			((uint32_t)header[2] << 8) | ((uint32_t)header[3]);
+		if (packetSize <= 0 || packetSize > WIN64_NET_MAX_PACKET_SIZE)
+		{
+			app.DebugPrintf("Win64 LAN: Split-screen pad %d invalid packet size %d\n", padIndex, packetSize);
+			break;
+		}
+
+		if ((int)recvBuf.size() < packetSize)
+			recvBuf.resize(packetSize);
+
+		if (!RecvExact(sock, &recvBuf[0], packetSize))
+		{
+			app.DebugPrintf("Win64 LAN: Split-screen pad %d disconnected from host (body)\n", padIndex);
+			break;
+		}
+
+		HandleDataReceived(s_hostSmallId, localSmallId, &recvBuf[0], packetSize);
+	}
+
+	EnterCriticalSection(&s_disconnectLock);
+	s_disconnectedSmallIds.push_back(localSmallId);
+	LeaveCriticalSection(&s_disconnectLock);
+
+	return 0;
+}
+
 DWORD WINAPI WinsockNetLayer::ClientRecvThreadProc(LPVOID param)
 {
 	std::vector<BYTE> recvBuf;
@@ -643,7 +1053,7 @@ DWORD WINAPI WinsockNetLayer::ClientRecvThreadProc(LPVOID param)
 			break;
 		}
 
-		if ((int)recvBuf.size() < packetSize)
+		if (static_cast<int>(recvBuf.size()) < packetSize)
 		{
 			recvBuf.resize(packetSize);
 			app.DebugPrintf("Win64 LAN: Resized client recv buffer to %d bytes\n", packetSize);
@@ -671,7 +1081,7 @@ bool WinsockNetLayer::StartAdvertising(int gamePort, const wchar_t* hostName, un
 	memset(&s_advertiseData, 0, sizeof(s_advertiseData));
 	s_advertiseData.magic = WIN64_LAN_BROADCAST_MAGIC;
 	s_advertiseData.netVersion = netVer;
-	s_advertiseData.gamePort = (WORD)gamePort;
+	s_advertiseData.gamePort = static_cast<WORD>(gamePort);
 	wcsncpy_s(s_advertiseData.hostName, 32, hostName, _TRUNCATE);
 	s_advertiseData.playerCount = 1;
 	s_advertiseData.maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
@@ -693,7 +1103,7 @@ bool WinsockNetLayer::StartAdvertising(int gamePort, const wchar_t* hostName, un
 	setsockopt(s_advertiseSock, SOL_SOCKET, SO_BROADCAST, (const char*)&broadcast, sizeof(broadcast));
 
 	s_advertising = true;
-	s_advertiseThread = CreateThread(NULL, 0, AdvertiseThreadProc, NULL, 0, NULL);
+	s_advertiseThread = CreateThread(nullptr, 0, AdvertiseThreadProc, nullptr, 0, nullptr);
 
 	app.DebugPrintf("Win64 LAN: Started advertising on UDP port %d\n", WIN64_LAN_DISCOVERY_PORT);
 	return true;
@@ -709,11 +1119,11 @@ void WinsockNetLayer::StopAdvertising()
 		s_advertiseSock = INVALID_SOCKET;
 	}
 
-	if (s_advertiseThread != NULL)
+	if (s_advertiseThread != nullptr)
 	{
 		WaitForSingleObject(s_advertiseThread, 2000);
 		CloseHandle(s_advertiseThread);
-		s_advertiseThread = NULL;
+		s_advertiseThread = nullptr;
 	}
 }
 
@@ -724,6 +1134,13 @@ void WinsockNetLayer::UpdateAdvertisePlayerCount(BYTE count)
 	LeaveCriticalSection(&s_advertiseLock);
 }
 
+void WinsockNetLayer::UpdateAdvertiseMaxPlayers(BYTE maxPlayers)
+{
+	EnterCriticalSection(&s_advertiseLock);
+	s_advertiseData.maxPlayers = maxPlayers;
+	LeaveCriticalSection(&s_advertiseLock);
+}
+
 void WinsockNetLayer::UpdateAdvertiseJoinable(bool joinable)
 {
 	EnterCriticalSection(&s_advertiseLock);
@@ -792,7 +1209,7 @@ bool WinsockNetLayer::StartDiscovery()
 	setsockopt(s_discoverySock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
 
 	s_discovering = true;
-	s_discoveryThread = CreateThread(NULL, 0, DiscoveryThreadProc, NULL, 0, NULL);
+	s_discoveryThread = CreateThread(nullptr, 0, DiscoveryThreadProc, nullptr, 0, nullptr);
 
 	app.DebugPrintf("Win64 LAN: Listening for LAN games on UDP port %d\n", WIN64_LAN_DISCOVERY_PORT);
 	return true;
@@ -808,11 +1225,11 @@ void WinsockNetLayer::StopDiscovery()
 		s_discoverySock = INVALID_SOCKET;
 	}
 
-	if (s_discoveryThread != NULL)
+	if (s_discoveryThread != nullptr)
 	{
 		WaitForSingleObject(s_discoveryThread, 2000);
 		CloseHandle(s_discoveryThread);
-		s_discoveryThread = NULL;
+		s_discoveryThread = nullptr;
 	}
 
 	EnterCriticalSection(&s_discoveryLock);
@@ -846,7 +1263,7 @@ DWORD WINAPI WinsockNetLayer::DiscoveryThreadProc(LPVOID param)
 			continue;
 		}
 
-		if (recvLen < (int)sizeof(Win64LANBroadcast))
+		if (recvLen < static_cast<int>(sizeof(Win64LANBroadcast)))
 			continue;
 
 		Win64LANBroadcast* broadcast = (Win64LANBroadcast*)recvBuf;
@@ -864,7 +1281,7 @@ DWORD WINAPI WinsockNetLayer::DiscoveryThreadProc(LPVOID param)
 		for (size_t i = 0; i < s_discoveredSessions.size(); i++)
 		{
 			if (strcmp(s_discoveredSessions[i].hostIP, senderIP) == 0 &&
-				s_discoveredSessions[i].hostPort == (int)broadcast->gamePort)
+				s_discoveredSessions[i].hostPort == static_cast<int>(broadcast->gamePort))
 			{
 				s_discoveredSessions[i].netVersion = broadcast->netVersion;
 				wcsncpy_s(s_discoveredSessions[i].hostName, 32, broadcast->hostName, _TRUNCATE);
@@ -885,7 +1302,7 @@ DWORD WINAPI WinsockNetLayer::DiscoveryThreadProc(LPVOID param)
 			Win64LANSession session;
 			memset(&session, 0, sizeof(session));
 			strncpy_s(session.hostIP, sizeof(session.hostIP), senderIP, _TRUNCATE);
-			session.hostPort = (int)broadcast->gamePort;
+			session.hostPort = static_cast<int>(broadcast->gamePort);
 			session.netVersion = broadcast->netVersion;
 			wcsncpy_s(session.hostName, 32, broadcast->hostName, _TRUNCATE);
 			session.playerCount = broadcast->playerCount;
diff --git a/Minecraft.Client/Windows64/Network/WinsockNetLayer.h b/Minecraft.Client/Windows64/Network/WinsockNetLayer.h
index fd1280f7..afccbd66 100644
--- a/Minecraft.Client/Windows64/Network/WinsockNetLayer.h
+++ b/Minecraft.Client/Windows64/Network/WinsockNetLayer.h
@@ -12,7 +12,8 @@
 #pragma comment(lib, "Ws2_32.lib")
 
 #define WIN64_NET_DEFAULT_PORT 25565
-#define WIN64_NET_MAX_CLIENTS 7
+#define WIN64_NET_MAX_CLIENTS 255
+#define WIN64_SMALLID_REJECT 0xFF
 #define WIN64_NET_RECV_BUFFER_SIZE 65536
 #define WIN64_NET_MAX_PACKET_SIZE (4 * 1024 * 1024)
 #define WIN64_LAN_DISCOVERY_PORT 25566
@@ -65,12 +66,18 @@ public:
 	static bool Initialize();
 	static void Shutdown();
 
-	static bool HostGame(int port, const char* bindIp = NULL);
+	static bool HostGame(int port, const char* bindIp = nullptr);
 	static bool JoinGame(const char* ip, int port);
 
 	static bool SendToSmallId(BYTE targetSmallId, const void* data, int dataSize);
 	static bool SendOnSocket(SOCKET sock, const void* data, int dataSize);
 
+	// Non-host split-screen: additional TCP connections to host, one per pad
+	static bool JoinSplitScreen(int padIndex, BYTE* outSmallId);
+	static void CloseSplitScreenConnection(int padIndex);
+	static SOCKET GetLocalSocket(BYTE senderSmallId);
+	static BYTE GetSplitScreenSmallId(int padIndex);
+
 	static bool IsHosting() { return s_isHost; }
 	static bool IsConnected() { return s_connected; }
 	static bool IsActive() { return s_active; }
@@ -89,6 +96,7 @@ public:
 	static bool StartAdvertising(int gamePort, const wchar_t* hostName, unsigned int gameSettings, unsigned int texPackId, unsigned char subTexId, unsigned short netVer);
 	static void StopAdvertising();
 	static void UpdateAdvertisePlayerCount(BYTE count);
+	static void UpdateAdvertiseMaxPlayers(BYTE maxPlayers);
 	static void UpdateAdvertiseJoinable(bool joinable);
 
 	static bool StartDiscovery();
@@ -101,6 +109,7 @@ private:
 	static DWORD WINAPI AcceptThreadProc(LPVOID param);
 	static DWORD WINAPI RecvThreadProc(LPVOID param);
 	static DWORD WINAPI ClientRecvThreadProc(LPVOID param);
+	static DWORD WINAPI SplitScreenRecvThreadProc(LPVOID param);
 	static DWORD WINAPI AdvertiseThreadProc(LPVOID param);
 	static DWORD WINAPI DiscoveryThreadProc(LPVOID param);
 
@@ -116,7 +125,7 @@ private:
 
 	static BYTE s_localSmallId;
 	static BYTE s_hostSmallId;
-	static BYTE s_nextSmallId;
+	static unsigned int s_nextSmallId;
 
 	static CRITICAL_SECTION s_sendLock;
 	static CRITICAL_SECTION s_connectionsLock;
@@ -141,6 +150,17 @@ private:
 
 	static CRITICAL_SECTION s_freeSmallIdLock;
 	static std::vector<BYTE> s_freeSmallIds;
+	// O(1) smallId -> socket lookup so we don't scan s_connections (which never shrinks) on every send
+	static SOCKET s_smallIdToSocket[256];
+	static CRITICAL_SECTION s_smallIdToSocketLock;
+
+	// Per-pad split-screen TCP connections (client-side, non-host only)
+	static SOCKET s_splitScreenSocket[XUSER_MAX_COUNT];
+	static BYTE s_splitScreenSmallId[XUSER_MAX_COUNT];
+	static HANDLE s_splitScreenRecvThread[XUSER_MAX_COUNT];
+
+public:
+	static void ClearSocketForSmallId(BYTE smallId);
 };
 
 extern bool g_Win64MultiplayerHost;
@@ -150,5 +170,6 @@ extern char g_Win64MultiplayerIP[256];
 extern bool g_Win64DedicatedServer;
 extern int g_Win64DedicatedServerPort;
 extern char g_Win64DedicatedServerBindIP[256];
+extern bool g_Win64DedicatedServerLanAdvertise;
 
 #endif
diff --git a/Minecraft.Client/Windows64/PostProcesser.cpp b/Minecraft.Client/Windows64/PostProcesser.cpp
index 5abd83b4..aabb1f67 100644
--- a/Minecraft.Client/Windows64/PostProcesser.cpp
+++ b/Minecraft.Client/Windows64/PostProcesser.cpp
@@ -21,14 +21,22 @@ const char* PostProcesser::g_gammaPSCode =
     "cbuffer GammaCB : register(b0)\n"
     "{\n"
     "    float gamma;\n"
-    "    float3 pad;\n"
+    "    float _pad;\n"
+    "    float2 uvOffset;\n"
+    "    float2 uvScale;\n"
+    "    float2 _pad2;\n"
     "};\n"
     "Texture2D sceneTex : register(t0);\n"
     "SamplerState sceneSampler : register(s0);\n"
     "float4 main(float4 pos : SV_Position, float2 uv : TEXCOORD0) : SV_Target\n"
     "{\n"
-    "    float4 color = sceneTex.Sample(sceneSampler, uv);\n"
-    "    color.rgb = pow(max(color.rgb, 0.0), 1.0 / gamma);\n"
+    "    float2 texUV = uvOffset + uv * uvScale;\n"
+    "    float4 color = sceneTex.Sample(sceneSampler, texUV);\n"
+    "\n"
+    "    color.rgb = max(color.rgb, 0.0);\n"
+    "\n"
+    "    color.rgb = pow(color.rgb, 1.0 / gamma);\n"
+    "\n"
     "    return color;\n"
     "}\n";
 
@@ -75,6 +83,9 @@ void PostProcesser::Init()
     pBackBuffer->GetDesc(&bbDesc);
     pBackBuffer->Release();
 
+    m_gammaTexWidth = bbDesc.Width;
+    m_gammaTexHeight = bbDesc.Height;
+
     DXGI_FORMAT texFormat = bbDesc.Format;
     if (m_wineMode)
     {
@@ -151,7 +162,7 @@ void PostProcesser::Init()
     cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
     cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
 
-    GammaCBData initData = {1.0f, {0, 0, 0}};
+    GammaCBData initData = {1.0f, 0, 0.0f, 0.0f, 1.0f, 1.0f, {0, 0}};
     D3D11_SUBRESOURCE_DATA srData;
     srData.pSysMem = &initData;
     srData.SysMemPitch = 0;
@@ -219,7 +230,9 @@ void PostProcesser::Apply() const
     if (FAILED(hr))
         return;
 
-    ctx->CopyResource(m_pGammaOffscreenTex, pBackBuffer);
+    D3D11_BOX srcBox = { 0, 0, 0, m_gammaTexWidth, m_gammaTexHeight, 1 };
+    ctx->CopySubresourceRegion(m_pGammaOffscreenTex, 0, 0, 0, 0, pBackBuffer, 0, &srcBox);
+    pBackBuffer->Release();
 
     D3D11_MAPPED_SUBRESOURCE mapped;
     const D3D11_MAP mapType = m_wineMode ? D3D11_MAP_WRITE_NO_OVERWRITE : D3D11_MAP_WRITE_DISCARD;
@@ -228,6 +241,10 @@ void PostProcesser::Apply() const
     {
         GammaCBData *cb = static_cast<GammaCBData *>(mapped.pData);
         cb->gamma = m_gamma;
+        cb->uvOffsetX = 0.0f;
+        cb->uvOffsetY = 0.0f;
+        cb->uvScaleX = 1.0f;
+        cb->uvScaleY = 1.0f;
         ctx->Unmap(m_pGammaCB, 0);
     }
 
@@ -236,16 +253,12 @@ void PostProcesser::Apply() const
     ctx->OMGetRenderTargets(1, &oldRTV, &oldDSV);
 
     UINT numViewports = 1;
-    D3D11_VIEWPORT oldViewport;
+    D3D11_VIEWPORT oldViewport = {};
     ctx->RSGetViewports(&numViewports, &oldViewport);
 
     ID3D11RenderTargetView* bbRTV = g_pRenderTargetView;
     ctx->OMSetRenderTargets(1, &bbRTV, nullptr);
 
-    D3D11_TEXTURE2D_DESC bbDesc;
-    pBackBuffer->GetDesc(&bbDesc);
-    pBackBuffer->Release();
-
     D3D11_VIEWPORT vp;
     if (m_useCustomViewport)
     {
@@ -253,8 +266,8 @@ void PostProcesser::Apply() const
     }
     else
     {
-        vp.Width = static_cast<FLOAT>(bbDesc.Width);
-        vp.Height = static_cast<FLOAT>(bbDesc.Height);
+        vp.Width = static_cast<FLOAT>(m_gammaTexWidth);
+        vp.Height = static_cast<FLOAT>(m_gammaTexHeight);
         vp.MinDepth = 0.0f;
         vp.MaxDepth = 1.0f;
         vp.TopLeftX = 0;
@@ -313,7 +326,8 @@ void PostProcesser::CopyBackbuffer()
     if (FAILED(hr))
         return;
 
-    ctx->CopyResource(m_pGammaOffscreenTex, pBackBuffer);
+    D3D11_BOX srcBox = { 0, 0, 0, m_gammaTexWidth, m_gammaTexHeight, 1 };
+    ctx->CopySubresourceRegion(m_pGammaOffscreenTex, 0, 0, 0, 0, pBackBuffer, 0, &srcBox);
     pBackBuffer->Release();
 }
 
@@ -327,6 +341,21 @@ void PostProcesser::ApplyFromCopied() const
 
     ID3D11DeviceContext* ctx = g_pImmediateContext;
 
+    D3D11_VIEWPORT vp;
+    if (m_useCustomViewport)
+    {
+        vp = m_customViewport;
+    }
+    else
+    {
+        vp.Width = static_cast<FLOAT>(m_gammaTexWidth);
+        vp.Height = static_cast<FLOAT>(m_gammaTexHeight);
+        vp.MinDepth = 0.0f;
+        vp.MaxDepth = 1.0f;
+        vp.TopLeftX = 0;
+        vp.TopLeftY = 0;
+    }
+
     D3D11_MAPPED_SUBRESOURCE mapped;
     const D3D11_MAP mapType = m_wineMode ? D3D11_MAP_WRITE_NO_OVERWRITE : D3D11_MAP_WRITE_DISCARD;
     const HRESULT hr = ctx->Map(m_pGammaCB, 0, mapType, 0, &mapped);
@@ -334,6 +363,12 @@ void PostProcesser::ApplyFromCopied() const
     {
         const auto cb = static_cast<GammaCBData*>(mapped.pData);
         cb->gamma = m_gamma;
+        const float texW = static_cast<float>(m_gammaTexWidth);
+        const float texH = static_cast<float>(m_gammaTexHeight);
+        cb->uvOffsetX = vp.TopLeftX / texW;
+        cb->uvOffsetY = vp.TopLeftY / texH;
+        cb->uvScaleX = vp.Width / texW;
+        cb->uvScaleY = vp.Height / texH;
         ctx->Unmap(m_pGammaCB, 0);
     }
 
@@ -342,29 +377,12 @@ void PostProcesser::ApplyFromCopied() const
     ctx->OMGetRenderTargets(1, &oldRTV, &oldDSV);
 
     UINT numViewports = 1;
-    D3D11_VIEWPORT oldViewport;
+    D3D11_VIEWPORT oldViewport = {};
     ctx->RSGetViewports(&numViewports, &oldViewport);
 
     ID3D11RenderTargetView* bbRTV = g_pRenderTargetView;
     ctx->OMSetRenderTargets(1, &bbRTV, nullptr);
 
-    D3D11_VIEWPORT vp;
-    if (m_useCustomViewport)
-    {
-        vp = m_customViewport;
-    }
-    else
-    {
-        D3D11_TEXTURE2D_DESC texDesc;
-        m_pGammaOffscreenTex->GetDesc(&texDesc);
-        vp.Width = static_cast<FLOAT>(texDesc.Width);
-        vp.Height = static_cast<FLOAT>(texDesc.Height);
-        vp.MinDepth = 0.0f;
-        vp.MaxDepth = 1.0f;
-        vp.TopLeftX = 0;
-        vp.TopLeftY = 0;
-    }
-
     ctx->RSSetViewports(1, &vp);
 
     ctx->IASetInputLayout(nullptr);
diff --git a/Minecraft.Client/Windows64/Windows64_App.cpp b/Minecraft.Client/Windows64/Windows64_App.cpp
index ad9e1f24..369e2909 100644
--- a/Minecraft.Client/Windows64/Windows64_App.cpp
+++ b/Minecraft.Client/Windows64/Windows64_App.cpp
@@ -52,8 +52,8 @@ void CConsoleMinecraftApp::GetSaveThumbnail(PBYTE *pbData,DWORD *pdwSize)
 	}
 	else
 	{
-		// No capture happened (e.g. first save on world creation) leave thumbnail as NULL
-		if (pbData)  *pbData  = NULL;
+		// No capture happened (e.g. first save on world creation) leave thumbnail as nullptr
+		if (pbData)  *pbData  = nullptr;
 		if (pdwSize) *pdwSize = 0;
 	}
 }
@@ -69,7 +69,7 @@ void CConsoleMinecraftApp::TemporaryCreateGameStart()
 {
 	////////////////////////////////////////////////////////////////////////////////////////////// From CScene_Main::OnInit
 
-	app.setLevelGenerationOptions(NULL);
+	app.setLevelGenerationOptions(nullptr);
 
 	// From CScene_Main::RunPlayGame
 	Minecraft *pMinecraft=Minecraft::GetInstance();
@@ -95,11 +95,11 @@ void CConsoleMinecraftApp::TemporaryCreateGameStart()
 	StorageManager.SetSaveTitle(wWorldName.c_str());
 
 	bool isFlat = false;
-	__int64 seedValue = 0; // BiomeSource::findSeed(isFlat?LevelType::lvl_flat:LevelType::lvl_normal);	// 4J - was (new Random())->nextLong() - now trying to actually find a seed to suit our requirements
+	int64_t seedValue = 0; // BiomeSource::findSeed(isFlat?LevelType::lvl_flat:LevelType::lvl_normal);	// 4J - was (new Random())->nextLong() - now trying to actually find a seed to suit our requirements
 
 	NetworkGameInitData *param = new NetworkGameInitData();
 	param->seed = seedValue;
-	param->saveData = NULL;
+	param->saveData = nullptr;
 
 	app.SetGameHostOption(eGameHostOption_Difficulty,0);
 	app.SetGameHostOption(eGameHostOption_FriendsOfFriends,0);
@@ -125,7 +125,7 @@ void CConsoleMinecraftApp::TemporaryCreateGameStart()
 
 	LoadingInputParams *loadingParams = new LoadingInputParams();
 	loadingParams->func = &CGameNetworkManager::RunNetworkGameThreadProc;
-	loadingParams->lpParam = (LPVOID)param;
+	loadingParams->lpParam = static_cast<LPVOID>(param);
 
 	// Reset the autosave time
 	app.SetAutosaveTimerTime();
diff --git a/Minecraft.Client/Windows64/Windows64_App.h b/Minecraft.Client/Windows64/Windows64_App.h
index bff916ec..639cec73 100644
--- a/Minecraft.Client/Windows64/Windows64_App.h
+++ b/Minecraft.Client/Windows64/Windows64_App.h
@@ -25,9 +25,9 @@ public:
 	virtual int GetLocalTMSFileIndex(WCHAR *wchTMSFile,bool bFilenameIncludesExtension,eFileExtensionType eEXT=eFileExtensionType_PNG);
 
 	// BANNED LEVEL LIST
-	virtual void ReadBannedList(int iPad, eTMSAction action=(eTMSAction)0, bool bCallback=false) {}
+	virtual void ReadBannedList(int iPad, eTMSAction action=static_cast<eTMSAction>(0), bool bCallback=false) {}
 
-	C4JStringTable *GetStringTable()																									{ return NULL;}
+	C4JStringTable *GetStringTable()																									{ return nullptr;}
 
 	// original code
 	virtual void TemporaryCreateGameStart();
diff --git a/Minecraft.Client/Windows64/Windows64_Minecraft.cpp b/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
index 2eef5f73..81430ffc 100644
--- a/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
+++ b/Minecraft.Client/Windows64/Windows64_Minecraft.cpp
@@ -22,6 +22,9 @@
 #include "..\..\Minecraft.World\net.minecraft.world.level.tile.h"
 
 #include "..\ClientConnection.h"
+#include "..\Minecraft.h"
+#include "..\ChatScreen.h"
+#include "KeyboardMouseInput.h"
 #include "..\User.h"
 #include "..\..\Minecraft.World\Socket.h"
 #include "..\..\Minecraft.World\ThreadName.h"
@@ -41,7 +44,15 @@
 #include "..\..\Minecraft.World\compression.h"
 #include "..\..\Minecraft.World\OldChunkStorage.h"
 #include "Common/PostProcesser.h"
+#include "..\GameRenderer.h"
 #include "Network\WinsockNetLayer.h"
+#include "Windows64_Xuid.h"
+#include "Common/UI/UI.h"
+
+// Forward-declare the internal Renderer class and its global instance from 4J_Render_PC_d.lib.
+// C4JRender (RenderManager) is a stateless wrapper — all D3D state lives in InternalRenderManager.
+class Renderer;
+extern Renderer InternalRenderManager;
 
 #include "Xbox/resource.h"
 
@@ -77,7 +88,6 @@ DWORD dwProfileSettingsA[NUM_PROFILE_VALUES]=
 	0,0,0,0,0
 #endif
 };
-
 //-------------------------------------------------------------------------------------
 // Time             Since fAppTime is a float, we need to keep the quadword app time
 //                  as a LARGE_INTEGER so that we don't lose precision after running
@@ -86,10 +96,20 @@ DWORD dwProfileSettingsA[NUM_PROFILE_VALUES]=
 
 BOOL g_bWidescreen = TRUE;
 
+// Screen resolution — auto-detected from the monitor at startup.
+// The 3D world renders at native resolution; Flash UI is 16:9-fitted and centered
+// within each viewport (pillarboxed on ultrawide, letterboxed on tall displays).
+// ApplyScreenMode() can still override these for debug/test resolutions via launch args.
 int g_iScreenWidth = 1920;
 int g_iScreenHeight = 1080;
 
+// Real window dimensions — updated on every WM_SIZE so the 3D perspective
+// always matches the current window, even after a resize.
+int g_rScreenWidth = 1920;
+int g_rScreenHeight = 1080;
+
 float g_iAspectRatio = static_cast<float>(g_iScreenWidth) / g_iScreenHeight;
+static bool g_bResizeReady = false;
 
 char g_Win64Username[17] = { 0 };
 wchar_t g_Win64UsernameW[17] = { 0 };
@@ -98,18 +118,10 @@ wchar_t g_Win64UsernameW[17] = { 0 };
 static bool g_isFullscreen = false;
 static WINDOWPLACEMENT g_wpPrev = { sizeof(g_wpPrev) };
 
-//--------------------------------------------------------------------------------------
-// Update the Aspect Ratio to support Any Aspect Ratio
-//--------------------------------------------------------------------------------------
-void UpdateAspectRatio(int width, int height)
-{
-	g_iAspectRatio = static_cast<float>(width) / height;
-}
-
 struct Win64LaunchOptions
 {
 	int screenMode;
-	bool serverMode;
+	bool fullscreen;
 };
 
 static void CopyWideArgToAnsi(LPCWSTR source, char* dest, size_t destSize)
@@ -118,17 +130,17 @@ static void CopyWideArgToAnsi(LPCWSTR source, char* dest, size_t destSize)
 		return;
 
 	dest[0] = 0;
-	if (source == NULL)
+	if (source == nullptr)
 		return;
 
-	WideCharToMultiByte(CP_ACP, 0, source, -1, dest, (int)destSize, NULL, NULL);
+	WideCharToMultiByte(CP_ACP, 0, source, -1, dest, static_cast<int>(destSize), nullptr, nullptr);
 	dest[destSize - 1] = 0;
 }
 
 // ---------- Persistent options (options.txt next to exe) ----------
 static void GetOptionsFilePath(char *out, size_t outSize)
 {
-	GetModuleFileNameA(NULL, out, (DWORD)outSize);
+	GetModuleFileNameA(nullptr, out, static_cast<DWORD>(outSize));
 	char *p = strrchr(out, '\\');
 	if (p) *(p + 1) = '\0';
 	strncat_s(out, outSize, "options.txt", _TRUNCATE);
@@ -194,17 +206,13 @@ static Win64LaunchOptions ParseLaunchOptions()
 {
 	Win64LaunchOptions options = {};
 	options.screenMode = 0;
-	options.serverMode = false;
 
 	g_Win64MultiplayerJoin = false;
 	g_Win64MultiplayerPort = WIN64_NET_DEFAULT_PORT;
-	g_Win64DedicatedServer = false;
-	g_Win64DedicatedServerPort = WIN64_NET_DEFAULT_PORT;
-	g_Win64DedicatedServerBindIP[0] = 0;
 
 	int argc = 0;
 	LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
-	if (argv == NULL)
+	if (argv == nullptr)
 		return options;
 
 	if (argc > 1 && lstrlenW(argv[1]) == 1)
@@ -215,17 +223,6 @@ static Win64LaunchOptions ParseLaunchOptions()
 
 	for (int i = 1; i < argc; ++i)
 	{
-		if (_wcsicmp(argv[i], L"-server") == 0)
-		{
-			options.serverMode = true;
-			break;
-		}
-	}
-
-	g_Win64DedicatedServer = options.serverMode;
-
-	for (int i = 1; i < argc; ++i)
-	{
 		if (_wcsicmp(argv[i], L"-name") == 0 && (i + 1) < argc)
 		{
 			CopyWideArgToAnsi(argv[++i], g_Win64Username, sizeof(g_Win64Username));
@@ -234,64 +231,26 @@ static Win64LaunchOptions ParseLaunchOptions()
 		{
 			char ipBuf[256];
 			CopyWideArgToAnsi(argv[++i], ipBuf, sizeof(ipBuf));
-			if (options.serverMode)
-			{
-				strncpy_s(g_Win64DedicatedServerBindIP, sizeof(g_Win64DedicatedServerBindIP), ipBuf, _TRUNCATE);
-			}
-			else
-			{
-				strncpy_s(g_Win64MultiplayerIP, sizeof(g_Win64MultiplayerIP), ipBuf, _TRUNCATE);
-				g_Win64MultiplayerJoin = true;
-			}
+			strncpy_s(g_Win64MultiplayerIP, sizeof(g_Win64MultiplayerIP), ipBuf, _TRUNCATE);
+			g_Win64MultiplayerJoin = true;
 		}
 		else if (_wcsicmp(argv[i], L"-port") == 0 && (i + 1) < argc)
 		{
-			wchar_t* endPtr = NULL;
-			long port = wcstol(argv[++i], &endPtr, 10);
+			wchar_t* endPtr = nullptr;
+			const long port = wcstol(argv[++i], &endPtr, 10);
 			if (endPtr != argv[i] && *endPtr == 0 && port > 0 && port <= 65535)
 			{
-				if (options.serverMode)
-					g_Win64DedicatedServerPort = (int)port;
-				else
-					g_Win64MultiplayerPort = (int)port;
+				g_Win64MultiplayerPort = static_cast<int>(port);
 			}
 		}
+		else if (_wcsicmp(argv[i], L"-fullscreen") == 0)
+			options.fullscreen = true;
 	}
 
 	LocalFree(argv);
 	return options;
 }
 
-static BOOL WINAPI HeadlessServerCtrlHandler(DWORD ctrlType)
-{
-	switch (ctrlType)
-	{
-	case CTRL_C_EVENT:
-	case CTRL_BREAK_EVENT:
-	case CTRL_CLOSE_EVENT:
-	case CTRL_SHUTDOWN_EVENT:
-		app.m_bShutdown = true;
-		MinecraftServer::HaltServer();
-		return TRUE;
-	default:
-		return FALSE;
-	}
-}
-
-static void SetupHeadlessServerConsole()
-{
-	if (AllocConsole())
-	{
-		FILE* stream = NULL;
-		freopen_s(&stream, "CONIN$", "r", stdin);
-		freopen_s(&stream, "CONOUT$", "w", stdout);
-		freopen_s(&stream, "CONOUT$", "w", stderr);
-		SetConsoleTitleA("Minecraft Server");
-	}
-
-	SetConsoleCtrlHandler(HeadlessServerCtrlHandler, TRUE);
-}
-
 void DefineActions(void)
 {
 	// The app needs to define the actions required, and the possible mappings for these
@@ -483,7 +442,7 @@ HRESULT InitD3D( IDirect3DDevice9 **ppDevice,
 	return pD3D->CreateDevice(
 		0,
 		D3DDEVTYPE_HAL,
-		NULL,
+		nullptr,
 		D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_BUFFER_2_FRAMES,
 		pd3dPP,
 		ppDevice );
@@ -501,16 +460,16 @@ void MemSect(int sect)
 }
 #endif
 
-HINSTANCE               g_hInst = NULL;
-HWND                    g_hWnd = NULL;
+HINSTANCE               g_hInst = nullptr;
+HWND                    g_hWnd = nullptr;
 D3D_DRIVER_TYPE         g_driverType = D3D_DRIVER_TYPE_NULL;
 D3D_FEATURE_LEVEL       g_featureLevel = D3D_FEATURE_LEVEL_11_0;
-ID3D11Device*           g_pd3dDevice = NULL;
-ID3D11DeviceContext*    g_pImmediateContext = NULL;
-IDXGISwapChain*         g_pSwapChain = NULL;
-ID3D11RenderTargetView* g_pRenderTargetView = NULL;
-ID3D11DepthStencilView* g_pDepthStencilView = NULL;
-ID3D11Texture2D*		g_pDepthStencilBuffer = NULL;
+ID3D11Device*           g_pd3dDevice = nullptr;
+ID3D11DeviceContext*    g_pImmediateContext = nullptr;
+IDXGISwapChain*         g_pSwapChain = nullptr;
+ID3D11RenderTargetView* g_pRenderTargetView = nullptr;
+ID3D11DepthStencilView* g_pDepthStencilView = nullptr;
+ID3D11Texture2D*		g_pDepthStencilBuffer = nullptr;
 
 //
 //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
@@ -523,6 +482,11 @@ ID3D11Texture2D*		g_pDepthStencilBuffer = NULL;
 //  WM_SIZE		- handle resizing logic to support Any Aspect Ratio
 //
 //
+static bool ResizeD3D(int newW, int newH); // forward declaration
+static bool g_bInSizeMove = false;     // true while the user is dragging the window border
+static int  g_pendingResizeW = 0;      // deferred resize dimensions
+static int  g_pendingResizeH = 0;
+
 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
 	int wmId, wmEvent;
@@ -568,14 +532,30 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 	case WM_CHAR:
 		// Buffer typed characters so UIScene_Keyboard can dispatch them to the Iggy Flash player
 		if (wParam >= 0x20 || wParam == 0x08 || wParam == 0x0D) // printable chars + backspace + enter
-			g_KBMInput.OnChar((wchar_t)wParam);
+			g_KBMInput.OnChar(static_cast<wchar_t>(wParam));
 		break;
 
 	case WM_KEYDOWN:
 	case WM_SYSKEYDOWN:
 	{
-		int vk = (int)wParam;
-		if (lParam & 0x40000000) break; // ignore auto-repeat
+		int vk = static_cast<int>(wParam);
+		if ((lParam & 0x40000000) && vk != VK_LEFT && vk != VK_RIGHT && vk != VK_BACK)
+			break;
+#ifdef _WINDOWS64
+		const Minecraft* pm = Minecraft::GetInstance();
+		ChatScreen* chat = pm && pm->screen ? dynamic_cast<ChatScreen*>(pm->screen) : nullptr;
+		if (chat)
+		{
+			if (vk == 'V' && (GetKeyState(VK_CONTROL) & 0x8000))
+				{ chat->handlePasteRequest(); break; }
+			if ((vk == VK_UP || vk == VK_DOWN) && !(lParam & 0x40000000))
+				{ if (vk == VK_UP) chat->handleHistoryUp(); else chat->handleHistoryDown(); break; }
+			if (vk >= '1' && vk <= '9') // Prevent hotkey conflicts
+				break;
+			if (vk == VK_SHIFT)
+				break;
+		}
+#endif
 		if (vk == VK_SHIFT)
 			vk = (MapVirtualKey((lParam >> 16) & 0xFF, MAPVK_VSC_TO_VK_EX) == VK_RSHIFT) ? VK_RSHIFT : VK_LSHIFT;
 		else if (vk == VK_CONTROL)
@@ -583,12 +563,12 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 		else if (vk == VK_MENU)
 			vk = (lParam & (1 << 24)) ? VK_RMENU : VK_LMENU;
 		g_KBMInput.OnKeyDown(vk);
-		break;
+		return DefWindowProc(hWnd, message, wParam, lParam);
 	}
 	case WM_KEYUP:
 	case WM_SYSKEYUP:
 	{
-		int vk = (int)wParam;
+		int vk = static_cast<int>(wParam);
 		if (vk == VK_SHIFT)
 			vk = (MapVirtualKey((lParam >> 16) & 0xFF, MAPVK_VSC_TO_VK_EX) == VK_RSHIFT) ? VK_RSHIFT : VK_LSHIFT;
 		else if (vk == VK_CONTROL)
@@ -629,13 +609,13 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 	case WM_INPUT:
 		{
 			UINT dwSize = 0;
-			GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));
+			GetRawInputData((HRAWINPUT)lParam, RID_INPUT, nullptr, &dwSize, sizeof(RAWINPUTHEADER));
 			if (dwSize > 0 && dwSize <= 256)
 			{
 				BYTE rawBuffer[256];
 				if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, rawBuffer, &dwSize, sizeof(RAWINPUTHEADER)) == dwSize)
 				{
-					RAWINPUT* raw = (RAWINPUT*)rawBuffer;
+					const RAWINPUT* raw = (RAWINPUT*)rawBuffer;
 					if (raw->header.dwType == RIM_TYPEMOUSE)
 					{
 						g_KBMInput.OnRawMouseDelta(raw->data.mouse.lLastX, raw->data.mouse.lLastY);
@@ -644,9 +624,40 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			}
 		}
 		break;
+	case WM_ENTERSIZEMOVE:
+		g_bInSizeMove = true;
+		break;
+
+	case WM_EXITSIZEMOVE:
+		g_bInSizeMove = false;
+		if (g_pendingResizeW > 0 && g_pendingResizeH > 0)
+		{
+			// g_rScreenWidth/Height updated inside ResizeD3D to backbuffer dims
+			ResizeD3D(g_pendingResizeW, g_pendingResizeH);
+			g_pendingResizeW = 0;
+			g_pendingResizeH = 0;
+		}
+		break;
+
 	case WM_SIZE:
 		{
-			UpdateAspectRatio(LOWORD(lParam), HIWORD(lParam));
+			int newW = LOWORD(lParam);
+			int newH = HIWORD(lParam);
+			if (newW > 0 && newH > 0)
+			{
+				if (g_bInSizeMove)
+				{
+					// Just store the latest size, resize when dragging ends
+					g_pendingResizeW = newW;
+					g_pendingResizeH = newH;
+				}
+				else
+				{
+					// Immediate resize (maximize, programmatic resize, etc.)
+					// g_rScreenWidth/Height updated inside ResizeD3D to backbuffer dims
+					ResizeD3D(newW, newH);
+				}
+			}
 		}
 		break;
 	default:
@@ -672,7 +683,7 @@ ATOM MyRegisterClass(HINSTANCE hInstance)
 	wcex.cbWndExtra		= 0;
 	wcex.hInstance		= hInstance;
 	wcex.hIcon			= LoadIcon(hInstance, "Minecraft");
-	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
+	wcex.hCursor		= LoadCursor(nullptr, IDC_ARROW);
 	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
 	wcex.lpszMenuName	= "Minecraft";
 	wcex.lpszClassName	= "MinecraftClass";
@@ -695,7 +706,7 @@ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
 {
 	g_hInst = hInstance; // Store instance handle in our global variable
 
-	RECT wr = {0, 0, g_iScreenWidth, g_iScreenHeight};    // set the size, but not the position
+	RECT wr = {0, 0, g_rScreenWidth, g_rScreenHeight};    // set the size, but not the position
 	AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);    // adjust the size
 
 	g_hWnd = CreateWindow(	"MinecraftClass",
@@ -705,10 +716,10 @@ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
 		0,
 		wr.right - wr.left,    // width of the window
 		wr.bottom - wr.top,    // height of the window
-		NULL,
-		NULL,
+		nullptr,
+		nullptr,
 		hInstance,
-		NULL);
+		nullptr);
 
 	if (!g_hWnd)
 	{
@@ -781,8 +792,8 @@ HRESULT InitDevice()
 	UINT width = rc.right - rc.left;
 	UINT height = rc.bottom - rc.top;
 //app.DebugPrintf("width: %d, height: %d\n", width, height);
-	width = g_iScreenWidth;
-	height = g_iScreenHeight;
+	width = g_rScreenWidth;
+	height = g_rScreenHeight;
 //app.DebugPrintf("width: %d, height: %d\n", width, height);
 
 	UINT createDeviceFlags = 0;
@@ -814,7 +825,7 @@ HRESULT InitDevice()
 	sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
 	sd.BufferDesc.RefreshRate.Numerator = 60;
 	sd.BufferDesc.RefreshRate.Denominator = 1;
-	sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+	sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
 	sd.OutputWindow = g_hWnd;
 	sd.SampleDesc.Count = 1;
 	sd.SampleDesc.Quality = 0;
@@ -823,7 +834,7 @@ HRESULT InitDevice()
 	for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
 	{
 		g_driverType = driverTypes[driverTypeIndex];
-		hr = D3D11CreateDeviceAndSwapChain( NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels,
+		hr = D3D11CreateDeviceAndSwapChain( nullptr, g_driverType, nullptr, createDeviceFlags, featureLevels, numFeatureLevels,
 			D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext );
 		if( HRESULT_SUCCEEDED( hr ) )
 			break;
@@ -832,7 +843,7 @@ HRESULT InitDevice()
 		return hr;
 
 	// Create a render target view
-	ID3D11Texture2D* pBackBuffer = NULL;
+	ID3D11Texture2D* pBackBuffer = nullptr;
 	hr = g_pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&pBackBuffer );
 	if( FAILED( hr ) )
 		return hr;
@@ -852,7 +863,7 @@ HRESULT InitDevice()
 	descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
 	descDepth.CPUAccessFlags = 0;
 	descDepth.MiscFlags = 0;
-	hr = g_pd3dDevice->CreateTexture2D(&descDepth, NULL, &g_pDepthStencilBuffer);
+	hr = g_pd3dDevice->CreateTexture2D(&descDepth, nullptr, &g_pDepthStencilBuffer);
 
 	D3D11_DEPTH_STENCIL_VIEW_DESC descDSView;
 	ZeroMemory(&descDSView, sizeof(descDSView));
@@ -862,7 +873,7 @@ HRESULT InitDevice()
 
 	hr = g_pd3dDevice->CreateDepthStencilView(g_pDepthStencilBuffer, &descDSView, &g_pDepthStencilView);
 
-	hr = g_pd3dDevice->CreateRenderTargetView( pBackBuffer, NULL, &g_pRenderTargetView );
+	hr = g_pd3dDevice->CreateRenderTargetView( pBackBuffer, nullptr, &g_pRenderTargetView );
 	pBackBuffer->Release();
 	if( FAILED( hr ) )
 		return hr;
@@ -871,8 +882,8 @@ HRESULT InitDevice()
 
 	// Setup the viewport
 	D3D11_VIEWPORT vp;
-	vp.Width = (FLOAT)width;
-	vp.Height = (FLOAT)height;
+	vp.Width = static_cast<FLOAT>(width);
+	vp.Height = static_cast<FLOAT>(height);
 	vp.MinDepth = 0.0f;
 	vp.MaxDepth = 1.0f;
 	vp.TopLeftX = 0;
@@ -892,18 +903,293 @@ HRESULT InitDevice()
 void Render()
 {
 	// Just clear the backbuffer
-	float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; //red,green,blue,alpha
+	const float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; //red,green,blue,alpha
 
 	g_pImmediateContext->ClearRenderTargetView( g_pRenderTargetView, ClearColor );
 	g_pSwapChain->Present( 0, 0 );
 }
 
 //--------------------------------------------------------------------------------------
+// Rebuild D3D11 resources after a window resize
+//--------------------------------------------------------------------------------------
+static bool ResizeD3D(int newW, int newH)
+{
+	if (newW <= 0 || newH <= 0) return false;
+	if (!g_pSwapChain) return false;
+	if (!g_bResizeReady) return false;
+
+	int bbW = newW;
+	int bbH = newH;
+
+	// InternalRenderManager member offsets (from decompiled Renderer.h):
+	//   0x10  m_pDevice              (ID3D11Device*)
+	//   0x18  m_pDeviceContext       (ID3D11DeviceContext*)
+	//   0x20  m_pSwapChain           (IDXGISwapChain*)
+	//   0x28  renderTargetView       (ID3D11RenderTargetView*)  — backbuffer RTV
+	//   0x50  renderTargetShaderResourceView (ID3D11ShaderResourceView*)
+	//   0x98  depthStencilView       (ID3D11DepthStencilView*)
+	//   0x5138 backBufferWidth       (DWORD) — used by StartFrame() for viewport
+	//   0x513C backBufferHeight      (DWORD) — used by StartFrame() for viewport
+	//
+	// Strategy: destroy old swap chain, create new one, patch Renderer's internal
+	// pointers directly. This avoids both ResizeBuffers (outstanding ref issues)
+	// and Initialise() (which wipes the texture table via memset).
+	// The Renderer's old RTV/SRV/DSV are intentionally NOT released — they become
+	// orphaned with the old swap chain. Tiny leak, but avoids fighting unknown refs.
+	char* pRM = (char*)&InternalRenderManager;
+	ID3D11RenderTargetView**    ppRM_RTV     = (ID3D11RenderTargetView**)(pRM + 0x28);
+	ID3D11ShaderResourceView**  ppRM_SRV     = (ID3D11ShaderResourceView**)(pRM + 0x50);
+	ID3D11DepthStencilView**    ppRM_DSV     = (ID3D11DepthStencilView**)(pRM + 0x98);
+	IDXGISwapChain**            ppRM_SC      = (IDXGISwapChain**)(pRM + 0x20);
+	DWORD*                      pRM_BBWidth  = (DWORD*)(pRM + 0x5138);
+	DWORD*                      pRM_BBHeight = (DWORD*)(pRM + 0x513C);
+
+	// Verify offsets by checking device and swap chain pointers
+	ID3D11Device** ppRM_Device = (ID3D11Device**)(pRM + 0x10);
+	if (*ppRM_Device != g_pd3dDevice || *ppRM_SC != g_pSwapChain)
+	{
+		app.DebugPrintf("[RESIZE] ERROR: RenderManager offset verification failed! "
+			"device=%p (expected %p) swapchain=%p (expected %p)\n",
+			*ppRM_Device, g_pd3dDevice, *ppRM_SC, g_pSwapChain);
+		return false;
+	}
+
+	// Cross-check backbuffer dimension offsets against swap chain desc
+	DXGI_SWAP_CHAIN_DESC oldScDesc;
+	g_pSwapChain->GetDesc(&oldScDesc);
+	bool bbDimsValid = (*pRM_BBWidth == oldScDesc.BufferDesc.Width &&
+	                    *pRM_BBHeight == oldScDesc.BufferDesc.Height);
+	if (!bbDimsValid)
+	{
+		app.DebugPrintf("[RESIZE] WARNING: backBuffer dim offsets wrong: "
+			"stored=%ux%u, swapchain=%ux%u\n",
+			*pRM_BBWidth, *pRM_BBHeight, oldScDesc.BufferDesc.Width, oldScDesc.BufferDesc.Height);
+	}
+
+	RenderManager.Suspend();
+	while (!RenderManager.Suspended()) { Sleep(1); }
+
+	PostProcesser::GetInstance().Cleanup();
+
+	g_pImmediateContext->ClearState();
+	g_pImmediateContext->Flush();
+
+	// Release OUR views and depth buffer
+	if (g_pRenderTargetView) { g_pRenderTargetView->Release(); g_pRenderTargetView = NULL; }
+	if (g_pDepthStencilView) { g_pDepthStencilView->Release(); g_pDepthStencilView = NULL; }
+	if (g_pDepthStencilBuffer) { g_pDepthStencilBuffer->Release(); g_pDepthStencilBuffer = NULL; }
+
+	gdraw_D3D11_PreReset();
+
+	// Get IDXGIFactory from the existing device BEFORE destroying the old swap chain.
+	// If anything fails before we have a new swap chain, we abort without destroying
+	// the old one — leaving the Renderer in a valid (old-size) state.
+	IDXGISwapChain* pOldSwapChain = g_pSwapChain;
+	bool success = false;
+	HRESULT hr;
+
+	IDXGIDevice* dxgiDevice = NULL;
+	IDXGIAdapter* dxgiAdapter = NULL;
+	IDXGIFactory* dxgiFactory = NULL;
+	hr = g_pd3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice);
+	if (FAILED(hr)) goto postReset;
+	hr = dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter);
+	if (FAILED(hr)) { dxgiDevice->Release(); goto postReset; }
+	hr = dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory);
+	dxgiAdapter->Release();
+	dxgiDevice->Release();
+	if (FAILED(hr)) goto postReset;
+
+	// Create new swap chain at backbuffer size
+	{
+		DXGI_SWAP_CHAIN_DESC sd = {};
+		sd.BufferCount = 1;
+		sd.BufferDesc.Width = bbW;
+		sd.BufferDesc.Height = bbH;
+		sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+		sd.BufferDesc.RefreshRate.Numerator = 60;
+		sd.BufferDesc.RefreshRate.Denominator = 1;
+		sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
+		sd.OutputWindow = g_hWnd;
+		sd.SampleDesc.Count = 1;
+		sd.SampleDesc.Quality = 0;
+		sd.Windowed = TRUE;
+
+		IDXGISwapChain* pNewSwapChain = NULL;
+		hr = dxgiFactory->CreateSwapChain(g_pd3dDevice, &sd, &pNewSwapChain);
+		dxgiFactory->Release();
+		if (FAILED(hr) || pNewSwapChain == NULL)
+		{
+			app.DebugPrintf("[RESIZE] CreateSwapChain FAILED hr=0x%08X — keeping old swap chain\n", (unsigned)hr);
+			goto postReset;
+		}
+
+		// New swap chain created successfully — NOW destroy the old one.
+		// The Renderer's internal RTV/SRV still reference the old backbuffer —
+		// those COM objects become orphaned (tiny leak, harmless). We DON'T
+		// release them because unknown code may also hold refs.
+		pOldSwapChain->Release();
+		g_pSwapChain = pNewSwapChain;
+	}
+
+	// Patch Renderer's swap chain pointer
+	*ppRM_SC = g_pSwapChain;
+
+	// Create render target views from new backbuffer
+	{
+		ID3D11Texture2D* pBackBuffer = NULL;
+		hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
+		if (FAILED(hr)) goto postReset;
+
+		// Our RTV
+		hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView);
+		if (FAILED(hr)) { pBackBuffer->Release(); goto postReset; }
+
+		// Renderer's internal RTV (offset 0x28)
+		hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, ppRM_RTV);
+		if (FAILED(hr)) { pBackBuffer->Release(); goto postReset; }
+
+		// Renderer's SRV: separate texture matching backbuffer dims (used by CaptureThumbnail)
+		D3D11_TEXTURE2D_DESC backDesc = {};
+		pBackBuffer->GetDesc(&backDesc);
+		pBackBuffer->Release();
+
+		D3D11_TEXTURE2D_DESC srvDesc = backDesc;
+		srvDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
+		ID3D11Texture2D* srvTexture = NULL;
+		hr = g_pd3dDevice->CreateTexture2D(&srvDesc, NULL, &srvTexture);
+		if (SUCCEEDED(hr))
+		{
+			hr = g_pd3dDevice->CreateShaderResourceView(srvTexture, NULL, ppRM_SRV);
+			srvTexture->Release();
+		}
+		if (FAILED(hr)) goto postReset;
+	}
+
+	// Recreate depth stencil at backbuffer size
+	{
+		D3D11_TEXTURE2D_DESC descDepth = {};
+		descDepth.Width = bbW;
+		descDepth.Height = bbH;
+		descDepth.MipLevels = 1;
+		descDepth.ArraySize = 1;
+		descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
+		descDepth.SampleDesc.Count = 1;
+		descDepth.SampleDesc.Quality = 0;
+		descDepth.Usage = D3D11_USAGE_DEFAULT;
+		descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
+		hr = g_pd3dDevice->CreateTexture2D(&descDepth, NULL, &g_pDepthStencilBuffer);
+		if (FAILED(hr)) goto postReset;
+
+		D3D11_DEPTH_STENCIL_VIEW_DESC descDSView = {};
+		descDSView.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
+		descDSView.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
+		hr = g_pd3dDevice->CreateDepthStencilView(g_pDepthStencilBuffer, &descDSView, &g_pDepthStencilView);
+		if (FAILED(hr)) goto postReset;
+	}
+
+	// Patch Renderer's DSV (AddRef because both we and the Renderer reference it)
+	g_pDepthStencilView->AddRef();
+	*ppRM_DSV = g_pDepthStencilView;
+
+	// Update Renderer's cached backbuffer dimensions (StartFrame uses these for viewport)
+	if (bbDimsValid)
+	{
+		*pRM_BBWidth  = (DWORD)bbW;
+		*pRM_BBHeight = (DWORD)bbH;
+	}
+
+	// Rebind render targets and viewport
+	g_pImmediateContext->OMSetRenderTargets(1, &g_pRenderTargetView, g_pDepthStencilView);
+	{
+		D3D11_VIEWPORT vp = {};
+		vp.Width = (FLOAT)bbW;
+		vp.Height = (FLOAT)bbH;
+		vp.MinDepth = 0.0f;
+		vp.MaxDepth = 1.0f;
+		g_pImmediateContext->RSSetViewports(1, &vp);
+	}
+
+	ui.updateRenderTargets(g_pRenderTargetView, g_pDepthStencilView);
+	ui.updateScreenSize(bbW, bbH);
+
+	// Track actual backbuffer dimensions for the rest of the engine
+	g_rScreenWidth = bbW;
+	g_rScreenHeight = bbH;
+
+	success = true;
+
+postReset:
+	if (!success && g_pSwapChain != NULL)
+	{
+		// Failure recovery: recreate our views from whatever swap chain survived
+		// so ui.m_pRenderTargetView / m_pDepthStencilView don't dangle.
+		DXGI_SWAP_CHAIN_DESC recoveryDesc;
+		g_pSwapChain->GetDesc(&recoveryDesc);
+		int recW = (int)recoveryDesc.BufferDesc.Width;
+		int recH = (int)recoveryDesc.BufferDesc.Height;
+
+		if (g_pRenderTargetView == NULL)
+		{
+			ID3D11Texture2D* pBB = NULL;
+			if (SUCCEEDED(g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBB)))
+			{
+				g_pd3dDevice->CreateRenderTargetView(pBB, NULL, &g_pRenderTargetView);
+				pBB->Release();
+			}
+		}
+		if (g_pDepthStencilView == NULL)
+		{
+			D3D11_TEXTURE2D_DESC dd = {};
+			dd.Width = recW; dd.Height = recH; dd.MipLevels = 1; dd.ArraySize = 1;
+			dd.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
+			dd.SampleDesc.Count = 1; dd.Usage = D3D11_USAGE_DEFAULT;
+			dd.BindFlags = D3D11_BIND_DEPTH_STENCIL;
+			if (g_pDepthStencilBuffer == NULL)
+				g_pd3dDevice->CreateTexture2D(&dd, NULL, &g_pDepthStencilBuffer);
+			if (g_pDepthStencilBuffer != NULL)
+			{
+				D3D11_DEPTH_STENCIL_VIEW_DESC dsvd = {};
+				dsvd.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
+				dsvd.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
+				g_pd3dDevice->CreateDepthStencilView(g_pDepthStencilBuffer, &dsvd, &g_pDepthStencilView);
+			}
+		}
+		if (g_pRenderTargetView != NULL)
+			g_pImmediateContext->OMSetRenderTargets(1, &g_pRenderTargetView, g_pDepthStencilView);
+
+		ui.updateRenderTargets(g_pRenderTargetView, g_pDepthStencilView);
+
+		// If the surviving swap chain is the OLD one, dims are unchanged.
+		// If it's the NEW one (partial failure after swap), update to new dims.
+		if (g_pSwapChain != pOldSwapChain)
+		{
+			g_rScreenWidth = recW;
+			g_rScreenHeight = recH;
+			ui.updateScreenSize(recW, recH);
+		}
+
+		app.DebugPrintf("[RESIZE] FAILED but recovered views at %dx%d\n", g_rScreenWidth, g_rScreenHeight);
+	}
+
+	gdraw_D3D11_PostReset();
+	gdraw_D3D11_SetRendertargetSize(g_rScreenWidth, g_rScreenHeight);
+	if (success)
+		IggyFlushInstalledFonts();
+	RenderManager.Resume();
+
+	if (success)
+		PostProcesser::GetInstance().Init();
+
+	return success;
+}
+
+//--------------------------------------------------------------------------------------
 // Toggle borderless fullscreen
 //--------------------------------------------------------------------------------------
 void ToggleFullscreen()
 {
-	DWORD dwStyle = GetWindowLong(g_hWnd, GWL_STYLE);
+	const DWORD dwStyle = GetWindowLong(g_hWnd, GWL_STYLE);
 	if (!g_isFullscreen)
 	{
 		MONITORINFO mi = { sizeof(mi) };
@@ -922,7 +1208,7 @@ void ToggleFullscreen()
 	{
 		SetWindowLong(g_hWnd, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
 		SetWindowPlacement(g_hWnd, &g_wpPrev);
-		SetWindowPos(g_hWnd, NULL, 0, 0, 0, 0,
+		SetWindowPos(g_hWnd, nullptr, 0, 0, 0, 0,
 			SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
 	}
 	g_isFullscreen = !g_isFullscreen;
@@ -939,6 +1225,8 @@ void CleanupDevice()
 {
 	if( g_pImmediateContext ) g_pImmediateContext->ClearState();
 
+	if( g_pDepthStencilView ) g_pDepthStencilView->Release();
+	if( g_pDepthStencilBuffer ) g_pDepthStencilBuffer->Release();
 	if( g_pRenderTargetView ) g_pRenderTargetView->Release();
 	if( g_pSwapChain ) g_pSwapChain->Release();
 	if( g_pImmediateContext ) g_pImmediateContext->Release();
@@ -952,7 +1240,7 @@ static Minecraft* InitialiseMinecraftRuntime()
 	RenderManager.Initialise(g_pd3dDevice, g_pSwapChain);
 
 	app.loadStringTable();
-	ui.init(g_pd3dDevice, g_pImmediateContext, g_pRenderTargetView, g_pDepthStencilView, g_iScreenWidth, g_iScreenHeight);
+	ui.init(g_pd3dDevice, g_pImmediateContext, g_pRenderTargetView, g_pDepthStencilView, g_rScreenWidth, g_rScreenHeight);
 
 	InputManager.Initialise(1, 3, MINECRAFT_ACTION_MAX, ACTION_MAX_MENU);
 	g_KBMInput.Init();
@@ -975,7 +1263,7 @@ static Minecraft* InitialiseMinecraftRuntime()
 
 	for (int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; i++)
 	{
-		IQNet::m_player[i].m_smallId = (BYTE)i;
+		IQNet::m_player[i].m_smallId = static_cast<BYTE>(i);
 		IQNet::m_player[i].m_isRemote = false;
 		IQNet::m_player[i].m_isHostPlayer = (i == 0);
 		swprintf_s(IQNet::m_player[i].m_gamertag, 32, L"Player%d", i);
@@ -997,8 +1285,8 @@ static Minecraft* InitialiseMinecraftRuntime()
 
 	Minecraft::main();
 	Minecraft* pMinecraft = Minecraft::GetInstance();
-	if (pMinecraft == NULL)
-		return NULL;
+	if (pMinecraft == nullptr)
+		return nullptr;
 
 	app.InitGameSettings();
 	app.InitialiseTips();
@@ -1006,161 +1294,6 @@ static Minecraft* InitialiseMinecraftRuntime()
 	return pMinecraft;
 }
 
-static int HeadlessServerConsoleThreadProc(void* lpParameter)
-{
-	UNREFERENCED_PARAMETER(lpParameter);
-
-	std::string line;
-	while (!app.m_bShutdown)
-	{
-		if (!std::getline(std::cin, line))
-		{
-			if (std::cin.eof())
-			{
-				break;
-			}
-
-			std::cin.clear();
-			Sleep(50);
-			continue;
-		}
-
-		wstring command = trimString(convStringToWstring(line));
-		if (command.empty())
-			continue;
-
-		MinecraftServer* server = MinecraftServer::getInstance();
-		if (server != NULL)
-		{
-			server->handleConsoleInput(command, server);
-		}
-	}
-
-	return 0;
-}
-
-static int RunHeadlessServer()
-{
-	SetupHeadlessServerConsole();
-
-	Settings serverSettings(new File(L"server.properties"));
-	wstring configuredBindIp = serverSettings.getString(L"server-ip", L"");
-
-	const char* bindIp = "*";
-	if (g_Win64DedicatedServerBindIP[0] != 0)
-	{
-		bindIp = g_Win64DedicatedServerBindIP;
-	}
-	else if (!configuredBindIp.empty())
-	{
-		bindIp = wstringtochararray(configuredBindIp);
-	}
-
-	const int port = g_Win64DedicatedServerPort > 0 ? g_Win64DedicatedServerPort : serverSettings.getInt(L"server-port", WIN64_NET_DEFAULT_PORT);
-
-	printf("Starting headless server on %s:%d\n", bindIp, port);
-	fflush(stdout);
-
-	Minecraft* pMinecraft = InitialiseMinecraftRuntime();
-	if (pMinecraft == NULL)
-	{
-		fprintf(stderr, "Failed to initialise the Minecraft runtime.\n");
-		return 1;
-	}
-
-	app.SetGameHostOption(eGameHostOption_Difficulty, serverSettings.getInt(L"difficulty", 1));
-	app.SetGameHostOption(eGameHostOption_Gamertags, 1);
-	app.SetGameHostOption(eGameHostOption_GameType, serverSettings.getInt(L"gamemode", 0));
-	app.SetGameHostOption(eGameHostOption_LevelType, 0);
-	app.SetGameHostOption(eGameHostOption_Structures, serverSettings.getBoolean(L"generate-structures", true) ? 1 : 0);
-	app.SetGameHostOption(eGameHostOption_BonusChest, serverSettings.getBoolean(L"bonus-chest", false) ? 1 : 0);
-	app.SetGameHostOption(eGameHostOption_PvP, serverSettings.getBoolean(L"pvp", true) ? 1 : 0);
-	app.SetGameHostOption(eGameHostOption_TrustPlayers, serverSettings.getBoolean(L"trust-players", true) ? 1 : 0);
-	app.SetGameHostOption(eGameHostOption_FireSpreads, serverSettings.getBoolean(L"fire-spreads", true) ? 1 : 0);
-	app.SetGameHostOption(eGameHostOption_TNT, serverSettings.getBoolean(L"tnt", true) ? 1 : 0);
-	app.SetGameHostOption(eGameHostOption_HostCanFly, 1);
-	app.SetGameHostOption(eGameHostOption_HostCanChangeHunger, 1);
-	app.SetGameHostOption(eGameHostOption_HostCanBeInvisible, 1);
-	app.SetGameHostOption(eGameHostOption_MobGriefing, 1);
-	app.SetGameHostOption(eGameHostOption_KeepInventory, 0);
-	app.SetGameHostOption(eGameHostOption_DoMobSpawning, 1);
-	app.SetGameHostOption(eGameHostOption_DoMobLoot, 1);
-	app.SetGameHostOption(eGameHostOption_DoTileDrops, 1);
-	app.SetGameHostOption(eGameHostOption_NaturalRegeneration, 1);
-	app.SetGameHostOption(eGameHostOption_DoDaylightCycle, 1);
-
-	MinecraftServer::resetFlags();
-	g_NetworkManager.HostGame(0, false, true, MINECRAFT_NET_MAX_PLAYERS, 0);
-
-	if (!WinsockNetLayer::IsActive())
-	{
-		fprintf(stderr, "Failed to bind the server socket on %s:%d.\n", bindIp, port);
-		return 1;
-	}
-
-	g_NetworkManager.FakeLocalPlayerJoined();
-
-	NetworkGameInitData* param = new NetworkGameInitData();
-	param->seed = 0;
-	param->settings = app.GetGameHostOption(eGameHostOption_All);
-
-	g_NetworkManager.ServerStoppedCreate(true);
-	g_NetworkManager.ServerReadyCreate(true);
-
-	C4JThread* thread = new C4JThread(&CGameNetworkManager::ServerThreadProc, param, "Server", 256 * 1024);
-	thread->SetProcessor(CPU_CORE_SERVER);
-	thread->Run();
-
-	g_NetworkManager.ServerReadyWait();
-	g_NetworkManager.ServerReadyDestroy();
-
-	if (MinecraftServer::serverHalted())
-	{
-		fprintf(stderr, "The server halted during startup.\n");
-		g_NetworkManager.LeaveGame(false);
-		return 1;
-	}
-
-	app.SetGameStarted(true);
-	g_NetworkManager.DoWork();
-
-	printf("Server ready on %s:%d\n", bindIp, port);
-	printf("Type 'help' for server commands.\n");
-	fflush(stdout);
-
-	C4JThread* consoleThread = new C4JThread(&HeadlessServerConsoleThreadProc, NULL, "Server console", 128 * 1024);
-	consoleThread->Run();
-
-	MSG msg = { 0 };
-	while (WM_QUIT != msg.message && !app.m_bShutdown && !MinecraftServer::serverHalted())
-	{
-		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
-		{
-			TranslateMessage(&msg);
-			DispatchMessage(&msg);
-			continue;
-		}
-
-		app.UpdateTime();
-		ProfileManager.Tick();
-		StorageManager.Tick();
-		RenderManager.Tick();
-		ui.tick();
-		g_NetworkManager.DoWork();
-		app.HandleXuiActions();
-
-		Sleep(10);
-	}
-
-	printf("Stopping server...\n");
-	fflush(stdout);
-
-	app.m_bShutdown = true;
-	MinecraftServer::HaltServer();
-	g_NetworkManager.LeaveGame(false);
-	return 0;
-}
-
 int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 					   _In_opt_ HINSTANCE hPrevInstance,
 					   _In_ LPTSTR    lpCmdLine,
@@ -1172,19 +1305,23 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 	// 4J-Win64: set CWD to exe dir so asset paths resolve correctly
 	{
 		char szExeDir[MAX_PATH] = {};
-		GetModuleFileNameA(NULL, szExeDir, MAX_PATH);
+		GetModuleFileNameA(nullptr, szExeDir, MAX_PATH);
 		char *pSlash = strrchr(szExeDir, '\\');
 		if (pSlash) { *(pSlash + 1) = '\0'; SetCurrentDirectoryA(szExeDir); }
 	}
 
 	// Declare DPI awareness so GetSystemMetrics returns physical pixels
 	SetProcessDPIAware();
-	g_iScreenWidth = GetSystemMetrics(SM_CXSCREEN);
-	g_iScreenHeight = GetSystemMetrics(SM_CYSCREEN);
+	// Use the native monitor resolution for the window and swap chain,
+	// but keep g_iScreenWidth/Height at 1920x1080 for logical resolution
+	// (SWF selection, ortho projection, game logic). The real window
+	// dimensions are tracked by g_rScreenWidth/g_rScreenHeight.
+	g_rScreenWidth = GetSystemMetrics(SM_CXSCREEN);
+	g_rScreenHeight = GetSystemMetrics(SM_CYSCREEN);
 
 	// Load username from username.txt
     char exePath[MAX_PATH] = {};
-    GetModuleFileNameA(NULL, exePath, MAX_PATH);
+    GetModuleFileNameA(nullptr, exePath, MAX_PATH);
     char *lastSlash = strrchr(exePath, '\\');
     if (lastSlash)
     {
@@ -1200,7 +1337,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
         char buf[128] = {};
         if (fgets(buf, sizeof(buf), f))
         {
-            int len = (int)strlen(buf);
+            int len = static_cast<int>(strlen(buf));
             while (len > 0 && (buf[len - 1] == '\n' || buf[len - 1] == '\r' || buf[len - 1] == ' '))
             {
                 buf[--len] = '\0';
@@ -1215,9 +1352,12 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
     }
 
 	// Load stuff from launch options, including username
-	Win64LaunchOptions launchOptions = ParseLaunchOptions();
+	const Win64LaunchOptions launchOptions = ParseLaunchOptions();
 	ApplyScreenMode(launchOptions.screenMode);
 
+	// Ensure uid.dat exists from startup (before any multiplayer/login path).
+	Win64Xuid::ResolvePersistentXuid();
+
 	// If no username, let's fall back
 	if (g_Win64Username[0] == 0)
 	{
@@ -1227,11 +1367,77 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 
 	MultiByteToWideChar(CP_ACP, 0, g_Win64Username, -1, g_Win64UsernameW, 17);
 
+	// convert servers.txt to servers.db
+	if (GetFileAttributesA("servers.txt") != INVALID_FILE_ATTRIBUTES &&
+		GetFileAttributesA("servers.db") == INVALID_FILE_ATTRIBUTES)
+	{
+		FILE* txtFile = nullptr;
+		if (fopen_s(&txtFile, "servers.txt", "r") == 0 && txtFile)
+		{
+			struct MigEntry { std::string ip; uint16_t port; std::string name; };
+			std::vector<MigEntry> migEntries;
+			char line[512];
+
+			while (fgets(line, sizeof(line), txtFile))
+			{
+				int l = (int)strlen(line);
+				while (l > 0 && (line[l - 1] == '\n' || line[l - 1] == '\r' || line[l - 1] == ' '))
+					line[--l] = '\0';
+				if (l == 0) continue;
+
+				std::string srvIP = line;
+
+				if (!fgets(line, sizeof(line), txtFile)) break;
+				l = (int)strlen(line);
+				while (l > 0 && (line[l - 1] == '\n' || line[l - 1] == '\r' || line[l - 1] == ' '))
+					line[--l] = '\0';
+				uint16_t srvPort = (uint16_t)atoi(line);
+
+				std::string srvName;
+				if (fgets(line, sizeof(line), txtFile))
+				{
+					l = (int)strlen(line);
+					while (l > 0 && (line[l - 1] == '\n' || line[l - 1] == '\r' || line[l - 1] == ' '))
+						line[--l] = '\0';
+					srvName = line;
+				}
+
+				if (!srvIP.empty() && srvPort > 0)
+					migEntries.push_back({srvIP, srvPort, srvName});
+			}
+			fclose(txtFile);
+
+			if (!migEntries.empty())
+			{
+				FILE* dbFile = nullptr;
+				if (fopen_s(&dbFile, "servers.db", "wb") == 0 && dbFile)
+				{
+					fwrite("MCSV", 1, 4, dbFile);
+					uint32_t ver = 1;
+					uint32_t cnt = (uint32_t)migEntries.size();
+					fwrite(&ver, sizeof(uint32_t), 1, dbFile);
+					fwrite(&cnt, sizeof(uint32_t), 1, dbFile);
+					for (size_t i = 0; i < migEntries.size(); i++)
+					{
+						uint16_t ipLen = (uint16_t)migEntries[i].ip.length();
+						fwrite(&ipLen, sizeof(uint16_t), 1, dbFile);
+						fwrite(migEntries[i].ip.c_str(), 1, ipLen, dbFile);
+						fwrite(&migEntries[i].port, sizeof(uint16_t), 1, dbFile);
+						uint16_t nameLen = (uint16_t)migEntries[i].name.length();
+						fwrite(&nameLen, sizeof(uint16_t), 1, dbFile);
+						fwrite(migEntries[i].name.c_str(), 1, nameLen, dbFile);
+					}
+					fclose(dbFile);
+				}
+			}
+		}
+	}
+
 	// Initialize global strings
 	MyRegisterClass(hInstance);
 
 	// Perform application initialization:
-	if (!InitInstance (hInstance, launchOptions.serverMode ? SW_HIDE : nCmdShow))
+	if (!InitInstance (hInstance, nCmdShow))
 	{
 		return FALSE;
 	}
@@ -1245,24 +1451,17 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 	}
 
 	// Restore fullscreen state from previous session
-	if (LoadFullscreenOption() && !g_isFullscreen)
+	if (LoadFullscreenOption() && !g_isFullscreen || launchOptions.fullscreen)
 	{
 		ToggleFullscreen();
 	}
 
-	if (launchOptions.serverMode)
-	{
-		int serverResult = RunHeadlessServer();
-		CleanupDevice();
-		return serverResult;
-	}
-
 #if 0
 	// Main message loop
 	MSG msg = {0};
 	while( WM_QUIT != msg.message )
 	{
-		if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
+		if( PeekMessage( &msg, nullptr, 0, 0, PM_REMOVE ) )
 		{
 			TranslateMessage( &msg );
 			DispatchMessage( &msg );
@@ -1310,11 +1509,12 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 
 #endif
 	Minecraft *pMinecraft = InitialiseMinecraftRuntime();
-	if (pMinecraft == NULL)
+	if (pMinecraft == nullptr)
 	{
 		CleanupDevice();
 		return 1;
 	}
+	g_bResizeReady = true;
 
 	//app.TemporaryCreateGameStart();
 
@@ -1346,7 +1546,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 	{
 		g_KBMInput.Tick();
 
-		while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
+		while( PeekMessage( &msg, nullptr, 0, 0, PM_REMOVE ) )
 		{
 			TranslateMessage( &msg );
 			DispatchMessage( &msg );
@@ -1354,6 +1554,14 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		}
 		if (msg.message == WM_QUIT) break;
 
+		// When the window is minimized (e.g. "Show Desktop"), skip rendering entirely
+		// to avoid pegging the GPU at 100% presenting to a non-visible swap chain.
+		if (IsIconic(g_hWnd))
+		{
+			Sleep(100);
+			continue;
+		}
+
 		RenderManager.StartFrame();
 #if 0
 		if(pMinecraft->soundEngine->isStreamingWavebankReady() &&
@@ -1379,7 +1587,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		// Detect KBM vs controller input mode
 		if (InputManager.IsPadConnected(0))
 		{
-			bool controllerUsed = InputManager.ButtonPressed(0) ||
+			const bool controllerUsed = InputManager.ButtonPressed(0) ||
 				InputManager.GetJoypadStick_LX(0, false) != 0.0f ||
 				InputManager.GetJoypadStick_LY(0, false) != 0.0f ||
 				InputManager.GetJoypadStick_RX(0, false) != 0.0f ||
@@ -1441,7 +1649,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		else
 		{
 			MemSect(28);
-			pMinecraft->soundEngine->tick(NULL, 0.0f);
+			pMinecraft->soundEngine->tick(nullptr, 0.0f);
 			MemSect(0);
 			pMinecraft->textures->tick(true,false);
 			IntCache::Reset();
@@ -1488,6 +1696,9 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 #endif
 		ui.tick();
 		ui.render();
+
+		pMinecraft->gameRenderer->ApplyGammaPostProcess();
+
 #if 0
 		app.HandleButtonPresses();
 
@@ -1535,7 +1746,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		// Update mouse grab: grab when in-game and no menu is open
 		{
 			static bool altToggleSuppressCapture = false;
-			bool shouldCapture = app.GetGameStarted() && !ui.GetMenuDisplayed(0) && pMinecraft->screen == NULL;
+			const bool shouldCapture = app.GetGameStarted() && !ui.GetMenuDisplayed(0) && pMinecraft->screen == nullptr;
 			// Left Alt key toggles capture on/off for debugging
 			if (g_KBMInput.IsKeyPressed(VK_LMENU) || g_KBMInput.IsKeyPressed(VK_RMENU))
 			{
@@ -1554,18 +1765,18 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 		}
 
 		// F1 toggles the HUD
-		if (g_KBMInput.IsKeyPressed(VK_F1))
+		if (g_KBMInput.IsKeyPressed(KeyboardMouseInput::KEY_TOGGLE_HUD))
 		{
-			int primaryPad = ProfileManager.GetPrimaryPad();
-			unsigned char displayHud = app.GetGameSettings(primaryPad, eGameSetting_DisplayHUD);
+			const int primaryPad = ProfileManager.GetPrimaryPad();
+			const unsigned char displayHud = app.GetGameSettings(primaryPad, eGameSetting_DisplayHUD);
 			app.SetGameSettings(primaryPad, eGameSetting_DisplayHUD, displayHud ? 0 : 1);
 			app.SetGameSettings(primaryPad, eGameSetting_DisplayHand, displayHud ? 0 : 1);
 		}
 
 		// F3 toggles onscreen debug info
-		if (g_KBMInput.IsKeyPressed(VK_F3))
+		if (g_KBMInput.IsKeyPressed(KeyboardMouseInput::KEY_DEBUG_INFO))
 		{
-			if (Minecraft* pMinecraft = Minecraft::GetInstance())
+			if (const Minecraft* pMinecraft = Minecraft::GetInstance())
 			{
 				if (pMinecraft->options)
 				{
@@ -1576,7 +1787,7 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 
 #ifdef _DEBUG_MENUS_ENABLED
         // F6 Open debug console
-        if (g_KBMInput.IsKeyPressed(VK_F6))
+        if (g_KBMInput.IsKeyPressed(KeyboardMouseInput::KEY_DEBUG_CONSOLE))
         {
         	static bool s_debugConsole = false;
         	s_debugConsole = !s_debugConsole;
@@ -1584,14 +1795,14 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
         }
 #endif
 
-		// F11 Toggle fullscreen
-		if (g_KBMInput.IsKeyPressed(VK_F11))
+		// toggle fullscreen
+		if (g_KBMInput.IsKeyPressed(KeyboardMouseInput::KEY_FULLSCREEN))
 		{
 			ToggleFullscreen();
 		}
 
 		// TAB opens game info menu. - Vvis :3 - Updated by detectiveren
-		if (g_KBMInput.IsKeyPressed(VK_TAB) && !ui.GetMenuDisplayed(0))
+		if (g_KBMInput.IsKeyPressed(KeyboardMouseInput::KEY_HOST_SETTINGS) && !ui.GetMenuDisplayed(0))
 		{
 			if (Minecraft* pMinecraft = Minecraft::GetInstance())
 			{
@@ -1602,6 +1813,14 @@ int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
 			}
 		}
 
+		// Open chat
+		if (g_KBMInput.IsKeyPressed(KeyboardMouseInput::KEY_CHAT) && app.GetGameStarted() && !ui.GetMenuDisplayed(0) && pMinecraft->screen == NULL)
+		{
+			g_KBMInput.ClearCharBuffer();
+			pMinecraft->setScreen(new ChatScreen());
+			SetFocus(g_hWnd);
+		}
+
 #if 0
 		// has the game defined profile data been changed (by a profile load)
 		if(app.uiGameDefinedDataChangedBitmask!=0)
diff --git a/Minecraft.Client/Windows64/Windows64_UIController.cpp b/Minecraft.Client/Windows64/Windows64_UIController.cpp
index 10ae20af..3929aa04 100644
--- a/Minecraft.Client/Windows64/Windows64_UIController.cpp
+++ b/Minecraft.Client/Windows64/Windows64_UIController.cpp
@@ -82,7 +82,7 @@ void ConsoleUIController::render()
 	example, no resolve targets are required. */
 	gdraw_D3D11_SetTileOrigin( m_pRenderTargetView,
 		m_pDepthStencilView,
-		NULL,
+		nullptr,
 		0,
 		0 );
 
@@ -143,11 +143,17 @@ void ConsoleUIController::endCustomDraw(IggyCustomDrawCallbackRegion *region)
 	PIXEndNamedEvent();
 }
 
+void ConsoleUIController::updateRenderTargets(ID3D11RenderTargetView* rtv, ID3D11DepthStencilView* dsv)
+{
+	m_pRenderTargetView = rtv;
+	m_pDepthStencilView = dsv;
+}
+
 void ConsoleUIController::setTileOrigin(S32 xPos, S32 yPos)
 {
 	gdraw_D3D11_SetTileOrigin( m_pRenderTargetView,
 		m_pDepthStencilView,
-		NULL,
+		nullptr,
 		xPos,
 		yPos );
 }
@@ -163,7 +169,7 @@ GDrawTexture *ConsoleUIController::getSubstitutionTexture(int textureId)
 	ID3D11ShaderResourceView *tex = RenderManager.TextureGetTexture(textureId);
 	ID3D11Resource *resource;
 	tex->GetResource(&resource);
-	ID3D11Texture2D  *tex2d = (ID3D11Texture2D *)resource;
+	ID3D11Texture2D  *tex2d = static_cast<ID3D11Texture2D *>(resource);
 	D3D11_TEXTURE2D_DESC desc;
 	tex2d->GetDesc(&desc);
 	GDrawTexture *gdrawTex = gdraw_D3D11_WrappedTextureCreate(tex);
diff --git a/Minecraft.Client/Windows64/Windows64_UIController.h b/Minecraft.Client/Windows64/Windows64_UIController.h
index 2b2ccdba..398e9712 100644
--- a/Minecraft.Client/Windows64/Windows64_UIController.h
+++ b/Minecraft.Client/Windows64/Windows64_UIController.h
@@ -16,15 +16,15 @@ public:
 	virtual CustomDrawData *calculateCustomDraw(IggyCustomDrawCallbackRegion *region);
 	virtual void endCustomDraw(IggyCustomDrawCallbackRegion *region);
 
+	void updateRenderTargets(ID3D11RenderTargetView* rtv, ID3D11DepthStencilView* dsv);
+
 protected:
 	virtual void setTileOrigin(S32 xPos, S32 yPos);
 
-public:	
+public:
 	GDrawTexture *getSubstitutionTexture(int textureId);
 	void destroySubstitutionTexture(void *destroyCallBackData, GDrawTexture *handle);
 
 public:
 	void shutdown();
 };
-
-extern ConsoleUIController ui;
\ No newline at end of file
diff --git a/Minecraft.Client/Windows64/Windows64_Xuid.h b/Minecraft.Client/Windows64/Windows64_Xuid.h
new file mode 100644
index 00000000..f5fd62b9
--- /dev/null
+++ b/Minecraft.Client/Windows64/Windows64_Xuid.h
@@ -0,0 +1,237 @@
+#pragma once
+
+#ifdef _WINDOWS64
+
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+#include <cerrno>
+#include <cstring>
+#include <Windows.h>
+
+namespace Win64Xuid
+{
+	inline PlayerUID GetLegacyEmbeddedBaseXuid()
+	{
+		return (PlayerUID)0xe000d45248242f2eULL;
+	}
+
+	inline PlayerUID GetLegacyEmbeddedHostXuid()
+	{
+		// Legacy behavior used "embedded base + smallId"; host was always smallId 0.
+		// We intentionally keep this value for host/self compatibility with pre-migration worlds.
+		return GetLegacyEmbeddedBaseXuid();
+	}
+
+	inline bool IsLegacyEmbeddedRange(PlayerUID xuid)
+	{
+		// Old Win64 XUIDs were not persistent and always lived in this narrow base+smallId range.
+		// Treat them as legacy/non-persistent so uid.dat values never collide with old slot IDs.
+		const PlayerUID base = GetLegacyEmbeddedBaseXuid();
+		return xuid >= base && xuid < (base + MINECRAFT_NET_MAX_PLAYERS);
+	}
+
+	inline bool IsPersistedUidValid(PlayerUID xuid)
+	{
+		return xuid != INVALID_XUID && !IsLegacyEmbeddedRange(xuid);
+	}
+
+
+	// ./uid.dat
+	inline bool BuildUidFilePath(char* outPath, size_t outPathSize)
+	{
+		if (outPath == NULL || outPathSize == 0)
+			return false;
+
+		outPath[0] = 0;
+
+		char exePath[MAX_PATH] = {};
+		DWORD len = GetModuleFileNameA(NULL, exePath, MAX_PATH);
+		if (len == 0 || len >= MAX_PATH)
+			return false;
+
+		char* lastSlash = strrchr(exePath, '\\');
+		if (lastSlash != NULL)
+		{
+			*(lastSlash + 1) = 0;
+		}
+
+		if (strcpy_s(outPath, outPathSize, exePath) != 0)
+			return false;
+		if (strcat_s(outPath, outPathSize, "uid.dat") != 0)
+			return false;
+
+		return true;
+	}
+
+	inline bool ReadUid(PlayerUID* outXuid)
+	{
+		if (outXuid == NULL)
+			return false;
+
+		char path[MAX_PATH] = {};
+		if (!BuildUidFilePath(path, MAX_PATH))
+			return false;
+
+		FILE* f = NULL;
+		if (fopen_s(&f, path, "rb") != 0 || f == NULL)
+			return false;
+
+		char buffer[128] = {};
+		size_t readBytes = fread(buffer, 1, sizeof(buffer) - 1, f);
+		fclose(f);
+
+		if (readBytes == 0)
+			return false;
+
+		// Compatibility: earlier experiments may have written raw 8-byte uid.dat.
+		if (readBytes == sizeof(uint64_t))
+		{
+			uint64_t raw = 0;
+			memcpy(&raw, buffer, sizeof(raw));
+			PlayerUID parsed = (PlayerUID)raw;
+			if (IsPersistedUidValid(parsed))
+			{
+				*outXuid = parsed;
+				return true;
+			}
+		}
+
+		buffer[readBytes] = 0;
+		char* begin = buffer;
+		while (*begin == ' ' || *begin == '\t' || *begin == '\r' || *begin == '\n')
+		{
+			++begin;
+		}
+
+		errno = 0;
+		char* end = NULL;
+		uint64_t raw = _strtoui64(begin, &end, 0);
+		if (begin == end || errno != 0)
+			return false;
+
+		while (*end == ' ' || *end == '\t' || *end == '\r' || *end == '\n')
+		{
+			++end;
+		}
+		if (*end != 0)
+			return false;
+
+		PlayerUID parsed = (PlayerUID)raw;
+		if (!IsPersistedUidValid(parsed))
+			return false;
+
+		*outXuid = parsed;
+		return true;
+	}
+
+	inline bool WriteUid(PlayerUID xuid)
+	{
+		char path[MAX_PATH] = {};
+		if (!BuildUidFilePath(path, MAX_PATH))
+			return false;
+
+		FILE* f = NULL;
+		if (fopen_s(&f, path, "wb") != 0 || f == NULL)
+			return false;
+
+		int written = fprintf_s(f, "0x%016llX\n", (unsigned long long)xuid);
+		fclose(f);
+		return written > 0;
+	}
+
+	inline uint64_t Mix64(uint64_t x)
+	{
+		x += 0x9E3779B97F4A7C15ULL;
+		x = (x ^ (x >> 30)) * 0xBF58476D1CE4E5B9ULL;
+		x = (x ^ (x >> 27)) * 0x94D049BB133111EBULL;
+		return x ^ (x >> 31);
+	}
+
+	inline PlayerUID GeneratePersistentUid()
+	{
+		// Avoid rand_s dependency: mix several Win64 runtime values into a 64-bit seed.
+		FILETIME ft = {};
+		GetSystemTimeAsFileTime(&ft);
+		uint64_t t = (((uint64_t)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+
+		LARGE_INTEGER qpc = {};
+		QueryPerformanceCounter(&qpc);
+
+		uint64_t seed = t;
+		seed ^= (uint64_t)qpc.QuadPart;
+		seed ^= ((uint64_t)GetCurrentProcessId() << 32);
+		seed ^= (uint64_t)GetCurrentThreadId();
+		seed ^= (uint64_t)GetTickCount();
+		seed ^= (uint64_t)(size_t)&qpc;
+		seed ^= (uint64_t)(size_t)GetModuleHandleA(NULL);
+
+		uint64_t raw = Mix64(seed) ^ Mix64(seed + 0xA0761D6478BD642FULL);
+		raw ^= 0x8F4B2D6C1A93E705ULL;
+		raw |= 0x8000000000000000ULL;
+
+		PlayerUID xuid = (PlayerUID)raw;
+		if (!IsPersistedUidValid(xuid))
+		{
+			raw ^= 0x0100000000000001ULL;
+			xuid = (PlayerUID)raw;
+		}
+
+		if (!IsPersistedUidValid(xuid))
+		{
+			// Last-resort deterministic fallback for pathological cases.
+			xuid = (PlayerUID)0xD15EA5E000000001ULL;
+		}
+
+		return xuid;
+	}
+
+	inline PlayerUID DeriveXuidForPad(PlayerUID baseXuid, int iPad)
+	{
+		if (iPad == 0)
+			return baseXuid;
+
+		// Deterministic per-pad XUID: hash the base XUID with the pad number.
+		// Produces a fully unique 64-bit value with no risk of overlap.
+		// Suggested by rtm516 to avoid adjacent-integer collisions from the old "+ iPad" approach.
+		uint64_t raw = Mix64((uint64_t)baseXuid + (uint64_t)iPad);
+		raw |= 0x8000000000000000ULL; // keep high bit set like all our XUIDs
+
+		PlayerUID xuid = (PlayerUID)raw;
+		if (!IsPersistedUidValid(xuid))
+		{
+			raw ^= 0x0100000000000001ULL;
+			xuid = (PlayerUID)raw;
+		}
+		if (!IsPersistedUidValid(xuid))
+			xuid = (PlayerUID)(0xD15EA5E000000001ULL + iPad);
+
+		return xuid;
+	}
+
+	inline PlayerUID ResolvePersistentXuid()
+	{
+		// Process-local cache: uid.dat is immutable during runtime and this path is hot.
+		static bool s_cached = false;
+		static PlayerUID s_xuid = INVALID_XUID;
+
+		if (s_cached)
+			return s_xuid;
+
+		PlayerUID fileXuid = INVALID_XUID;
+		if (ReadUid(&fileXuid))
+		{
+			s_xuid = fileXuid;
+			s_cached = true;
+			return s_xuid;
+		}
+
+		// First launch on this client: generate once and persist to uid.dat.
+		s_xuid = GeneratePersistentUid();
+		WriteUid(s_xuid);
+		s_cached = true;
+		return s_xuid;
+	}
+}
+
+#endif
diff --git a/Minecraft.Client/Windows64/XML/ATGXmlParser.h b/Minecraft.Client/Windows64/XML/ATGXmlParser.h
index 75142e3e..12f59737 100644
--- a/Minecraft.Client/Windows64/XML/ATGXmlParser.h
+++ b/Minecraft.Client/Windows64/XML/ATGXmlParser.h
@@ -138,7 +138,7 @@ private:
     DWORD           m_dwCharsTotal;
     DWORD           m_dwCharsConsumed;
 
-    BYTE            m_pReadBuf[ XML_READ_BUFFER_SIZE + 2 ]; // room for a trailing NULL
+    BYTE            m_pReadBuf[ XML_READ_BUFFER_SIZE + 2 ]; // room for a trailing nullptr
     WCHAR           m_pWriteBuf[ XML_WRITE_BUFFER_SIZE ];    
 
     BYTE*           m_pReadPtr;