diff --git a/gfx/common/d3d11_common.c b/gfx/common/d3d11_common.c
index 60a70d3f34..7ac5817f51 100644
--- a/gfx/common/d3d11_common.c
+++ b/gfx/common/d3d11_common.c
@@ -128,7 +128,8 @@ void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
 
    texture->desc.Format = d3d11_get_closest_match(device, texture->desc.Format, format_support);
 
-   D3D11CreateTexture2D(device, &texture->desc, NULL, &texture->handle);
+   device->lpVtbl->CreateTexture2D(device, &texture->desc, NULL,
+         &texture->handle);
 
    {
       D3D11_SHADER_RESOURCE_VIEW_DESC view_desc;
@@ -136,11 +137,13 @@ void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
       view_desc.ViewDimension                   = D3D_SRV_DIMENSION_TEXTURE2D;
       view_desc.Texture2D.MostDetailedMip       = 0;
       view_desc.Texture2D.MipLevels             = -1;
-      D3D11CreateTexture2DShaderResourceView(device, texture->handle, &view_desc, &texture->view);
+      device->lpVtbl->CreateShaderResourceView(device,
+            (D3D11Resource)texture->handle, &view_desc, &texture->view);
    }
 
    if (is_render_target)
-      D3D11CreateTexture2DRenderTargetView(device, texture->handle, NULL, &texture->rt_view);
+      device->lpVtbl->CreateRenderTargetView(device,
+            (D3D11Resource)texture->handle, NULL, &texture->rt_view);
    else
    {
       D3D11_TEXTURE2D_DESC desc = texture->desc;
@@ -149,7 +152,7 @@ void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
       desc.MiscFlags            = 0;
       desc.Usage                = D3D11_USAGE_STAGING;
       desc.CPUAccessFlags       = D3D11_CPU_ACCESS_WRITE;
-      D3D11CreateTexture2D(device, &desc, NULL, &texture->staging);
+      device->lpVtbl->CreateTexture2D(device, &desc, NULL, &texture->staging);
    }
 
    texture->size_data.x = texture->desc.Width;
@@ -195,7 +198,7 @@ void d3d11_update_texture(
          (D3D11Resource)texture->staging, 0, &frame_box);
 
    if (texture->desc.MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
-      D3D11GenerateMips(ctx, texture->view);
+      ctx->lpVtbl->GenerateMips(ctx, texture->view);
 }
 
    DXGI_FORMAT
