Emulator-Archive/psOff_public
1
0
Fork 0
mirror of https://github.com/SysRay/psOff_public.git synced 2024-10-07 03:43:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

move main| dump

Browse Source
This commit is contained in:
Martin Baliet 2024-04-28 15:40:28 +02:00
parent fdaf97b9ea
commit 227ad2640d
23 changed files with 151 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
CMakeLists.txt
View File

@ -22,9 +22,7 @@ if(NOT PRJ_SRC_DIR)
set(PRJ_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
endif()
if(NOT DEFINED IMAGE_BASE)
set(IMAGE_BASE 0x10000000)
endif()
set(IMAGE_BASE 0x10000000)
# # Gather Infos
@ -68,16 +66,16 @@ ExternalProject_Add(third_party
)
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
ExternalProject_Add(renderer
ExternalProject_Add(psoff_render
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
PREFIX ${CMAKE_BINARY_DIR}/renderer
PREFIX ${CMAKE_BINARY_DIR}/psoff_render
BUILD_IN_SOURCE 1
URL https://github.com/SysRay/psOff_Renderer/releases/download/${PSOFF_RENDER_VERSION}/psOff-renderer.zip
)
install(FILES ${CMAKE_BINARY_DIR}/renderer/src/renderer/emulator.exe DESTINATION ${CMAKE_INSTALL_PREFIX})
install(FILES ${CMAKE_BINARY_DIR}/psoff_render/src/renderer/emulator.exe DESTINATION ${CMAKE_INSTALL_PREFIX})
endif()
set(TEST_BENCH OFF CACHE BOOL "Enable testing")
@ -106,6 +104,14 @@ add_subdirectory(tools/gamereport)
# #- Projects
# Executable
add_executable(psoff
main.cpp
)
add_dependencies(psoff logging)
target_link_options(psoff PUBLIC /DEBUG /DYNAMICBASE:NO --image-base=${IMAGE_BASE})
# # Install
install(DIRECTORY "${CMAKE_BINARY_DIR}/third_party/src/third_party/bin/" DESTINATION ${CMAKE_INSTALL_PREFIX}
FILES_MATCHING PATTERN "*.dll"

1
core/imports/CMakeLists.txt
View File

@ -1,6 +1,5 @@
add_library(imports OBJECT
imports.cpp
exit.cpp
intercepts.cpp
)

14
core/imports/exit.cpp
View File

@ -1,14 +0,0 @@
#define __APICALL_EXTERN
#include "imports_exit.h"
#undef __APICALL_EXTERN
#include "core/dmem/dmem.h"
/**
* @brief Exit handling of the core lib
*
*/
void core_exit() {
// signal handler context
}

14
core/imports/exports/graphics.h
View File

@ -28,11 +28,7 @@ class IEventsGraphics {
public:
virtual void eventDoFlip(int handle, int index, int64_t flipArg, VkSemaphore waitSema, size_t waitValue) = 0;
virtual vulkan::DeviceInfo* getDeviceInfo() = 0;
virtual vulkan::QueueInfo* getQueue(vulkan::QueueType type) = 0;
virtual VkPhysicalDeviceLimits const* getVulkanLimits() const = 0;
};
class IGraphics {
@ -163,4 +159,14 @@ class IGraphics {
* @return true success
*/
virtual bool copyDisplayBuffer(uint64_t vaddr, VkCommandBuffer cmdBuffer, VkImage dstImage, VkExtent2D dstExtent) = 0;
/**
* @brief Get the required memory alignment. Dont' call from constructor.
*
* @param format
* @param extent shouldn't matter if not 100% correct
* @return memory alignment
*/
virtual uint64_t getImageAlignment(VkFormat format, VkExtent3D const& extent) = 0;
};

4
core/imports/imports.cpp
View File

@ -13,9 +13,9 @@ static createGraphics_t g_createGraphics = nullptr;
static getEmulatorVersion_t g_getEmulatorVersion = nullptr;
std::unique_ptr<IGraphics> createGraphics(IEventsGraphics& listener, VkDevice device, VkPhysicalDevice physDev, VkInstance instance) {
std::unique_ptr<IGraphics> createGraphics(IEventsGraphics& listener, std::shared_ptr<vulkan::DeviceInfo>& deviceInfo) {
assert(g_createGraphics != nullptr);
return g_createGraphics(listener, device, physDev, instance);
return g_createGraphics(listener, deviceInfo);
}
std::string_view getEmulatorVersion() {

3
core/imports/imports.h
View File

@ -1,5 +1,6 @@
#pragma once
#include "core/videoout/vulkan/vulkanTypes.h"
#include "exports/graphics.h"
#include <memory>
@ -14,7 +15,7 @@
#define __APICALL
#endif
using createGraphics_t = std::unique_ptr<IGraphics> (*)(IEventsGraphics& listener, VkDevice device, VkPhysicalDevice physDev, VkInstance instance);
using createGraphics_t = std::unique_ptr<IGraphics> (*)(IEventsGraphics& listener, std::shared_ptr<vulkan::DeviceInfo>& deviceInfo);
using getEmulatorVersion_t = std::string_view (*)();

16
core/imports/imports_exit.h
View File

@ -1,16 +0,0 @@
#if defined(__APICALL_EXTERN)
#define __APICALL __declspec(dllexport)
#elif defined(__APICALL_IMPORT)
#define __APICALL __declspec(dllimport)
#else
#define __APICALL
#endif
/**
* @brief Called at exit
*
*/
__APICALL void core_exit();
#undef __APICALL

2
core/imports/imports_func.h
View File

@ -23,5 +23,5 @@
* @param instance
* @return object
*/
__APICALL std::unique_ptr<IGraphics> createGraphics(IEventsGraphics& listener, VkDevice device, VkPhysicalDevice physDev, VkInstance instance);
__APICALL std::unique_ptr<IGraphics> createGraphics(IEventsGraphics& listener, std::shared_ptr<vulkan::DeviceInfo>& deviceInfo);
#undef __APICALL

1
core/runtime/CMakeLists.txt
View File

@ -4,6 +4,7 @@ add_library(runtime OBJECT
util/virtualmemory.cpp
formats/elf64.cpp
exports/intern.cpp
runtimeLinker.cpp
)

13
core/runtime/exports/intern.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "../runtimeLinker.h"
#include "macro.h"
#include "utility/utility.h"
namespace intern {
SYSV_ABI void module_start(size_t argc, const void* argp, int* pRes) {}
void init() {
LIB_DEFINE_START("intern", 0, "intern", 0, 0)
LIB_FUNC("module_start", module_start), LIB_DEFINE_END();
}
} // namespace intern

5
core/runtime/exports/intern.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
namespace intern {
void init();
}

26
core/runtime/exports/macro.h Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#define LIB_DEFINE_START(lib, ver, mod, verMajor, verMinor) \
{ \
auto libInfo = std::make_unique<Symbols::SymbolExport>(lib, ver, mod, verMajor, verMinor); \
libInfo->symbolsMap = {
#define LIB_FUNC(sym, func) \
{ \
sym, { \
sym, #func, reinterpret_cast<uint64_t>(func), Symbols::SymbolType::Func \
} \
}
#define LIB_OBJECT(sym, obj) \
{ \
sym, { \
sym, #obj, reinterpret_cast<uint64_t>(obj), Symbols::SymbolType::Object \
} \
}
#define LIB_DEFINE_END() \
} \
; \
accessRuntimeLinker().addExport(std::move(libInfo)); \
}

53
core/videoout/imageHandler.cpp
View File

@ -14,7 +14,7 @@ constexpr uint32_t NUM_DISPLAY_BUFFERS = 3;
class ImageHandler: public IImageHandler {
uint32_t m_maxImages = 1;
VkDevice m_device;
std::shared_ptr<vulkan::DeviceInfo> m_deviceInfo;
// Vulkan internal
VkSwapchainKHR m_swapchain = nullptr;
@ -45,8 +45,8 @@ class ImageHandler: public IImageHandler {
bool m_stop = false;
public:
ImageHandler(VkDevice vkDevice, VkExtent2D extentWindow, vulkan::QueueInfo* queue, ImageHandlerCB* callback)
: IImageHandler(extentWindow, queue, callback), m_device(vkDevice) {};
ImageHandler(std::shared_ptr<vulkan::DeviceInfo>& deviceInfo, VkExtent2D extentWindow, vulkan::QueueInfo* queue, ImageHandlerCB* callback)
: IImageHandler(extentWindow, queue, callback), m_deviceInfo(deviceInfo) {};
virtual ~ImageHandler() = default;
@ -68,14 +68,15 @@ class ImageHandler: public IImageHandler {
VkSwapchainKHR getSwapchain() const final { return m_swapchain; }
};
std::unique_ptr<IImageHandler> createImageHandler(VkDevice vkDevice, VkExtent2D extentWindow, vulkan::QueueInfo* queue, ImageHandlerCB* callback) {
return std::make_unique<ImageHandler>(vkDevice, extentWindow, queue, callback);
std::unique_ptr<IImageHandler> createImageHandler(std::shared_ptr<vulkan::DeviceInfo>& deviceInfo, VkExtent2D extentWindow, vulkan::QueueInfo* queue,
ImageHandlerCB* callback) {
return std::make_unique<ImageHandler>(deviceInfo, extentWindow, queue, callback);
}
void ImageHandler::recreate() {
LOG_USE_MODULE(ImageHandler);
vkDeviceWaitIdle(m_device);
vkDeviceWaitIdle(m_deviceInfo->device);
auto const newExtent = m_callback->getWindowSize();
if (newExtent.width != m_extentWindow.width || newExtent.height != m_extentWindow.height) {
@ -85,19 +86,19 @@ void ImageHandler::recreate() {
m_swapchainCreateInfo.oldSwapchain = m_swapchain;
VkSwapchainKHR newSwapchain;
if (auto result = vkCreateSwapchainKHR(m_device, &m_swapchainCreateInfo, nullptr, &newSwapchain); result != VK_SUCCESS) {
if (auto result = vkCreateSwapchainKHR(m_deviceInfo->device, &m_swapchainCreateInfo, nullptr, &newSwapchain); result != VK_SUCCESS) {
LOG_CRIT(L"Couldn't recreate swapchain: %d", result);
}
vkDestroySwapchainKHR(m_device, m_swapchain, nullptr); // Destroys images as well
vkDestroySwapchainKHR(m_deviceInfo->device, m_swapchain, nullptr); // Destroys images as well
m_swapchain = newSwapchain;
uint32_t numImages = 0;
vkGetSwapchainImagesKHR(m_device, m_swapchain, &numImages, nullptr);
vkGetSwapchainImagesKHR(m_deviceInfo->device, m_swapchain, &numImages, nullptr);
m_scImages.resize(numImages);
vkGetSwapchainImagesKHR(m_device, m_swapchain, &numImages, m_scImages.data());
vkGetSwapchainImagesKHR(m_deviceInfo->device, m_swapchain, &numImages, m_scImages.data());
}
}
@ -127,7 +128,7 @@ std::optional<ImageData> ImageHandler::getImage_blocking() {
VkResult result = VK_SUCCESS;
for (; numTries >= 0; --numTries) {
// toggle every 1ms
if (result = vkAcquireNextImageKHR(m_device, m_swapchain, (uint64_t)1e6, imageData.semImageReady, VK_NULL_HANDLE, &imageData.index);
if (result = vkAcquireNextImageKHR(m_deviceInfo->device, m_swapchain, (uint64_t)1e6, imageData.semImageReady, VK_NULL_HANDLE, &imageData.index);
result != VK_SUCCESS) {
if (result == VK_NOT_READY) {
std::this_thread::sleep_for(std::chrono::microseconds(100));
@ -177,8 +178,8 @@ void ImageHandler::notify_done(ImageData const& imageData) {
LOG_USE_MODULE(ImageHandler);
// vkQueuePresentKHR: amd waits and nvidia doesn't -> manual wait
vkWaitForFences(m_device, 1, &imageData.submitFence, VK_TRUE, UINT64_MAX);
vkResetFences(m_device, 1, &imageData.submitFence);
vkWaitForFences(m_deviceInfo->device, 1, &imageData.submitFence, VK_TRUE, UINT64_MAX);
vkResetFences(m_deviceInfo->device, 1, &imageData.submitFence);
vkResetCommandBuffer(imageData.cmdBuffer, VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
@ -212,9 +213,9 @@ void ImageHandler::init(vulkan::VulkanObj* obj, VkSurfaceKHR surface) {
m_fenceSubmit.resize(m_maxImages);
for (size_t n = 0; n < m_maxImages; ++n) {
vkCreateSemaphore(m_device, &semCreateInfo, nullptr, &m_semsImageReady[n]);
vkCreateSemaphore(m_device, &semCreateInfo, nullptr, &m_semsImageCopied[n]);
vkCreateFence(obj->deviceInfo.device, &fenceCreateInfo, nullptr, &m_fenceSubmit[n]);
vkCreateSemaphore(m_deviceInfo->device, &semCreateInfo, nullptr, &m_semsImageReady[n]);
vkCreateSemaphore(m_deviceInfo->device, &semCreateInfo, nullptr, &m_semsImageCopied[n]);
vkCreateFence(m_deviceInfo->device, &fenceCreateInfo, nullptr, &m_fenceSubmit[n]);
}
}
@ -254,15 +255,15 @@ void ImageHandler::init(vulkan::VulkanObj* obj, VkSurfaceKHR surface) {
.oldSwapchain = nullptr,
};
vkCreateSwapchainKHR(obj->deviceInfo.device, &m_swapchainCreateInfo, nullptr, &m_swapchain);
vkCreateSwapchainKHR(m_deviceInfo->device, &m_swapchainCreateInfo, nullptr, &m_swapchain);
}
{ // swapchain images
uint32_t numImages = 0;
vkGetSwapchainImagesKHR(m_device, m_swapchain, &numImages, nullptr);
vkGetSwapchainImagesKHR(m_deviceInfo->device, m_swapchain, &numImages, nullptr);
m_scImages.resize(numImages);
vkGetSwapchainImagesKHR(m_device, m_swapchain, &numImages, m_scImages.data());
vkGetSwapchainImagesKHR(m_deviceInfo->device, m_swapchain, &numImages, m_scImages.data());
}
{ // Command buffer
@ -273,7 +274,7 @@ void ImageHandler::init(vulkan::VulkanObj* obj, VkSurfaceKHR surface) {
.queueFamilyIndex = m_queue->family,
};
if (auto result = vkCreateCommandPool(obj->deviceInfo.device, &poolInfo, nullptr, &m_commandPool); result != VK_SUCCESS) {
if (auto result = vkCreateCommandPool(m_deviceInfo->device, &poolInfo, nullptr, &m_commandPool); result != VK_SUCCESS) {
LOG_CRIT(L"Couldn't create commandpool(graphics): %d", result);
}
@ -285,7 +286,7 @@ void ImageHandler::init(vulkan::VulkanObj* obj, VkSurfaceKHR surface) {
.commandBufferCount = m_maxImages,
};
if (auto result = vkAllocateCommandBuffers(obj->deviceInfo.device, &allocInfo, m_commandBuffer.data()); result != VK_SUCCESS) {
if (auto result = vkAllocateCommandBuffers(m_deviceInfo->device, &allocInfo, m_commandBuffer.data()); result != VK_SUCCESS) {
LOG_CRIT(L"Couldn't create commandbuffers(graphics): %d", result);
}
}
@ -295,17 +296,17 @@ void ImageHandler::deinit() {
printf("deinit ImageHandler\n");
for (auto& sem: m_semsImageReady) {
vkDestroySemaphore(m_device, sem, nullptr);
vkDestroySemaphore(m_deviceInfo->device, sem, nullptr);
}
for (auto& sem: m_semsImageCopied) {
vkDestroySemaphore(m_device, sem, nullptr);
vkDestroySemaphore(m_deviceInfo->device, sem, nullptr);
}
for (auto& fence: m_fenceSubmit) {
vkDestroyFence(m_device, fence, nullptr);
vkDestroyFence(m_deviceInfo->device, fence, nullptr);
}
if (m_commandPool != nullptr) vkDestroyCommandPool(m_device, m_commandPool, nullptr);
if (m_swapchain != nullptr) vkDestroySwapchainKHR(m_device, m_swapchain, nullptr);
if (m_commandPool != nullptr) vkDestroyCommandPool(m_deviceInfo->device, m_commandPool, nullptr);
if (m_swapchain != nullptr) vkDestroySwapchainKHR(m_deviceInfo->device, m_swapchain, nullptr);
printf("deinit ImageHandler| done\n");
}

4
core/videoout/imageHandler.h
View File

@ -1,4 +1,5 @@
#pragma once
#include "core/videoout/vulkan/vulkanTypes.h"
#include "utility/utility.h"
#include <optional>
@ -69,4 +70,5 @@ class IImageHandler {
virtual VkSwapchainKHR getSwapchain() const = 0;
};
std::unique_ptr<IImageHandler> createImageHandler(VkDevice vkDevice, VkExtent2D extentWindow, vulkan::QueueInfo* queue, ImageHandlerCB* callback);
std::unique_ptr<IImageHandler> createImageHandler(std::shared_ptr<vulkan::DeviceInfo>& deviceInfo, VkExtent2D extentWindow, vulkan::QueueInfo* queue,
ImageHandlerCB* callback);

22
core/videoout/intern.h
View File

@ -1,22 +0,0 @@
#pragma once
#include <vulkan/vulkan_core.h>
#if defined(__APICALL_EXTERN)
#define __APICALL __declspec(dllexport)
#elif defined(__APICALL_IMPORT)
#define __APICALL __declspec(dllimport)
#else
#define __APICALL
#endif
/**
* @brief Get the required memory alignment. Dont' call from constructor.
*
* @param format
* @param extent shouldn't matter if not 100% correct
* @return memory alignment
*/
__APICALL uint64_t getImageAlignment(VkFormat format, VkExtent3D const& extent);
#undef __APICALL

42
core/videoout/videoout.cpp
View File

@ -1,7 +1,5 @@
#define __APICALL_EXTERN
#include "videoout.h"
#include "intern.h"
#undef __APICALL_EXTERN
#include "config_emu.h"
@ -282,10 +280,6 @@ class VideoOut: public IVideoOut, private IEventsGraphics {
}
}
vulkan::DeviceInfo* getDeviceInfo() final { return &m_vulkanObj->deviceInfo; }
VkPhysicalDeviceLimits const* getVulkanLimits() const final { return vulkan::getPhysicalLimits(); }
int addEvent(int handle, EventQueue::KernelEqueueEvent const& event, Kernel::EventQueue::IKernelEqueue_t eq) final;
void removeEvent(int handle, Kernel::EventQueue::IKernelEqueue_t eq, int const ident) final;
void submitFlip(int handle, int index, int64_t flipArg) final; // -> Renderer
@ -922,16 +916,15 @@ std::thread VideoOut::createSDLThread() {
LOG_INFO(L"--> VideoOut Open(%S)| %d:%d", title.c_str(), window.config.resolution.paneWidth, window.config.resolution.paneHeight);
if (m_vulkanObj == nullptr) {
m_vulkanObj = vulkan::initVulkan(window.window, window.surface, accessInitParams()->enableValidation());
auto& info = m_vulkanObj->deviceInfo;
m_graphics = createGraphics(*this, info.device, info.physicalDevice, info.instance);
m_graphics = createGraphics(*this, m_vulkanObj->deviceInfo);
auto queue = m_vulkanObj->queues.items[getIndex(vulkan::QueueType::present)][0].get(); // todo use getQeueu
m_useVsync = accessInitParams()->useVSYNC();
m_imageHandler =
createImageHandler(info.device, VkExtent2D {window.config.resolution.paneWidth, window.config.resolution.paneHeight}, queue, &window);
m_imageHandler = createImageHandler(m_vulkanObj->deviceInfo, VkExtent2D {window.config.resolution.paneWidth, window.config.resolution.paneHeight},
queue, &window);
m_imageHandler->init(m_vulkanObj, window.surface);
*item.result = 0;
@ -982,31 +975,4 @@ std::thread VideoOut::createSDLThread() {
}
SDL_Quit();
});
}
uint64_t getImageAlignment(VkFormat format, VkExtent3D const& extent) {
auto device = ((VideoOut&)accessVideoOut()).getDeviceInfo()->device;
VkImageCreateInfo const imageInfo {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.imageType = VK_IMAGE_TYPE_2D,
.format = format,
.extent = extent,
.mipLevels = 1,
.arrayLayers = 1,
.samples = VK_SAMPLE_COUNT_1_BIT,
.tiling = VK_IMAGE_TILING_OPTIMAL,
.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
};
VkImage image;
VkMemoryRequirements reqs;
vkCreateImage(device, &imageInfo, nullptr, &image);
vkGetImageMemoryRequirements(device, image, &reqs);
vkDestroyImage(device, image, nullptr);
return reqs.alignment;
}
}

65
core/videoout/vulkan/vulkanHelper.cpp
View File

@ -26,7 +26,7 @@ namespace vulkan {
void createSurface(VulkanObj* obj, SDL_Window* window, VkSurfaceKHR& surfaceOut) {
LOG_USE_MODULE(vulkanHelper);
if (SDL_Vulkan_CreateSurface(window, obj->deviceInfo.instance, &surfaceOut)) {
if (SDL_Vulkan_CreateSurface(window, obj->deviceInfo->instance, &surfaceOut)) {
LOG_CRIT(L"Couldn't create surface");
}
}
@ -185,65 +185,4 @@ void presentImage(ImageData const& imageData, VkSwapchainKHR swapchain, QueueInf
vkQueuePresentKHR(queue->queue, &presentInfo);
}
}
} // namespace vulkan
// ### Vulkan EXT Function Definitions
VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos,
const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) {
static auto fn = (PFN_vkCreateShadersEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCreateShadersEXT");
return fn(device, createInfoCount, pCreateInfos, pAllocator, pShaders);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) {
static auto fn = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetDepthClipNegativeOneToOneEXT");
fn(commandBuffer, negativeOneToOne);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) {
static auto fn = (PFN_vkCmdSetColorWriteEnableEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetColorWriteEnableEXT");
fn(commandBuffer, attachmentCount, pColorWriteEnables);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount,
const VkColorComponentFlags* pColorWriteMasks) {
static auto fn = (PFN_vkCmdSetColorWriteMaskEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetColorWriteMaskEXT");
fn(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount,
const VkBool32* pColorBlendEnables) {
static auto fn = (PFN_vkCmdSetColorBlendEnableEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetColorBlendEnableEXT");
fn(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount,
const VkColorBlendEquationEXT* pColorBlendEquations) {
static auto fn = (PFN_vkCmdSetColorBlendEquationEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetColorBlendEquationEXT");
fn(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) {
static auto fn = (PFN_vkCmdSetPolygonModeEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetPolygonModeEXT");
fn(commandBuffer, polygonMode);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) {
static auto fn = (PFN_vkCmdSetRasterizationSamplesEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetRasterizationSamplesEXT");
fn(commandBuffer, rasterizationSamples);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) {
static auto fn = (PFN_vkCmdSetAlphaToCoverageEnableEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetAlphaToCoverageEnableEXT");
fn(commandBuffer, alphaToCoverageEnable);
}
VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) {
static auto fn = (PFN_vkCmdSetAlphaToOneEnableEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkCmdSetAlphaToOneEnableEXT");
fn(commandBuffer, alphaToOneEnable);
}
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer,
VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
static auto fn = (PFN_vkGetMemoryHostPointerPropertiesEXT)vkGetInstanceProcAddr(vulkan::getVkInstance(), "vkGetMemoryHostPointerPropertiesEXT");
return fn(device, handleType, pHostPointer, pMemoryHostPointerProperties);
}
} // namespace vulkan

38
core/videoout/vulkan/vulkanSetup.cpp
View File

@ -717,33 +717,33 @@ VulkanObj* initVulkan(SDL_Window* window, VkSurfaceKHR& surface, bool enableVali
.ppEnabledExtensionNames = extensions.requiredExtensions.data(),
};
if (VkResult result = vkCreateInstance(&instInfo, nullptr, &obj->deviceInfo.instance); result != VK_SUCCESS) {
if (VkResult result = vkCreateInstance(&instInfo, nullptr, &obj->deviceInfo->instance); result != VK_SUCCESS) {
if (result == VK_ERROR_INCOMPATIBLE_DRIVER)
LOG_CRIT(L"vkCreateInstance() Error:VK_ERROR_INCOMPATIBLE_DRIVER");
else
LOG_CRIT(L"vkCreateInstance() Error:%S", string_VkResult(result));
}
g_VkInstance = obj->deviceInfo.instance;
g_VkInstance = obj->deviceInfo->instance;
if (extensions.enableValidationLayers) {
// dbgCreateInfo.pNext = nullptr;
if (auto result = createDebugUtilsMessengerEXT(obj->deviceInfo.instance, &dbgCreateInfo, nullptr, &obj->debugMessenger); result != VK_SUCCESS) {
if (auto result = createDebugUtilsMessengerEXT(obj->deviceInfo->instance, &dbgCreateInfo, nullptr, &obj->debugMessenger); result != VK_SUCCESS) {
LOG_CRIT(L"createDebugUtilsMessengerEXT() %S", string_VkResult(result));
}
}
// -
if (auto result = SDL_Vulkan_CreateSurface(window, obj->deviceInfo.instance, &surface); result != true) {
if (auto result = SDL_Vulkan_CreateSurface(window, obj->deviceInfo->instance, &surface); result != true) {
LOG_CRIT(L"SDL_Vulkan_CreateSurface() Error:%S", SDL_GetError());
}
VulkanQueues queues;
findPhysicalDevice(obj->deviceInfo.instance, surface, &obj->surfaceCapabilities, &obj->deviceInfo.physicalDevice, &queues, enableValidation);
if (obj->deviceInfo.physicalDevice == nullptr) {
findPhysicalDevice(obj->deviceInfo->instance, surface, &obj->surfaceCapabilities, &obj->deviceInfo->physicalDevice, &queues, enableValidation);
if (obj->deviceInfo->physicalDevice == nullptr) {
LOG_CRIT(L"Couldn't find a suitable device");
}
vkGetPhysicalDeviceProperties(obj->deviceInfo.physicalDevice, &g_PhysicalDeviceProperties);
vkGetPhysicalDeviceProperties(obj->deviceInfo->physicalDevice, &g_PhysicalDeviceProperties);
{
auto const text =
@ -754,7 +754,7 @@ VulkanObj* initVulkan(SDL_Window* window, VkSurfaceKHR& surface, bool enableVali
// Debug infos
VkPhysicalDeviceMemoryProperties memProperties;
vkGetPhysicalDeviceMemoryProperties(obj->deviceInfo.physicalDevice, &memProperties);
vkGetPhysicalDeviceMemoryProperties(obj->deviceInfo->physicalDevice, &memProperties);
for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
LOG_DEBUG(L"%u| Memory Type: index:%u flags:%S", i, memProperties.memoryTypes[i].heapIndex,
@ -767,7 +767,7 @@ VulkanObj* initVulkan(SDL_Window* window, VkSurfaceKHR& surface, bool enableVali
// -
}
obj->deviceInfo.device = createDevice(obj->deviceInfo.physicalDevice, surface, extensions, queues, enableValidation);
obj->deviceInfo->device = createDevice(obj->deviceInfo->physicalDevice, surface, extensions, queues, enableValidation);
// Create queues
{
@ -779,30 +779,22 @@ VulkanObj* initVulkan(SDL_Window* window, VkSurfaceKHR& surface, bool enableVali
}
};
queueFunc(obj->deviceInfo.device, queues.compute, obj->queues.items[getIndex(QueueType::compute)]);
queueFunc(obj->deviceInfo.device, queues.present, obj->queues.items[getIndex(QueueType::present)]);
queueFunc(obj->deviceInfo.device, queues.transfer, obj->queues.items[getIndex(QueueType::transfer)]);
queueFunc(obj->deviceInfo.device, queues.graphics, obj->queues.items[getIndex(QueueType::graphics)]);
queueFunc(obj->deviceInfo->device, queues.compute, obj->queues.items[getIndex(QueueType::compute)]);
queueFunc(obj->deviceInfo->device, queues.present, obj->queues.items[getIndex(QueueType::present)]);
queueFunc(obj->deviceInfo->device, queues.transfer, obj->queues.items[getIndex(QueueType::transfer)]);
queueFunc(obj->deviceInfo->device, queues.graphics, obj->queues.items[getIndex(QueueType::graphics)]);
}
//-
return obj;
}
VkPhysicalDeviceLimits const* getPhysicalLimits() {
return &g_PhysicalDeviceProperties.limits;
}
VkInstance const getVkInstance() {
return g_VkInstance;
}
std::string_view const getGPUName() {
return g_PhysicalDeviceProperties.deviceName;
}
void deinitVulkan(VulkanObj* obj) {
vkDestroyInstance(obj->deviceInfo.instance, nullptr);
vkDestroyDevice(obj->deviceInfo.device, nullptr);
vkDestroyInstance(obj->deviceInfo->instance, nullptr);
vkDestroyDevice(obj->deviceInfo->device, nullptr);
delete obj;
}

14
core/videoout/vulkan/vulkanSetup.h
View File

@ -1,5 +1,7 @@
#pragma once
#include "vulkanTypes.h"
#include <array>
#include <boost/thread/thread.hpp>
#include <memory>
@ -14,12 +16,6 @@ struct SDL_Window;
namespace vulkan {
struct DeviceInfo {
VkInstance instance = nullptr;
VkPhysicalDevice physicalDevice = nullptr;
VkDevice device = nullptr;
};
enum class QueueType : uint8_t {
graphics = 0,
compute,
@ -67,7 +63,7 @@ struct SurfaceCapabilities {
};
struct VulkanObj {
DeviceInfo deviceInfo;
std::shared_ptr<vulkan::DeviceInfo> deviceInfo = std::make_shared<DeviceInfo>();
VkDebugUtilsMessengerEXT debugMessenger = nullptr;
SurfaceCapabilities surfaceCapabilities;
@ -79,10 +75,6 @@ void deinitVulkan(VulkanObj* obj);
void createSurface(VulkanObj* obj, SDL_Window* window, VkSurfaceKHR& surfaceOut);
VkPhysicalDeviceLimits const* getPhysicalLimits();
VkInstance const getVkInstance();
std::string_view const getGPUName();
std::pair<VkFormat, VkColorSpaceKHR> getDisplayFormat(VulkanObj* obj);

13
core/videoout/vulkan/vulkanTypes.h Normal file
View File

@ -0,0 +1,13 @@
#pragma once
#include <vulkan/vulkan_core.h>
namespace vulkan {
struct DeviceInfo {
VkInstance instance = nullptr;
VkPhysicalDevice physicalDevice = nullptr;
VkDevice device = nullptr;
VkPhysicalDeviceLimits limits;
};
} // namespace vulkan

9
main.cpp Normal file
View File

@ -0,0 +1,9 @@
#include "logging.h"
LOG_DEFINE_MODULE(MAIN);
int main() {
__Log::flush();
return 0;
}

4
modules/libSceAvPlayer/avplayer.cpp
View File

@ -1,7 +1,7 @@
#include "avplayer.h"
#include "core/fileManager/fileManager.h"
#include "core/videoout/intern.h"
#include "core/imports/exports/graphics.h"
#include "core/videoout/videoout.h"
#include "logging.h"
#include "typesEx.h"
@ -230,7 +230,7 @@ bool Avplayer::setFile(const char* filename) {
return false;
}
uint64_t const alignment = getImageAlignment(VK_FORMAT_R8G8_UNORM, VkExtent3D {1920, 1080, 1}); // image size doesn't matter
uint64_t const alignment = accessVideoOut().getGraphics()->getImageAlignment(VK_FORMAT_R8G8_UNORM, VkExtent3D {1920, 1080, 1}); // image size doesn't matter
m_videoBuffer = (void*)((uint64_t)m_memAlloc.allocateTexture(m_memAlloc.objectPointer, alignment, videobufferSize));
m_videoStride = std::array<int, 4> {m_video.codecContext->width, m_video.codecContext->width, 0, 0};

2
tools/logging/CMakeLists.txt
View File

@ -4,7 +4,7 @@ add_library(logging SHARED logging.cpp)
add_dependencies(logging third_party config_emu)
target_link_libraries(logging ws2_32 p7 config_emu.lib libboost_thread)
target_link_libraries(logging PRIVATE ws2_32 p7 config_emu.lib)
target_compile_definitions(logging PRIVATE BOOST_ALL_NO_LIB WIN32_LEAN_AND_MEAN)