diff --git a/gfx/common/d3d10_common.c b/gfx/common/d3d10_common.c
index d47474eb17..bca16016b3 100644
--- a/gfx/common/d3d10_common.c
+++ b/gfx/common/d3d10_common.c
@@ -68,40 +68,68 @@ HRESULT WINAPI D3D10CreateDeviceAndSwapChain(
 
 void d3d10_init_texture(D3D10Device device, d3d10_texture_t* texture)
 {
-   Release(texture->handle);
-   Release(texture->staging);
-   Release(texture->view);
+   bool is_render_target = texture->desc.BindFlags & D3D10_BIND_RENDER_TARGET;
+   UINT format_support   = D3D10_FORMAT_SUPPORT_TEXTURE2D | D3D10_FORMAT_SUPPORT_SHADER_SAMPLE;
 
-   //   .Usage = D3D10_USAGE_DYNAMIC,
-   //   .CPUAccessFlags = D3D10_CPU_ACCESS_WRITE,
+   d3d10_release_texture(texture);
 
    texture->desc.MipLevels          = 1;
    texture->desc.ArraySize          = 1;
    texture->desc.SampleDesc.Count   = 1;
    texture->desc.SampleDesc.Quality = 0;
-   texture->desc.BindFlags          = D3D10_BIND_SHADER_RESOURCE;
-   texture->desc.CPUAccessFlags     = 0;
-   texture->desc.MiscFlags          = 0;
+   texture->desc.BindFlags         |= D3D10_BIND_SHADER_RESOURCE;
+   texture->desc.CPUAccessFlags     =
+      texture->desc.Usage == D3D10_USAGE_DYNAMIC ? D3D10_CPU_ACCESS_WRITE : 0;
+
+   if (texture->desc.MiscFlags & D3D10_RESOURCE_MISC_GENERATE_MIPS)
+   {
+      unsigned width, height;
+
+      texture->desc.BindFlags |= D3D10_BIND_RENDER_TARGET;
+      width                    = texture->desc.Width >> 5;
+      height                   = texture->desc.Height >> 5;
+
+      while (width && height)
+      {
+         width >>= 1;
+         height >>= 1;
+         texture->desc.MipLevels++;
+      }
+   }
+
+   if (texture->desc.BindFlags & D3D10_BIND_RENDER_TARGET)
+      format_support |= D3D10_FORMAT_SUPPORT_RENDER_TARGET;
+
+   texture->desc.Format = d3d10_get_closest_match(device, texture->desc.Format, format_support);
+
    D3D10CreateTexture2D(device, &texture->desc, NULL, &texture->handle);
 
    {
       D3D10_SHADER_RESOURCE_VIEW_DESC view_desc = { DXGI_FORMAT_UNKNOWN };
-      view_desc.Format                    = texture->desc.Format;
-      view_desc.ViewDimension             = D3D_SRV_DIMENSION_TEXTURE2D;
-      view_desc.Texture2D.MostDetailedMip = 0;
-      view_desc.Texture2D.MipLevels       = -1;
-
-      D3D10CreateTexture2DShaderResourceView(device,
-            texture->handle, &view_desc, &texture->view);
+      view_desc.Format                          = texture->desc.Format;
+      view_desc.ViewDimension                   = D3D_SRV_DIMENSION_TEXTURE2D;
+      view_desc.Texture2D.MostDetailedMip       = 0;
+      view_desc.Texture2D.MipLevels             = -1;
+      D3D10CreateTexture2DShaderResourceView(device, texture->handle, &view_desc, &texture->view);
    }
 
+   if (is_render_target)
+      D3D10CreateTexture2DRenderTargetView(device, texture->handle, NULL, &texture->rt_view);
+   else
    {
       D3D10_TEXTURE2D_DESC desc = texture->desc;
+      desc.MipLevels            = 1;
       desc.BindFlags            = 0;
+      desc.MiscFlags            = 0;
       desc.Usage                = D3D10_USAGE_STAGING;
       desc.CPUAccessFlags       = D3D10_CPU_ACCESS_WRITE;
       D3D10CreateTexture2D(device, &desc, NULL, &texture->staging);
    }
+
+   texture->size_data.x = texture->desc.Width;
+   texture->size_data.y = texture->desc.Height;
+   texture->size_data.z = 1.0f / texture->desc.Width;
+   texture->size_data.w = 1.0f / texture->desc.Height;
 }
 
 void d3d10_update_texture(
diff --git a/gfx/common/d3d10_common.h b/gfx/common/d3d10_common.h
index bff18cb40f..ee8373ca57 100644
--- a/gfx/common/d3d10_common.h
+++ b/gfx/common/d3d10_common.h
@@ -22,8 +22,6 @@
 
 #include "../drivers_shader/slang_process.h"
 
-typedef D3D10_MAPPED_TEXTURE3D D3D10_MAPPED_SUBRESOURCE;
-
 typedef const ID3D10SamplerState*       D3D10SamplerStateRef;
 
 typedef ID3D10InputLayout*       D3D10InputLayout;
@@ -1141,11 +1139,6 @@ typedef struct
    D3D10Buffer           ubo;
    d3d10_uniform_t       ubo_values;
    D3D10SamplerState     samplers[RARCH_FILTER_MAX][RARCH_WRAP_MAX];
-   D3D10InputLayout      layout;
-   D3D10VertexShader     vs;
-   D3D10PixelShader      ps;
-   D3D10SamplerState     sampler_nearest;
-   D3D10SamplerState     sampler_linear;
    D3D10BlendState       blend_enable;
    D3D10BlendState       blend_disable;
    D3D10BlendState       blend_pipeline;
@@ -1188,7 +1181,6 @@ typedef struct
    {
       d3d10_texture_t   texture;
       D3D10Buffer       vbo;
-      D3D10SamplerState sampler;
       bool              enabled;
       bool              fullscreen;
    } menu;
@@ -1197,7 +1189,6 @@ typedef struct
       d3d10_texture_t texture[GFX_MAX_FRAME_HISTORY + 1];
       D3D10Buffer       vbo;
       D3D10Buffer       ubo;
-      D3D10SamplerState sampler;
       D3D10_VIEWPORT    viewport;
       float4_t          output_size;
       int               rotation;
diff --git a/gfx/drivers/d3d10.c b/gfx/drivers/d3d10.c
index 98e4791fd8..c7e3e7890c 100644
--- a/gfx/drivers/d3d10.c
+++ b/gfx/drivers/d3d10.c
@@ -46,71 +46,60 @@ static void d3d10_free_overlays(d3d10_video_t* d3d10)
 static void
 d3d10_overlay_vertex_geom(void* data, unsigned index, float x, float y, float w, float h)
 {
-   D3D10_MAPPED_SUBRESOURCE mapped_vbo;
-   d3d10_video_t*           d3d10 = (d3d10_video_t*)data;
+	d3d10_sprite_t* sprites = NULL;
+   d3d10_video_t*  d3d10 = (d3d10_video_t*)data;
 
    if (!d3d10)
       return;
 
    D3D10MapBuffer(d3d10->overlays.vbo, 
-         D3D10_MAP_WRITE_NO_OVERWRITE, 0, (void**)&mapped_vbo);
-   {
-      d3d10_sprite_t* sprites = (d3d10_sprite_t*)mapped_vbo.pData;
-      sprites[index].pos.x    = x;
-      sprites[index].pos.y    = y;
-      sprites[index].pos.w    = w;
-      sprites[index].pos.h    = h;
-   }
+         D3D10_MAP_WRITE_NO_OVERWRITE, 0, (void**)&sprites);
+	sprites[index].pos.x    = x;
+	sprites[index].pos.y    = y;
+	sprites[index].pos.w    = w;
+	sprites[index].pos.h    = h;
    D3D10UnmapBuffer(d3d10->overlays.vbo);
 }
 
 static void d3d10_overlay_tex_geom(void* data, unsigned index, float u, float v, float w, float h)
 {
-   D3D10_MAPPED_SUBRESOURCE mapped_vbo;
-   d3d10_video_t*           d3d10 = (d3d10_video_t*)data;
+	d3d10_sprite_t* sprites = NULL;
+   d3d10_video_t*  d3d10 = (d3d10_video_t*)data;
 
    if (!d3d10)
       return;
 
    D3D10MapBuffer(
          d3d10->overlays.vbo, 
-         D3D10_MAP_WRITE_NO_OVERWRITE, 0, (void**)&mapped_vbo);
-   {
-      d3d10_sprite_t* sprites = (d3d10_sprite_t*)mapped_vbo.pData;
-      sprites[index].coords.u = u;
-      sprites[index].coords.v = v;
-      sprites[index].coords.w = w;
-      sprites[index].coords.h = h;
-   }
+         D3D10_MAP_WRITE_NO_OVERWRITE, 0, (void**)&sprites);
+	sprites[index].coords.u = u;
+	sprites[index].coords.v = v;
+	sprites[index].coords.w = w;
+	sprites[index].coords.h = h;
    D3D10UnmapBuffer(d3d10->overlays.vbo);
 }
 
 static void d3d10_overlay_set_alpha(void* data, unsigned index, float mod)
 {
-   D3D10_MAPPED_SUBRESOURCE mapped_vbo;
-   d3d10_video_t*           d3d10 = (d3d10_video_t*)data;
+	d3d10_sprite_t* sprites = NULL;
+   d3d10_video_t*  d3d10 = (d3d10_video_t*)data;
 
    if (!d3d10)
       return;
 
    D3D10MapBuffer(
-         d3d10->overlays.vbo, 
-         D3D10_MAP_WRITE_NO_OVERWRITE, 0, (void**)&mapped_vbo);
-
-   {
-      d3d10_sprite_t* sprites  = (d3d10_sprite_t*)mapped_vbo.pData;
-      sprites[index].colors[0] = DXGI_COLOR_RGBA(0xFF, 0xFF, 0xFF, mod * 0xFF);
-      sprites[index].colors[1] = sprites[index].colors[0];
-      sprites[index].colors[2] = sprites[index].colors[0];
-      sprites[index].colors[3] = sprites[index].colors[0];
-   }
+         d3d10->overlays.vbo,
+         D3D10_MAP_WRITE_NO_OVERWRITE, 0, (void**)&sprites);
+	sprites[index].colors[0] = DXGI_COLOR_RGBA(0xFF, 0xFF, 0xFF, mod * 0xFF);
+	sprites[index].colors[1] = sprites[index].colors[0];
+	sprites[index].colors[2] = sprites[index].colors[0];
+	sprites[index].colors[3] = sprites[index].colors[0];
    D3D10UnmapBuffer(d3d10->overlays.vbo);
 }
 
 static bool d3d10_overlay_load(void* data, const void* image_data, unsigned num_images)
 {
    D3D10_BUFFER_DESC desc;
-   D3D10_MAPPED_SUBRESOURCE    mapped_vbo;
    int                         i;
    d3d10_sprite_t*             sprites;
    d3d10_video_t*              d3d10  = (d3d10_video_t*)data;
@@ -135,8 +124,7 @@ static bool d3d10_overlay_load(void* data, const void* image_data, unsigned num_
    D3D10CreateBuffer(d3d10->device, &desc, NULL, &d3d10->overlays.vbo);
 
    D3D10MapBuffer(d3d10->overlays.vbo, 
-         D3D10_MAP_WRITE_DISCARD, 0, (void**)&mapped_vbo);
-   sprites                  = (d3d10_sprite_t*)mapped_vbo.pData;
+         D3D10_MAP_WRITE_DISCARD, 0, (void**)&sprites);
 
    for (i = 0; i < num_images; i++)
    {
@@ -210,31 +198,33 @@ static void d3d10_get_overlay_interface(void* data, const video_overlay_interfac
 
 static void d3d10_set_filtering(void* data, unsigned index, bool smooth)
 {
+   unsigned       i;
    d3d10_video_t* d3d10 = (d3d10_video_t*)data;
 
-   if (smooth)
-      d3d10->frame.sampler = d3d10->sampler_linear;
-   else
-      d3d10->frame.sampler = d3d10->sampler_nearest;
+   for (i = 0; i < RARCH_WRAP_MAX; i++)
+   {
+      if (smooth)
+         d3d10->samplers[RARCH_FILTER_UNSPEC][i] = d3d10->samplers[RARCH_FILTER_LINEAR][i];
+      else
+         d3d10->samplers[RARCH_FILTER_UNSPEC][i] = d3d10->samplers[RARCH_FILTER_NEAREST][i];
+   }
 }
 
+
 static void d3d10_gfx_set_rotation(void* data, unsigned rotation)
 {
-   math_matrix_4x4  rot;
-   math_matrix_4x4* mvp;
-   d3d10_video_t*   d3d10 = (d3d10_video_t*)data;
+	math_matrix_4x4 rot;
+   d3d10_video_t*  d3d10 = (d3d10_video_t*)data;
 
-   if(!d3d10)
+   if (!d3d10)
       return;
 
-   d3d10->frame.rotation = rotation;
+   matrix_4x4_rotate_z(rot, rotation * (M_PI / 2.0f));
+   matrix_4x4_multiply(d3d10->mvp, rot, d3d10->ubo_values.mvp);
 
-
-   matrix_4x4_rotate_z(rot, d3d10->frame.rotation * (M_PI / 2.0f));
-   matrix_4x4_multiply(d3d10->mvp, rot, d3d10->mvp_no_rot);
-
-   D3D10MapBuffer(d3d10->frame.ubo, D3D10_MAP_WRITE_DISCARD, 0, (void**)&mvp);
-   *mvp = d3d10->mvp;
+   void* mapped_ubo;
+   D3D10MapBuffer(d3d10->frame.ubo, D3D10_MAP_WRITE_DISCARD, 0, &mapped_ubo);
+   *(math_matrix_4x4*)mapped_ubo = d3d10->mvp;
    D3D10UnmapBuffer(d3d10->frame.ubo);
 }
 
@@ -244,13 +234,22 @@ static void d3d10_update_viewport(void* data, bool force_full)
 
    video_driver_update_viewport(&d3d10->vp, force_full, d3d10->keep_aspect);
 
-   d3d10->frame.viewport.TopLeftX = (float)d3d10->vp.x;
-   d3d10->frame.viewport.TopLeftY = (float)d3d10->vp.y;
-   d3d10->frame.viewport.Width    = (float)d3d10->vp.width;
-   d3d10->frame.viewport.Height   = (float)d3d10->vp.height;
+   d3d10->frame.viewport.TopLeftX = d3d10->vp.x;
+   d3d10->frame.viewport.TopLeftY = d3d10->vp.y;
+   d3d10->frame.viewport.Width    = d3d10->vp.width;
+   d3d10->frame.viewport.Height   = d3d10->vp.height;
    d3d10->frame.viewport.MaxDepth = 0.0f;
    d3d10->frame.viewport.MaxDepth = 1.0f;
 
+   if (d3d10->shader_preset && (d3d10->frame.output_size.x != d3d10->vp.width ||
+                                d3d10->frame.output_size.y != d3d10->vp.height))
+      d3d10->resize_render_targets = true;
+
+   d3d10->frame.output_size.x = d3d10->vp.width;
+   d3d10->frame.output_size.y = d3d10->vp.height;
+   d3d10->frame.output_size.z = 1.0f / d3d10->vp.width;
+   d3d10->frame.output_size.w = 1.0f / d3d10->vp.height;
+
    d3d10->resize_viewport = false;
 }
 
@@ -299,72 +298,6 @@ static void d3d10_free_shader_preset(d3d10_video_t* d3d10)
    d3d10->resize_render_targets = false;
 }
 
-
-static void d3d10_gfx_free(void* data)
-{
-   unsigned       i;
-   d3d10_video_t* d3d10 = (d3d10_video_t*)data;
-
-   if (!d3d10)
-      return;
-
-#ifdef HAVE_OVERLAY
-   d3d10_free_overlays(d3d10);
-#endif
-
-   d3d10_free_shader_preset(d3d10);
-
-   d3d10_release_texture(&d3d10->frame.texture[0]);
-   Release(d3d10->frame.ubo);
-   Release(d3d10->frame.vbo);
-
-   d3d10_release_texture(&d3d10->menu.texture);
-   Release(d3d10->menu.vbo);
-
-   d3d10_release_shader(&d3d10->sprites.shader);
-   d3d10_release_shader(&d3d10->sprites.shader_font);
-   Release(d3d10->sprites.vbo);
-
-   for (i = 0; i < GFX_MAX_SHADERS; i++)
-      d3d10_release_shader(&d3d10->shaders[i]);
-
-   Release(d3d10->menu_pipeline_vbo);
-   Release(d3d10->blend_pipeline);
-
-   Release(d3d10->ubo);
-
-   Release(d3d10->blend_enable);
-   Release(d3d10->blend_disable);
-
-   for (i = 0; i < RARCH_WRAP_MAX; i++)
-   {
-      Release(d3d10->samplers[RARCH_FILTER_LINEAR][i]);
-      Release(d3d10->samplers[RARCH_FILTER_NEAREST][i]);
-   }
-
-   Release(d3d10->state);
-   Release(d3d10->renderTargetView);
-   Release(d3d10->swapChain);
-
-   font_driver_free_osd();
-
-#if 0
-	if (video_driver_is_video_cache_context())
-	{
-      cached_device_d3d10 = d3d10->device;
-		cached_context = d3d10->context;
-	}
-	else
-#endif
-	{
-		Release(d3d10->device);
-	}
-
-   win32_monitor_from_window();
-   win32_destroy_window();
-   free(d3d10);
-}
-
 static bool d3d10_gfx_set_shader(void* data,
       enum rarch_shader_type type, const char* path)
 {
@@ -513,9 +446,6 @@ static bool d3d10_gfx_set_shader(void* data,
          desc.BindFlags           = D3D10_BIND_CONSTANT_BUFFER;
          desc.CPUAccessFlags      = D3D10_CPU_ACCESS_WRITE;
          desc.MiscFlags           = 0;
-#if 0
-         desc.StructureByteStride = 0;
-#endif
 
          if (!desc.ByteWidth)
             continue;
@@ -564,9 +494,75 @@ error:
    return false;
 }
 
+static void d3d10_gfx_free(void* data)
+{
+   unsigned       i;
+   d3d10_video_t* d3d10 = (d3d10_video_t*)data;
+
+   if (!d3d10)
+      return;
+
+#ifdef HAVE_OVERLAY
+   d3d10_free_overlays(d3d10);
+#endif
+
+   d3d10_free_shader_preset(d3d10);
+
+   d3d10_release_texture(&d3d10->frame.texture[0]);
+   Release(d3d10->frame.ubo);
+   Release(d3d10->frame.vbo);
+
+   d3d10_release_texture(&d3d10->menu.texture);
+   Release(d3d10->menu.vbo);
+
+   d3d10_release_shader(&d3d10->sprites.shader);
+   d3d10_release_shader(&d3d10->sprites.shader_font);
+   Release(d3d10->sprites.vbo);
+
+   for (i = 0; i < GFX_MAX_SHADERS; i++)
+      d3d10_release_shader(&d3d10->shaders[i]);
+
+   Release(d3d10->menu_pipeline_vbo);
+   Release(d3d10->blend_pipeline);
+
+   Release(d3d10->ubo);
+
+   Release(d3d10->blend_enable);
+   Release(d3d10->blend_disable);
+
+   for (i = 0; i < RARCH_WRAP_MAX; i++)
+   {
+      Release(d3d10->samplers[RARCH_FILTER_LINEAR][i]);
+      Release(d3d10->samplers[RARCH_FILTER_NEAREST][i]);
+   }
+
+   Release(d3d10->state);
+   Release(d3d10->renderTargetView);
+   Release(d3d10->swapChain);
+
+   font_driver_free_osd();
+
+#if 0
+	if (video_driver_is_video_cache_context())
+	{
+      cached_device_d3d10 = d3d10->device;
+		cached_context = d3d10->context;
+	}
+	else
+#endif
+	{
+		Release(d3d10->device);
+	}
+
+   win32_monitor_from_window();
+   win32_destroy_window();
+   free(d3d10);
+}
+
    static void*
 d3d10_gfx_init(const video_info_t* video, const input_driver_t** input, void** input_data)
 {
+   unsigned i;
    MONITORINFOEX   current_mon;
    HMONITOR        hm_to_use;
    WNDCLASSEX      wndclass = { 0 };
@@ -591,34 +587,31 @@ d3d10_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
    if (!d3d10->vp.full_height)
       d3d10->vp.full_height = current_mon.rcMonitor.bottom - current_mon.rcMonitor.top;
 
-   if (!win32_set_video_mode(d3d10, video->width, video->height, video->fullscreen))
+	if (!win32_set_video_mode(d3d10, d3d10->vp.full_width, d3d10->vp.full_height, video->fullscreen))
    {
       RARCH_ERR("[D3D10]: win32_set_video_mode failed.\n");
       goto error;
    }
-
    dxgi_input_driver(settings->arrays.input_joypad_driver, input, input_data);
 
    {
       UINT                 flags = 0;
       DXGI_SWAP_CHAIN_DESC desc  = {0};
 
-      desc.BufferCount           = 2;
-      desc.BufferDesc.Width      = video->width;
-      desc.BufferDesc.Height     = video->height;
+      desc.BufferCount           = 1;
+      desc.BufferDesc.Width      = d3d10->vp.full_width;
+      desc.BufferDesc.Height     = d3d10->vp.full_height;
       desc.BufferDesc.Format     = DXGI_FORMAT_R8G8B8A8_UNORM;
-#if 0
       desc.BufferDesc.RefreshRate.Numerator   = 60;
       desc.BufferDesc.RefreshRate.Denominator = 1;
-#endif
       desc.BufferUsage           = DXGI_USAGE_RENDER_TARGET_OUTPUT;
       desc.OutputWindow          = main_window.hwnd;
       desc.SampleDesc.Count      = 1;
       desc.SampleDesc.Quality    = 0;
       desc.Windowed              = TRUE;
-      desc.SwapEffect            = DXGI_SWAP_EFFECT_DISCARD;
+		desc.SwapEffect            = DXGI_SWAP_EFFECT_SEQUENTIAL;
 #if 0
-      desc.SwapEffect            = DXGI_SWAP_EFFECT_SEQUENTIAL;
+		desc.SwapEffect            = DXGI_SWAP_EFFECT_DISCARD;
       desc.SwapEffect            = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
       desc.SwapEffect            = DXGI_SWAP_EFFECT_FLIP_DISCARD;
 #endif
@@ -641,16 +634,17 @@ d3d10_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
       Release(backBuffer);
    }
 
-   D3D10SetRenderTargets(d3d10->device, 1, &d3d10->renderTargetView, NULL);
-   d3d10->viewport.Width  = video->width;
-   d3d10->viewport.Height = video->height;
+	D3D10SetRenderTargets(d3d10->device, 1, &d3d10->renderTargetView, NULL);
+
+   video_driver_set_size(&d3d10->vp.full_width, &d3d10->vp.full_height);
+   d3d10->viewport.Width  = d3d10->vp.full_width;
+   d3d10->viewport.Height = d3d10->vp.full_height;
    d3d10->resize_viewport = true;
-   d3d10->keep_aspect     = video->force_aspect;
    d3d10->vsync           = video->vsync;
    d3d10->format          = video->rgb32 ? 
       DXGI_FORMAT_B8G8R8X8_UNORM : DXGI_FORMAT_B5G6R5_UNORM;
 
-   d3d10->frame.texture[0].desc.Format = d3d10_get_closest_match_texture2D(d3d10->device, d3d10->format);
+   d3d10->frame.texture[0].desc.Format = d3d10->format;
    d3d10->frame.texture[0].desc.Usage  = D3D10_USAGE_DEFAULT;
    d3d10->frame.texture[0].desc.Width  = 4;
    d3d10->frame.texture[0].desc.Height = 4;
@@ -659,7 +653,7 @@ d3d10_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
 
    d3d10->menu.texture.desc.Usage  = D3D10_USAGE_DEFAULT;
 
-   matrix_4x4_ortho(d3d10->mvp_no_rot, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
+   matrix_4x4_ortho(d3d10->ubo_values.mvp, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
 
    d3d10->ubo_values.OutputSize.width  = d3d10->viewport.Width;
    d3d10->ubo_values.OutputSize.height = d3d10->viewport.Height;
@@ -668,13 +662,13 @@ d3d10_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
       D3D10_SUBRESOURCE_DATA ubo_data;
       D3D10_BUFFER_DESC desc;
 
-      desc.ByteWidth            = sizeof(math_matrix_4x4);
+      desc.ByteWidth            = sizeof(d3d10->ubo_values);
       desc.Usage                = D3D10_USAGE_DYNAMIC;
       desc.BindFlags            = D3D10_BIND_CONSTANT_BUFFER;
       desc.CPUAccessFlags       = D3D10_CPU_ACCESS_WRITE;
       desc.MiscFlags            = 0;
 
-      ubo_data.pSysMem          = &d3d10->mvp_no_rot;
+      ubo_data.pSysMem          = &d3d10->ubo_values.mvp;
       ubo_data.SysMemPitch      = 0;
       ubo_data.SysMemSlicePitch = 0;
 
@@ -685,22 +679,11 @@ d3d10_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
    d3d10_gfx_set_rotation(d3d10, 0);
 
    {
-      unsigned i;
-      unsigned k;
-      D3D10_SAMPLER_DESC desc;
-
-      desc.Filter         = D3D10_FILTER_MIN_MAG_MIP_POINT;
-      desc.AddressU       = D3D10_TEXTURE_ADDRESS_BORDER;
-      desc.AddressV       = D3D10_TEXTURE_ADDRESS_BORDER;
-      desc.AddressW       = D3D10_TEXTURE_ADDRESS_BORDER;
-      desc.MipLODBias     = 0.0f;
-      desc.MaxAnisotropy  = 1;
-      desc.ComparisonFunc = D3D10_COMPARISON_NEVER;
-      desc.MinLOD         = -D3D10_FLOAT32_MAX;
-      desc.MaxLOD         = D3D10_FLOAT32_MAX;
-
-      for (k = 0; k < 4; k++)
-         desc.BorderColor[k] = 0.0f;
+		D3D10_SAMPLER_DESC desc = { D3D10_FILTER_MIN_MAG_MIP_POINT };
+      desc.MaxAnisotropy      = 1;
+      desc.ComparisonFunc     = D3D10_COMPARISON_NEVER;
+      desc.MinLOD             = -D3D10_FLOAT32_MAX;
+      desc.MaxLOD             = D3D10_FLOAT32_MAX;
 
       /* Initialize samplers */
       for (i = 0; i < RARCH_WRAP_MAX; i++)
@@ -882,27 +865,26 @@ d3d10_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
    }
 
    {
-      unsigned k;
-      D3D10_BLEND_DESC blend_desc;
-
-      for (k = 0; k < 8; k++)
-      {
-         blend_desc.BlendEnable[k]           = TRUE;
-         blend_desc.RenderTargetWriteMask[k] = D3D10_COLOR_WRITE_ENABLE_ALL;
-      }
-
-      blend_desc.AlphaToCoverageEnable        = FALSE;
-      blend_desc.SrcBlend                     = D3D10_BLEND_SRC_ALPHA;
-      blend_desc.DestBlend                    = D3D10_BLEND_INV_SRC_ALPHA;
-      blend_desc.BlendOp                      = D3D10_BLEND_OP_ADD;
-      blend_desc.SrcBlendAlpha                = D3D10_BLEND_SRC_ALPHA;
-      blend_desc.DestBlendAlpha               = D3D10_BLEND_INV_SRC_ALPHA;
-      blend_desc.BlendOpAlpha                 = D3D10_BLEND_OP_ADD;
+		D3D10_BLEND_DESC blend_desc = { 0 };
 
+      blend_desc.AlphaToCoverageEnable    = FALSE;
+      blend_desc.BlendEnable[0]           = TRUE;
+      blend_desc.SrcBlend                 = D3D10_BLEND_SRC_ALPHA;
+      blend_desc.DestBlend                = D3D10_BLEND_INV_SRC_ALPHA;
+      blend_desc.BlendOp                  = D3D10_BLEND_OP_ADD;
+      blend_desc.SrcBlendAlpha            = D3D10_BLEND_SRC_ALPHA;
+      blend_desc.DestBlendAlpha           = D3D10_BLEND_INV_SRC_ALPHA;
+      blend_desc.BlendOpAlpha             = D3D10_BLEND_OP_ADD;
+      blend_desc.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;
       D3D10CreateBlendState(d3d10->device, &blend_desc, &d3d10->blend_enable);
+
+      blend_desc.SrcBlend  = D3D10_BLEND_ONE;
+      blend_desc.DestBlend = D3D10_BLEND_ONE;
+      D3D10CreateBlendState(d3d10->device, &blend_desc, &d3d10->blend_pipeline);
+
       blend_desc.BlendEnable[0] = FALSE;
       D3D10CreateBlendState(d3d10->device, &blend_desc, &d3d10->blend_disable);
-   }
+   }	
 
    {
       D3D10_RASTERIZER_DESC desc = { (D3D10_FILL_MODE)0 };
@@ -930,8 +912,8 @@ d3d10_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
        video_driver_get_hw_context()->version_major == 11)
    {
       d3d10->hw.enable                  = true;
-      d3d10->hw.iface.interface_type    = RETRO_HW_RENDER_INTERFACE_D3D11;
-      d3d10->hw.iface.interface_version = RETRO_HW_RENDER_INTERFACE_D3D11_VERSION;
+      d3d10->hw.iface.interface_type    = RETRO_HW_RENDER_INTERFACE_D3D10;
+      d3d10->hw.iface.interface_version = RETRO_HW_RENDER_INTERFACE_D3D10_VERSION;
       d3d10->hw.iface.handle            = d3d10;
       d3d10->hw.iface.device            = d3d10->device;
       d3d10->hw.iface.context           = d3d10->context;
@@ -1221,14 +1203,14 @@ static bool d3d10_gfx_frame(
 
             if (buffer_sem->stage_mask && buffer_sem->uniforms)
             {
-               D3D10_MAPPED_SUBRESOURCE res;
+               void* data;
                uniform_sem_t*           uniform = buffer_sem->uniforms;
 
-               D3D10MapBuffer(buffer, D3D10_MAP_WRITE_DISCARD, 0, (void**)&res);
+               D3D10MapBuffer(buffer, D3D10_MAP_WRITE_DISCARD, 0, (void**)&data);
                while (uniform->size)
                {
                   if (uniform->data)
-                     memcpy((uint8_t*)res.pData + uniform->offset, uniform->data, uniform->size);
+                     memcpy((uint8_t*)data + uniform->offset, uniform->data, uniform->size);
                   uniform++;
                }
                D3D10UnmapBuffer(buffer);
@@ -1392,6 +1374,10 @@ static bool d3d10_gfx_frame(
 static void d3d10_gfx_set_nonblock_state(void* data, bool toggle)
 {
    d3d10_video_t* d3d10 = (d3d10_video_t*)data;
+
+	if (!d3d10)
+      return;
+
    d3d10->vsync         = !toggle;
 }
 
@@ -1451,14 +1437,13 @@ static bool d3d10_gfx_read_viewport(void* data, uint8_t* buffer, bool is_idle)
 static void d3d10_set_menu_texture_frame(
       void* data, const void* frame, bool rgb32, unsigned width, unsigned height, float alpha)
 {
-   d3d10_video_t* d3d10     = (d3d10_video_t*)data;
-   settings_t*     settings = config_get_ptr();
-   int            pitch     = width * (rgb32 ? sizeof(uint32_t) 
-         : sizeof(uint16_t));
-   DXGI_FORMAT    format    = rgb32 ? DXGI_FORMAT_B8G8R8A8_UNORM 
-      : (DXGI_FORMAT)DXGI_FORMAT_EX_A4R4G4B4_UNORM;
+   d3d10_video_t* d3d10    = (d3d10_video_t*)data;
+   settings_t*    settings = config_get_ptr();
+   DXGI_FORMAT    format   = rgb32 ? DXGI_FORMAT_B8G8R8A8_UNORM :
+      (DXGI_FORMAT)DXGI_FORMAT_EX_A4R4G4B4_UNORM;
 
-   if (  d3d10->menu.texture.desc.Width  != width || 
+   if (
+         d3d10->menu.texture.desc.Width  != width ||
          d3d10->menu.texture.desc.Height != height)
    {
       d3d10->menu.texture.desc.Format = format;
@@ -1467,19 +1452,20 @@ static void d3d10_set_menu_texture_frame(
       d3d10_init_texture(d3d10->device, &d3d10->menu.texture);
    }
 
-   d3d10_update_texture(d3d10->device,
-         width, height, pitch, format,
-         frame, &d3d10->menu.texture);
+   d3d10_update_texture(d3d10->device, width, height, 0,
+         format, frame, &d3d10->menu.texture);
    d3d10->menu.texture.sampler = d3d10->samplers
       [settings->bools.menu_linear_filter
       ? RARCH_FILTER_LINEAR
          : RARCH_FILTER_NEAREST][RARCH_WRAP_DEFAULT];
 }
-
 static void d3d10_set_menu_texture_enable(void* data, bool state, bool full_screen)
 {
    d3d10_video_t* d3d10 = (d3d10_video_t*)data;
 
+	if (!d3d10)
+      return;
+
    d3d10->menu.enabled    = state;
    d3d10->menu.fullscreen = full_screen;
 }
@@ -1609,7 +1595,7 @@ static const video_poke_interface_t d3d10_poke_interface = {
    d3d10_gfx_get_current_shader,
    NULL, /* get_current_software_framebuffer */
 #if 0
-   d3d11_get_hw_render_interface,
+   d3d10_get_hw_render_interface,
 #else
    NULL, /* get_hw_render_interface */
 #endif
diff --git a/gfx/drivers_font/d3d10_font.c b/gfx/drivers_font/d3d10_font.c
index 43a0c309c3..3252854303 100644
--- a/gfx/drivers_font/d3d10_font.c
+++ b/gfx/drivers_font/d3d10_font.c
@@ -130,7 +130,7 @@ static void d3d10_font_render_line(
       unsigned            text_align)
 {
    unsigned                 i, count;
-   D3D10_MAPPED_SUBRESOURCE mapped_vbo;
+   void*                    mapped_vbo;
    d3d10_sprite_t*          v;
    d3d10_video_t*           d3d10  = (d3d10_video_t*)video_info->userdata;
    unsigned                 width  = video_info->width;
@@ -158,7 +158,7 @@ static void d3d10_font_render_line(
    }
 
    D3D10MapBuffer(d3d10->sprites.vbo, D3D10_MAP_WRITE_NO_OVERWRITE, 0, (void**)&mapped_vbo);
-   v = (d3d10_sprite_t*)mapped_vbo.pData + d3d10->sprites.offset;
+   v = (d3d10_sprite_t*)mapped_vbo + d3d10->sprites.offset;
 
    for (i = 0; i < msg_len; i++)
    {
@@ -202,7 +202,7 @@ static void d3d10_font_render_line(
       y += glyph->advance_y * scale;
    }
 
-   count = v - ((d3d10_sprite_t*)mapped_vbo.pData + d3d10->sprites.offset);
+   count = v - ((d3d10_sprite_t*)mapped_vbo + d3d10->sprites.offset);
    D3D10UnmapBuffer(d3d10->sprites.vbo);
 
    if (!count)
diff --git a/menu/drivers_display/menu_display_d3d10.c b/menu/drivers_display/menu_display_d3d10.c
index d5e200a638..7579fc8791 100644
--- a/menu/drivers_display/menu_display_d3d10.c
+++ b/menu/drivers_display/menu_display_d3d10.c
@@ -101,12 +101,12 @@ static void menu_display_d3d10_draw(void* data, video_frame_info_t *video_info)
       d3d10->sprites.offset = 0;
 
    {
-      D3D10_MAPPED_SUBRESOURCE mapped_vbo;
-      d3d10_sprite_t*          sprite = NULL;
+      void*           mapped_vbo;
+      d3d10_sprite_t* sprite = NULL;
 
-      D3D10MapBuffer(d3d10->sprites.vbo, D3D10_MAP_WRITE_NO_OVERWRITE, 0, (void**)&mapped_vbo);
+      D3D10MapBuffer(d3d10->sprites.vbo, D3D10_MAP_WRITE_NO_OVERWRITE, 0, &mapped_vbo);
 
-      sprite = (d3d10_sprite_t*)mapped_vbo.pData + d3d10->sprites.offset;
+      sprite = (d3d10_sprite_t*)mapped_vbo + d3d10->sprites.offset;
 
       if (vertex_count == 1)
       {
@@ -231,9 +231,9 @@ static void menu_display_d3d10_draw_pipeline(void* data,
    d3d10->ubo_values.time += 0.01f;
 
    {
-      D3D10_MAPPED_SUBRESOURCE mapped_ubo;
+      void* mapped_ubo;
       D3D10MapBuffer(d3d10->ubo, D3D10_MAP_WRITE_DISCARD, 0, (void**)&mapped_ubo);
-      *(d3d10_uniform_t*)mapped_ubo.pData = d3d10->ubo_values;
+      *(d3d10_uniform_t*)mapped_ubo = d3d10->ubo_values;
       D3D10UnmapBuffer(d3d10->ubo);
    }
 }