@@ -210,7 +213,8 @@ d3d11_get_closest_match(D3D11Device device, DXGI_FORMAT desired_format, UINT des
    while (*format != DXGI_FORMAT_UNKNOWN)
    {
       UINT         format_support;
-      if (SUCCEEDED(D3D11CheckFormatSupport(device, *format, &format_support)) &&
+      if (SUCCEEDED(device->lpVtbl->CheckFormatSupport(device, *format,
+                  &format_support)) &&
             ((format_support & desired_format_support) == desired_format_support))
          break;
       format++;
@@ -279,19 +283,22 @@ bool d3d11_init_shader(
    }
 
    if (vs_code)
-      D3D11CreateVertexShader(
-            device, D3DGetBufferPointer(vs_code), D3DGetBufferSize(vs_code), NULL, &out->vs);
+      device->lpVtbl->CreateVertexShader(
+            device, D3DGetBufferPointer(vs_code), D3DGetBufferSize(vs_code),
+            NULL, &out->vs);
 
    if (ps_code)
-      D3D11CreatePixelShader(
-            device, D3DGetBufferPointer(ps_code), D3DGetBufferSize(ps_code), NULL, &out->ps);
+      device->lpVtbl->CreatePixelShader(
+            device, D3DGetBufferPointer(ps_code), D3DGetBufferSize(ps_code),
+            NULL, &out->ps);
 
    if (gs_code)
-      D3D11CreateGeometryShader(
-            device, D3DGetBufferPointer(gs_code), D3DGetBufferSize(gs_code), NULL, &out->gs);
+      device->lpVtbl->CreateGeometryShader(
+            device, D3DGetBufferPointer(gs_code), D3DGetBufferSize(gs_code),
+            NULL, &out->gs);
 
    if (vs_code && input_element_descs)
-      D3D11CreateInputLayout(
+      device->lpVtbl->CreateInputLayout(
             device, input_element_descs, num_elements, D3DGetBufferPointer(vs_code),
             D3DGetBufferSize(vs_code), &out->layout);
 
diff --git a/gfx/common/d3d11_common.h b/gfx/common/d3d11_common.h
index 9fdd61c8c3..8378f7ceef 100644
--- a/gfx/common/d3d11_common.h
+++ b/gfx/common/d3d11_common.h
@@ -295,171 +295,6 @@ typedef struct
    d3d11_texture_t      luts[GFX_MAX_TEXTURES];
 } d3d11_video_t;
 
-#if !defined(__cplusplus) || defined(CINTERFACE)
-static INLINE void D3D11GetTexture2DDesc(D3D11Texture2D texture2d, D3D11_TEXTURE2D_DESC* desc)
-{
-    texture2d->lpVtbl->GetDesc(texture2d, desc);
-}
-
-static INLINE void D3D11GetShaderResourceViewResource(
-      D3D11ShaderResourceView shader_resource_view, D3D11Resource* resource)
-{
-   shader_resource_view->lpVtbl->GetResource(shader_resource_view, resource);
-}
-
-static INLINE void D3D11GetShaderResourceViewTexture2D(
-    D3D11ShaderResourceView shader_resource_view, D3D11Texture2D* texture2d)
-{
-    shader_resource_view->lpVtbl->GetResource(shader_resource_view, (D3D11Resource*)texture2d);
-}
-
-static INLINE void D3D11GetShaderResourceViewDesc(
-    D3D11ShaderResourceView shader_resource_view, D3D11_SHADER_RESOURCE_VIEW_DESC* desc)
-{
-    shader_resource_view->lpVtbl->GetDesc(shader_resource_view, desc);
-}
-
-static INLINE void D3D11SetPShaderResources(
-      D3D11DeviceContext               device_context,
-      UINT                             start_slot,
-      UINT                             num_views,
-      ID3D11ShaderResourceView* const* shader_resource_views)
-{
-   device_context->lpVtbl->PSSetShaderResources(
-         device_context, start_slot, num_views,
-         shader_resource_views);
-}
-
-static INLINE void
-D3D11GenerateMips(D3D11DeviceContext device_context, D3D11ShaderResourceView shader_resource_view)
-{
-   device_context->lpVtbl->GenerateMips(device_context, shader_resource_view);
-}
-
-static INLINE void
-D3D11GetState(D3D11DeviceContext device_context, D3D11RasterizerState* rasterizer_state)
-{
-   device_context->lpVtbl->RSGetState(device_context, rasterizer_state);
-}
-
-static INLINE HRESULT D3D11CreateBuffer(
-      D3D11Device             device,
-      D3D11_BUFFER_DESC*      desc,
-      D3D11_SUBRESOURCE_DATA* initial_data,
-      D3D11Buffer*            buffer)
-{
-   return device->lpVtbl->CreateBuffer(device, desc, initial_data, buffer);
-}
-
-static INLINE HRESULT D3D11CreateTexture2D(
-      D3D11Device             device,
-      D3D11_TEXTURE2D_DESC*   desc,
-      D3D11_SUBRESOURCE_DATA* initial_data,
-      D3D11Texture2D*         texture2d)
-{
-   return device->lpVtbl->CreateTexture2D(device, desc, initial_data, texture2d);
-}
-static INLINE HRESULT D3D11CreateShaderResourceView(
-      D3D11Device                      device,
-      D3D11Resource                    resource,
-      D3D11_SHADER_RESOURCE_VIEW_DESC* desc,
-      D3D11ShaderResourceView*         srview)
-{
-   return device->lpVtbl->CreateShaderResourceView(device, resource, desc, srview);
-}
-static INLINE HRESULT D3D11CreateRenderTargetView(
-      D3D11Device                    device,
-      D3D11Resource                  resource,
-      D3D11_RENDER_TARGET_VIEW_DESC* desc,
-      D3D11RenderTargetView*         rtview)
-{
-   return device->lpVtbl->CreateRenderTargetView(device, resource, desc, rtview);
-}
-static INLINE HRESULT D3D11CreateDepthStencilView(
-      D3D11Device                    device,
-      D3D11Resource                  resource,
-      D3D11_DEPTH_STENCIL_VIEW_DESC* desc,
-      D3D11DepthStencilView*         depth_stencil_view)
-{
-   return device->lpVtbl->CreateDepthStencilView(device, resource, desc, depth_stencil_view);
-}
-static INLINE HRESULT D3D11CreateInputLayout(
-      D3D11Device                     device,
-      const D3D11_INPUT_ELEMENT_DESC* input_element_descs,
-      UINT                            num_elements,
-      void*                           shader_bytecode_with_input_signature,
-      SIZE_T                          bytecode_length,
-      D3D11InputLayout*               input_layout)
-{
-   return device->lpVtbl->CreateInputLayout(
-         device, input_element_descs, num_elements, shader_bytecode_with_input_signature,
-         bytecode_length, input_layout);
-}
-static INLINE HRESULT D3D11CreateVertexShader(
-      D3D11Device        device,
-      void*              shader_bytecode,
-      SIZE_T             bytecode_length,
-      D3D11ClassLinkage  class_linkage,
-      D3D11VertexShader* vertex_shader)
-{
-   return device->lpVtbl->CreateVertexShader(
-         device, shader_bytecode, bytecode_length, class_linkage, vertex_shader);
-}
-static INLINE HRESULT D3D11CreateGeometryShader(
-      D3D11Device          device,
-      void*                shader_bytecode,
-      SIZE_T               bytecode_length,
-      D3D11ClassLinkage    class_linkage,
-      D3D11GeometryShader* geometry_shader)
-{
-   return device->lpVtbl->CreateGeometryShader(
-         device, shader_bytecode, bytecode_length, class_linkage, geometry_shader);
-}
-static INLINE HRESULT D3D11CreatePixelShader(
-      D3D11Device       device,
-      void*             shader_bytecode,
-      SIZE_T            bytecode_length,
-      D3D11ClassLinkage class_linkage,
-      D3D11PixelShader* pixel_shader)
-{
-   return device->lpVtbl->CreatePixelShader(
-         device, shader_bytecode, bytecode_length, class_linkage, pixel_shader);
-}
-
-static INLINE HRESULT
-D3D11CheckFormatSupport(D3D11Device device, DXGI_FORMAT format, UINT* format_support)
-{
-   return device->lpVtbl->CheckFormatSupport(device, format, format_support);
-}
-
-static INLINE D3D_FEATURE_LEVEL D3D11GetFeatureLevel(D3D11Device device)
-{
-   return device->lpVtbl->GetFeatureLevel(device);
-}
-
-/* end of auto-generated */
-
-static INLINE HRESULT D3D11CreateTexture2DRenderTargetView(
-      D3D11Device                    device,
-      D3D11Texture2D                 texture,
-      D3D11_RENDER_TARGET_VIEW_DESC* desc,
-      D3D11RenderTargetView*         rtview)
-{
-   return device->lpVtbl->CreateRenderTargetView(device, (D3D11Resource)texture, desc, rtview);
-}
-
-static INLINE HRESULT D3D11CreateTexture2DShaderResourceView(
-      D3D11Device                      device,
-      D3D11Texture2D                   texture,
-      D3D11_SHADER_RESOURCE_VIEW_DESC* desc,
-      D3D11ShaderResourceView*         srview)
-{
-   return device->lpVtbl->CreateShaderResourceView(device, (D3D11Resource)texture, desc, srview);
-}
-#endif
-
-void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture);
-
 static INLINE void d3d11_release_texture(d3d11_texture_t* texture)
 {
    Release(texture->handle);
@@ -468,6 +303,8 @@ static INLINE void d3d11_release_texture(d3d11_texture_t* texture)
    Release(texture->rt_view);
 }
 
+void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture);
+
 void d3d11_update_texture(
       D3D11DeviceContext ctx,
       unsigned           width,
@@ -492,11 +329,3 @@ bool d3d11_init_shader(
       UINT                            num_elements,
       d3d11_shader_t*                 out,
       enum d3d11_feature_level_hint   hint);
-
-static INLINE void d3d11_release_shader(d3d11_shader_t* shader)
-{
-   Release(shader->layout);
-   Release(shader->vs);
-   Release(shader->ps);
-   Release(shader->gs);
-}
diff --git a/gfx/drivers/d3d11.c b/gfx/drivers/d3d11.c
index e037833e4c..22a307a436 100644
--- a/gfx/drivers/d3d11.c
+++ b/gfx/drivers/d3d11.c
@@ -82,6 +82,14 @@ static D3D11Device           cached_device_d3d11;
 static D3D_FEATURE_LEVEL     cached_supportedFeatureLevel;
 static D3D11DeviceContext    cached_context_d3d11;
 
+static INLINE void d3d11_release_shader(d3d11_shader_t* shader)
+{
+   Release(shader->layout);
+   Release(shader->vs);
+   Release(shader->ps);
+   Release(shader->gs);
+}
+
 static uint32_t d3d11_get_flags(void *data)
 {
    uint32_t flags = 0;
@@ -192,7 +200,8 @@ static bool d3d11_overlay_load(void* data, const void* image_data, unsigned num_
    desc.CPUAccessFlags      = D3D11_CPU_ACCESS_WRITE;
    desc.MiscFlags           = 0;
    desc.StructureByteStride = 0;
-   D3D11CreateBuffer(d3d11->device, &desc, NULL, &d3d11->overlays.vbo);
+   d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, NULL,
+         &d3d11->overlays.vbo);
 
    d3d11->context->lpVtbl->Map(
          d3d11->context, (D3D11Resource)d3d11->overlays.vbo, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_vbo);
@@ -665,7 +674,7 @@ static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const
          if (!desc.ByteWidth)
             continue;
 
-         D3D11CreateBuffer(d3d11->device, &desc, NULL, &d3d11->pass[i].buffers[j]);
+         d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, NULL, &d3d11->pass[i].buffers[j]);
       }
    }
 
