diff --git a/src/d3d11/d3d11_context.h b/src/d3d11/d3d11_context.h
index 47efa7a3..615e47d2 100644
--- a/src/d3d11/d3d11_context.h
+++ b/src/d3d11/d3d11_context.h
@@ -24,36 +24,36 @@ namespace dxvk {
     
     HRESULT STDMETHODCALLTYPE QueryInterface(
             REFIID  riid,
-            void**  ppvObject) final;
+            void**  ppvObject);
     
-    void STDMETHODCALLTYPE DiscardResource(ID3D11Resource *pResource) final;
+    void STDMETHODCALLTYPE DiscardResource(ID3D11Resource *pResource);
 
-    void STDMETHODCALLTYPE DiscardView(ID3D11View* pResourceView) final;
+    void STDMETHODCALLTYPE DiscardView(ID3D11View* pResourceView);
 
     void STDMETHODCALLTYPE DiscardView1(
             ID3D11View*                      pResourceView,
       const D3D11_RECT*                      pRects,
-            UINT                             NumRects) final;
+            UINT                             NumRects);
 
     void STDMETHODCALLTYPE SwapDeviceContextState(
            ID3DDeviceContextState*           pState,
-           ID3DDeviceContextState**          ppPreviousState) final;
+           ID3DDeviceContextState**          ppPreviousState);
 
-    void STDMETHODCALLTYPE GetDevice(ID3D11Device **ppDevice) final;
+    void STDMETHODCALLTYPE GetDevice(ID3D11Device **ppDevice);
     
-    void STDMETHODCALLTYPE ClearState() final;
+    void STDMETHODCALLTYPE ClearState();
     
-    void STDMETHODCALLTYPE Begin(ID3D11Asynchronous *pAsync) final;
+    void STDMETHODCALLTYPE Begin(ID3D11Asynchronous *pAsync);
     
-    void STDMETHODCALLTYPE End(ID3D11Asynchronous *pAsync) final;
+    void STDMETHODCALLTYPE End(ID3D11Asynchronous *pAsync);
     
     void STDMETHODCALLTYPE SetPredication(
             ID3D11Predicate*                  pPredicate,
-            BOOL                              PredicateValue) final;
+            BOOL                              PredicateValue);
     
     void STDMETHODCALLTYPE GetPredication(
             ID3D11Predicate**                 ppPredicate,
-            BOOL*                             pPredicateValue) final;
+            BOOL*                             pPredicateValue);
     
     void STDMETHODCALLTYPE CopySubresourceRegion(
             ID3D11Resource*                   pDstResource,
@@ -83,31 +83,31 @@ namespace dxvk {
     void STDMETHODCALLTYPE CopyStructureCount(
             ID3D11Buffer*                     pDstBuffer,
             UINT                              DstAlignedByteOffset,
-            ID3D11UnorderedAccessView*        pSrcView) final;
+            ID3D11UnorderedAccessView*        pSrcView);
     
     void STDMETHODCALLTYPE ClearRenderTargetView(
             ID3D11RenderTargetView*           pRenderTargetView,
-      const FLOAT                             ColorRGBA[4]) final;
+      const FLOAT                             ColorRGBA[4]);
     
     void STDMETHODCALLTYPE ClearUnorderedAccessViewUint(
             ID3D11UnorderedAccessView*        pUnorderedAccessView,
-      const UINT                              Values[4]) final;
+      const UINT                              Values[4]);
     
     void STDMETHODCALLTYPE ClearUnorderedAccessViewFloat(
             ID3D11UnorderedAccessView*        pUnorderedAccessView,
-      const FLOAT                             Values[4]) final;
+      const FLOAT                             Values[4]);
     
     void STDMETHODCALLTYPE ClearDepthStencilView(
             ID3D11DepthStencilView*           pDepthStencilView,
             UINT                              ClearFlags,
             FLOAT                             Depth,
-            UINT8                             Stencil) final;
+            UINT8                             Stencil);
     
     void STDMETHODCALLTYPE ClearView(
             ID3D11View                        *pView,
       const FLOAT                             Color[4],
       const D3D11_RECT                        *pRect,
-            UINT                              NumRects) final;
+            UINT                              NumRects);
 
     void STDMETHODCALLTYPE GenerateMips(
             ID3D11ShaderResourceView*         pShaderResourceView);
