clang-modernize -use-nullptr

and s/\bNULL\b/nullptr/g for *.cpp/h/mm files not compiled on my machine

45 files changed, 332 insertions, 332 deletions

diff --git a/Source/Core/VideoBackends/D3D/D3DBase.cpp b/Source/Core/VideoBackends/D3D/D3DBase.cpp
index 4575d47f37..4efacfa689 100644
--- a/Source/Core/VideoBackends/D3D/D3DBase.cpp
+++ b/Source/Core/VideoBackends/D3D/D3DBase.cpp
@@ -11,29 +11,29 @@
 namespace DX11
 {
 
-HINSTANCE hD3DCompilerDll = NULL;
-D3DREFLECT PD3DReflect = NULL;
-pD3DCompile PD3DCompile = NULL;
+HINSTANCE hD3DCompilerDll = nullptr;
+D3DREFLECT PD3DReflect = nullptr;
+pD3DCompile PD3DCompile = nullptr;
 int d3dcompiler_dll_ref = 0;
 
-CREATEDXGIFACTORY PCreateDXGIFactory = NULL;
-HINSTANCE hDXGIDll = NULL;
+CREATEDXGIFACTORY PCreateDXGIFactory = nullptr;
+HINSTANCE hDXGIDll = nullptr;
 int dxgi_dll_ref = 0;
 
 typedef HRESULT (WINAPI* D3D11CREATEDEVICEANDSWAPCHAIN)(IDXGIAdapter*, D3D_DRIVER_TYPE, HMODULE, UINT, CONST D3D_FEATURE_LEVEL*, UINT, UINT, CONST DXGI_SWAP_CHAIN_DESC*, IDXGISwapChain**, ID3D11Device**, D3D_FEATURE_LEVEL*, ID3D11DeviceContext**);
-D3D11CREATEDEVICE PD3D11CreateDevice = NULL;
-D3D11CREATEDEVICEANDSWAPCHAIN PD3D11CreateDeviceAndSwapChain = NULL;
-HINSTANCE hD3DDll = NULL;
+D3D11CREATEDEVICE PD3D11CreateDevice = nullptr;
+D3D11CREATEDEVICEANDSWAPCHAIN PD3D11CreateDeviceAndSwapChain = nullptr;
+HINSTANCE hD3DDll = nullptr;
 int d3d_dll_ref = 0;
 
 namespace D3D
 {
 
-ID3D11Device* device = NULL;
-ID3D11DeviceContext* context = NULL;
-IDXGISwapChain* swapchain = NULL;
+ID3D11Device* device = nullptr;
+ID3D11DeviceContext* context = nullptr;
+IDXGISwapChain* swapchain = nullptr;
 D3D_FEATURE_LEVEL featlevel;
-D3DTexture2D* backbuf = NULL;
+D3DTexture2D* backbuf = nullptr;
 HWND hWnd;
 
 std::vector<DXGI_SAMPLE_DESC> aa_modes; // supported AA modes of the current adapter
@@ -59,12 +59,12 @@ HRESULT LoadDXGI()
 	hDXGIDll = LoadLibraryA("dxgi.dll");
 	if (!hDXGIDll)
 	{
-		MessageBoxA(NULL, "Failed to load dxgi.dll", "Critical error", MB_OK | MB_ICONERROR);
+		MessageBoxA(nullptr, "Failed to load dxgi.dll", "Critical error", MB_OK | MB_ICONERROR);
 		--dxgi_dll_ref;
 		return E_FAIL;
 	}
 	PCreateDXGIFactory = (CREATEDXGIFACTORY)GetProcAddress(hDXGIDll, "CreateDXGIFactory");
-	if (PCreateDXGIFactory == NULL) MessageBoxA(NULL, "GetProcAddress failed for CreateDXGIFactory!", "Critical error", MB_OK | MB_ICONERROR);
+	if (PCreateDXGIFactory == nullptr) MessageBoxA(nullptr, "GetProcAddress failed for CreateDXGIFactory!", "Critical error", MB_OK | MB_ICONERROR);
 
 	return S_OK;
 }
@@ -77,15 +77,15 @@ HRESULT LoadD3D()
 	hD3DDll = LoadLibraryA("d3d11.dll");
 	if (!hD3DDll)
 	{
-		MessageBoxA(NULL, "Failed to load d3d11.dll", "Critical error", MB_OK | MB_ICONERROR);
+		MessageBoxA(nullptr, "Failed to load d3d11.dll", "Critical error", MB_OK | MB_ICONERROR);
 		--d3d_dll_ref;
 		return E_FAIL;
 	}
 	PD3D11CreateDevice = (D3D11CREATEDEVICE)GetProcAddress(hD3DDll, "D3D11CreateDevice");
-	if (PD3D11CreateDevice == NULL) MessageBoxA(NULL, "GetProcAddress failed for D3D11CreateDevice!", "Critical error", MB_OK | MB_ICONERROR);
+	if (PD3D11CreateDevice == nullptr) MessageBoxA(nullptr, "GetProcAddress failed for D3D11CreateDevice!", "Critical error", MB_OK | MB_ICONERROR);
 
 	PD3D11CreateDeviceAndSwapChain = (D3D11CREATEDEVICEANDSWAPCHAIN)GetProcAddress(hD3DDll, "D3D11CreateDeviceAndSwapChain");
-	if (PD3D11CreateDeviceAndSwapChain == NULL) MessageBoxA(NULL, "GetProcAddress failed for D3D11CreateDeviceAndSwapChain!", "Critical error", MB_OK | MB_ICONERROR);
+	if (PD3D11CreateDeviceAndSwapChain == nullptr) MessageBoxA(nullptr, "GetProcAddress failed for D3D11CreateDeviceAndSwapChain!", "Critical error", MB_OK | MB_ICONERROR);
 
 	return S_OK;
 }
@@ -104,7 +104,7 @@ HRESULT LoadD3DCompiler()
 		hD3DCompilerDll = LoadLibraryA("D3DCompiler_42.dll");
 		if (!hD3DCompilerDll)
 		{
-			MessageBoxA(NULL, "Failed to load D3DCompiler_42.dll, update your DX11 runtime, please", "Critical error", MB_OK | MB_ICONERROR);
+			MessageBoxA(nullptr, "Failed to load D3DCompiler_42.dll, update your DX11 runtime, please", "Critical error", MB_OK | MB_ICONERROR);
 			return E_FAIL;
 		}
 		else
@@ -114,9 +114,9 @@ HRESULT LoadD3DCompiler()
 	}
 
 	PD3DReflect = (D3DREFLECT)GetProcAddress(hD3DCompilerDll, "D3DReflect");
-	if (PD3DReflect == NULL) MessageBoxA(NULL, "GetProcAddress failed for D3DReflect!", "Critical error", MB_OK | MB_ICONERROR);
+	if (PD3DReflect == nullptr) MessageBoxA(nullptr, "GetProcAddress failed for D3DReflect!", "Critical error", MB_OK | MB_ICONERROR);
 	PD3DCompile = (pD3DCompile)GetProcAddress(hD3DCompilerDll, "D3DCompile");
-	if (PD3DCompile == NULL) MessageBoxA(NULL, "GetProcAddress failed for D3DCompile!", "Critical error", MB_OK | MB_ICONERROR);
+	if (PD3DCompile == nullptr) MessageBoxA(nullptr, "GetProcAddress failed for D3DCompile!", "Critical error", MB_OK | MB_ICONERROR);
 
 	return S_OK;
 }
@@ -127,8 +127,8 @@ void UnloadDXGI()
 	if (--dxgi_dll_ref != 0) return;
 
 	if(hDXGIDll) FreeLibrary(hDXGIDll);
-	hDXGIDll = NULL;
-	PCreateDXGIFactory = NULL;
+	hDXGIDll = nullptr;
+	PCreateDXGIFactory = nullptr;
 }
 
 void UnloadD3D()
@@ -137,9 +137,9 @@ void UnloadD3D()
 	if (--d3d_dll_ref != 0) return;
 
 	if(hD3DDll) FreeLibrary(hD3DDll);
-	hD3DDll = NULL;
-	PD3D11CreateDevice = NULL;
-	PD3D11CreateDeviceAndSwapChain = NULL;
+	hD3DDll = nullptr;
+	PD3D11CreateDevice = nullptr;
+	PD3D11CreateDeviceAndSwapChain = nullptr;
 }
 
 void UnloadD3DCompiler()
@@ -148,8 +148,8 @@ void UnloadD3DCompiler()
 	if (--d3dcompiler_dll_ref != 0) return;
 
 	if (hD3DCompilerDll) FreeLibrary(hD3DCompilerDll);
-	hD3DCompilerDll = NULL;
-	PD3DReflect = NULL;
+	hD3DCompilerDll = nullptr;
+	PD3DReflect = nullptr;
 }
 
 std::vector<DXGI_SAMPLE_DESC> EnumAAModes(IDXGIAdapter* adapter)
@@ -161,7 +161,7 @@ std::vector<DXGI_SAMPLE_DESC> EnumAAModes(IDXGIAdapter* adapter)
 	ID3D11Device* device;
 	ID3D11DeviceContext* context;
 	D3D_FEATURE_LEVEL feat_level;
-	HRESULT hr = PD3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, D3D11_CREATE_DEVICE_SINGLETHREADED, supported_feature_levels, NUM_SUPPORTED_FEATURE_LEVELS, D3D11_SDK_VERSION, &device, &feat_level, &context);
+	HRESULT hr = PD3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, D3D11_CREATE_DEVICE_SINGLETHREADED, supported_feature_levels, NUM_SUPPORTED_FEATURE_LEVELS, D3D11_SDK_VERSION, &device, &feat_level, &context);
 	if (FAILED(hr) || feat_level == D3D_FEATURE_LEVEL_10_0)
 	{
 		DXGI_SAMPLE_DESC desc;
@@ -193,7 +193,7 @@ std::vector<DXGI_SAMPLE_DESC> EnumAAModes(IDXGIAdapter* adapter)
 D3D_FEATURE_LEVEL GetFeatureLevel(IDXGIAdapter* adapter)
 {
 	D3D_FEATURE_LEVEL feat_level = D3D_FEATURE_LEVEL_9_1;
-	PD3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, D3D11_CREATE_DEVICE_SINGLETHREADED, supported_feature_levels, NUM_SUPPORTED_FEATURE_LEVELS, D3D11_SDK_VERSION, NULL, &feat_level, NULL);
+	PD3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, D3D11_CREATE_DEVICE_SINGLETHREADED, supported_feature_levels, NUM_SUPPORTED_FEATURE_LEVELS, D3D11_SDK_VERSION, nullptr, &feat_level, nullptr);
 	return feat_level;
 }
 
@@ -269,7 +269,7 @@ HRESULT Create(HWND wnd)
 	mode_desc.Height = yres;
 	mode_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
 	mode_desc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
-	hr = output->FindClosestMatchingMode(&mode_desc, &swap_chain_desc.BufferDesc, NULL);
+	hr = output->FindClosestMatchingMode(&mode_desc, &swap_chain_desc.BufferDesc, nullptr);
 	if (FAILED(hr)) MessageBox(wnd, _T("Failed to find a supported video mode"), _T("Dolphin Direct3D 11 backend"), MB_OK | MB_ICONERROR);
 
 	// forcing buffer resolution to xres and yres.. TODO: The new video mode might not actually be supported!
