diff --git a/src/d3d8/d3d8_texture.cpp b/src/d3d8/d3d8_texture.cpp
new file mode 100644
index 000000000..35a63facd
--- /dev/null
+++ b/src/d3d8/d3d8_texture.cpp
@@ -0,0 +1,149 @@
+#include "d3d8_texture.h"
+
+#include "d3d8_d3d9_util.h"
+
+namespace dxvk {
+
+  // D3D8Texture2D
+
+  D3D8Texture2D::D3D8Texture2D(
+          D3D8Device*                    pDevice,
+          Com<d3d9::IDirect3DTexture9>&& pTexture)
+    : D3D8Texture2DBase(pDevice, std::move(pTexture), pTexture->GetLevelCount()) {
+  }
+
+  D3DRESOURCETYPE STDMETHODCALLTYPE D3D8Texture2D::GetType() { return D3DRTYPE_TEXTURE; }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture2D::GetLevelDesc(UINT Level, D3DSURFACE_DESC* pDesc) {
+    if (unlikely(pDesc == nullptr))
+      return D3DERR_INVALIDCALL;
+
+    d3d9::D3DSURFACE_DESC surf;
+    HRESULT res = GetD3D9()->GetLevelDesc(Level, &surf);
+
+    if (likely(SUCCEEDED(res)))
+      ConvertSurfaceDesc8(&surf, pDesc);
+
+    return res;
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture2D::GetSurfaceLevel(UINT Level, IDirect3DSurface8** ppSurfaceLevel) {
+    return GetSubresource(Level, ppSurfaceLevel);
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture2D::LockRect(
+      UINT            Level,
+      D3DLOCKED_RECT* pLockedRect,
+      CONST RECT*     pRect,
+      DWORD           Flags) {
+    return GetD3D9()->LockRect(Level, reinterpret_cast<d3d9::D3DLOCKED_RECT*>(pLockedRect), pRect, Flags);
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture2D::UnlockRect(UINT Level) {
+    return GetD3D9()->UnlockRect(Level);
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture2D::AddDirtyRect(CONST RECT* pDirtyRect) {
+    return GetD3D9()->AddDirtyRect(pDirtyRect);
+  }
+
+  // D3D8Texture3D
+
+  D3D8Texture3D::D3D8Texture3D(
+          D3D8Device*                           pDevice,
+          Com<d3d9::IDirect3DVolumeTexture9>&&  pVolumeTexture)
+    : D3D8Texture3DBase(pDevice, std::move(pVolumeTexture), pVolumeTexture->GetLevelCount()) {}
+
+  D3DRESOURCETYPE STDMETHODCALLTYPE D3D8Texture3D::GetType() { return D3DRTYPE_VOLUMETEXTURE; }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture3D::GetLevelDesc(UINT Level, D3DVOLUME_DESC *pDesc) {
+    if (unlikely(pDesc == nullptr))
+      return D3DERR_INVALIDCALL;
+
+    d3d9::D3DVOLUME_DESC vol;
+    HRESULT res = GetD3D9()->GetLevelDesc(Level, &vol);
+
+    if (likely(SUCCEEDED(res)))
+      ConvertVolumeDesc8(&vol, pDesc);
+
+    return res;
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture3D::GetVolumeLevel(UINT Level, IDirect3DVolume8** ppVolumeLevel) {
+    return GetSubresource(Level, ppVolumeLevel);
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture3D::LockBox(
+      UINT           Level,
+      D3DLOCKED_BOX* pLockedBox,
+      CONST D3DBOX*  pBox,
+      DWORD          Flags) {
+    return GetD3D9()->LockBox(
+      Level,
+      reinterpret_cast<d3d9::D3DLOCKED_BOX*>(pLockedBox),
+      reinterpret_cast<const d3d9::D3DBOX*>(pBox),
+      Flags
+    );
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture3D::UnlockBox(UINT Level) {
+    return GetD3D9()->UnlockBox(Level);
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8Texture3D::AddDirtyBox(CONST D3DBOX* pDirtyBox) {
+    return GetD3D9()->AddDirtyBox(reinterpret_cast<const d3d9::D3DBOX*>(pDirtyBox));
+  }
+
+  // D3D8TextureCube
+
+  D3D8TextureCube::D3D8TextureCube(
+          D3D8Device*                         pDevice,
+          Com<d3d9::IDirect3DCubeTexture9>&&  pTexture)
+    : D3D8TextureCubeBase(pDevice, std::move(pTexture), pTexture->GetLevelCount() * CUBE_FACES) {
+  }
+
+  D3DRESOURCETYPE STDMETHODCALLTYPE D3D8TextureCube::GetType() { return D3DRTYPE_CUBETEXTURE; }
+
+  HRESULT STDMETHODCALLTYPE D3D8TextureCube::GetLevelDesc(UINT Level, D3DSURFACE_DESC* pDesc) {
+    if (unlikely(pDesc == nullptr))
+      return D3DERR_INVALIDCALL;
+
+    d3d9::D3DSURFACE_DESC surf;
+    HRESULT res = GetD3D9()->GetLevelDesc(Level, &surf);
+
+    if (likely(SUCCEEDED(res)))
+      ConvertSurfaceDesc8(&surf, pDesc);
+
+    return res;
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8TextureCube::GetCubeMapSurface(
+      D3DCUBEMAP_FACES    Face,
+      UINT                Level,
+      IDirect3DSurface8** ppSurfaceLevel) {
+    return GetSubresource((Level * CUBE_FACES) + Face, ppSurfaceLevel);
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8TextureCube::LockRect(
+          D3DCUBEMAP_FACES Face,
+          UINT Level,
+          D3DLOCKED_RECT* pLockedRect,
+          const RECT* pRect,
+          DWORD Flags) {
+    return GetD3D9()->LockRect(
+      d3d9::D3DCUBEMAP_FACES(Face),
+      Level,
+      reinterpret_cast<d3d9::D3DLOCKED_RECT*>(pLockedRect),
+      pRect,
+      Flags);
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8TextureCube::UnlockRect(D3DCUBEMAP_FACES Face, UINT Level) {
+    return GetD3D9()->UnlockRect(d3d9::D3DCUBEMAP_FACES(Face), Level);
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D8TextureCube::AddDirtyRect(D3DCUBEMAP_FACES Face, const RECT* pDirtyRect) {
+    return GetD3D9()->AddDirtyRect(d3d9::D3DCUBEMAP_FACES(Face), pDirtyRect);
+  }
+
+}
\ No newline at end of file
diff --git a/src/d3d8/d3d8_texture.h b/src/d3d8/d3d8_texture.h
index 75dc21b3a..3aec12b32 100644
--- a/src/d3d8/d3d8_texture.h
+++ b/src/d3d8/d3d8_texture.h
@@ -4,8 +4,6 @@
 #include "d3d8_surface.h"
 #include "d3d8_volume.h"
 
-#include "d3d8_d3d9_util.h"
-
 #include <vector>
 #include <new>
 
@@ -114,40 +112,23 @@ namespace dxvk {
 
     D3D8Texture2D(
             D3D8Device*                    pDevice,
-            Com<d3d9::IDirect3DTexture9>&& pTexture)
-      : D3D8Texture2DBase(pDevice, std::move(pTexture), pTexture->GetLevelCount()) {
-    }
+            Com<d3d9::IDirect3DTexture9>&& pTexture);
 
-    D3DRESOURCETYPE STDMETHODCALLTYPE GetType() final { return D3DRTYPE_TEXTURE; }
+    D3DRESOURCETYPE STDMETHODCALLTYPE GetType() final;
 
-    HRESULT STDMETHODCALLTYPE GetLevelDesc(UINT Level, D3DSURFACE_DESC* pDesc) {
-      if (unlikely(pDesc == nullptr))
-        return D3DERR_INVALIDCALL;
+    HRESULT STDMETHODCALLTYPE GetLevelDesc(UINT Level, D3DSURFACE_DESC* pDesc);
 
-      d3d9::D3DSURFACE_DESC surf;
-      HRESULT res = GetD3D9()->GetLevelDesc(Level, &surf);
+    HRESULT STDMETHODCALLTYPE GetSurfaceLevel(UINT Level, IDirect3DSurface8** ppSurfaceLevel);
 
-      if (likely(SUCCEEDED(res)))
-        ConvertSurfaceDesc8(&surf, pDesc);
+    HRESULT STDMETHODCALLTYPE LockRect(
+        UINT            Level,
+        D3DLOCKED_RECT* pLockedRect,
+        CONST RECT*     pRect,
+        DWORD           Flags);
 
-      return res;
-    }
+    HRESULT STDMETHODCALLTYPE UnlockRect(UINT Level);
 
-    HRESULT STDMETHODCALLTYPE GetSurfaceLevel(UINT Level, IDirect3DSurface8** ppSurfaceLevel) {
-      return GetSubresource(Level, ppSurfaceLevel);
-    }
-
-    HRESULT STDMETHODCALLTYPE LockRect(UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) {
-      return GetD3D9()->LockRect(Level, reinterpret_cast<d3d9::D3DLOCKED_RECT*>(pLockedRect), pRect, Flags);
-    }
-
-    HRESULT STDMETHODCALLTYPE UnlockRect(UINT Level) {
-      return GetD3D9()->UnlockRect(Level);
-    }
-
-    HRESULT STDMETHODCALLTYPE AddDirtyRect(CONST RECT* pDirtyRect) {
-      return GetD3D9()->AddDirtyRect(pDirtyRect);
-    }
+    HRESULT STDMETHODCALLTYPE AddDirtyRect(CONST RECT* pDirtyRect);
 
   };
 
@@ -157,45 +138,24 @@ namespace dxvk {
   public:
 
     D3D8Texture3D(
-          D3D8Device*                           pDevice,
-          Com<d3d9::IDirect3DVolumeTexture9>&&  pVolumeTexture)
-      : D3D8Texture3DBase(pDevice, std::move(pVolumeTexture), pVolumeTexture->GetLevelCount()) {}
+            D3D8Device*                           pDevice,
+            Com<d3d9::IDirect3DVolumeTexture9>&&  pVolumeTexture);
 
-    D3DRESOURCETYPE STDMETHODCALLTYPE GetType() final { return D3DRTYPE_VOLUMETEXTURE; }
+    D3DRESOURCETYPE STDMETHODCALLTYPE GetType() final;
 
-    HRESULT STDMETHODCALLTYPE GetLevelDesc(UINT Level, D3DVOLUME_DESC *pDesc) {
-      if (unlikely(pDesc == nullptr))
-        return D3DERR_INVALIDCALL;
+    HRESULT STDMETHODCALLTYPE GetLevelDesc(UINT Level, D3DVOLUME_DESC *pDesc);
 
-      d3d9::D3DVOLUME_DESC vol;
-      HRESULT res = GetD3D9()->GetLevelDesc(Level, &vol);
+    HRESULT STDMETHODCALLTYPE GetVolumeLevel(UINT Level, IDirect3DVolume8** ppVolumeLevel);
 
-      if (likely(SUCCEEDED(res)))
-        ConvertVolumeDesc8(&vol, pDesc);
+    HRESULT STDMETHODCALLTYPE LockBox(
+        UINT           Level,
+        D3DLOCKED_BOX* pLockedBox,
+        CONST D3DBOX*  pBox,
+        DWORD          Flags);
 
-      return res;
-    }
+    HRESULT STDMETHODCALLTYPE UnlockBox(UINT Level);
 
-    HRESULT STDMETHODCALLTYPE GetVolumeLevel(UINT Level, IDirect3DVolume8** ppVolumeLevel) {
-      return GetSubresource(Level, ppVolumeLevel);
-    }
-
-    HRESULT STDMETHODCALLTYPE LockBox(UINT Level, D3DLOCKED_BOX* pLockedBox, CONST D3DBOX* pBox, DWORD Flags) {
-      return GetD3D9()->LockBox(
-        Level,
-        reinterpret_cast<d3d9::D3DLOCKED_BOX*>(pLockedBox),
-        reinterpret_cast<const d3d9::D3DBOX*>(pBox),
-        Flags
-      );
-    }
-
-    HRESULT STDMETHODCALLTYPE UnlockBox(UINT Level) {
-      return GetD3D9()->UnlockBox(Level);
-    }
-
-    HRESULT STDMETHODCALLTYPE AddDirtyBox(CONST D3DBOX* pDirtyBox) {
-      return GetD3D9()->AddDirtyBox(reinterpret_cast<const d3d9::D3DBOX*>(pDirtyBox));
-    }
+    HRESULT STDMETHODCALLTYPE AddDirtyBox(CONST D3DBOX* pDirtyBox);
 
   };
 
@@ -206,49 +166,28 @@ namespace dxvk {
 
     D3D8TextureCube(
             D3D8Device*                         pDevice,
-            Com<d3d9::IDirect3DCubeTexture9>&&  pTexture)
-      : D3D8TextureCubeBase(pDevice, std::move(pTexture), pTexture->GetLevelCount() * CUBE_FACES) {
-    }
+            Com<d3d9::IDirect3DCubeTexture9>&&  pTexture);
 
-    D3DRESOURCETYPE STDMETHODCALLTYPE GetType() final { return D3DRTYPE_CUBETEXTURE; }
+    D3DRESOURCETYPE STDMETHODCALLTYPE GetType() final;
 
-    HRESULT STDMETHODCALLTYPE GetLevelDesc(UINT Level, D3DSURFACE_DESC* pDesc) {
-      if (unlikely(pDesc == nullptr))
-        return D3DERR_INVALIDCALL;
+    HRESULT STDMETHODCALLTYPE GetLevelDesc(UINT Level, D3DSURFACE_DESC* pDesc);
 
-      d3d9::D3DSURFACE_DESC surf;
-      HRESULT res = GetD3D9()->GetLevelDesc(Level, &surf);
-
-      if (likely(SUCCEEDED(res)))
-        ConvertSurfaceDesc8(&surf, pDesc);
-
-      return res;
-    }
-
-    HRESULT STDMETHODCALLTYPE GetCubeMapSurface(D3DCUBEMAP_FACES Face, UINT Level, IDirect3DSurface8** ppSurfaceLevel) {
-      return GetSubresource((Level * CUBE_FACES) + Face, ppSurfaceLevel);
-    }
+    HRESULT STDMETHODCALLTYPE GetCubeMapSurface(
+        D3DCUBEMAP_FACES    Face,
+        UINT                Level,
+        IDirect3DSurface8** ppSurfaceLevel);
 
     HRESULT STDMETHODCALLTYPE LockRect(
-            D3DCUBEMAP_FACES Face,
-            UINT Level,
-            D3DLOCKED_RECT* pLockedRect,
-            const RECT* pRect,
-            DWORD Flags) {
-      return GetD3D9()->LockRect(
-        d3d9::D3DCUBEMAP_FACES(Face),
-        Level,
-        reinterpret_cast<d3d9::D3DLOCKED_RECT*>(pLockedRect),
-        pRect,
-        Flags);
-    }
+        D3DCUBEMAP_FACES Face,
+        UINT Level,
+        D3DLOCKED_RECT* pLockedRect,
+        const RECT* pRect,
+        DWORD Flags);
 
-    HRESULT STDMETHODCALLTYPE UnlockRect(D3DCUBEMAP_FACES Face, UINT Level) {
-      return GetD3D9()->UnlockRect(d3d9::D3DCUBEMAP_FACES(Face), Level);
-    }
+    HRESULT STDMETHODCALLTYPE UnlockRect(D3DCUBEMAP_FACES Face, UINT Level);
+
+    HRESULT STDMETHODCALLTYPE AddDirtyRect(D3DCUBEMAP_FACES Face, const RECT* pDirtyRect);
 
-    HRESULT STDMETHODCALLTYPE AddDirtyRect(D3DCUBEMAP_FACES Face, const RECT* pDirtyRect) {
-      return GetD3D9()->AddDirtyRect(d3d9::D3DCUBEMAP_FACES(Face), pDirtyRect);
-    }
   };
+
 }
\ No newline at end of file
diff --git a/src/d3d8/meson.build b/src/d3d8/meson.build
index c638c2ede..e5305d301 100644
--- a/src/d3d8/meson.build
+++ b/src/d3d8/meson.build
@@ -9,7 +9,8 @@ d3d8_src = [
   'd3d8_shader.cpp',
   'd3d8_state_block.cpp',
   'd3d8_surface.cpp',
-  'd3d8_swapchain.cpp'
+  'd3d8_swapchain.cpp',
+  'd3d8_texture.cpp'
 ]
 
 d3d8_ld_args      = []