@@ -131,10 +131,10 @@ namespace dxvk {
     
     void STDMETHODCALLTYPE SetResourceMinLOD(
             ID3D11Resource*                   pResource,
-            FLOAT                             MinLOD) final;
+            FLOAT                             MinLOD);
     
     FLOAT STDMETHODCALLTYPE GetResourceMinLOD(
-            ID3D11Resource*                   pResource) final;
+            ID3D11Resource*                   pResource);
     
     void STDMETHODCALLTYPE ResolveSubresource(
             ID3D11Resource*                   pDstResource,
@@ -143,417 +143,417 @@ namespace dxvk {
             UINT                              SrcSubresource,
             DXGI_FORMAT                       Format);
     
-    void STDMETHODCALLTYPE DrawAuto() final;
+    void STDMETHODCALLTYPE DrawAuto();
     
     void STDMETHODCALLTYPE Draw(
             UINT            VertexCount,
-            UINT            StartVertexLocation) final;
+            UINT            StartVertexLocation);
     
     void STDMETHODCALLTYPE DrawIndexed(
             UINT            IndexCount,
             UINT            StartIndexLocation,
-            INT             BaseVertexLocation) final;
+            INT             BaseVertexLocation);
     
     void STDMETHODCALLTYPE DrawInstanced(
             UINT            VertexCountPerInstance,
             UINT            InstanceCount,
             UINT            StartVertexLocation,
-            UINT            StartInstanceLocation) final;
+            UINT            StartInstanceLocation);
     
     void STDMETHODCALLTYPE DrawIndexedInstanced(
             UINT            IndexCountPerInstance,
             UINT            InstanceCount,
             UINT            StartIndexLocation,
             INT             BaseVertexLocation,
-            UINT            StartInstanceLocation) final;
+            UINT            StartInstanceLocation);
     
     void STDMETHODCALLTYPE DrawIndexedInstancedIndirect(
             ID3D11Buffer*   pBufferForArgs,
-            UINT            AlignedByteOffsetForArgs) final;
+            UINT            AlignedByteOffsetForArgs);
     
     void STDMETHODCALLTYPE DrawInstancedIndirect(
             ID3D11Buffer*   pBufferForArgs,
-            UINT            AlignedByteOffsetForArgs) final;
+            UINT            AlignedByteOffsetForArgs);
     
     void STDMETHODCALLTYPE Dispatch(
             UINT            ThreadGroupCountX,
             UINT            ThreadGroupCountY,
-            UINT            ThreadGroupCountZ) final;
+            UINT            ThreadGroupCountZ);
     
     void STDMETHODCALLTYPE DispatchIndirect(
             ID3D11Buffer*   pBufferForArgs,
-            UINT            AlignedByteOffsetForArgs) final;
+            UINT            AlignedByteOffsetForArgs);
     
     void STDMETHODCALLTYPE IASetInputLayout(
-            ID3D11InputLayout*                pInputLayout) final;
+            ID3D11InputLayout*                pInputLayout);
     
     void STDMETHODCALLTYPE IASetPrimitiveTopology(
-            D3D11_PRIMITIVE_TOPOLOGY          Topology) final;
+            D3D11_PRIMITIVE_TOPOLOGY          Topology);
     
     void STDMETHODCALLTYPE IASetVertexBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer* const*              ppVertexBuffers,
       const UINT*                             pStrides,
-      const UINT*                             pOffsets) final;
+      const UINT*                             pOffsets);
     
     void STDMETHODCALLTYPE IASetIndexBuffer(
             ID3D11Buffer*                     pIndexBuffer,
             DXGI_FORMAT                       Format,
-            UINT                              Offset) final;
+            UINT                              Offset);
     
     void STDMETHODCALLTYPE IAGetInputLayout(
-            ID3D11InputLayout**               ppInputLayout) final;
+            ID3D11InputLayout**               ppInputLayout);
     
     void STDMETHODCALLTYPE IAGetPrimitiveTopology(
-            D3D11_PRIMITIVE_TOPOLOGY*         pTopology) final;
+            D3D11_PRIMITIVE_TOPOLOGY*         pTopology);
     
     void STDMETHODCALLTYPE IAGetVertexBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer**                    ppVertexBuffers,
             UINT*                             pStrides,