@@ -280,7 +280,7 @@ HRESULT Create(HWND wnd)
 	// Creating debug devices can sometimes fail if the user doesn't have the correct
 	// version of the DirectX SDK. If it does, simply fallback to a non-debug device.
 	{
-		hr = PD3D11CreateDeviceAndSwapChain(adapter, D3D_DRIVER_TYPE_UNKNOWN, NULL,
+		hr = PD3D11CreateDeviceAndSwapChain(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr,
 											D3D11_CREATE_DEVICE_SINGLETHREADED | D3D11_CREATE_DEVICE_DEBUG,
 											supported_feature_levels, NUM_SUPPORTED_FEATURE_LEVELS,
 											D3D11_SDK_VERSION, &swap_chain_desc, &swapchain, &device,
@@ -290,7 +290,7 @@ HRESULT Create(HWND wnd)
 	if (FAILED(hr))
 #endif
 	{
-		hr = PD3D11CreateDeviceAndSwapChain(adapter, D3D_DRIVER_TYPE_UNKNOWN, NULL,
+		hr = PD3D11CreateDeviceAndSwapChain(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr,
 											D3D11_CREATE_DEVICE_SINGLETHREADED,
 											supported_feature_levels, NUM_SUPPORTED_FEATURE_LEVELS,
 											D3D11_SDK_VERSION, &swap_chain_desc, &swapchain, &device,
@@ -322,11 +322,11 @@ HRESULT Create(HWND wnd)
 	}
 	backbuf = new D3DTexture2D(buf, D3D11_BIND_RENDER_TARGET);
 	SAFE_RELEASE(buf);
-	CHECK(backbuf!=NULL, "Create back buffer texture");
+	CHECK(backbuf!=nullptr, "Create back buffer texture");
 	SetDebugObjectName((ID3D11DeviceChild*)backbuf->GetTex(), "backbuffer texture");
 	SetDebugObjectName((ID3D11DeviceChild*)backbuf->GetRTV(), "backbuffer render target view");
 
-	context->OMSetRenderTargets(1, &backbuf->GetRTV(), NULL);
+	context->OMSetRenderTargets(1, &backbuf->GetRTV(), nullptr);
 
 	// BGRA textures are easier to deal with in TextureCache, but might not be supported by the hardware
 	UINT format_support;
@@ -356,7 +356,7 @@ void Close()
 	{
 		NOTICE_LOG(VIDEO, "Successfully released all device references!");
 	}
-	device = NULL;
+	device = nullptr;
 
 	// unload DLLs
 	UnloadD3D();
@@ -439,7 +439,7 @@ void Reset()
 	}
 	backbuf = new D3DTexture2D(buf, D3D11_BIND_RENDER_TARGET);
 	SAFE_RELEASE(buf);
-	CHECK(backbuf!=NULL, "Create back buffer texture");
+	CHECK(backbuf!=nullptr, "Create back buffer texture");
 	SetDebugObjectName((ID3D11DeviceChild*)backbuf->GetTex(), "backbuffer texture");
 	SetDebugObjectName((ID3D11DeviceChild*)backbuf->GetRTV(), "backbuffer render target view");
 }
@@ -452,7 +452,7 @@ bool BeginFrame()
 		return false;
 	}
 	bFrameInProgress = true;
-	return (device != NULL);
+	return (device != nullptr);
 }
 
 void EndFrame()
diff --git a/Source/Core/VideoBackends/D3D/D3DBase.h b/Source/Core/VideoBackends/D3D/D3DBase.h
index 457b62d8d9..f4f364bb89 100644
--- a/Source/Core/VideoBackends/D3D/D3DBase.h
+++ b/Source/Core/VideoBackends/D3D/D3DBase.h
@@ -14,9 +14,9 @@
 namespace DX11
 {
 
-#define SAFE_RELEASE(x) { if (x) (x)->Release(); (x) = NULL; }
-#define SAFE_DELETE(x) { delete (x); (x) = NULL; }
-#define SAFE_DELETE_ARRAY(x) { delete[] (x); (x) = NULL; }
+#define SAFE_RELEASE(x) { if (x) (x)->Release(); (x) = nullptr; }
+#define SAFE_DELETE(x) { delete (x); (x) = nullptr; }
+#define SAFE_DELETE_ARRAY(x) { delete[] (x); (x) = nullptr; }
 #define CHECK(cond, Message, ...) if (!(cond)) { PanicAlert(__FUNCTION__ "Failed in %s at line %d: " Message, __FILE__, __LINE__, __VA_ARGS__); }
 
 class D3DTexture2D;
diff --git a/Source/Core/VideoBackends/D3D/D3DBlob.cpp b/Source/Core/VideoBackends/D3D/D3DBlob.cpp
index 79fccd3dcf..8ace345fcb 100644
--- a/Source/Core/VideoBackends/D3D/D3DBlob.cpp
+++ b/Source/Core/VideoBackends/D3D/D3DBlob.cpp
@@ -9,7 +9,7 @@
 namespace DX11
 {
 
-D3DBlob::D3DBlob(unsigned int blob_size, const u8* init_data) : ref(1), size(blob_size), blob(NULL)
+D3DBlob::D3DBlob(unsigned int blob_size, const u8* init_data) : ref(1), size(blob_size), blob(nullptr)
 {
 	data = new u8[blob_size];
 	if (init_data) memcpy(data, init_data, size);
diff --git a/Source/Core/VideoBackends/D3D/D3DBlob.h b/Source/Core/VideoBackends/D3D/D3DBlob.h
index 7e00ba689a..09d34525ae 100644
--- a/Source/Core/VideoBackends/D3D/D3DBlob.h
+++ b/Source/Core/VideoBackends/D3D/D3DBlob.h
@@ -16,7 +16,7 @@ class D3DBlob
 {
 public:
 	// memory will be copied into an own buffer
-	D3DBlob(unsigned int blob_size, const u8* init_data = NULL);
+	D3DBlob(unsigned int blob_size, const u8* init_data = nullptr);
 
 	// d3dblob will be AddRef'd
 	D3DBlob(ID3D10Blob* d3dblob);
diff --git a/Source/Core/VideoBackends/D3D/D3DShader.cpp b/Source/Core/VideoBackends/D3D/D3DShader.cpp
index 21590143e7..2bbc1b31c4 100644
--- a/Source/Core/VideoBackends/D3D/D3DShader.cpp
+++ b/Source/Core/VideoBackends/D3D/D3DShader.cpp
@@ -18,9 +18,9 @@ namespace D3D
 ID3D11VertexShader* CreateVertexShaderFromByteCode(const void* bytecode, unsigned int len)
 {
 	ID3D11VertexShader* v_shader;
-	HRESULT hr = D3D::device->CreateVertexShader(bytecode, len, NULL, &v_shader);
+	HRESULT hr = D3D::device->CreateVertexShader(bytecode, len, nullptr, &v_shader);
 	if (FAILED(hr))
-		return NULL;
+		return nullptr;
 
 	return v_shader;
 }
@@ -28,15 +28,15 @@ ID3D11VertexShader* CreateVertexShaderFromByteCode(const void* bytecode, unsigne
 // code->bytecode
 bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob)
 {
-	ID3D10Blob* shaderBuffer = NULL;
-	ID3D10Blob* errorBuffer = NULL;
+	ID3D10Blob* shaderBuffer = nullptr;
+	ID3D10Blob* errorBuffer = nullptr;
 
 #if defined(_DEBUG) || defined(DEBUGFAST)
 	UINT flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY|D3D10_SHADER_DEBUG|D3D10_SHADER_WARNINGS_ARE_ERRORS;
 #else
 	UINT flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY|D3D10_SHADER_OPTIMIZATION_LEVEL3|D3D10_SHADER_SKIP_VALIDATION;
 #endif
-	HRESULT hr = PD3DCompile(code, len, NULL, NULL, NULL, "main", D3D::VertexShaderVersionString(),
+	HRESULT hr = PD3DCompile(code, len, nullptr, nullptr, nullptr, "main", D3D::VertexShaderVersionString(),
 							flags, 0, &shaderBuffer, &errorBuffer);
 	if (errorBuffer)
 	{
@@ -59,7 +59,7 @@ bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob)
 						D3D::VertexShaderVersionString(),
 						(char*)errorBuffer->GetBufferPointer());
 
-		*blob = NULL;
+		*blob = nullptr;
 		errorBuffer->Release();
 	}
 	else
@@ -74,9 +74,9 @@ bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob)
 ID3D11GeometryShader* CreateGeometryShaderFromByteCode(const void* bytecode, unsigned int len)
 {
 	ID3D11GeometryShader* g_shader;
-	HRESULT hr = D3D::device->CreateGeometryShader(bytecode, len, NULL, &g_shader);
+	HRESULT hr = D3D::device->CreateGeometryShader(bytecode, len, nullptr, &g_shader);
 	if (FAILED(hr))
-		return NULL;
+		return nullptr;
 
 	return g_shader;
 }
@@ -85,15 +85,15 @@ ID3D11GeometryShader* CreateGeometryShaderFromByteCode(const void* bytecode, uns
 bool CompileGeometryShader(const char* code, unsigned int len, D3DBlob** blob,
 	const D3D_SHADER_MACRO* pDefines)
 {
-	ID3D10Blob* shaderBuffer = NULL;
-	ID3D10Blob* errorBuffer = NULL;
+	ID3D10Blob* shaderBuffer = nullptr;
+	ID3D10Blob* errorBuffer = nullptr;
 
 #if defined(_DEBUG) || defined(DEBUGFAST)
 	UINT flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY|D3D10_SHADER_DEBUG|D3D10_SHADER_WARNINGS_ARE_ERRORS;
 #else
 	UINT flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY|D3D10_SHADER_OPTIMIZATION_LEVEL3|D3D10_SHADER_SKIP_VALIDATION;
 #endif
-	HRESULT hr = PD3DCompile(code, len, NULL, pDefines, NULL, "main", D3D::GeometryShaderVersionString(),
+	HRESULT hr = PD3DCompile(code, len, nullptr, pDefines, nullptr, "main", D3D::GeometryShaderVersionString(),
 							flags, 0, &shaderBuffer, &errorBuffer);
 
 	if (errorBuffer)
@@ -117,7 +117,7 @@ bool CompileGeometryShader(const char* code, unsigned int len, D3DBlob** blob,
 						D3D::GeometryShaderVersionString(),
 						(char*)errorBuffer->GetBufferPointer());
 
-		*blob = NULL;
+		*blob = nullptr;
 		errorBuffer->Release();
 	}
 	else
@@ -132,11 +132,11 @@ bool CompileGeometryShader(const char* code, unsigned int len, D3DBlob** blob,
 ID3D11PixelShader* CreatePixelShaderFromByteCode(const void* bytecode, unsigned int len)
 {
 	ID3D11PixelShader* p_shader;
-	HRESULT hr = D3D::device->CreatePixelShader(bytecode, len, NULL, &p_shader);
+	HRESULT hr = D3D::device->CreatePixelShader(bytecode, len, nullptr, &p_shader);
 	if (FAILED(hr))
 	{
 		PanicAlert("CreatePixelShaderFromByteCode failed at %s %d\n", __FILE__, __LINE__);
-		p_shader = NULL;
+		p_shader = nullptr;
 	}
 	return p_shader;
 }
@@ -145,15 +145,15 @@ ID3D11PixelShader* CreatePixelShaderFromByteCode(const void* bytecode, unsigned
 bool CompilePixelShader(const char* code, unsigned int len, D3DBlob** blob,
 	const D3D_SHADER_MACRO* pDefines)
 {
-	ID3D10Blob* shaderBuffer = NULL;
-	ID3D10Blob* errorBuffer = NULL;
+	ID3D10Blob* shaderBuffer = nullptr;
+	ID3D10Blob* errorBuffer = nullptr;
 
 #if defined(_DEBUG) || defined(DEBUGFAST)
 	UINT flags = D3D10_SHADER_DEBUG|D3D10_SHADER_WARNINGS_ARE_ERRORS;
 #else
 	UINT flags = D3D10_SHADER_OPTIMIZATION_LEVEL3;
 #endif
-	HRESULT hr = PD3DCompile(code, len, NULL, pDefines, NULL, "main", D3D::PixelShaderVersionString(),
+	HRESULT hr = PD3DCompile(code, len, nullptr, pDefines, nullptr, "main", D3D::PixelShaderVersionString(),
 							flags, 0, &shaderBuffer, &errorBuffer);
 
 	if (errorBuffer)
@@ -177,7 +177,7 @@ bool CompilePixelShader(const char* code, unsigned int len, D3DBlob** blob,
 						D3D::PixelShaderVersionString(),
 						(char*)errorBuffer->GetBufferPointer());
 
-		*blob = NULL;
+		*blob = nullptr;
 		errorBuffer->Release();
 	}
 	else
@@ -192,33 +192,33 @@ bool CompilePixelShader(const char* code, unsigned int len, D3DBlob** blob,
 ID3D11VertexShader* CompileAndCreateVertexShader(const char* code,
 	unsigned int len)
 {
-	D3DBlob* blob = NULL;
+	D3DBlob* blob = nullptr;
 	if (CompileVertexShader(code, len, &blob))
 	{
 		ID3D11VertexShader* v_shader = CreateVertexShaderFromByteCode(blob);
 		blob->Release();
 		return v_shader;
 	}
-	return NULL;
+	return nullptr;
 }
 
 ID3D11GeometryShader* CompileAndCreateGeometryShader(const char* code,
 	unsigned int len, const D3D_SHADER_MACRO* pDefines)
 {
-	D3DBlob* blob = NULL;
+	D3DBlob* blob = nullptr;
 	if (CompileGeometryShader(code, len, &blob, pDefines))
 	{
 		ID3D11GeometryShader* g_shader = CreateGeometryShaderFromByteCode(blob);
 		blob->Release();
 		return g_shader;
 	}
-	return NULL;
+	return nullptr;
 }
 
 ID3D11PixelShader* CompileAndCreatePixelShader(const char* code,
 	unsigned int len)
 {
-	D3DBlob* blob = NULL;
+	D3DBlob* blob = nullptr;
 	CompilePixelShader(code, len, &blob);
 	if (blob)
 	{
@@ -226,7 +226,7 @@ ID3D11PixelShader* CompileAndCreatePixelShader(const char* code,
 		blob->Release();
 		return p_shader;
 	}
-	return NULL;
+	return nullptr;
 }
 
 }  // namespace
diff --git a/Source/Core/VideoBackends/D3D/D3DShader.h b/Source/Core/VideoBackends/D3D/D3DShader.h
index fc0951ab4b..6d572c847e 100644
--- a/Source/Core/VideoBackends/D3D/D3DShader.h
+++ b/Source/Core/VideoBackends/D3D/D3DShader.h
@@ -23,15 +23,15 @@ namespace D3D
 	bool CompileVertexShader(const char* code, unsigned int len,
 		D3DBlob** blob);
 	bool CompileGeometryShader(const char* code, unsigned int len,
-		D3DBlob** blob, const D3D_SHADER_MACRO* pDefines = NULL);
+		D3DBlob** blob, const D3D_SHADER_MACRO* pDefines = nullptr);
 	bool CompilePixelShader(const char* code, unsigned int len,
-		D3DBlob** blob, const D3D_SHADER_MACRO* pDefines = NULL);
+		D3DBlob** blob, const D3D_SHADER_MACRO* pDefines = nullptr);
 
 	// Utility functions
 	ID3D11VertexShader* CompileAndCreateVertexShader(const char* code,
 		unsigned int len);
 	ID3D11GeometryShader* CompileAndCreateGeometryShader(const char* code,
-		unsigned int len, const D3D_SHADER_MACRO* pDefines = NULL);
+		unsigned int len, const D3D_SHADER_MACRO* pDefines = nullptr);
 	ID3D11PixelShader* CompileAndCreatePixelShader(const char* code,
 		unsigned int len);
 
@@ -44,7 +44,7 @@ namespace D3D
 
 	inline ID3D11VertexShader* CompileAndCreateVertexShader(D3DBlob* code)
 	{ return CompileAndCreateVertexShader((const char*)code->Data(), code->Size()); }
-	inline ID3D11GeometryShader* CompileAndCreateGeometryShader(D3DBlob* code, const D3D_SHADER_MACRO* pDefines = NULL)
+	inline ID3D11GeometryShader* CompileAndCreateGeometryShader(D3DBlob* code, const D3D_SHADER_MACRO* pDefines = nullptr)
 	{ return CompileAndCreateGeometryShader((const char*)code->Data(), code->Size(), pDefines); }
 	inline ID3D11PixelShader* CompileAndCreatePixelShader(D3DBlob* code)
 	{ return CompileAndCreatePixelShader((const char*)code->Data(), code->Size()); }
diff --git a/Source/Core/VideoBackends/D3D/D3DTexture.cpp b/Source/Core/VideoBackends/D3D/D3DTexture.cpp
index f0114cad95..d08c850187 100644
--- a/Source/Core/VideoBackends/D3D/D3DTexture.cpp
+++ b/Source/Core/VideoBackends/D3D/D3DTexture.cpp
@@ -39,7 +39,7 @@ void ReplaceRGBATexture2D(ID3D11Texture2D* pTexture, const u8* buffer, unsigned
 
 D3DTexture2D* D3DTexture2D::Create(unsigned int width, unsigned int height, D3D11_BIND_FLAG bind, D3D11_USAGE usage, DXGI_FORMAT fmt, unsigned int levels)
 {
-	ID3D11Texture2D* pTexture = NULL;
+	ID3D11Texture2D* pTexture = nullptr;
 	HRESULT hr;
 
 	D3D11_CPU_ACCESS_FLAG cpuflags;
@@ -47,11 +47,11 @@ D3DTexture2D* D3DTexture2D::Create(unsigned int width, unsigned int height, D3D1
 	else if (usage == D3D11_USAGE_DYNAMIC) cpuflags = D3D11_CPU_ACCESS_WRITE;
 	else cpuflags = (D3D11_CPU_ACCESS_FLAG)0;
 	D3D11_TEXTURE2D_DESC texdesc = CD3D11_TEXTURE2D_DESC(fmt, width, height, 1, levels, bind, usage, cpuflags);
-	hr = D3D::device->CreateTexture2D(&texdesc, NULL, &pTexture);
+	hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &pTexture);
 	if (FAILED(hr))
 	{
 		PanicAlert("Failed to create texture at %s, line %d: hr=%#x\n", __FILE__, __LINE__, hr);
-		return NULL;
+		return nullptr;
 	}
 
 	D3DTexture2D* ret = new D3DTexture2D(pTexture, bind);
@@ -82,7 +82,7 @@ ID3D11DepthStencilView* &D3DTexture2D::GetDSV() { return dsv; }
 
 D3DTexture2D::D3DTexture2D(ID3D11Texture2D* texptr, D3D11_BIND_FLAG bind,
 							DXGI_FORMAT srv_format, DXGI_FORMAT dsv_format, DXGI_FORMAT rtv_format, bool multisampled)
-							: ref(1), tex(texptr), srv(NULL), rtv(NULL), dsv(NULL)
+							: ref(1), tex(texptr), srv(nullptr), rtv(nullptr), dsv(nullptr)
 {
 	D3D11_SRV_DIMENSION srv_dim = multisampled ? D3D11_SRV_DIMENSION_TEXTURE2DMS : D3D11_SRV_DIMENSION_TEXTURE2D;
 	D3D11_DSV_DIMENSION dsv_dim = multisampled ? D3D11_DSV_DIMENSION_TEXTURE2DMS : D3D11_DSV_DIMENSION_TEXTURE2D;
diff --git a/Source/Core/VideoBackends/D3D/D3DUtil.cpp b/Source/Core/VideoBackends/D3D/D3DUtil.cpp
index 9dd7f23e39..7e5270fc50 100644
--- a/Source/Core/VideoBackends/D3D/D3DUtil.cpp
+++ b/Source/Core/VideoBackends/D3D/D3DUtil.cpp
@@ -21,10 +21,10 @@ namespace D3D
 class UtilVertexBuffer
 {
 public:
-	UtilVertexBuffer(int size) : buf(NULL), offset(0), max_size(size)
+	UtilVertexBuffer(int size) : buf(nullptr), offset(0), max_size(size)
 	{
 		D3D11_BUFFER_DESC desc = CD3D11_BUFFER_DESC(max_size, D3D11_BIND_VERTEX_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
-		device->CreateBuffer(&desc, NULL, &buf);
+		device->CreateBuffer(&desc, nullptr, &buf);
 	}
 	~UtilVertexBuffer()
 	{
@@ -72,7 +72,7 @@ private:
 };
 
 CD3DFont font;
-UtilVertexBuffer* util_vbuf = NULL;
+UtilVertexBuffer* util_vbuf = nullptr;
 
 #define MAX_NUM_VERTICES 50*6
 struct FONT2DVERTEX {
@@ -93,11 +93,11 @@ inline FONT2DVERTEX InitFont2DVertex(float x, float y, u32 color, float tu, floa
 
 CD3DFont::CD3DFont() : m_dwTexWidth(512), m_dwTexHeight(512)
 {
-	m_pTexture    = NULL;
-	m_pVB         = NULL;
-	m_InputLayout = NULL;
-	m_pshader     = NULL;
-	m_vshader     = NULL;
+	m_pTexture    = nullptr;
+	m_pVB         = nullptr;
+	m_InputLayout = nullptr;
+	m_pshader     = nullptr;
+	m_vshader     = nullptr;
 }
 
 const char fontpixshader[] = {
@@ -161,8 +161,8 @@ int CD3DFont::Init()
 	bmi.bmiHeader.biBitCount    = 32;
 
 	// Create a DC and a bitmap for the font
-	HDC hDC = CreateCompatibleDC(NULL);
-	HBITMAP hbmBitmap = CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, (void**)&pBitmapBits, NULL, 0);
+	HDC hDC = CreateCompatibleDC(nullptr);
+	HBITMAP hbmBitmap = CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, (void**)&pBitmapBits, nullptr, 0);
 	SetMapMode(hDC, MM_TEXT);
 
 	// create a GDI font
@@ -170,7 +170,7 @@ int CD3DFont::Init()
 							FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
 							CLIP_DEFAULT_PRECIS, PROOF_QUALITY,
 							VARIABLE_PITCH, _T("Tahoma"));
-	if (NULL == hFont) return E_FAIL;
+	if (nullptr == hFont) return E_FAIL;
 
 	HGDIOBJ hOldbmBitmap = SelectObject(hDC, hbmBitmap);
 	HGDIOBJ hOldFont = SelectObject(hDC, hFont);
@@ -199,7 +199,7 @@ int CD3DFont::Init()
 			y += m_LineHeight;
 		}
 
-		ExtTextOutA(hDC, x+1, y+0, ETO_OPAQUE | ETO_CLIPPED, NULL, str, 1, NULL);
+		ExtTextOutA(hDC, x+1, y+0, ETO_OPAQUE | ETO_CLIPPED, nullptr, str, 1, nullptr);
 		m_fTexCoords[c][0] = ((float)(x+0))/m_dwTexWidth;
 		m_fTexCoords[c][1] = ((float)(y+0))/m_dwTexHeight;
 		m_fTexCoords[c][2] = ((float)(x+0+size.cx))/m_dwTexWidth;
@@ -215,7 +215,7 @@ int CD3DFont::Init()
 	D3D11_TEXTURE2D_DESC texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, m_dwTexWidth, m_dwTexHeight,
 										1, 1, D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_DYNAMIC,
 										D3D11_CPU_ACCESS_WRITE);
-	hr = device->CreateTexture2D(&texdesc, NULL, &buftex);
+	hr = device->CreateTexture2D(&texdesc, nullptr, &buftex);
 	if (FAILED(hr))
 	{
 		PanicAlert("Failed to create font texture");
@@ -240,7 +240,7 @@ int CD3DFont::Init()
 
 	// Done updating texture, so clean up used objects
 	context->Unmap(buftex, 0);
-	hr = D3D::device->CreateShaderResourceView(buftex, NULL, &m_pTexture);
+	hr = D3D::device->CreateShaderResourceView(buftex, nullptr, &m_pTexture);
 	if (FAILED(hr)) PanicAlert("Failed to create shader resource view at %s %d\n", __FILE__, __LINE__);
 	SAFE_RELEASE(buftex);
 
@@ -252,14 +252,14 @@ int CD3DFont::Init()
 
 	// setup device objects for drawing
 	m_pshader = D3D::CompileAndCreatePixelShader(fontpixshader, sizeof(fontpixshader));
-	if (m_pshader == NULL) PanicAlert("Failed to create pixel shader, %s %d\n", __FILE__, __LINE__);
+	if (m_pshader == nullptr) PanicAlert("Failed to create pixel shader, %s %d\n", __FILE__, __LINE__);
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_pshader, "pixel shader of a CD3DFont object");
 
 	D3DBlob* vsbytecode;
 	D3D::CompileVertexShader(fontvertshader, sizeof(fontvertshader), &vsbytecode);
-	if (vsbytecode == NULL) PanicAlert("Failed to compile vertex shader, %s %d\n", __FILE__, __LINE__);
+	if (vsbytecode == nullptr) PanicAlert("Failed to compile vertex shader, %s %d\n", __FILE__, __LINE__);
 	m_vshader = D3D::CreateVertexShaderFromByteCode(vsbytecode);
-	if (m_vshader == NULL) PanicAlert("Failed to create vertex shader, %s %d\n", __FILE__, __LINE__);
+	if (m_vshader == nullptr) PanicAlert("Failed to create vertex shader, %s %d\n", __FILE__, __LINE__);
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_vshader, "vertex shader of a CD3DFont object");
 
 	const D3D11_INPUT_ELEMENT_DESC desc[] =
@@ -293,7 +293,7 @@ int CD3DFont::Init()
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_raststate, "rasterizer state of a CD3DFont object");
 
 	D3D11_BUFFER_DESC vbdesc = CD3D11_BUFFER_DESC(MAX_NUM_VERTICES*sizeof(FONT2DVERTEX), D3D11_BIND_VERTEX_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
-	if (FAILED(hr = device->CreateBuffer(&vbdesc, NULL, &m_pVB)))
+	if (FAILED(hr = device->CreateBuffer(&vbdesc, nullptr, &m_pVB)))
 	{
 		PanicAlert("Failed to create font vertex buffer at %s, line %d\n", __FILE__, __LINE__);
 		return hr;
@@ -347,8 +347,8 @@ int CD3DFont::DrawTextScaled(float x, float y, float size, float spacing, u32 dw
 	D3D::stateman->PushRasterizerState(m_raststate);
 	D3D::stateman->Apply();
 
-	D3D::context->PSSetShader(m_pshader, NULL, 0);
-	D3D::context->VSSetShader(m_vshader, NULL, 0);
+	D3D::context->PSSetShader(m_pshader, nullptr, 0);
+	D3D::context->VSSetShader(m_vshader, nullptr, 0);
 
 	D3D::context->IASetInputLayout(m_InputLayout);
 	D3D::context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@@ -415,8 +415,8 @@ int CD3DFont::DrawTextScaled(float x, float y, float size, float spacing, u32 dw
 	return S_OK;
 }
 
-ID3D11SamplerState* linear_copy_sampler = NULL;
-ID3D11SamplerState* point_copy_sampler = NULL;
+ID3D11SamplerState* linear_copy_sampler = nullptr;
+ID3D11SamplerState* point_copy_sampler = nullptr;
 
 typedef struct { float x,y,z,u,v,w; } STQVertex;
 typedef struct { float x,y,z,u,v,w; } STSQVertex;
@@ -545,13 +545,13 @@ void drawShadedTexQuad(ID3D11ShaderResourceView* texture,
 	D3D::context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 	D3D::context->IASetInputLayout(layout);
 	D3D::context->IASetVertexBuffers(0, 1, &util_vbuf->GetBuffer(), &stride, &offset);
-	D3D::context->PSSetShader(PShader, NULL, 0);
+	D3D::context->PSSetShader(PShader, nullptr, 0);
 	D3D::context->PSSetShaderResources(0, 1, &texture);
-	D3D::context->VSSetShader(Vshader, NULL, 0);
+	D3D::context->VSSetShader(Vshader, nullptr, 0);
 	D3D::stateman->Apply();
 	D3D::context->Draw(4, stq_offset);
 
-	ID3D11ShaderResourceView* texres = NULL;
+	ID3D11ShaderResourceView* texres = nullptr;
 	context->PSSetShaderResources(0, 1, &texres); // immediately unbind the texture
 }
 
@@ -603,12 +603,12 @@ void drawShadedTexSubQuad(ID3D11ShaderResourceView* texture,
 	context->IASetVertexBuffers(0, 1, &util_vbuf->GetBuffer(), &stride, &offset);
 	context->IASetInputLayout(layout);
 	context->PSSetShaderResources(0, 1, &texture);
-	context->PSSetShader(PShader, NULL, 0);
-	context->VSSetShader(Vshader, NULL, 0);
+	context->PSSetShader(PShader, nullptr, 0);
+	context->VSSetShader(Vshader, nullptr, 0);
 	stateman->Apply();
 	context->Draw(4, stsq_offset);
 
-	ID3D11ShaderResourceView* texres = NULL;
+	ID3D11ShaderResourceView* texres = nullptr;
 	context->PSSetShaderResources(0, 1, &texres); // immediately unbind the texture
 }
 
@@ -638,8 +638,8 @@ void drawColorQuad(u32 Color, float x1, float y1, float x2, float y2)
 		draw_quad_data.col = Color;
 	}
 
-	context->VSSetShader(VertexShaderCache::GetClearVertexShader(), NULL, 0);
-	context->PSSetShader(PixelShaderCache::GetClearProgram(), NULL, 0);
+	context->VSSetShader(VertexShaderCache::GetClearVertexShader(), nullptr, 0);
+	context->PSSetShader(PixelShaderCache::GetClearProgram(), nullptr, 0);
 	context->IASetInputLayout(VertexShaderCache::GetClearInputLayout());
 
 	UINT stride = sizeof(ColVertex);
@@ -668,8 +668,8 @@ void drawClearQuad(u32 Color, float z, ID3D11PixelShader* PShader, ID3D11VertexS
 		clear_quad_data.col = Color;
 		clear_quad_data.z = z;
 	}
-	context->VSSetShader(Vshader, NULL, 0);
-	context->PSSetShader(PShader, NULL, 0);
+	context->VSSetShader(Vshader, nullptr, 0);
+	context->PSSetShader(PShader, nullptr, 0);
 	context->IASetInputLayout(layout);
 
 	UINT stride = sizeof(ClearVertex);
diff --git a/Source/Core/VideoBackends/D3D/FramebufferManager.cpp b/Source/Core/VideoBackends/D3D/FramebufferManager.cpp
index 6b217fd0a1..aeaaf6b8e8 100644
--- a/Source/Core/VideoBackends/D3D/FramebufferManager.cpp
+++ b/Source/Core/VideoBackends/D3D/FramebufferManager.cpp
@@ -59,10 +59,10 @@ FramebufferManager::FramebufferManager()
 
 	// EFB color texture - primary render target
 	texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, target_width, target_height, 1, 1, D3D11_BIND_SHADER_RESOURCE|D3D11_BIND_RENDER_TARGET, D3D11_USAGE_DEFAULT, 0, sample_desc.Count, sample_desc.Quality);
-	hr = D3D::device->CreateTexture2D(&texdesc, NULL, &buf);
+	hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
 	CHECK(hr==S_OK, "create EFB color texture (size: %dx%d; hr=%#x)", target_width, target_height, hr);
 	m_efb.color_tex = new D3DTexture2D(buf, (D3D11_BIND_FLAG)(D3D11_BIND_SHADER_RESOURCE|D3D11_BIND_RENDER_TARGET), DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM, (sample_desc.Count > 1));
-	CHECK(m_efb.color_tex!=NULL, "create EFB color texture (size: %dx%d)", target_width, target_height);
+	CHECK(m_efb.color_tex!=nullptr, "create EFB color texture (size: %dx%d)", target_width, target_height);
 	SAFE_RELEASE(buf);
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_efb.color_tex->GetTex(), "EFB color texture");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_efb.color_tex->GetSRV(), "EFB color texture shader resource view");
@@ -70,10 +70,10 @@ FramebufferManager::FramebufferManager()
 
 	// Temporary EFB color texture - used in ReinterpretPixelData
 	texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, target_width, target_height, 1, 1, D3D11_BIND_SHADER_RESOURCE|D3D11_BIND_RENDER_TARGET, D3D11_USAGE_DEFAULT, 0, sample_desc.Count, sample_desc.Quality);
-	hr = D3D::device->CreateTexture2D(&texdesc, NULL, &buf);
+	hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
 	CHECK(hr==S_OK, "create EFB color temp texture (size: %dx%d; hr=%#x)", target_width, target_height, hr);
 	m_efb.color_temp_tex = new D3DTexture2D(buf, (D3D11_BIND_FLAG)(D3D11_BIND_SHADER_RESOURCE|D3D11_BIND_RENDER_TARGET), DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM, (sample_desc.Count > 1));
-	CHECK(m_efb.color_temp_tex!=NULL, "create EFB color temp texture (size: %dx%d)", target_width, target_height);
+	CHECK(m_efb.color_temp_tex!=nullptr, "create EFB color temp texture (size: %dx%d)", target_width, target_height);
 	SAFE_RELEASE(buf);
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_efb.color_temp_tex->GetTex(), "EFB color temp texture");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_efb.color_temp_tex->GetSRV(), "EFB color temp texture shader resource view");
@@ -81,13 +81,13 @@ FramebufferManager::FramebufferManager()
 
 	// AccessEFB - Sysmem buffer used to retrieve the pixel data from color_tex
 	texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, 1, 1, 1, 1, 0, D3D11_USAGE_STAGING, D3D11_CPU_ACCESS_READ);
-	hr = D3D::device->CreateTexture2D(&texdesc, NULL, &m_efb.color_staging_buf);
+	hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &m_efb.color_staging_buf);
 	CHECK(hr==S_OK, "create EFB color staging buffer (hr=%#x)", hr);
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_efb.color_staging_buf, "EFB color staging texture (used for Renderer::AccessEFB)");
 
 	// EFB depth buffer - primary depth buffer
 	texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R24G8_TYPELESS, target_width, target_height, 1, 1, D3D11_BIND_DEPTH_STENCIL|D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_DEFAULT, 0, sample_desc.Count, sample_desc.Quality);
