1 // Copyright (c) 2012- 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 "Common/Profiler/Profiler.h"
19 #include "Common/Data/Text/I18n.h"
20
21 #include "Common/Log.h"
22 #include "Common/Serialize/Serializer.h"
23 #include "Common/File/FileUtil.h"
24 #include "Common/GraphicsContext.h"
25
26 #include "Core/Config.h"
27 #include "Core/Debugger/Breakpoints.h"
28 #include "Core/MemMapHelpers.h"
29 #include "Core/Host.h"
30 #include "Core/Config.h"
31 #include "Core/Reporting.h"
32 #include "Core/System.h"
33 #include "Core/ELF/ParamSFO.h"
34
35 #include "GPU/GPUState.h"
36 #include "GPU/ge_constants.h"
37 #include "GPU/GeDisasm.h"
38 #include "GPU/Common/FramebufferManagerCommon.h"
39 #include "GPU/Debugger/Debugger.h"
40 #include "GPU/GLES/ShaderManagerGLES.h"
41 #include "GPU/GLES/GPU_GLES.h"
42 #include "GPU/GLES/FramebufferManagerGLES.h"
43 #include "GPU/GLES/DrawEngineGLES.h"
44 #include "GPU/GLES/TextureCacheGLES.h"
45
46 #include "Core/MIPS/MIPS.h"
47 #include "Core/HLE/sceKernelThread.h"
48 #include "Core/HLE/sceKernelInterrupt.h"
49 #include "Core/HLE/sceGe.h"
50
51 #ifdef _WIN32
52 #include "Windows/GPU/WindowsGLContext.h"
53 #endif
54
GPU_GLES(GraphicsContext * gfxCtx,Draw::DrawContext * draw)55 GPU_GLES::GPU_GLES(GraphicsContext *gfxCtx, Draw::DrawContext *draw)
56 : GPUCommon(gfxCtx, draw), depalShaderCache_(draw), drawEngine_(draw), fragmentTestCache_(draw) {
57 UpdateVsyncInterval(true);
58 CheckGPUFeatures();
59
60 GLRenderManager *render = (GLRenderManager *)draw->GetNativeObject(Draw::NativeObject::RENDER_MANAGER);
61
62 shaderManagerGL_ = new ShaderManagerGLES(draw);
63 framebufferManagerGL_ = new FramebufferManagerGLES(draw, render);
64 framebufferManager_ = framebufferManagerGL_;
65 textureCacheGL_ = new TextureCacheGLES(draw);
66 textureCache_ = textureCacheGL_;
67 drawEngineCommon_ = &drawEngine_;
68 shaderManager_ = shaderManagerGL_;
69 drawEngineCommon_ = &drawEngine_;
70
71 drawEngine_.SetShaderManager(shaderManagerGL_);
72 drawEngine_.SetTextureCache(textureCacheGL_);
73 drawEngine_.SetFramebufferManager(framebufferManagerGL_);
74 drawEngine_.SetFragmentTestCache(&fragmentTestCache_);
75 drawEngine_.Init();
76 framebufferManagerGL_->SetTextureCache(textureCacheGL_);
77 framebufferManagerGL_->SetShaderManager(shaderManagerGL_);
78 framebufferManagerGL_->SetDrawEngine(&drawEngine_);
79 framebufferManagerGL_->Init();
80 depalShaderCache_.Init();
81 textureCacheGL_->SetFramebufferManager(framebufferManagerGL_);
82 textureCacheGL_->SetDepalShaderCache(&depalShaderCache_);
83 textureCacheGL_->SetShaderManager(shaderManagerGL_);
84 textureCacheGL_->SetDrawEngine(&drawEngine_);
85 fragmentTestCache_.SetTextureCache(textureCacheGL_);
86
87 // Sanity check gstate
88 if ((int *)&gstate.transferstart - (int *)&gstate != 0xEA) {
89 ERROR_LOG(G3D, "gstate has drifted out of sync!");
90 }
91
92 // No need to flush before the tex scale/offset commands if we are baking
93 // the tex scale/offset into the vertices anyway.
94
95 UpdateCmdInfo();
96
97 BuildReportingInfo();
98 // Update again after init to be sure of any silly driver problems.
99 UpdateVsyncInterval(true);
100
101 textureCacheGL_->NotifyConfigChanged();
102
103 // Load shader cache.
104 std::string discID = g_paramSFO.GetDiscID();
105 if (discID.size()) {
106 File::CreateFullPath(GetSysDirectory(DIRECTORY_APP_CACHE));
107 shaderCachePath_ = GetSysDirectory(DIRECTORY_APP_CACHE) / (discID + ".glshadercache");
108 // Actually precompiled by IsReady() since we're single-threaded.
109 shaderManagerGL_->Load(shaderCachePath_);
110 }
111
112 if (g_Config.bHardwareTessellation) {
113 // Disable hardware tessellation if device is unsupported.
114 if (!drawEngine_.SupportsHWTessellation()) {
115 ERROR_LOG(G3D, "Hardware Tessellation is unsupported, falling back to software tessellation");
116 auto gr = GetI18NCategory("Graphics");
117 host->NotifyUserMessage(gr->T("Turn off Hardware Tessellation - unsupported"), 2.5f, 0xFF3030FF);
118 }
119 }
120 }
121
~GPU_GLES()122 GPU_GLES::~GPU_GLES() {
123 if (draw_) {
124 GLRenderManager *render = (GLRenderManager *)draw_->GetNativeObject(Draw::NativeObject::RENDER_MANAGER);
125 render->Wipe();
126 }
127
128 // If we're here during app shutdown (exiting the Windows app in-game, for example)
129 // everything should already be cleared since DeviceLost has been run.
130
131 if (shaderCachePath_.Valid() && draw_) {
132 shaderManagerGL_->Save(shaderCachePath_);
133 }
134
135 framebufferManagerGL_->DestroyAllFBOs();
136 shaderManagerGL_->ClearCache(true);
137 depalShaderCache_.Clear();
138 fragmentTestCache_.Clear();
139
140 delete shaderManagerGL_;
141 shaderManagerGL_ = nullptr;
142 delete framebufferManagerGL_;
143 delete textureCacheGL_;
144 }
145
146 // Take the raw GL extension and versioning data and turn into feature flags.
CheckGPUFeatures()147 void GPU_GLES::CheckGPUFeatures() {
148 u32 features = 0;
149
150 features |= GPU_SUPPORTS_16BIT_FORMATS;
151
152 if (!draw_->GetBugs().Has(Draw::Bugs::BROKEN_NAN_IN_CONDITIONAL)) {
153 if (!PSP_CoreParameter().compat.flags().DisableRangeCulling) {
154 features |= GPU_SUPPORTS_VS_RANGE_CULLING;
155 }
156 }
157
158 if (gl_extensions.ARB_blend_func_extended || gl_extensions.EXT_blend_func_extended) {
159 if (!g_Config.bVendorBugChecksEnabled || !draw_->GetBugs().Has(Draw::Bugs::DUAL_SOURCE_BLENDING_BROKEN)) {
160 features |= GPU_SUPPORTS_DUALSOURCE_BLEND;
161 }
162 }
163
164 if (gl_extensions.IsGLES) {
165 if (gl_extensions.GLES3) {
166 features |= GPU_SUPPORTS_GLSL_ES_300;
167 // Mali reports 30 but works fine...
168 if (gl_extensions.range[1][5][1] >= 30) {
169 features |= GPU_SUPPORTS_32BIT_INT_FSHADER;
170 }
171 }
172 } else {
173 if (gl_extensions.VersionGEThan(3, 3, 0)) {
174 features |= GPU_SUPPORTS_GLSL_330;
175 features |= GPU_SUPPORTS_32BIT_INT_FSHADER;
176 }
177 }
178
179 if (gl_extensions.EXT_shader_framebuffer_fetch || gl_extensions.ARM_shader_framebuffer_fetch) {
180 // This has caused problems in the past. Let's only enable on GLES3.
181 if (features & GPU_SUPPORTS_GLSL_ES_300) {
182 features |= GPU_SUPPORTS_ANY_FRAMEBUFFER_FETCH;
183 }
184 }
185
186 if (gl_extensions.ARB_framebuffer_object || gl_extensions.NV_framebuffer_blit || gl_extensions.GLES3) {
187 features |= GPU_SUPPORTS_FRAMEBUFFER_BLIT | GPU_SUPPORTS_FRAMEBUFFER_BLIT_TO_DEPTH;
188 }
189
190 if ((gl_extensions.gpuVendor == GPU_VENDOR_NVIDIA) || (gl_extensions.gpuVendor == GPU_VENDOR_AMD))
191 features |= GPU_PREFER_REVERSE_COLOR_ORDER;
192
193 if (gl_extensions.OES_texture_npot)
194 features |= GPU_SUPPORTS_TEXTURE_NPOT;
195
196 if (gl_extensions.EXT_blend_minmax)
197 features |= GPU_SUPPORTS_BLEND_MINMAX;
198
199 if (gl_extensions.OES_copy_image || gl_extensions.NV_copy_image || gl_extensions.EXT_copy_image || gl_extensions.ARB_copy_image)
200 features |= GPU_SUPPORTS_COPY_IMAGE;
201
202 if (!gl_extensions.IsGLES)
203 features |= GPU_SUPPORTS_LOGIC_OP;
204
205 if (gl_extensions.GLES3 || !gl_extensions.IsGLES)
206 features |= GPU_SUPPORTS_TEXTURE_LOD_CONTROL;
207
208 if (gl_extensions.EXT_texture_filter_anisotropic)
209 features |= GPU_SUPPORTS_ANISOTROPY;
210
211 bool canUseInstanceID = gl_extensions.EXT_draw_instanced || gl_extensions.ARB_draw_instanced;
212 bool canDefInstanceID = gl_extensions.IsGLES || gl_extensions.EXT_gpu_shader4 || gl_extensions.VersionGEThan(3, 1);
213 bool instanceRendering = gl_extensions.GLES3 || (canUseInstanceID && canDefInstanceID);
214 if (instanceRendering)
215 features |= GPU_SUPPORTS_INSTANCE_RENDERING;
216
217 int maxVertexTextureImageUnits = gl_extensions.maxVertexTextureUnits;
218 if (maxVertexTextureImageUnits >= 3) // At least 3 for hardware tessellation
219 features |= GPU_SUPPORTS_VERTEX_TEXTURE_FETCH;
220
221 if (gl_extensions.ARB_texture_float || gl_extensions.OES_texture_float)
222 features |= GPU_SUPPORTS_TEXTURE_FLOAT;
223
224 if (draw_->GetDeviceCaps().depthClampSupported) {
225 features |= GPU_SUPPORTS_DEPTH_CLAMP | GPU_SUPPORTS_ACCURATE_DEPTH;
226 // Our implementation of depth texturing needs simple Z range, so can't
227 // use the extension hacks (yet).
228 if (gl_extensions.GLES3)
229 features |= GPU_SUPPORTS_DEPTH_TEXTURE;
230 }
231
232 // If we already have a 16-bit depth buffer, we don't need to round.
233 bool prefer24 = draw_->GetDeviceCaps().preferredDepthBufferFormat == Draw::DataFormat::D24_S8;
234 if (prefer24) {
235 if (!g_Config.bHighQualityDepth && (features & GPU_SUPPORTS_ACCURATE_DEPTH) != 0) {
236 features |= GPU_SCALE_DEPTH_FROM_24BIT_TO_16BIT;
237 } else if (PSP_CoreParameter().compat.flags().PixelDepthRounding) {
238 if (!gl_extensions.IsGLES || gl_extensions.GLES3) {
239 // Use fragment rounding on desktop and GLES3, most accurate.
240 features |= GPU_ROUND_FRAGMENT_DEPTH_TO_16BIT;
241 } else if (prefer24 && (features & GPU_SUPPORTS_ACCURATE_DEPTH) != 0) {
242 // Here we can simulate a 16 bit depth buffer by scaling.
243 // Note that the depth buffer is fixed point, not floating, so dividing by 256 is pretty good.
244 features |= GPU_SCALE_DEPTH_FROM_24BIT_TO_16BIT;
245 } else {
246 // At least do vertex rounding if nothing else.
247 features |= GPU_ROUND_DEPTH_TO_16BIT;
248 }
249 } else if (PSP_CoreParameter().compat.flags().VertexDepthRounding) {
250 features |= GPU_ROUND_DEPTH_TO_16BIT;
251 }
252 }
253
254 // The Phantasy Star hack :(
255 if (PSP_CoreParameter().compat.flags().DepthRangeHack && (features & GPU_SUPPORTS_ACCURATE_DEPTH) == 0) {
256 features |= GPU_USE_DEPTH_RANGE_HACK;
257 }
258
259 if (PSP_CoreParameter().compat.flags().ClearToRAM) {
260 features |= GPU_USE_CLEAR_RAM_HACK;
261 }
262
263 gstate_c.featureFlags = features;
264 }
265
IsReady()266 bool GPU_GLES::IsReady() {
267 return shaderManagerGL_->ContinuePrecompile();
268 }
269
CancelReady()270 void GPU_GLES::CancelReady() {
271 shaderManagerGL_->CancelPrecompile();
272 }
273
BuildReportingInfo()274 void GPU_GLES::BuildReportingInfo() {
275 GLRenderManager *render = (GLRenderManager *)draw_->GetNativeObject(Draw::NativeObject::RENDER_MANAGER);
276
277 std::string glVendor = render->GetGLString(GL_VENDOR);
278 std::string glRenderer = render->GetGLString(GL_RENDERER);
279 std::string glVersion = render->GetGLString(GL_VERSION);
280 std::string glSlVersion = render->GetGLString(GL_SHADING_LANGUAGE_VERSION);
281 std::string glExtensions;
282
283 if (gl_extensions.VersionGEThan(3, 0)) {
284 glExtensions = g_all_gl_extensions;
285 } else {
286 glExtensions = render->GetGLString(GL_EXTENSIONS);
287 }
288
289 char temp[16384];
290 snprintf(temp, sizeof(temp), "%s (%s %s), %s (extensions: %s)", glVersion.c_str(), glVendor.c_str(), glRenderer.c_str(), glSlVersion.c_str(), glExtensions.c_str());
291 reportingPrimaryInfo_ = glVendor;
292 reportingFullInfo_ = temp;
293
294 Reporting::UpdateConfig();
295 }
296
DeviceLost()297 void GPU_GLES::DeviceLost() {
298 INFO_LOG(G3D, "GPU_GLES: DeviceLost");
299
300 // Simply drop all caches and textures.
301 // FBOs appear to survive? Or no?
302 // TransformDraw has registered as a GfxResourceHolder.
303 CancelReady();
304 shaderManagerGL_->DeviceLost();
305 textureCacheGL_->DeviceLost();
306 fragmentTestCache_.DeviceLost();
307 depalShaderCache_.DeviceLost();
308 drawEngine_.DeviceLost();
309
310 GPUCommon::DeviceLost();
311 }
312
DeviceRestore()313 void GPU_GLES::DeviceRestore() {
314 GPUCommon::DeviceRestore();
315
316 UpdateCmdInfo();
317 UpdateVsyncInterval(true);
318
319 shaderManagerGL_->DeviceRestore(draw_);
320 textureCacheGL_->DeviceRestore(draw_);
321 drawEngine_.DeviceRestore(draw_);
322 fragmentTestCache_.DeviceRestore(draw_);
323 depalShaderCache_.DeviceRestore(draw_);
324 }
325
Reinitialize()326 void GPU_GLES::Reinitialize() {
327 GPUCommon::Reinitialize();
328 depalShaderCache_.Clear();
329 }
330
InitClear()331 void GPU_GLES::InitClear() {
332 }
333
BeginHostFrame()334 void GPU_GLES::BeginHostFrame() {
335 GPUCommon::BeginHostFrame();
336 UpdateCmdInfo();
337 if (resized_) {
338 CheckGPUFeatures();
339 framebufferManager_->Resized();
340 drawEngine_.Resized();
341 shaderManagerGL_->DirtyShader();
342 textureCacheGL_->NotifyConfigChanged();
343 resized_ = false;
344 }
345
346 drawEngine_.BeginFrame();
347 }
348
EndHostFrame()349 void GPU_GLES::EndHostFrame() {
350 drawEngine_.EndFrame();
351 }
352
ReapplyGfxState()353 void GPU_GLES::ReapplyGfxState() {
354 GPUCommon::ReapplyGfxState();
355 }
356
BeginFrame()357 void GPU_GLES::BeginFrame() {
358 textureCacheGL_->StartFrame();
359 depalShaderCache_.Decimate();
360 fragmentTestCache_.Decimate();
361
362 GPUCommon::BeginFrame();
363
364 // Save the cache from time to time. TODO: How often? We save on exit, so shouldn't need to do this all that often.
365 if (shaderCachePath_.Valid() && (gpuStats.numFlips & 4095) == 0) {
366 shaderManagerGL_->Save(shaderCachePath_);
367 }
368
369 shaderManagerGL_->DirtyShader();
370
371 // Not sure if this is really needed.
372 gstate_c.Dirty(DIRTY_ALL_UNIFORMS);
373
374 framebufferManagerGL_->BeginFrame();
375 }
376
SetDisplayFramebuffer(u32 framebuf,u32 stride,GEBufferFormat format)377 void GPU_GLES::SetDisplayFramebuffer(u32 framebuf, u32 stride, GEBufferFormat format) {
378 GPUDebug::NotifyDisplay(framebuf, stride, format);
379 framebufferManagerGL_->SetDisplayFramebuffer(framebuf, stride, format);
380 }
381
CopyDisplayToOutput(bool reallyDirty)382 void GPU_GLES::CopyDisplayToOutput(bool reallyDirty) {
383 // Flush anything left over.
384 framebufferManagerGL_->RebindFramebuffer("RebindFramebuffer - CopyDisplayToOutput");
385 drawEngine_.Flush();
386
387 shaderManagerGL_->DirtyLastShader();
388
389 framebufferManagerGL_->CopyDisplayToOutput(reallyDirty);
390 framebufferManagerGL_->EndFrame();
391 }
392
FinishDeferred()393 void GPU_GLES::FinishDeferred() {
394 // This finishes reading any vertex data that is pending.
395 drawEngine_.FinishDeferred();
396 }
397
CheckFlushOp(int cmd,u32 diff)398 inline void GPU_GLES::CheckFlushOp(int cmd, u32 diff) {
399 const u8 cmdFlags = cmdInfo_[cmd].flags;
400 if (diff && (cmdFlags & FLAG_FLUSHBEFOREONCHANGE)) {
401 if (dumpThisFrame_) {
402 NOTICE_LOG(G3D, "================ FLUSH ================");
403 }
404 drawEngine_.Flush();
405 }
406 }
407
PreExecuteOp(u32 op,u32 diff)408 void GPU_GLES::PreExecuteOp(u32 op, u32 diff) {
409 CheckFlushOp(op >> 24, diff);
410 }
411
ExecuteOp(u32 op,u32 diff)412 void GPU_GLES::ExecuteOp(u32 op, u32 diff) {
413 const u8 cmd = op >> 24;
414 const CommandInfo info = cmdInfo_[cmd];
415 const u8 cmdFlags = info.flags;
416 if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) {
417 (this->*info.func)(op, diff);
418 } else if (diff) {
419 uint64_t dirty = info.flags >> 8;
420 if (dirty)
421 gstate_c.Dirty(dirty);
422 }
423 }
424
GetStats(char * buffer,size_t bufsize)425 void GPU_GLES::GetStats(char *buffer, size_t bufsize) {
426 size_t offset = FormatGPUStatsCommon(buffer, bufsize);
427 buffer += offset;
428 bufsize -= offset;
429 if ((int)bufsize < 0)
430 return;
431 snprintf(buffer, bufsize,
432 "Vertex, Fragment, Programs loaded: %d, %d, %d\n",
433 shaderManagerGL_->GetNumVertexShaders(),
434 shaderManagerGL_->GetNumFragmentShaders(),
435 shaderManagerGL_->GetNumPrograms()
436 );
437 }
438
ClearCacheNextFrame()439 void GPU_GLES::ClearCacheNextFrame() {
440 textureCacheGL_->ClearNextFrame();
441 }
442
ClearShaderCache()443 void GPU_GLES::ClearShaderCache() {
444 shaderManagerGL_->ClearCache(true);
445 }
446
CleanupBeforeUI()447 void GPU_GLES::CleanupBeforeUI() {
448 // Clear any enabled vertex arrays.
449 shaderManagerGL_->DirtyLastShader();
450 }
451
DoState(PointerWrap & p)452 void GPU_GLES::DoState(PointerWrap &p) {
453 GPUCommon::DoState(p);
454
455 // TODO: Some of these things may not be necessary.
456 // None of these are necessary when saving.
457 // In Freeze-Frame mode, we don't want to do any of this.
458 if (p.mode == p.MODE_READ && !PSP_CoreParameter().frozen) {
459 textureCache_->Clear(true);
460 depalShaderCache_.Clear();
461 drawEngine_.ClearTrackedVertexArrays();
462
463 gstate_c.Dirty(DIRTY_TEXTURE_IMAGE);
464 framebufferManager_->DestroyAllFBOs();
465 }
466 }
467
DebugGetShaderIDs(DebugShaderType type)468 std::vector<std::string> GPU_GLES::DebugGetShaderIDs(DebugShaderType type) {
469 switch (type) {
470 case SHADER_TYPE_VERTEXLOADER:
471 return drawEngine_.DebugGetVertexLoaderIDs();
472 case SHADER_TYPE_DEPAL:
473 return depalShaderCache_.DebugGetShaderIDs(type);
474 default:
475 return shaderManagerGL_->DebugGetShaderIDs(type);
476 }
477 }
478
DebugGetShaderString(std::string id,DebugShaderType type,DebugShaderStringType stringType)479 std::string GPU_GLES::DebugGetShaderString(std::string id, DebugShaderType type, DebugShaderStringType stringType) {
480 switch (type) {
481 case SHADER_TYPE_VERTEXLOADER:
482 return drawEngine_.DebugGetVertexLoaderString(id, stringType);
483 case SHADER_TYPE_DEPAL:
484 return depalShaderCache_.DebugGetShaderString(id, type, stringType);
485 default:
486 return shaderManagerGL_->DebugGetShaderString(id, type, stringType);
487 }
488 }
489