1 files changed, 7 insertions, 99 deletions

diff --git a/src/video_core/texture_cache/surface_base.h b/src/video_core/texture_cache/surface_base.h
index 70b5258c9..9d19ecd5f 100644
--- a/src/video_core/texture_cache/surface_base.h
+++ b/src/video_core/texture_cache/surface_base.h
@@ -136,83 +136,17 @@ public:
         return params.target == target;
     }
 
+    MatchTopologyResult MatchesTopology(const SurfaceParams& rhs) const;
+
+    MatchStructureResult MatchesStructure(const SurfaceParams& rhs) const;
+
     bool MatchesSubTexture(const SurfaceParams& rhs, const GPUVAddr other_gpu_addr) const {
         return std::tie(gpu_addr, params.target, params.num_levels) ==
                    std::tie(other_gpu_addr, rhs.target, rhs.num_levels) &&
                params.target == SurfaceTarget::Texture2D && params.num_levels == 1;
     }
 
-    MatchTopologyResult MatchesTopology(const SurfaceParams& rhs) const {
-        const u32 src_bpp{params.GetBytesPerPixel()};
-        const u32 dst_bpp{rhs.GetBytesPerPixel()};
-        const bool ib1 = params.IsBuffer();
-        const bool ib2 = rhs.IsBuffer();
-        if (std::tie(src_bpp, params.is_tiled, ib1) == std::tie(dst_bpp, rhs.is_tiled, ib2)) {
-            const bool cb1 = params.IsCompressed();
-            const bool cb2 = rhs.IsCompressed();
-            if (cb1 == cb2) {
-                return MatchTopologyResult::FullMatch;
-            }
-            return MatchTopologyResult::CompressUnmatch;
-        }
-        return MatchTopologyResult::None;
-    }
-
-    MatchStructureResult MatchesStructure(const SurfaceParams& rhs) const {
-        // Buffer surface Check
-        if (params.IsBuffer()) {
-            const std::size_t wd1 = params.width * params.GetBytesPerPixel();
-            const std::size_t wd2 = rhs.width * rhs.GetBytesPerPixel();
-            if (wd1 == wd2) {
-                return MatchStructureResult::FullMatch;
-            }
-            return MatchStructureResult::None;
-        }
-
-        // Linear Surface check
-        if (!params.is_tiled) {
-            if (std::tie(params.width, params.height, params.pitch) ==
-                std::tie(rhs.width, rhs.height, rhs.pitch)) {
-                return MatchStructureResult::FullMatch;
-            }
-            return MatchStructureResult::None;
-        }
-
-        // Tiled Surface check
-        if (std::tie(params.depth, params.block_width, params.block_height, params.block_depth,
-                     params.tile_width_spacing, params.num_levels) ==
-            std::tie(rhs.depth, rhs.block_width, rhs.block_height, rhs.block_depth,
-                     rhs.tile_width_spacing, rhs.num_levels)) {
-            if (std::tie(params.width, params.height) == std::tie(rhs.width, rhs.height)) {
-                return MatchStructureResult::FullMatch;
-            }
-            const u32 ws = SurfaceParams::ConvertWidth(rhs.GetBlockAlignedWidth(),
-                                                       params.pixel_format, rhs.pixel_format);
-            const u32 hs =
-                SurfaceParams::ConvertHeight(rhs.height, params.pixel_format, rhs.pixel_format);
-            const u32 w1 = params.GetBlockAlignedWidth();
-            if (std::tie(w1, params.height) == std::tie(ws, hs)) {
-                return MatchStructureResult::SemiMatch;
-            }
-        }
-        return MatchStructureResult::None;
-    }
-
-    std::optional<std::pair<u32, u32>> GetLayerMipmap(const GPUVAddr candidate_gpu_addr) const {
-        if (candidate_gpu_addr < gpu_addr) {
-            return {};
-        }
-        const auto relative_address{static_cast<GPUVAddr>(candidate_gpu_addr - gpu_addr)};
-        const auto layer{static_cast<u32>(relative_address / layer_size)};
-        const GPUVAddr mipmap_address = relative_address - layer_size * layer;
-        const auto mipmap_it =
-            Common::BinaryFind(mipmap_offsets.begin(), mipmap_offsets.end(), mipmap_address);
-        if (mipmap_it == mipmap_offsets.end()) {
-            return {};
-        }
-        const auto level{static_cast<u32>(std::distance(mipmap_offsets.begin(), mipmap_it))};
-        return std::make_pair(layer, level);
-    }
+    std::optional<std::pair<u32, u32>> GetLayerMipmap(const GPUVAddr candidate_gpu_addr) const;
 
     std::vector<CopyParams> BreakDown(const SurfaceParams& in_params) const {
         return params.is_layered ? BreakDownLayered(in_params) : BreakDownNonLayered(in_params);
@@ -241,35 +175,9 @@ private:
     void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params, u8* buffer,
                      u32 level);
 
-    std::vector<CopyParams> BreakDownLayered(const SurfaceParams& in_params) const {
-        const u32 layers{params.depth};
-        const u32 mipmaps{params.num_levels};
-        std::vector<CopyParams> result;
-        result.reserve(static_cast<std::size_t>(layers) * static_cast<std::size_t>(mipmaps));
-
-        for (u32 layer = 0; layer < layers; layer++) {
-            for (u32 level = 0; level < mipmaps; level++) {
-                const u32 width = SurfaceParams::IntersectWidth(params, in_params, level, level);
-                const u32 height = SurfaceParams::IntersectHeight(params, in_params, level, level);
-                result.emplace_back(width, height, layer, level);
-            }
-        }
-        return result;
-    }
-
-    std::vector<CopyParams> BreakDownNonLayered(const SurfaceParams& in_params) const {
-        const u32 mipmaps{params.num_levels};
-        std::vector<CopyParams> result;
-        result.reserve(mipmaps);
+    std::vector<CopyParams> BreakDownLayered(const SurfaceParams& in_params) const;
 
-        for (u32 level = 0; level < mipmaps; level++) {
-            const u32 width = SurfaceParams::IntersectWidth(params, in_params, level, level);
-            const u32 height = SurfaceParams::IntersectHeight(params, in_params, level, level);
-            const u32 depth{std::min(params.GetMipDepth(level), in_params.GetMipDepth(level))};
-            result.emplace_back(width, height, depth, level);
-        }
-        return result;
-    }
+    std::vector<CopyParams> BreakDownNonLayered(const SurfaceParams& in_params) const;
 };
 
 template <typename TView>