-	hr = D3D::device->CreateTexture2D(&texdesc, NULL, &buf);
+	hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
 	CHECK(hr==S_OK, "create EFB depth texture (size: %dx%d; hr=%#x)", target_width, target_height, hr);
 	m_efb.depth_tex = new D3DTexture2D(buf, (D3D11_BIND_FLAG)(D3D11_BIND_DEPTH_STENCIL|D3D11_BIND_SHADER_RESOURCE), DXGI_FORMAT_R24_UNORM_X8_TYPELESS, DXGI_FORMAT_D24_UNORM_S8_UINT, DXGI_FORMAT_UNKNOWN, (sample_desc.Count > 1));
 	SAFE_RELEASE(buf);
@@ -97,7 +97,7 @@ FramebufferManager::FramebufferManager()
 
 	// Render buffer for AccessEFB (depth data)
 	texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R32_FLOAT, 1, 1, 1, 1, D3D11_BIND_RENDER_TARGET);
-	hr = D3D::device->CreateTexture2D(&texdesc, NULL, &buf);
+	hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
 	CHECK(hr==S_OK, "create EFB depth read texture (hr=%#x)", hr);
 	m_efb.depth_read_texture = new D3DTexture2D(buf, D3D11_BIND_RENDER_TARGET);
 	SAFE_RELEASE(buf);
@@ -106,7 +106,7 @@ FramebufferManager::FramebufferManager()
 
 	// AccessEFB - Sysmem buffer used to retrieve the pixel data from depth_read_texture
 	texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R32_FLOAT, 1, 1, 1, 1, 0, D3D11_USAGE_STAGING, D3D11_CPU_ACCESS_READ);
-	hr = D3D::device->CreateTexture2D(&texdesc, NULL, &m_efb.depth_staging_buf);
+	hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &m_efb.depth_staging_buf);
 	CHECK(hr==S_OK, "create EFB depth staging buffer (hr=%#x)", hr);
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)m_efb.depth_staging_buf, "EFB depth staging texture (used for Renderer::AccessEFB)");
 
@@ -114,15 +114,15 @@ FramebufferManager::FramebufferManager()
 	{
 		// Framebuffer resolve textures (color+depth)
 		texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, target_width, target_height, 1, 1, D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_DEFAULT, 0, 1);
-		hr = D3D::device->CreateTexture2D(&texdesc, NULL, &buf);
+		hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
 		m_efb.resolved_color_tex = new D3DTexture2D(buf, D3D11_BIND_SHADER_RESOURCE, DXGI_FORMAT_R8G8B8A8_UNORM);
-		CHECK(m_efb.resolved_color_tex!=NULL, "create EFB color resolve texture (size: %dx%d)", target_width, target_height);
+		CHECK(m_efb.resolved_color_tex!=nullptr, "create EFB color resolve texture (size: %dx%d)", target_width, target_height);
 		SAFE_RELEASE(buf);
 		D3D::SetDebugObjectName((ID3D11DeviceChild*)m_efb.resolved_color_tex->GetTex(), "EFB color resolve texture");
 		D3D::SetDebugObjectName((ID3D11DeviceChild*)m_efb.resolved_color_tex->GetSRV(), "EFB color resolve texture shader resource view");
 
 		texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R24G8_TYPELESS, target_width, target_height, 1, 1, D3D11_BIND_SHADER_RESOURCE);
-		hr = D3D::device->CreateTexture2D(&texdesc, NULL, &buf);
+		hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
 		CHECK(hr==S_OK, "create EFB depth resolve texture (size: %dx%d; hr=%#x)", target_width, target_height, hr);
 		m_efb.resolved_depth_tex = new D3DTexture2D(buf, D3D11_BIND_SHADER_RESOURCE, DXGI_FORMAT_R24_UNORM_X8_TYPELESS);
 		SAFE_RELEASE(buf);
@@ -131,8 +131,8 @@ FramebufferManager::FramebufferManager()
 	}
 	else
 	{
-		m_efb.resolved_color_tex = NULL;
-		m_efb.resolved_depth_tex = NULL;
+		m_efb.resolved_color_tex = nullptr;
+		m_efb.resolved_depth_tex = nullptr;
 	}
 
 	s_xfbEncoder.Init();
@@ -200,7 +200,7 @@ void XFBSource::CopyEFB(float Gamma)
 	const D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)texWidth, (float)texHeight);
 
 	D3D::context->RSSetViewports(1, &vp);
-	D3D::context->OMSetRenderTargets(1, &tex->GetRTV(), NULL);
+	D3D::context->OMSetRenderTargets(1, &tex->GetRTV(), nullptr);
 	D3D::SetLinearCopySampler();
 
 	D3D::drawShadedTexQuad(FramebufferManager::GetEFBColorTexture()->GetSRV(), sourceRc.AsRECT(),
diff --git a/Source/Core/VideoBackends/D3D/GfxState.cpp b/Source/Core/VideoBackends/D3D/GfxState.cpp
index c31c45e2ea..af85993e4d 100644
--- a/Source/Core/VideoBackends/D3D/GfxState.cpp
+++ b/Source/Core/VideoBackends/D3D/GfxState.cpp
@@ -30,10 +30,10 @@ template<typename T> AutoState<T>::AutoState(const AutoState<T> &source)
 template<typename T> AutoState<T>::~AutoState()
 {
 	if(state) ((T*)state)->Release();
-	state = NULL;
+	state = nullptr;
 }
 
-StateManager::StateManager() : cur_blendstate(NULL), cur_depthstate(NULL), cur_raststate(NULL) {}
+StateManager::StateManager() : cur_blendstate(nullptr), cur_depthstate(nullptr), cur_raststate(nullptr) {}
 
 void StateManager::PushBlendState(const ID3D11BlendState* state) { blendstates.push(AutoBlendState(state)); }
 void StateManager::PushDepthState(const ID3D11DepthStencilState* state) { depthstates.push(AutoDepthStencilState(state)); }
@@ -49,7 +49,7 @@ void StateManager::Apply()
 		if (cur_blendstate != blendstates.top().GetPtr())
 		{
 			cur_blendstate = (ID3D11BlendState*)blendstates.top().GetPtr();
-			D3D::context->OMSetBlendState(cur_blendstate, NULL, 0xFFFFFFFF);
+			D3D::context->OMSetBlendState(cur_blendstate, nullptr, 0xFFFFFFFF);
 		}
 	}
 	else ERROR_LOG(VIDEO, "Tried to apply without blend state!");
diff --git a/Source/Core/VideoBackends/D3D/LineGeometryShader.cpp b/Source/Core/VideoBackends/D3D/LineGeometryShader.cpp
index b0b71313fa..66910eb6f2 100644
--- a/Source/Core/VideoBackends/D3D/LineGeometryShader.cpp
+++ b/Source/Core/VideoBackends/D3D/LineGeometryShader.cpp
@@ -125,7 +125,7 @@ static const char LINE_GS_COMMON[] =
 ;
 
 LineGeometryShader::LineGeometryShader()
-	: m_ready(false), m_paramsBuffer(NULL)
+	: m_ready(false), m_paramsBuffer(nullptr)
 { }
 
 void LineGeometryShader::Init()
