1 // Copyright (c) 2015- PPSSPP Project.
2
3 // This program is free software: you can redistribute it and/or modify
4 // it under the terms of the GNU General Public License as published by
5 // the Free Software Foundation, version 2.0 or later versions.
6
7 // This program is distributed in the hope that it will be useful,
8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 // GNU General Public License 2.0 for more details.
11
12 // A copy of the GPL 2.0 should have been included with the program.
13 // If not, see http://www.gnu.org/licenses/
14
15 // Official git repository and contact information can be found at
16 // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
17
18 #include <algorithm>
19
20 #include "Common/Profiler/Profiler.h"
21
22 #include "Common/System/Display.h"
23 #include "Common/Math/lin/matrix4x4.h"
24 #include "Common/Data/Convert/ColorConv.h"
25 #include "Common/Data/Convert/SmallDataConvert.h"
26 #include "Common/GPU/thin3d.h"
27
28 #include "Common/GPU/Vulkan/VulkanContext.h"
29 #include "Common/GPU/Vulkan/VulkanMemory.h"
30 #include "Common/GPU/Vulkan/VulkanImage.h"
31 #include "Common/GPU/Vulkan/VulkanRenderManager.h"
32 #include "Core/MemMap.h"
33 #include "Core/Config.h"
34 #include "Core/ConfigValues.h"
35 #include "Core/System.h"
36 #include "Core/Reporting.h"
37 #include "Core/HLE/sceDisplay.h"
38 #include "GPU/ge_constants.h"
39 #include "GPU/GPUInterface.h"
40 #include "GPU/GPUState.h"
41
42 #include "GPU/Common/TextureDecoder.h"
43 #include "GPU/Common/FramebufferManagerCommon.h"
44 #include "GPU/Debugger/Stepping.h"
45 #include "GPU/Vulkan/FramebufferManagerVulkan.h"
46 #include "GPU/Vulkan/DrawEngineVulkan.h"
47 #include "GPU/Vulkan/TextureCacheVulkan.h"
48 #include "GPU/Vulkan/ShaderManagerVulkan.h"
49 #include "GPU/Vulkan/VulkanUtil.h"
50
51 using namespace PPSSPP_VK;
52
53 static const char tex_fs[] = R"(#version 450
54 #extension GL_ARB_separate_shader_objects : enable
55 #extension GL_ARB_shading_language_420pack : enable
56 layout (binding = 0) uniform sampler2D sampler0;
57 layout (location = 0) in vec2 v_texcoord0;
58 layout (location = 0) out vec4 fragColor;
59 void main() {
60 fragColor = texture(sampler0, v_texcoord0);
61 }
62 )";
63
64 static const char tex_vs[] = R"(#version 450
65 #extension GL_ARB_separate_shader_objects : enable
66 #extension GL_ARB_shading_language_420pack : enable
67 layout (location = 0) in vec3 a_position;
68 layout (location = 1) in vec2 a_texcoord0;
69 layout (location = 0) out vec2 v_texcoord0;
70 out gl_PerVertex { vec4 gl_Position; };
71 void main() {
72 v_texcoord0 = a_texcoord0;
73 gl_Position = vec4(a_position, 1.0);
74 }
75 )";
76
FramebufferManagerVulkan(Draw::DrawContext * draw,VulkanContext * vulkan)77 FramebufferManagerVulkan::FramebufferManagerVulkan(Draw::DrawContext *draw, VulkanContext *vulkan) :
78 FramebufferManagerCommon(draw),
79 vulkan_(vulkan) {
80 presentation_->SetLanguage(GLSL_VULKAN);
81
82 InitDeviceObjects();
83
84 // After a blit we do need to rebind for the VulkanRenderManager to know what to do.
85 needGLESRebinds_ = true;
86 }
87
~FramebufferManagerVulkan()88 FramebufferManagerVulkan::~FramebufferManagerVulkan() {
89 DeviceLost();
90 }
91
SetTextureCache(TextureCacheVulkan * tc)92 void FramebufferManagerVulkan::SetTextureCache(TextureCacheVulkan *tc) {
93 textureCacheVulkan_ = tc;
94 textureCache_ = tc;
95 }
96
SetShaderManager(ShaderManagerVulkan * sm)97 void FramebufferManagerVulkan::SetShaderManager(ShaderManagerVulkan *sm) {
98 shaderManagerVulkan_ = sm;
99 shaderManager_ = sm;
100 }
101
SetDrawEngine(DrawEngineVulkan * td)102 void FramebufferManagerVulkan::SetDrawEngine(DrawEngineVulkan *td) {
103 drawEngineVulkan_ = td;
104 drawEngine_ = td;
105 }
106
InitDeviceObjects()107 void FramebufferManagerVulkan::InitDeviceObjects() {
108 std::string fs_errors, vs_errors;
109 fsBasicTex_ = CompileShaderModule(vulkan_, VK_SHADER_STAGE_FRAGMENT_BIT, tex_fs, &fs_errors);
110 vsBasicTex_ = CompileShaderModule(vulkan_, VK_SHADER_STAGE_VERTEX_BIT, tex_vs, &vs_errors);
111 _assert_(fsBasicTex_ != VK_NULL_HANDLE);
112 _assert_(vsBasicTex_ != VK_NULL_HANDLE);
113
114 VkSamplerCreateInfo samp = { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
115 samp.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
116 samp.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
117 samp.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
118 samp.magFilter = VK_FILTER_NEAREST;
119 samp.minFilter = VK_FILTER_NEAREST;
120 VkResult res = vkCreateSampler(vulkan_->GetDevice(), &samp, nullptr, &nearestSampler_);
121 _assert_(res == VK_SUCCESS);
122 samp.magFilter = VK_FILTER_LINEAR;
123 samp.minFilter = VK_FILTER_LINEAR;
124 res = vkCreateSampler(vulkan_->GetDevice(), &samp, nullptr, &linearSampler_);
125 _assert_(res == VK_SUCCESS);
126 }
127
DestroyDeviceObjects()128 void FramebufferManagerVulkan::DestroyDeviceObjects() {
129 if (fsBasicTex_ != VK_NULL_HANDLE) {
130 vulkan2D_->PurgeFragmentShader(fsBasicTex_);
131 vulkan_->Delete().QueueDeleteShaderModule(fsBasicTex_);
132 }
133 if (vsBasicTex_ != VK_NULL_HANDLE) {
134 vulkan2D_->PurgeVertexShader(vsBasicTex_);
135 vulkan_->Delete().QueueDeleteShaderModule(vsBasicTex_);
136 }
137 if (stencilFs_ != VK_NULL_HANDLE) {
138 vulkan2D_->PurgeFragmentShader(stencilFs_);
139 vulkan_->Delete().QueueDeleteShaderModule(stencilFs_);
140 }
141 if (stencilVs_ != VK_NULL_HANDLE) {
142 vulkan2D_->PurgeVertexShader(stencilVs_);
143 vulkan_->Delete().QueueDeleteShaderModule(stencilVs_);
144 }
145
146 if (linearSampler_ != VK_NULL_HANDLE)
147 vulkan_->Delete().QueueDeleteSampler(linearSampler_);
148 if (nearestSampler_ != VK_NULL_HANDLE)
149 vulkan_->Delete().QueueDeleteSampler(nearestSampler_);
150 }
151
NotifyClear(bool clearColor,bool clearAlpha,bool clearDepth,uint32_t color,float depth)152 void FramebufferManagerVulkan::NotifyClear(bool clearColor, bool clearAlpha, bool clearDepth, uint32_t color, float depth) {
153 int mask = 0;
154 // The Clear detection takes care of doing a regular draw instead if separate masking
155 // of color and alpha is needed, so we can just treat them as the same.
156 if (clearColor || clearAlpha)
157 mask |= Draw::FBChannel::FB_COLOR_BIT;
158 if (clearDepth)
159 mask |= Draw::FBChannel::FB_DEPTH_BIT;
160 if (clearAlpha)
161 mask |= Draw::FBChannel::FB_STENCIL_BIT;
162
163 // Note that since the alpha channel and the stencil channel are shared on the PSP,
164 // when we clear alpha, we also clear stencil to the same value.
165 draw_->Clear(mask, color, depth, color >> 24);
166 if (clearColor || clearAlpha) {
167 SetColorUpdated(gstate_c.skipDrawReason);
168 }
169 if (clearDepth) {
170 SetDepthUpdated();
171 }
172 }
173
DrawActiveTexture(float x,float y,float w,float h,float destW,float destH,float u0,float v0,float u1,float v1,int uvRotation,int flags)174 void FramebufferManagerVulkan::DrawActiveTexture(float x, float y, float w, float h, float destW, float destH, float u0, float v0, float u1, float v1, int uvRotation, int flags) {
175 float texCoords[8] = {
176 u0,v0,
177 u1,v0,
178 u1,v1,
179 u0,v1,
180 };
181
182 if (uvRotation != ROTATION_LOCKED_HORIZONTAL) {
183 float temp[8];
184 int rotation = 0;
185 switch (uvRotation) {
186 case ROTATION_LOCKED_HORIZONTAL180: rotation = 4; break;
187 case ROTATION_LOCKED_VERTICAL: rotation = 2; break;
188 case ROTATION_LOCKED_VERTICAL180: rotation = 6; break;
189 }
190 for (int i = 0; i < 8; i++) {
191 temp[i] = texCoords[(i + rotation) & 7];
192 }
193 memcpy(texCoords, temp, sizeof(temp));
194 }
195
196 Vulkan2D::Vertex vtx[4] = {
197 {x, y, 0, texCoords[0], texCoords[1]},
198 {x + w, y, 0, texCoords[2], texCoords[3]},
199 {x, y + h, 0, texCoords[6], texCoords[7]},
200 {x + w, y + h, 0, texCoords[4], texCoords[5]},
201 };
202
203 float invDestW = 1.0f / (destW * 0.5f);
204 float invDestH = 1.0f / (destH * 0.5f);
205 for (int i = 0; i < 4; i++) {
206 vtx[i].x = vtx[i].x * invDestW - 1.0f;
207 vtx[i].y = vtx[i].y * invDestH - 1.0f;
208 }
209
210 if ((flags & DRAWTEX_TO_BACKBUFFER) && g_display_rotation != DisplayRotation::ROTATE_0) {
211 for (int i = 0; i < 4; i++) {
212 Lin::Vec3 v(vtx[i].x, vtx[i].y, 0.0f);
213 // backwards notation, should fix that...
214 v = v * g_display_rot_matrix;
215 vtx[i].x = v.x;
216 vtx[i].y = v.y;
217 }
218 }
219
220 draw_->FlushState();
221
222 // TODO: Should probably use draw_ directly and not go low level
223
224 VulkanRenderManager *renderManager = (VulkanRenderManager *)draw_->GetNativeObject(Draw::NativeObject::RENDER_MANAGER);
225
226 VkImageView view = (VkImageView)draw_->GetNativeObject(Draw::NativeObject::BOUND_TEXTURE0_IMAGEVIEW);
227 VkDescriptorSet descSet = vulkan2D_->GetDescriptorSet(view, (flags & DRAWTEX_LINEAR) ? linearSampler_ : nearestSampler_, VK_NULL_HANDLE, VK_NULL_HANDLE);
228 VkBuffer vbuffer;
229 VkDeviceSize offset = push_->Push(vtx, sizeof(vtx), &vbuffer);
230 renderManager->BindPipeline(cur2DPipeline_, (PipelineFlags)0);
231 renderManager->Draw(vulkan2D_->GetPipelineLayout(), descSet, 0, nullptr, vbuffer, offset, 4);
232 }
233
Bind2DShader()234 void FramebufferManagerVulkan::Bind2DShader() {
235 VkRenderPass rp = (VkRenderPass)draw_->GetNativeObject(Draw::NativeObject::COMPATIBLE_RENDERPASS);
236 cur2DPipeline_ = vulkan2D_->GetPipeline(rp, vsBasicTex_, fsBasicTex_);
237 }
238
BlitFramebuffer(VirtualFramebuffer * dst,int dstX,int dstY,VirtualFramebuffer * src,int srcX,int srcY,int w,int h,int bpp,const char * tag)239 void FramebufferManagerVulkan::BlitFramebuffer(VirtualFramebuffer *dst, int dstX, int dstY, VirtualFramebuffer *src, int srcX, int srcY, int w, int h, int bpp, const char *tag) {
240 if (!dst->fbo || !src->fbo || !useBufferedRendering_) {
241 // This can happen if they recently switched from non-buffered.
242 if (useBufferedRendering_) {
243 draw_->BindFramebufferAsRenderTarget(nullptr, { Draw::RPAction::KEEP, Draw::RPAction::KEEP, Draw::RPAction::KEEP }, "BlitFramebuffer_Fail");
244 gstate_c.Dirty(DIRTY_VIEWPORTSCISSOR_STATE);
245 }
246 return;
247 }
248
249 // Perform a little bit of clipping first.
250 // Block transfer coords are unsigned so I don't think we need to clip on the left side..
251 if (dstX + w > dst->bufferWidth) {
252 w -= dstX + w - dst->bufferWidth;
253 }
254 if (dstY + h > dst->bufferHeight) {
255 h -= dstY + h - dst->bufferHeight;
256 }
257 if (srcX + w > src->bufferWidth) {
258 w -= srcX + w - src->bufferWidth;
259 }
260 if (srcY + h > src->bufferHeight) {
261 h -= srcY + h - src->bufferHeight;
262 }
263
264 if (w <= 0 || h <= 0) {
265 // The whole rectangle got clipped.
266 return;
267 }
268
269 float srcXFactor = (float)src->renderScaleFactor;
270 float srcYFactor = (float)src->renderScaleFactor;
271
272 // Some games use wrong-format block transfers. Simulate that.
273 const int srcBpp = src->format == GE_FORMAT_8888 ? 4 : 2;
274 if (srcBpp != bpp && bpp != 0) {
275 srcXFactor = (srcXFactor * bpp) / srcBpp;
276 }
277 int srcX1 = srcX * srcXFactor;
278 int srcX2 = (srcX + w) * srcXFactor;
279 int srcY1 = srcY * srcYFactor;
280 int srcY2 = (srcY + h) * srcYFactor;
281
282 float dstXFactor = (float)dst->renderScaleFactor;
283 float dstYFactor = (float)dst->renderScaleFactor;
284 const int dstBpp = dst->format == GE_FORMAT_8888 ? 4 : 2;
285 if (dstBpp != bpp && bpp != 0) {
286 dstXFactor = (dstXFactor * bpp) / dstBpp;
287 }
288 int dstX1 = dstX * dstXFactor;
289 int dstX2 = (dstX + w) * dstXFactor;
290 int dstY1 = dstY * dstYFactor;
291 int dstY2 = (dstY + h) * dstYFactor;
292
293 if (src == dst && srcX == dstX && srcY == dstY) {
294 // Let's just skip a copy where the destination is equal to the source.
295 WARN_LOG_REPORT_ONCE(blitSame, G3D, "Skipped blit with equal dst and src");
296 return;
297 }
298
299 const bool sameSize = dstX2 - dstX1 == srcX2 - srcX1 && dstY2 - dstY1 == srcY2 - srcY1;
300 const bool srcInsideBounds = srcX2 <= src->renderWidth && srcY2 <= src->renderHeight;
301 const bool dstInsideBounds = dstX2 <= dst->renderWidth && dstY2 <= dst->renderHeight;
302 const bool xOverlap = src == dst && srcX2 > dstX1 && srcX1 < dstX2;
303 const bool yOverlap = src == dst && srcY2 > dstY1 && srcY1 < dstY2;
304 if (sameSize && srcInsideBounds && dstInsideBounds && !(xOverlap && yOverlap)) {
305 draw_->CopyFramebufferImage(src->fbo, 0, srcX1, srcY1, 0, dst->fbo, 0, dstX1, dstY1, 0, dstX2 - dstX1, dstY2 - dstY1, 1, Draw::FB_COLOR_BIT, tag);
306 } else {
307 draw_->BlitFramebuffer(src->fbo, srcX1, srcY1, srcX2, srcY2, dst->fbo, dstX1, dstY1, dstX2, dstY2, Draw::FB_COLOR_BIT, Draw::FB_BLIT_NEAREST, tag);
308 }
309 }
310
BeginFrameVulkan()311 void FramebufferManagerVulkan::BeginFrameVulkan() {
312 BeginFrame();
313 }
314
EndFrame()315 void FramebufferManagerVulkan::EndFrame() {
316 }
317
DeviceLost()318 void FramebufferManagerVulkan::DeviceLost() {
319 FramebufferManagerCommon::DeviceLost();
320 DestroyDeviceObjects();
321 }
322
DeviceRestore(Draw::DrawContext * draw)323 void FramebufferManagerVulkan::DeviceRestore(Draw::DrawContext *draw) {
324 FramebufferManagerCommon::DeviceRestore(draw);
325 vulkan_ = (VulkanContext *)draw->GetNativeObject(Draw::NativeObject::CONTEXT);
326 InitDeviceObjects();
327 }
328