@@ -1223,8 +1232,10 @@ static void *d3d11_gfx_init(const video_info_t* video,
       ubo_data.SysMemPitch      = 0;
       ubo_data.SysMemSlicePitch = 0;
 
-      D3D11CreateBuffer(d3d11->device, &desc, &ubo_data, &d3d11->ubo);
-      D3D11CreateBuffer(d3d11->device, &desc, NULL, &d3d11->frame.ubo);
+      d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &ubo_data,
+            &d3d11->ubo);
+      d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, NULL,
+            &d3d11->frame.ubo);
    }
 
    d3d11_gfx_set_rotation(d3d11, 0);
@@ -1260,7 +1271,8 @@ static void *d3d11_gfx_init(const video_info_t* video,
       ubo_data.SysMemPitch                 = 0;
       ubo_data.SysMemSlicePitch            = 0;
 
-      D3D11CreateBuffer(d3d11->device, &desc, &ubo_data, &d3d11->hdr.ubo);
+      d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &ubo_data,
+            &d3d11->hdr.ubo);
    }
 #endif
 
@@ -1330,14 +1342,17 @@ static void *d3d11_gfx_init(const video_info_t* video,
       desc.MiscFlags               = 0;
       desc.StructureByteStride     = 0;
 
-      D3D11CreateBuffer(d3d11->device, &desc, &vertex_data, &d3d11->frame.vbo);
+      d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &vertex_data,
+            &d3d11->frame.vbo);
       desc.Usage                   = D3D11_USAGE_DYNAMIC;
       desc.CPUAccessFlags          = D3D11_CPU_ACCESS_WRITE;