@@ -138,7 +138,7 @@ void LineGeometryShader::Init()
 
 	D3D11_BUFFER_DESC bd = CD3D11_BUFFER_DESC(sizeof(LineGSParams_Padded),
 		D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
-	hr = D3D::device->CreateBuffer(&bd, NULL, &m_paramsBuffer);
+	hr = D3D::device->CreateBuffer(&bd, nullptr, &m_paramsBuffer);
 	CHECK(SUCCEEDED(hr), "create line geometry shader params buffer");
 	D3D::SetDebugObjectName(m_paramsBuffer, "line geometry shader params buffer");
 
@@ -184,14 +184,14 @@ bool LineGeometryShader::SetShader(u32 components, float lineWidth,
 		const std::string& numTexCoordsStr = numTexCoordsStream.str();
 		D3D_SHADER_MACRO macros[] = {
 			{ "NUM_TEXCOORDS", numTexCoordsStr.c_str() },
-			{ NULL, NULL }
+			{ nullptr, nullptr }
 		};
 		ID3D11GeometryShader* newShader = D3D::CompileAndCreateGeometryShader(code.GetBuffer(), unsigned int(strlen(code.GetBuffer())), macros);
 		if (!newShader)
 		{
 			WARN_LOG(VIDEO, "Line geometry shader for components 0x%.08X failed to compile", components);
 			// Add dummy shader to prevent trying to compile again
-			m_shaders[components] = NULL;
+			m_shaders[components] = nullptr;
 			return false;
 		}
 
@@ -223,7 +223,7 @@ bool LineGeometryShader::SetShader(u32 components, float lineWidth,
 			DEBUG_LOG(VIDEO, "Line params: width %f, texOffset %f, vpWidth %f, vpHeight %f",
 				lineWidth, texOffset, vpWidth, vpHeight);
 
-			D3D::context->GSSetShader(shaderIt->second, NULL, 0);
+			D3D::context->GSSetShader(shaderIt->second, nullptr, 0);
 			D3D::context->GSSetConstantBuffers(0, 1, &m_paramsBuffer);
 
 			return true;
diff --git a/Source/Core/VideoBackends/D3D/NativeVertexFormat.cpp b/Source/Core/VideoBackends/D3D/NativeVertexFormat.cpp
index 661e1e4609..60ded71f7f 100644
--- a/Source/Core/VideoBackends/D3D/NativeVertexFormat.cpp
+++ b/Source/Core/VideoBackends/D3D/NativeVertexFormat.cpp
@@ -20,7 +20,7 @@ class D3DVertexFormat : public NativeVertexFormat
 	ID3D11InputLayout* m_layout;
 
 public:
-	D3DVertexFormat() : m_num_elems(0), m_vs_bytecode(NULL), m_layout(NULL) {}
+	D3DVertexFormat() : m_num_elems(0), m_vs_bytecode(nullptr), m_layout(nullptr) {}
 	~D3DVertexFormat() { SAFE_RELEASE(m_vs_bytecode); SAFE_RELEASE(m_layout); }
 
 	void Initialize(const PortableVertexDeclaration &_vtx_decl);
diff --git a/Source/Core/VideoBackends/D3D/PSTextureEncoder.cpp b/Source/Core/VideoBackends/D3D/PSTextureEncoder.cpp
index 3820fb3cb3..db7eb9ee3e 100644
--- a/Source/Core/VideoBackends/D3D/PSTextureEncoder.cpp
+++ b/Source/Core/VideoBackends/D3D/PSTextureEncoder.cpp
@@ -849,21 +849,21 @@ static const char EFB_ENCODE_PS[] =
 ;
 
 PSTextureEncoder::PSTextureEncoder()
-	: m_ready(false), m_out(NULL), m_outRTV(NULL), m_outStage(NULL),
-	m_encodeParams(NULL),
-	m_quad(NULL), m_vShader(NULL), m_quadLayout(NULL),
-	m_efbEncodeBlendState(NULL), m_efbEncodeDepthState(NULL),
-	m_efbEncodeRastState(NULL), m_efbSampler(NULL),
-	m_dynamicShader(NULL), m_classLinkage(NULL)
+	: m_ready(false), m_out(nullptr), m_outRTV(nullptr), m_outStage(nullptr),
+	m_encodeParams(nullptr),
+	m_quad(nullptr), m_vShader(nullptr), m_quadLayout(nullptr),
+	m_efbEncodeBlendState(nullptr), m_efbEncodeDepthState(nullptr),
+	m_efbEncodeRastState(nullptr), m_efbSampler(nullptr),
+	m_dynamicShader(nullptr), m_classLinkage(nullptr)
 {
 	for (size_t i = 0; i < 4; ++i)
-		m_fetchClass[i] = NULL;
+		m_fetchClass[i] = nullptr;
 	for (size_t i = 0; i < 2; ++i)
-		m_scaledFetchClass[i] = NULL;
+		m_scaledFetchClass[i] = nullptr;
 	for (size_t i = 0; i < 2; ++i)
-		m_intensityClass[i] = NULL;
+		m_intensityClass[i] = nullptr;
 	for (size_t i = 0; i < 16; ++i)
-		m_generatorClass[i] = NULL;
+		m_generatorClass[i] = nullptr;
 }
 
 static const D3D11_INPUT_ELEMENT_DESC QUAD_LAYOUT_DESC[] = {
@@ -888,7 +888,7 @@ void PSTextureEncoder::Init()
 	D3D11_TEXTURE2D_DESC t2dd = CD3D11_TEXTURE2D_DESC(
 		DXGI_FORMAT_R32G32B32A32_UINT,
 		EFB_WIDTH, EFB_HEIGHT/4, 1, 1, D3D11_BIND_RENDER_TARGET);
-	hr = D3D::device->CreateTexture2D(&t2dd, NULL, &m_out);
+	hr = D3D::device->CreateTexture2D(&t2dd, nullptr, &m_out);
 	CHECK(SUCCEEDED(hr), "create efb encode output texture");
 	D3D::SetDebugObjectName(m_out, "efb encoder output texture");
 
@@ -905,7 +905,7 @@ void PSTextureEncoder::Init()
 	t2dd.Usage = D3D11_USAGE_STAGING;
 	t2dd.BindFlags = 0;
 	t2dd.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-	hr = D3D::device->CreateTexture2D(&t2dd, NULL, &m_outStage);
+	hr = D3D::device->CreateTexture2D(&t2dd, nullptr, &m_outStage);
 	CHECK(SUCCEEDED(hr), "create efb encode output staging buffer");
 	D3D::SetDebugObjectName(m_outStage, "efb encoder output staging buffer");
 
@@ -913,7 +913,7 @@ void PSTextureEncoder::Init()
 
 	D3D11_BUFFER_DESC bd = CD3D11_BUFFER_DESC(sizeof(EFBEncodeParams),
 		D3D11_BIND_CONSTANT_BUFFER);
-	hr = D3D::device->CreateBuffer(&bd, NULL, &m_encodeParams);
+	hr = D3D::device->CreateBuffer(&bd, nullptr, &m_encodeParams);
 	CHECK(SUCCEEDED(hr), "create efb encode params buffer");
 	D3D::SetDebugObjectName(m_encodeParams, "efb encoder params buffer");
 
@@ -929,14 +929,14 @@ void PSTextureEncoder::Init()
 
 	// Create vertex shader
 
-	D3DBlob* bytecode = NULL;
+	D3DBlob* bytecode = nullptr;
 	if (!D3D::CompileVertexShader(EFB_ENCODE_VS, sizeof(EFB_ENCODE_VS), &bytecode))
 	{
 		ERROR_LOG(VIDEO, "EFB encode vertex shader failed to compile");
 		return;
 	}
 
-	hr = D3D::device->CreateVertexShader(bytecode->Data(), bytecode->Size(), NULL, &m_vShader);
+	hr = D3D::device->CreateVertexShader(bytecode->Data(), bytecode->Size(), nullptr, &m_vShader);
 	CHECK(SUCCEEDED(hr), "create efb encode vertex shader");
 	D3D::SetDebugObjectName(m_vShader, "efb encoder vertex shader");
 
@@ -1084,7 +1084,7 @@ size_t PSTextureEncoder::Encode(u8* dst, unsigned int dstFormat,
 	if (SetStaticShader(dstFormat, srcFormat, isIntensity, scaleByHalf))
 #endif
 	{
-		D3D::context->VSSetShader(m_vShader, NULL, 0);
+		D3D::context->VSSetShader(m_vShader, nullptr, 0);
 
 		D3D::stateman->PushBlendState(m_efbEncodeBlendState);
 		D3D::stateman->PushDepthState(m_efbEncodeDepthState);
@@ -1116,11 +1116,11 @@ size_t PSTextureEncoder::Encode(u8* dst, unsigned int dstFormat,
 		params.TexTop = float(targetRect.top) / g_renderer->GetTargetHeight();
 		params.TexRight = float(targetRect.right) / g_renderer->GetTargetWidth();
 		params.TexBottom = float(targetRect.bottom) / g_renderer->GetTargetHeight();
-		D3D::context->UpdateSubresource(m_encodeParams, 0, NULL, &params, 0, 0);
+		D3D::context->UpdateSubresource(m_encodeParams, 0, nullptr, &params, 0, 0);
 
 		D3D::context->VSSetConstantBuffers(0, 1, &m_encodeParams);
 
-		D3D::context->OMSetRenderTargets(1, &m_outRTV, NULL);
+		D3D::context->OMSetRenderTargets(1, &m_outRTV, nullptr);
 
 		ID3D11ShaderResourceView* pEFB = (srcFormat == PIXELFMT_Z24) ?
 			FramebufferManager::GetEFBDepthTexture()->GetSRV() :
@@ -1144,13 +1144,13 @@ size_t PSTextureEncoder::Encode(u8* dst, unsigned int dstFormat,
 
 		// Clean up state
 
-		IUnknown* nullDummy = NULL;
+		IUnknown* nullDummy = nullptr;
 
 		D3D::context->PSSetSamplers(0, 1, (ID3D11SamplerState**)&nullDummy);
 		D3D::context->PSSetShaderResources(0, 1, (ID3D11ShaderResourceView**)&nullDummy);
 		D3D::context->PSSetConstantBuffers(0, 1, (ID3D11Buffer**)&nullDummy);
 
-		D3D::context->OMSetRenderTargets(0, NULL, NULL);
+		D3D::context->OMSetRenderTargets(0, nullptr, nullptr);
 
 		D3D::context->VSSetConstantBuffers(0, 1, (ID3D11Buffer**)&nullDummy);
 
@@ -1158,8 +1158,8 @@ size_t PSTextureEncoder::Encode(u8* dst, unsigned int dstFormat,
 		D3D::stateman->PopDepthState();
 		D3D::stateman->PopBlendState();
 
-		D3D::context->PSSetShader(NULL, NULL, 0);
-		D3D::context->VSSetShader(NULL, NULL, 0);
+		D3D::context->PSSetShader(nullptr, nullptr, 0);
+		D3D::context->VSSetShader(nullptr, nullptr, 0);
 
 		// Transfer staging buffer to GameCube/Wii RAM
 
@@ -1221,7 +1221,7 @@ bool PSTextureEncoder::SetStaticShader(unsigned int dstFormat, unsigned int srcF
 	ComboMap::iterator it = m_staticShaders.find(key);
 	if (it == m_staticShaders.end())
 	{
-		const char* generatorFuncName = NULL;
+		const char* generatorFuncName = nullptr;
 		switch (generatorNum)
 		{
 		case 0x0: generatorFuncName = "Generate_0"; break;
@@ -1239,7 +1239,7 @@ bool PSTextureEncoder::SetStaticShader(unsigned int dstFormat, unsigned int srcF
 		case 0xC: generatorFuncName = "Generate_C"; break;
 		default:
 			WARN_LOG(VIDEO, "No generator available for dst format 0x%X; aborting", generatorNum);
-			m_staticShaders[key] = NULL;
+			m_staticShaders[key] = nullptr;
 			return false;
 		}
 
@@ -1247,13 +1247,13 @@ bool PSTextureEncoder::SetStaticShader(unsigned int dstFormat, unsigned int srcF
 			dstFormat, srcFormat, isIntensity ? 1 : 0, scaleByHalf ? 1 : 0);
 
 		// Shader permutation not found, so compile it
-		D3DBlob* bytecode = NULL;
+		D3DBlob* bytecode = nullptr;
 		D3D_SHADER_MACRO macros[] = {
 			{ "IMP_FETCH", FETCH_FUNC_NAMES[fetchNum] },
 			{ "IMP_SCALEDFETCH", SCALEDFETCH_FUNC_NAMES[scaledFetchNum] },
 			{ "IMP_INTENSITY", INTENSITY_FUNC_NAMES[intensityNum] },
 			{ "IMP_GENERATOR", generatorFuncName },
-			{ NULL, NULL }
+			{ nullptr, nullptr }
 		};
 		if (!D3D::CompilePixelShader(EFB_ENCODE_PS, sizeof(EFB_ENCODE_PS), &bytecode, macros))
 		{
@@ -1261,12 +1261,12 @@ bool PSTextureEncoder::SetStaticShader(unsigned int dstFormat, unsigned int srcF
 				dstFormat, srcFormat, isIntensity ? 1 : 0, scaleByHalf ? 1 : 0);
 			// Add dummy shader to map to prevent trying to compile over and
 			// over again
-			m_staticShaders[key] = NULL;
+			m_staticShaders[key] = nullptr;
 			return false;
 		}
 
 		ID3D11PixelShader* newShader;
-		HRESULT hr = D3D::device->CreatePixelShader(bytecode->Data(), bytecode->Size(), NULL, &newShader);
+		HRESULT hr = D3D::device->CreatePixelShader(bytecode->Data(), bytecode->Size(), nullptr, &newShader);
 		CHECK(SUCCEEDED(hr), "create efb encoder pixel shader");
 
 		it = m_staticShaders.insert(std::make_pair(key, newShader)).first;
@@ -1277,7 +1277,7 @@ bool PSTextureEncoder::SetStaticShader(unsigned int dstFormat, unsigned int srcF
 	{
 		if (it->second)
 		{
-			D3D::context->PSSetShader(it->second, NULL, 0);
+			D3D::context->PSSetShader(it->second, nullptr, 0);
 			return true;
 		}
 		else
@@ -1292,11 +1292,11 @@ bool PSTextureEncoder::InitDynamicMode()
 	HRESULT hr;
 
 	D3D_SHADER_MACRO macros[] = {
-		{ "DYNAMIC_MODE", NULL },
-		{ NULL, NULL }
+		{ "DYNAMIC_MODE", nullptr },
+		{ nullptr, nullptr }
 	};
 
-	D3DBlob* bytecode = NULL;
+	D3DBlob* bytecode = nullptr;
 	if (!D3D::CompilePixelShader(EFB_ENCODE_PS, sizeof(EFB_ENCODE_PS), &bytecode, macros))
 	{
 		ERROR_LOG(VIDEO, "EFB encode pixel shader failed to compile");
@@ -1313,14 +1313,14 @@ bool PSTextureEncoder::InitDynamicMode()
 
 	// Use D3DReflect
 
-	ID3D11ShaderReflection* reflect = NULL;
+	ID3D11ShaderReflection* reflect = nullptr;
 	hr = PD3DReflect(bytecode->Data(), bytecode->Size(), IID_ID3D11ShaderReflection, (void**)&reflect);
 	CHECK(SUCCEEDED(hr), "reflect on efb encoder shader");
 
 	// Get number of slots and create dynamic linkage array
 
 	UINT numSlots = reflect->GetNumInterfaceSlots();
-	m_linkageArray.resize(numSlots, NULL);
+	m_linkageArray.resize(numSlots, nullptr);
 
 	// Get interface slots
 
@@ -1342,13 +1342,13 @@ bool PSTextureEncoder::InitDynamicMode()
 	// Class instances will be created at the time they are used
 
 	for (size_t i = 0; i < 4; ++i)
-		m_fetchClass[i] = NULL;
+		m_fetchClass[i] = nullptr;
 	for (size_t i = 0; i < 2; ++i)
-		m_scaledFetchClass[i] = NULL;
+		m_scaledFetchClass[i] = nullptr;
 	for (size_t i = 0; i < 2; ++i)
-		m_intensityClass[i] = NULL;
+		m_intensityClass[i] = nullptr;
 	for (size_t i = 0; i < 16; ++i)
-		m_generatorClass[i] = NULL;
+		m_generatorClass[i] = nullptr;
 
 	reflect->Release();
 	bytecode->Release();
@@ -1378,7 +1378,7 @@ bool PSTextureEncoder::SetDynamicShader(unsigned int dstFormat,
 
 	// FIXME: Not all the possible generators are available as classes yet.
 	// When dynamic mode is usable, implement them.
-	const char* generatorName = NULL;
+	const char* generatorName = nullptr;
 	switch (generatorNum)
 	{
 	case 0x4: generatorName = "cGenerator_4"; break;
@@ -1438,7 +1438,7 @@ bool PSTextureEncoder::SetDynamicShader(unsigned int dstFormat,
 		m_linkageArray[m_generatorSlot] = m_generatorClass[generatorNum];
 
 	D3D::context->PSSetShader(m_dynamicShader,
-		m_linkageArray.empty() ? NULL : &m_linkageArray[0],
+		m_linkageArray.empty() ? nullptr : &m_linkageArray[0],
 		(UINT)m_linkageArray.size());
 
 	return true;
diff --git a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
index 4c234517a3..da1f1b0746 100644
--- a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
@@ -31,13 +31,13 @@ UidChecker<PixelShaderUid,PixelShaderCode> PixelShaderCache::pixel_uid_checker;
 
 LinearDiskCache<PixelShaderUid, u8> g_ps_disk_cache;
 
-ID3D11PixelShader* s_ColorMatrixProgram[2] = {NULL};
-ID3D11PixelShader* s_ColorCopyProgram[2] = {NULL};
-ID3D11PixelShader* s_DepthMatrixProgram[2] = {NULL};
-ID3D11PixelShader* s_ClearProgram = NULL;
-ID3D11PixelShader* s_rgba6_to_rgb8[2] = {NULL};
-ID3D11PixelShader* s_rgb8_to_rgba6[2] = {NULL};
-ID3D11Buffer* pscbuf = NULL;
+ID3D11PixelShader* s_ColorMatrixProgram[2] = {nullptr};
+ID3D11PixelShader* s_ColorCopyProgram[2] = {nullptr};
+ID3D11PixelShader* s_DepthMatrixProgram[2] = {nullptr};
+ID3D11PixelShader* s_ClearProgram = nullptr;
+ID3D11PixelShader* s_rgba6_to_rgb8[2] = {nullptr};
+ID3D11PixelShader* s_rgb8_to_rgba6[2] = {nullptr};
+ID3D11Buffer* pscbuf = nullptr;
 
 const char clear_program_code[] = {
 	"void main(\n"
@@ -291,7 +291,7 @@ ID3D11PixelShader* PixelShaderCache::GetColorCopyProgram(bool multisampled)
 		char buf[1024];
 		int l = sprintf_s(buf, 1024, color_copy_program_code_msaa, D3D::GetAAMode(g_ActiveConfig.iMultisampleMode).Count);
 		s_ColorCopyProgram[1] = D3D::CompileAndCreatePixelShader(buf, l);
-		CHECK(s_ColorCopyProgram[1]!=NULL, "Create color copy MSAA pixel shader");
+		CHECK(s_ColorCopyProgram[1]!=nullptr, "Create color copy MSAA pixel shader");
 		D3D::SetDebugObjectName((ID3D11DeviceChild*)s_ColorCopyProgram[1], "color copy MSAA pixel shader");
 		return s_ColorCopyProgram[1];
 	}
@@ -307,7 +307,7 @@ ID3D11PixelShader* PixelShaderCache::GetColorMatrixProgram(bool multisampled)
 		char buf[1024];
 		int l = sprintf_s(buf, 1024, color_matrix_program_code_msaa, D3D::GetAAMode(g_ActiveConfig.iMultisampleMode).Count);
 		s_ColorMatrixProgram[1] = D3D::CompileAndCreatePixelShader(buf, l);
-		CHECK(s_ColorMatrixProgram[1]!=NULL, "Create color matrix MSAA pixel shader");
+		CHECK(s_ColorMatrixProgram[1]!=nullptr, "Create color matrix MSAA pixel shader");
 		D3D::SetDebugObjectName((ID3D11DeviceChild*)s_ColorMatrixProgram[1], "color matrix MSAA pixel shader");
 		return s_ColorMatrixProgram[1];
 	}
@@ -323,7 +323,7 @@ ID3D11PixelShader* PixelShaderCache::GetDepthMatrixProgram(bool multisampled)
 		char buf[1024];
 		int l = sprintf_s(buf, 1024, depth_matrix_program_msaa, D3D::GetAAMode(g_ActiveConfig.iMultisampleMode).Count);
 		s_DepthMatrixProgram[1] = D3D::CompileAndCreatePixelShader(buf, l);
-		CHECK(s_DepthMatrixProgram[1]!=NULL, "Create depth matrix MSAA pixel shader");
+		CHECK(s_DepthMatrixProgram[1]!=nullptr, "Create depth matrix MSAA pixel shader");
 		D3D::SetDebugObjectName((ID3D11DeviceChild*)s_DepthMatrixProgram[1], "depth matrix MSAA pixel shader");
 		return s_DepthMatrixProgram[1];
 	}
@@ -364,28 +364,28 @@ void PixelShaderCache::Init()
 {
 	unsigned int cbsize = ((sizeof(PixelShaderConstants))&(~0xf))+0x10; // must be a multiple of 16
 	D3D11_BUFFER_DESC cbdesc = CD3D11_BUFFER_DESC(cbsize, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
-	D3D::device->CreateBuffer(&cbdesc, NULL, &pscbuf);
-	CHECK(pscbuf!=NULL, "Create pixel shader constant buffer");
+	D3D::device->CreateBuffer(&cbdesc, nullptr, &pscbuf);
+	CHECK(pscbuf!=nullptr, "Create pixel shader constant buffer");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)pscbuf, "pixel shader constant buffer used to emulate the GX pipeline");
 
 	// used when drawing clear quads
 	s_ClearProgram = D3D::CompileAndCreatePixelShader(clear_program_code, sizeof(clear_program_code));
-	CHECK(s_ClearProgram!=NULL, "Create clear pixel shader");
+	CHECK(s_ClearProgram!=nullptr, "Create clear pixel shader");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)s_ClearProgram, "clear pixel shader");
 
 	// used when copying/resolving the color buffer
 	s_ColorCopyProgram[0] = D3D::CompileAndCreatePixelShader(color_copy_program_code, sizeof(color_copy_program_code));
-	CHECK(s_ColorCopyProgram[0]!=NULL, "Create color copy pixel shader");
+	CHECK(s_ColorCopyProgram[0]!=nullptr, "Create color copy pixel shader");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)s_ColorCopyProgram[0], "color copy pixel shader");
 
 	// used for color conversion
 	s_ColorMatrixProgram[0] = D3D::CompileAndCreatePixelShader(color_matrix_program_code, sizeof(color_matrix_program_code));
-	CHECK(s_ColorMatrixProgram[0]!=NULL, "Create color matrix pixel shader");
+	CHECK(s_ColorMatrixProgram[0]!=nullptr, "Create color matrix pixel shader");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)s_ColorMatrixProgram[0], "color matrix pixel shader");
 
 	// used for depth copy
 	s_DepthMatrixProgram[0] = D3D::CompileAndCreatePixelShader(depth_matrix_program, sizeof(depth_matrix_program));
-	CHECK(s_DepthMatrixProgram[0]!=NULL, "Create depth matrix pixel shader");
+	CHECK(s_DepthMatrixProgram[0]!=nullptr, "Create depth matrix pixel shader");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)s_DepthMatrixProgram[0], "depth matrix pixel shader");
 
 	Clear();
@@ -405,7 +405,7 @@ void PixelShaderCache::Init()
 	if (g_Config.bEnableShaderDebugging)
 		Clear();
 
-	last_entry = NULL;
+	last_entry = nullptr;
 }
 
 // ONLY to be used during shutdown.
@@ -416,7 +416,7 @@ void PixelShaderCache::Clear()
 	PixelShaders.clear();
 	pixel_uid_checker.Invalidate();
 
-	last_entry = NULL;
+	last_entry = nullptr;
 }
 
 // Used in Swap() when AA mode has changed
@@ -465,7 +465,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
 		if (uid == last_uid)
 		{
 			GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE,true);
-			return (last_entry->shader != NULL);
+			return (last_entry->shader != nullptr);
 		}
 	}
 
@@ -480,7 +480,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
 		last_entry = &entry;
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE,true);
-		return (entry.shader != NULL);
+		return (entry.shader != nullptr);
 	}
 
 	// Need to compile a new shader
@@ -512,7 +512,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
 bool PixelShaderCache::InsertByteCode(const PixelShaderUid &uid, const void* bytecode, unsigned int bytecodelen)
 {
 	ID3D11PixelShader* shader = D3D::CreatePixelShaderFromByteCode(bytecode, bytecodelen);
-	if (shader == NULL)
+	if (shader == nullptr)
 		return false;
 
 	// TODO: Somehow make the debug name a bit more specific
diff --git a/Source/Core/VideoBackends/D3D/PixelShaderCache.h b/Source/Core/VideoBackends/D3D/PixelShaderCache.h
index 26981dc481..55a31379e3 100644
--- a/Source/Core/VideoBackends/D3D/PixelShaderCache.h
+++ b/Source/Core/VideoBackends/D3D/PixelShaderCache.h
@@ -42,7 +42,7 @@ private:
 
 		std::string code;
 
-		PSCacheEntry() : shader(NULL) {}
+		PSCacheEntry() : shader(nullptr) {}
 		void Destroy() { SAFE_RELEASE(shader); }
 	};
 
diff --git a/Source/Core/VideoBackends/D3D/PointGeometryShader.cpp b/Source/Core/VideoBackends/D3D/PointGeometryShader.cpp
index 5e7cb5eda6..3d1d8077eb 100644
--- a/Source/Core/VideoBackends/D3D/PointGeometryShader.cpp
+++ b/Source/Core/VideoBackends/D3D/PointGeometryShader.cpp
@@ -119,7 +119,7 @@ static const char POINT_GS_COMMON[] =
 ;
 
 PointGeometryShader::PointGeometryShader()
-	: m_ready(false), m_paramsBuffer(NULL)
+	: m_ready(false), m_paramsBuffer(nullptr)
 { }
 
 void PointGeometryShader::Init()
@@ -132,7 +132,7 @@ void PointGeometryShader::Init()
 
 	D3D11_BUFFER_DESC bd = CD3D11_BUFFER_DESC(sizeof(PointGSParams_Padded),
 		D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
-	hr = D3D::device->CreateBuffer(&bd, NULL, &m_paramsBuffer);
+	hr = D3D::device->CreateBuffer(&bd, nullptr, &m_paramsBuffer);
 	CHECK(SUCCEEDED(hr), "create point geometry shader params buffer");
 	D3D::SetDebugObjectName(m_paramsBuffer, "point geometry shader params buffer");
 
@@ -178,14 +178,14 @@ bool PointGeometryShader::SetShader(u32 components, float pointSize,
 		const std::string& numTexCoordsStr = numTexCoordsStream.str();
 		D3D_SHADER_MACRO macros[] = {
 			{ "NUM_TEXCOORDS", numTexCoordsStr.c_str() },
-			{ NULL, NULL }
+			{ nullptr, nullptr }
 		};
 		ID3D11GeometryShader* newShader = D3D::CompileAndCreateGeometryShader(code.GetBuffer(), unsigned int(strlen(code.GetBuffer())), macros);
 		if (!newShader)
 		{
 			WARN_LOG(VIDEO, "Point geometry shader for components 0x%.08X failed to compile", components);
 			// Add dummy shader to prevent trying to compile again
-			m_shaders[components] = NULL;
+			m_shaders[components] = nullptr;
 			return false;
 		}
 
@@ -217,7 +217,7 @@ bool PointGeometryShader::SetShader(u32 components, float pointSize,
 			DEBUG_LOG(VIDEO, "Point params: size %f, texOffset %f, vpWidth %f, vpHeight %f",
 				pointSize, texOffset, vpWidth, vpHeight);
 
-			D3D::context->GSSetShader(shaderIt->second, NULL, 0);
+			D3D::context->GSSetShader(shaderIt->second, nullptr, 0);
 			D3D::context->GSSetConstantBuffers(0, 1, &m_paramsBuffer);
 
 			return true;
diff --git a/Source/Core/VideoBackends/D3D/Render.cpp b/Source/Core/VideoBackends/D3D/Render.cpp
index 23467f2406..3b987fe7f7 100644
--- a/Source/Core/VideoBackends/D3D/Render.cpp
+++ b/Source/Core/VideoBackends/D3D/Render.cpp
@@ -44,14 +44,14 @@ static u32 s_LastAA = 0;
 
 static Television s_television;
 
-ID3D11Buffer* access_efb_cbuf = NULL;
-ID3D11BlendState* clearblendstates[4] = {NULL};
-ID3D11DepthStencilState* cleardepthstates[3] = {NULL};
-ID3D11BlendState* resetblendstate = NULL;
-ID3D11DepthStencilState* resetdepthstate = NULL;
-ID3D11RasterizerState* resetraststate = NULL;
+ID3D11Buffer* access_efb_cbuf = nullptr;
+ID3D11BlendState* clearblendstates[4] = {nullptr};
+ID3D11DepthStencilState* cleardepthstates[3] = {nullptr};
+ID3D11BlendState* resetblendstate = nullptr;
+ID3D11DepthStencilState* resetdepthstate = nullptr;
+ID3D11RasterizerState* resetraststate = nullptr;
 
-static ID3D11Texture2D* s_screenshot_texture = NULL;
+static ID3D11Texture2D* s_screenshot_texture = nullptr;
 
 
 // GX pipeline state
@@ -145,7 +145,7 @@ void SetupDeviceObjects()
 	CHECK(hr==S_OK, "Create rasterizer state for Renderer::ResetAPIState");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)resetraststate, "rasterizer state for Renderer::ResetAPIState");
 
-	s_screenshot_texture = NULL;
+	s_screenshot_texture = nullptr;
 }
 
 // Kill off all device objects
@@ -172,7 +172,7 @@ void TeardownDeviceObjects()
 void CreateScreenshotTexture(const TargetRectangle& rc)
 {
 	D3D11_TEXTURE2D_DESC scrtex_desc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, rc.GetWidth(), rc.GetHeight(), 1, 1, 0, D3D11_USAGE_STAGING, D3D11_CPU_ACCESS_READ|D3D11_CPU_ACCESS_WRITE);
-	HRESULT hr = D3D::device->CreateTexture2D(&scrtex_desc, NULL, &s_screenshot_texture);
+	HRESULT hr = D3D::device->CreateTexture2D(&scrtex_desc, nullptr, &s_screenshot_texture);
 	CHECK(hr==S_OK, "Create screenshot staging texture");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)s_screenshot_texture, "staging screenshot texture");
 }
