From 1b4503c571d3b961efe74fa7e35d5fa14941ec09 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Wed, 24 Apr 2019 16:35:54 -0300
Subject: texture_cache: Split texture cache into different files

---
 src/video_core/texture_cache/surface_params.h | 229 ++++++++++++++++++++++++++
 1 file changed, 229 insertions(+)
 create mode 100644 src/video_core/texture_cache/surface_params.h

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
new file mode 100644
index 000000000..77dc0ba66
--- /dev/null
+++ b/src/video_core/texture_cache/surface_params.h
@@ -0,0 +1,229 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <map>
+
+#include "common/common_types.h"
+#include "video_core/engines/fermi_2d.h"
+#include "video_core/engines/maxwell_3d.h"
+#include "video_core/surface.h"
+
+namespace VideoCommon {
+
+class HasheableSurfaceParams {
+public:
+    std::size_t Hash() const;
+
+    bool operator==(const HasheableSurfaceParams& rhs) const;
+
+    bool operator!=(const HasheableSurfaceParams& rhs) const {
+        return !operator==(rhs);
+    }
+
+protected:
+    // Avoid creation outside of a managed environment.
+    HasheableSurfaceParams() = default;
+
+    bool is_tiled;
+    bool srgb_conversion;
+    u32 block_width;
+    u32 block_height;
+    u32 block_depth;
+    u32 tile_width_spacing;
+    u32 width;
+    u32 height;
+    u32 depth;
+    u32 pitch;
+    u32 unaligned_height;
+    u32 num_levels;
+    VideoCore::Surface::PixelFormat pixel_format;
+    VideoCore::Surface::ComponentType component_type;
+    VideoCore::Surface::SurfaceType type;
+    VideoCore::Surface::SurfaceTarget target;
+};
+
+class SurfaceParams final : public HasheableSurfaceParams {
+public:
+    /// Creates SurfaceCachedParams from a texture configuration.
+    static SurfaceParams CreateForTexture(Core::System& system,
+                                          const Tegra::Texture::FullTextureInfo& config);
+
+    /// Creates SurfaceCachedParams for a depth buffer configuration.
+    static SurfaceParams CreateForDepthBuffer(
+        Core::System& system, u32 zeta_width, u32 zeta_height, Tegra::DepthFormat format,
+        u32 block_width, u32 block_height, u32 block_depth,
+        Tegra::Engines::Maxwell3D::Regs::InvMemoryLayout type);
+
+    /// Creates SurfaceCachedParams from a framebuffer configuration.
+    static SurfaceParams CreateForFramebuffer(Core::System& system, std::size_t index);
+
+    /// Creates SurfaceCachedParams from a Fermi2D surface configuration.
+    static SurfaceParams CreateForFermiCopySurface(
+        const Tegra::Engines::Fermi2D::Regs::Surface& config);
+
+    bool IsTiled() const {
+        return is_tiled;
+    }
+
+    bool GetSrgbConversion() const {
+        return srgb_conversion;
+    }
+
+    u32 GetBlockWidth() const {
+        return block_width;
+    }
+
+    u32 GetTileWidthSpacing() const {
+        return tile_width_spacing;
+    }
+
+    u32 GetWidth() const {
+        return width;
+    }
+
+    u32 GetHeight() const {
+        return height;
+    }
+
+    u32 GetDepth() const {
+        return depth;
+    }
+
+    u32 GetPitch() const {
+        return pitch;
+    }
+
+    u32 GetNumLevels() const {
+        return num_levels;
+    }
+
+    VideoCore::Surface::PixelFormat GetPixelFormat() const {
+        return pixel_format;
+    }
+
+    VideoCore::Surface::ComponentType GetComponentType() const {
+        return component_type;
+    }
+
+    VideoCore::Surface::SurfaceTarget GetTarget() const {
+        return target;
+    }
+
+    VideoCore::Surface::SurfaceType GetType() const {
+        return type;
+    }
+
+    std::size_t GetGuestSizeInBytes() const {
+        return guest_size_in_bytes;
+    }
+
+    std::size_t GetHostSizeInBytes() const {
+        return host_size_in_bytes;
+    }
+
+    u32 GetNumLayers() const {
+        return num_layers;
+    }
+
+    /// Returns the width of a given mipmap level.
+    u32 GetMipWidth(u32 level) const;
+
+    /// Returns the height of a given mipmap level.
+    u32 GetMipHeight(u32 level) const;
+
+    /// Returns the depth of a given mipmap level.
+    u32 GetMipDepth(u32 level) const;
+
+    /// Returns true if these parameters are from a layered surface.
+    bool IsLayered() const;
+
+    /// Returns the block height of a given mipmap level.
+    u32 GetMipBlockHeight(u32 level) const;
+
+    /// Returns the block depth of a given mipmap level.
+    u32 GetMipBlockDepth(u32 level) const;
+
+    /// Returns the offset in bytes in guest memory of a given mipmap level.
+    std::size_t GetGuestMipmapLevelOffset(u32 level) const;
+
+    /// Returns the offset in bytes in host memory (linear) of a given mipmap level.
+    std::size_t GetHostMipmapLevelOffset(u32 level) const;
+
+    /// Returns the size in bytes in host memory (linear) of a given mipmap level.
+    std::size_t GetHostMipmapSize(u32 level) const;
+
+    /// Returns the size of a layer in bytes in guest memory.
+    std::size_t GetGuestLayerSize() const;
+
+    /// Returns the size of a layer in bytes in host memory for a given mipmap level.
+    std::size_t GetHostLayerSize(u32 level) const;
+
+    /// Returns the default block width.
+    u32 GetDefaultBlockWidth() const;
+
+    /// Returns the default block height.
+    u32 GetDefaultBlockHeight() const;
+
+    /// Returns the bits per pixel.
+    u32 GetBitsPerPixel() const;
+
+    /// Returns the bytes per pixel.
+    u32 GetBytesPerPixel() const;
+
+    /// Returns true if another surface can be familiar with this. This is a loosely defined term
+    /// that reflects the possibility of these two surface parameters potentially being part of a
+    /// bigger superset.
+    bool IsFamiliar(const SurfaceParams& view_params) const;
+
+    /// Returns true if the pixel format is a depth and/or stencil format.
+    bool IsPixelFormatZeta() const;
+
+    /// Creates a map that redirects an address difference to a layer and mipmap level.
+    std::map<u64, std::pair<u32, u32>> CreateViewOffsetMap() const;
+
+    /// Returns true if the passed surface view parameters is equal or a valid subset of this.
+    bool IsViewValid(const SurfaceParams& view_params, u32 layer, u32 level) const;
+
+private:
+    /// Calculates values that can be deduced from HasheableSurfaceParams.
+    void CalculateCachedValues();
+
+    /// Returns the size of a given mipmap level inside a layer.
+    std::size_t GetInnerMipmapMemorySize(u32 level, bool as_host_size, bool uncompressed) const;
+
+    /// Returns the size of all mipmap levels and aligns as needed.
+    std::size_t GetInnerMemorySize(bool as_host_size, bool layer_only, bool uncompressed) const;
+
+    /// Returns the size of a layer
+    std::size_t GetLayerSize(bool as_host_size, bool uncompressed) const;
+
+    /// Returns true if the passed view width and height match the size of this params in a given
+    /// mipmap level.
+    bool IsDimensionValid(const SurfaceParams& view_params, u32 level) const;
+
+    /// Returns true if the passed view depth match the size of this params in a given mipmap level.
+    bool IsDepthValid(const SurfaceParams& view_params, u32 level) const;
+
+    /// Returns true if the passed view layers and mipmap levels are in bounds.
+    bool IsInBounds(const SurfaceParams& view_params, u32 layer, u32 level) const;
+
+    std::size_t guest_size_in_bytes;
+    std::size_t host_size_in_bytes;
+    u32 num_layers;
+};
+
+} // namespace VideoCommon
+
+namespace std {
+
+template <>
+struct hash<VideoCommon::SurfaceParams> {
+    std::size_t operator()(const VideoCommon::SurfaceParams& k) const noexcept {
+        return k.Hash();
+    }
+};
+
+} // namespace std
-- 
cgit v1.2.3