-            UINT*                             pOffsets) final;
+            UINT*                             pOffsets);
     
     void STDMETHODCALLTYPE IAGetIndexBuffer(
             ID3D11Buffer**                    ppIndexBuffer,
             DXGI_FORMAT*                      pFormat,
-            UINT*                             pOffset) final;
+            UINT*                             pOffset);
     
     void STDMETHODCALLTYPE VSSetShader(
             ID3D11VertexShader*               pVertexShader,
             ID3D11ClassInstance* const*       ppClassInstances,
-            UINT                              NumClassInstances) final;
+            UINT                              NumClassInstances);
     
     void STDMETHODCALLTYPE VSSetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer* const*              ppConstantBuffers) final;
+            ID3D11Buffer* const*              ppConstantBuffers);
 
      void STDMETHODCALLTYPE VSSetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer* const*              ppConstantBuffers,
       const UINT*                             pFirstConstant,
-      const UINT*                             pNumConstants) final;
+      const UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE VSSetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView* const*  ppShaderResourceViews) final;
+            ID3D11ShaderResourceView* const*  ppShaderResourceViews);
     
     void STDMETHODCALLTYPE VSSetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState* const*        ppSamplers) final;
+            ID3D11SamplerState* const*        ppSamplers);
     
     void STDMETHODCALLTYPE VSGetShader(
             ID3D11VertexShader**              ppVertexShader,
             ID3D11ClassInstance**             ppClassInstances,
-            UINT*                             pNumClassInstances) final;
+            UINT*                             pNumClassInstances);
     
     void STDMETHODCALLTYPE VSGetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer**                    ppConstantBuffers) final;
+            ID3D11Buffer**                    ppConstantBuffers);
 
     void STDMETHODCALLTYPE VSGetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer**                    ppConstantBuffers,
             UINT*                             pFirstConstant,
-            UINT*                             pNumConstants) final;
+            UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE VSGetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView**        ppShaderResourceViews) final;
+            ID3D11ShaderResourceView**        ppShaderResourceViews);
     
     void STDMETHODCALLTYPE VSGetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState**              ppSamplers) final;
+            ID3D11SamplerState**              ppSamplers);
     
     void STDMETHODCALLTYPE HSSetShader(
             ID3D11HullShader*                 pHullShader,
             ID3D11ClassInstance* const*       ppClassInstances,
-            UINT                              NumClassInstances) final;
+            UINT                              NumClassInstances);
     
     void STDMETHODCALLTYPE HSSetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView* const*  ppShaderResourceViews) final;
+            ID3D11ShaderResourceView* const*  ppShaderResourceViews);
     
     void STDMETHODCALLTYPE HSSetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer* const*              ppConstantBuffers) final;
+            ID3D11Buffer* const*              ppConstantBuffers);
     
     void STDMETHODCALLTYPE HSSetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer* const*              ppConstantBuffers,
       const UINT*                             pFirstConstant,
-      const UINT*                             pNumConstants) final;
+      const UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE HSSetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState* const*        ppSamplers) final;
+            ID3D11SamplerState* const*        ppSamplers);
     
     void STDMETHODCALLTYPE HSGetShader(
             ID3D11HullShader**                ppHullShader,
             ID3D11ClassInstance**             ppClassInstances,
-            UINT*                             pNumClassInstances) final;
+            UINT*                             pNumClassInstances);
     
     void STDMETHODCALLTYPE HSGetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer**                    ppConstantBuffers) final;
+            ID3D11Buffer**                    ppConstantBuffers);
 
      void STDMETHODCALLTYPE HSGetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer**                    ppConstantBuffers,
             UINT*                             pFirstConstant,
-            UINT*                             pNumConstants) final;
+            UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE HSGetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView**        ppShaderResourceViews) final;
+            ID3D11ShaderResourceView**        ppShaderResourceViews);
     
     void STDMETHODCALLTYPE HSGetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState**              ppSamplers) final;