@@ -385,7 +385,7 @@ u32 Renderer::AccessEFB(EFBAccessType type, u32 x, u32 y, u32 poke_data)
 		D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, 1.f, 1.f);
 		D3D::context->RSSetViewports(1, &vp);
 		D3D::context->PSSetConstantBuffers(0, 1, &access_efb_cbuf);
-		D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBDepthReadTexture()->GetRTV(), NULL);
+		D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBDepthReadTexture()->GetRTV(), nullptr);
 		D3D::SetPointCopySampler();
 		D3D::drawShadedTexQuad(FramebufferManager::GetEFBDepthTexture()->GetSRV(),
 								&RectToLock,
@@ -464,7 +464,7 @@ u32 Renderer::AccessEFB(EFBAccessType type, u32 x, u32 y, u32 poke_data)
 		// TODO: The first five PE registers may change behavior of EFB pokes, this isn't implemented, yet.
 		ResetAPIState();
 
-		D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(), NULL);
+		D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(), nullptr);
 		D3D::drawColorQuad(rgbaColor, (float)RectToLock.left   * 2.f / (float)Renderer::GetTargetWidth()  - 1.f,
 		                            - (float)RectToLock.top    * 2.f / (float)Renderer::GetTargetHeight() + 1.f,
 		                              (float)RectToLock.right  * 2.f / (float)Renderer::GetTargetWidth()  - 1.f,
@@ -570,7 +570,7 @@ void Renderer::ReinterpretPixelData(unsigned int convtype)
 	D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)g_renderer->GetTargetWidth(), (float)g_renderer->GetTargetHeight());
 	D3D::context->RSSetViewports(1, &vp);
 
-	D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTempTexture()->GetRTV(), NULL);
+	D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTempTexture()->GetRTV(), nullptr);
 	D3D::SetPointCopySampler();
 	D3D::drawShadedTexQuad(FramebufferManager::GetEFBColorTexture()->GetSRV(), &source, g_renderer->GetTargetWidth(), g_renderer->GetTargetHeight(), pixel_shader, VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout());
 
@@ -770,7 +770,7 @@ void Renderer::SwapImpl(u32 xfbAddr, u32 fbWidth, u32 fbHeight,const EFBRectangl
 	if (Height > (s_backbuffer_height - Y)) Height = s_backbuffer_height - Y;
 	D3D11_VIEWPORT vp = CD3D11_VIEWPORT((float)X, (float)Y, (float)Width, (float)Height);
 	D3D::context->RSSetViewports(1, &vp);
-	D3D::context->OMSetRenderTargets(1, &D3D::GetBackBuffer()->GetRTV(), NULL);
+	D3D::context->OMSetRenderTargets(1, &D3D::GetBackBuffer()->GetRTV(), nullptr);
 
 	float ClearColor[4] = { 0.f, 0.f, 0.f, 1.f };
 	D3D::context->ClearRenderTargetView(D3D::GetBackBuffer()->GetRTV(), ClearColor);
@@ -999,7 +999,7 @@ void Renderer::SwapImpl(u32 xfbAddr, u32 fbWidth, u32 fbHeight,const EFBRectangl
 		s_LastEFBScale = g_ActiveConfig.iEFBScale;
 		CalculateTargetSize(s_backbuffer_width, s_backbuffer_height);
 
-		D3D::context->OMSetRenderTargets(1, &D3D::GetBackBuffer()->GetRTV(), NULL);
+		D3D::context->OMSetRenderTargets(1, &D3D::GetBackBuffer()->GetRTV(), nullptr);
 
 		delete g_framebuffer_manager;
 		g_framebuffer_manager = new FramebufferManager;
@@ -1089,7 +1089,7 @@ void Renderer::ApplyState(bool bUseDstAlpha)
 			if (FAILED(hr)) PanicAlert("Fail %s %d, stage=%d\n", __FILE__, __LINE__, stage);
 			else D3D::SetDebugObjectName((ID3D11DeviceChild*)samplerstate[stage], "sampler state used to emulate the GX pipeline");
 		}
-		// else samplerstate[stage] = NULL;
+		// else samplerstate[stage] = nullptr;
 	}
 	D3D::context->PSSetSamplers(0, 8, samplerstate);
 	for (unsigned int stage = 0; stage < 8; stage++)
@@ -1107,13 +1107,13 @@ void Renderer::ApplyState(bool bUseDstAlpha)
 	D3D::context->PSSetConstantBuffers(0, 1, &PixelShaderCache::GetConstantBuffer());
 	D3D::context->VSSetConstantBuffers(0, 1, &VertexShaderCache::GetConstantBuffer());
 
