From 9b0aa5135e9e002bd7ef0addaf8c30406100df91 Mon Sep 17 00:00:00 2001
From: emufan4568 <geoster3d@gmail.com>
Date: Tue, 6 Sep 2022 22:52:10 +0300
Subject: [PATCH] rasterizer_cache: microprofile: Rename OpenGL to
 RasterizerCache

---
 .../rasterizer_cache/cached_surface.cpp          | 16 ++++++++--------
 .../rasterizer_cache/rasterizer_cache.cpp        |  8 ++++----
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/video_core/rasterizer_cache/cached_surface.cpp b/src/video_core/rasterizer_cache/cached_surface.cpp
index c053bc634..96dd5accc 100644
--- a/src/video_core/rasterizer_cache/cached_surface.cpp
+++ b/src/video_core/rasterizer_cache/cached_surface.cpp
@@ -26,7 +26,7 @@ CachedSurface::~CachedSurface() {
     }
 }
 
-MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 192, 64));
+MICROPROFILE_DEFINE(RasterizerCache_SurfaceLoad, "RasterizerCache", "Surface Load", MP_RGB(128, 192, 64));
 void CachedSurface::LoadGLBuffer(PAddr load_start, PAddr load_end) {
     ASSERT(type != SurfaceType::Fill);
     const bool need_swap =
@@ -47,7 +47,7 @@ void CachedSurface::LoadGLBuffer(PAddr load_start, PAddr load_end) {
     if (load_start < Memory::VRAM_VADDR && load_end > Memory::VRAM_VADDR)
         load_start = Memory::VRAM_VADDR;
 
-    MICROPROFILE_SCOPE(OpenGL_SurfaceLoad);
+    MICROPROFILE_SCOPE(RasterizerCache_SurfaceLoad);
 
     ASSERT(load_start >= addr && load_end <= end);
     const u32 start_offset = load_start - addr;
@@ -103,7 +103,7 @@ void CachedSurface::LoadGLBuffer(PAddr load_start, PAddr load_end) {
     }
 }
 
-MICROPROFILE_DEFINE(OpenGL_SurfaceFlush, "OpenGL", "Surface Flush", MP_RGB(128, 192, 64));
+MICROPROFILE_DEFINE(RasterizerCache_SurfaceFlush, "RasterizerCache", "Surface Flush", MP_RGB(128, 192, 64));
 void CachedSurface::FlushGLBuffer(PAddr flush_start, PAddr flush_end) {
     u8* const dst_buffer = VideoCore::g_memory->GetPhysicalPointer(addr);
     if (dst_buffer == nullptr)
@@ -119,7 +119,7 @@ void CachedSurface::FlushGLBuffer(PAddr flush_start, PAddr flush_end) {
     if (flush_start < Memory::VRAM_VADDR && flush_end > Memory::VRAM_VADDR)
         flush_start = Memory::VRAM_VADDR;
 
-    MICROPROFILE_SCOPE(OpenGL_SurfaceFlush);
+    MICROPROFILE_SCOPE(RasterizerCache_SurfaceFlush);
 
     ASSERT(flush_start >= addr && flush_end <= end);
     const u32 start_offset = flush_start - addr;
@@ -252,13 +252,13 @@ void CachedSurface::DumpTexture(GLuint target_tex, u64 tex_hash) {
     }
 }
 
-MICROPROFILE_DEFINE(OpenGL_TextureUL, "OpenGL", "Texture Upload", MP_RGB(128, 192, 64));
+MICROPROFILE_DEFINE(RasterizerCache_TextureUL, "RasterizerCache", "Texture Upload", MP_RGB(128, 192, 64));
 void CachedSurface::UploadGLTexture(Common::Rectangle<u32> rect) {
     if (type == SurfaceType::Fill) {
         return;
     }
 
-    MICROPROFILE_SCOPE(OpenGL_TextureUL);
+    MICROPROFILE_SCOPE(RasterizerCache_TextureUL);
     ASSERT(gl_buffer.size() == width * height * GetBytesPerPixel(pixel_format));
 
     u64 tex_hash = 0;
@@ -357,13 +357,13 @@ void CachedSurface::UploadGLTexture(Common::Rectangle<u32> rect) {
     InvalidateAllWatcher();
 }
 
-MICROPROFILE_DEFINE(OpenGL_TextureDL, "OpenGL", "Texture Download", MP_RGB(128, 192, 64));
+MICROPROFILE_DEFINE(RasterizerCache_TextureDL, "RasterizerCache", "Texture Download", MP_RGB(128, 192, 64));
 void CachedSurface::DownloadGLTexture(const Common::Rectangle<u32>& rect) {
     if (type == SurfaceType::Fill) {
         return;
     }
 
-    MICROPROFILE_SCOPE(OpenGL_TextureDL);
+    MICROPROFILE_SCOPE(RasterizerCache_TextureDL);
 
     if (gl_buffer.empty()) {
         gl_buffer.resize(width * height * GetBytesPerPixel(pixel_format));
diff --git a/src/video_core/rasterizer_cache/rasterizer_cache.cpp b/src/video_core/rasterizer_cache/rasterizer_cache.cpp
index 6ac8ce3e4..7a0fca75a 100644
--- a/src/video_core/rasterizer_cache/rasterizer_cache.cpp
+++ b/src/video_core/rasterizer_cache/rasterizer_cache.cpp
@@ -40,10 +40,10 @@ OGLTexture RasterizerCache::AllocateSurfaceTexture(PixelFormat format, u32 width
     return texture;
 }
 
-MICROPROFILE_DEFINE(OpenGL_CopySurface, "OpenGL", "CopySurface", MP_RGB(128, 192, 64));
+MICROPROFILE_DEFINE(RasterizerCache_CopySurface, "RasterizerCache", "CopySurface", MP_RGB(128, 192, 64));
 void RasterizerCache::CopySurface(const Surface& src_surface, const Surface& dst_surface,
                                         SurfaceInterval copy_interval) {
-    MICROPROFILE_SCOPE(OpenGL_CopySurface);
+    MICROPROFILE_SCOPE(RasterizerCache_CopySurface);
 
     SurfaceParams subrect_params = dst_surface->FromInterval(copy_interval);
     ASSERT(subrect_params.GetInterval() == copy_interval && src_surface != dst_surface);
@@ -199,12 +199,12 @@ RasterizerCache::RasterizerCache(VideoCore::RasterizerAccelerated& rasterizer)
 
 RasterizerCache::~RasterizerCache() = default;
 
-MICROPROFILE_DEFINE(OpenGL_BlitSurface, "OpenGL", "BlitSurface", MP_RGB(128, 192, 64));
+MICROPROFILE_DEFINE(RasterizerCache_BlitSurface, "RasterizerCache", "BlitSurface", MP_RGB(128, 192, 64));
 bool RasterizerCache::BlitSurfaces(const Surface& src_surface,
                                          const Common::Rectangle<u32>& src_rect,
                                          const Surface& dst_surface,
                                          const Common::Rectangle<u32>& dst_rect) {
-    MICROPROFILE_SCOPE(OpenGL_BlitSurface);
+    MICROPROFILE_SCOPE(RasterizerCache_BlitSurface);
 
     if (CheckFormatsBlittable(src_surface->pixel_format, dst_surface->pixel_format)) {
         dst_surface->InvalidateAllWatcher();