+            ID3D11SamplerState**              ppSamplers);
     
     void STDMETHODCALLTYPE DSSetShader(
             ID3D11DomainShader*               pDomainShader,
             ID3D11ClassInstance* const*       ppClassInstances,
-            UINT                              NumClassInstances) final;
+            UINT                              NumClassInstances);
     
     void STDMETHODCALLTYPE DSSetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView* const*  ppShaderResourceViews) final;
+            ID3D11ShaderResourceView* const*  ppShaderResourceViews);
     
     void STDMETHODCALLTYPE DSSetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer* const*              ppConstantBuffers) final;
+            ID3D11Buffer* const*              ppConstantBuffers);
 
     void STDMETHODCALLTYPE DSSetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer* const*              ppConstantBuffers,
       const UINT*                             pFirstConstant,
-      const UINT*                             pNumConstants) final;
+      const UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE DSSetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState* const*        ppSamplers) final;
+            ID3D11SamplerState* const*        ppSamplers);
     
     void STDMETHODCALLTYPE DSGetShader(
             ID3D11DomainShader**              ppDomainShader,
             ID3D11ClassInstance**             ppClassInstances,
-            UINT*                             pNumClassInstances) final;
+            UINT*                             pNumClassInstances);
     
     void STDMETHODCALLTYPE DSGetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer**                    ppConstantBuffers) final;
+            ID3D11Buffer**                    ppConstantBuffers);
     
      void STDMETHODCALLTYPE DSGetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer**                    ppConstantBuffers,
             UINT*                             pFirstConstant,
-            UINT*                             pNumConstants) final;
+            UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE DSGetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView**        ppShaderResourceViews) final;
+            ID3D11ShaderResourceView**        ppShaderResourceViews);
     
     void STDMETHODCALLTYPE DSGetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState**              ppSamplers) final;
+            ID3D11SamplerState**              ppSamplers);
     
     void STDMETHODCALLTYPE GSSetShader(
             ID3D11GeometryShader*             pShader,
             ID3D11ClassInstance* const*       ppClassInstances,
-            UINT                              NumClassInstances) final;
+            UINT                              NumClassInstances);
     
     void STDMETHODCALLTYPE GSSetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer* const*              ppConstantBuffers) final;
+            ID3D11Buffer* const*              ppConstantBuffers);
     
     virtual void STDMETHODCALLTYPE GSSetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer* const*              ppConstantBuffers,
       const UINT*                             pFirstConstant,
-      const UINT*                             pNumConstants) final;
+      const UINT*                             pNumConstants);
 
     void STDMETHODCALLTYPE GSSetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView* const*  ppShaderResourceViews) final;
+            ID3D11ShaderResourceView* const*  ppShaderResourceViews);
     
     void STDMETHODCALLTYPE GSSetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState* const*        ppSamplers) final;
+            ID3D11SamplerState* const*        ppSamplers);
     
     void STDMETHODCALLTYPE GSGetShader(
             ID3D11GeometryShader**            ppGeometryShader,
             ID3D11ClassInstance**             ppClassInstances,
-            UINT*                             pNumClassInstances) final;
+            UINT*                             pNumClassInstances);
     
     void STDMETHODCALLTYPE GSGetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer**                    ppConstantBuffers) final;
+            ID3D11Buffer**                    ppConstantBuffers);
     
      void STDMETHODCALLTYPE GSGetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer**                    ppConstantBuffers,
             UINT*                             pFirstConstant,
-            UINT*                             pNumConstants) final;
+            UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE GSGetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView**        ppShaderResourceViews) final;
+            ID3D11ShaderResourceView**        ppShaderResourceViews);
     
     void STDMETHODCALLTYPE GSGetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState**              ppSamplers) final;
+            ID3D11SamplerState**              ppSamplers);
     
     void STDMETHODCALLTYPE PSSetShader(
             ID3D11PixelShader*                pPixelShader,
             ID3D11ClassInstance* const*       ppClassInstances,
-            UINT                              NumClassInstances) final;
+            UINT                              NumClassInstances);
     
     void STDMETHODCALLTYPE PSSetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer* const*              ppConstantBuffers) final;