-	D3D::context->PSSetShader(PixelShaderCache::GetActiveShader(), NULL, 0);
-	D3D::context->VSSetShader(VertexShaderCache::GetActiveShader(), NULL, 0);
+	D3D::context->PSSetShader(PixelShaderCache::GetActiveShader(), nullptr, 0);
+	D3D::context->VSSetShader(VertexShaderCache::GetActiveShader(), nullptr, 0);
 }
 
 void Renderer::RestoreState()
 {
-	ID3D11ShaderResourceView* shader_resources[8] = { NULL };
+	ID3D11ShaderResourceView* shader_resources[8] = { nullptr };
 	D3D::context->PSSetShaderResources(0, 8, shader_resources);
 
 	D3D::stateman->PopBlendState();
diff --git a/Source/Core/VideoBackends/D3D/Television.cpp b/Source/Core/VideoBackends/D3D/Television.cpp
index 816fe32a3a..50516b787d 100644
--- a/Source/Core/VideoBackends/D3D/Television.cpp
+++ b/Source/Core/VideoBackends/D3D/Television.cpp
@@ -59,7 +59,7 @@ static const char YUYV_DECODER_PS[] =
 ;
 
 Television::Television()
-	: m_yuyvTexture(NULL), m_yuyvTextureSRV(NULL), m_pShader(NULL)
+	: m_yuyvTexture(nullptr), m_yuyvTextureSRV(nullptr), m_pShader(nullptr)
 { }
 
 void Television::Init()
@@ -99,7 +99,7 @@ void Television::Init()
 	// Create YUYV-decoding pixel shader
 
 	m_pShader = D3D::CompileAndCreatePixelShader(YUYV_DECODER_PS, sizeof(YUYV_DECODER_PS));
-	CHECK(m_pShader != NULL, "compile and create yuyv decoder pixel shader");
+	CHECK(m_pShader != nullptr, "compile and create yuyv decoder pixel shader");
 	D3D::SetDebugObjectName(m_pShader, "yuyv decoder pixel shader");
 
 	// Create sampler state and set border color
diff --git a/Source/Core/VideoBackends/D3D/TextureCache.cpp b/Source/Core/VideoBackends/D3D/TextureCache.cpp
index 4ea188986c..608cbd67cc 100644
--- a/Source/Core/VideoBackends/D3D/TextureCache.cpp
+++ b/Source/Core/VideoBackends/D3D/TextureCache.cpp
@@ -18,7 +18,7 @@
 namespace DX11
 {
 
-static TextureEncoder* g_encoder = NULL;
+static TextureEncoder* g_encoder = nullptr;
 const size_t MAX_COPY_BUFFERS = 32;
 ID3D11Buffer* efbcopycbuf[MAX_COPY_BUFFERS] = { 0 };
 
@@ -43,7 +43,7 @@ bool TextureCache::TCacheEntry::Save(const std::string& filename, unsigned int l
 		return false;
 	}
 
-	ID3D11Texture2D* pNewTexture = NULL;
+	ID3D11Texture2D* pNewTexture = nullptr;
 	ID3D11Texture2D* pSurface = texture->GetTex();
 	D3D11_TEXTURE2D_DESC desc;
 	pSurface->GetDesc(&desc);
@@ -52,7 +52,7 @@ bool TextureCache::TCacheEntry::Save(const std::string& filename, unsigned int l
 	desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
 	desc.Usage = D3D11_USAGE_STAGING;
 
-	HRESULT hr = D3D::device->CreateTexture2D(&desc, NULL, &pNewTexture);
+	HRESULT hr = D3D::device->CreateTexture2D(&desc, nullptr, &pNewTexture);
 
 	bool saved_png = false;
 
@@ -85,7 +85,7 @@ TextureCache::TCacheEntryBase* TextureCache::CreateTexture(unsigned int width,
 {
 	D3D11_USAGE usage = D3D11_USAGE_DEFAULT;
 	D3D11_CPU_ACCESS_FLAG cpu_access = (D3D11_CPU_ACCESS_FLAG)0;
-	D3D11_SUBRESOURCE_DATA srdata, *data = NULL;
+	D3D11_SUBRESOURCE_DATA srdata, *data = nullptr;
 
 	if (tex_levels == 1)
 	{
@@ -134,7 +134,7 @@ void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFo
 		D3D::context->RSSetViewports(1, &vp);
 
 		// set transformation
-		if (NULL == efbcopycbuf[cbufid])
+		if (nullptr == efbcopycbuf[cbufid])
 		{
 			const D3D11_BUFFER_DESC cbdesc = CD3D11_BUFFER_DESC(28 * sizeof(float), D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DEFAULT);
 			D3D11_SUBRESOURCE_DATA data;
@@ -155,7 +155,7 @@ void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFo
 		else
 			D3D::SetPointCopySampler();
 
-		D3D::context->OMSetRenderTargets(1, &texture->GetRTV(), NULL);
+		D3D::context->OMSetRenderTargets(1, &texture->GetRTV(), nullptr);
 
 		// Create texture copy
 		D3D::drawShadedTexQuad(
@@ -208,7 +208,7 @@ TextureCache::~TextureCache()
 
 	g_encoder->Shutdown();
 	delete g_encoder;
-	g_encoder = NULL;
+	g_encoder = nullptr;
 }
 
 }
diff --git a/Source/Core/VideoBackends/D3D/VertexManager.cpp b/Source/Core/VideoBackends/D3D/VertexManager.cpp
index 06ade13fa2..a68f4d63e8 100644
--- a/Source/Core/VideoBackends/D3D/VertexManager.cpp
+++ b/Source/Core/VideoBackends/D3D/VertexManager.cpp
@@ -41,8 +41,8 @@ void VertexManager::CreateDeviceObjects()
 	m_vertex_buffers = new PID3D11Buffer[MAX_VBUFFER_COUNT];
 	for (m_current_index_buffer = 0; m_current_index_buffer < MAX_VBUFFER_COUNT; m_current_index_buffer++)
 	{
-		m_index_buffers[m_current_index_buffer] = NULL;
-		CHECK(SUCCEEDED(D3D::device->CreateBuffer(&bufdesc, NULL, &m_index_buffers[m_current_index_buffer])),
+		m_index_buffers[m_current_index_buffer] = nullptr;
+		CHECK(SUCCEEDED(D3D::device->CreateBuffer(&bufdesc, nullptr, &m_index_buffers[m_current_index_buffer])),
 		"Failed to create index buffer.");
 		D3D::SetDebugObjectName((ID3D11DeviceChild*)m_index_buffers[m_current_index_buffer], "index buffer of VertexManager");
 	}
@@ -50,8 +50,8 @@ void VertexManager::CreateDeviceObjects()
 	bufdesc.ByteWidth = VBUFFER_SIZE;
 	for (m_current_vertex_buffer = 0; m_current_vertex_buffer < MAX_VBUFFER_COUNT; m_current_vertex_buffer++)
 	{
-		m_vertex_buffers[m_current_vertex_buffer] = NULL;
-		CHECK(SUCCEEDED(D3D::device->CreateBuffer(&bufdesc, NULL, &m_vertex_buffers[m_current_vertex_buffer])),
+		m_vertex_buffers[m_current_vertex_buffer] = nullptr;
+		CHECK(SUCCEEDED(D3D::device->CreateBuffer(&bufdesc, nullptr, &m_vertex_buffers[m_current_vertex_buffer])),
 		"Failed to create vertex buffer.");
 		D3D::SetDebugObjectName((ID3D11DeviceChild*)m_vertex_buffers[m_current_vertex_buffer], "Vertex buffer of VertexManager");
 	}
@@ -167,7 +167,7 @@ void VertexManager::Draw(UINT stride)
 			D3D::context->DrawIndexed(IndexGenerator::GetIndexLen(), m_index_draw_offset, 0);
 			INCSTAT(stats.thisFrame.numIndexedDrawCalls);
 
-			D3D::context->GSSetShader(NULL, NULL, 0);
+			D3D::context->GSSetShader(nullptr, nullptr, 0);
 			((DX11::Renderer*)g_renderer)->RestoreCull();
 		}
 	}
@@ -191,7 +191,7 @@ void VertexManager::Draw(UINT stride)
 			D3D::context->DrawIndexed(IndexGenerator::GetIndexLen(), m_index_draw_offset, 0);
 			INCSTAT(stats.thisFrame.numIndexedDrawCalls);
 
-			D3D::context->GSSetShader(NULL, NULL, 0);
+			D3D::context->GSSetShader(nullptr, nullptr, 0);
 			((DX11::Renderer*)g_renderer)->RestoreCull();
 		}
 	}
diff --git a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
index 7d35d84a36..d51ce98b30 100644
--- a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
@@ -23,10 +23,10 @@ const VertexShaderCache::VSCacheEntry *VertexShaderCache::last_entry;
 VertexShaderUid VertexShaderCache::last_uid;
 UidChecker<VertexShaderUid,VertexShaderCode> VertexShaderCache::vertex_uid_checker;
 
-static ID3D11VertexShader* SimpleVertexShader = NULL;
-static ID3D11VertexShader* ClearVertexShader = NULL;
-static ID3D11InputLayout* SimpleLayout = NULL;
-static ID3D11InputLayout* ClearLayout = NULL;
+static ID3D11VertexShader* SimpleVertexShader = nullptr;
+static ID3D11VertexShader* ClearVertexShader = nullptr;
+static ID3D11InputLayout* SimpleLayout = nullptr;
+static ID3D11InputLayout* ClearLayout = nullptr;
 
 LinearDiskCache<VertexShaderUid, u8> g_vs_disk_cache;
 
@@ -35,7 +35,7 @@ ID3D11VertexShader* VertexShaderCache::GetClearVertexShader() { return ClearVert
 ID3D11InputLayout* VertexShaderCache::GetSimpleInputLayout() { return SimpleLayout; }
 ID3D11InputLayout* VertexShaderCache::GetClearInputLayout() { return ClearLayout; }
 
-ID3D11Buffer* vscbuf = NULL;
+ID3D11Buffer* vscbuf = nullptr;
 
 ID3D11Buffer* &VertexShaderCache::GetConstantBuffer()
 {
@@ -114,7 +114,7 @@ void VertexShaderCache::Init()
 
 	unsigned int cbsize = ((sizeof(VertexShaderConstants))&(~0xf))+0x10; // must be a multiple of 16
 	D3D11_BUFFER_DESC cbdesc = CD3D11_BUFFER_DESC(cbsize, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
-	HRESULT hr = D3D::device->CreateBuffer(&cbdesc, NULL, &vscbuf);
+	HRESULT hr = D3D::device->CreateBuffer(&cbdesc, nullptr, &vscbuf);
 	CHECK(hr==S_OK, "Create vertex shader constant buffer (size=%u)", cbsize);
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)vscbuf, "vertex shader constant buffer used to emulate the GX pipeline");
 
@@ -122,7 +122,7 @@ void VertexShaderCache::Init()
 	D3D::CompileVertexShader(simple_shader_code, sizeof(simple_shader_code), &blob);
 	D3D::device->CreateInputLayout(simpleelems, 2, blob->Data(), blob->Size(), &SimpleLayout);
 	SimpleVertexShader = D3D::CreateVertexShaderFromByteCode(blob);
-	if (SimpleLayout == NULL || SimpleVertexShader == NULL) PanicAlert("Failed to create simple vertex shader or input layout at %s %d\n", __FILE__, __LINE__);
+	if (SimpleLayout == nullptr || SimpleVertexShader == nullptr) PanicAlert("Failed to create simple vertex shader or input layout at %s %d\n", __FILE__, __LINE__);
 	blob->Release();
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)SimpleVertexShader, "simple vertex shader");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)SimpleLayout, "simple input layout");
@@ -130,7 +130,7 @@ void VertexShaderCache::Init()
 	D3D::CompileVertexShader(clear_shader_code, sizeof(clear_shader_code), &blob);
 	D3D::device->CreateInputLayout(clearelems, 2, blob->Data(), blob->Size(), &ClearLayout);
 	ClearVertexShader = D3D::CreateVertexShaderFromByteCode(blob);
-	if (ClearLayout == NULL || ClearVertexShader == NULL) PanicAlert("Failed to create clear vertex shader or input layout at %s %d\n", __FILE__, __LINE__);
+	if (ClearLayout == nullptr || ClearVertexShader == nullptr) PanicAlert("Failed to create clear vertex shader or input layout at %s %d\n", __FILE__, __LINE__);
 	blob->Release();
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)ClearVertexShader, "clear vertex shader");
 	D3D::SetDebugObjectName((ID3D11DeviceChild*)ClearLayout, "clear input layout");
@@ -152,7 +152,7 @@ void VertexShaderCache::Init()
 	if (g_Config.bEnableShaderDebugging)
 		Clear();
 
-	last_entry = NULL;
+	last_entry = nullptr;
 }
 
 void VertexShaderCache::Clear()
@@ -162,7 +162,7 @@ void VertexShaderCache::Clear()
 	vshaders.clear();
 	vertex_uid_checker.Invalidate();
 
-	last_entry = NULL;
+	last_entry = nullptr;
 }
 
 void VertexShaderCache::Shutdown()
@@ -196,7 +196,7 @@ bool VertexShaderCache::SetShader(u32 components)
 		if (uid == last_uid)
 		{
 			GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-			return (last_entry->shader != NULL);
+			return (last_entry->shader != nullptr);
 		}
 	}
 
@@ -209,16 +209,16 @@ bool VertexShaderCache::SetShader(u32 components)
 		last_entry = &entry;
 
 		GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-		return (entry.shader != NULL);
+		return (entry.shader != nullptr);
 	}
 
 	VertexShaderCode code;
 	GenerateVertexShaderCode(code, components, API_D3D);
 
-	D3DBlob* pbytecode = NULL;
+	D3DBlob* pbytecode = nullptr;
 	D3D::CompileVertexShader(code.GetBuffer(), (int)strlen(code.GetBuffer()), &pbytecode);
 
-	if (pbytecode == NULL)
+	if (pbytecode == nullptr)
 	{
 		GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true);
 		return false;
