Modernize project codebase (#906)

* Fixed boats falling and a TP glitch #266

* Replaced every C-style cast with C++ ones

* Replaced every C-style cast with C++ ones

* Fixed boats falling and a TP glitch #266

* Updated NULL to nullptr and fixing some type issues

* Modernized and fixed a few bugs

- Replaced most instances of `NULL` with `nullptr`.
- Replaced most `shared_ptr(new ...)` with `make_shared`.
- Removed the `nullptr` macro as it was interfering with the actual nullptr keyword in some instances.

* Fixing more conflicts

* Replace int loops with size_t and start work on overrides

* Add safety checks and fix a issue with vector going OOR

7 files changed, 251 insertions, 251 deletions

diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d10_shaders.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d10_shaders.inl
index d4d2bb22..6ea0d142 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d10_shaders.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d10_shaders.inl
@@ -1364,7 +1364,7 @@ static DWORD pshader_exceptional_blend_12[276] = {
 };
 
 static ProgramWithCachedVariableLocations pshader_exceptional_blend_arr[13] = {
-   { NULL, 0, },
+   { nullptr, 0, },
    { pshader_exceptional_blend_1, 1340, },
    { pshader_exceptional_blend_2, 1444, },
    { pshader_exceptional_blend_3, 1424, },
@@ -2672,10 +2672,10 @@ static ProgramWithCachedVariableLocations pshader_filter_arr[32] = {
    { pshader_filter_9, 708, },
    { pshader_filter_10, 1644, },
    { pshader_filter_11, 1372, },
-   { NULL, 0, },
-   { NULL, 0, },
-   { NULL, 0, },
-   { NULL, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
    { pshader_filter_16, 1740, },
    { pshader_filter_17, 1732, },
    { pshader_filter_18, 1820, },
@@ -2688,10 +2688,10 @@ static ProgramWithCachedVariableLocations pshader_filter_arr[32] = {
    { pshader_filter_25, 1468, },
    { pshader_filter_26, 1820, },
    { pshader_filter_27, 1548, },
-   { NULL, 0, },
-   { NULL, 0, },
-   { NULL, 0, },
-   { NULL, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
 };
 
 static DWORD pshader_blur_2[320] = {
@@ -3193,8 +3193,8 @@ static DWORD pshader_blur_9[621] = {
 };
 
 static ProgramWithCachedVariableLocations pshader_blur_arr[10] = {
-   { NULL, 0, },
-   { NULL, 0, },
+   { nullptr, 0, },
+   { nullptr, 0, },
    { pshader_blur_2, 1280, },
    { pshader_blur_3, 1452, },
    { pshader_blur_4, 1624, },
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.cpp b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.cpp
index 9ebf6c5d..b9fb627b 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.cpp
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.cpp
@@ -64,7 +64,7 @@ static void *map_buffer(ID3D1XContext *ctx, ID3D11Buffer *buf, bool discard)
    HRESULT hr = ctx->Map(buf, 0, discard ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE_NO_OVERWRITE, 0, &msr);
    if (FAILED(hr)) {
       report_d3d_error(hr, "Map", "of buffer");
-      return NULL;
+      return nullptr;
    } else
       return msr.pData;
 }
@@ -76,12 +76,12 @@ static void unmap_buffer(ID3D1XContext *ctx, ID3D11Buffer *buf)
 
 static RADINLINE void set_pixel_shader(ID3D11DeviceContext *ctx, ID3D11PixelShader *shader)
 {
-   ctx->PSSetShader(shader, NULL, 0);
+   ctx->PSSetShader(shader, nullptr, 0);
 }
 
 static RADINLINE void set_vertex_shader(ID3D11DeviceContext *ctx, ID3D11VertexShader *shader)
 {
-   ctx->VSSetShader(shader, NULL, 0);
+   ctx->VSSetShader(shader, nullptr, 0);
 }
 
 static ID3D11BlendState *create_blend_state(ID3D11Device *dev, BOOL blend, D3D11_BLEND src, D3D11_BLEND dst)
@@ -100,7 +100,7 @@ static ID3D11BlendState *create_blend_state(ID3D11Device *dev, BOOL blend, D3D11
    HRESULT hr = dev->CreateBlendState(&desc, &res);
    if (FAILED(hr)) {
       report_d3d_error(hr, "CreateBlendState", "");
-      res = NULL;
+      res = nullptr;
    }
 
    return res;
@@ -113,10 +113,10 @@ static void create_pixel_shader(ProgramWithCachedVariableLocations *p, ProgramWi
 {
    *p = *src;
    if(p->bytecode) {
-      HRESULT hr = gdraw->d3d_device->CreatePixelShader(p->bytecode, p->size, NULL, &p->pshader);
+      HRESULT hr = gdraw->d3d_device->CreatePixelShader(p->bytecode, p->size, nullptr, &p->pshader);
       if (FAILED(hr)) {
          report_d3d_error(hr, "CreatePixelShader", "");
-         p->pshader = NULL;
+         p->pshader = nullptr;
          return;
       }
    }
@@ -126,10 +126,10 @@ static void create_vertex_shader(ProgramWithCachedVariableLocations *p, ProgramW
 {
    *p = *src;
    if(p->bytecode) {
-      HRESULT hr = gdraw->d3d_device->CreateVertexShader(p->bytecode, p->size, NULL, &p->vshader);
+      HRESULT hr = gdraw->d3d_device->CreateVertexShader(p->bytecode, p->size, nullptr, &p->vshader);
       if (FAILED(hr)) {
          report_d3d_error(hr, "CreateVertexShader", "");
-         p->vshader = NULL;
+         p->vshader = nullptr;
          return;
       }
    }
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.h b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.h
index 7fd7012f..47fe3c29 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.h
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d11.h
@@ -42,7 +42,7 @@ IDOC extern GDrawFunctions * gdraw_D3D11_CreateContext(ID3D11Device *dev, ID3D11
    There can only be one D3D GDraw context active at any one time.
 
    If initialization fails for some reason (the main reason would be an out of memory condition),
-   NULL is returned. Otherwise, you can pass the return value to IggySetGDraw. */
+   nullptr is returned. Otherwise, you can pass the return value to IggySetGDraw. */
 
 IDOC extern void gdraw_D3D11_DestroyContext(void);
 /* Destroys the current GDraw context, if any. */
@@ -70,7 +70,7 @@ IDOC extern void gdraw_D3D11_SetTileOrigin(ID3D11RenderTargetView *main_rt, ID3D
    If your rendertarget uses multisampling, you also need to specify a shader
    resource view for a non-MSAA rendertarget texture (identically sized to main_rt)
    in non_msaa_rt. This is only used if the Flash content includes non-standard
-   blend modes which have to use a special blend shader, so you can leave it NULL
+   blend modes which have to use a special blend shader, so you can leave it nullptr
    if you forbid such content.
 
    You need to call this before Iggy calls any rendering functions. */
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d1x_shared.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d1x_shared.inl
index 9a447833..0722308a 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d1x_shared.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d1x_shared.inl
@@ -196,16 +196,16 @@ static void safe_release(T *&p)
 {
    if (p) {
       p->Release();
-      p = NULL;
+      p = nullptr;
    }
 }
 
 static void report_d3d_error(HRESULT hr, const char *call, const char *context)
 {
    if (hr == E_OUTOFMEMORY)
-      IggyGDrawSendWarning(NULL, "GDraw D3D out of memory in %s%s", call, context);
+      IggyGDrawSendWarning(nullptr, "GDraw D3D out of memory in %s%s", call, context);
    else
-      IggyGDrawSendWarning(NULL, "GDraw D3D error in %s%s: 0x%08x", call, context, hr);
+      IggyGDrawSendWarning(nullptr, "GDraw D3D error in %s%s: 0x%08x", call, context, hr);
 }
 
 static void unbind_resources(void)
@@ -214,13 +214,13 @@ static void unbind_resources(void)
 
    // unset active textures and vertex/index buffers,
    // to make sure there are no dangling refs
-   static ID3D1X(ShaderResourceView) *no_views[3] = { 0 };
-   ID3D1X(Buffer) *no_vb = NULL;
+   static ID3D1X(ShaderResourceView) *no_views[3] = { nullptr };
+   ID3D1X(Buffer) *no_vb = nullptr;
    UINT no_offs = 0;
 
    d3d->PSSetShaderResources(0, 3, no_views);
    d3d->IASetVertexBuffers(0, 1, &no_vb, &no_offs, &no_offs);
-   d3d->IASetIndexBuffer(NULL, DXGI_FORMAT_UNKNOWN, 0);
+   d3d->IASetIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0);
 }
 
 static void api_free_resource(GDrawHandle *r)
@@ -251,11 +251,11 @@ static void RADLINK gdraw_UnlockHandles(GDrawStats * /*stats*/)
 
 static void *start_write_dyn(DynBuffer *buf, U32 size)
 {
-   U8 *ptr = NULL;
+   U8 *ptr = nullptr;
 
    if (size > buf->size) {
-      IggyGDrawSendWarning(NULL, "GDraw dynamic vertex buffer usage of %d bytes in one call larger than buffer size %d", size, buf->size);
-      return NULL;
+      IggyGDrawSendWarning(nullptr, "GDraw dynamic vertex buffer usage of %d bytes in one call larger than buffer size %d", size, buf->size);
+      return nullptr;
    }
 
    // update statistics
@@ -270,7 +270,7 @@ static void *start_write_dyn(DynBuffer *buf, U32 size)
    // discard buffer whenever the current write position is 0;
    // done this way so that if a DISCARD Map() were to fail, we would
    // just keep retrying the next time around.
-   ptr = (U8 *) map_buffer(gdraw->d3d_context, buf->buffer, buf->write_pos == 0);
+   ptr = static_cast<U8 *>(map_buffer(gdraw->d3d_context, buf->buffer, buf->write_pos == 0));
    if (ptr) {
       ptr += buf->write_pos; // we return pointer to write position in buffer
       buf->alloc_pos = buf->write_pos + size; // bump alloc position
@@ -373,19 +373,19 @@ extern GDrawTexture *gdraw_D3D1X_(WrappedTextureCreate)(ID3D1X(ShaderResourceVie
 {
    GDrawStats stats={0};
    GDrawHandle *p = gdraw_res_alloc_begin(gdraw->texturecache, 0, &stats); // it may need to free one item to give us a handle
-   p->handle.tex.d3d = NULL;
+   p->handle.tex.d3d = nullptr;
    p->handle.tex.d3d_view = tex_view;
-   p->handle.tex.d3d_rtview = NULL;
+   p->handle.tex.d3d_rtview = nullptr;
    p->handle.tex.w = 1;
    p->handle.tex.h = 1;
-   gdraw_HandleCacheAllocateEnd(p, 0, NULL, GDRAW_HANDLE_STATE_user_owned);
+   gdraw_HandleCacheAllocateEnd(p, 0, nullptr, GDRAW_HANDLE_STATE_user_owned);
    return (GDrawTexture *) p;
 }
 
 extern void gdraw_D3D1X_(WrappedTextureChange)(GDrawTexture *tex, ID3D1X(ShaderResourceView) *tex_view)
 {
    GDrawHandle *p = (GDrawHandle *) tex;
-   p->handle.tex.d3d = NULL;
+   p->handle.tex.d3d = nullptr;
    p->handle.tex.d3d_view = tex_view;
 }
 
@@ -407,12 +407,12 @@ static void RADLINK gdraw_SetTextureUniqueID(GDrawTexture *tex, void *old_id, vo
 
 static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height, gdraw_texture_format format, U32 flags, GDraw_MakeTexture_ProcessingInfo *p, GDrawStats *stats)
 {
-   GDrawHandle *t = NULL;
+   GDrawHandle *t = nullptr;
    DXGI_FORMAT dxgi_fmt;
    S32 bpp, size = 0, nmips = 0;
 
    if (width >= 16384 || height >= 16384) {
-      IggyGDrawSendWarning(NULL, "GDraw texture size too large (%d x %d), dimension limit is 16384", width, height);
+      IggyGDrawSendWarning(nullptr, "GDraw texture size too large (%d x %d), dimension limit is 16384", width, height);
       return false;
    }
 
@@ -433,7 +433,7 @@ static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height,
    // try to allocate memory for the client to write to
    p->texture_data = (U8 *) IggyGDrawMalloc(size);
    if (!p->texture_data) {
-      IggyGDrawSendWarning(NULL, "GDraw out of memory to store texture data to pass to D3D for %d x %d texture", width, height);
+      IggyGDrawSendWarning(nullptr, "GDraw out of memory to store texture data to pass to D3D for %d x %d texture", width, height);
       return false;
    }
 
@@ -446,9 +446,9 @@ static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height,
 
    t->handle.tex.w = width;
    t->handle.tex.h = height;
-   t->handle.tex.d3d = NULL;
-   t->handle.tex.d3d_view = NULL;
-   t->handle.tex.d3d_rtview = NULL;
+   t->handle.tex.d3d = nullptr;
+   t->handle.tex.d3d_view = nullptr;
+   t->handle.tex.d3d_rtview = nullptr;
 
    p->texture_type = GDRAW_TEXTURE_TYPE_rgba;
    p->p0 = t;
@@ -474,7 +474,7 @@ static rrbool RADLINK gdraw_MakeTextureMore(GDraw_MakeTexture_ProcessingInfo * /
 
 static GDrawTexture * RADLINK gdraw_MakeTextureEnd(GDraw_MakeTexture_ProcessingInfo *p, GDrawStats *stats)
 {
-   GDrawHandle *t = (GDrawHandle *) p->p0;
+   GDrawHandle *t = static_cast<GDrawHandle *>(p->p0);
    D3D1X_(SUBRESOURCE_DATA) mipdata[24];
    S32 i, w, h, nmips, bpp;
    HRESULT hr = S_OK;
@@ -512,7 +512,7 @@ static GDrawTexture * RADLINK gdraw_MakeTextureEnd(GDraw_MakeTexture_ProcessingI
 
    // and create a corresponding shader resource view
    failed_call = "CreateShaderResourceView";
-   hr = gdraw->d3d_device->CreateShaderResourceView(t->handle.tex.d3d, NULL, &t->handle.tex.d3d_view);
+   hr = gdraw->d3d_device->CreateShaderResourceView(t->handle.tex.d3d, nullptr, &t->handle.tex.d3d_view);
 
 done:
    if (!FAILED(hr)) {
@@ -525,7 +525,7 @@ done:
       safe_release(t->handle.tex.d3d_view);
 
       gdraw_HandleCacheAllocateFail(t);
-      t = NULL;
+      t = nullptr;
       report_d3d_error(hr, failed_call, " while creating texture");
    }
 
@@ -554,8 +554,8 @@ static void RADLINK gdraw_UpdateTextureEnd(GDrawTexture *t, void * /*unique_id*/
 static void RADLINK gdraw_FreeTexture(GDrawTexture *tt, void *unique_id, GDrawStats *stats)
 {
    GDrawHandle *t = (GDrawHandle *) tt;
-   assert(t != NULL); // @GDRAW_ASSERT
-   if (t->owner == unique_id || unique_id == NULL) {
+   assert(t != nullptr); // @GDRAW_ASSERT
+   if (t->owner == unique_id || unique_id == nullptr) {
       if (t->cache == &gdraw->rendertargets) {
          gdraw_HandleCacheUnlock(t);
          // cache it by simply not freeing it
@@ -595,7 +595,7 @@ static void RADLINK gdraw_SetAntialiasTexture(S32 width, U8 *rgba)
       return;
    }
 
-   hr = gdraw->d3d_device->CreateShaderResourceView(gdraw->aa_tex, NULL, &gdraw->aa_tex_view);
+   hr = gdraw->d3d_device->CreateShaderResourceView(gdraw->aa_tex, nullptr, &gdraw->aa_tex_view);
    if (FAILED(hr)) {
       report_d3d_error(hr, "CreateShaderResourceView", " while creating texture");
       safe_release(gdraw->aa_tex);
@@ -616,8 +616,8 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
    if (p->vertex_data && p->index_data) {
       GDrawHandle *vb = gdraw_res_alloc_begin(gdraw->vbufcache, vbuf_size + ibuf_size, stats);
       if (vb) {
-         vb->handle.vbuf.verts = NULL;
-         vb->handle.vbuf.inds = NULL;
+         vb->handle.vbuf.verts = nullptr;
+         vb->handle.vbuf.inds = nullptr;
 
          p->vertex_data_length = vbuf_size;
          p->index_data_length = ibuf_size;
@@ -643,7 +643,7 @@ static rrbool RADLINK gdraw_MakeVertexBufferMore(GDraw_MakeVertexBuffer_Processi
 
 static GDrawVertexBuffer * RADLINK gdraw_MakeVertexBufferEnd(GDraw_MakeVertexBuffer_ProcessingInfo *p, GDrawStats * /*stats*/)
 {
-   GDrawHandle *vb = (GDrawHandle *) p->p0;
+   GDrawHandle *vb = static_cast<GDrawHandle *>(p->p0);
 
    HRESULT hr;
    D3D1X_(BUFFER_DESC) vbdesc = { static_cast<U32>(p->vertex_data_length), D3D1X_(USAGE_IMMUTABLE), D3D1X_(BIND_VERTEX_BUFFER), 0U, 0U };
@@ -661,7 +661,7 @@ static GDrawVertexBuffer * RADLINK gdraw_MakeVertexBufferEnd(GDraw_MakeVertexBuf
       safe_release(vb->handle.vbuf.inds);
 
       gdraw_HandleCacheAllocateFail(vb);
-      vb = NULL;
+      vb = nullptr;
 
       report_d3d_error(hr, "CreateBuffer", " creating vertex buffer");
    } else {
@@ -682,7 +682,7 @@ static rrbool RADLINK gdraw_TryLockVertexBuffer(GDrawVertexBuffer *vb, void *uni
 static void RADLINK gdraw_FreeVertexBuffer(GDrawVertexBuffer *vb, void *unique_id, GDrawStats *stats)
 {
    GDrawHandle *h = (GDrawHandle *) vb;
-   assert(h != NULL); // @GDRAW_ASSERT
+   assert(h != nullptr); // @GDRAW_ASSERT
    if (h->owner == unique_id)
       gdraw_res_free(h, stats);
 }
@@ -712,31 +712,31 @@ static GDrawHandle *get_color_rendertarget(GDrawStats *stats)
    // ran out of RTs, allocate a new one
    S32 size = gdraw->frametex_width * gdraw->frametex_height * 4;
    if (gdraw->rendertargets.bytes_free < size) {
-      IggyGDrawSendWarning(NULL, "GDraw rendertarget allocation failed: hit size limit of %d bytes", gdraw->rendertargets.total_bytes);
-      return NULL;
+      IggyGDrawSendWarning(nullptr, "GDraw rendertarget allocation failed: hit size limit of %d bytes", gdraw->rendertargets.total_bytes);
+      return nullptr;
    }
 
    t = gdraw_HandleCacheAllocateBegin(&gdraw->rendertargets);
    if (!t) {
-      IggyGDrawSendWarning(NULL, "GDraw rendertarget allocation failed: hit handle limit");
+      IggyGDrawSendWarning(nullptr, "GDraw rendertarget allocation failed: hit handle limit");
       return t;
    }
 
    D3D1X_(TEXTURE2D_DESC) desc = { static_cast<U32>(gdraw->frametex_width), static_cast<U32>(gdraw->frametex_height), 1U, 1U, DXGI_FORMAT_R8G8B8A8_UNORM, { 1, 0 },
       D3D1X_(USAGE_DEFAULT), D3D1X_(BIND_SHADER_RESOURCE) | D3D1X_(BIND_RENDER_TARGET), 0U, 0U };
 
-   t->handle.tex.d3d = NULL;
-   t->handle.tex.d3d_view = NULL;
-   t->handle.tex.d3d_rtview = NULL;
+   t->handle.tex.d3d = nullptr;
+   t->handle.tex.d3d_view = nullptr;
+   t->handle.tex.d3d_rtview = nullptr;
 
-   HRESULT hr = gdraw->d3d_device->CreateTexture2D(&desc, NULL, &t->handle.tex.d3d);
+   HRESULT hr = gdraw->d3d_device->CreateTexture2D(&desc, nullptr, &t->handle.tex.d3d);
    failed_call = "CreateTexture2D";
    if (!FAILED(hr)) {
-      hr = gdraw->d3d_device->CreateShaderResourceView(t->handle.tex.d3d, NULL, &t->handle.tex.d3d_view);
+      hr = gdraw->d3d_device->CreateShaderResourceView(t->handle.tex.d3d, nullptr, &t->handle.tex.d3d_view);
       failed_call = "CreateTexture2D";
    }
    if (!FAILED(hr)) {
-      hr = gdraw->d3d_device->CreateRenderTargetView(t->handle.tex.d3d, NULL, &t->handle.tex.d3d_rtview);
+      hr = gdraw->d3d_device->CreateRenderTargetView(t->handle.tex.d3d, nullptr, &t->handle.tex.d3d_rtview);
       failed_call = "CreateRenderTargetView";
    }
 
@@ -748,7 +748,7 @@ static GDrawHandle *get_color_rendertarget(GDrawStats *stats)
 
       report_d3d_error(hr, failed_call, " creating rendertarget");
 
-      return NULL;
+      return nullptr;
    }
 
    gdraw_HandleCacheAllocateEnd(t, size, (void *) 1, GDRAW_HANDLE_STATE_locked);
@@ -768,10 +768,10 @@ static ID3D1X(DepthStencilView) *get_rendertarget_depthbuffer(GDrawStats *stats)
       D3D1X_(TEXTURE2D_DESC) desc = { static_cast<U32>(gdraw->frametex_width), static_cast<U32>(gdraw->frametex_height), 1U, 1U, DXGI_FORMAT_D24_UNORM_S8_UINT, { 1, 0 },
          D3D1X_(USAGE_DEFAULT), D3D1X_(BIND_DEPTH_STENCIL), 0U, 0U };
 
-      HRESULT hr = gdraw->d3d_device->CreateTexture2D(&desc, NULL, &gdraw->rt_depth_buffer);
+      HRESULT hr = gdraw->d3d_device->CreateTexture2D(&desc, nullptr, &gdraw->rt_depth_buffer);
       failed_call = "CreateTexture2D";
       if (!FAILED(hr)) {
-         hr = gdraw->d3d_device->CreateDepthStencilView(gdraw->rt_depth_buffer, NULL, &gdraw->depth_buffer[1]);
+         hr = gdraw->d3d_device->CreateDepthStencilView(gdraw->rt_depth_buffer, nullptr, &gdraw->depth_buffer[1]);
          failed_call = "CreateDepthStencilView while creating rendertarget";
       }
 
@@ -861,7 +861,7 @@ static void disable_scissor(int force)
 
 static void set_viewport_raw(S32 x, S32 y, S32 w, S32 h)
 {
-   D3D1X_(VIEWPORT) vp = { (ViewCoord) x, (ViewCoord) y, (ViewCoord) w, (ViewCoord) h, 0.0f, 1.0f };
+   D3D1X_(VIEWPORT) vp = { static_cast<ViewCoord>(x), static_cast<ViewCoord>(y), static_cast<ViewCoord>(w), static_cast<ViewCoord>(h), 0.0f, 1.0f };
    gdraw->d3d_context->RSSetViewports(1, &vp);
    gdraw->cview.x = x;
    gdraw->cview.y = y;
@@ -891,8 +891,8 @@ static void set_projection_raw(S32 x0, S32 x1, S32 y0, S32 y1)
 {
    gdraw->projection[0] = 2.0f / (x1-x0);
    gdraw->projection[1] = 2.0f / (y1-y0);
-   gdraw->projection[2] = (x1+x0)/(F32)(x0-x1);
-   gdraw->projection[3] = (y1+y0)/(F32)(y0-y1);
+   gdraw->projection[2] = (x1+x0)/static_cast<F32>(x0 - x1);
+   gdraw->projection[3] = (y1+y0)/static_cast<F32>(y0 - y1);
 
    set_projection_base();
 }
@@ -1120,7 +1120,7 @@ static void set_render_target(GDrawStats *stats)
       gdraw->d3d_context->OMSetRenderTargets(1, &target, gdraw->depth_buffer[0]);
       gdraw->d3d_context->RSSetState(gdraw->raster_state[gdraw->main_msaa]);
    } else {
-      ID3D1X(DepthStencilView) *depth = NULL;
+      ID3D1X(DepthStencilView) *depth = nullptr;
       if (gdraw->cur->flags & (GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_id | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_stencil))
          depth = get_rendertarget_depthbuffer(stats);
 
@@ -1135,15 +1135,15 @@ static void set_render_target(GDrawStats *stats)
 static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_texture_format /*format*/, U32 flags, void *owner, GDrawStats *stats)
 {
    GDrawFramebufferState *n = gdraw->cur+1;
-   GDrawHandle *t = NULL;
+   GDrawHandle *t = nullptr;
    if (gdraw->tw == 0 || gdraw->th == 0) {
-      IggyGDrawSendWarning(NULL, "GDraw warning: w=0,h=0 rendertarget");
+      IggyGDrawSendWarning(nullptr, "GDraw warning: w=0,h=0 rendertarget");
       return false;
    }
 
    if (n >= &gdraw->frame[MAX_RENDER_STACK_DEPTH]) {
       assert(0);
-      IggyGDrawSendWarning(NULL, "GDraw rendertarget nesting exceeds MAX_RENDER_STACK_DEPTH");
+      IggyGDrawSendWarning(nullptr, "GDraw rendertarget nesting exceeds MAX_RENDER_STACK_DEPTH");
       return false;
    }
 
@@ -1157,10 +1157,10 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
 
    n->flags = flags;
    n->color_buffer = t;
-   assert(n->color_buffer != NULL); // @GDRAW_ASSERT
+   assert(n->color_buffer != nullptr); // @GDRAW_ASSERT
 
    ++gdraw->cur;
-   gdraw->cur->cached = owner != NULL;
+   gdraw->cur->cached = owner != nullptr;
    if (owner) {
       gdraw->cur->base_x = region->x0;
       gdraw->cur->base_y = region->y0;
@@ -1171,7 +1171,7 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
    set_render_target(stats);
    assert(gdraw->frametex_width >= gdraw->tw && gdraw->frametex_height >= gdraw->th); // @GDRAW_ASSERT
 
-   S32 k = (S32) (t - gdraw->rendertargets.handle);
+   S32 k = static_cast<S32>(t - gdraw->rendertargets.handle);
 
    if (region) {
       gswf_recti r;
@@ -1197,7 +1197,7 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
 
       if (r.x1 <= r.x0 || r.y1 <= r.y0) { // region doesn't intersect with current tile
          --gdraw->cur;
-         gdraw_FreeTexture((GDrawTexture *) t, 0, stats);
+         gdraw_FreeTexture((GDrawTexture *) t, nullptr, stats);
          // note: don't send a warning since this will happen during regular tiled rendering
          return false;
       }
@@ -1231,17 +1231,17 @@ static GDrawTexture *RADLINK gdraw_TextureDrawBufferEnd(GDrawStats *stats)
 {
    GDrawFramebufferState *n =   gdraw->cur;
    GDrawFramebufferState *m = --gdraw->cur;
-   if (gdraw->tw == 0 || gdraw->th == 0) return 0;
+   if (gdraw->tw == 0 || gdraw->th == 0) return nullptr;
 
    if (n >= &gdraw->frame[MAX_RENDER_STACK_DEPTH])
-      return 0; // already returned a warning in Begin
+      return nullptr; // already returned a warning in Begin
 
    assert(m >= gdraw->frame);  // bug in Iggy -- unbalanced
 
    if (m != gdraw->frame) {
-      assert(m->color_buffer != NULL); // @GDRAW_ASSERT
+      assert(m->color_buffer != nullptr); // @GDRAW_ASSERT
    }
-   assert(n->color_buffer != NULL); // @GDRAW_ASSERT
+   assert(n->color_buffer != nullptr); // @GDRAW_ASSERT
 
    // switch back to old render target
    set_render_target(stats);
@@ -1291,15 +1291,15 @@ static void RADLINK gdraw_ClearID(void)
 // assuming the depth buffer has been mappped to 0..1
 static F32 depth_from_id(S32 id)
 {
-   return 1.0f - ((F32) id + 1.0f) / MAX_DEPTH_VALUE;
+   return 1.0f - (static_cast<F32>(id) + 1.0f) / MAX_DEPTH_VALUE;
 }
 
 static void set_texture(S32 texunit, GDrawTexture *tex, rrbool nearest, S32 wrap)
 {
    ID3D1XContext *d3d = gdraw->d3d_context;
 
-   if (tex == NULL) {
-      ID3D1X(ShaderResourceView) *notex = NULL;
+   if (tex == nullptr) {
+      ID3D1X(ShaderResourceView) *notex = nullptr;
       d3d->PSSetShaderResources(texunit, 1, &notex);
    } else {
       GDrawHandle *h = (GDrawHandle *) tex;
@@ -1310,7 +1310,7 @@ static void set_texture(S32 texunit, GDrawTexture *tex, rrbool nearest, S32 wrap
 
 static void RADLINK gdraw_Set3DTransform(F32 *mat)
 {
-   if (mat == NULL)
+   if (mat == nullptr)
       gdraw->use_3d = 0;
    else {
       gdraw->use_3d = 1;
@@ -1326,7 +1326,7 @@ static int set_renderstate_full(S32 vertex_format, GDrawRenderState *r, GDrawSta
    set_vertex_shader(d3d, gdraw->vert[vertex_format].vshader);
    
    // set vertex shader constants
-   if (VertexVars *vvars = (VertexVars *) map_buffer(gdraw->d3d_context, gdraw->cb_vertex, true)) {
+   if (VertexVars *vvars = static_cast<VertexVars *>(map_buffer(gdraw->d3d_context, gdraw->cb_vertex, true))) {
       F32 depth = depth_from_id(r->id);
       if (!r->use_world_space)
          gdraw_ObjectSpace(vvars->world[0], r->o2w, depth, 0.0f);
@@ -1373,9 +1373,9 @@ static int set_renderstate_full(S32 vertex_format, GDrawRenderState *r, GDrawSta
          // in stencil set mode, prefer not doing any shading at all
          // but if alpha test is on, we need to make an exception
 
-#ifndef GDRAW_D3D11_LEVEL9 // level9 can't do NULL PS it seems
+#ifndef GDRAW_D3D11_LEVEL9 // level9 can't do nullptr PS it seems
          if (which != GDRAW_TEXTURE_alpha_test)
-            program = NULL;
+            program = nullptr;
          else
 #endif
          {
@@ -1391,7 +1391,7 @@ static int set_renderstate_full(S32 vertex_format, GDrawRenderState *r, GDrawSta
    set_texture(0, r->tex[0], r->nearest0, r->wrap0);
 
    // pixel shader constants
-   if (PixelCommonVars *pvars = (PixelCommonVars *) map_buffer(gdraw->d3d_context, gdraw->cb_ps_common, true)) {
+   if (PixelCommonVars *pvars = static_cast<PixelCommonVars *>(map_buffer(gdraw->d3d_context, gdraw->cb_ps_common, true))) {
       memcpy(pvars->color_mul, r->color, 4*sizeof(float));
 
       if (r->cxf_add) {
@@ -1485,13 +1485,13 @@ static int vertsize[GDRAW_vformat__basic_count] = {
 //   Draw triangles with a given renderstate
 //
 
-static void tag_resources(void *r1, void *r2=NULL, void *r3=NULL, void *r4=NULL)
+static void tag_resources(void *r1, void *r2=nullptr, void *r3=nullptr, void *r4=nullptr)
 {
    U64 now = gdraw->frame_counter;
-   if (r1) ((GDrawHandle *) r1)->fence.value = now;
-   if (r2) ((GDrawHandle *) r2)->fence.value = now;
-   if (r3) ((GDrawHandle *) r3)->fence.value = now;
-   if (r4) ((GDrawHandle *) r4)->fence.value = now;
+   if (r1) static_cast<GDrawHandle *>(r1)->fence.value = now;
+   if (r2) static_cast<GDrawHandle *>(r2)->fence.value = now;
+   if (r3) static_cast<GDrawHandle *>(r3)->fence.value = now;
+   if (r4) static_cast<GDrawHandle *>(r4)->fence.value = now;
 }
 
 static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimitive *p, GDrawVertexBuffer *buf, GDrawStats *stats)
@@ -1508,10 +1508,10 @@ static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimiti
    d3d->IASetInputLayout(gdraw->inlayout[vfmt]);
 
    if (vb) {
-      UINT offs = (UINT) (UINTa) p->vertices;
+      UINT offs = static_cast<UINT>((UINTa)p->vertices);
 
       d3d->IASetVertexBuffers(0, 1, &vb->handle.vbuf.verts, &stride, &offs);
-      d3d->IASetIndexBuffer(vb->handle.vbuf.inds, DXGI_FORMAT_R16_UINT, (UINT) (UINTa) p->indices);
+      d3d->IASetIndexBuffer(vb->handle.vbuf.inds, DXGI_FORMAT_R16_UINT, static_cast<UINT>((UINTa)p->indices));
       d3d->DrawIndexed(p->num_indices, 0, 0);
    } else if (p->indices) {
       U32 vbytes = p->num_vertices * stride;
@@ -1588,10 +1588,10 @@ static void set_pixel_constant(F32 *constant, F32 x, F32 y, F32 z, F32 w)
 static void do_screen_quad(gswf_recti *s, const F32 *tc, GDrawStats *stats)
 {
    ID3D1XContext *d3d = gdraw->d3d_context;
-   F32 px0 = (F32) s->x0, py0 = (F32) s->y0, px1 = (F32) s->x1, py1 = (F32) s->y1;
+   F32 px0 = static_cast<F32>(s->x0), py0 = static_cast<F32>(s->y0), px1 = static_cast<F32>(s->x1), py1 = static_cast<F32>(s->y1);
 
    // generate vertex data
-   gswf_vertex_xyst *vert = (gswf_vertex_xyst *) start_write_dyn(&gdraw->dyn_vb, 4 * sizeof(gswf_vertex_xyst));
+   gswf_vertex_xyst *vert = static_cast<gswf_vertex_xyst *>(start_write_dyn(&gdraw->dyn_vb, 4 * sizeof(gswf_vertex_xyst)));
    if (!vert)
       return;
 
@@ -1602,7 +1602,7 @@ static void do_screen_quad(gswf_recti *s, const F32 *tc, GDrawStats *stats)
    UINT offs = end_write_dyn(&gdraw->dyn_vb);
    UINT stride = sizeof(gswf_vertex_xyst);
 
-   if (VertexVars *vvars = (VertexVars *) map_buffer(gdraw->d3d_context, gdraw->cb_vertex, true)) {
+   if (VertexVars *vvars = static_cast<VertexVars *>(map_buffer(gdraw->d3d_context, gdraw->cb_vertex, true))) {
       gdraw_PixelSpace(vvars->world[0]);
       memcpy(vvars->x3d, gdraw->projmat, 12*sizeof(F32));
       unmap_buffer(gdraw->d3d_context, gdraw->cb_vertex);
@@ -1636,7 +1636,7 @@ static void manual_clear(gswf_recti *r, GDrawStats *stats)
    set_projection_raw(0, gdraw->frametex_width, gdraw->frametex_height, 0);
    set_pixel_shader(d3d, gdraw->clear_ps.pshader);
 
-   if (PixelCommonVars *pvars = (PixelCommonVars *) map_buffer(gdraw->d3d_context, gdraw->cb_ps_common, true)) {
+   if (PixelCommonVars *pvars = static_cast<PixelCommonVars *>(map_buffer(gdraw->d3d_context, gdraw->cb_ps_common, true))) {
       memset(pvars, 0, sizeof(*pvars));
       unmap_buffer(gdraw->d3d_context, gdraw->cb_ps_common);
       d3d->PSSetConstantBuffers(0, 1, &gdraw->cb_ps_common);
@@ -1650,7 +1650,7 @@ static void gdraw_DriverBlurPass(GDrawRenderState *r, int taps,  float *data, gs
    set_texture(0, r->tex[0], false, GDRAW_WRAP_clamp);
 
    set_pixel_shader(gdraw->d3d_context, gdraw->blur_prog[taps].pshader);
-   PixelParaBlur *para = (PixelParaBlur *) start_ps_constants(gdraw->cb_blur);
+   PixelParaBlur *para = static_cast<PixelParaBlur *>(start_ps_constants(gdraw->cb_blur));
    memcpy(para->clamp, clamp, 4 * sizeof(float));
    memcpy(para->tap, data, taps * 4 * sizeof(float));
    end_ps_constants(gdraw->cb_blur);
@@ -1661,13 +1661,13 @@ static void gdraw_DriverBlurPass(GDrawRenderState *r, int taps,  float *data, gs
 
 static void gdraw_Colormatrix(GDrawRenderState *r, gswf_recti *s, float *tc, GDrawStats *stats)
 {
-   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, 0, stats))
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, nullptr, stats))
       return;
 
    set_texture(0, r->tex[0], false, GDRAW_WRAP_clamp);
    set_pixel_shader(gdraw->d3d_context, gdraw->colormatrix.pshader);
 
-   PixelParaColorMatrix *para = (PixelParaColorMatrix *) start_ps_constants(gdraw->cb_colormatrix);
+   PixelParaColorMatrix *para = static_cast<PixelParaColorMatrix *>(start_ps_constants(gdraw->cb_colormatrix));
    memcpy(para->data, r->shader_data, 5 * 4 * sizeof(float));
    end_ps_constants(gdraw->cb_colormatrix);
 
@@ -1679,7 +1679,7 @@ static void gdraw_Colormatrix(GDrawRenderState *r, gswf_recti *s, float *tc, GDr
 static gswf_recti *get_valid_rect(GDrawTexture *tex)
 {
    GDrawHandle *h = (GDrawHandle *) tex;
-   S32 n = (S32) (h - gdraw->rendertargets.handle);
+   S32 n = static_cast<S32>(h - gdraw->rendertargets.handle);
    assert(n >= 0 && n <= MAX_RENDER_STACK_DEPTH+1);
    return &gdraw->rt_valid[n];
 }
@@ -1697,7 +1697,7 @@ static void set_clamp_constant(F32 *constant, GDrawTexture *tex)
 
 static void gdraw_Filter(GDrawRenderState *r, gswf_recti *s, float *tc, int isbevel, GDrawStats *stats)
 {
-   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, NULL, stats))
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, nullptr, stats))
       return;
 
    set_texture(0, r->tex[0], false, GDRAW_WRAP_clamp);
@@ -1705,12 +1705,12 @@ static void gdraw_Filter(GDrawRenderState *r, gswf_recti *s, float *tc, int isbe
    set_texture(2, r->tex[2], false, GDRAW_WRAP_clamp);
    set_pixel_shader(gdraw->d3d_context, gdraw->filter_prog[isbevel][r->filter_mode].pshader);
 
-   PixelParaFilter *para = (PixelParaFilter *) start_ps_constants(gdraw->cb_filter);
+   PixelParaFilter *para = static_cast<PixelParaFilter *>(start_ps_constants(gdraw->cb_filter));
    set_clamp_constant(para->clamp0, r->tex[0]);
    set_clamp_constant(para->clamp1, r->tex[1]);
    set_pixel_constant(para->color, r->shader_data[0], r->shader_data[1], r->shader_data[2], r->shader_data[3]);
    set_pixel_constant(para->color2, r->shader_data[8], r->shader_data[9], r->shader_data[10], r->shader_data[11]);
-   set_pixel_constant(para->tc_off, -r->shader_data[4] / (F32)gdraw->frametex_width, -r->shader_data[5] / (F32)gdraw->frametex_height, r->shader_data[6], 0);
+   set_pixel_constant(para->tc_off, -r->shader_data[4] / static_cast<F32>(gdraw->frametex_width), -r->shader_data[5] / static_cast<F32>(gdraw->frametex_height), r->shader_data[6], 0);
    end_ps_constants(gdraw->cb_filter);
 
    do_screen_quad(s, tc, stats);
@@ -1732,10 +1732,10 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
    if (s.x1 < s.x0 || s.y1 < s.y0)
       return;
 
-   tc[0] = (s.x0 - gdraw->tx0p) / (F32) gdraw->frametex_width;
-   tc[1] = (s.y0 - gdraw->ty0p) / (F32) gdraw->frametex_height;
-   tc[2] = (s.x1 - gdraw->tx0p) / (F32) gdraw->frametex_width;
-   tc[3] = (s.y1 - gdraw->ty0p) / (F32) gdraw->frametex_height;
+   tc[0] = (s.x0 - gdraw->tx0p) / static_cast<F32>(gdraw->frametex_width);
+   tc[1] = (s.y0 - gdraw->ty0p) / static_cast<F32>(gdraw->frametex_height);
+   tc[2] = (s.x1 - gdraw->tx0p) / static_cast<F32>(gdraw->frametex_width);
+   tc[3] = (s.y1 - gdraw->ty0p) / static_cast<F32>(gdraw->frametex_height);
 
    // clear to known render state
    d3d->OMSetBlendState(gdraw->blend_state[GDRAW_BLEND_none], four_zeros, ~0u);
@@ -1785,7 +1785,7 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
             assert(0);
       }
    } else {
-      GDrawHandle *blend_tex = NULL;
+      GDrawHandle *blend_tex = nullptr;
 
       // for crazy blend modes, we need to read back from the framebuffer
       // and do the blending in the pixel shader. we do this with copies
@@ -1818,10 +1818,10 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
             d3d->PSSetSamplers(1, 1, &gdraw->sampler_state[0][GDRAW_WRAP_clamp]);
 
             // calculate texture coordinate remapping
-            rescale1[0] = gdraw->frametex_width / (F32) texdesc.Width;
-            rescale1[1] = gdraw->frametex_height / (F32) texdesc.Height;
-            rescale1[2] = (gdraw->vx - gdraw->tx0 + gdraw->tx0p) / (F32) texdesc.Width;
-            rescale1[3] = (gdraw->vy - gdraw->ty0 + gdraw->ty0p) / (F32) texdesc.Height;
+            rescale1[0] = gdraw->frametex_width / static_cast<F32>(texdesc.Width);
+            rescale1[1] = gdraw->frametex_height / static_cast<F32>(texdesc.Height);
+            rescale1[2] = (gdraw->vx - gdraw->tx0 + gdraw->tx0p) / static_cast<F32>(texdesc.Width);
+            rescale1[3] = (gdraw->vy - gdraw->ty0 + gdraw->ty0p) / static_cast<F32>(texdesc.Height);
          } else {
             D3D1X_(BOX) box = { 0,0,0,0,0,1 };
             S32 dx = 0, dy = 0;
@@ -1854,7 +1854,7 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
       do_screen_quad(&s, tc, stats);
       tag_resources(r->tex[0], r->tex[1]);
       if (blend_tex)
-         gdraw_FreeTexture((GDrawTexture *) blend_tex, 0, stats);
+         gdraw_FreeTexture((GDrawTexture *) blend_tex, nullptr, stats);
    }
 }
 
@@ -1869,18 +1869,18 @@ static void destroy_shader(ProgramWithCachedVariableLocations *p)
 {
    if (p->pshader) {
       p->pshader->Release();
-      p->pshader = NULL;
+      p->pshader = nullptr;
    }
 }
 
 static ID3D1X(Buffer) *create_dynamic_buffer(U32 size, U32 bind)
 {
    D3D1X_(BUFFER_DESC) desc = { size, D3D1X_(USAGE_DYNAMIC), bind, D3D1X_(CPU_ACCESS_WRITE), 0 };
-   ID3D1X(Buffer) *buf = NULL;
-   HRESULT hr = gdraw->d3d_device->CreateBuffer(&desc, NULL, &buf);
+   ID3D1X(Buffer) *buf = nullptr;
+   HRESULT hr = gdraw->d3d_device->CreateBuffer(&desc, nullptr, &buf);
    if (FAILED(hr)) {
       report_d3d_error(hr, "CreateBuffer", " creating dynamic vertex buffer");
-      buf = NULL;
+      buf = nullptr;
    }
    return buf;
 }
@@ -1917,7 +1917,7 @@ static void create_all_shaders_and_state(void)
       HRESULT hr = d3d->CreateInputLayout(vformats[i].desc, vformats[i].nelem, vsh->bytecode, vsh->size, &gdraw->inlayout[i]);
       if (FAILED(hr)) {
          report_d3d_error(hr, "CreateInputLayout", "");
-         gdraw->inlayout[i] = NULL;
+         gdraw->inlayout[i] = nullptr;
       }
    }
 
@@ -2036,11 +2036,11 @@ static void create_all_shaders_and_state(void)
       hr = gdraw->d3d_device->CreateBuffer(&bufdesc, &data, &gdraw->quad_ib);
       if (FAILED(hr)) {
          report_d3d_error(hr, "CreateBuffer", " for constants");
-         gdraw->quad_ib = NULL;
+         gdraw->quad_ib = nullptr;
       }
       IggyGDrawFree(inds);
    } else
-      gdraw->quad_ib = NULL;
+      gdraw->quad_ib = nullptr;
 }
 
 static void destroy_all_shaders_and_state()
@@ -2113,7 +2113,7 @@ static void free_gdraw()
    if (gdraw->texturecache) IggyGDrawFree(gdraw->texturecache);
    if (gdraw->vbufcache) IggyGDrawFree(gdraw->vbufcache);
    IggyGDrawFree(gdraw);
-   gdraw = NULL;
+   gdraw = nullptr;
 }
 
 static bool alloc_dynbuffer(U32 size)
@@ -2149,7 +2149,7 @@ static bool alloc_dynbuffer(U32 size)
    gdraw->max_quad_vert_count = RR_MIN(size / sizeof(gswf_vertex_xyst), QUAD_IB_COUNT * 4);
    gdraw->max_quad_vert_count &= ~3; // must be multiple of four
 
-   return gdraw->dyn_vb.buffer != NULL && gdraw->dyn_ib.buffer != NULL;
+   return gdraw->dyn_vb.buffer != nullptr && gdraw->dyn_ib.buffer != nullptr;
 }
 
 int gdraw_D3D1X_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S32 num_bytes)
@@ -2188,7 +2188,7 @@ int gdraw_D3D1X_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S3
             IggyGDrawFree(gdraw->texturecache);
          }
          gdraw->texturecache = make_handle_cache(GDRAW_D3D1X_(RESOURCE_texture));
-         return gdraw->texturecache != NULL;
+         return gdraw->texturecache != nullptr;
 
       case GDRAW_D3D1X_(RESOURCE_vertexbuffer):
          if (gdraw->vbufcache) {
@@ -2196,7 +2196,7 @@ int gdraw_D3D1X_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S3
             IggyGDrawFree(gdraw->vbufcache);
          }
          gdraw->vbufcache = make_handle_cache(GDRAW_D3D1X_(RESOURCE_vertexbuffer));
-         return gdraw->vbufcache != NULL;
+         return gdraw->vbufcache != nullptr;
 
       case GDRAW_D3D1X_(RESOURCE_dynbuffer):
          unbind_resources();
@@ -2212,7 +2212,7 @@ int gdraw_D3D1X_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S3
 static GDrawFunctions *create_context(ID3D1XDevice *dev, ID3D1XContext *ctx, S32 w, S32 h)
 {
    gdraw = (GDraw *) IggyGDrawMalloc(sizeof(*gdraw));
-   if (!gdraw) return NULL;
+   if (!gdraw) return nullptr;
 
    memset(gdraw, 0, sizeof(*gdraw));
 
@@ -2227,7 +2227,7 @@ static GDrawFunctions *create_context(ID3D1XDevice *dev, ID3D1XContext *ctx, S32
 
    if (!gdraw->texturecache || !gdraw->vbufcache || !alloc_dynbuffer(gdraw_limits[GDRAW_D3D1X_(RESOURCE_dynbuffer)].num_bytes)) {
       free_gdraw();
-      return NULL;
+      return nullptr;
    }
 
    create_all_shaders_and_state();
@@ -2298,7 +2298,7 @@ void gdraw_D3D1X_(DestroyContext)(void)
       if (gdraw->texturecache)   gdraw_res_flush(gdraw->texturecache, &stats);
       if (gdraw->vbufcache)      gdraw_res_flush(gdraw->vbufcache, &stats);
 
-      gdraw->d3d_device = NULL;
+      gdraw->d3d_device = nullptr;
    }
 
    free_gdraw();
@@ -2361,7 +2361,7 @@ void RADLINK gdraw_D3D1X_(GetResourceUsageStats)(gdraw_resourcetype type, S32 *h
       case GDRAW_D3D1X_(RESOURCE_texture):         cache = gdraw->texturecache; break;
       case GDRAW_D3D1X_(RESOURCE_vertexbuffer):    cache = gdraw->vbufcache; break;
       case GDRAW_D3D1X_(RESOURCE_dynbuffer):       *handles_used = 0; *bytes_used = gdraw->last_dyn_maxalloc; return;
-      default:                                     cache = NULL; break;
+      default:                                     cache = nullptr; break;
    }
 
    *handles_used = *bytes_used = 0;
@@ -2392,14 +2392,14 @@ static S32 num_pixels(S32 w, S32 h, S32 mipmaps)
 GDrawTexture * RADLINK gdraw_D3D1X_(MakeTextureFromResource)(U8 *resource_file, S32 /*len*/, IggyFileTextureRaw *texture)
 {
    const char *failed_call="";
-   U8 *free_data = 0;
-   GDrawTexture *t=0;
+   U8 *free_data = nullptr;
+   GDrawTexture *t=nullptr;
    S32 width, height, mipmaps, size, blk;
-   ID3D1X(Texture2D) *tex=0;
-   ID3D1X(ShaderResourceView) *view=0;
+   ID3D1X(Texture2D) *tex=nullptr;
+   ID3D1X(ShaderResourceView) *view=nullptr;
 
    DXGI_FORMAT d3dfmt;
-   D3D1X_(SUBRESOURCE_DATA) mipdata[24] = { 0 };
+   D3D1X_(SUBRESOURCE_DATA) mipdata[24] = { nullptr };
    S32 k;
 
    HRESULT hr = S_OK;
@@ -2420,7 +2420,7 @@ GDrawTexture * RADLINK gdraw_D3D1X_(MakeTextureFromResource)(U8 *resource_file,
       case IFT_FORMAT_DXT3        : size=16; d3dfmt = DXGI_FORMAT_BC2_UNORM; blk = 4; break;
       case IFT_FORMAT_DXT5        : size=16; d3dfmt = DXGI_FORMAT_BC3_UNORM; blk = 4; break;
       default: {
-         IggyGDrawSendWarning(NULL, "GDraw .iggytex raw texture format %d not supported by hardware", texture->format);
+         IggyGDrawSendWarning(nullptr, "GDraw .iggytex raw texture format %d not supported by hardware", texture->format);
          done = true;
       }
    }
@@ -2437,7 +2437,7 @@ GDrawTexture * RADLINK gdraw_D3D1X_(MakeTextureFromResource)(U8 *resource_file,
       
          free_data = (U8 *) IggyGDrawMalloc(total_size);
          if (!free_data) {
-            IggyGDrawSendWarning(NULL, "GDraw out of memory to store texture data to pass to D3D for %d x %d texture", width, height);
+            IggyGDrawSendWarning(nullptr, "GDraw out of memory to store texture data to pass to D3D for %d x %d texture", width, height);
             done = true;
          } else {
             U8 *cur = free_data;
@@ -2470,7 +2470,7 @@ GDrawTexture * RADLINK gdraw_D3D1X_(MakeTextureFromResource)(U8 *resource_file,
          hr = gdraw->d3d_device->CreateTexture2D(&desc, mipdata, &tex);
          if (!FAILED(hr)) {
              failed_call = "CreateShaderResourceView for texture creation";
-             hr = gdraw->d3d_device->CreateShaderResourceView(tex, NULL, &view);
+             hr = gdraw->d3d_device->CreateShaderResourceView(tex, nullptr, &view);
              if (!FAILED(hr))
                  t = gdraw_D3D1X_(WrappedTextureCreate)(view);
          }
@@ -2490,14 +2490,14 @@ GDrawTexture * RADLINK gdraw_D3D1X_(MakeTextureFromResource)(U8 *resource_file,
       if (tex)
          tex->Release();
    } else {
-      ((GDrawHandle *) t)->handle.tex.d3d = tex;
+      reinterpret_cast<GDrawHandle *>(t)->handle.tex.d3d = tex;
    }
    return t;
 }
 
 void RADLINK gdraw_D3D1X_(DestroyTextureFromResource)(GDrawTexture *tex)
 {
-   GDrawHandle *h = (GDrawHandle *) tex;
+   GDrawHandle *h = reinterpret_cast<GDrawHandle *>(tex);
    safe_release(h->handle.tex.d3d_view);
    safe_release(h->handle.tex.d3d);
    gdraw_D3D1X_(WrappedTextureDestroy)(tex);
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shaders.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shaders.inl
index dc8a0484..74a29221 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shaders.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shaders.inl
@@ -181,7 +181,7 @@ static char *pshader_basic_vars[] = {
    "color_mul",
    "color_add",
    "focal",
-   NULL
+   nullptr
 };
 
 static char pshader_general2_frag0[] =
@@ -293,7 +293,7 @@ static char **pshader_general2(void)
 
 static char *pshader_general2_vars[] = {
    "tex0",
-   NULL
+   nullptr
 };
 
 static char pshader_exceptional_blend_frag0[] =
@@ -414,7 +414,7 @@ static char pshader_exceptional_blend_frag13[] =
 
 #define NUMFRAGMENTS_pshader_exceptional_blend 3
 static char *pshader_exceptional_blend_arr[13][NUMFRAGMENTS_pshader_exceptional_blend] = {
-   { NULL, NULL, NULL, },
+   { nullptr, nullptr, nullptr, },
    { pshader_exceptional_blend_frag0, pshader_exceptional_blend_frag1, pshader_exceptional_blend_frag2, },
    { pshader_exceptional_blend_frag0, pshader_exceptional_blend_frag3, pshader_exceptional_blend_frag2, },
    { pshader_exceptional_blend_frag0, pshader_exceptional_blend_frag4, pshader_exceptional_blend_frag2, },
@@ -439,7 +439,7 @@ static char *pshader_exceptional_blend_vars[] = {
    "tex1",
    "color_mul",
    "color_add",
-   NULL
+   nullptr
 };
 
 static char pshader_filter_frag0[] =
@@ -593,10 +593,10 @@ static char *pshader_filter_arr[32][NUMFRAGMENTS_pshader_filter] = {
    { pshader_filter_frag0, pshader_filter_frag1, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag3, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag1, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag1, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag1, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag3, pshader_filter_frag2, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag3, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag1, pshader_filter_frag2, },
@@ -609,10 +609,10 @@ static char *pshader_filter_arr[32][NUMFRAGMENTS_pshader_filter] = {
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag1, pshader_filter_frag3, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag1, pshader_filter_frag2, },
    { pshader_filter_frag0, pshader_filter_frag7, pshader_filter_frag6, pshader_filter_frag1, pshader_filter_frag4, pshader_filter_frag3, pshader_filter_frag2, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
-   { NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, },
 };
 
 static char **pshader_filter(int bevel, int ontop, int inner, int gradient, int knockout)
@@ -629,7 +629,7 @@ static char *pshader_filter_vars[] = {
    "clamp0",
    "clamp1",
    "color2",
-   NULL
+   nullptr
 };
 
 static char pshader_blur_frag0[] =
@@ -701,8 +701,8 @@ static char pshader_blur_frag9[] =
 
 #define NUMFRAGMENTS_pshader_blur 3
 static char *pshader_blur_arr[10][NUMFRAGMENTS_pshader_blur] = {
-   { NULL, NULL, NULL, },
-   { NULL, NULL, NULL, },
+   { nullptr, nullptr, nullptr, },
+   { nullptr, nullptr, nullptr, },
    { pshader_blur_frag0, pshader_blur_frag1, pshader_blur_frag2, },
    { pshader_blur_frag0, pshader_blur_frag3, pshader_blur_frag2, },
    { pshader_blur_frag0, pshader_blur_frag4, pshader_blur_frag2, },
@@ -722,7 +722,7 @@ static char *pshader_blur_vars[] = {
    "tex0",
    "tap",
    "clampv",
-   NULL
+   nullptr
 };
 
 static char pshader_color_matrix_frag0[] =
@@ -804,7 +804,7 @@ static char **pshader_color_matrix(void)
 static char *pshader_color_matrix_vars[] = {
    "tex0",
    "data",
-   NULL
+   nullptr
 };
 
 static char pshader_manual_clear_frag0[] =
@@ -855,7 +855,7 @@ static char **pshader_manual_clear(void)
 
 static char *pshader_manual_clear_vars[] = {
    "color_mul",
-   NULL
+   nullptr
 };
 
 static char vshader_vsgl_frag0[] =
@@ -966,7 +966,7 @@ static char *vshader_vsgl_vars[] = {
    "texgen_s",
    "texgen_t",
    "viewproj",
-   NULL
+   nullptr
 };
 
 static char vshader_vsglihud_frag0[] =
@@ -1079,6 +1079,6 @@ static char *vshader_vsglihud_vars[] = {
    "worldview",
    "material",
    "textmode",
-   NULL
+   nullptr
 };
 
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shared.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shared.inl
index 9916096a..f134b740 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shared.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_gl_shared.inl
@@ -60,7 +60,7 @@ static RADINLINE void break_on_err(GLint e)
 static void report_err(GLint e)
 {
    break_on_err(e);
-   IggyGDrawSendWarning(NULL, "OpenGL glGetError error");
+   IggyGDrawSendWarning(nullptr, "OpenGL glGetError error");
 }
 
 static void compilation_err(const char *msg)
@@ -256,7 +256,7 @@ static void make_texture(GLuint tex)
 static void make_rendertarget(GDrawHandle *t, GLuint tex, GLenum int_type, GLenum ext_type, GLenum data_type, S32 w, S32 h, S32 size)
 {
    glBindTexture(GL_TEXTURE_2D, tex);
-   glTexImage2D(GL_TEXTURE_2D, 0, int_type, w, h, 0, ext_type, data_type, NULL);
+   glTexImage2D(GL_TEXTURE_2D, 0, int_type, w, h, 0, ext_type, data_type, nullptr);
    make_texture(tex);
    glBindTexture(GL_TEXTURE_2D, 0);
 }
@@ -309,7 +309,7 @@ extern GDrawTexture *gdraw_GLx_(WrappedTextureCreate)(S32 gl_texture_handle, S32
    p->handle.tex.w = width;
    p->handle.tex.h = height;
    p->handle.tex.nonpow2 = !(is_pow2(width) && is_pow2(height));
-   gdraw_HandleCacheAllocateEnd(p, 0, NULL, GDRAW_HANDLE_STATE_user_owned);
+   gdraw_HandleCacheAllocateEnd(p, 0, nullptr, GDRAW_HANDLE_STATE_user_owned);
    return (GDrawTexture *) p;
 }
 
@@ -350,7 +350,7 @@ static void RADLINK gdraw_SetTextureUniqueID(GDrawTexture *tex, void *old_id, vo
 static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height, gdraw_texture_format format, U32 flags, GDraw_MakeTexture_ProcessingInfo *p, GDrawStats *gstats)
 {
    S32 size=0, asize, stride;
-   GDrawHandle *t = NULL;
+   GDrawHandle *t = nullptr;
    opengl_check();
 
    stride = width;
@@ -369,7 +369,7 @@ static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height,
    p->texture_data = IggyGDrawMalloc(size);
    if (!p->texture_data) {
       gdraw_HandleCacheAllocateFail(t);
-      IggyGDrawSendWarning(NULL, "GDraw malloc for texture data failed");
+      IggyGDrawSendWarning(nullptr, "GDraw malloc for texture data failed");
       return false;
    }
    
@@ -419,9 +419,9 @@ static GDrawTexture * RADLINK gdraw_MakeTextureEnd(GDraw_MakeTexture_ProcessingI
 
    if (e != 0) {
       gdraw_HandleCacheAllocateFail(t);
-      IggyGDrawSendWarning(NULL, "GDraw OpenGL error creating texture");
+      IggyGDrawSendWarning(nullptr, "GDraw OpenGL error creating texture");
       eat_gl_err();
-      return NULL;
+      return nullptr;
    } else {
       gdraw_HandleCacheAllocateEnd(t, p->i4, p->p1, (flags & GDRAW_MAKETEXTURE_FLAGS_never_flush) ? GDRAW_HANDLE_STATE_pinned : GDRAW_HANDLE_STATE_locked);
       stats->nonzero_flags |= GDRAW_STATS_alloc_tex;
@@ -467,8 +467,8 @@ static void RADLINK gdraw_UpdateTextureEnd(GDrawTexture *tex, void *unique_id, G
 static void RADLINK gdraw_FreeTexture(GDrawTexture *tt, void *unique_id, GDrawStats *gstats)
 {
    GDrawHandle *t = (GDrawHandle *) tt;
-   assert(t != NULL);
-   if (t->owner == unique_id || unique_id == NULL) {
+   assert(t != nullptr);
+   if (t->owner == unique_id || unique_id == nullptr) {
       if (t->cache == &gdraw->rendertargets) {
          gdraw_HandleCacheUnlock(t);
          // cache it by simply not freeing it
@@ -516,7 +516,7 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
    opengl_check();
    vb = gdraw_res_alloc_begin(gdraw->vbufcache, vbuf_size + ibuf_size, gstats);
    if (!vb) {
-      IggyGDrawSendWarning(NULL, "GDraw out of vertex buffer memory");
+      IggyGDrawSendWarning(nullptr, "GDraw out of vertex buffer memory");
       return false;
    }
 
@@ -526,9 +526,9 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
    glGenBuffers(1, &vb->handle.vbuf.base);
    glGenBuffers(1, &vb->handle.vbuf.indices);
    glBindBuffer(GL_ARRAY_BUFFER, vb->handle.vbuf.base);
-   glBufferData(GL_ARRAY_BUFFER, vbuf_size, NULL, GL_STATIC_DRAW);
+   glBufferData(GL_ARRAY_BUFFER, vbuf_size, nullptr, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vb->handle.vbuf.indices);
-   glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibuf_size, NULL, GL_STATIC_DRAW);
+   glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibuf_size, nullptr, GL_STATIC_DRAW);
    if (!e) e = glGetError();
    if (e != GL_NO_ERROR) {
       glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -537,7 +537,7 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
       glDeleteBuffers(1, &vb->handle.vbuf.indices);
       gdraw_HandleCacheAllocateFail(vb);
       eat_gl_err();
-      IggyGDrawSendWarning(NULL, "GDraw OpenGL vertex buffer creation failed");
+      IggyGDrawSendWarning(nullptr, "GDraw OpenGL vertex buffer creation failed");
       return false;
    }
 
@@ -556,7 +556,7 @@ static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat
       if (!p->vertex_data || !p->index_data) {
          if (p->vertex_data)  IggyGDrawFree(p->vertex_data);
          if (p->index_data)   IggyGDrawFree(p->index_data);
-         IggyGDrawSendWarning(NULL, "GDraw malloc for vertex buffer temporary memory failed");
+         IggyGDrawSendWarning(nullptr, "GDraw malloc for vertex buffer temporary memory failed");
          return false;
       }
    } else {
@@ -602,7 +602,7 @@ static GDrawVertexBuffer * RADLINK gdraw_MakeVertexBufferEnd(GDraw_MakeVertexBuf
       glDeleteBuffers(1, &vb->handle.vbuf.indices);
       gdraw_HandleCacheAllocateFail(vb);
       eat_gl_err();
-      return NULL;
+      return nullptr;
    } else
       gdraw_HandleCacheAllocateEnd(vb, p->i0 + p->i1, p->p1, GDRAW_HANDLE_STATE_locked);
 
@@ -619,7 +619,7 @@ static rrbool RADLINK gdraw_TryToLockVertexBuffer(GDrawVertexBuffer *vb, void *u
 static void RADLINK gdraw_FreeVertexBuffer(GDrawVertexBuffer *vb, void *unique_id, GDrawStats *stats)
 {
    GDrawHandle *h = (GDrawHandle *) vb;
-   assert(h != NULL);
+   assert(h != nullptr);
    if (h->owner == unique_id)
       gdraw_res_free(h, stats);
 }
@@ -678,13 +678,13 @@ static GDrawHandle *get_color_rendertarget(GDrawStats *gstats)
    // ran out of RTs, allocate a new one
    size = gdraw->frametex_width * gdraw->frametex_height * 4;
    if (gdraw->rendertargets.bytes_free < size) {
-      IggyGDrawSendWarning(NULL, "GDraw exceeded available rendertarget memory");
-      return NULL;
+      IggyGDrawSendWarning(nullptr, "GDraw exceeded available rendertarget memory");
+      return nullptr;
    }
 
    t = gdraw_HandleCacheAllocateBegin(&gdraw->rendertargets);
    if (!t) {
-      IggyGDrawSendWarning(NULL, "GDraw exceeded available rendertarget handles");
+      IggyGDrawSendWarning(nullptr, "GDraw exceeded available rendertarget handles");
       return t;
    }
 
@@ -873,7 +873,7 @@ static void RADLINK gdraw_SetViewSizeAndWorldScale(S32 w, S32 h, F32 scalex, F32
 
 static void RADLINK gdraw_Set3DTransform(F32 *mat)
 {
-   if (mat == NULL)
+   if (mat == nullptr)
       gdraw->use_3d = 0;
    else {
       gdraw->use_3d = 1;
@@ -992,30 +992,30 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
    GDrawHandle *t;
    int k;
    if (gdraw->tw == 0 || gdraw->th == 0) {
-      IggyGDrawSendWarning(NULL, "GDraw got a request for an empty rendertarget");
+      IggyGDrawSendWarning(nullptr, "GDraw got a request for an empty rendertarget");
       return false;
    }
 
    if (n >= &gdraw->frame[MAX_RENDER_STACK_DEPTH]) {
-      IggyGDrawSendWarning(NULL, "GDraw rendertarget nesting exceeded MAX_RENDER_STACK_DEPTH");
+      IggyGDrawSendWarning(nullptr, "GDraw rendertarget nesting exceeded MAX_RENDER_STACK_DEPTH");
       return false;
    }
 
    if (owner) {
       t = get_rendertarget_texture(region->x1 - region->x0, region->y1 - region->y0, owner, gstats);
       if (!t) {
-         IggyGDrawSendWarning(NULL, "GDraw ran out of rendertargets for cacheAsBItmap");
+         IggyGDrawSendWarning(nullptr, "GDraw ran out of rendertargets for cacheAsBItmap");
          return false;
       }
    } else {
       t = get_color_rendertarget(gstats);
       if (!t) {
-         IggyGDrawSendWarning(NULL, "GDraw ran out of rendertargets");
+         IggyGDrawSendWarning(nullptr, "GDraw ran out of rendertargets");
          return false;
       }
    }
    n->color_buffer = t;
-   assert(n->color_buffer != NULL);
+   assert(n->color_buffer != nullptr);
 
    if (n == gdraw->frame+1)
       n->stencil_depth = get_depthstencil_renderbuffer(gstats);
@@ -1023,7 +1023,7 @@ static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_tex
       n->stencil_depth = (n-1)->stencil_depth;
    ++gdraw->cur;
 
-   gdraw->cur->cached = owner != NULL;
+   gdraw->cur->cached = owner != nullptr;
    if (owner) {
       gdraw->cur->base_x = region->x0;
       gdraw->cur->base_y = region->y0;
@@ -1161,8 +1161,8 @@ static GDrawTexture *RADLINK gdraw_TextureDrawBufferEnd(GDrawStats *gstats)
    assert(m >= gdraw->frame);  // bug in Iggy -- unbalanced
 
    if (m != gdraw->frame)
-      assert(m->color_buffer != NULL);
-   assert(n->color_buffer != NULL);
+      assert(m->color_buffer != nullptr);
+   assert(n->color_buffer != nullptr);
 
    // remove color and stencil buffers
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , GL_RENDERBUFFER, 0);
@@ -1274,7 +1274,7 @@ static float depth_from_id(S32 id)
 static void set_texture(U32 texunit, GDrawTexture *tex)
 {
    glActiveTexture(GL_TEXTURE0 + texunit);
-   if (tex == NULL)
+   if (tex == nullptr)
       glBindTexture(GL_TEXTURE_2D, 0);
    else
       glBindTexture(GL_TEXTURE_2D, ((GDrawHandle *) tex)->handle.tex.gl);
@@ -1575,7 +1575,7 @@ static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimiti
       glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    }
 
-   if (!set_render_state(r,p->vertex_format, NULL, p, gstats)) return;
+   if (!set_render_state(r,p->vertex_format, nullptr, p, gstats)) return;
    gstats->nonzero_flags |= GDRAW_STATS_batches;
    gstats->num_batches += 1;
    gstats->drawn_indices += p->num_indices;
@@ -1593,7 +1593,7 @@ static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimiti
       while (pos < p->num_vertices) {
          S32 vert_count = RR_MIN(p->num_vertices - pos, QUAD_IB_COUNT * 4);
          set_vertex_format(p->vertex_format, p->vertices + pos*stride);
-         glDrawElements(GL_TRIANGLES, (vert_count >> 2) * 6, GL_UNSIGNED_SHORT, NULL);
+         glDrawElements(GL_TRIANGLES, (vert_count >> 2) * 6, GL_UNSIGNED_SHORT, nullptr);
          pos += vert_count;
       }
       
@@ -1719,7 +1719,7 @@ static void gdraw_DriverBlurPass(GDrawRenderState *r, int taps, F32 *data, gswf_
 static void gdraw_Colormatrix(GDrawRenderState *r, gswf_recti *s, float *tc, GDrawStats *gstats)
 {
    ProgramWithCachedVariableLocations *prg = &gdraw->colormatrix;
-   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, NULL, gstats))
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, nullptr, gstats))
       return;
    use_lazy_shader(prg);
    set_texture(0, r->tex[0]);
@@ -1752,7 +1752,7 @@ static void set_clamp_constant(GLint constant, GDrawTexture *tex)
 static void gdraw_Filter(GDrawRenderState *r, gswf_recti *s, float *tc, int isbevel, GDrawStats *gstats)
 {
    ProgramWithCachedVariableLocations *prg = &gdraw->filter_prog[isbevel][r->filter_mode];
-   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, NULL, gstats))
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, nullptr, gstats))
       return;
    use_lazy_shader(prg);
    set_texture(0, r->tex[0]);
@@ -1845,7 +1845,7 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
             assert(0);
       }
    } else {
-      GDrawTexture *blend_tex = NULL;
+      GDrawTexture *blend_tex = nullptr;
       const int *vvars;
 
       // for crazy blend modes, we need to read back from the framebuffer
@@ -1864,7 +1864,7 @@ static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1
          set_texture(1, blend_tex);
       }
 
-      if (!set_render_state(r, GDRAW_vformat_v2tc2, &vvars, NULL, gstats))
+      if (!set_render_state(r, GDRAW_vformat_v2tc2, &vvars, nullptr, gstats))
          return;
       do_screen_quad(&s, tc, vvars, gstats, 0);
       tag_resources(r->tex[0],r->tex[1],0);
@@ -1932,7 +1932,7 @@ static void make_fragment_program(ProgramWithCachedVariableLocations *p, int num
    }
 
    shad = glCreateShader(GL_FRAGMENT_SHADER);
-   glShaderSource(shad, num_strings, (const GLchar **)strings, NULL);
+   glShaderSource(shad, num_strings, (const GLchar **)strings, nullptr);
    glCompileShader(shad);
    glGetShaderiv(shad, GL_COMPILE_STATUS, &res);
    if (!res) {
@@ -1994,7 +1994,7 @@ static void make_vertex_program(GLuint *vprog, int num_strings, char **strings)
    if(strings[0])
    {
       shad = glCreateShader(GL_VERTEX_SHADER);
-      glShaderSource(shad, num_strings, (const GLchar **)strings, NULL);
+      glShaderSource(shad, num_strings, (const GLchar **)strings, nullptr);
       glCompileShader(shad);
       glGetShaderiv(shad, GL_COMPILE_STATUS, &res);
       if (!res) {
@@ -2154,7 +2154,7 @@ static void free_gdraw()
    if (gdraw->texturecache) IggyGDrawFree(gdraw->texturecache);
    if (gdraw->vbufcache) IggyGDrawFree(gdraw->vbufcache);
    IggyGDrawFree(gdraw);
-   gdraw = NULL;
+   gdraw = nullptr;
 }
 
 int gdraw_GLx_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S32 num_bytes)
@@ -2193,7 +2193,7 @@ int gdraw_GLx_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S32
             IggyGDrawFree(gdraw->texturecache);
          }
          gdraw->texturecache = make_handle_cache(GDRAW_GLx_(RESOURCE_texture));
-         return gdraw->texturecache != NULL;
+         return gdraw->texturecache != nullptr;
 
       case GDRAW_GLx_(RESOURCE_vertexbuffer):
          if (gdraw->vbufcache) {
@@ -2201,7 +2201,7 @@ int gdraw_GLx_(SetResourceLimits)(gdraw_resourcetype type, S32 num_handles, S32
             IggyGDrawFree(gdraw->vbufcache);
          }
          gdraw->vbufcache = make_handle_cache(GDRAW_GLx_(RESOURCE_vertexbuffer));
-         return gdraw->vbufcache != NULL;
+         return gdraw->vbufcache != nullptr;
 
       default:
          return 0;
@@ -2220,12 +2220,12 @@ GDrawTexture * RADLINK gdraw_GLx_(MakeTextureFromResource)(U8 *resource_file, S3
    while (fmt->iggyfmt != texture->format && fmt->blkbytes)
       fmt++;
    if (!fmt->blkbytes) // end of list - i.e. format not supported
-      return NULL;
+      return nullptr;
 
    // prepare texture
    glGenTextures(1, &gl_texture_handle);
    if (gl_texture_handle == 0)
-      return NULL;
+      return nullptr;
 
    opengl_check();
    make_texture(gl_texture_handle);
@@ -2283,7 +2283,7 @@ GDrawTexture * RADLINK gdraw_GLx_(MakeTextureFromResource)(U8 *resource_file, S3
       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mips-1);
 
    tex = gdraw_GLx_(WrappedTextureCreate)(gl_texture_handle, texture->w, texture->h, mips > 1);
-   if (tex == NULL)
+   if (tex == nullptr)
       glDeleteTextures(1, &gl_texture_handle);
    opengl_check();
    return tex;
@@ -2301,7 +2301,7 @@ static rrbool hasext(const char *exts, const char *which)
    size_t len;
 
 #ifdef GDRAW_USE_glGetStringi
-   if (exts == NULL) {
+   if (exts == nullptr) {
       GLint i, num_exts;
       glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts);
       for (i=0; i < num_exts; ++i)
@@ -2316,7 +2316,7 @@ static rrbool hasext(const char *exts, const char *which)
 
    for(;;) {
       where = strstr(where, which);
-      if (where == NULL)
+      if (where == nullptr)
          return false;
 
       if (   (where == exts || *(where - 1) == ' ')   // starts with terminator
@@ -2329,7 +2329,7 @@ static rrbool hasext(const char *exts, const char *which)
 static GDrawFunctions *create_context(S32 w, S32 h)
 {
    gdraw = IggyGDrawMalloc(sizeof(*gdraw));
-   if (!gdraw) return NULL;
+   if (!gdraw) return nullptr;
 
    memset(gdraw, 0, sizeof(*gdraw));
 
@@ -2339,7 +2339,7 @@ static GDrawFunctions *create_context(S32 w, S32 h)
 
    if (!gdraw->texturecache || !gdraw->vbufcache || !make_quad_indices()) {
       free_gdraw();
-      return NULL;
+      return nullptr;
    }
 
    opengl_check();
@@ -2380,7 +2380,7 @@ static GDrawFunctions *create_context(S32 w, S32 h)
    gdraw_funcs.ClearID = gdraw_ClearID;
 
    gdraw_funcs.MakeTextureBegin = gdraw_MakeTextureBegin;
-   gdraw_funcs.MakeTextureMore = NULL;
+   gdraw_funcs.MakeTextureMore = nullptr;
    gdraw_funcs.MakeTextureEnd = gdraw_MakeTextureEnd;
 
    gdraw_funcs.UpdateTextureRect = gdraw_UpdateTextureRect;
diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_shared.inl b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_shared.inl
index a60fa520..1790de77 100644
--- a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_shared.inl
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_shared.inl
@@ -226,7 +226,7 @@ static void debug_check_raw_values(GDrawHandleCache *c)
             s = s->next;
          }
          s = c->active;
-         while (s != NULL) {
+         while (s != nullptr) {
             assert(s->raw_ptr != t->raw_ptr);
             s = s->next;
          }
@@ -368,7 +368,7 @@ static void gdraw_HandleTransitionInsertBefore(GDrawHandle *t, GDrawHandleState
 {
    check_lists(t->cache);
    assert(t->state != GDRAW_HANDLE_STATE_sentinel); // sentinels should never get here!
-   assert(t->state != (U32) new_state); // code should never call "transition" if it's not transitioning!
+   assert(t->state != static_cast<U32>(new_state)); // code should never call "transition" if it's not transitioning!
    // unlink from prev state
    t->prev->next = t->next;
    t->next->prev = t->prev;
@@ -433,7 +433,7 @@ static rrbool gdraw_HandleCacheLockStats(GDrawHandle *t, void *owner, GDrawStats
 
 static rrbool gdraw_HandleCacheLock(GDrawHandle *t, void *owner)
 {
-   return gdraw_HandleCacheLockStats(t, owner, NULL);
+   return gdraw_HandleCacheLockStats(t, owner, nullptr);
 }
 
 static void gdraw_HandleCacheUnlock(GDrawHandle *t)
@@ -461,11 +461,11 @@ static void gdraw_HandleCacheInit(GDrawHandleCache *c, S32 num_handles, S32 byte
    c->is_thrashing = false;
    c->did_defragment = false;
    for (i=0; i < GDRAW_HANDLE_STATE__count; i++) {
-      c->state[i].owner = NULL;
-      c->state[i].cache = NULL; // should never follow cache link from sentinels!
+      c->state[i].owner = nullptr;
+      c->state[i].cache = nullptr; // should never follow cache link from sentinels!
       c->state[i].next = c->state[i].prev = &c->state[i];
 #ifdef GDRAW_MANAGE_MEM
-      c->state[i].raw_ptr = NULL;
+      c->state[i].raw_ptr = nullptr;
 #endif
       c->state[i].fence.value = 0;
       c->state[i].bytes = 0;
@@ -478,7 +478,7 @@ static void gdraw_HandleCacheInit(GDrawHandleCache *c, S32 num_handles, S32 byte
       c->handle[i].bytes = 0;
       c->handle[i].state = GDRAW_HANDLE_STATE_free;
 #ifdef GDRAW_MANAGE_MEM
-      c->handle[i].raw_ptr = NULL;
+      c->handle[i].raw_ptr = nullptr;
 #endif
    }
    c->state[GDRAW_HANDLE_STATE_free].next = &c->handle[0];
@@ -486,10 +486,10 @@ static void gdraw_HandleCacheInit(GDrawHandleCache *c, S32 num_handles, S32 byte
    c->prev_frame_start.value = 0;
    c->prev_frame_end.value = 0;
 #ifdef GDRAW_MANAGE_MEM
-   c->alloc = NULL;
+   c->alloc = nullptr;
 #endif
 #ifdef GDRAW_MANAGE_MEM_TWOPOOL
-   c->alloc_other = NULL;
+   c->alloc_other = nullptr;
 #endif
    check_lists(c);
 }
@@ -497,14 +497,14 @@ static void gdraw_HandleCacheInit(GDrawHandleCache *c, S32 num_handles, S32 byte
 static GDrawHandle *gdraw_HandleCacheAllocateBegin(GDrawHandleCache *c)
 {
    GDrawHandle *free_list = &c->state[GDRAW_HANDLE_STATE_free];
-   GDrawHandle *t = NULL;
+   GDrawHandle *t = nullptr;
    if (free_list->next != free_list) {
       t = free_list->next;
       gdraw_HandleTransitionTo(t, GDRAW_HANDLE_STATE_alloc);
       t->bytes = 0;
       t->owner = 0;
 #ifdef GDRAW_MANAGE_MEM
-      t->raw_ptr = NULL;
+      t->raw_ptr = nullptr;
 #endif
 #ifdef GDRAW_CORRUPTION_CHECK
       t->has_check_value = false;
@@ -558,7 +558,7 @@ static GDrawHandle *gdraw_HandleCacheGetLRU(GDrawHandleCache *c)
    // at the front of the LRU list are the oldest ones, since in-use resources
    // will get appended on every transition from "locked" to "live".
    GDrawHandle *sentinel = &c->state[GDRAW_HANDLE_STATE_live];
-   return (sentinel->next != sentinel) ? sentinel->next : NULL;
+   return (sentinel->next != sentinel) ? sentinel->next : nullptr;
 }
 
 static void gdraw_HandleCacheTick(GDrawHandleCache *c, GDrawFence now)
@@ -773,7 +773,7 @@ static GDrawTexture *gdraw_BlurPass(GDrawFunctions *g, GDrawBlurInfo *c, GDrawRe
    if (!g->TextureDrawBufferBegin(draw_bounds, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, 0, gstats))
       return r->tex[0];
 
-   c->BlurPass(r, taps, data, draw_bounds, tc, (F32) c->h / c->frametex_height, clamp, gstats);
+   c->BlurPass(r, taps, data, draw_bounds, tc, static_cast<F32>(c->h) / c->frametex_height, clamp, gstats);
    return g->TextureDrawBufferEnd(gstats);
 }
 
@@ -825,7 +825,7 @@ static GDrawTexture *gdraw_BlurPassDownsample(GDrawFunctions *g, GDrawBlurInfo *
    assert(clamp[0] <= clamp[2]);
    assert(clamp[1] <= clamp[3]);
 
-   c->BlurPass(r, taps, data, &z, tc, (F32) c->h / c->frametex_height, clamp, gstats);
+   c->BlurPass(r, taps, data, &z, tc, static_cast<F32>(c->h) / c->frametex_height, clamp, gstats);
    return g->TextureDrawBufferEnd(gstats);
 }
 
@@ -837,7 +837,7 @@ static void gdraw_BlurAxis(S32 axis, GDrawFunctions *g, GDrawBlurInfo *c, GDrawR
    GDrawTexture *t;
    F32 data[MAX_TAPS][4];
    S32 off_axis = 1-axis;
-   S32 w = ((S32) ceil((blur_width-1)/2))*2+1;  // 1.2 => 3, 2.8 => 3, 3.2 => 5
+   S32 w = static_cast<S32>(ceil((blur_width - 1) / 2))*2+1;  // 1.2 => 3, 2.8 => 3, 3.2 => 5
    F32 edge_weight = 1 - (w - blur_width)/2;   // 3 => 0 => 1;   1.2 => 1.8 => 0.9 => 0.1
    F32 inverse_weight = 1.0f / blur_width;
 
@@ -944,7 +944,7 @@ static void gdraw_BlurAxis(S32 axis, GDrawFunctions *g, GDrawBlurInfo *c, GDrawR
          // max coverage is 25 samples, or a filter width of 13. with 7 taps, we sample
          // 13 samples in one pass, max coverage is 13*13 samples or (13*13-1)/2 width,
          // which is ((2T-1)*(2T-1)-1)/2 or (4T^2 - 4T + 1 -1)/2 or 2T^2 - 2T or 2T*(T-1)
-         S32 w_mip = (S32) ceil(linear_remap(w, MAX_TAPS+1, MAX_TAPS*MAX_TAPS, 2, MAX_TAPS));
+         S32 w_mip = static_cast<S32>(ceil(linear_remap(w, MAX_TAPS+1, MAX_TAPS*MAX_TAPS, 2, MAX_TAPS)));
          S32 downsample = w_mip;
          F32 sample_spacing = texel;
          if (downsample < 2) downsample = 2;
@@ -1090,7 +1090,7 @@ static void make_pool_aligned(void **start, S32 *num_bytes, U32 alignment)
    if (addr_aligned != addr_orig) {
       S32 diff = (S32) (addr_aligned - addr_orig);
       if (*num_bytes < diff) { 
-         *start = NULL;
+         *start = nullptr;
          *num_bytes = 0;
          return;
       } else {
@@ -1127,7 +1127,7 @@ static void *gdraw_arena_alloc(GDrawArena *arena, U32 size, U32 align)
    UINTa remaining = arena->end - arena->current;
    UINTa total_size = (ptr - arena->current) + size;
    if (remaining < total_size) // doesn't fit
-      return NULL;
+      return nullptr;
 
    arena->current = ptr + size;
    return ptr;
@@ -1152,7 +1152,7 @@ static void *gdraw_arena_alloc(GDrawArena *arena, U32 size, U32 align)
 //   (i.e. block->next->prev == block->prev->next == block)
 // - All allocated blocks are also kept in a hash table, indexed by their
 //   pointer (to allow free to locate the corresponding block_info quickly).
-//   There's a single-linked, NULL-terminated list of elements in each hash
+//   There's a single-linked, nullptr-terminated list of elements in each hash
 //   bucket.
 // - The physical block list is ordered. It always contains all currently
 //   active blocks and spans the whole managed memory range. There are no
@@ -1161,7 +1161,7 @@ static void *gdraw_arena_alloc(GDrawArena *arena, U32 size, U32 align)
 //   they are coalesced immediately.
 // - The maximum number of blocks that could ever be necessary is allocated
 //   on initialization. All block_infos not currently in use are kept in a
-//   single-linked, NULL-terminated list of unused blocks. Every block is either
+//   single-linked, nullptr-terminated list of unused blocks. Every block is either
 //   in the physical block list or the unused list, and the total number of
 //   blocks is constant.
 // These invariants always hold before and after an allocation/free.
@@ -1379,7 +1379,7 @@ static void gfxalloc_check2(gfx_allocator *alloc)
 
 static gfx_block_info *gfxalloc_pop_unused(gfx_allocator *alloc)
 {
-   GFXALLOC_ASSERT(alloc->unused_list != NULL);
+   GFXALLOC_ASSERT(alloc->unused_list != nullptr);
    GFXALLOC_ASSERT(alloc->unused_list->is_unused);
    GFXALLOC_IF_CHECK(GFXALLOC_ASSERT(alloc->num_unused);)
 
@@ -1452,7 +1452,7 @@ static gfx_allocator *gfxalloc_create(void *mem, U32 mem_size, U32 align, U32 ma
    U32 i, max_blocks, size;
 
    if (!align || (align & (align - 1)) != 0) // align must be >0 and a power of 2
-      return NULL;
+      return nullptr;
 
    // for <= max_allocs live allocs, there's <= 2*max_allocs+1 blocks. worst case:
    // [free][used][free] .... [free][used][free]
@@ -1460,7 +1460,7 @@ static gfx_allocator *gfxalloc_create(void *mem, U32 mem_size, U32 align, U32 ma
    size = sizeof(gfx_allocator) + max_blocks * sizeof(gfx_block_info);
    a = (gfx_allocator *) IggyGDrawMalloc(size);
    if (!a)
-      return NULL;
+      return nullptr;
 
    memset(a, 0, size);
 
@@ -1501,16 +1501,16 @@ static gfx_allocator *gfxalloc_create(void *mem, U32 mem_size, U32 align, U32 ma
    a->blocks[i].is_unused = 1;
 
    gfxalloc_check(a);
-   debug_complete_check(a, NULL, 0,0);
+   debug_complete_check(a, nullptr, 0,0);
    return a;
 }
 
 static void *gfxalloc_alloc(gfx_allocator *alloc, U32 size_in_bytes)
 {
-   gfx_block_info *cur, *best = NULL;
+   gfx_block_info *cur, *best = nullptr;
    U32 i, best_wasted = ~0u;
    U32 size = size_in_bytes;
-debug_complete_check(alloc, NULL, 0,0);
+debug_complete_check(alloc, nullptr, 0,0);
 gfxalloc_check(alloc);
    GFXALLOC_IF_CHECK(GFXALLOC_ASSERT(alloc->num_blocks == alloc->num_alloc + alloc->num_free + alloc->num_unused);)
    GFXALLOC_IF_CHECK(GFXALLOC_ASSERT(alloc->num_free <= alloc->num_blocks+1);)
@@ -1560,7 +1560,7 @@ gfxalloc_check(alloc);
 debug_check_overlap(alloc->cache, best->ptr, best->size);
       return best->ptr;
    } else
-      return NULL; // not enough space!
+      return nullptr; // not enough space!
 }
 
 static void gfxalloc_free(gfx_allocator *alloc, void *ptr)
@@ -1730,7 +1730,7 @@ static void gdraw_DefragmentMain(GDrawHandleCache *c, U32 flags, GDrawStats *sta
    // (unused for allocated blocks, we'll use it to store a back-pointer to the corresponding handle)
    for (b = alloc->blocks[0].next_phys; b != alloc->blocks; b=b->next_phys)
       if (!b->is_free)
-         b->prev = NULL;
+         b->prev = nullptr;
 
    // go through all handles and store a pointer to the handle in the corresponding memory block
    for (i=0; i < c->max_handles; i++)
@@ -1743,7 +1743,7 @@ static void gdraw_DefragmentMain(GDrawHandleCache *c, U32 flags, GDrawStats *sta
                break;
             }
 
-         GFXALLOC_ASSERT(b != NULL); // didn't find this block anywhere!
+         GFXALLOC_ASSERT(b != nullptr); // didn't find this block anywhere!
       }
 
    // clear alloc hash table (we rebuild it during defrag)
@@ -1905,7 +1905,7 @@ static rrbool gdraw_CanDefragment(GDrawHandleCache *c)
 static rrbool gdraw_MigrateResource(GDrawHandle *t, GDrawStats *stats)
 {
    GDrawHandleCache *c = t->cache;
-   void *ptr = NULL;
+   void *ptr = nullptr;
 
    assert(t->state == GDRAW_HANDLE_STATE_live || t->state == GDRAW_HANDLE_STATE_locked || t->state == GDRAW_HANDLE_STATE_pinned);
    // anything we migrate should be in the "other" (old) pool
@@ -2295,7 +2295,7 @@ static void gdraw_bufring_init(gdraw_bufring * RADRESTRICT ring, void *ptr, U32
 
 static void gdraw_bufring_shutdown(gdraw_bufring * RADRESTRICT ring)
 {
-   ring->cur = NULL;
+   ring->cur = nullptr;
    ring->seg_size = 0;
 }
 
@@ -2305,7 +2305,7 @@ static void *gdraw_bufring_alloc(gdraw_bufring * RADRESTRICT ring, U32 size, U32
    gdraw_bufring_seg *seg;
 
    if (size > ring->seg_size)
-      return NULL; // nope, won't fit
+      return nullptr; // nope, won't fit
 
    assert(align <= ring->align);
 
@@ -2410,7 +2410,7 @@ static rrbool gdraw_res_free_lru(GDrawHandleCache *c, GDrawStats *stats)
    // was it referenced since end of previous frame (=in this frame)?
    // if some, we're thrashing; report it to the user, but only once per frame.
    if (c->prev_frame_end.value < r->fence.value && !c->is_thrashing) {
-      IggyGDrawSendWarning(NULL, c->is_vertex ? "GDraw Thrashing vertex memory" : "GDraw Thrashing texture memory");
+      IggyGDrawSendWarning(nullptr, c->is_vertex ? "GDraw Thrashing vertex memory" : "GDraw Thrashing texture memory");
       c->is_thrashing = true;
    }
 
@@ -2430,8 +2430,8 @@ static GDrawHandle *gdraw_res_alloc_outofmem(GDrawHandleCache *c, GDrawHandle *t
 {
    if (t)
       gdraw_HandleCacheAllocateFail(t);
-   IggyGDrawSendWarning(NULL, c->is_vertex ? "GDraw Out of static vertex buffer %s" : "GDraw Out of texture %s", failed_type);
-   return NULL;
+   IggyGDrawSendWarning(nullptr, c->is_vertex ? "GDraw Out of static vertex buffer %s" : "GDraw Out of texture %s", failed_type);
+   return nullptr;
 }
 
 #ifndef GDRAW_MANAGE_MEM
@@ -2440,7 +2440,7 @@ static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawSt
 {
    GDrawHandle *t;
    if (size > c->total_bytes)
-      gdraw_res_alloc_outofmem(c, NULL, "memory (single resource larger than entire pool)");
+      gdraw_res_alloc_outofmem(c, nullptr, "memory (single resource larger than entire pool)");
    else {
       // given how much data we're going to allocate, throw out
       // data until there's "room" (this basically lets us use
@@ -2448,7 +2448,7 @@ static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawSt
       // packing it and being exact)
       while (c->bytes_free < size) {
          if (!gdraw_res_free_lru(c, stats)) {
-            gdraw_res_alloc_outofmem(c, NULL, "memory");
+            gdraw_res_alloc_outofmem(c, nullptr, "memory");
             break;
          }
       }
@@ -2463,8 +2463,8 @@ static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawSt
       // we'd trade off cost of regenerating)
       if (gdraw_res_free_lru(c, stats)) {
          t = gdraw_HandleCacheAllocateBegin(c);
-         if (t == NULL) {
-            gdraw_res_alloc_outofmem(c, NULL, "handles");
+         if (t == nullptr) {
+            gdraw_res_alloc_outofmem(c, nullptr, "handles");
          }
       }
    }
@@ -2508,7 +2508,7 @@ static void gdraw_res_kill(GDrawHandle *r, GDrawStats *stats)
 {
    GDRAW_FENCE_FLUSH(); // dead list is sorted by fence index - make sure all fence values are current.
 
-   r->owner = NULL;
+   r->owner = nullptr;
    gdraw_HandleCacheInsertDead(r);
    gdraw_res_reap(r->cache, stats);
 }
@@ -2516,11 +2516,11 @@ static void gdraw_res_kill(GDrawHandle *r, GDrawStats *stats)
 static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawStats *stats)
 {
    GDrawHandle *t;
-   void *ptr = NULL;
+   void *ptr = nullptr;
 
    gdraw_res_reap(c, stats); // NB this also does GDRAW_FENCE_FLUSH();
    if (size > c->total_bytes)
-      return gdraw_res_alloc_outofmem(c, NULL, "memory (single resource larger than entire pool)");
+      return gdraw_res_alloc_outofmem(c, nullptr, "memory (single resource larger than entire pool)");
    
    // now try to allocate a handle
    t = gdraw_HandleCacheAllocateBegin(c);
@@ -2532,7 +2532,7 @@ static GDrawHandle *gdraw_res_alloc_begin(GDrawHandleCache *c, S32 size, GDrawSt
       gdraw_res_free_lru(c, stats);
       t = gdraw_HandleCacheAllocateBegin(c);
       if (!t)
-         return gdraw_res_alloc_outofmem(c, NULL, "handles");
+         return gdraw_res_alloc_outofmem(c, nullptr, "handles");
    }
 
    // try to allocate first