+            ID3D11Buffer* const*              ppConstantBuffers);
 
     void STDMETHODCALLTYPE PSSetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer* const*              ppConstantBuffers,
       const UINT*                             pFirstConstant,
-      const UINT*                             pNumConstants) final;
+      const UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE PSSetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView* const*  ppShaderResourceViews) final;
+            ID3D11ShaderResourceView* const*  ppShaderResourceViews);
     
     void STDMETHODCALLTYPE PSSetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState* const*        ppSamplers) final;
+            ID3D11SamplerState* const*        ppSamplers);
     
     void STDMETHODCALLTYPE PSGetShader(
             ID3D11PixelShader**               ppPixelShader,
             ID3D11ClassInstance**             ppClassInstances,
-            UINT*                             pNumClassInstances) final;
+            UINT*                             pNumClassInstances);
     
     void STDMETHODCALLTYPE PSGetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer**                    ppConstantBuffers) final;
+            ID3D11Buffer**                    ppConstantBuffers);
     
     void STDMETHODCALLTYPE PSGetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer**                    ppConstantBuffers,
             UINT*                             pFirstConstant,
-            UINT*                             pNumConstants) final;
+            UINT*                             pNumConstants);
 
     void STDMETHODCALLTYPE PSGetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView**        ppShaderResourceViews) final;
+            ID3D11ShaderResourceView**        ppShaderResourceViews);
     
     void STDMETHODCALLTYPE PSGetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState**              ppSamplers) final;
+            ID3D11SamplerState**              ppSamplers);
     
     void STDMETHODCALLTYPE CSSetShader(
             ID3D11ComputeShader*              pComputeShader,
             ID3D11ClassInstance* const*       ppClassInstances,
-            UINT                              NumClassInstances) final;
+            UINT                              NumClassInstances);
     
     void STDMETHODCALLTYPE CSSetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer* const*              ppConstantBuffers) final;
+            ID3D11Buffer* const*              ppConstantBuffers);
     
     void STDMETHODCALLTYPE CSSetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer* const*              ppConstantBuffers,
       const UINT*                             pFirstConstant,
-      const UINT*                             pNumConstants) final;
+      const UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE CSSetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView* const*  ppShaderResourceViews) final;
+            ID3D11ShaderResourceView* const*  ppShaderResourceViews);
     
     void STDMETHODCALLTYPE CSSetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState* const*        ppSamplers) final;