@@ -240,7 +240,7 @@ bool VertexShaderCache::SetShader(u32 components)
 bool VertexShaderCache::InsertByteCode(const VertexShaderUid &uid, D3DBlob* bcodeblob)
 {
 	ID3D11VertexShader* shader = D3D::CreateVertexShaderFromByteCode(bcodeblob);
-	if (shader == NULL)
+	if (shader == nullptr)
 		return false;
 
 	// TODO: Somehow make the debug name a bit more specific
diff --git a/Source/Core/VideoBackends/D3D/VertexShaderCache.h b/Source/Core/VideoBackends/D3D/VertexShaderCache.h
index 0c9c739f6b..2597963e55 100644
--- a/Source/Core/VideoBackends/D3D/VertexShaderCache.h
+++ b/Source/Core/VideoBackends/D3D/VertexShaderCache.h
@@ -40,7 +40,7 @@ private:
 
 		std::string code;
 
-		VSCacheEntry() : shader(NULL), bytecode(NULL) {}
+		VSCacheEntry() : shader(nullptr), bytecode(nullptr) {}
 		void SetByteCode(D3DBlob* blob)
 		{
 			SAFE_RELEASE(bytecode);
diff --git a/Source/Core/VideoBackends/D3D/XFBEncoder.cpp b/Source/Core/VideoBackends/D3D/XFBEncoder.cpp
index 25d69aed12..d32d76f88e 100644
--- a/Source/Core/VideoBackends/D3D/XFBEncoder.cpp
+++ b/Source/Core/VideoBackends/D3D/XFBEncoder.cpp
@@ -130,10 +130,10 @@ static const struct QuadVertex
 } QUAD_VERTS[4] = { { 0, 0 }, { 1, 0 }, { 0, 1 }, { 1, 1 } };
 
 XFBEncoder::XFBEncoder()
-	: m_out(NULL), m_outRTV(NULL), m_outStage(NULL), m_encodeParams(NULL),
-	m_quad(NULL), m_vShader(NULL), m_quadLayout(NULL), m_pShader(NULL),
-	m_xfbEncodeBlendState(NULL), m_xfbEncodeDepthState(NULL),
-	m_xfbEncodeRastState(NULL), m_efbSampler(NULL)
+	: m_out(nullptr), m_outRTV(nullptr), m_outStage(nullptr), m_encodeParams(nullptr),
+	m_quad(nullptr), m_vShader(nullptr), m_quadLayout(nullptr), m_pShader(nullptr),
+	m_xfbEncodeBlendState(nullptr), m_xfbEncodeDepthState(nullptr),
+	m_xfbEncodeRastState(nullptr), m_efbSampler(nullptr)
 { }
 
 void XFBEncoder::Init()
@@ -147,7 +147,7 @@ void XFBEncoder::Init()
 	D3D11_TEXTURE2D_DESC t2dd = CD3D11_TEXTURE2D_DESC(
 		DXGI_FORMAT_R8G8B8A8_UNORM, MAX_XFB_WIDTH/2, MAX_XFB_HEIGHT, 1, 1,
 		D3D11_BIND_RENDER_TARGET);
-	hr = D3D::device->CreateTexture2D(&t2dd, NULL, &m_out);
+	hr = D3D::device->CreateTexture2D(&t2dd, nullptr, &m_out);
 	CHECK(SUCCEEDED(hr), "create xfb encoder output texture");
 	D3D::SetDebugObjectName(m_out, "xfb encoder output texture");
 
@@ -164,7 +164,7 @@ void XFBEncoder::Init()
 	t2dd.Usage = D3D11_USAGE_STAGING;
 	t2dd.BindFlags = 0;
 	t2dd.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-	hr = D3D::device->CreateTexture2D(&t2dd, NULL, &m_outStage);
+	hr = D3D::device->CreateTexture2D(&t2dd, nullptr, &m_outStage);
 	CHECK(SUCCEEDED(hr), "create xfb encoder output staging buffer");
 	D3D::SetDebugObjectName(m_outStage, "xfb encoder output staging buffer");
 
@@ -172,7 +172,7 @@ void XFBEncoder::Init()
 
 	D3D11_BUFFER_DESC bd = CD3D11_BUFFER_DESC(sizeof(XFBEncodeParams),
 		D3D11_BIND_CONSTANT_BUFFER);
-	hr = D3D::device->CreateBuffer(&bd, NULL, &m_encodeParams);
+	hr = D3D::device->CreateBuffer(&bd, nullptr, &m_encodeParams);
 	CHECK(SUCCEEDED(hr), "create xfb encode params buffer");
 	D3D::SetDebugObjectName(m_encodeParams, "xfb encoder params buffer");
 
@@ -188,14 +188,14 @@ void XFBEncoder::Init()
 
 	// Create vertex shader
 
-	D3DBlob* bytecode = NULL;
+	D3DBlob* bytecode = nullptr;
 	if (!D3D::CompileVertexShader(XFB_ENCODE_VS, sizeof(XFB_ENCODE_VS), &bytecode))
 	{
 		ERROR_LOG(VIDEO, "XFB encode vertex shader failed to compile");
 		return;
 	}
 
-	hr = D3D::device->CreateVertexShader(bytecode->Data(), bytecode->Size(), NULL, &m_vShader);
+	hr = D3D::device->CreateVertexShader(bytecode->Data(), bytecode->Size(), nullptr, &m_vShader);
 	CHECK(SUCCEEDED(hr), "create xfb encode vertex shader");
 	D3D::SetDebugObjectName(m_vShader, "xfb encoder vertex shader");
 
@@ -279,8 +279,8 @@ void XFBEncoder::Encode(u8* dst, u32 width, u32 height, const EFBRectangle& srcR
 
 	// Set up all the state for XFB encoding
 
-	D3D::context->PSSetShader(m_pShader, NULL, 0);
-	D3D::context->VSSetShader(m_vShader, NULL, 0);
+	D3D::context->PSSetShader(m_pShader, nullptr, 0);
+	D3D::context->VSSetShader(m_vShader, nullptr, 0);
 
 	D3D::stateman->PushBlendState(m_xfbEncodeBlendState);
 	D3D::stateman->PushDepthState(m_xfbEncodeDepthState);
@@ -306,11 +306,11 @@ void XFBEncoder::Encode(u8* dst, u32 width, u32 height, const EFBRectangle& srcR
 	params.TexRight = FLOAT(targetRect.right) / g_renderer->GetTargetWidth();
 	params.TexBottom = FLOAT(targetRect.bottom) / g_renderer->GetTargetHeight();
 	params.Gamma = gamma;
-	D3D::context->UpdateSubresource(m_encodeParams, 0, NULL, &params, 0, 0);
+	D3D::context->UpdateSubresource(m_encodeParams, 0, nullptr, &params, 0, 0);
 
 	D3D::context->VSSetConstantBuffers(0, 1, &m_encodeParams);
 
-	D3D::context->OMSetRenderTargets(1, &m_outRTV, NULL);
+	D3D::context->OMSetRenderTargets(1, &m_outRTV, nullptr);
 
 	ID3D11ShaderResourceView* pEFB = FramebufferManager::GetEFBColorTexture()->GetSRV();
 
@@ -329,13 +329,13 @@ void XFBEncoder::Encode(u8* dst, u32 width, u32 height, const EFBRectangle& srcR
 
 	// Clean up state
 
-	IUnknown* nullDummy = NULL;
+	IUnknown* nullDummy = nullptr;
 
 	D3D::context->PSSetSamplers(0, 1, (ID3D11SamplerState**)&nullDummy);
 	D3D::context->PSSetShaderResources(0, 1, (ID3D11ShaderResourceView**)&nullDummy);
 	D3D::context->PSSetConstantBuffers(0, 1, (ID3D11Buffer**)&nullDummy);
 
-	D3D::context->OMSetRenderTargets(0, NULL, NULL);
+	D3D::context->OMSetRenderTargets(0, nullptr, nullptr);
 
 	D3D::context->VSSetConstantBuffers(0, 1, (ID3D11Buffer**)&nullDummy);
 
@@ -343,8 +343,8 @@ void XFBEncoder::Encode(u8* dst, u32 width, u32 height, const EFBRectangle& srcR
 	D3D::stateman->PopDepthState();
 	D3D::stateman->PopBlendState();
 
-	D3D::context->PSSetShader(NULL, NULL, 0);
-	D3D::context->VSSetShader(NULL, NULL, 0);
+	D3D::context->PSSetShader(nullptr, nullptr, 0);
+	D3D::context->VSSetShader(nullptr, nullptr, 0);
 
 	// Transfer staging buffer to GameCube/Wii RAM
 
diff --git a/Source/Core/VideoBackends/D3D/main.cpp b/Source/Core/VideoBackends/D3D/main.cpp
index 77ed8e9899..ae509cbfde 100644
--- a/Source/Core/VideoBackends/D3D/main.cpp
+++ b/Source/Core/VideoBackends/D3D/main.cpp
@@ -161,7 +161,7 @@ bool VideoBackend::Initialize(void *&window_handle)
 	UpdateActiveConfig();
 
 	window_handle = (void*)EmuWindow::Create((HWND)window_handle, GetModuleHandle(0), _T("Loading - Please wait."));
-	if (window_handle == NULL)
+	if (window_handle == nullptr)
 	{
 		ERROR_LOG(VIDEO, "An error has occurred while trying to create the window.");
 		return false;
@@ -230,8 +230,8 @@ void VideoBackend::Shutdown()
 		delete g_vertex_manager;
 		delete g_texture_cache;
 		delete g_renderer;
-		g_renderer = NULL;
-		g_texture_cache = NULL;
+		g_renderer = nullptr;
+		g_texture_cache = nullptr;
 	}
 }
 
diff --git a/Source/Core/VideoBackends/OGL/FramebufferManager.cpp b/Source/Core/VideoBackends/OGL/FramebufferManager.cpp
index 3fca224bb8..a9ccedf46d 100644
--- a/Source/Core/VideoBackends/OGL/FramebufferManager.cpp
+++ b/Source/Core/VideoBackends/OGL/FramebufferManager.cpp
@@ -81,19 +81,19 @@ FramebufferManager::FramebufferManager(int targetWidth, int targetHeight, int ms
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
 		glBindTexture(GL_TEXTURE_2D, m_efbDepth);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, m_targetWidth, m_targetHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, m_targetWidth, m_targetHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
 
 		glBindTexture(GL_TEXTURE_2D, m_resolvedColorTexture);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
 		// Bind target textures to the EFB framebuffer.
 
@@ -152,13 +152,13 @@ FramebufferManager::FramebufferManager(int targetWidth, int targetHeight, int ms
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
 		glBindTexture(GL_TEXTURE_2D, m_resolvedDepthTexture);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, m_targetWidth, m_targetHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, m_targetWidth, m_targetHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
 
 		// Bind resolved textures to resolved framebuffer.
 
@@ -446,7 +446,7 @@ XFBSourceBase* FramebufferManager::CreateXFBSource(unsigned int target_width, un
 	glActiveTexture(GL_TEXTURE0 + 9);
 	glBindTexture(GL_TEXTURE_2D, texture);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, target_width, target_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, target_width, target_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
 	return new XFBSource(texture);
 }
diff --git a/Source/Core/VideoBackends/OGL/GLExtensions/GLExtensions.cpp b/Source/Core/VideoBackends/OGL/GLExtensions/GLExtensions.cpp
index 3e690cc8d0..99f5004bda 100644
--- a/Source/Core/VideoBackends/OGL/GLExtensions/GLExtensions.cpp
+++ b/Source/Core/VideoBackends/OGL/GLExtensions/GLExtensions.cpp
@@ -1739,15 +1739,15 @@ namespace GLExtensions
 	void* GetFuncAddress(std::string name, void **func)
 	{
 		*func = GLInterface->GetFuncAddress(name);
-		if (*func == NULL)
+		if (*func == nullptr)
 		{
 #if defined(__linux__) || defined(__APPLE__)
 			// Give it a second try with dlsym
 			*func = dlsym(RTLD_NEXT, name.c_str());
 #endif
-			if (*func == NULL && _isES)
+			if (*func == nullptr && _isES)
 				*func = (void*)0xFFFFFFFF; // Easy to determine invalid function, just so we continue on
-			if (*func == NULL)
+			if (*func == nullptr)
 				ERROR_LOG(VIDEO, "Couldn't load function %s", name.c_str());
 		}
 		return *func;
@@ -1769,13 +1769,13 @@ namespace GLExtensions
 		// We need them to grab the extension list
 		// Also to check if there is an error grabbing the version
 		// If it fails then the user's drivers don't support GL 3.0
-		if (GetFuncAddress ("glGetIntegerv", (void**)&glGetIntegerv) == NULL)
+		if (GetFuncAddress ("glGetIntegerv", (void**)&glGetIntegerv) == nullptr)
 			return false;
-		if (GetFuncAddress("glGetString", (void**)&glGetString) == NULL)
+		if (GetFuncAddress("glGetString", (void**)&glGetString) == nullptr)
 			return false;
-		if (GetFuncAddress("glGetStringi", (void**)&glGetStringi) == NULL)
+		if (GetFuncAddress("glGetStringi", (void**)&glGetStringi) == nullptr)
 			return false;
-		if (GetFuncAddress("glGetError", (void**)&glGetError) == NULL)
+		if (GetFuncAddress("glGetError", (void**)&glGetError) == nullptr)
 			return false;
 
 		InitVersion();
diff --git a/Source/Core/VideoBackends/OGL/GLUtil.cpp b/Source/Core/VideoBackends/OGL/GLUtil.cpp
index abe2505e74..1e43f2a137 100644
--- a/Source/Core/VideoBackends/OGL/GLUtil.cpp
+++ b/Source/Core/VideoBackends/OGL/GLUtil.cpp
@@ -56,7 +56,7 @@ GLuint OpenGL_CompileProgram ( const char* vertexShader, const char* fragmentSha
 	GLuint programID = glCreateProgram();
 
 	// compile vertex shader
-	glShaderSource(vertexShaderID, 1, &vertexShader, NULL);
+	glShaderSource(vertexShaderID, 1, &vertexShader, nullptr);
 	glCompileShader(vertexShaderID);
 #if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL)
 	GLint Result = GL_FALSE;
@@ -75,7 +75,7 @@ GLuint OpenGL_CompileProgram ( const char* vertexShader, const char* fragmentSha
 #endif
 
 	// compile fragment shader
-	glShaderSource(fragmentShaderID, 1, &fragmentShader, NULL);
+	glShaderSource(fragmentShaderID, 1, &fragmentShader, nullptr);
 	glCompileShader(fragmentShaderID);
 #if defined(_DEBUG) || defined(DEBUGFAST) || defined(DEBUG_GLSL)
 	glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &Result);
diff --git a/Source/Core/VideoBackends/OGL/NativeVertexFormat.cpp b/Source/Core/VideoBackends/OGL/NativeVertexFormat.cpp
index dad409e47a..dd1ffc2dfd 100644
--- a/Source/Core/VideoBackends/OGL/NativeVertexFormat.cpp
+++ b/Source/Core/VideoBackends/OGL/NativeVertexFormat.cpp
@@ -50,9 +50,9 @@ static void SetPointer(u32 attrib, u32 stride, const AttributeFormat &format)
 
 	glEnableVertexAttribArray(attrib);
 	if (format.integer)
-		glVertexAttribIPointer(attrib, format.components, VarToGL(format.type), stride, (u8*)NULL + format.offset);
+		glVertexAttribIPointer(attrib, format.components, VarToGL(format.type), stride, (u8*)nullptr + format.offset);
 	else
-		glVertexAttribPointer(attrib, format.components, VarToGL(format.type), true, stride, (u8*)NULL + format.offset);
+		glVertexAttribPointer(attrib, format.components, VarToGL(format.type), true, stride, (u8*)nullptr + format.offset);
 }
 
 void GLVertexFormat::Initialize(const PortableVertexDeclaration &_vtx_decl)
diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 211cf5d937..929fcd0de8 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -51,7 +51,7 @@ void Init()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); // disable mipmaps
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	glBindFramebuffer(GL_FRAMEBUFFER, s_fbo);
 	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, s_texture, 0);
 	FramebufferManager::SetFramebuffer(0);
@@ -108,7 +108,7 @@ void Update ( u32 width, u32 height )
 		// alloc texture for framebuffer
 		glActiveTexture(GL_TEXTURE0+9);
 		glBindTexture(GL_TEXTURE_2D, s_texture);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	}
 }
 
diff --git a/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp b/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
index 68c1e44399..c4e150d7d0 100644
--- a/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
+++ b/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
@@ -194,7 +194,7 @@ SHADER* ProgramShaderCache::SetShader ( DSTALPHA_MODE dstAlphaMode, u32 componen
 
 	if (!CompileShader(newentry.shader, vcode.GetBuffer(), pcode.GetBuffer())) {
 		GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true);
-		return NULL;
+		return nullptr;
 	}
 
 	INCSTAT(stats.numPixelShadersCreated);
@@ -281,7 +281,7 @@ GLuint ProgramShaderCache::CompileSingleShader (GLuint type, const char* code )
 
 	const char *src[] = {s_glsl_header, code};
 
-	glShaderSource(result, 2, src, NULL);
+	glShaderSource(result, 2, src, nullptr);
 	glCompileShader(result);
 	GLint compileStatus;
 	glGetShaderiv(result, GL_COMPILE_STATUS, &compileStatus);
@@ -396,7 +396,7 @@ void ProgramShaderCache::Init(void)
 	CreateHeader();
 
 	CurrentProgram = 0;
-	last_entry = NULL;
+	last_entry = nullptr;
 }
 
 void ProgramShaderCache::Shutdown(void)
@@ -421,7 +421,7 @@ void ProgramShaderCache::Shutdown(void)
 			u8 *data = new u8[binary_size+sizeof(GLenum)];
 			u8 *binary = data + sizeof(GLenum);
 			GLenum *prog_format = (GLenum*)data;
-			glGetProgramBinary(entry.second.shader.glprogid, binary_size, NULL, prog_format, binary);
+			glGetProgramBinary(entry.second.shader.glprogid, binary_size, nullptr, prog_format, binary);
 
 			g_program_disk_cache.Append(entry.first, data, binary_size+sizeof(GLenum));
 			delete [] data;
@@ -443,7 +443,7 @@ void ProgramShaderCache::Shutdown(void)
 	vertex_uid_checker.Invalidate();
 
 	delete s_buffer;
-	s_buffer = 0;
+	s_buffer = nullptr;
 }
 
 void ProgramShaderCache::CreateHeader ( void )
diff --git a/Source/Core/VideoBackends/OGL/RasterFont.cpp b/Source/Core/VideoBackends/OGL/RasterFont.cpp
index 1f2eefdb8b..1b7845887b 100644
--- a/Source/Core/VideoBackends/OGL/RasterFont.cpp
+++ b/Source/Core/VideoBackends/OGL/RasterFont.cpp
@@ -168,9 +168,9 @@ RasterFont::RasterFont()
 	glBindBuffer(GL_ARRAY_BUFFER, VBO);
 	glBindVertexArray(VAO);
 	glEnableVertexAttribArray(SHADER_POSITION_ATTRIB);
-	glVertexAttribPointer(SHADER_POSITION_ATTRIB, 2, GL_FLOAT, 0, sizeof(GLfloat)*4, NULL);
+	glVertexAttribPointer(SHADER_POSITION_ATTRIB, 2, GL_FLOAT, 0, sizeof(GLfloat)*4, nullptr);
 	glEnableVertexAttribArray(SHADER_TEXTURE0_ATTRIB);
-	glVertexAttribPointer(SHADER_TEXTURE0_ATTRIB, 2, GL_FLOAT, 0, sizeof(GLfloat)*4, (GLfloat*)NULL+2);
+	glVertexAttribPointer(SHADER_TEXTURE0_ATTRIB, 2, GL_FLOAT, 0, sizeof(GLfloat)*4, (GLfloat*)nullptr+2);
 }
 
 RasterFont::~RasterFont()
diff --git a/Source/Core/VideoBackends/OGL/Render.cpp b/Source/Core/VideoBackends/OGL/Render.cpp
index b4530a0bdb..3116961f5d 100644
--- a/Source/Core/VideoBackends/OGL/Render.cpp
+++ b/Source/Core/VideoBackends/OGL/Render.cpp
@@ -95,7 +95,7 @@ static GLuint s_ShowEFBCopyRegions_VBO = 0;
 static GLuint s_ShowEFBCopyRegions_VAO = 0;
 static SHADER s_ShowEFBCopyRegions;
 
-static RasterFont* s_pfont = NULL;
+static RasterFont* s_pfont = nullptr;
 
 // 1 for no MSAA. Use s_MSAASamples > 1 to check for MSAA.
 static int s_MSAASamples = 1;
@@ -499,14 +499,14 @@ Renderer::Renderer()
 #if defined(_DEBUG) || defined(DEBUGFAST)
 	if (GLExtensions::Supports("GL_KHR_debug"))
 	{
-		glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, true);
-		glDebugMessageCallback( ErrorCallback, NULL );
+		glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, true);
+		glDebugMessageCallback( ErrorCallback, nullptr );
 		glEnable( GL_DEBUG_OUTPUT );
 	}
 	else if (GLExtensions::Supports("GL_ARB_debug_output"))
 	{
-		glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, true);
-		glDebugMessageCallbackARB( ErrorCallback, NULL );
+		glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, true);
+		glDebugMessageCallbackARB( ErrorCallback, nullptr );
 		glEnable( GL_DEBUG_OUTPUT );
 	}
 #endif
@@ -639,7 +639,7 @@ void Renderer::Shutdown()
 	s_ShowEFBCopyRegions_VBO = 0;
 
 	delete s_pfont;
-	s_pfont = 0;
+	s_pfont = nullptr;
 	s_ShowEFBCopyRegions.Destroy();
 }
 
@@ -671,9 +671,9 @@ void Renderer::Init()
 	glBindBuffer(GL_ARRAY_BUFFER, s_ShowEFBCopyRegions_VBO);
 	glBindVertexArray( s_ShowEFBCopyRegions_VAO );
 	glEnableVertexAttribArray(SHADER_POSITION_ATTRIB);
-	glVertexAttribPointer(SHADER_POSITION_ATTRIB, 2, GL_FLOAT, 0, sizeof(GLfloat)*5, NULL);
+	glVertexAttribPointer(SHADER_POSITION_ATTRIB, 2, GL_FLOAT, 0, sizeof(GLfloat)*5, nullptr);
 	glEnableVertexAttribArray(SHADER_COLOR0_ATTRIB);