-      D3D11CreateBuffer(d3d11->device, &desc, &vertex_data, &d3d11->menu.vbo);
+      d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &vertex_data,
+            &d3d11->menu.vbo);
 
       d3d11->sprites.capacity  = 16 * 1024;
       desc.ByteWidth           = sizeof(d3d11_sprite_t) * d3d11->sprites.capacity;
-      D3D11CreateBuffer(d3d11->device, &desc, NULL, &d3d11->sprites.vbo);
+      d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, NULL,
+            &d3d11->sprites.vbo);
    }
 
 #ifdef HAVE_DXGI_HDR
@@ -1895,8 +1910,9 @@ static bool d3d11_gfx_frame(
    {
        D3D11Texture2D back_buffer;
        d3d11->swapChain->lpVtbl->GetBuffer(d3d11->swapChain, 0,
-uuidof(ID3D11Texture2D), (void**)&back_buffer);
-       D3D11CreateTexture2DRenderTargetView(d3d11->device, back_buffer, NULL, &rtv);
+             uuidof(ID3D11Texture2D), (void**)&back_buffer);
+       d3d11->device->lpVtbl->CreateRenderTargetView(d3d11->device,
+             (D3D11Resource)back_buffer, NULL, &rtv);
        Release(back_buffer);
    }
 