+            ID3D11SamplerState* const*        ppSamplers);
     
     void STDMETHODCALLTYPE CSSetUnorderedAccessViews(
             UINT                              StartSlot,
             UINT                              NumUAVs,
             ID3D11UnorderedAccessView* const* ppUnorderedAccessViews,
-      const UINT*                             pUAVInitialCounts) final;
+      const UINT*                             pUAVInitialCounts);
     
     void STDMETHODCALLTYPE CSGetShader(
             ID3D11ComputeShader**             ppComputeShader,
             ID3D11ClassInstance**             ppClassInstances,
-            UINT*                             pNumClassInstances) final;
+            UINT*                             pNumClassInstances);
     
     void STDMETHODCALLTYPE CSGetConstantBuffers(
             UINT                              StartSlot,
             UINT                              NumBuffers,
-            ID3D11Buffer**                    ppConstantBuffers) final;
+            ID3D11Buffer**                    ppConstantBuffers);
     
     void STDMETHODCALLTYPE CSGetConstantBuffers1(
             UINT                              StartSlot,
             UINT                              NumBuffers,
             ID3D11Buffer**                    ppConstantBuffers,
             UINT*                             pFirstConstant,
-            UINT*                             pNumConstants) final;
+            UINT*                             pNumConstants);
     
     void STDMETHODCALLTYPE CSGetShaderResources(
             UINT                              StartSlot,
             UINT                              NumViews,
-            ID3D11ShaderResourceView**        ppShaderResourceViews) final;
+            ID3D11ShaderResourceView**        ppShaderResourceViews);
     
     void STDMETHODCALLTYPE CSGetSamplers(
             UINT                              StartSlot,
             UINT                              NumSamplers,
-            ID3D11SamplerState**              ppSamplers) final;
+            ID3D11SamplerState**              ppSamplers);
     
     void STDMETHODCALLTYPE CSGetUnorderedAccessViews(
             UINT                              StartSlot,
             UINT                              NumUAVs,
-            ID3D11UnorderedAccessView**       ppUnorderedAccessViews) final;
+            ID3D11UnorderedAccessView**       ppUnorderedAccessViews);
     
     void STDMETHODCALLTYPE OMSetRenderTargets(
             UINT                              NumViews,
@@ -572,16 +572,16 @@ namespace dxvk {
     void STDMETHODCALLTYPE OMSetBlendState(
             ID3D11BlendState*                 pBlendState,
       const FLOAT                             BlendFactor[4],
-            UINT                              SampleMask) final;
+            UINT                              SampleMask);
     
     void STDMETHODCALLTYPE OMSetDepthStencilState(
             ID3D11DepthStencilState*          pDepthStencilState,
-            UINT                              StencilRef) final;
+            UINT                              StencilRef);
     
     void STDMETHODCALLTYPE OMGetRenderTargets(
             UINT                              NumViews,
             ID3D11RenderTargetView**          ppRenderTargetViews,
-            ID3D11DepthStencilView**          ppDepthStencilView) final;
+            ID3D11DepthStencilView**          ppDepthStencilView);
     
     void STDMETHODCALLTYPE OMGetRenderTargetsAndUnorderedAccessViews(
             UINT                              NumRTVs,
@@ -589,47 +589,47 @@ namespace dxvk {
             ID3D11DepthStencilView**          ppDepthStencilView,
             UINT                              UAVStartSlot,
             UINT                              NumUAVs,
-            ID3D11UnorderedAccessView**       ppUnorderedAccessViews) final;
+            ID3D11UnorderedAccessView**       ppUnorderedAccessViews);
     
     void STDMETHODCALLTYPE OMGetBlendState(
             ID3D11BlendState**                ppBlendState,
             FLOAT                             BlendFactor[4],
-            UINT*                             pSampleMask) final;
+            UINT*                             pSampleMask);
     
     void STDMETHODCALLTYPE OMGetDepthStencilState(
             ID3D11DepthStencilState**         ppDepthStencilState,
-            UINT*                             pStencilRef) final;
+            UINT*                             pStencilRef);
     
     void STDMETHODCALLTYPE RSSetState(
-            ID3D11RasterizerState*            pRasterizerState) final;
+            ID3D11RasterizerState*            pRasterizerState);
     
     void STDMETHODCALLTYPE RSSetViewports(
             UINT                              NumViewports,
-      const D3D11_VIEWPORT*                   pViewports) final;
+      const D3D11_VIEWPORT*                   pViewports);
     
     void STDMETHODCALLTYPE RSSetScissorRects(
             UINT                              NumRects,
-      const D3D11_RECT*                       pRects) final;
+      const D3D11_RECT*                       pRects);
     
     void STDMETHODCALLTYPE RSGetState(
-            ID3D11RasterizerState**           ppRasterizerState) final;
+            ID3D11RasterizerState**           ppRasterizerState);
     
     void STDMETHODCALLTYPE RSGetViewports(
             UINT*                             pNumViewports,
-            D3D11_VIEWPORT*                   pViewports) final;
+            D3D11_VIEWPORT*                   pViewports);
     
     void STDMETHODCALLTYPE RSGetScissorRects(
             UINT*                             pNumRects,
-            D3D11_RECT*                       pRects) final;
+            D3D11_RECT*                       pRects);
     
     void STDMETHODCALLTYPE SOSetTargets(
             UINT                              NumBuffers,
             ID3D11Buffer* const*              ppSOTargets,
-      const UINT*                             pOffsets) final;
+      const UINT*                             pOffsets);
     
     void STDMETHODCALLTYPE SOGetTargets(
             UINT                              NumBuffers,
-            ID3D11Buffer**                    ppSOTargets) final;
+            ID3D11Buffer**                    ppSOTargets);
     
     void STDMETHODCALLTYPE SOGetTargetsWithOffsets(
             UINT                              NumBuffers,
diff --git a/src/d3d11/d3d11_context_def.h b/src/d3d11/d3d11_context_def.h
index 911a37b5..3dfc8002 100644
--- a/src/d3d11/d3d11_context_def.h
+++ b/src/d3d11/d3d11_context_def.h
@@ -30,36 +30,36 @@ namespace dxvk {
       const Rc<DxvkDevice>& Device,
             UINT            ContextFlags);
     
-    D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType() final;
+    D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType();
     
-    UINT STDMETHODCALLTYPE GetContextFlags() final;
+    UINT STDMETHODCALLTYPE GetContextFlags();
     
     HRESULT STDMETHODCALLTYPE GetData(
             ID3D11Asynchronous*               pAsync,
             void*                             pData,
             UINT                              DataSize,
-            UINT                              GetDataFlags) final;
+            UINT                              GetDataFlags);
     