-	glVertexAttribPointer(SHADER_COLOR0_ATTRIB, 3, GL_FLOAT, 0, sizeof(GLfloat)*5, (GLfloat*)NULL+2);
+	glVertexAttribPointer(SHADER_COLOR0_ATTRIB, 3, GL_FLOAT, 0, sizeof(GLfloat)*5, (GLfloat*)nullptr+2);
 }
 
 // Create On-Screen-Messages
@@ -703,7 +703,7 @@ void Renderer::DrawDebugInfo()
 		// 2*Coords + 3*Color
 		u32 length = stats.efb_regions.size() * sizeof(GLfloat) * (2+3)*2*6;
 		glBindBuffer(GL_ARRAY_BUFFER, s_ShowEFBCopyRegions_VBO);
-		glBufferData(GL_ARRAY_BUFFER, length, NULL, GL_STREAM_DRAW);
+		glBufferData(GL_ARRAY_BUFFER, length, nullptr, GL_STREAM_DRAW);
 		GLfloat *Vertices = (GLfloat*)glMapBufferRange(GL_ARRAY_BUFFER, 0, length, GL_MAP_WRITE_BIT);
 
 		// Draw EFB copy regions rectangles
@@ -1315,7 +1315,7 @@ void Renderer::SwapImpl(u32 xfbAddr, u32 fbWidth, u32 fbHeight,const EFBRectangl
 
 	// Copy the framebuffer to screen.
 
-	const XFBSourceBase* xfbSource = NULL;
+	const XFBSourceBase* xfbSource = nullptr;
 
 	if(g_ActiveConfig.bUseXFB)
 	{
diff --git a/Source/Core/VideoBackends/OGL/StreamBuffer.cpp b/Source/Core/VideoBackends/OGL/StreamBuffer.cpp
index 2de5490eaa..be7f4eeacd 100644
--- a/Source/Core/VideoBackends/OGL/StreamBuffer.cpp
+++ b/Source/Core/VideoBackends/OGL/StreamBuffer.cpp
@@ -141,7 +141,7 @@ class MapAndOrphan : public StreamBuffer
 public:
 	MapAndOrphan(u32 type, size_t size) : StreamBuffer(type, size) {
 		glBindBuffer(m_buffertype, m_buffer);
-		glBufferData(m_buffertype, m_size, NULL, GL_STREAM_DRAW);
+		glBufferData(m_buffertype, m_size, nullptr, GL_STREAM_DRAW);
 	}
 
 	~MapAndOrphan() {
@@ -150,7 +150,7 @@ public:
 	std::pair<u8*, size_t> Map(size_t size, u32 stride) override {
 		Align(stride);
 		if(m_iterator + size >= m_size) {
-			glBufferData(m_buffertype, m_size, NULL, GL_STREAM_DRAW);
+			glBufferData(m_buffertype, m_size, nullptr, GL_STREAM_DRAW);
 			m_iterator = 0;
 		}
 		u8* pointer = (u8*)glMapBufferRange(m_buffertype, m_iterator, size,
@@ -178,7 +178,7 @@ public:
 	MapAndSync(u32 type, size_t size) : StreamBuffer(type, size) {
 		CreateFences();
 		glBindBuffer(m_buffertype, m_buffer);
-		glBufferData(m_buffertype, m_size, NULL, GL_STREAM_DRAW);
+		glBufferData(m_buffertype, m_size, nullptr, GL_STREAM_DRAW);
 	}
 
 	~MapAndSync() {
@@ -223,7 +223,7 @@ public:
 		// PERSISTANT_BIT to make sure that the buffer can be used while mapped
 		// COHERENT_BIT is set so we don't have to use a MemoryBarrier on write
 		// CLIENT_STORAGE_BIT is set since we access the buffer more frequently on the client side then server side
-		glBufferStorage(m_buffertype, m_size, NULL,
+		glBufferStorage(m_buffertype, m_size, nullptr,
 			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_CLIENT_STORAGE_BIT); 
 		m_pointer = (u8*)glMapBufferRange(m_buffertype, 0, m_size,
 			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT); 
@@ -272,7 +272,7 @@ public:
 		glBindBuffer(m_buffertype, 0);
 		glFinish(); // ogl pipeline must be flushed, else this buffer can be in use
 		FreeAlignedMemory(m_pointer);
-		m_pointer = NULL;
+		m_pointer = nullptr;
 	}
 
 	std::pair<u8*, size_t> Map(size_t size, u32 stride) override {
@@ -299,7 +299,7 @@ class BufferSubData : public StreamBuffer
 public:
 	BufferSubData(u32 type, size_t size) : StreamBuffer(type, size) {
 		glBindBuffer(m_buffertype, m_buffer);
-		glBufferData(m_buffertype, size, 0, GL_STATIC_DRAW);
+		glBufferData(m_buffertype, size, nullptr, GL_STATIC_DRAW);
 		m_pointer = new u8[m_size];
 	}
 
diff --git a/Source/Core/VideoBackends/OGL/TextureCache.cpp b/Source/Core/VideoBackends/OGL/TextureCache.cpp
index cf17125f97..9262f9f4d1 100644
--- a/Source/Core/VideoBackends/OGL/TextureCache.cpp
+++ b/Source/Core/VideoBackends/OGL/TextureCache.cpp
@@ -242,7 +242,7 @@ TextureCache::TCacheEntryBase* TextureCache::CreateRenderTargetTexture(
 
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
 
-	glTexImage2D(GL_TEXTURE_2D, 0, gl_iformat, scaled_tex_w, scaled_tex_h, 0, gl_format, gl_type, NULL);
+	glTexImage2D(GL_TEXTURE_2D, 0, gl_iformat, scaled_tex_w, scaled_tex_h, 0, gl_format, gl_type, nullptr);
 	glBindTexture(GL_TEXTURE_2D, 0);
 
 	glGenFramebuffers(1, &entry->framebuffer);
diff --git a/Source/Core/VideoBackends/OGL/TextureConverter.cpp b/Source/Core/VideoBackends/OGL/TextureConverter.cpp
index 514dbd22f6..32225652f6 100644
--- a/Source/Core/VideoBackends/OGL/TextureConverter.cpp
+++ b/Source/Core/VideoBackends/OGL/TextureConverter.cpp
@@ -179,7 +179,7 @@ void Init()
 	glGenTextures(1, &s_dstTexture);
 	glBindTexture(GL_TEXTURE_2D, s_dstTexture);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, renderBufferWidth, renderBufferHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, renderBufferWidth, renderBufferHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	
 	
 	FramebufferManager::SetFramebuffer(s_texConvFrameBuffer[0]);
@@ -261,8 +261,8 @@ void EncodeToRamUsingShader(GLuint srcTexture, const TargetRectangle& sourceRc,
 		// in this way, we only have one vram->ram transfer, but maybe a bigger
 		// cpu overhead because of the pbo
 		glBindBuffer(GL_PIXEL_PACK_BUFFER, s_PBO);
-		glBufferData(GL_PIXEL_PACK_BUFFER, dstSize, NULL, GL_STREAM_READ);
-		glReadPixels(0, 0, (GLsizei)dstWidth, (GLsizei)dstHeight, GL_BGRA, GL_UNSIGNED_BYTE, 0);
+		glBufferData(GL_PIXEL_PACK_BUFFER, dstSize, nullptr, GL_STREAM_READ);
+		glReadPixels(0, 0, (GLsizei)dstWidth, (GLsizei)dstHeight, GL_BGRA, GL_UNSIGNED_BYTE, nullptr);
 		u8* pbo = (u8*)glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, dstSize, GL_MAP_READ_BIT);
 
 		for (int i = 0; i < readLoops; i++)
diff --git a/Source/Core/VideoBackends/OGL/VertexManager.cpp b/Source/Core/VideoBackends/OGL/VertexManager.cpp
index 4af1a48953..89dfda38e2 100644
--- a/Source/Core/VideoBackends/OGL/VertexManager.cpp
+++ b/Source/Core/VideoBackends/OGL/VertexManager.cpp
@@ -60,7 +60,7 @@ void VertexManager::CreateDeviceObjects()
 	s_indexBuffer = StreamBuffer::Create(GL_ELEMENT_ARRAY_BUFFER, MAX_IBUFFER_SIZE);
 	m_index_buffers = s_indexBuffer->m_buffer;
 
-	m_CurrentVertexFmt = NULL;
+	m_CurrentVertexFmt = nullptr;
 	m_last_vao = 0;
 }
 
@@ -120,9 +120,9 @@ void VertexManager::Draw(u32 stride)
 	}
 
 	if(g_ogl_config.bSupportsGLBaseVertex) {
-		glDrawRangeElementsBaseVertex(primitive_mode, 0, max_index, index_size, GL_UNSIGNED_SHORT, (u8*)NULL+s_index_offset, (GLint)s_baseVertex);
+		glDrawRangeElementsBaseVertex(primitive_mode, 0, max_index, index_size, GL_UNSIGNED_SHORT, (u8*)nullptr+s_index_offset, (GLint)s_baseVertex);
 	} else {
-		glDrawRangeElements(primitive_mode, 0, max_index, index_size, GL_UNSIGNED_SHORT, (u8*)NULL+s_index_offset);
+		glDrawRangeElements(primitive_mode, 0, max_index, index_size, GL_UNSIGNED_SHORT, (u8*)nullptr+s_index_offset);
 	}
 	INCSTAT(stats.thisFrame.numIndexedDrawCalls);
 }
diff --git a/Source/Core/VideoBackends/OGL/main.cpp b/Source/Core/VideoBackends/OGL/main.cpp
index b37f428531..d902485bb8 100644
--- a/Source/Core/VideoBackends/OGL/main.cpp
+++ b/Source/Core/VideoBackends/OGL/main.cpp
@@ -256,20 +256,20 @@ void VideoBackend::Video_Cleanup() {
 		TextureConverter::Shutdown();
 		VertexLoaderManager::Shutdown();
 		delete g_sampler_cache;
-		g_sampler_cache = NULL;
+		g_sampler_cache = nullptr;
 		delete g_texture_cache;
-		g_texture_cache = NULL;
+		g_texture_cache = nullptr;
 		PostProcessing::Shutdown();
 		ProgramShaderCache::Shutdown();
 		VertexShaderManager::Shutdown();
 		PixelShaderManager::Shutdown();
 		delete g_perf_query;
-		g_perf_query = NULL;
+		g_perf_query = nullptr;
 		delete g_vertex_manager;
-		g_vertex_manager = NULL;
+		g_vertex_manager = nullptr;
 		OpcodeDecoder_Shutdown();
 		delete g_renderer;
-		g_renderer = NULL;
+		g_renderer = nullptr;
 		GLInterface->ClearCurrent();
 	}
 }
diff --git a/Source/Core/VideoBackends/Software/BPMemLoader.cpp b/Source/Core/VideoBackends/Software/BPMemLoader.cpp
index 738b909fc0..7672e233ac 100644
--- a/Source/Core/VideoBackends/Software/BPMemLoader.cpp
+++ b/Source/Core/VideoBackends/Software/BPMemLoader.cpp
@@ -100,7 +100,7 @@ void SWBPWritten(int address, int newvalue)
 			u32 tlutTMemAddr = (newvalue & 0x3FF) << 9;
 			u32 tlutXferCount = (newvalue & 0x1FFC00) >> 5;
 
-			u8 *ptr = 0;
+			u8 *ptr = nullptr;
 
 			// TODO - figure out a cleaner way.
 			if (Core::g_CoreStartupParameter.bWii)
diff --git a/Source/Core/VideoBackends/Software/DebugUtil.cpp b/Source/Core/VideoBackends/Software/DebugUtil.cpp
index 6b5b1f7c7d..e6995b5068 100644
--- a/Source/Core/VideoBackends/Software/DebugUtil.cpp
+++ b/Source/Core/VideoBackends/Software/DebugUtil.cpp
@@ -39,7 +39,7 @@ void Init()
 	{
 		memset(ObjectBuffer[i], 0, sizeof(ObjectBuffer[i]));
 		DrawnToBuffer[i] = false;
-		ObjectBufferName[i] = 0;
+		ObjectBufferName[i] = nullptr;
 		BufferBase[i] = 0;
 	}
 }
diff --git a/Source/Core/VideoBackends/Software/OpcodeDecoder.cpp b/Source/Core/VideoBackends/Software/OpcodeDecoder.cpp
index 069876741d..ff2b4f0bb8 100644
--- a/Source/Core/VideoBackends/Software/OpcodeDecoder.cpp
+++ b/Source/Core/VideoBackends/Software/OpcodeDecoder.cpp
@@ -19,7 +19,7 @@ typedef void (*DecodingFunction)(u32);
 
 namespace OpcodeDecoder
 {
-static DecodingFunction currentFunction = NULL;
+static DecodingFunction currentFunction = nullptr;
 static u32 minCommandSize;
 static u16 streamSize;
 static u16 streamAddress;
diff --git a/Source/Core/VideoBackends/Software/SWCommandProcessor.cpp b/Source/Core/VideoBackends/Software/SWCommandProcessor.cpp
index d8288adc1a..8329024e3a 100644
--- a/Source/Core/VideoBackends/Software/SWCommandProcessor.cpp
+++ b/Source/Core/VideoBackends/Software/SWCommandProcessor.cpp
@@ -101,7 +101,7 @@ void Init()
 	interruptSet = false;
 	interruptWaiting = false;
 
-	g_pVideoData = 0;
+	g_pVideoData = nullptr;
 	g_bSkipCurrentFrame = false;
 }
 
diff --git a/Source/Core/VideoBackends/Software/SWRenderer.cpp b/Source/Core/VideoBackends/Software/SWRenderer.cpp
index c56390ba90..deb934ee2f 100644
--- a/Source/Core/VideoBackends/Software/SWRenderer.cpp
+++ b/Source/Core/VideoBackends/Software/SWRenderer.cpp
@@ -28,7 +28,7 @@ static std::string s_sScreenshotName;
 
 // Rasterfont isn't compatible with GLES
 // degasus: I think it does, but I can't test it
-RasterFont* s_pfont = NULL;
+RasterFont* s_pfont = nullptr;
 
 void SWRenderer::Init()
 {
@@ -44,7 +44,7 @@ void SWRenderer::Shutdown()
 	if (GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL)
 	{
 		delete s_pfont;
-		s_pfont = 0;
+		s_pfont = nullptr;
 	}
 }
 
diff --git a/Source/Core/VideoBackends/Software/SWVertexLoader.cpp b/Source/Core/VideoBackends/Software/SWVertexLoader.cpp
index fbecdaeb79..63d96dcd2c 100644
--- a/Source/Core/VideoBackends/Software/SWVertexLoader.cpp
+++ b/Source/Core/VideoBackends/Software/SWVertexLoader.cpp
@@ -40,7 +40,7 @@ SWVertexLoader::SWVertexLoader() :
 SWVertexLoader::~SWVertexLoader()
 {
 	delete m_SetupUnit;
-	m_SetupUnit = NULL;
+	m_SetupUnit = nullptr;
 }
 
 void SWVertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
@@ -89,8 +89,8 @@ void SWVertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
 	m_VertexSize = 0;
 
 	// Reset pipeline
-	m_positionLoader = NULL;
-	m_normalLoader = NULL;
+	m_positionLoader = nullptr;
+	m_normalLoader = nullptr;
 	m_NumAttributeLoaders = 0;
 
 	// Reset vertex
@@ -164,7 +164,7 @@ void SWVertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
 		m_normalLoader = VertexLoader_Normal::GetFunction(g_VtxDesc.Normal,
 			m_CurrentVat->g0.NormalFormat, m_CurrentVat->g0.NormalElements, m_CurrentVat->g0.NormalIndex3);
 
-		if (m_normalLoader == 0)
+		if (m_normalLoader == nullptr)
 		{
 			ERROR_LOG(VIDEO, "VertexLoader_Normal::GetFunction returned zero!");
 		}
@@ -176,7 +176,7 @@ void SWVertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
 		switch (colDesc[i])
 		{
 		case NOT_PRESENT:
-			m_colorLoader[i] = NULL;
+			m_colorLoader[i] = nullptr;
 			break;
 		case DIRECT:
 			switch (colComp[i])
diff --git a/Source/Core/VideoBackends/Software/SWmain.cpp b/Source/Core/VideoBackends/Software/SWmain.cpp
index c5178f682c..4651e444a4 100644
--- a/Source/Core/VideoBackends/Software/SWmain.cpp
+++ b/Source/Core/VideoBackends/Software/SWmain.cpp
@@ -60,7 +60,7 @@ std::string VideoSoftware::GetName()
 
 void *DllDebugger(void *_hParent, bool Show)
 {
-	return NULL;
+	return nullptr;
 }
 
 void VideoSoftware::ShowConfig(void *_hParent)
diff --git a/Source/Core/VideoBackends/Software/TextureSampler.cpp b/Source/Core/VideoBackends/Software/TextureSampler.cpp
index 87ac79563b..b77248ff9d 100644
--- a/Source/Core/VideoBackends/Software/TextureSampler.cpp
+++ b/Source/Core/VideoBackends/Software/TextureSampler.cpp
@@ -106,7 +106,7 @@ void SampleMip(s32 s, s32 t, s32 mip, bool linear, u8 texmap, u8 *sample)
 	TexImage0& ti0 = texUnit.texImage0[subTexmap];
 	TexTLUT& texTlut = texUnit.texTlut[subTexmap];
 
-	u8 *imageSrc, *imageSrcOdd = NULL;
+	u8 *imageSrc, *imageSrcOdd = nullptr;
 	if (texUnit.texImage1[subTexmap].image_type)
 	{
 		imageSrc = &texMem[texUnit.texImage1[subTexmap].tmem_even * TMEM_LINE_SIZE];