thirdparty/ppsspp
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Libretro: style nits.

Browse source
This commit is contained in:
aliaspider 2018-03-26 17:37:34 +01:00
parent 5a9ce3bc19
commit 4202ae58bd
10 changed files with 311 additions and 420 deletions
Download patch file Download diff file Expand all files Collapse all files

2
libretro/LibretroD3D11Context.cpp
View file

@ -88,7 +88,7 @@ void LibretroD3D11Context::SwapBuffers() {
d3d11_->context->PSSetShaderResources(0, 1, &SRView_); d3d11_->context->PSSetShaderResources(0, 1, &SRView_);
LibretroHWRenderContext::SwapBuffers(); LibretroHWRenderContext::SwapBuffers();
ID3D11ShaderResourceView * nullSRV = nullptr; ID3D11ShaderResourceView *nullSRV = nullptr;
d3d11_->context->PSSetShaderResources(0, 1, &nullSRV); d3d11_->context->PSSetShaderResources(0, 1, &nullSRV);
draw_->HandleEvent(Draw::Event::PRESENTED, 0, 0, nullptr, nullptr); draw_->HandleEvent(Draw::Event::PRESENTED, 0, 0, nullptr, nullptr);

3
libretro/LibretroD3D11Context.h
View file

@ -5,7 +5,7 @@
#include "libretro/LibretroGraphicsContext.h" #include "libretro/LibretroGraphicsContext.h"
class LibretroD3D11Context : public LibretroHWRenderContext { class LibretroD3D11Context : public LibretroHWRenderContext {
public: public:
LibretroD3D11Context() : LibretroHWRenderContext(RETRO_HW_CONTEXT_DIRECT3D, 11) {} LibretroD3D11Context() : LibretroHWRenderContext(RETRO_HW_CONTEXT_DIRECT3D, 11) {}
bool Init() override; bool Init() override;
@ -17,6 +17,7 @@ class LibretroD3D11Context : public LibretroHWRenderContext {
GPUCore GetGPUCore() override { return GPUCORE_DIRECTX11; } GPUCore GetGPUCore() override { return GPUCORE_DIRECTX11; }
const char *Ident() override { return "DirectX 11"; } const char *Ident() override { return "DirectX 11"; }
private: private:
retro_hw_render_interface_d3d11 *d3d11_ = nullptr; retro_hw_render_interface_d3d11 *d3d11_ = nullptr;
ID3D11Texture2D *texture_ = nullptr; ID3D11Texture2D *texture_ = nullptr;

15
libretro/LibretroGLContext.cpp
View file

@ -6,8 +6,7 @@
#include "libretro/LibretroGLContext.h" #include "libretro/LibretroGLContext.h"
bool LibretroGLContext::Init() bool LibretroGLContext::Init() {
{
if (!LibretroHWRenderContext::Init(true)) if (!LibretroHWRenderContext::Init(true))
return false; return false;
@ -15,13 +14,10 @@ bool LibretroGLContext::Init()
return true; return true;
} }
void LibretroGLContext::CreateDrawContext() void LibretroGLContext::CreateDrawContext() {
{ if (!glewInitDone) {
if (!glewInitDone)
{
#if !defined(IOS) && !defined(USING_GLES2) #if !defined(IOS) && !defined(USING_GLES2)
if (glewInit() != GLEW_OK) if (glewInit() != GLEW_OK) {
{
ERROR_LOG(G3D, "glewInit() failed.\n"); ERROR_LOG(G3D, "glewInit() failed.\n");
return; return;
} }
@ -33,8 +29,7 @@ void LibretroGLContext::CreateDrawContext()
renderManager_ = (GLRenderManager *)draw_->GetNativeObject(Draw::NativeObject::RENDER_MANAGER); renderManager_ = (GLRenderManager *)draw_->GetNativeObject(Draw::NativeObject::RENDER_MANAGER);
} }
void LibretroGLContext::DestroyDrawContext() void LibretroGLContext::DestroyDrawContext() {
{
LibretroHWRenderContext::DestroyDrawContext(); LibretroHWRenderContext::DestroyDrawContext();
renderManager_ = nullptr; renderManager_ = nullptr;
} }

17
libretro/LibretroGLContext.h
View file

@ -5,15 +5,14 @@
#include "thin3d/GLRenderManager.h" #include "thin3d/GLRenderManager.h"
class LibretroGLContext : public LibretroHWRenderContext { class LibretroGLContext : public LibretroHWRenderContext {
public: public:
LibretroGLContext() LibretroGLContext()
:
#ifdef USING_GLES2 #ifdef USING_GLES2
HWRenderContext(RETRO_HW_CONTEXT_OPENGLES2) : HWRenderContext(RETRO_HW_CONTEXT_OPENGLES2)
#elif defined(HAVE_OPENGL_CORE) #elif defined(HAVE_OPENGL_CORE)
HWRenderContext(RETRO_HW_CONTEXT_OPENGL_CORE, 3, 1) : HWRenderContext(RETRO_HW_CONTEXT_OPENGL_CORE, 3, 1)
#else #else
LibretroHWRenderContext(RETRO_HW_CONTEXT_OPENGL) : LibretroHWRenderContext(RETRO_HW_CONTEXT_OPENGL)
#endif #endif
{ {
hw_render_.bottom_left_origin = true; hw_render_.bottom_left_origin = true;
@ -22,8 +21,7 @@ class LibretroGLContext : public LibretroHWRenderContext {
bool Init() override; bool Init() override;
void CreateDrawContext() override; void CreateDrawContext() override;
void DestroyDrawContext() override; void DestroyDrawContext() override;
void SetRenderTarget() override void SetRenderTarget() override {
{
extern GLuint g_defaultFBO; extern GLuint g_defaultFBO;
g_defaultFBO = hw_render_.get_current_framebuffer(); g_defaultFBO = hw_render_.get_current_framebuffer();
} }
@ -31,8 +29,7 @@ class LibretroGLContext : public LibretroHWRenderContext {
void ThreadStart() override { renderManager_->ThreadStart(); } void ThreadStart() override { renderManager_->ThreadStart(); }
bool ThreadFrame() override { return renderManager_->ThreadFrame(); } bool ThreadFrame() override { return renderManager_->ThreadFrame(); }
void ThreadEnd() override { renderManager_->ThreadEnd(); } void ThreadEnd() override { renderManager_->ThreadEnd(); }
void StopThread() override void StopThread() override {
{
renderManager_->WaitUntilQueueIdle(); renderManager_->WaitUntilQueueIdle();
renderManager_->StopThread(); renderManager_->StopThread();
} }
@ -40,7 +37,7 @@ class LibretroGLContext : public LibretroHWRenderContext {
GPUCore GetGPUCore() override { return GPUCORE_GLES; } GPUCore GetGPUCore() override { return GPUCORE_GLES; }
const char *Ident() override { return "OpenGL"; } const char *Ident() override { return "OpenGL"; }
private: private:
GLRenderManager *renderManager_ = nullptr; GLRenderManager *renderManager_ = nullptr;
bool glewInitDone = false; bool glewInitDone = false;
}; };

57
libretro/LibretroGraphicsContext.cpp
View file

@ -25,8 +25,7 @@ bool LibretroHWRenderContext::Init(bool cache_context) {
return Libretro::environ_cb(RETRO_ENVIRONMENT_SET_HW_RENDER, &hw_render_); return Libretro::environ_cb(RETRO_ENVIRONMENT_SET_HW_RENDER, &hw_render_);
} }
LibretroHWRenderContext::LibretroHWRenderContext(retro_hw_context_type context_type, unsigned version_major, unsigned version_minor) LibretroHWRenderContext::LibretroHWRenderContext(retro_hw_context_type context_type, unsigned version_major, unsigned version_minor) {
{
hw_render_.context_type = context_type; hw_render_.context_type = context_type;
hw_render_.version_major = version_major; hw_render_.version_major = version_major;
hw_render_.version_minor = version_minor; hw_render_.version_minor = version_minor;
@ -35,17 +34,16 @@ LibretroHWRenderContext::LibretroHWRenderContext(retro_hw_context_type context_t
hw_render_.depth = true; hw_render_.depth = true;
} }
void LibretroHWRenderContext::ContextReset() void LibretroHWRenderContext::ContextReset() {
{
INFO_LOG(G3D, "Context reset"); INFO_LOG(G3D, "Context reset");
// needed to restart the thread // needed to restart the thread
// TODO: find a way to move this to ContextDestroy. // TODO: find a way to move this to ContextDestroy.
if (!hw_render_.cache_context && Libretro::useEmuThread && draw_ && Libretro::emuThreadState != Libretro::EmuThreadState::PAUSED) if (!hw_render_.cache_context && Libretro::useEmuThread && draw_ && Libretro::emuThreadState != Libretro::EmuThreadState::PAUSED) {
DestroyDrawContext(); DestroyDrawContext();
}
if (!draw_) if (!draw_) {
{
CreateDrawContext(); CreateDrawContext();
PSP_CoreParameter().thin3d = draw_; PSP_CoreParameter().thin3d = draw_;
bool success = draw_->CreatePresets(); bool success = draw_->CreatePresets();
@ -54,16 +52,15 @@ void LibretroHWRenderContext::ContextReset()
GotBackbuffer(); GotBackbuffer();
if (gpu) if (gpu) {
gpu->DeviceRestore(); gpu->DeviceRestore();
}
} }
void LibretroHWRenderContext::ContextDestroy() void LibretroHWRenderContext::ContextDestroy() {
{
INFO_LOG(G3D, "Context destroy"); INFO_LOG(G3D, "Context destroy");
if (Libretro::useEmuThread) if (Libretro::useEmuThread) {
{
#if 0 #if 0
Libretro::EmuThreadPause(); Libretro::EmuThreadPause();
#else #else
@ -75,62 +72,56 @@ void LibretroHWRenderContext::ContextDestroy()
gpu->DeviceLost(); gpu->DeviceLost();
if(!hw_render_.cache_context && !Libretro::useEmuThread) if (!hw_render_.cache_context && !Libretro::useEmuThread) {
Shutdown(); Shutdown();
}
} }
void LibretroGraphicsContext::GotBackbuffer() void LibretroGraphicsContext::GotBackbuffer() { draw_->HandleEvent(Draw::Event::GOT_BACKBUFFER, PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight); }
{
draw_->HandleEvent(Draw::Event::GOT_BACKBUFFER, PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight);
}
void LibretroGraphicsContext::LostBackbuffer() void LibretroGraphicsContext::LostBackbuffer() { draw_->HandleEvent(Draw::Event::LOST_BACKBUFFER, -1, -1); }
{
draw_->HandleEvent(Draw::Event::LOST_BACKBUFFER, -1, -1);
}
LibretroGraphicsContext *LibretroGraphicsContext::CreateGraphicsContext() LibretroGraphicsContext *LibretroGraphicsContext::CreateGraphicsContext() {
{
LibretroGraphicsContext *ctx; LibretroGraphicsContext *ctx;
ctx = new LibretroGLContext(); ctx = new LibretroGLContext();
if (ctx->Init()) if (ctx->Init()) {
return ctx; return ctx;
}
delete ctx; delete ctx;
#ifndef NO_VULKAN #ifndef NO_VULKAN
ctx = new LibretroVulkanContext(); ctx = new LibretroVulkanContext();
if (ctx->Init()) if (ctx->Init()) {
return ctx; return ctx;
}
delete ctx; delete ctx;
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
ctx = new LibretroD3D11Context(); ctx = new LibretroD3D11Context();
if (ctx->Init()) if (ctx->Init()) {
return ctx; return ctx;
}
delete ctx; delete ctx;
ctx = new LibretroD3D9Context(); ctx = new LibretroD3D9Context();
if (ctx->Init()) if (ctx->Init()) {
return ctx; return ctx;
}
delete ctx; delete ctx;
#endif #endif
#if 1 #if 1
ctx = new LibretroSoftwareContext(); ctx = new LibretroSoftwareContext();
if (ctx->Init()) if (ctx->Init()) {
return ctx; return ctx;
}
delete ctx; delete ctx;
#endif #endif

41
libretro/LibretroGraphicsContext.h
View file

@ -9,17 +9,16 @@
#include "GPU/GPUState.h" #include "GPU/GPUState.h"
class LibretroGraphicsContext : public GraphicsContext { class LibretroGraphicsContext : public GraphicsContext {
public: public:
LibretroGraphicsContext() {} LibretroGraphicsContext() {}
~LibretroGraphicsContext() override { Shutdown();} ~LibretroGraphicsContext() override { Shutdown(); }
virtual bool Init() = 0; virtual bool Init() = 0;
virtual void SetRenderTarget() {} virtual void SetRenderTarget() {}
virtual GPUCore GetGPUCore() = 0; virtual GPUCore GetGPUCore() = 0;
virtual const char *Ident() = 0; virtual const char *Ident() = 0;
void Shutdown() override void Shutdown() override {
{
DestroyDrawContext(); DestroyDrawContext();
PSP_CoreParameter().thin3d = nullptr; PSP_CoreParameter().thin3d = nullptr;
} }
@ -30,10 +29,10 @@ class LibretroGraphicsContext : public GraphicsContext {
virtual void LostBackbuffer(); virtual void LostBackbuffer();
virtual void CreateDrawContext() {} virtual void CreateDrawContext() {}
virtual void DestroyDrawContext() virtual void DestroyDrawContext() {
{ if (!draw_) {
if (!draw_)
return; return;
}
delete draw_; delete draw_;
draw_ = nullptr; draw_ = nullptr;
} }
@ -43,37 +42,36 @@ class LibretroGraphicsContext : public GraphicsContext {
static retro_video_refresh_t video_cb; static retro_video_refresh_t video_cb;
protected: protected:
Draw::DrawContext *draw_ = nullptr; Draw::DrawContext *draw_ = nullptr;
}; };
class LibretroHWRenderContext : public LibretroGraphicsContext { class LibretroHWRenderContext : public LibretroGraphicsContext {
public: public:
LibretroHWRenderContext(retro_hw_context_type context_type, unsigned version_major = 0, unsigned version_minor = 0); LibretroHWRenderContext(retro_hw_context_type context_type, unsigned version_major = 0, unsigned version_minor = 0);
bool Init(bool cache_context); bool Init(bool cache_context);
void SetRenderTarget() override {} void SetRenderTarget() override {}
void SwapBuffers() override void SwapBuffers() override {
{ if (gstate_c.skipDrawReason) {
if (gstate_c.skipDrawReason)
video_cb(NULL, 0, 0, 0); video_cb(NULL, 0, 0, 0);
else } else {
video_cb(RETRO_HW_FRAME_BUFFER_VALID, PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight, 0); video_cb(RETRO_HW_FRAME_BUFFER_VALID, PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight, 0);
}
} }
virtual void ContextReset(); virtual void ContextReset();
virtual void ContextDestroy(); virtual void ContextDestroy();
protected: protected:
retro_hw_render_callback hw_render_ = {}; retro_hw_render_callback hw_render_ = {};
}; };
#ifdef _WIN32 #ifdef _WIN32
class LibretroD3D9Context : public LibretroHWRenderContext { class LibretroD3D9Context : public LibretroHWRenderContext {
public: public:
LibretroD3D9Context() : LibretroHWRenderContext(RETRO_HW_CONTEXT_DIRECT3D, 9) {} LibretroD3D9Context() : LibretroHWRenderContext(RETRO_HW_CONTEXT_DIRECT3D, 9) {}
bool Init() override { return false; } bool Init() override { return false; }
void CreateDrawContext() override void CreateDrawContext() override {
{
draw_ = Draw::T3DCreateDX9Context(nullptr, nullptr, 0, nullptr, nullptr); draw_ = Draw::T3DCreateDX9Context(nullptr, nullptr, 0, nullptr, nullptr);
draw_->CreatePresets(); draw_->CreatePresets();
} }
@ -84,7 +82,7 @@ class LibretroD3D9Context : public LibretroHWRenderContext {
#endif #endif
class LibretroSoftwareContext : public LibretroGraphicsContext { class LibretroSoftwareContext : public LibretroGraphicsContext {
public: public:
LibretroSoftwareContext() {} LibretroSoftwareContext() {}
bool Init() override { return true; } bool Init() override { return true; }
void SwapBuffers() override { video_cb(NULL, PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight, 0); } void SwapBuffers() override { video_cb(NULL, PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight, 0); }
@ -93,7 +91,7 @@ class LibretroSoftwareContext : public LibretroGraphicsContext {
}; };
class LibretroNullContext : public LibretroGraphicsContext { class LibretroNullContext : public LibretroGraphicsContext {
public: public:
LibretroNullContext() {} LibretroNullContext() {}
bool Init() override { return true; } bool Init() override { return true; }
@ -106,8 +104,7 @@ namespace Libretro {
extern LibretroGraphicsContext *ctx; extern LibretroGraphicsContext *ctx;
extern retro_environment_t environ_cb; extern retro_environment_t environ_cb;
enum class EmuThreadState enum class EmuThreadState {
{
DISABLED, DISABLED,
START_REQUESTED, START_REQUESTED,
RUNNING, RUNNING,
@ -121,4 +118,4 @@ extern std::atomic<EmuThreadState> emuThreadState;
void EmuThreadStart(); void EmuThreadStart();
void EmuThreadStop(); void EmuThreadStop();
void EmuThreadPause(); void EmuThreadPause();
} // namespace Libretro } // namespace Libretro

46
libretro/LibretroVulkanContext.cpp
View file

@ -1,5 +1,4 @@
#include "Common/Vulkan/VulkanLoader.h" #include "Common/Vulkan/VulkanLoader.h"
#include "Common/Vulkan/VulkanContext.h" #include "Common/Vulkan/VulkanContext.h"
#include "Common/Vulkan/VulkanDebug.h" #include "Common/Vulkan/VulkanDebug.h"
@ -22,19 +21,16 @@ void vk_libretro_wait_for_presentation();
LibretroVulkanContext::LibretroVulkanContext() LibretroVulkanContext::LibretroVulkanContext()
: LibretroHWRenderContext(RETRO_HW_CONTEXT_VULKAN, VK_MAKE_VERSION(1, 0, 18)) {} : LibretroHWRenderContext(RETRO_HW_CONTEXT_VULKAN, VK_MAKE_VERSION(1, 0, 18)) {}
void LibretroVulkanContext::SwapBuffers() void LibretroVulkanContext::SwapBuffers() {
{
vk_libretro_wait_for_presentation(); vk_libretro_wait_for_presentation();
LibretroHWRenderContext::SwapBuffers(); LibretroHWRenderContext::SwapBuffers();
} }
static bool create_device(retro_vulkan_context *context, VkInstance instance, VkPhysicalDevice gpu, VkSurfaceKHR surface, PFN_vkGetInstanceProcAddr get_instance_proc_addr, const char **required_device_extensions, unsigned num_required_device_extensions, const char **required_device_layers, unsigned num_required_device_layers, const VkPhysicalDeviceFeatures *required_features) static bool create_device(retro_vulkan_context *context, VkInstance instance, VkPhysicalDevice gpu, VkSurfaceKHR surface, PFN_vkGetInstanceProcAddr get_instance_proc_addr, const char **required_device_extensions, unsigned num_required_device_extensions, const char **required_device_layers, unsigned num_required_device_layers, const VkPhysicalDeviceFeatures *required_features) {
{
init_glslang(); init_glslang();
vk = new VulkanContext; vk = new VulkanContext;
if (!vk->InitError().empty()) if (!vk->InitError().empty()) {
{
ERROR_LOG(G3D, "%s", vk->InitError().c_str()); ERROR_LOG(G3D, "%s", vk->InitError().c_str());
return false; return false;
} }
@ -44,11 +40,13 @@ static bool create_device(retro_vulkan_context *context, VkInstance instance, Vk
vk->CreateInstance({}); vk->CreateInstance({});
int physical_device = 0; int physical_device = 0;
while (gpu && vk->GetPhysicalDevice(physical_device) != gpu) while (gpu && vk->GetPhysicalDevice(physical_device) != gpu) {
physical_device++; physical_device++;
}
if (!gpu) if (!gpu) {
physical_device = vk->GetBestPhysicalDevice(); physical_device = vk->GetBestPhysicalDevice();
}
vk->ChooseDevice(physical_device); vk->ChooseDevice(physical_device);
vk->CreateDevice(); vk->CreateDevice();
@ -64,8 +62,9 @@ static bool create_device(retro_vulkan_context *context, VkInstance instance, Vk
vk->InitSurface(WINDOWSYSTEM_WAYLAND, nullptr, nullptr); vk->InitSurface(WINDOWSYSTEM_WAYLAND, nullptr, nullptr);
#endif #endif
if (!vk->InitQueue()) if (!vk->InitQueue()) {
return false; return false;
}
context->gpu = vk->GetPhysicalDevice(physical_device); context->gpu = vk->GetPhysicalDevice(physical_device);
context->device = vk->GetDevice(); context->device = vk->GetDevice();
@ -79,8 +78,7 @@ static bool create_device(retro_vulkan_context *context, VkInstance instance, Vk
return true; return true;
} }
static const VkApplicationInfo *GetApplicationInfo(void) static const VkApplicationInfo *GetApplicationInfo(void) {
{
static VkApplicationInfo app_info{ VK_STRUCTURE_TYPE_APPLICATION_INFO }; static VkApplicationInfo app_info{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
app_info.pApplicationName = "PPSSPP"; app_info.pApplicationName = "PPSSPP";
app_info.applicationVersion = Version(PPSSPP_GIT_VERSION).ToInteger(); app_info.applicationVersion = Version(PPSSPP_GIT_VERSION).ToInteger();
@ -90,10 +88,10 @@ static const VkApplicationInfo *GetApplicationInfo(void)
return &app_info; return &app_info;
} }
bool LibretroVulkanContext::Init() bool LibretroVulkanContext::Init() {
{ if (!LibretroHWRenderContext::Init(false)) {
if (!LibretroHWRenderContext::Init(false))
return false; return false;
}
static const struct retro_hw_render_context_negotiation_interface_vulkan iface = { RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN, RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN_VERSION, GetApplicationInfo, create_device, nullptr }; static const struct retro_hw_render_context_negotiation_interface_vulkan iface = { RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN, RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN_VERSION, GetApplicationInfo, create_device, nullptr };
Libretro::environ_cb(RETRO_ENVIRONMENT_SET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE, (void *)&iface); Libretro::environ_cb(RETRO_ENVIRONMENT_SET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE, (void *)&iface);
@ -102,12 +100,12 @@ bool LibretroVulkanContext::Init()
return true; return true;
} }
void LibretroVulkanContext::Shutdown() void LibretroVulkanContext::Shutdown() {
{
LibretroHWRenderContext::Shutdown(); LibretroHWRenderContext::Shutdown();
if (!vk) if (!vk) {
return; return;
}
vk->WaitUntilQueueIdle(); vk->WaitUntilQueueIdle();
@ -123,16 +121,13 @@ void LibretroVulkanContext::Shutdown()
void *LibretroVulkanContext::GetAPIContext() { return vk; } void *LibretroVulkanContext::GetAPIContext() { return vk; }
void LibretroVulkanContext::CreateDrawContext() void LibretroVulkanContext::CreateDrawContext() {
{
retro_hw_render_interface *vulkan; retro_hw_render_interface *vulkan;
if (!Libretro::environ_cb(RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE, (void **)&vulkan) || !vulkan) if (!Libretro::environ_cb(RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE, (void **)&vulkan) || !vulkan) {
{
ERROR_LOG(G3D, "Failed to get HW rendering interface!\n"); ERROR_LOG(G3D, "Failed to get HW rendering interface!\n");
return; return;
} }
if (vulkan->interface_version != RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION) if (vulkan->interface_version != RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION) {
{
ERROR_LOG(G3D, "HW render interface mismatch, expected %u, got %u!\n", RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION, vulkan->interface_version); ERROR_LOG(G3D, "HW render interface mismatch, expected %u, got %u!\n", RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION, vulkan->interface_version);
return; return;
} }
@ -140,8 +135,9 @@ void LibretroVulkanContext::CreateDrawContext()
vk->ReinitSurface(PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight); vk->ReinitSurface(PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight);
if (!vk->InitSwapchain()) if (!vk->InitSwapchain()) {
return; return;
}
draw_ = Draw::T3DCreateVulkanContext(vk, false); draw_ = Draw::T3DCreateVulkanContext(vk, false);
} }

2
libretro/LibretroVulkanContext.h
View file

@ -3,7 +3,7 @@
#include "libretro/LibretroGraphicsContext.h" #include "libretro/LibretroGraphicsContext.h"
class LibretroVulkanContext : public LibretroHWRenderContext { class LibretroVulkanContext : public LibretroHWRenderContext {
public: public:
LibretroVulkanContext(); LibretroVulkanContext();
~LibretroVulkanContext() override {} ~LibretroVulkanContext() override {}
bool Init() override; bool Init() override;

382
libretro/libretro.cpp
View file

@ -46,18 +46,17 @@ retro_environment_t environ_cb;
static retro_audio_sample_batch_t audio_batch_cb; static retro_audio_sample_batch_t audio_batch_cb;
static retro_input_poll_t input_poll_cb; static retro_input_poll_t input_poll_cb;
static retro_input_state_t input_state_cb; static retro_input_state_t input_state_cb;
} // namespace Libretro } // namespace Libretro
using namespace Libretro; using namespace Libretro;
class LibretroHost : public Host { class LibretroHost : public Host {
public: public:
LibretroHost() {} LibretroHost() {}
bool InitGraphics(std::string *error_message, GraphicsContext **ctx) override { return true; } bool InitGraphics(std::string *error_message, GraphicsContext **ctx) override { return true; }
void ShutdownGraphics() override {} void ShutdownGraphics() override {}
void InitSound() override {} void InitSound() override {}
void UpdateSound() override void UpdateSound() override {
{
extern int hostAttemptBlockSize; extern int hostAttemptBlockSize;
const int blockSizeMax = 512; const int blockSizeMax = 512;
static int16_t audio[blockSizeMax * 2]; static int16_t audio[blockSizeMax * 2];
@ -72,69 +71,60 @@ class LibretroHost : public Host {
}; };
class PrintfLogger : public LogListener { class PrintfLogger : public LogListener {
public: public:
PrintfLogger(retro_log_callback log) : log_(log.log) {} PrintfLogger(retro_log_callback log) : log_(log.log) {}
void Log(const LogMessage &message) void Log(const LogMessage &message) {
{ switch (message.level) {
switch (message.level) case LogTypes::LVERBOSE:
{ case LogTypes::LDEBUG:
case LogTypes::LVERBOSE: log_(RETRO_LOG_DEBUG, "[%s] %s", message.log, message.msg.c_str());
case LogTypes::LDEBUG: return;
log_(RETRO_LOG_DEBUG, "[%s] %s", message.log, message.msg.c_str());
return;
case LogTypes::LERROR: case LogTypes::LERROR:
log_(RETRO_LOG_ERROR, "[%s] %s", message.log, message.msg.c_str()); log_(RETRO_LOG_ERROR, "[%s] %s", message.log, message.msg.c_str());
return; return;
case LogTypes::LNOTICE: case LogTypes::LNOTICE:
case LogTypes::LWARNING: case LogTypes::LWARNING:
log_(RETRO_LOG_WARN, "[%s] %s", message.log, message.msg.c_str()); log_(RETRO_LOG_WARN, "[%s] %s", message.log, message.msg.c_str());
return; return;
case LogTypes::LINFO: case LogTypes::LINFO:
default: default:
log_(RETRO_LOG_INFO, "[%s] %s", message.log, message.msg.c_str()); log_(RETRO_LOG_INFO, "[%s] %s", message.log, message.msg.c_str());
return; return;
} }
} }
private: private:
retro_log_printf_t log_; retro_log_printf_t log_;
}; };
static PrintfLogger *printfLogger; static PrintfLogger *printfLogger;
template <typename T> class RetroOption { template <typename T> class RetroOption {
public: public:
RetroOption(const char *id, const char *name, std::initializer_list<std::pair<const char *, T>> list) : id_(id), name_(name), list_(list.begin(), list.end()) {} RetroOption(const char *id, const char *name, std::initializer_list<std::pair<const char *, T>> list) : id_(id), name_(name), list_(list.begin(), list.end()) {}
RetroOption(const char *id, const char *name, std::initializer_list<const char *> list) : id_(id), name_(name) RetroOption(const char *id, const char *name, std::initializer_list<const char *> list) : id_(id), name_(name) {
{
for (auto option : list) for (auto option : list)
list_.push_back({ option, (T)list_.size() }); list_.push_back({ option, (T)list_.size() });
} }
RetroOption(const char *id, const char *name, T first, std::initializer_list<const char *> list) : id_(id), name_(name) RetroOption(const char *id, const char *name, T first, std::initializer_list<const char *> list) : id_(id), name_(name) {
{
for (auto option : list) for (auto option : list)
list_.push_back({ option, first + (int)list_.size() }); list_.push_back({ option, first + (int)list_.size() });
} }
RetroOption(const char *id, const char *name, T first, int count, int step = 1) : id_(id), name_(name) RetroOption(const char *id, const char *name, T first, int count, int step = 1) : id_(id), name_(name) {
{
for (T i = first; i < first + count; i += step) for (T i = first; i < first + count; i += step)
list_.push_back({ std::to_string(i), i }); list_.push_back({ std::to_string(i), i });
} }
RetroOption(const char *id, const char *name, bool initial) : id_(id), name_(name) RetroOption(const char *id, const char *name, bool initial) : id_(id), name_(name) {
{
list_.push_back({ initial ? "enabled" : "disabled", initial }); list_.push_back({ initial ? "enabled" : "disabled", initial });
list_.push_back({ !initial ? "enabled" : "disabled", !initial }); list_.push_back({ !initial ? "enabled" : "disabled", !initial });
} }
retro_variable GetOptions() retro_variable GetOptions() {
{ if (options_.empty()) {
if (options_.empty())
{
options_ = name_; options_ = name_;
options_.push_back(';'); options_.push_back(';');
for (auto &option : list_) for (auto &option : list_) {
{
if (option.first == list_.begin()->first) if (option.first == list_.begin()->first)
options_ += std::string(" ") + option.first; options_ += std::string(" ") + option.first;
else else
@ -143,25 +133,20 @@ template <typename T> class RetroOption {
} }
return { id_, options_.c_str() }; return { id_, options_.c_str() };
} }
bool Update(T *dest) bool Update(T *dest) {
{
retro_variable var{ id_ }; retro_variable var{ id_ };
T val = list_.front().second; T val = list_.front().second;
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
{ for (auto option : list_) {
for (auto option : list_) if (option.first == var.value) {
{
if (option.first == var.value)
{
val = option.second; val = option.second;
break; break;
} }
} }
} }
if (*dest != val) if (*dest != val) {
{
*dest = val; *dest = val;
return true; return true;
} }
@ -169,7 +154,7 @@ template <typename T> class RetroOption {
return false; return false;
} }
private: private:
const char *id_; const char *id_;
const char *name_; const char *name_;
std::string options_; std::string options_;
@ -200,8 +185,7 @@ static RetroOption<bool> ppsspp_unsafe_func_replacements("ppsspp_unsafe_func_rep
static RetroOption<bool> ppsspp_sound_speedhack("ppsspp_sound_speedhack", "Sound Speedhack", false); static RetroOption<bool> ppsspp_sound_speedhack("ppsspp_sound_speedhack", "Sound Speedhack", false);
static RetroOption<bool> ppsspp_cheats("ppsspp_cheats", "Internal Cheats Support", false); static RetroOption<bool> ppsspp_cheats("ppsspp_cheats", "Internal Cheats Support", false);
void retro_set_environment(retro_environment_t cb) void retro_set_environment(retro_environment_t cb) {
{
std::vector<retro_variable> vars; std::vector<retro_variable> vars;
vars.push_back(ppsspp_cpu_core.GetOptions()); vars.push_back(ppsspp_cpu_core.GetOptions());
vars.push_back(ppsspp_locked_cpu_speed.GetOptions()); vars.push_back(ppsspp_locked_cpu_speed.GetOptions());
@ -233,44 +217,41 @@ void retro_set_environment(retro_environment_t cb)
cb(RETRO_ENVIRONMENT_SET_VARIABLES, (void *)vars.data()); cb(RETRO_ENVIRONMENT_SET_VARIABLES, (void *)vars.data());
} }
static int get_language_auto(void) static int get_language_auto(void) {
{
retro_language val = RETRO_LANGUAGE_ENGLISH; retro_language val = RETRO_LANGUAGE_ENGLISH;
environ_cb(RETRO_ENVIRONMENT_GET_LANGUAGE, &val); environ_cb(RETRO_ENVIRONMENT_GET_LANGUAGE, &val);
switch (val) switch (val) {
{ default:
default: case RETRO_LANGUAGE_ENGLISH:
case RETRO_LANGUAGE_ENGLISH: return PSP_SYSTEMPARAM_LANGUAGE_ENGLISH;
return PSP_SYSTEMPARAM_LANGUAGE_ENGLISH; case RETRO_LANGUAGE_JAPANESE:
case RETRO_LANGUAGE_JAPANESE: return PSP_SYSTEMPARAM_LANGUAGE_JAPANESE;
return PSP_SYSTEMPARAM_LANGUAGE_JAPANESE; case RETRO_LANGUAGE_FRENCH:
case RETRO_LANGUAGE_FRENCH: return PSP_SYSTEMPARAM_LANGUAGE_FRENCH;
return PSP_SYSTEMPARAM_LANGUAGE_FRENCH; case RETRO_LANGUAGE_GERMAN:
case RETRO_LANGUAGE_GERMAN: return PSP_SYSTEMPARAM_LANGUAGE_GERMAN;
return PSP_SYSTEMPARAM_LANGUAGE_GERMAN; case RETRO_LANGUAGE_SPANISH:
case RETRO_LANGUAGE_SPANISH: return PSP_SYSTEMPARAM_LANGUAGE_SPANISH;
return PSP_SYSTEMPARAM_LANGUAGE_SPANISH; case RETRO_LANGUAGE_ITALIAN:
case RETRO_LANGUAGE_ITALIAN: return PSP_SYSTEMPARAM_LANGUAGE_ITALIAN;
return PSP_SYSTEMPARAM_LANGUAGE_ITALIAN; case RETRO_LANGUAGE_PORTUGUESE_BRAZIL:
case RETRO_LANGUAGE_PORTUGUESE_BRAZIL: case RETRO_LANGUAGE_PORTUGUESE_PORTUGAL:
case RETRO_LANGUAGE_PORTUGUESE_PORTUGAL: return PSP_SYSTEMPARAM_LANGUAGE_PORTUGUESE;
return PSP_SYSTEMPARAM_LANGUAGE_PORTUGUESE; case RETRO_LANGUAGE_RUSSIAN:
case RETRO_LANGUAGE_RUSSIAN: return PSP_SYSTEMPARAM_LANGUAGE_RUSSIAN;
return PSP_SYSTEMPARAM_LANGUAGE_RUSSIAN; case RETRO_LANGUAGE_DUTCH:
case RETRO_LANGUAGE_DUTCH: return PSP_SYSTEMPARAM_LANGUAGE_DUTCH;
return PSP_SYSTEMPARAM_LANGUAGE_DUTCH; case RETRO_LANGUAGE_KOREAN:
case RETRO_LANGUAGE_KOREAN: return PSP_SYSTEMPARAM_LANGUAGE_KOREAN;
return PSP_SYSTEMPARAM_LANGUAGE_KOREAN; case RETRO_LANGUAGE_CHINESE_TRADITIONAL:
case RETRO_LANGUAGE_CHINESE_TRADITIONAL: return PSP_SYSTEMPARAM_LANGUAGE_CHINESE_TRADITIONAL;
return PSP_SYSTEMPARAM_LANGUAGE_CHINESE_TRADITIONAL; case RETRO_LANGUAGE_CHINESE_SIMPLIFIED:
case RETRO_LANGUAGE_CHINESE_SIMPLIFIED: return PSP_SYSTEMPARAM_LANGUAGE_CHINESE_SIMPLIFIED;
return PSP_SYSTEMPARAM_LANGUAGE_CHINESE_SIMPLIFIED;
} }
} }
static void check_variables(CoreParameter &coreParam) static void check_variables(CoreParameter &coreParam) {
{
bool updated = false; bool updated = false;
if (coreState != CORE_POWERUP && environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && !updated) if (coreState != CORE_POWERUP && environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && !updated)
@ -297,15 +278,14 @@ static void check_variables(CoreParameter &coreParam)
ppsspp_cpu_core.Update((CPUCore *)&g_Config.iCpuCore); ppsspp_cpu_core.Update((CPUCore *)&g_Config.iCpuCore);
ppsspp_language.Update(&g_Config.iLanguage); ppsspp_language.Update(&g_Config.iLanguage);
if (g_Config.iLanguage < 0) if (g_Config.iLanguage < 0) {
g_Config.iLanguage = get_language_auto(); g_Config.iLanguage = get_language_auto();
}
if (ppsspp_internal_resolution.Update(&g_Config.iInternalResolution)) if (ppsspp_internal_resolution.Update(&g_Config.iInternalResolution)) {
{
coreParam.pixelWidth = coreParam.renderWidth = g_Config.iInternalResolution * 480; coreParam.pixelWidth = coreParam.renderWidth = g_Config.iInternalResolution * 480;
coreParam.pixelHeight = coreParam.renderHeight = g_Config.iInternalResolution * 272; coreParam.pixelHeight = coreParam.renderHeight = g_Config.iInternalResolution * 272;
if (gpu) if (gpu) {
{
retro_system_av_info av_info; retro_system_av_info av_info;
retro_get_system_av_info(&av_info); retro_get_system_av_info(&av_info);
environ_cb(RETRO_ENVIRONMENT_SET_SYSTEM_AV_INFO, &av_info); environ_cb(RETRO_ENVIRONMENT_SET_SYSTEM_AV_INFO, &av_info);
@ -313,11 +293,13 @@ static void check_variables(CoreParameter &coreParam)
} }
} }
if (ppsspp_texture_scaling_type.Update(&g_Config.iTexScalingType) && gpu) if (ppsspp_texture_scaling_type.Update(&g_Config.iTexScalingType) && gpu) {
gpu->ClearCacheNextFrame(); gpu->ClearCacheNextFrame();
}
if (ppsspp_texture_scaling_level.Update(&g_Config.iTexScalingLevel) && gpu) if (ppsspp_texture_scaling_level.Update(&g_Config.iTexScalingLevel) && gpu) {
gpu->ClearCacheNextFrame(); gpu->ClearCacheNextFrame();
}
} }
void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb) { audio_batch_cb = cb; } void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb) { audio_batch_cb = cb; }
@ -325,8 +307,7 @@ void retro_set_audio_sample(retro_audio_sample_t cb) { (void)cb; }
void retro_set_input_poll(retro_input_poll_t cb) { input_poll_cb = cb; } void retro_set_input_poll(retro_input_poll_t cb) { input_poll_cb = cb; }
void retro_set_input_state(retro_input_state_t cb) { input_state_cb = cb; } void retro_set_input_state(retro_input_state_t cb) { input_state_cb = cb; }
void retro_init(void) void retro_init(void) {
{
#if 0 #if 0
g_Config.Load(""); g_Config.Load("");
#endif #endif
@ -344,8 +325,7 @@ void retro_init(void)
host = new LibretroHost; host = new LibretroHost;
struct retro_log_callback log; struct retro_log_callback log;
if (environ_cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log)) if (environ_cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log)) {
{
printfLogger = new PrintfLogger(log); printfLogger = new PrintfLogger(log);
LogManager *logman = LogManager::GetInstance(); LogManager *logman = LogManager::GetInstance();
logman->RemoveListener(logman->GetConsoleListener()); logman->RemoveListener(logman->GetConsoleListener());
@ -358,8 +338,7 @@ void retro_init(void)
} }
} }
void retro_deinit(void) void retro_deinit(void) {
{
LogManager::Shutdown(); LogManager::Shutdown();
delete printfLogger; delete printfLogger;
@ -369,14 +348,12 @@ void retro_deinit(void)
host = nullptr; host = nullptr;
} }
void retro_set_controller_port_device(unsigned port, unsigned device) void retro_set_controller_port_device(unsigned port, unsigned device) {
{
(void)port; (void)port;
(void)device; (void)device;
} }
void retro_get_system_info(struct retro_system_info *info) void retro_get_system_info(struct retro_system_info *info) {
{
*info = {}; *info = {};
info->library_name = "PPSSPP"; info->library_name = "PPSSPP";
info->library_version = PPSSPP_GIT_VERSION; info->library_version = PPSSPP_GIT_VERSION;
@ -384,8 +361,7 @@ void retro_get_system_info(struct retro_system_info *info)
info->valid_extensions = "elf|iso|cso|prx|pbp"; info->valid_extensions = "elf|iso|cso|prx|pbp";
} }
void retro_get_system_av_info(struct retro_system_av_info *info) void retro_get_system_av_info(struct retro_system_av_info *info) {
{
*info = {}; *info = {};
info->timing.fps = 60.0f / 1.001f; info->timing.fps = 60.0f / 1.001f;
info->timing.sample_rate = SAMPLERATE; info->timing.sample_rate = SAMPLERATE;
@ -404,11 +380,11 @@ bool useEmuThread = false;
std::atomic<EmuThreadState> emuThreadState(EmuThreadState::DISABLED); std::atomic<EmuThreadState> emuThreadState(EmuThreadState::DISABLED);
static std::thread emuThread; static std::thread emuThread;
static void EmuFrame() static void EmuFrame() {
{
ctx->SetRenderTarget(); ctx->SetRenderTarget();
if (ctx->GetDrawContext()) if (ctx->GetDrawContext()) {
ctx->GetDrawContext()->BeginFrame(); ctx->GetDrawContext()->BeginFrame();
}
gpu->BeginHostFrame(); gpu->BeginHostFrame();
@ -417,60 +393,55 @@ static void EmuFrame()
gpu->EndHostFrame(); gpu->EndHostFrame();
if (ctx->GetDrawContext()) if (ctx->GetDrawContext()) {
ctx->GetDrawContext()->EndFrame(); ctx->GetDrawContext()->EndFrame();
}
} }
static void EmuThreadFunc() static void EmuThreadFunc() {
{
setCurrentThreadName("Emu"); setCurrentThreadName("Emu");
while (true) while (true) {
{ switch ((EmuThreadState)emuThreadState) {
switch ((EmuThreadState)emuThreadState) case EmuThreadState::START_REQUESTED:
{ emuThreadState = EmuThreadState::RUNNING;
case EmuThreadState::START_REQUESTED: /* fallthrough */
emuThreadState = EmuThreadState::RUNNING; case EmuThreadState::RUNNING:
/* fallthrough */ EmuFrame();
case EmuThreadState::RUNNING: break;
EmuFrame(); case EmuThreadState::PAUSE_REQUESTED:
break; emuThreadState = EmuThreadState::PAUSED;
case EmuThreadState::PAUSE_REQUESTED: /* fallthrough */
emuThreadState = EmuThreadState::PAUSED; case EmuThreadState::PAUSED:
/* fallthrough */ sleep_ms(1);
case EmuThreadState::PAUSED: break;
sleep_ms(1); default:
break; case EmuThreadState::QUIT_REQUESTED:
default: emuThreadState = EmuThreadState::STOPPED;
case EmuThreadState::QUIT_REQUESTED: ctx->StopThread();
emuThreadState = EmuThreadState::STOPPED; return;
ctx->StopThread();
return;
} }
} }
} }
void EmuThreadStart() void EmuThreadStart() {
{
bool wasPaused = emuThreadState == EmuThreadState::PAUSED; bool wasPaused = emuThreadState == EmuThreadState::PAUSED;
emuThreadState = EmuThreadState::START_REQUESTED; emuThreadState = EmuThreadState::START_REQUESTED;
if (!wasPaused) if (!wasPaused) {
{
ctx->ThreadStart(); ctx->ThreadStart();
emuThread = std::thread(&EmuThreadFunc); emuThread = std::thread(&EmuThreadFunc);
} }
} }
void EmuThreadStop() void EmuThreadStop() {
{ if (emuThreadState != EmuThreadState::RUNNING) {
if (emuThreadState != EmuThreadState::RUNNING)
return; return;
}
emuThreadState = EmuThreadState::QUIT_REQUESTED; emuThreadState = EmuThreadState::QUIT_REQUESTED;
while (ctx->ThreadFrame()) while (ctx->ThreadFrame()) {
{
// Need to keep eating frames to allow the EmuThread to exit correctly. // Need to keep eating frames to allow the EmuThread to exit correctly.
continue; continue;
} }
@ -479,20 +450,20 @@ void EmuThreadStop()
ctx->ThreadEnd(); ctx->ThreadEnd();
} }
void EmuThreadPause() void EmuThreadPause() {
{ if (emuThreadState != EmuThreadState::RUNNING) {
if (emuThreadState != EmuThreadState::RUNNING)
return; return;
}
emuThreadState = EmuThreadState::PAUSE_REQUESTED; emuThreadState = EmuThreadState::PAUSE_REQUESTED;
ctx->ThreadFrame(); ctx->ThreadFrame();
while (emuThreadState != EmuThreadState::PAUSED) while (emuThreadState != EmuThreadState::PAUSED) {
sleep_ms(1); sleep_ms(1);
}
} }
} // namespace Libretro } // namespace Libretro
bool retro_load_game(const struct retro_game_info *game) bool retro_load_game(const struct retro_game_info *game) {
{
struct retro_input_descriptor desc[] = { struct retro_input_descriptor desc[] = {
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left" }, { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up" }, { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up" },
@ -513,22 +484,21 @@ bool retro_load_game(const struct retro_game_info *game)
environ_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, desc); environ_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, desc);
enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_XRGB8888; enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_XRGB8888;
if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt)) if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt)) {
{
ERROR_LOG(SYSTEM, "XRGB8888 is not supported.\n"); ERROR_LOG(SYSTEM, "XRGB8888 is not supported.\n");
return false; return false;
} }
const char *nickname = NULL; const char *nickname = NULL;
if (environ_cb(RETRO_ENVIRONMENT_GET_USERNAME, &nickname) && nickname) if (environ_cb(RETRO_ENVIRONMENT_GET_USERNAME, &nickname) && nickname) {
g_Config.sNickName = std::string(nickname); g_Config.sNickName = std::string(nickname);
}
const char *dir_ptr = NULL; const char *dir_ptr = NULL;
static std::string retro_base_dir; static std::string retro_base_dir;
static std::string retro_save_dir; static std::string retro_save_dir;
if (environ_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &dir_ptr) && dir_ptr) if (environ_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &dir_ptr) && dir_ptr) {
{
retro_base_dir = dir_ptr; retro_base_dir = dir_ptr;
// Make sure that we don't have any lingering slashes, etc, as they break Windows. // Make sure that we don't have any lingering slashes, etc, as they break Windows.
size_t last = retro_base_dir.find_last_not_of(DIR_SEP_CHRS); size_t last = retro_base_dir.find_last_not_of(DIR_SEP_CHRS);
@ -538,8 +508,7 @@ bool retro_load_game(const struct retro_game_info *game)
retro_base_dir = retro_base_dir.substr(0, last) + DIR_SEP; retro_base_dir = retro_base_dir.substr(0, last) + DIR_SEP;
} }
if (environ_cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &dir_ptr) && dir_ptr) if (environ_cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &dir_ptr) && dir_ptr) {
{
retro_save_dir = dir_ptr; retro_save_dir = dir_ptr;
// Make sure that we don't have any lingering slashes, etc, as they break Windows. // Make sure that we don't have any lingering slashes, etc, as they break Windows.
size_t last = retro_save_dir.find_last_not_of(DIR_SEP_CHRS); size_t last = retro_save_dir.find_last_not_of(DIR_SEP_CHRS);
@ -549,13 +518,15 @@ bool retro_load_game(const struct retro_game_info *game)
retro_save_dir = retro_save_dir.substr(0, last) + DIR_SEP; retro_save_dir = retro_save_dir.substr(0, last) + DIR_SEP;
} }
if (retro_base_dir.empty()) if (retro_base_dir.empty()) {
retro_base_dir = File::GetDir(game->path); retro_base_dir = File::GetDir(game->path);
}
retro_base_dir += "PPSSPP" DIR_SEP; retro_base_dir += "PPSSPP" DIR_SEP;
if (retro_save_dir.empty()) if (retro_save_dir.empty()) {
retro_save_dir = File::GetDir(game->path); retro_save_dir = File::GetDir(game->path);
}
g_Config.currentDirectory = retro_base_dir; g_Config.currentDirectory = retro_base_dir;
g_Config.externalDirectory = retro_base_dir; g_Config.externalDirectory = retro_base_dir;
@ -592,8 +563,7 @@ bool retro_load_game(const struct retro_game_info *game)
#endif #endif
std::string error_string; std::string error_string;
if (!PSP_InitStart(coreParam, &error_string)) if (!PSP_InitStart(coreParam, &error_string)) {
{
ERROR_LOG(BOOT, "%s", error_string.c_str()); ERROR_LOG(BOOT, "%s", error_string.c_str());
return false; return false;
} }
@ -601,10 +571,10 @@ bool retro_load_game(const struct retro_game_info *game)
return true; return true;
} }
void retro_unload_game(void) void retro_unload_game(void) {
{ if (Libretro::useEmuThread) {
if (Libretro::useEmuThread)
Libretro::EmuThreadStop(); Libretro::EmuThreadStop();
}
PSP_Shutdown(); PSP_Shutdown();
VFSShutdown(); VFSShutdown();
@ -614,30 +584,27 @@ void retro_unload_game(void)
PSP_CoreParameter().graphicsContext = nullptr; PSP_CoreParameter().graphicsContext = nullptr;
} }
void retro_reset(void) void retro_reset(void) {
{
std::string error_string; std::string error_string;
PSP_Shutdown(); PSP_Shutdown();
#if 0 #if 0
coreState = CORE_POWERUP; coreState = CORE_POWERUP;
if(!PSP_InitStart(PSP_CoreParameter(), &error_string)) if (!PSP_InitStart(PSP_CoreParameter(), &error_string))
{ {
ERROR_LOG(BOOT, "%s", error_string.c_str()); ERROR_LOG(BOOT, "%s", error_string.c_str());
environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, nullptr); environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, nullptr);
} }
#else #else
if (!PSP_Init(PSP_CoreParameter(), &error_string)) if (!PSP_Init(PSP_CoreParameter(), &error_string)) {
{
ERROR_LOG(BOOT, "%s", error_string.c_str()); ERROR_LOG(BOOT, "%s", error_string.c_str());
environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, nullptr); environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, nullptr);
} }
#endif #endif
} }
static void retro_input(void) static void retro_input(void) {
{
// clang-format off // clang-format off
static struct static struct
{ {
@ -661,36 +628,34 @@ static void retro_input(void)
input_poll_cb(); input_poll_cb();
for (int i = 0; i < sizeof(map) / sizeof(*map); i++) for (int i = 0; i < sizeof(map) / sizeof(*map); i++) {
{ if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, map[i].retro)) {
if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, map[i].retro))
__CtrlButtonDown(map[i].sceCtrl); __CtrlButtonDown(map[i].sceCtrl);
else } else {
__CtrlButtonUp(map[i].sceCtrl); __CtrlButtonUp(map[i].sceCtrl);
}
} }
__CtrlSetAnalogX(input_state_cb(0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X) / 32768.0f); __CtrlSetAnalogX(input_state_cb(0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X) / 32768.0f);
__CtrlSetAnalogY(input_state_cb(0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y) / -32768.0f); __CtrlSetAnalogY(input_state_cb(0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y) / -32768.0f);
} }
void retro_run(void) void retro_run(void) {
{ if (PSP_IsIniting()) {
if (PSP_IsIniting())
{
std::string error_string; std::string error_string;
#if 0 #if 0
if(!PSP_InitUpdate(&error_string)) if (!PSP_InitUpdate(&error_string))
{ {
graphics_context->SwapBuffers(); graphics_context->SwapBuffers();
return; return;
} }
#else #else
while (!PSP_InitUpdate(&error_string)) while (!PSP_InitUpdate(&error_string)) {
sleep_ms(4); sleep_ms(4);
}
#endif #endif
if (!PSP_IsInited()) if (!PSP_IsInited()) {
{
ERROR_LOG(BOOT, "%s", error_string.c_str()); ERROR_LOG(BOOT, "%s", error_string.c_str());
environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, nullptr); environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, nullptr);
return; return;
@ -701,24 +666,24 @@ void retro_run(void)
retro_input(); retro_input();
if (useEmuThread) if (useEmuThread) {
{ if (emuThreadState != EmuThreadState::RUNNING) {
if (emuThreadState != EmuThreadState::RUNNING)
EmuThreadStart(); EmuThreadStart();
}
if (!ctx->ThreadFrame()) if (!ctx->ThreadFrame()) {
return; return;
} }
else } else {
EmuFrame(); EmuFrame();
}
ctx->SwapBuffers(); ctx->SwapBuffers();
} }
unsigned retro_get_region(void) { return RETRO_REGION_NTSC; } unsigned retro_get_region(void) { return RETRO_REGION_NTSC; }
bool retro_load_game_special(unsigned type, const struct retro_game_info *info, size_t num) bool retro_load_game_special(unsigned type, const struct retro_game_info *info, size_t num) {
{
(void)type; (void)type;
(void)info; (void)info;
(void)num; (void)num;
@ -726,62 +691,53 @@ bool retro_load_game_special(unsigned type, const struct retro_game_info *info,
} }
namespace SaveState { namespace SaveState {
struct SaveStart struct SaveStart {
{
void DoState(PointerWrap &p); void DoState(PointerWrap &p);
}; };
} // namespace SaveState } // namespace SaveState
size_t retro_serialize_size(void) size_t retro_serialize_size(void) {
{
SaveState::SaveStart state; SaveState::SaveStart state;
return (CChunkFileReader::MeasurePtr(state) + 0x800000) & ~0x7FFFFF; return (CChunkFileReader::MeasurePtr(state) + 0x800000) & ~0x7FFFFF;
} }
bool retro_serialize(void *data, size_t size) bool retro_serialize(void *data, size_t size) {
{
SaveState::SaveStart state; SaveState::SaveStart state;
assert(CChunkFileReader::MeasurePtr(state) <= size); assert(CChunkFileReader::MeasurePtr(state) <= size);
return CChunkFileReader::SavePtr((u8 *)data, state) == CChunkFileReader::ERROR_NONE; return CChunkFileReader::SavePtr((u8 *)data, state) == CChunkFileReader::ERROR_NONE;
} }
bool retro_unserialize(const void *data, size_t size) bool retro_unserialize(const void *data, size_t size) {
{
SaveState::SaveStart state; SaveState::SaveStart state;
return CChunkFileReader::LoadPtr((u8 *)data, state) == CChunkFileReader::ERROR_NONE; return CChunkFileReader::LoadPtr((u8 *)data, state) == CChunkFileReader::ERROR_NONE;
} }
void *retro_get_memory_data(unsigned id) void *retro_get_memory_data(unsigned id) {
{
(void)id; (void)id;
return NULL; return NULL;
} }
size_t retro_get_memory_size(unsigned id) size_t retro_get_memory_size(unsigned id) {
{
(void)id; (void)id;
return 0; return 0;
} }
void retro_cheat_reset(void) {} void retro_cheat_reset(void) {}
void retro_cheat_set(unsigned index, bool enabled, const char *code) void retro_cheat_set(unsigned index, bool enabled, const char *code) {
{
(void)index; (void)index;
(void)enabled; (void)enabled;
(void)code; (void)code;
} }
int System_GetPropertyInt(SystemProperty prop) int System_GetPropertyInt(SystemProperty prop) {
{ switch (prop) {
switch (prop) case SYSPROP_AUDIO_SAMPLE_RATE:
{ return SAMPLERATE;
case SYSPROP_AUDIO_SAMPLE_RATE: case SYSPROP_DISPLAY_REFRESH_RATE:
return SAMPLERATE; return 60000;
case SYSPROP_DISPLAY_REFRESH_RATE: default:
return 60000; return -1;
default:
return -1;
} }
} }

166
libretro/libretro_vulkan.cpp
View file

@ -10,8 +10,7 @@
static retro_hw_render_interface_vulkan *vulkan; static retro_hw_render_interface_vulkan *vulkan;
static struct static struct {
{
VkInstance instance; VkInstance instance;
VkPhysicalDevice gpu; VkPhysicalDevice gpu;
VkSurfaceKHR surface; VkSurfaceKHR surface;
@ -36,11 +35,9 @@ extern PFN_vkDestroyImageView vkDestroyImageView;
extern PFN_vkFreeMemory vkFreeMemory; extern PFN_vkFreeMemory vkFreeMemory;
#define VULKAN_MAX_SWAPCHAIN_IMAGES 8 #define VULKAN_MAX_SWAPCHAIN_IMAGES 8
struct VkSwapchainKHR_T struct VkSwapchainKHR_T {
{
uint32_t count; uint32_t count;
struct struct {
{
VkImage handle; VkImage handle;
VkDeviceMemory memory; VkDeviceMemory memory;
retro_vulkan_image retro_image; retro_vulkan_image retro_image;
@ -51,46 +48,43 @@ struct VkSwapchainKHR_T
}; };
static VkSwapchainKHR_T chain; static VkSwapchainKHR_T chain;
#define LIBRETRO_VK_WARP_LIST() \ #define LIBRETRO_VK_WARP_LIST() \
LIBRETRO_VK_WARP_FUNC(vkDestroyInstance); \ LIBRETRO_VK_WARP_FUNC(vkDestroyInstance); \
LIBRETRO_VK_WARP_FUNC(vkCreateDevice); \ LIBRETRO_VK_WARP_FUNC(vkCreateDevice); \
LIBRETRO_VK_WARP_FUNC(vkDestroyDevice); \ LIBRETRO_VK_WARP_FUNC(vkDestroyDevice); \
LIBRETRO_VK_WARP_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); \ LIBRETRO_VK_WARP_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); \
LIBRETRO_VK_WARP_FUNC(vkDestroySurfaceKHR); \ LIBRETRO_VK_WARP_FUNC(vkDestroySurfaceKHR); \
LIBRETRO_VK_WARP_FUNC(vkCreateSwapchainKHR); \ LIBRETRO_VK_WARP_FUNC(vkCreateSwapchainKHR); \
LIBRETRO_VK_WARP_FUNC(vkGetSwapchainImagesKHR); \ LIBRETRO_VK_WARP_FUNC(vkGetSwapchainImagesKHR); \
LIBRETRO_VK_WARP_FUNC(vkAcquireNextImageKHR); \ LIBRETRO_VK_WARP_FUNC(vkAcquireNextImageKHR); \
LIBRETRO_VK_WARP_FUNC(vkQueuePresentKHR); \ LIBRETRO_VK_WARP_FUNC(vkQueuePresentKHR); \
LIBRETRO_VK_WARP_FUNC(vkDestroySwapchainKHR); \ LIBRETRO_VK_WARP_FUNC(vkDestroySwapchainKHR); \
LIBRETRO_VK_WARP_FUNC(vkQueueSubmit); \ LIBRETRO_VK_WARP_FUNC(vkQueueSubmit); \
LIBRETRO_VK_WARP_FUNC(vkQueueWaitIdle); \ LIBRETRO_VK_WARP_FUNC(vkQueueWaitIdle); \
LIBRETRO_VK_WARP_FUNC(vkCmdPipelineBarrier); \ LIBRETRO_VK_WARP_FUNC(vkCmdPipelineBarrier); \
LIBRETRO_VK_WARP_FUNC(vkCreateRenderPass) LIBRETRO_VK_WARP_FUNC(vkCreateRenderPass)
#define LIBRETRO_VK_WARP_FUNC(x) \ #define LIBRETRO_VK_WARP_FUNC(x) \
extern PFN_##x x; \ extern PFN_##x x; \
PFN_##x x##_org PFN_##x x##_org
LIBRETRO_VK_WARP_FUNC(vkGetInstanceProcAddr); LIBRETRO_VK_WARP_FUNC(vkGetInstanceProcAddr);
LIBRETRO_VK_WARP_FUNC(vkGetDeviceProcAddr); LIBRETRO_VK_WARP_FUNC(vkGetDeviceProcAddr);
LIBRETRO_VK_WARP_LIST(); LIBRETRO_VK_WARP_LIST();
static VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance_libretro(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) static VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance_libretro(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
{
*pInstance = vk_init_info.instance; *pInstance = vk_init_info.instance;
return VK_SUCCESS; return VK_SUCCESS;
} }
static void add_name_unique(std::vector<const char *> &list, const char *value) static void add_name_unique(std::vector<const char *> &list, const char *value) {
{
for (const char *name : list) for (const char *name : list)
if (!strcmp(value, name)) if (!strcmp(value, name))
return; return;
list.push_back(value); list.push_back(value);
} }
static VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice_libretro(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) static VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice_libretro(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
{
VkDeviceCreateInfo info = *pCreateInfo; VkDeviceCreateInfo info = *pCreateInfo;
std::vector<const char *> EnabledLayerNames(info.ppEnabledLayerNames, info.ppEnabledLayerNames + info.enabledLayerCount); std::vector<const char *> EnabledLayerNames(info.ppEnabledLayerNames, info.ppEnabledLayerNames + info.enabledLayerCount);
std::vector<const char *> EnabledExtensionNames(info.ppEnabledExtensionNames, info.ppEnabledExtensionNames + info.enabledExtensionCount); std::vector<const char *> EnabledExtensionNames(info.ppEnabledExtensionNames, info.ppEnabledExtensionNames + info.enabledExtensionCount);
@ -103,14 +97,12 @@ static VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice_libretro(VkPhysicalDevice p
add_name_unique(EnabledExtensionNames, vk_init_info.required_device_extensions[i]); add_name_unique(EnabledExtensionNames, vk_init_info.required_device_extensions[i]);
add_name_unique(EnabledExtensionNames, VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME); add_name_unique(EnabledExtensionNames, VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME);
for (unsigned i = 0; i < sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); i++) for (unsigned i = 0; i < sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); i++) {
{
if (((VkBool32 *)vk_init_info.required_features)[i]) if (((VkBool32 *)vk_init_info.required_features)[i])
((VkBool32 *)&EnabledFeatures)[i] = VK_TRUE; ((VkBool32 *)&EnabledFeatures)[i] = VK_TRUE;
} }
for (auto extension_name : EnabledExtensionNames) for (auto extension_name : EnabledExtensionNames) {
{
if (!strcmp(extension_name, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME)) if (!strcmp(extension_name, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME))
DEDICATED_ALLOCATION = true; DEDICATED_ALLOCATION = true;
} }
@ -124,35 +116,28 @@ static VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice_libretro(VkPhysicalDevice p
return vkCreateDevice_org(physicalDevice, &info, pAllocator, pDevice); return vkCreateDevice_org(physicalDevice, &info, pAllocator, pDevice);
} }
static VKAPI_ATTR VkResult VKAPI_CALL vkCreateLibretroSurfaceKHR(VkInstance instance, const void *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) static VKAPI_ATTR VkResult VKAPI_CALL vkCreateLibretroSurfaceKHR(VkInstance instance, const void *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
{
*pSurface = vk_init_info.surface; *pSurface = vk_init_info.surface;
return VK_SUCCESS; return VK_SUCCESS;
} }
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR_libretro(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR_libretro(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
{
VkResult res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR_org(physicalDevice, surface, pSurfaceCapabilities); VkResult res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR_org(physicalDevice, surface, pSurfaceCapabilities);
if (res == VK_SUCCESS) if (res == VK_SUCCESS) {
{
pSurfaceCapabilities->currentExtent.width = -1; pSurfaceCapabilities->currentExtent.width = -1;
pSurfaceCapabilities->currentExtent.height = -1; pSurfaceCapabilities->currentExtent.height = -1;
} }
return res; return res;
} }
static bool MemoryTypeFromProperties(uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex) static bool MemoryTypeFromProperties(uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex) {
{
VkPhysicalDeviceMemoryProperties memory_properties; VkPhysicalDeviceMemoryProperties memory_properties;
vkGetPhysicalDeviceMemoryProperties(vulkan->gpu, &memory_properties); vkGetPhysicalDeviceMemoryProperties(vulkan->gpu, &memory_properties);
// Search memtypes to find first index with those properties // Search memtypes to find first index with those properties
for (uint32_t i = 0; i < 32; i++) for (uint32_t i = 0; i < 32; i++) {
{ if ((typeBits & 1) == 1) {
if ((typeBits & 1) == 1)
{
// Type is available, does it match user properties? // Type is available, does it match user properties?
if ((memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) if ((memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) {
{
*typeIndex = i; *typeIndex = i;
return true; return true;
} }
@ -163,20 +148,17 @@ static bool MemoryTypeFromProperties(uint32_t typeBits, VkFlags requirements_mas
return false; return false;
} }
static VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR_libretro(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) static VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR_libretro(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
{
uint32_t swapchain_mask = vulkan->get_sync_index_mask(vulkan->handle); uint32_t swapchain_mask = vulkan->get_sync_index_mask(vulkan->handle);
chain.count = 0; chain.count = 0;
while (swapchain_mask) while (swapchain_mask) {
{
chain.count++; chain.count++;
swapchain_mask >>= 1; swapchain_mask >>= 1;
} }
assert(chain.count <= VULKAN_MAX_SWAPCHAIN_IMAGES); assert(chain.count <= VULKAN_MAX_SWAPCHAIN_IMAGES);
for (uint32_t i = 0; i < chain.count; i++) for (uint32_t i = 0; i < chain.count; i++) {
{
{ {
VkImageCreateInfo info{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO }; VkImageCreateInfo info{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
info.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; info.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
@ -202,8 +184,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR_libretro(VkDevice dev
alloc.allocationSize = memreq.size; alloc.allocationSize = memreq.size;
VkMemoryDedicatedAllocateInfoKHR dedicated{ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR }; VkMemoryDedicatedAllocateInfoKHR dedicated{ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
if (DEDICATED_ALLOCATION) if (DEDICATED_ALLOCATION) {
{
alloc.pNext = &dedicated; alloc.pNext = &dedicated;
dedicated.image = chain.images[i].handle; dedicated.image = chain.images[i].handle;
} }
@ -233,23 +214,19 @@ static VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR_libretro(VkDevice dev
return VK_SUCCESS; return VK_SUCCESS;
} }
static VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR_libretro(VkDevice device, VkSwapchainKHR swapchain_, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) static VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR_libretro(VkDevice device, VkSwapchainKHR swapchain_, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) {
{
VkSwapchainKHR_T *swapchain = (VkSwapchainKHR_T *)swapchain_; VkSwapchainKHR_T *swapchain = (VkSwapchainKHR_T *)swapchain_;
if (pSwapchainImages) if (pSwapchainImages) {
{
assert(*pSwapchainImageCount <= swapchain->count); assert(*pSwapchainImageCount <= swapchain->count);
for (int i = 0; i < *pSwapchainImageCount; i++) for (int i = 0; i < *pSwapchainImageCount; i++)
pSwapchainImages[i] = swapchain->images[i].handle; pSwapchainImages[i] = swapchain->images[i].handle;
} } else
else
*pSwapchainImageCount = swapchain->count; *pSwapchainImageCount = swapchain->count;
return VK_SUCCESS; return VK_SUCCESS;
} }
static VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR_libretro(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) static VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR_libretro(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
{
vulkan->wait_sync_index(vulkan->handle); vulkan->wait_sync_index(vulkan->handle);
*pImageIndex = vulkan->get_sync_index(vulkan->handle); *pImageIndex = vulkan->get_sync_index(vulkan->handle);
#if 0 #if 0
@ -258,8 +235,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR_libretro(VkDevice de
return VK_SUCCESS; return VK_SUCCESS;
} }
static VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR_libretro(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) static VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR_libretro(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
{
VkSwapchainKHR_T *swapchain = (VkSwapchainKHR_T *)pPresentInfo->pSwapchains[0]; VkSwapchainKHR_T *swapchain = (VkSwapchainKHR_T *)pPresentInfo->pSwapchains[0];
std::unique_lock<std::mutex> lock(swapchain->mutex); std::unique_lock<std::mutex> lock(swapchain->mutex);
#if 0 #if 0
@ -278,8 +254,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR_libretro(VkQueue queue,
return VK_SUCCESS; return VK_SUCCESS;
} }
void vk_libretro_wait_for_presentation() void vk_libretro_wait_for_presentation() {
{
std::unique_lock<std::mutex> lock(chain.mutex); std::unique_lock<std::mutex> lock(chain.mutex);
if (chain.current_index < 0) if (chain.current_index < 0)
chain.condVar.wait(lock); chain.condVar.wait(lock);
@ -292,10 +267,8 @@ void vk_libretro_wait_for_presentation()
static VKAPI_ATTR void VKAPI_CALL vkDestroyInstance_libretro(VkInstance instance, const VkAllocationCallbacks *pAllocator) {} static VKAPI_ATTR void VKAPI_CALL vkDestroyInstance_libretro(VkInstance instance, const VkAllocationCallbacks *pAllocator) {}
static VKAPI_ATTR void VKAPI_CALL vkDestroyDevice_libretro(VkDevice device, const VkAllocationCallbacks *pAllocator) {} static VKAPI_ATTR void VKAPI_CALL vkDestroyDevice_libretro(VkDevice device, const VkAllocationCallbacks *pAllocator) {}
static VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR_libretro(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) {} static VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR_libretro(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) {}
static VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR_libretro(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) static VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR_libretro(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
{ for (int i = 0; i < chain.count; i++) {
for (int i = 0; i < chain.count; i++)
{
vkDestroyImage(device, chain.images[i].handle, pAllocator); vkDestroyImage(device, chain.images[i].handle, pAllocator);
vkDestroyImageView(device, chain.images[i].retro_image.image_view, pAllocator); vkDestroyImageView(device, chain.images[i].retro_image.image_view, pAllocator);
vkFreeMemory(device, chain.images[i].memory, pAllocator); vkFreeMemory(device, chain.images[i].memory, pAllocator);
@ -306,8 +279,7 @@ static VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR_libretro(VkDevice device
chain.current_index = -1; chain.current_index = -1;
} }
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit_libretro(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit_libretro(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) {
{
VkResult res = VK_SUCCESS; VkResult res = VK_SUCCESS;
#if 0 #if 0
@ -315,8 +287,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit_libretro(VkQueue queue, uint32_t su
vulkan->set_command_buffers(vulkan->handle, pSubmits[i].commandBufferCount, pSubmits[i].pCommandBuffers); vulkan->set_command_buffers(vulkan->handle, pSubmits[i].commandBufferCount, pSubmits[i].pCommandBuffers);
#else #else
#if 1 #if 1
for (int i = 0; i < submitCount; i++) for (int i = 0; i < submitCount; i++) {
{
((VkSubmitInfo *)pSubmits)[i].waitSemaphoreCount = 0; ((VkSubmitInfo *)pSubmits)[i].waitSemaphoreCount = 0;
((VkSubmitInfo *)pSubmits)[i].pWaitSemaphores = nullptr; ((VkSubmitInfo *)pSubmits)[i].pWaitSemaphores = nullptr;
((VkSubmitInfo *)pSubmits)[i].signalSemaphoreCount = 0; ((VkSubmitInfo *)pSubmits)[i].signalSemaphoreCount = 0;
@ -331,26 +302,21 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit_libretro(VkQueue queue, uint32_t su
return res; return res;
} }
VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle_libretro(VkQueue queue) VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle_libretro(VkQueue queue) {
{
vulkan->lock_queue(vulkan->handle); vulkan->lock_queue(vulkan->handle);
VkResult res = vkQueueWaitIdle_org(queue); VkResult res = vkQueueWaitIdle_org(queue);
vulkan->unlock_queue(vulkan->handle); vulkan->unlock_queue(vulkan->handle);
return res; return res;
} }
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier_libretro(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier_libretro(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
{
VkImageMemoryBarrier *barriers = (VkImageMemoryBarrier *)pImageMemoryBarriers; VkImageMemoryBarrier *barriers = (VkImageMemoryBarrier *)pImageMemoryBarriers;
for (int i = 0; i < imageMemoryBarrierCount; i++) for (int i = 0; i < imageMemoryBarrierCount; i++) {
{ if (pImageMemoryBarriers[i].oldLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
if (pImageMemoryBarriers[i].oldLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)
{
barriers[i].oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; barriers[i].oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
barriers[i].srcAccessMask = VK_ACCESS_SHADER_READ_BIT; barriers[i].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
} }
if (pImageMemoryBarriers[i].newLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) if (pImageMemoryBarriers[i].newLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
{
barriers[i].newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; barriers[i].newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
barriers[i].dstAccessMask = VK_ACCESS_SHADER_READ_BIT; barriers[i].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
} }
@ -358,8 +324,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier_libretro(VkCommandBuffer command
return vkCmdPipelineBarrier_org(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, barriers); return vkCmdPipelineBarrier_org(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, barriers);
} }
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass_libretro(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass_libretro(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) {
{
if (pCreateInfo->pAttachments[0].finalLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) if (pCreateInfo->pAttachments[0].finalLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)
((VkAttachmentDescription *)pCreateInfo->pAttachments)[0].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; ((VkAttachmentDescription *)pCreateInfo->pAttachments)[0].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
@ -367,18 +332,15 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass_libretro(VkDevice device, cons
} }
#undef LIBRETRO_VK_WARP_FUNC #undef LIBRETRO_VK_WARP_FUNC
#define LIBRETRO_VK_WARP_FUNC(x) \ #define LIBRETRO_VK_WARP_FUNC(x) \
do \ do { \
{ \ if (!strcmp(pName, #x)) { \
if (!strcmp(pName, #x)) \ x##_org = (PFN_##x)fptr; \
{ \ return (PFN_vkVoidFunction)x##_libretro; \
x##_org = (PFN_##x)fptr; \ } \
return (PFN_vkVoidFunction)x##_libretro; \
} \
} while (0) } while (0)
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr_libretro(VkInstance instance, const char *pName) VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr_libretro(VkInstance instance, const char *pName) {
{
if (false if (false
#ifdef _WIN32 #ifdef _WIN32
|| !strcmp(pName, "vkCreateWin32SurfaceKHR") || !strcmp(pName, "vkCreateWin32SurfaceKHR")
@ -395,8 +357,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr_libretro(VkInstan
#ifdef VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR
|| !strcmp(pName, "vkCreateWaylandSurfaceKHR") || !strcmp(pName, "vkCreateWaylandSurfaceKHR")
#endif #endif
) ) {
{
return (PFN_vkVoidFunction)vkCreateLibretroSurfaceKHR; return (PFN_vkVoidFunction)vkCreateLibretroSurfaceKHR;
} }
@ -409,8 +370,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr_libretro(VkInstan
return fptr; return fptr;
} }
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr_libretro(VkDevice device, const char *pName) VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr_libretro(VkDevice device, const char *pName) {
{
PFN_vkVoidFunction fptr = vkGetDeviceProcAddr_org(device, pName); PFN_vkVoidFunction fptr = vkGetDeviceProcAddr_org(device, pName);
if (!fptr) if (!fptr)
return fptr; return fptr;
@ -420,8 +380,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr_libretro(VkDevice d
return fptr; return fptr;
} }
void vk_libretro_init(VkInstance instance, VkPhysicalDevice gpu, VkSurfaceKHR surface, PFN_vkGetInstanceProcAddr get_instance_proc_addr, const char **required_device_extensions, unsigned num_required_device_extensions, const char **required_device_layers, unsigned num_required_device_layers, const VkPhysicalDeviceFeatures *required_features) void vk_libretro_init(VkInstance instance, VkPhysicalDevice gpu, VkSurfaceKHR surface, PFN_vkGetInstanceProcAddr get_instance_proc_addr, const char **required_device_extensions, unsigned num_required_device_extensions, const char **required_device_layers, unsigned num_required_device_layers, const VkPhysicalDeviceFeatures *required_features) {
{
assert(surface); assert(surface);
vk_init_info.instance = instance; vk_init_info.instance = instance;
@ -442,8 +401,7 @@ void vk_libretro_init(VkInstance instance, VkPhysicalDevice gpu, VkSurfaceKHR su
} }
void vk_libretro_set_hwrender_interface(retro_hw_render_interface *hw_render_interface) { vulkan = (retro_hw_render_interface_vulkan *)hw_render_interface; } void vk_libretro_set_hwrender_interface(retro_hw_render_interface *hw_render_interface) { vulkan = (retro_hw_render_interface_vulkan *)hw_render_interface; }
void vk_libretro_shutdown() void vk_libretro_shutdown() {
{
memset(&vk_init_info, 0x00, sizeof(vk_init_info)); memset(&vk_init_info, 0x00, sizeof(vk_init_info));
vulkan = NULL; vulkan = NULL;
DEDICATED_ALLOCATION = false; DEDICATED_ALLOCATION = false;