From c74f5b21890e74992a6178cb41b8948cc7bd2e2c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Sat, 25 Feb 2023 15:59:35 +0100 Subject: [PATCH] Prepare for unifying more stuff --- GPU/Common/ShaderCommon.h | 4 ++++ GPU/Common/TextureCacheCommon.cpp | 8 +++---- GPU/Common/TextureCacheCommon.h | 7 +++++-- GPU/D3D11/GPU_D3D11.cpp | 12 +++++------ GPU/D3D11/ShaderManagerD3D11.h | 4 +++- GPU/D3D11/TextureCacheD3D11.h | 3 +++ GPU/Directx9/GPU_DX9.cpp | 21 +++++++------------ GPU/Directx9/GPU_DX9.h | 1 - GPU/Directx9/ShaderManagerDX9.cpp | 5 ++--- GPU/Directx9/ShaderManagerDX9.h | 5 ++++- GPU/Directx9/TextureCacheDX9.h | 3 +++ GPU/GLES/GPU_GLES.cpp | 35 ++++++++++++++----------------- GPU/GLES/ShaderManagerGLES.cpp | 2 +- GPU/GLES/ShaderManagerGLES.h | 6 +++--- GPU/GLES/TextureCacheGLES.h | 4 ++-- GPU/GPUCommonHW.cpp | 6 +++++- GPU/Vulkan/GPU_Vulkan.cpp | 23 ++++++++------------ GPU/Vulkan/GPU_Vulkan.h | 1 - GPU/Vulkan/ShaderManagerVulkan.h | 4 ++-- GPU/Vulkan/TextureCacheVulkan.cpp | 8 ------- GPU/Vulkan/TextureCacheVulkan.h | 1 - GPU/Vulkan/VulkanUtil.cpp | 3 --- GPU/Vulkan/VulkanUtil.h | 1 - 23 files changed, 80 insertions(+), 87 deletions(-) diff --git a/GPU/Common/ShaderCommon.h b/GPU/Common/ShaderCommon.h index 73f748003e..025576ea6f 100644 --- a/GPU/Common/ShaderCommon.h +++ b/GPU/Common/ShaderCommon.h @@ -126,8 +126,12 @@ public: ShaderManagerCommon(Draw::DrawContext *draw) : draw_(draw) {} virtual ~ShaderManagerCommon() {} + virtual void ClearShaders() = 0; virtual void DirtyLastShader() = 0; + virtual void DeviceLost() = 0; + virtual void DeviceRestore(Draw::DrawContext *draw) = 0; // must set draw_ to draw + protected: Draw::DrawContext *draw_ = nullptr; }; diff --git a/GPU/Common/TextureCacheCommon.cpp b/GPU/Common/TextureCacheCommon.cpp index 6611c21156..5a88a718b0 100644 --- a/GPU/Common/TextureCacheCommon.cpp +++ b/GPU/Common/TextureCacheCommon.cpp @@ -138,6 +138,10 @@ TextureCacheCommon::~TextureCacheCommon() { FreeAlignedMemory(expandClut_); } +void TextureCacheCommon::StartFrame() { + textureShaderCache_->Decimate(); +} + // Produces a signed 1.23.8 value. static int TexLog2(float delta) { union FloatBits { @@ -2906,7 +2910,3 @@ CheckAlphaResult TextureCacheCommon::CheckCLUTAlpha(const uint8_t *pixelData, GE return CheckAlpha32((const u32 *)pixelData, w, 0xFF000000); } } - -void TextureCacheCommon::StartFrame() { - textureShaderCache_->Decimate(); -} diff --git a/GPU/Common/TextureCacheCommon.h b/GPU/Common/TextureCacheCommon.h index f85e09b9a4..ec45251fa8 100644 --- a/GPU/Common/TextureCacheCommon.h +++ b/GPU/Common/TextureCacheCommon.h @@ -350,6 +350,11 @@ public: } virtual bool GetCurrentTextureDebug(GPUDebugBuffer &buffer, int level, bool *isFramebuffer) { return false; } + virtual void StartFrame(); + + virtual void DeviceLost() = 0; + virtual void DeviceRestore(Draw::DrawContext *draw) = 0; + protected: virtual void *GetNativeTextureView(const TexCacheEntry *entry) = 0; bool PrepareBuildTexture(BuildTexturePlan &plan, TexCacheEntry *entry); @@ -403,8 +408,6 @@ protected: virtual void BoundFramebufferTexture() {} - virtual void StartFrame(); - void DecimateVideos(); bool IsVideo(u32 texaddr) const; diff --git a/GPU/D3D11/GPU_D3D11.cpp b/GPU/D3D11/GPU_D3D11.cpp index d20b36edbd..1b58db17c8 100644 --- a/GPU/D3D11/GPU_D3D11.cpp +++ b/GPU/D3D11/GPU_D3D11.cpp @@ -120,9 +120,9 @@ void GPU_D3D11::DeviceLost() { draw_->Invalidate(InvalidationFlags::CACHED_RENDER_STATE); // Simply drop all caches and textures. // FBOs appear to survive? Or no? - shaderManagerD3D11_->ClearShaders(); + shaderManager_->ClearShaders(); drawEngine_.ClearInputLayoutMap(); - textureCacheD3D11_->Clear(false); + textureCache_->Clear(false); GPUCommon::DeviceLost(); } @@ -141,19 +141,19 @@ void GPU_D3D11::InitClear() { void GPU_D3D11::BeginFrame() { GPUCommon::BeginFrame(); - textureCacheD3D11_->StartFrame(); + textureCache_->StartFrame(); drawEngine_.BeginFrame(); - shaderManagerD3D11_->DirtyLastShader(); + shaderManager_->DirtyLastShader(); - framebufferManagerD3D11_->BeginFrame(); + framebufferManager_->BeginFrame(); gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); if (gstate_c.useFlagsChanged) { // TODO: It'd be better to recompile them in the background, probably? // This most likely means that saw equal depth changed. WARN_LOG(G3D, "Shader use flags changed, clearing all shaders and depth buffers"); - shaderManagerD3D11_->ClearShaders(); + shaderManager_->ClearShaders(); framebufferManager_->ClearAllDepthBuffers(); drawEngine_.ClearInputLayoutMap(); gstate_c.useFlagsChanged = false; diff --git a/GPU/D3D11/ShaderManagerD3D11.h b/GPU/D3D11/ShaderManagerD3D11.h index 75203f9533..5dacd408a5 100644 --- a/GPU/D3D11/ShaderManagerD3D11.h +++ b/GPU/D3D11/ShaderManagerD3D11.h @@ -86,9 +86,11 @@ public: ~ShaderManagerD3D11(); void GetShaders(int prim, VertexDecoder *decoder, D3D11VertexShader **vshader, D3D11FragmentShader **fshader, const ComputedPipelineState &pipelineState, bool useHWTransform, bool useHWTessellation, bool weightsAsFloat, bool useSkinInDecode); - void ClearShaders(); + void ClearShaders() override; void DirtyLastShader() override; + void DeviceLost() override {} + void DeviceRestore(Draw::DrawContext *draw) override { draw_ = draw; } int GetNumVertexShaders() const { return (int)vsCache_.size(); } int GetNumFragmentShaders() const { return (int)fsCache_.size(); } diff --git a/GPU/D3D11/TextureCacheD3D11.h b/GPU/D3D11/TextureCacheD3D11.h index 4cb01375ff..8c2ff77f62 100644 --- a/GPU/D3D11/TextureCacheD3D11.h +++ b/GPU/D3D11/TextureCacheD3D11.h @@ -54,6 +54,9 @@ public: bool GetCurrentTextureDebug(GPUDebugBuffer &buffer, int level, bool *isFramebuffer) override; + void DeviceLost() override {} + void DeviceRestore(Draw::DrawContext *draw) override { draw_ = draw; } + protected: void BindTexture(TexCacheEntry *entry) override; void Unbind() override; diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index 96ea5ae435..b857fcfa80 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -106,25 +106,20 @@ u32 GPU_DX9::CheckGPUFeatures() const { } GPU_DX9::~GPU_DX9() { - framebufferManagerDX9_->DestroyAllFBOs(); - delete framebufferManagerDX9_; + framebufferManager_->DestroyAllFBOs(); + delete framebufferManager_; delete textureCache_; - shaderManagerDX9_->ClearCache(true); - delete shaderManagerDX9_; + shaderManager_->ClearShaders(); + delete shaderManager_; } void GPU_DX9::DeviceLost() { // Simply drop all caches and textures. - shaderManagerDX9_->ClearCache(false); - textureCacheDX9_->Clear(false); + shaderManager_->ClearShaders(); + textureCache_->Clear(false); GPUCommon::DeviceLost(); } -void GPU_DX9::DeviceRestore() { - GPUCommon::DeviceRestore(); - // Nothing needed. -} - void GPU_DX9::InitClear() { if (!framebufferManager_->UseBufferedRendering()) { dxstate.depthWrite.set(true); @@ -139,7 +134,7 @@ void GPU_DX9::ReapplyGfxState() { } void GPU_DX9::BeginFrame() { - textureCacheDX9_->StartFrame(); + textureCache_->StartFrame(); drawEngine_.BeginFrame(); GPUCommon::BeginFrame(); @@ -151,7 +146,7 @@ void GPU_DX9::BeginFrame() { // TODO: It'd be better to recompile them in the background, probably? // This most likely means that saw equal depth changed. WARN_LOG(G3D, "Shader use flags changed, clearing all shaders and depth buffers"); - shaderManagerDX9_->ClearCache(true); + shaderManager_->ClearShaders(); framebufferManager_->ClearAllDepthBuffers(); gstate_c.useFlagsChanged = false; } diff --git a/GPU/Directx9/GPU_DX9.h b/GPU/Directx9/GPU_DX9.h index 6d1001d90c..7e1132175e 100644 --- a/GPU/Directx9/GPU_DX9.h +++ b/GPU/Directx9/GPU_DX9.h @@ -40,7 +40,6 @@ public: void ReapplyGfxState() override; void GetStats(char *buffer, size_t bufsize) override; void DeviceLost() override; // Only happens on Android. Drop all textures and shaders. - void DeviceRestore() override; // Using string because it's generic - makes no assumptions on the size of the shader IDs of this backend. std::vector DebugGetShaderIDs(DebugShaderType shader) override; diff --git a/GPU/Directx9/ShaderManagerDX9.cpp b/GPU/Directx9/ShaderManagerDX9.cpp index 1571d517bd..dee68027b1 100644 --- a/GPU/Directx9/ShaderManagerDX9.cpp +++ b/GPU/Directx9/ShaderManagerDX9.cpp @@ -540,11 +540,10 @@ void ShaderManagerDX9::Clear() { DirtyShader(); } -void ShaderManagerDX9::ClearCache(bool deleteThem) { +void ShaderManagerDX9::ClearShaders() { Clear(); } - void ShaderManagerDX9::DirtyShader() { // Forget the last shader ID lastFSID_.set_invalid(); @@ -554,7 +553,7 @@ void ShaderManagerDX9::DirtyShader() { gstate_c.Dirty(DIRTY_ALL_UNIFORMS | DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE); } -void ShaderManagerDX9::DirtyLastShader() { // disables vertex arrays +void ShaderManagerDX9::DirtyLastShader() { lastVShader_ = nullptr; lastPShader_ = nullptr; } diff --git a/GPU/Directx9/ShaderManagerDX9.h b/GPU/Directx9/ShaderManagerDX9.h index 299eb677d2..a0ccce98ed 100644 --- a/GPU/Directx9/ShaderManagerDX9.h +++ b/GPU/Directx9/ShaderManagerDX9.h @@ -77,7 +77,7 @@ public: ShaderManagerDX9(Draw::DrawContext *draw, LPDIRECT3DDEVICE9 device); ~ShaderManagerDX9(); - void ClearCache(bool deleteThem); // TODO: deleteThem currently not respected + void ClearShaders() override; VSShader *ApplyShader(bool useHWTransform, bool useHWTessellation, VertexDecoder *decoder, bool weightsAsFloat, bool useSkinInDecode, const ComputedPipelineState &pipelineState); void DirtyShader(); void DirtyLastShader() override; @@ -85,6 +85,9 @@ public: int GetNumVertexShaders() const { return (int)vsCache_.size(); } int GetNumFragmentShaders() const { return (int)fsCache_.size(); } + void DeviceLost() override {} + void DeviceRestore(Draw::DrawContext *draw) override { draw_ = draw; } + std::vector DebugGetShaderIDs(DebugShaderType type); std::string DebugGetShaderString(std::string id, DebugShaderType type, DebugShaderStringType stringType); diff --git a/GPU/Directx9/TextureCacheDX9.h b/GPU/Directx9/TextureCacheDX9.h index 0080fbdef3..8b2a9eaec8 100644 --- a/GPU/Directx9/TextureCacheDX9.h +++ b/GPU/Directx9/TextureCacheDX9.h @@ -42,6 +42,9 @@ public: bool GetCurrentTextureDebug(GPUDebugBuffer &buffer, int level, bool *isFramebuffer) override; + void DeviceLost() override {} + void DeviceRestore(Draw::DrawContext *draw) override { draw_ = draw; } + protected: void BindTexture(TexCacheEntry *entry) override; void Unbind() override; diff --git a/GPU/GLES/GPU_GLES.cpp b/GPU/GLES/GPU_GLES.cpp index 2cb6a88504..4d5abeadb7 100644 --- a/GPU/GLES/GPU_GLES.cpp +++ b/GPU/GLES/GPU_GLES.cpp @@ -139,17 +139,14 @@ GPU_GLES::~GPU_GLES() { } } - framebufferManagerGL_->DestroyAllFBOs(); - shaderManagerGL_->ClearCache(true); + framebufferManager_->DestroyAllFBOs(); + shaderManager_->ClearShaders(); fragmentTestCache_.Clear(); - delete shaderManagerGL_; - shaderManagerGL_ = nullptr; - delete framebufferManagerGL_; - delete textureCacheGL_; - - // Clear features so they're not visible in system info. - gstate_c.SetUseFlags(0); + delete shaderManager_; + shaderManager_ = nullptr; + delete framebufferManager_; + delete textureCache_; } // Take the raw GL extension and versioning data and turn into feature flags. @@ -249,8 +246,8 @@ void GPU_GLES::DeviceLost() { // FBOs appear to survive? Or no? // TransformDraw has registered as a GfxResourceHolder. CancelReady(); - shaderManagerGL_->DeviceLost(); - textureCacheGL_->DeviceLost(); + shaderManager_->DeviceLost(); + textureCache_->DeviceLost(); fragmentTestCache_.DeviceLost(); drawEngine_.DeviceLost(); @@ -263,8 +260,8 @@ void GPU_GLES::DeviceRestore() { UpdateCmdInfo(); UpdateVsyncInterval(true); - shaderManagerGL_->DeviceRestore(draw_); - textureCacheGL_->DeviceRestore(draw_); + shaderManager_->DeviceRestore(draw_); + textureCache_->DeviceRestore(draw_); drawEngine_.DeviceRestore(draw_); fragmentTestCache_.DeviceRestore(draw_); } @@ -284,7 +281,7 @@ void GPU_GLES::BeginHostFrame() { // TODO: It'd be better to recompile them in the background, probably? // This most likely means that saw equal depth changed. WARN_LOG(G3D, "Shader use flags changed, clearing all shaders and depth buffers"); - shaderManagerGL_->ClearCache(true); + shaderManager_->ClearShaders(); framebufferManager_->ClearAllDepthBuffers(); gstate_c.useFlagsChanged = false; } @@ -299,22 +296,22 @@ void GPU_GLES::ReapplyGfxState() { } void GPU_GLES::BeginFrame() { - textureCacheGL_->StartFrame(); - fragmentTestCache_.Decimate(); - GPUCommon::BeginFrame(); + textureCache_->StartFrame(); + // Save the cache from time to time. TODO: How often? We save on exit, so shouldn't need to do this all that often. if (shaderCachePath_.Valid() && (gpuStats.numFlips & 4095) == 0) { shaderManagerGL_->SaveCache(shaderCachePath_, &drawEngine_); } - shaderManagerGL_->DirtyShader(); // Not sure if this is really needed. gstate_c.Dirty(DIRTY_ALL_UNIFORMS); - framebufferManagerGL_->BeginFrame(); + framebufferManager_->BeginFrame(); + + fragmentTestCache_.Decimate(); } void GPU_GLES::FinishDeferred() { diff --git a/GPU/GLES/ShaderManagerGLES.cpp b/GPU/GLES/ShaderManagerGLES.cpp index d80cfb494f..e050b9381a 100644 --- a/GPU/GLES/ShaderManagerGLES.cpp +++ b/GPU/GLES/ShaderManagerGLES.cpp @@ -715,7 +715,7 @@ void ShaderManagerGLES::Clear() { DirtyShader(); } -void ShaderManagerGLES::ClearCache(bool deleteThem) { +void ShaderManagerGLES::ClearShaders() { // TODO: Recreate all from the diskcache when we come back. Clear(); } diff --git a/GPU/GLES/ShaderManagerGLES.h b/GPU/GLES/ShaderManagerGLES.h index b37604ba5d..6435b44d7d 100644 --- a/GPU/GLES/ShaderManagerGLES.h +++ b/GPU/GLES/ShaderManagerGLES.h @@ -165,15 +165,15 @@ public: ShaderManagerGLES(Draw::DrawContext *draw); ~ShaderManagerGLES(); - void ClearCache(bool deleteThem); // TODO: deleteThem currently not respected + void ClearShaders() override; // This is the old ApplyShader split into two parts, because of annoying information dependencies. // If you call ApplyVertexShader, you MUST call ApplyFragmentShader soon afterwards. Shader *ApplyVertexShader(bool useHWTransform, bool useHWTessellation, VertexDecoder *vertexDecoder, bool weightsAsFloat, bool useSkinInDecode, VShaderID *VSID); LinkedShader *ApplyFragmentShader(VShaderID VSID, Shader *vs, const ComputedPipelineState &pipelineState, bool useBufferedRendering); - void DeviceLost(); - void DeviceRestore(Draw::DrawContext *draw); + void DeviceLost() override; + void DeviceRestore(Draw::DrawContext *draw) override; void DirtyShader(); void DirtyLastShader() override; diff --git a/GPU/GLES/TextureCacheGLES.h b/GPU/GLES/TextureCacheGLES.h index 2546c605b9..6f90475ed1 100644 --- a/GPU/GLES/TextureCacheGLES.h +++ b/GPU/GLES/TextureCacheGLES.h @@ -54,8 +54,8 @@ public: bool GetCurrentTextureDebug(GPUDebugBuffer &buffer, int level, bool *isFramebuffer) override; - void DeviceLost(); - void DeviceRestore(Draw::DrawContext *draw); + void DeviceLost() override; + void DeviceRestore(Draw::DrawContext *draw) override; protected: void BindTexture(TexCacheEntry *entry) override; diff --git a/GPU/GPUCommonHW.cpp b/GPU/GPUCommonHW.cpp index 6c98d9f44c..8f587d6f77 100644 --- a/GPU/GPUCommonHW.cpp +++ b/GPU/GPUCommonHW.cpp @@ -10,7 +10,11 @@ #include "GPU/Common/FramebufferManagerCommon.h" GPUCommonHW::GPUCommonHW(GraphicsContext *gfxCtx, Draw::DrawContext *draw) : GPUCommon(gfxCtx, draw) {} -GPUCommonHW::~GPUCommonHW() {} + +GPUCommonHW::~GPUCommonHW() { + // Clear features so they're not visible in system info. + gstate_c.SetUseFlags(0); +} void GPUCommonHW::PreExecuteOp(u32 op, u32 diff) { CheckFlushOp(op >> 24, diff); diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index faed3b7e4c..11d7b562cc 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -187,10 +187,10 @@ GPU_Vulkan::~GPU_Vulkan() { DestroyDeviceObjects(); framebufferManagerVulkan_->DestroyAllFBOs(); drawEngine_.DeviceLost(); - delete textureCacheVulkan_; + delete textureCache_; delete pipelineManager_; - delete shaderManagerVulkan_; - delete framebufferManagerVulkan_; + delete shaderManager_; + delete framebufferManager_; } u32 GPU_Vulkan::CheckGPUFeatures() const { @@ -292,7 +292,7 @@ void GPU_Vulkan::BeginHostFrame() { GPUCommon::BeginHostFrame(); drawEngine_.BeginFrame(); - textureCacheVulkan_->StartFrame(); + textureCache_->StartFrame(); VulkanContext *vulkan = (VulkanContext *)draw_->GetNativeObject(Draw::NativeObject::CONTEXT); int curFrame = vulkan->GetCurFrame(); @@ -301,7 +301,7 @@ void GPU_Vulkan::BeginHostFrame() { frame.push_->Reset(); frame.push_->Begin(vulkan); - framebufferManagerVulkan_->BeginFrame(); + framebufferManager_->BeginFrame(); textureCacheVulkan_->SetPushBuffer(frameData_[curFrame].push_); shaderManagerVulkan_->DirtyShader(); @@ -313,7 +313,7 @@ void GPU_Vulkan::BeginHostFrame() { WARN_LOG(G3D, "Shader use flags changed, clearing all shaders and depth buffers"); // TODO: Not all shaders need to be recompiled. In fact, quite few? Of course, depends on // the use flag change.. This is a major frame rate hitch in the start of a race in Outrun. - shaderManagerVulkan_->ClearShaders(); + shaderManager_->ClearShaders(); pipelineManager_->Clear(); framebufferManager_->ClearAllDepthBuffers(); gstate_c.useFlagsChanged = false; @@ -335,7 +335,6 @@ void GPU_Vulkan::EndHostFrame() { frame.push_->End(); drawEngine_.EndFrame(); - textureCacheVulkan_->EndFrame(); GPUCommon::EndHostFrame(); } @@ -391,10 +390,6 @@ void GPU_Vulkan::BuildReportingInfo() { Reporting::UpdateConfig(); } -void GPU_Vulkan::Reinitialize() { - GPUCommon::Reinitialize(); -} - void GPU_Vulkan::InitClear() { if (!framebufferManager_->UseBufferedRendering()) { // TODO? @@ -450,8 +445,8 @@ void GPU_Vulkan::DestroyDeviceObjects() { } void GPU_Vulkan::CheckRenderResized() { + GPUCommon::CheckRenderResized(); if (renderResized_) { - GPUCommon::CheckRenderResized(); pipelineManager_->InvalidateMSAAPipelines(); framebufferManager_->ReleasePipelines(); } @@ -471,11 +466,11 @@ void GPU_Vulkan::DeviceLost() { textureCacheVulkan_->DeviceLost(); shaderManagerVulkan_->DeviceLost(); - GPUCommon::DeviceLost(); + GPUCommonHW::DeviceLost(); } void GPU_Vulkan::DeviceRestore() { - GPUCommon::DeviceRestore(); + GPUCommonHW::DeviceRestore(); InitDeviceObjects(); gstate_c.SetUseFlags(CheckGPUFeatures()); diff --git a/GPU/Vulkan/GPU_Vulkan.h b/GPU/Vulkan/GPU_Vulkan.h index f468ec8b68..6892eafa58 100644 --- a/GPU/Vulkan/GPU_Vulkan.h +++ b/GPU/Vulkan/GPU_Vulkan.h @@ -68,7 +68,6 @@ protected: private: void BuildReportingInfo() override; void InitClear() override; - void Reinitialize() override; void InitDeviceObjects(); void DestroyDeviceObjects(); diff --git a/GPU/Vulkan/ShaderManagerVulkan.h b/GPU/Vulkan/ShaderManagerVulkan.h index 91544124f3..a29ea06be3 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.h +++ b/GPU/Vulkan/ShaderManagerVulkan.h @@ -114,8 +114,8 @@ public: ShaderManagerVulkan(Draw::DrawContext *draw); ~ShaderManagerVulkan(); - void DeviceLost(); - void DeviceRestore(Draw::DrawContext *draw); + void DeviceLost() override; + void DeviceRestore(Draw::DrawContext *draw) override; void GetShaders(int prim, VertexDecoder *decoder, VulkanVertexShader **vshader, VulkanFragmentShader **fshader, VulkanGeometryShader **gshader, const ComputedPipelineState &pipelineState, bool useHWTransform, bool useHWTessellation, bool weightsAsFloat, bool useSkinInDecode); void ClearShaders(); diff --git a/GPU/Vulkan/TextureCacheVulkan.cpp b/GPU/Vulkan/TextureCacheVulkan.cpp index 349d608c3a..da69158dc3 100644 --- a/GPU/Vulkan/TextureCacheVulkan.cpp +++ b/GPU/Vulkan/TextureCacheVulkan.cpp @@ -352,14 +352,6 @@ void TextureCacheVulkan::StartFrame() { computeShaderManager_.BeginFrame(); } -void TextureCacheVulkan::EndFrame() { - computeShaderManager_.EndFrame(); - - if (texelsScaledThisFrame_) { - VERBOSE_LOG(G3D, "Scaled %i texels", texelsScaledThisFrame_); - } -} - void TextureCacheVulkan::UpdateCurrentClut(GEPaletteFormat clutFormat, u32 clutBase, bool clutIndexIsSimple) { const u32 clutBaseBytes = clutFormat == GE_CMODE_32BIT_ABGR8888 ? (clutBase * sizeof(u32)) : (clutBase * sizeof(u16)); // Technically, these extra bytes weren't loaded, but hopefully it was loaded earlier. diff --git a/GPU/Vulkan/TextureCacheVulkan.h b/GPU/Vulkan/TextureCacheVulkan.h index 3654101b90..2c7c149ef6 100644 --- a/GPU/Vulkan/TextureCacheVulkan.h +++ b/GPU/Vulkan/TextureCacheVulkan.h @@ -58,7 +58,6 @@ public: ~TextureCacheVulkan(); void StartFrame() override; - void EndFrame(); void DeviceLost(); void DeviceRestore(Draw::DrawContext *draw); diff --git a/GPU/Vulkan/VulkanUtil.cpp b/GPU/Vulkan/VulkanUtil.cpp index c47fd21d9c..0d87ebc153 100644 --- a/GPU/Vulkan/VulkanUtil.cpp +++ b/GPU/Vulkan/VulkanUtil.cpp @@ -208,6 +208,3 @@ void VulkanComputeShaderManager::BeginFrame() { FrameData &frame = frameData_[curFrame]; frame.descPool.Reset(); } - -void VulkanComputeShaderManager::EndFrame() { -} diff --git a/GPU/Vulkan/VulkanUtil.h b/GPU/Vulkan/VulkanUtil.h index 8663d3ce1e..2046f6201f 100644 --- a/GPU/Vulkan/VulkanUtil.h +++ b/GPU/Vulkan/VulkanUtil.h @@ -61,7 +61,6 @@ public: VkPipelineLayout GetPipelineLayout() const { return pipelineLayout_; } void BeginFrame(); - void EndFrame(); private: void InitDeviceObjects(Draw::DrawContext *draw);