-    void STDMETHODCALLTYPE Flush() final;
+    void STDMETHODCALLTYPE Flush();
     
     void STDMETHODCALLTYPE ExecuteCommandList(
             ID3D11CommandList*  pCommandList,
-            BOOL                RestoreContextState) final;
+            BOOL                RestoreContextState);
     
     HRESULT STDMETHODCALLTYPE FinishCommandList(
             BOOL                RestoreDeferredContextState,
-            ID3D11CommandList   **ppCommandList) final;
+            ID3D11CommandList   **ppCommandList);
     
     HRESULT STDMETHODCALLTYPE Map(
             ID3D11Resource*             pResource,
             UINT                        Subresource,
             D3D11_MAP                   MapType,
             UINT                        MapFlags,
-            D3D11_MAPPED_SUBRESOURCE*   pMappedResource) final;
+            D3D11_MAPPED_SUBRESOURCE*   pMappedResource);
     
     void STDMETHODCALLTYPE Unmap(
             ID3D11Resource*             pResource,
-            UINT                        Subresource) final;
+            UINT                        Subresource);
     
   private:
     
@@ -97,7 +97,7 @@ namespace dxvk {
     
     Com<D3D11CommandList> CreateCommandList();
     
-    void EmitCsChunk(DxvkCsChunkRef&& chunk) final;
+    void EmitCsChunk(DxvkCsChunkRef&& chunk);
     
     auto FindMapEntry(ID3D11Resource* pResource, UINT Subresource) {
       return std::find_if(m_mappedResources.rbegin(), m_mappedResources.rend(),
diff --git a/src/d3d11/d3d11_context_imm.h b/src/d3d11/d3d11_context_imm.h
index 4e8e5a17..35598554 100644
--- a/src/d3d11/d3d11_context_imm.h
+++ b/src/d3d11/d3d11_context_imm.h
@@ -17,40 +17,40 @@ namespace dxvk {
       const Rc<DxvkDevice>& Device);
     ~D3D11ImmediateContext();
     
-    ULONG STDMETHODCALLTYPE AddRef() final;
+    ULONG STDMETHODCALLTYPE AddRef();
     
-    ULONG STDMETHODCALLTYPE Release() final;
+    ULONG STDMETHODCALLTYPE Release();
     
-    D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType() final;
+    D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType();
     
-    UINT STDMETHODCALLTYPE GetContextFlags() final;
+    UINT STDMETHODCALLTYPE GetContextFlags();
     
     HRESULT STDMETHODCALLTYPE GetData(
             ID3D11Asynchronous*               pAsync,
             void*                             pData,
             UINT                              DataSize,
-            UINT                              GetDataFlags) final;
+            UINT                              GetDataFlags);
     
-    void STDMETHODCALLTYPE Flush() final;
+    void STDMETHODCALLTYPE Flush();
     
     void STDMETHODCALLTYPE ExecuteCommandList(
             ID3D11CommandList*  pCommandList,
-            BOOL                RestoreContextState) final;
+            BOOL                RestoreContextState);
     
     HRESULT STDMETHODCALLTYPE FinishCommandList(
             BOOL                RestoreDeferredContextState,
-            ID3D11CommandList   **ppCommandList) final;
+            ID3D11CommandList   **ppCommandList);
     
     HRESULT STDMETHODCALLTYPE Map(
             ID3D11Resource*             pResource,
             UINT                        Subresource,
             D3D11_MAP                   MapType,
             UINT                        MapFlags,
-            D3D11_MAPPED_SUBRESOURCE*   pMappedResource) final;
+            D3D11_MAPPED_SUBRESOURCE*   pMappedResource);
     
     void STDMETHODCALLTYPE Unmap(
             ID3D11Resource*             pResource,
-            UINT                        Subresource) final;
+            UINT                        Subresource);
     
     void STDMETHODCALLTYPE CopySubresourceRegion(
             ID3D11Resource*                   pDstResource,
@@ -60,7 +60,7 @@ namespace dxvk {
             UINT                              DstZ,
             ID3D11Resource*                   pSrcResource,
             UINT                              SrcSubresource,
-      const D3D11_BOX*                        pSrcBox) final;
+      const D3D11_BOX*                        pSrcBox);
     
     void STDMETHODCALLTYPE CopySubresourceRegion1(
             ID3D11Resource*                   pDstResource,
@@ -71,14 +71,14 @@ namespace dxvk {
             ID3D11Resource*                   pSrcResource,
             UINT                              SrcSubresource,
       const D3D11_BOX*                        pSrcBox,
-            UINT                              CopyFlags) final;
+            UINT                              CopyFlags);
     
     void STDMETHODCALLTYPE CopyResource(
             ID3D11Resource*                   pDstResource,
-            ID3D11Resource*                   pSrcResource) final;
+            ID3D11Resource*                   pSrcResource);
     
     void STDMETHODCALLTYPE GenerateMips(
-            ID3D11ShaderResourceView*         pShaderResourceView) final;
+            ID3D11ShaderResourceView*         pShaderResourceView);
     
     void STDMETHODCALLTYPE UpdateSubresource(
             ID3D11Resource*                   pDstResource,
@@ -86,7 +86,7 @@ namespace dxvk {
       const D3D11_BOX*                        pDstBox,
       const void*                             pSrcData,
             UINT                              SrcRowPitch,
-            UINT                              SrcDepthPitch) final;
+            UINT                              SrcDepthPitch);
     
     void STDMETHODCALLTYPE UpdateSubresource1(
             ID3D11Resource*                   pDstResource,
@@ -95,19 +95,19 @@ namespace dxvk {
       const void*                             pSrcData,
             UINT                              SrcRowPitch,
             UINT                              SrcDepthPitch,
-            UINT                              CopyFlags) final;
+            UINT                              CopyFlags);
     
     void STDMETHODCALLTYPE ResolveSubresource(
             ID3D11Resource*                   pDstResource,
             UINT                              DstSubresource,
             ID3D11Resource*                   pSrcResource,
             UINT                              SrcSubresource,
-            DXGI_FORMAT                       Format) final;
+            DXGI_FORMAT                       Format);
             
     void STDMETHODCALLTYPE OMSetRenderTargets(
             UINT                              NumViews,
             ID3D11RenderTargetView* const*    ppRenderTargetViews,
-            ID3D11DepthStencilView*           pDepthStencilView) final;
+            ID3D11DepthStencilView*           pDepthStencilView);
     
     void STDMETHODCALLTYPE OMSetRenderTargetsAndUnorderedAccessViews(
             UINT                              NumRTVs,
@@ -116,7 +116,7 @@ namespace dxvk {
             UINT                              UAVStartSlot,
             UINT                              NumUAVs,
             ID3D11UnorderedAccessView* const* ppUnorderedAccessViews,
-      const UINT*                             pUAVInitialCounts) final;
+      const UINT*                             pUAVInitialCounts);
     
     void SynchronizeCsThread();
     
@@ -151,7 +151,7 @@ namespace dxvk {
       const Rc<DxvkResource>&                 Resource,
             UINT                              MapFlags);
     
-    void EmitCsChunk(DxvkCsChunkRef&& chunk) final;
+    void EmitCsChunk(DxvkCsChunkRef&& chunk);
 
     void FlushImplicit();