From 3d471e732d688c20aef73a506bdb6126002d3193 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Tue, 7 May 2019 10:56:45 -0400
Subject: Correct Surface Base and Views for new Texture Cache

---
 src/video_core/texture_cache/surface_params.h | 159 ++++++++------------------
 1 file changed, 47 insertions(+), 112 deletions(-)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index 77dc0ba66..ec8efa210 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -6,50 +6,21 @@
 
 #include <map>
 
+#include "common/alignment.h"
 #include "common/common_types.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/surface.h"
+#include "video_core/shader/shader_ir.h"
 
 namespace VideoCommon {
 
-class HasheableSurfaceParams {
-public:
-    std::size_t Hash() const;
-
-    bool operator==(const HasheableSurfaceParams& rhs) const;
-
-    bool operator!=(const HasheableSurfaceParams& rhs) const {
-        return !operator==(rhs);
-    }
-
-protected:
-    // Avoid creation outside of a managed environment.
-    HasheableSurfaceParams() = default;
-
-    bool is_tiled;
-    bool srgb_conversion;
-    u32 block_width;
-    u32 block_height;
-    u32 block_depth;
-    u32 tile_width_spacing;
-    u32 width;
-    u32 height;
-    u32 depth;
-    u32 pitch;
-    u32 unaligned_height;
-    u32 num_levels;
-    VideoCore::Surface::PixelFormat pixel_format;
-    VideoCore::Surface::ComponentType component_type;
-    VideoCore::Surface::SurfaceType type;
-    VideoCore::Surface::SurfaceTarget target;
-};
-
-class SurfaceParams final : public HasheableSurfaceParams {
+class SurfaceParams {
 public:
     /// Creates SurfaceCachedParams from a texture configuration.
     static SurfaceParams CreateForTexture(Core::System& system,
-                                          const Tegra::Texture::FullTextureInfo& config);
+                                          const Tegra::Texture::FullTextureInfo& config,
+                                          const VideoCommon::Shader::Sampler& entry);
 
     /// Creates SurfaceCachedParams for a depth buffer configuration.
     static SurfaceParams CreateForDepthBuffer(
@@ -64,68 +35,33 @@ public:
     static SurfaceParams CreateForFermiCopySurface(
         const Tegra::Engines::Fermi2D::Regs::Surface& config);
 
-    bool IsTiled() const {
-        return is_tiled;
-    }
-
-    bool GetSrgbConversion() const {
-        return srgb_conversion;
-    }
-
-    u32 GetBlockWidth() const {
-        return block_width;
-    }
-
-    u32 GetTileWidthSpacing() const {
-        return tile_width_spacing;
-    }
-
-    u32 GetWidth() const {
-        return width;
-    }
-
-    u32 GetHeight() const {
-        return height;
-    }
-
-    u32 GetDepth() const {
-        return depth;
-    }
-
-    u32 GetPitch() const {
-        return pitch;
-    }
-
-    u32 GetNumLevels() const {
-        return num_levels;
-    }
-
-    VideoCore::Surface::PixelFormat GetPixelFormat() const {
-        return pixel_format;
-    }
-
-    VideoCore::Surface::ComponentType GetComponentType() const {
-        return component_type;
-    }
+    std::size_t Hash() const;
 
-    VideoCore::Surface::SurfaceTarget GetTarget() const {
-        return target;
-    }
+    bool operator==(const SurfaceParams& rhs) const;
 
-    VideoCore::Surface::SurfaceType GetType() const {
-        return type;
+    bool operator!=(const SurfaceParams& rhs) const {
+        return !operator==(rhs);
     }
 
     std::size_t GetGuestSizeInBytes() const {
-        return guest_size_in_bytes;
+        return GetInnerMemorySize(false, false, false);
     }
 
     std::size_t GetHostSizeInBytes() const {
+        std::size_t host_size_in_bytes;
+        if (IsPixelFormatASTC(pixel_format)) {
+            // ASTC is uncompressed in software, in emulated as RGBA8
+            host_size_in_bytes = static_cast<std::size_t>(Common::AlignUp(width, GetDefaultBlockWidth())) *
+                                 static_cast<std::size_t>(Common::AlignUp(height, GetDefaultBlockHeight())) *
+                                 static_cast<std::size_t>(depth) * 4ULL;
+        } else {
+            host_size_in_bytes = GetInnerMemorySize(true, false, false);
+        }
         return host_size_in_bytes;
     }
 
-    u32 GetNumLayers() const {
-        return num_layers;
+    u32 GetBlockAlignedWidth() const {
+        return Common::AlignUp(width, 64 / GetBytesPerPixel());
     }
 
     /// Returns the width of a given mipmap level.
@@ -137,9 +73,6 @@ public:
     /// Returns the depth of a given mipmap level.
     u32 GetMipDepth(u32 level) const;
 
-    /// Returns true if these parameters are from a layered surface.
-    bool IsLayered() const;
-
     /// Returns the block height of a given mipmap level.
     u32 GetMipBlockHeight(u32 level) const;
 
@@ -152,6 +85,9 @@ public:
     /// Returns the offset in bytes in host memory (linear) of a given mipmap level.
     std::size_t GetHostMipmapLevelOffset(u32 level) const;
 
+    /// Returns the size in bytes in guest memory of a given mipmap level.
+    std::size_t GetGuestMipmapSize(u32 level) const;
+
     /// Returns the size in bytes in host memory (linear) of a given mipmap level.
     std::size_t GetHostMipmapSize(u32 level) const;
 
@@ -173,24 +109,30 @@ public:
     /// Returns the bytes per pixel.
     u32 GetBytesPerPixel() const;
 
-    /// Returns true if another surface can be familiar with this. This is a loosely defined term
-    /// that reflects the possibility of these two surface parameters potentially being part of a
-    /// bigger superset.
-    bool IsFamiliar(const SurfaceParams& view_params) const;
-
     /// Returns true if the pixel format is a depth and/or stencil format.
     bool IsPixelFormatZeta() const;
 
-    /// Creates a map that redirects an address difference to a layer and mipmap level.
-    std::map<u64, std::pair<u32, u32>> CreateViewOffsetMap() const;
+    std::string TargetName() const;
 
-    /// Returns true if the passed surface view parameters is equal or a valid subset of this.
-    bool IsViewValid(const SurfaceParams& view_params, u32 layer, u32 level) const;
+    bool is_tiled;
+    bool srgb_conversion;
+    bool is_layered;
+    u32 block_width;
+    u32 block_height;
+    u32 block_depth;
+    u32 tile_width_spacing;
+    u32 width;
+    u32 height;
+    u32 depth;
+    u32 pitch;
+    u32 unaligned_height;
+    u32 num_levels;
+    VideoCore::Surface::PixelFormat pixel_format;
+    VideoCore::Surface::ComponentType component_type;
+    VideoCore::Surface::SurfaceType type;
+    VideoCore::Surface::SurfaceTarget target;
 
 private:
-    /// Calculates values that can be deduced from HasheableSurfaceParams.
-    void CalculateCachedValues();
-
     /// Returns the size of a given mipmap level inside a layer.
     std::size_t GetInnerMipmapMemorySize(u32 level, bool as_host_size, bool uncompressed) const;
 
@@ -200,19 +142,12 @@ private:
     /// Returns the size of a layer
     std::size_t GetLayerSize(bool as_host_size, bool uncompressed) const;
 
-    /// Returns true if the passed view width and height match the size of this params in a given
-    /// mipmap level.
-    bool IsDimensionValid(const SurfaceParams& view_params, u32 level) const;
-
-    /// Returns true if the passed view depth match the size of this params in a given mipmap level.
-    bool IsDepthValid(const SurfaceParams& view_params, u32 level) const;
-
-    /// Returns true if the passed view layers and mipmap levels are in bounds.
-    bool IsInBounds(const SurfaceParams& view_params, u32 layer, u32 level) const;
+    std::size_t GetNumLayers() const {
+        return is_layered ? depth : 1;
+    }
 
-    std::size_t guest_size_in_bytes;
-    std::size_t host_size_in_bytes;
-    u32 num_layers;
+    /// Returns true if these parameters are from a layered surface.
+    bool IsLayered() const;
 };
 
 } // namespace VideoCommon
-- 
cgit v1.2.3


From b347543e8341ae323ea232d47df2c144fe21c739 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Wed, 8 May 2019 18:27:29 -0400
Subject: Reduce amount of size calculations.

---
 src/video_core/texture_cache/surface_params.h | 50 +++++++++++++++++++++------
 1 file changed, 39 insertions(+), 11 deletions(-)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index ec8efa210..e0ec1be0e 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -10,8 +10,9 @@
 #include "common/common_types.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/surface.h"
 #include "video_core/shader/shader_ir.h"
+#include "video_core/surface.h"
+#include "video_core/textures/decoders.h"
 
 namespace VideoCommon {
 
@@ -50,10 +51,17 @@ public:
     std::size_t GetHostSizeInBytes() const {
         std::size_t host_size_in_bytes;
         if (IsPixelFormatASTC(pixel_format)) {
+            constexpr std::size_t rgb8_bpp = 4ULL;
             // ASTC is uncompressed in software, in emulated as RGBA8
-            host_size_in_bytes = static_cast<std::size_t>(Common::AlignUp(width, GetDefaultBlockWidth())) *
-                                 static_cast<std::size_t>(Common::AlignUp(height, GetDefaultBlockHeight())) *
-                                 static_cast<std::size_t>(depth) * 4ULL;
+            host_size_in_bytes = 0;
+            for (std::size_t level = 0; level < num_levels; level++) {
+                const std::size_t width =
+                    Common::AlignUp(GetMipWidth(level), GetDefaultBlockWidth());
+                const std::size_t height =
+                    Common::AlignUp(GetMipHeight(level), GetDefaultBlockHeight());
+                const std::size_t depth = is_layered ? depth : GetMipDepth(level);
+                host_size_in_bytes += width * height * depth * rgb8_bpp;
+            }
         } else {
             host_size_in_bytes = GetInnerMemorySize(true, false, false);
         }
@@ -65,13 +73,19 @@ public:
     }
 
     /// Returns the width of a given mipmap level.
-    u32 GetMipWidth(u32 level) const;
+    u32 GetMipWidth(u32 level) const {
+        return std::max(1U, width >> level);
+    }
 
     /// Returns the height of a given mipmap level.
-    u32 GetMipHeight(u32 level) const;
+    u32 GetMipHeight(u32 level) const {
+        return std::max(1U, height >> level);
+    }
 
     /// Returns the depth of a given mipmap level.
-    u32 GetMipDepth(u32 level) const;
+    u32 GetMipDepth(u32 level) const {
+        return is_layered ? depth : std::max(1U, depth >> level);
+    }
 
     /// Returns the block height of a given mipmap level.
     u32 GetMipBlockHeight(u32 level) const;
@@ -79,6 +93,12 @@ public:
     /// Returns the block depth of a given mipmap level.
     u32 GetMipBlockDepth(u32 level) const;
 
+    // Helper used for out of class size calculations
+    static std::size_t AlignLayered(const std::size_t out_size, const u32 block_height,
+                                    const u32 block_depth) {
+        return Common::AlignUp(out_size, Tegra::Texture::GetGOBSize() * block_height * block_depth);
+    }
+
     /// Returns the offset in bytes in guest memory of a given mipmap level.
     std::size_t GetGuestMipmapLevelOffset(u32 level) const;
 
@@ -98,16 +118,24 @@ public:
     std::size_t GetHostLayerSize(u32 level) const;
 
     /// Returns the default block width.
-    u32 GetDefaultBlockWidth() const;
+    u32 GetDefaultBlockWidth() const {
+        return VideoCore::Surface::GetDefaultBlockWidth(pixel_format);
+    }
 
     /// Returns the default block height.
-    u32 GetDefaultBlockHeight() const;
+    u32 GetDefaultBlockHeight() const {
+        return VideoCore::Surface::GetDefaultBlockHeight(pixel_format);
+    }
 
     /// Returns the bits per pixel.
-    u32 GetBitsPerPixel() const;
+    u32 GetBitsPerPixel() const {
+        return VideoCore::Surface::GetFormatBpp(pixel_format);
+    }
 
     /// Returns the bytes per pixel.
-    u32 GetBytesPerPixel() const;
+    u32 GetBytesPerPixel() const {
+        return VideoCore::Surface::GetBytesPerPixel(pixel_format);
+    }
 
     /// Returns true if the pixel format is a depth and/or stencil format.
     bool IsPixelFormatZeta() const;
-- 
cgit v1.2.3


From 345e73f2feb0701e3c3099d002a1c21fb524eae4 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Fri, 10 May 2019 04:17:48 -0300
Subject: video_core: Use un-shifted block sizes to avoid integer divisions

Instead of storing all block width, height and depths in their shifted
form:

block_width = 1U << block_shift;

Store them like they are provided by the emulated hardware (their
block_shift form). This way we can avoid doing the costly
Common::AlignUp operation to align texture sizes and drop CPU integer
divisions with bitwise logic (defined in Common::AlignBits).
---
 src/video_core/texture_cache/surface_params.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index e0ec1be0e..7c48782c7 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -54,12 +54,12 @@ public:
             constexpr std::size_t rgb8_bpp = 4ULL;
             // ASTC is uncompressed in software, in emulated as RGBA8
             host_size_in_bytes = 0;
-            for (std::size_t level = 0; level < num_levels; level++) {
+            for (u32 level = 0; level < num_levels; ++level) {
                 const std::size_t width =
                     Common::AlignUp(GetMipWidth(level), GetDefaultBlockWidth());
                 const std::size_t height =
                     Common::AlignUp(GetMipHeight(level), GetDefaultBlockHeight());
-                const std::size_t depth = is_layered ? depth : GetMipDepth(level);
+                const std::size_t depth = is_layered ? this->depth : GetMipDepth(level);
                 host_size_in_bytes += width * height * depth * rgb8_bpp;
             }
         } else {
@@ -96,7 +96,8 @@ public:
     // Helper used for out of class size calculations
     static std::size_t AlignLayered(const std::size_t out_size, const u32 block_height,
                                     const u32 block_depth) {
-        return Common::AlignUp(out_size, Tegra::Texture::GetGOBSize() * block_height * block_depth);
+        return Common::AlignBits(out_size,
+                                 Tegra::Texture::GetGOBSizeShift() + block_height + block_depth);
     }
 
     /// Returns the offset in bytes in guest memory of a given mipmap level.
-- 
cgit v1.2.3


From 7731a0e2d15da04eea746b4b8dd5c6c4b29f9f29 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sun, 12 May 2019 20:33:52 -0400
Subject: texture_cache: General Fixes

Fixed ASTC mipmaps loading
Fixed alignment on openGL upload/download
Fixed Block Height Calculation
Removed unalign_height
---
 src/video_core/texture_cache/surface_params.h | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index 7c48782c7..b3082173f 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -7,6 +7,7 @@
 #include <map>
 
 #include "common/alignment.h"
+#include "common/bit_util.h"
 #include "common/common_types.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/maxwell_3d.h"
@@ -16,6 +17,8 @@
 
 namespace VideoCommon {
 
+using VideoCore::Surface::SurfaceCompression;
+
 class SurfaceParams {
 public:
     /// Creates SurfaceCachedParams from a texture configuration.
@@ -50,17 +53,12 @@ public:
 
     std::size_t GetHostSizeInBytes() const {
         std::size_t host_size_in_bytes;
-        if (IsPixelFormatASTC(pixel_format)) {
+        if (GetCompressionType() == SurfaceCompression::Converted) {
             constexpr std::size_t rgb8_bpp = 4ULL;
             // ASTC is uncompressed in software, in emulated as RGBA8
             host_size_in_bytes = 0;
             for (u32 level = 0; level < num_levels; ++level) {
-                const std::size_t width =
-                    Common::AlignUp(GetMipWidth(level), GetDefaultBlockWidth());
-                const std::size_t height =
-                    Common::AlignUp(GetMipHeight(level), GetDefaultBlockHeight());
-                const std::size_t depth = is_layered ? this->depth : GetMipDepth(level);
-                host_size_in_bytes += width * height * depth * rgb8_bpp;
+                host_size_in_bytes += GetConvertedMipmapSize(level);
             }
         } else {
             host_size_in_bytes = GetInnerMemorySize(true, false, false);
@@ -93,6 +91,12 @@ public:
     /// Returns the block depth of a given mipmap level.
     u32 GetMipBlockDepth(u32 level) const;
 
+    u32 GetRowAlignment(u32 level) const {
+        const u32 bpp =
+            GetCompressionType() == SurfaceCompression::Converted ? 4 : GetBytesPerPixel();
+        return 1U << Common::CountTrailingZeroes32(GetMipWidth(level) * bpp);
+    }
+
     // Helper used for out of class size calculations
     static std::size_t AlignLayered(const std::size_t out_size, const u32 block_height,
                                     const u32 block_depth) {
@@ -106,12 +110,16 @@ public:
     /// Returns the offset in bytes in host memory (linear) of a given mipmap level.
     std::size_t GetHostMipmapLevelOffset(u32 level) const;
 
+    std::size_t GetConvertedMipmapOffset(u32 level) const;
+
     /// Returns the size in bytes in guest memory of a given mipmap level.
     std::size_t GetGuestMipmapSize(u32 level) const;
 
     /// Returns the size in bytes in host memory (linear) of a given mipmap level.
     std::size_t GetHostMipmapSize(u32 level) const;
 
+    std::size_t GetConvertedMipmapSize(u32 level) const;
+
     /// Returns the size of a layer in bytes in guest memory.
     std::size_t GetGuestLayerSize() const;
 
@@ -141,6 +149,10 @@ public:
     /// Returns true if the pixel format is a depth and/or stencil format.
     bool IsPixelFormatZeta() const;
 
+    SurfaceCompression GetCompressionType() const {
+        return VideoCore::Surface::GetFormatCompressionType(pixel_format);
+    }
+
     std::string TargetName() const;
 
     bool is_tiled;
@@ -154,7 +166,6 @@ public:
     u32 height;
     u32 depth;
     u32 pitch;
-    u32 unaligned_height;
     u32 num_levels;
     VideoCore::Surface::PixelFormat pixel_format;
     VideoCore::Surface::ComponentType component_type;
-- 
cgit v1.2.3


From 175aa343ff1c9f931b266caf2d19b8df943dab0d Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sat, 18 May 2019 04:57:49 -0400
Subject: texture_cache: Fermi2D reform and implement View Mirage

This also does some fixes on compressed textures reinterpret and on the
Fermi2D engine in general.
---
 src/video_core/texture_cache/surface_params.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index b3082173f..13a08a60f 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -126,6 +126,20 @@ public:
     /// Returns the size of a layer in bytes in host memory for a given mipmap level.
     std::size_t GetHostLayerSize(u32 level) const;
 
+    static u32 ConvertWidth(u32 width, VideoCore::Surface::PixelFormat pixel_format_from,
+                            VideoCore::Surface::PixelFormat pixel_format_to) {
+        const u32 bw1 = VideoCore::Surface::GetDefaultBlockWidth(pixel_format_from);
+        const u32 bw2 = VideoCore::Surface::GetDefaultBlockWidth(pixel_format_to);
+        return (width * bw2 + bw1 - 1) / bw1;
+    }
+
+    static u32 ConvertHeight(u32 height, VideoCore::Surface::PixelFormat pixel_format_from,
+                             VideoCore::Surface::PixelFormat pixel_format_to) {
+        const u32 bh1 = VideoCore::Surface::GetDefaultBlockHeight(pixel_format_from);
+        const u32 bh2 = VideoCore::Surface::GetDefaultBlockHeight(pixel_format_to);
+        return (height * bh2 + bh1 - 1) / bh1;
+    }
+
     /// Returns the default block width.
     u32 GetDefaultBlockWidth() const {
         return VideoCore::Surface::GetDefaultBlockWidth(pixel_format);
-- 
cgit v1.2.3


From ea1525dab1bf7e9e56471b6d5fd50014bfeb4f96 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Tue, 21 May 2019 12:48:28 -0400
Subject: Fix rebase errors

---
 src/video_core/texture_cache/surface_params.h | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index 13a08a60f..d9aa0b521 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -167,6 +167,10 @@ public:
         return VideoCore::Surface::GetFormatCompressionType(pixel_format);
     }
 
+    bool IsBuffer() const {
+        return target == VideoCore::Surface::SurfaceTarget::TextureBuffer;
+    }
+
     std::string TargetName() const;
 
     bool is_tiled;
-- 
cgit v1.2.3


From 92513541529e90f4f79a1f2c3f8ccf5a199e4c20 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Fri, 24 May 2019 11:59:23 -0400
Subject: texture_cache: Correct copying between compressed and uncompressed
 formats

---
 src/video_core/texture_cache/surface_params.h | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index d9aa0b521..c3affd621 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -140,6 +140,26 @@ public:
         return (height * bh2 + bh1 - 1) / bh1;
     }
 
+    // this finds the maximun possible width between 2 2D layers of different formats
+    static u32 IntersectWidth(const SurfaceParams& src_params, const SurfaceParams& dst_params,
+                              const u32 src_level, const u32 dst_level) {
+        const u32 bw1 = src_params.GetDefaultBlockWidth();
+        const u32 bw2 = dst_params.GetDefaultBlockWidth();
+        const u32 t_src_width = (src_params.GetMipWidth(src_level) * bw2 + bw1 - 1) / bw1;
+        const u32 t_dst_width = (dst_params.GetMipWidth(dst_level) * bw1 + bw2 - 1) / bw2;
+        return std::min(t_src_width, t_dst_width);
+    }
+
+    // this finds the maximun possible height between 2 2D layers of different formats
+    static u32 IntersectHeight(const SurfaceParams& src_params, const SurfaceParams& dst_params,
+                               const u32 src_level, const u32 dst_level) {
+        const u32 bh1 = src_params.GetDefaultBlockHeight();
+        const u32 bh2 = dst_params.GetDefaultBlockHeight();
+        const u32 t_src_height = (src_params.GetMipHeight(src_level) * bh2 + bh1 - 1) / bh1;
+        const u32 t_dst_height = (dst_params.GetMipHeight(dst_level) * bh1 + bh2 - 1) / bh2;
+        return std::min(t_src_height, t_dst_height);
+    }
+
     /// Returns the default block width.
     u32 GetDefaultBlockWidth() const {
         return VideoCore::Surface::GetDefaultBlockWidth(pixel_format);
-- 
cgit v1.2.3


From 228f516bb4426a41a4d1c1756751557f7a0eecda Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Fri, 24 May 2019 15:34:31 -0400
Subject: texture_cache uncompress-compress is untopological.

This makes conflicts between non compress and compress textures to be
auto recycled. It also limits the amount of mipmaps a texture can have
if it goes above it's limit.
---
 src/video_core/texture_cache/surface_params.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index c3affd621..5fde695b6 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -160,6 +160,19 @@ public:
         return std::min(t_src_height, t_dst_height);
     }
 
+    u32 MaxPossibleMipmap() const {
+        const u32 max_mipmap_w = Common::Log2Ceil32(width) + 1U;
+        const u32 max_mipmap_h = Common::Log2Ceil32(height) + 1U;
+        const u32 max_mipmap = std::max(max_mipmap_w, max_mipmap_h);
+        if (target != VideoCore::Surface::SurfaceTarget::Texture3D)
+            return max_mipmap;
+        return std::max(max_mipmap, Common::Log2Ceil32(depth) + 1U);
+    }
+
+    bool IsCompressed() const {
+        return GetDefaultBlockHeight() > 1 || GetDefaultBlockWidth() > 1;
+    }
+
     /// Returns the default block width.
     u32 GetDefaultBlockWidth() const {
         return VideoCore::Surface::GetDefaultBlockWidth(pixel_format);
@@ -205,6 +218,7 @@ public:
     u32 depth;
     u32 pitch;
     u32 num_levels;
+    u32 emulated_levels;
     VideoCore::Surface::PixelFormat pixel_format;
     VideoCore::Surface::ComponentType component_type;
     VideoCore::Surface::SurfaceType type;
-- 
cgit v1.2.3


From 9f755218a1359cbd004e6c287f5fead0897c1d11 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Sat, 1 Jun 2019 23:03:22 -0400
Subject: texture_cache: move some large methods to cpp files

---
 src/video_core/texture_cache/surface_params.h | 32 +++++++++++++++++++++------
 1 file changed, 25 insertions(+), 7 deletions(-)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index 5fde695b6..c51e174cd 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -8,6 +8,7 @@
 
 #include "common/alignment.h"
 #include "common/bit_util.h"
+#include "common/cityhash.h"
 #include "common/common_types.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/maxwell_3d.h"
@@ -39,7 +40,10 @@ public:
     static SurfaceParams CreateForFermiCopySurface(
         const Tegra::Engines::Fermi2D::Regs::Surface& config);
 
-    std::size_t Hash() const;
+    std::size_t Hash() const {
+        return static_cast<std::size_t>(
+            Common::CityHash64(reinterpret_cast<const char*>(this), sizeof(*this)));
+    }
 
     bool operator==(const SurfaceParams& rhs) const;
 
@@ -113,18 +117,27 @@ public:
     std::size_t GetConvertedMipmapOffset(u32 level) const;
 
     /// Returns the size in bytes in guest memory of a given mipmap level.
-    std::size_t GetGuestMipmapSize(u32 level) const;
+    std::size_t GetGuestMipmapSize(u32 level) const {
+        return GetInnerMipmapMemorySize(level, false, false);
+    }
 
     /// Returns the size in bytes in host memory (linear) of a given mipmap level.
-    std::size_t GetHostMipmapSize(u32 level) const;
+    std::size_t GetHostMipmapSize(u32 level) const {
+        return GetInnerMipmapMemorySize(level, true, false) * GetNumLayers();
+    }
 
     std::size_t GetConvertedMipmapSize(u32 level) const;
 
     /// Returns the size of a layer in bytes in guest memory.
-    std::size_t GetGuestLayerSize() const;
+    std::size_t GetGuestLayerSize() const {
+        return GetLayerSize(false, false);
+    }
 
     /// Returns the size of a layer in bytes in host memory for a given mipmap level.
-    std::size_t GetHostLayerSize(u32 level) const;
+    std::size_t GetHostLayerSize(u32 level) const {
+        ASSERT(target != VideoCore::Surface::SurfaceTarget::Texture3D);
+        return GetInnerMipmapMemorySize(level, true, false);
+    }
 
     static u32 ConvertWidth(u32 width, VideoCore::Surface::PixelFormat pixel_format_from,
                             VideoCore::Surface::PixelFormat pixel_format_to) {
@@ -194,7 +207,10 @@ public:
     }
 
     /// Returns true if the pixel format is a depth and/or stencil format.
-    bool IsPixelFormatZeta() const;
+    bool IsPixelFormatZeta() const {
+        return pixel_format >= VideoCore::Surface::PixelFormat::MaxColorFormat &&
+               pixel_format < VideoCore::Surface::PixelFormat::MaxDepthStencilFormat;
+    }
 
     SurfaceCompression GetCompressionType() const {
         return VideoCore::Surface::GetFormatCompressionType(pixel_format);
@@ -229,7 +245,9 @@ private:
     std::size_t GetInnerMipmapMemorySize(u32 level, bool as_host_size, bool uncompressed) const;
 
     /// Returns the size of all mipmap levels and aligns as needed.
-    std::size_t GetInnerMemorySize(bool as_host_size, bool layer_only, bool uncompressed) const;
+    std::size_t GetInnerMemorySize(bool as_host_size, bool layer_only, bool uncompressed) const {
+        return GetLayerSize(as_host_size, uncompressed) * (layer_only ? 1U : depth);
+    }
 
     /// Returns the size of a layer
     std::size_t GetLayerSize(bool as_host_size, bool uncompressed) const;
-- 
cgit v1.2.3


From c0abc7124d6ecd17f9da5ee5b3de9cb3dbf3ce1f Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Tue, 25 Jun 2019 18:03:25 -0400
Subject: surface_params: Corrections, asserts and documentation.

---
 src/video_core/texture_cache/surface_params.h | 97 ++++++++++++++++-----------
 1 file changed, 56 insertions(+), 41 deletions(-)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index c51e174cd..4dfb882f0 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -95,25 +95,21 @@ public:
     /// Returns the block depth of a given mipmap level.
     u32 GetMipBlockDepth(u32 level) const;
 
+    /// returns the best possible row/pitch alignment for the surface.
     u32 GetRowAlignment(u32 level) const {
         const u32 bpp =
             GetCompressionType() == SurfaceCompression::Converted ? 4 : GetBytesPerPixel();
         return 1U << Common::CountTrailingZeroes32(GetMipWidth(level) * bpp);
     }
 
-    // Helper used for out of class size calculations
-    static std::size_t AlignLayered(const std::size_t out_size, const u32 block_height,
-                                    const u32 block_depth) {
-        return Common::AlignBits(out_size,
-                                 Tegra::Texture::GetGOBSizeShift() + block_height + block_depth);
-    }
-
     /// Returns the offset in bytes in guest memory of a given mipmap level.
     std::size_t GetGuestMipmapLevelOffset(u32 level) const;
 
     /// Returns the offset in bytes in host memory (linear) of a given mipmap level.
     std::size_t GetHostMipmapLevelOffset(u32 level) const;
 
+    /// Returns the offset in bytes in host memory (linear) of a given mipmap level
+    // for a texture that is converted in host gpu.
     std::size_t GetConvertedMipmapOffset(u32 level) const;
 
     /// Returns the size in bytes in guest memory of a given mipmap level.
@@ -139,40 +135,7 @@ public:
         return GetInnerMipmapMemorySize(level, true, false);
     }
 
-    static u32 ConvertWidth(u32 width, VideoCore::Surface::PixelFormat pixel_format_from,
-                            VideoCore::Surface::PixelFormat pixel_format_to) {
-        const u32 bw1 = VideoCore::Surface::GetDefaultBlockWidth(pixel_format_from);
-        const u32 bw2 = VideoCore::Surface::GetDefaultBlockWidth(pixel_format_to);
-        return (width * bw2 + bw1 - 1) / bw1;
-    }
-
-    static u32 ConvertHeight(u32 height, VideoCore::Surface::PixelFormat pixel_format_from,
-                             VideoCore::Surface::PixelFormat pixel_format_to) {
-        const u32 bh1 = VideoCore::Surface::GetDefaultBlockHeight(pixel_format_from);
-        const u32 bh2 = VideoCore::Surface::GetDefaultBlockHeight(pixel_format_to);
-        return (height * bh2 + bh1 - 1) / bh1;
-    }
-
-    // this finds the maximun possible width between 2 2D layers of different formats
-    static u32 IntersectWidth(const SurfaceParams& src_params, const SurfaceParams& dst_params,
-                              const u32 src_level, const u32 dst_level) {
-        const u32 bw1 = src_params.GetDefaultBlockWidth();
-        const u32 bw2 = dst_params.GetDefaultBlockWidth();
-        const u32 t_src_width = (src_params.GetMipWidth(src_level) * bw2 + bw1 - 1) / bw1;
-        const u32 t_dst_width = (dst_params.GetMipWidth(dst_level) * bw1 + bw2 - 1) / bw2;
-        return std::min(t_src_width, t_dst_width);
-    }
-
-    // this finds the maximun possible height between 2 2D layers of different formats
-    static u32 IntersectHeight(const SurfaceParams& src_params, const SurfaceParams& dst_params,
-                               const u32 src_level, const u32 dst_level) {
-        const u32 bh1 = src_params.GetDefaultBlockHeight();
-        const u32 bh2 = dst_params.GetDefaultBlockHeight();
-        const u32 t_src_height = (src_params.GetMipHeight(src_level) * bh2 + bh1 - 1) / bh1;
-        const u32 t_dst_height = (dst_params.GetMipHeight(dst_level) * bh1 + bh2 - 1) / bh2;
-        return std::min(t_src_height, t_dst_height);
-    }
-
+    /// Returns the max possible mipmap that the texture can have in host gpu
     u32 MaxPossibleMipmap() const {
         const u32 max_mipmap_w = Common::Log2Ceil32(width) + 1U;
         const u32 max_mipmap_h = Common::Log2Ceil32(height) + 1U;
@@ -182,6 +145,7 @@ public:
         return std::max(max_mipmap, Common::Log2Ceil32(depth) + 1U);
     }
 
+    /// Returns if the guest surface is a compressed surface.
     bool IsCompressed() const {
         return GetDefaultBlockHeight() > 1 || GetDefaultBlockWidth() > 1;
     }
@@ -212,16 +176,67 @@ public:
                pixel_format < VideoCore::Surface::PixelFormat::MaxDepthStencilFormat;
     }
 
+    /// Returns how the compression should be handled for this texture. Values
+    /// are: None(no compression), Compressed(texture is compressed),
+    /// Converted(texture is converted before upload/ after download),
+    /// Rearranged(texture is swizzled before upload/after download).
     SurfaceCompression GetCompressionType() const {
         return VideoCore::Surface::GetFormatCompressionType(pixel_format);
     }
 
+    /// Returns is the surface is a TextureBuffer type of surface.
     bool IsBuffer() const {
         return target == VideoCore::Surface::SurfaceTarget::TextureBuffer;
     }
 
+    /// Returns the debug name of the texture for use in graphic debuggers.
     std::string TargetName() const;
 
+    // Helper used for out of class size calculations
+    static std::size_t AlignLayered(const std::size_t out_size, const u32 block_height,
+                                    const u32 block_depth) {
+        return Common::AlignBits(out_size,
+                                 Tegra::Texture::GetGOBSizeShift() + block_height + block_depth);
+    }
+
+    /// Converts a width from a type of surface into another. This helps represent the
+    /// equivalent value between compressed/non-compressed textures.
+    static u32 ConvertWidth(u32 width, VideoCore::Surface::PixelFormat pixel_format_from,
+                            VideoCore::Surface::PixelFormat pixel_format_to) {
+        const u32 bw1 = VideoCore::Surface::GetDefaultBlockWidth(pixel_format_from);
+        const u32 bw2 = VideoCore::Surface::GetDefaultBlockWidth(pixel_format_to);
+        return (width * bw2 + bw1 - 1) / bw1;
+    }
+
+    /// Converts a height from a type of surface into another. This helps represent the
+    /// equivalent value between compressed/non-compressed textures.
+    static u32 ConvertHeight(u32 height, VideoCore::Surface::PixelFormat pixel_format_from,
+                             VideoCore::Surface::PixelFormat pixel_format_to) {
+        const u32 bh1 = VideoCore::Surface::GetDefaultBlockHeight(pixel_format_from);
+        const u32 bh2 = VideoCore::Surface::GetDefaultBlockHeight(pixel_format_to);
+        return (height * bh2 + bh1 - 1) / bh1;
+    }
+
+    // Finds the maximun possible width between 2 2D layers of different formats
+    static u32 IntersectWidth(const SurfaceParams& src_params, const SurfaceParams& dst_params,
+                              const u32 src_level, const u32 dst_level) {
+        const u32 bw1 = src_params.GetDefaultBlockWidth();
+        const u32 bw2 = dst_params.GetDefaultBlockWidth();
+        const u32 t_src_width = (src_params.GetMipWidth(src_level) * bw2 + bw1 - 1) / bw1;
+        const u32 t_dst_width = (dst_params.GetMipWidth(dst_level) * bw1 + bw2 - 1) / bw2;
+        return std::min(t_src_width, t_dst_width);
+    }
+
+    // Finds the maximun possible height between 2 2D layers of different formats
+    static u32 IntersectHeight(const SurfaceParams& src_params, const SurfaceParams& dst_params,
+                               const u32 src_level, const u32 dst_level) {
+        const u32 bh1 = src_params.GetDefaultBlockHeight();
+        const u32 bh2 = dst_params.GetDefaultBlockHeight();
+        const u32 t_src_height = (src_params.GetMipHeight(src_level) * bh2 + bh1 - 1) / bh1;
+        const u32 t_dst_height = (dst_params.GetMipHeight(dst_level) * bh1 + bh2 - 1) / bh2;
+        return std::min(t_src_height, t_dst_height);
+    }
+
     bool is_tiled;
     bool srgb_conversion;
     bool is_layered;
-- 
cgit v1.2.3


From f6f1a8f26a302dc33df635625c490f0d65880059 Mon Sep 17 00:00:00 2001
From: ReinUsesLisp <reinuseslisp@airmail.cc>
Date: Sat, 29 Jun 2019 19:52:37 -0300
Subject: texture_cache: Style changes

---
 src/video_core/texture_cache/surface_params.h | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

(limited to 'src/video_core/texture_cache/surface_params.h')

diff --git a/src/video_core/texture_cache/surface_params.h b/src/video_core/texture_cache/surface_params.h
index 4dfb882f0..358d6757c 100644
--- a/src/video_core/texture_cache/surface_params.h
+++ b/src/video_core/texture_cache/surface_params.h
@@ -95,7 +95,7 @@ public:
     /// Returns the block depth of a given mipmap level.
     u32 GetMipBlockDepth(u32 level) const;
 
-    /// returns the best possible row/pitch alignment for the surface.
+    /// Returns the best possible row/pitch alignment for the surface.
     u32 GetRowAlignment(u32 level) const {
         const u32 bpp =
             GetCompressionType() == SurfaceCompression::Converted ? 4 : GetBytesPerPixel();
@@ -109,7 +109,7 @@ public:
     std::size_t GetHostMipmapLevelOffset(u32 level) const;
 
     /// Returns the offset in bytes in host memory (linear) of a given mipmap level
-    // for a texture that is converted in host gpu.
+    /// for a texture that is converted in host gpu.
     std::size_t GetConvertedMipmapOffset(u32 level) const;
 
     /// Returns the size in bytes in guest memory of a given mipmap level.
@@ -176,10 +176,7 @@ public:
                pixel_format < VideoCore::Surface::PixelFormat::MaxDepthStencilFormat;
     }
 
-    /// Returns how the compression should be handled for this texture. Values
-    /// are: None(no compression), Compressed(texture is compressed),
-    /// Converted(texture is converted before upload/ after download),
-    /// Rearranged(texture is swizzled before upload/after download).
+    /// Returns how the compression should be handled for this texture.
     SurfaceCompression GetCompressionType() const {
         return VideoCore::Surface::GetFormatCompressionType(pixel_format);
     }
-- 
cgit v1.2.3