@@ -1914,8 +1930,8 @@ uuidof(ID3D11Texture2D), (void**)&back_buffer);
           D3D11_SHADER_RESOURCE_VIEW_DESC hw_desc;
           D3D11ShaderResourceView hw_view = NULL;
           context->lpVtbl->PSGetShaderResources(context, 0, 1, &hw_view);
-          D3D11GetShaderResourceViewDesc(hw_view, &hw_desc);
-          D3D11GetShaderResourceViewTexture2D(hw_view, &hw_texture);
+          hw_view->lpVtbl->GetDesc(hw_view, &hw_desc);
+          hw_view->lpVtbl->GetResource(hw_view, (D3D11Resource*)&hw_texture);
 
           if (d3d11->frame.texture[0].desc.Format != hw_desc.Format)
           {
diff --git a/gfx/drivers_display/gfx_display_d3d11.c b/gfx/drivers_display/gfx_display_d3d11.c
index b56211559b..66317e626f 100644
--- a/gfx/drivers_display/gfx_display_d3d11.c
+++ b/gfx/drivers_display/gfx_display_d3d11.c
@@ -173,7 +173,8 @@ static void gfx_display_d3d11_draw(gfx_display_ctx_draw_t *draw,
 
    {
       d3d11_texture_t *texture = (d3d11_texture_t*)draw->texture;
-      D3D11SetPShaderResources(d3d11->context, 0, 1, &texture->view);
+      d3d11->context->lpVtbl->PSSetShaderResources(
+            d3d11->context, 0, 1, &texture->view);
       d3d11->context->lpVtbl->PSSetSamplers(
             d3d11->context, 0, 1, (D3D11SamplerState*)&texture->sampler);
    }
@@ -224,7 +225,8 @@ static void gfx_display_d3d11_draw_pipeline(gfx_display_ctx_draw_t *draw,
                vertex_data.pSysMem          = ca->coords.vertex;
                vertex_data.SysMemPitch      = 0;
                vertex_data.SysMemSlicePitch = 0;
-               D3D11CreateBuffer(d3d11->device, &desc, &vertex_data, &d3d11->menu_pipeline_vbo);
+               d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &vertex_data,
+                     &d3d11->menu_pipeline_vbo);
             }
          }
          {
diff --git a/gfx/drivers_font/d3d11_font.c b/gfx/drivers_font/d3d11_font.c
index 59003ebf19..d159512c35 100644
--- a/gfx/drivers_font/d3d11_font.c
+++ b/gfx/drivers_font/d3d11_font.c
@@ -219,7 +219,8 @@ static void d3d11_font_render_line(
 
    {
       d3d11_texture_t *texture = (d3d11_texture_t*)&font->texture;
-      D3D11SetPShaderResources(d3d11->context, 0, 1, &texture->view);
+      d3d11->context->lpVtbl->PSSetShaderResources(
+            d3d11->context, 0, 1, &texture->view);
       d3d11->context->lpVtbl->PSSetSamplers(
             d3d11->context, 0, 1,
             (D3D11SamplerState*)&texture->sampler);