diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cdd9103a..5acc88fe 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -102,7 +102,7 @@ jobs: - name: Configure (CMake) run: | if [ "${{ matrix.vita }}" = "true" ]; then - PRESET=--preset vita-debug + PRESET="--preset vita-debug" fi ${{ matrix.cmake-wrapper || '' }} cmake $PRESET -S . -B build -GNinja \ -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \ diff --git a/miniwin/src/d3drm/backends/gxm/memory.cpp b/miniwin/src/d3drm/backends/gxm/memory.cpp index 734a43a5..61e8f7d3 100644 --- a/miniwin/src/d3drm/backends/gxm/memory.cpp +++ b/miniwin/src/d3drm/backends/gxm/memory.cpp @@ -1,165 +1,166 @@ #include "memory.h" + #include "utils.h" -#include - #include - +#include static SceUID cdramPoolUID = -1; static SceClibMspace cdramPool = NULL; - -void *patcher_host_alloc(void *user_data, unsigned int size) +void* patcher_host_alloc(void* user_data, unsigned int size) { - void *mem = SDL_malloc(size); - (void)user_data; - return mem; + void* mem = SDL_malloc(size); + (void) user_data; + return mem; } -void patcher_host_free(void *user_data, void *mem) +void patcher_host_free(void* user_data, void* mem) { - (void)user_data; - SDL_free(mem); + (void) user_data; + SDL_free(mem); } -void* vita_mem_alloc( - unsigned int type, - size_t size, - size_t alignment, - int attribs, - SceUID *uid -) { - void *mem; +void* vita_mem_alloc(unsigned int type, size_t size, size_t alignment, int attribs, SceUID* uid) +{ + void* mem; - if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW) { - size = ALIGN(size, 256 * 1024); - } else if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_NC_RW) { - size = ALIGN(size, 1024 * 1024); - } else { - size = ALIGN(size, 4 * 1024); - } + if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW) { + size = ALIGN(size, 256 * 1024); + } + else if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_NC_RW) { + size = ALIGN(size, 1024 * 1024); + } + else { + size = ALIGN(size, 4 * 1024); + } - *uid = sceKernelAllocMemBlock("gpu_mem", type, size, NULL); + *uid = sceKernelAllocMemBlock("gpu_mem", type, size, NULL); - if (*uid < 0) { + if (*uid < 0) { SDL_Log("sceKernelAllocMemBlock: 0x%x", *uid); - return NULL; - } - - if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { - return NULL; - } - - if (sceGxmMapMemory(mem, size, (SceGxmMemoryAttribFlags)attribs) < 0) { - SDL_Log("sceGxmMapMemory 0x%x 0x%x %d failed", mem, size, attribs); return NULL; - } + } - return mem; + if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { + return NULL; + } + + if (sceGxmMapMemory(mem, size, (SceGxmMemoryAttribFlags) attribs) < 0) { + SDL_Log("sceGxmMapMemory 0x%x 0x%x %d failed", mem, size, attribs); + return NULL; + } + + return mem; } void vita_mem_free(SceUID uid) { - void *mem = NULL; - if (sceKernelGetMemBlockBase(uid, &mem) < 0) { - return; - } - sceGxmUnmapMemory(mem); - sceKernelFreeMemBlock(uid); + void* mem = NULL; + if (sceKernelGetMemBlockBase(uid, &mem) < 0) { + return; + } + sceGxmUnmapMemory(mem); + sceKernelFreeMemBlock(uid); } -void *vita_mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset) +void* vita_mem_vertex_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset) { - void *mem = NULL; + void* mem = NULL; - size = ALIGN(size, 4096); - *uid = sceKernelAllocMemBlock("vertex_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL); + size = ALIGN(size, 4096); + *uid = sceKernelAllocMemBlock("vertex_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL); - if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { - return NULL; - } - if (sceGxmMapVertexUsseMemory(mem, size, usse_offset) < 0) { - return NULL; - } + if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { + return NULL; + } + if (sceGxmMapVertexUsseMemory(mem, size, usse_offset) < 0) { + return NULL; + } - return mem; + return mem; } void vita_mem_vertex_usse_free(SceUID uid) { - void *mem = NULL; - if (sceKernelGetMemBlockBase(uid, &mem) < 0) { - return; - } - sceGxmUnmapVertexUsseMemory(mem); - sceKernelFreeMemBlock(uid); + void* mem = NULL; + if (sceKernelGetMemBlockBase(uid, &mem) < 0) { + return; + } + sceGxmUnmapVertexUsseMemory(mem); + sceKernelFreeMemBlock(uid); } -void *vita_mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset) +void* vita_mem_fragment_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset) { - void *mem = NULL; + void* mem = NULL; - size = ALIGN(size, 4096); - *uid = sceKernelAllocMemBlock("fragment_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL); + size = ALIGN(size, 4096); + *uid = sceKernelAllocMemBlock("fragment_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL); - if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { - return NULL; - } - if (sceGxmMapFragmentUsseMemory(mem, size, usse_offset) < 0) { - return NULL; - } + if (sceKernelGetMemBlockBase(*uid, &mem) < 0) { + return NULL; + } + if (sceGxmMapFragmentUsseMemory(mem, size, usse_offset) < 0) { + return NULL; + } - return mem; + return mem; } void vita_mem_fragment_usse_free(SceUID uid) { - void *mem = NULL; - if (sceKernelGetMemBlockBase(uid, &mem) < 0) { - return; - } - sceGxmUnmapFragmentUsseMemory(mem); - sceKernelFreeMemBlock(uid); + void* mem = NULL; + if (sceKernelGetMemBlockBase(uid, &mem) < 0) { + return; + } + sceGxmUnmapFragmentUsseMemory(mem); + sceKernelFreeMemBlock(uid); } -bool cdramPool_init() { - if(cdramPool) { - return true; - } - int poolsize; - int ret; - void* mem; - SceKernelFreeMemorySizeInfo info; - info.size = sizeof(SceKernelFreeMemorySizeInfo); - sceKernelGetFreeMemorySize(&info); +bool cdramPool_init() +{ + if (cdramPool) { + return true; + } + int poolsize; + int ret; + void* mem; + SceKernelFreeMemorySizeInfo info; + info.size = sizeof(SceKernelFreeMemorySizeInfo); + sceKernelGetFreeMemorySize(&info); - poolsize = ALIGN(info.size_cdram, 256 * 1024); - if (poolsize > info.size_cdram) { - poolsize = ALIGN(info.size_cdram - 256 * 1024, 256 * 1024); - } - poolsize -= 16 * 1024 * 1024; - cdramPoolUID = sceKernelAllocMemBlock("gpu_cdram_pool", SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, poolsize, NULL); - if (cdramPool < 0) { - return false; - } + poolsize = ALIGN(info.size_cdram, 256 * 1024); + if (poolsize > info.size_cdram) { + poolsize = ALIGN(info.size_cdram - 256 * 1024, 256 * 1024); + } + poolsize -= 16 * 1024 * 1024; + cdramPoolUID = sceKernelAllocMemBlock("gpu_cdram_pool", SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, poolsize, NULL); + if (cdramPool < 0) { + return false; + } - ret = sceKernelGetMemBlockBase(cdramPoolUID, &mem); - if (ret < 0) { - return false; - } - cdramPool = sceClibMspaceCreate(mem, poolsize); + ret = sceKernelGetMemBlockBase(cdramPoolUID, &mem); + if (ret < 0) { + return false; + } + cdramPool = sceClibMspaceCreate(mem, poolsize); - if (!cdramPool) { - return false; - } - ret = sceGxmMapMemory(mem, poolsize, (SceGxmMemoryAttribFlags)(SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE)); - if (ret < 0) { - return false; - } - return true; + if (!cdramPool) { + return false; + } + ret = sceGxmMapMemory( + mem, + poolsize, + (SceGxmMemoryAttribFlags) (SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE) + ); + if (ret < 0) { + return false; + } + return true; } -SceClibMspace cdramPool_get() { - return cdramPool; +SceClibMspace cdramPool_get() +{ + return cdramPool; } diff --git a/miniwin/src/d3drm/backends/gxm/memory.h b/miniwin/src/d3drm/backends/gxm/memory.h index 8ed34c75..346b947e 100644 --- a/miniwin/src/d3drm/backends/gxm/memory.h +++ b/miniwin/src/d3drm/backends/gxm/memory.h @@ -1,25 +1,19 @@ #pragma once -#include -#include -#include #include +#include +#include +#include -void *patcher_host_alloc(void *user_data, unsigned int size); -void patcher_host_free(void *user_data, void *mem); +void* patcher_host_alloc(void* user_data, unsigned int size); +void patcher_host_free(void* user_data, void* mem); -void* vita_mem_alloc( - unsigned int type, - size_t size, - size_t alignment, - int attribs, - SceUID* uid -); +void* vita_mem_alloc(unsigned int type, size_t size, size_t alignment, int attribs, SceUID* uid); void vita_mem_free(SceUID uid); -void *vita_mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset); +void* vita_mem_vertex_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset); void vita_mem_vertex_usse_free(SceUID uid); -void *vita_mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset); +void* vita_mem_fragment_usse_alloc(unsigned int size, SceUID* uid, unsigned int* usse_offset); void vita_mem_fragment_usse_free(SceUID uid); bool cdramPool_init(); diff --git a/miniwin/src/d3drm/backends/gxm/renderer.cpp b/miniwin/src/d3drm/backends/gxm/renderer.cpp index c6135092..193b9c24 100644 --- a/miniwin/src/d3drm/backends/gxm/renderer.cpp +++ b/miniwin/src/d3drm/backends/gxm/renderer.cpp @@ -1,23 +1,21 @@ #include "d3drmrenderer_gxm.h" +#include "memory.h" #include "meshutils.h" +#include "utils.h" #include #include -#include - -#include #include -#include +#include #include - -#include "utils.h" -#include "memory.h" +#include +#include #define INCBIN_PREFIX _inc_ #include "incbin.h" bool with_razor = false; -#define VITA_GXM_SCREEN_WIDTH 960 +#define VITA_GXM_SCREEN_WIDTH 960 #define VITA_GXM_SCREEN_HEIGHT 544 #define VITA_GXM_SCREEN_STRIDE 960 #define VITA_GXM_PENDING_SWAPS 2 @@ -25,17 +23,15 @@ bool with_razor = false; #define VITA_GXM_COLOR_FORMAT SCE_GXM_COLOR_FORMAT_A8B8G8R8 #define VITA_GXM_PIXEL_FORMAT SCE_DISPLAY_PIXELFORMAT_A8B8G8R8 - - INCBIN(main_vert_gxp, "shaders/main.vert.gxp"); INCBIN(main_frag_gxp, "shaders/main.frag.gxp"); INCBIN(color_frag_gxp, "shaders/color.frag.gxp"); INCBIN(image_frag_gxp, "shaders/image.frag.gxp"); -const SceGxmProgram* mainVertexProgramGxp = (const SceGxmProgram*)_inc_main_vert_gxpData; -const SceGxmProgram* mainFragmentProgramGxp = (const SceGxmProgram*)_inc_main_frag_gxpData; -const SceGxmProgram* colorFragmentProgramGxp = (const SceGxmProgram*)_inc_color_frag_gxpData; -const SceGxmProgram* imageFragmentProgramGxp = (const SceGxmProgram*)_inc_image_frag_gxpData; +const SceGxmProgram* mainVertexProgramGxp = (const SceGxmProgram*) _inc_main_vert_gxpData; +const SceGxmProgram* mainFragmentProgramGxp = (const SceGxmProgram*) _inc_main_frag_gxpData; +const SceGxmProgram* colorFragmentProgramGxp = (const SceGxmProgram*) _inc_color_frag_gxpData; +const SceGxmProgram* imageFragmentProgramGxp = (const SceGxmProgram*) _inc_image_frag_gxpData; static const SceGxmBlendInfo blendInfoOpaque = { .colorMask = SCE_GXM_COLOR_MASK_ALL, @@ -63,186 +59,192 @@ extern "C" int sceRazorGpuCaptureSetTriggerNextFrame(const char* path); static GXMRendererContext gxm_renderer_context; -static void display_callback(const void *callback_data) { - const GXMDisplayData *display_data = (const GXMDisplayData *)callback_data; +static void display_callback(const void* callback_data) +{ + const GXMDisplayData* display_data = (const GXMDisplayData*) callback_data; SceDisplayFrameBuf framebuf; - SDL_memset(&framebuf, 0x00, sizeof(SceDisplayFrameBuf)); - framebuf.size = sizeof(SceDisplayFrameBuf); - framebuf.base = display_data->address; - framebuf.pitch = VITA_GXM_SCREEN_STRIDE; - framebuf.pixelformat = VITA_GXM_PIXEL_FORMAT; - framebuf.width = VITA_GXM_SCREEN_WIDTH; - framebuf.height = VITA_GXM_SCREEN_HEIGHT; - sceDisplaySetFrameBuf(&framebuf, SCE_DISPLAY_SETBUF_NEXTFRAME); - sceDisplayWaitSetFrameBuf(); + SDL_memset(&framebuf, 0x00, sizeof(SceDisplayFrameBuf)); + framebuf.size = sizeof(SceDisplayFrameBuf); + framebuf.base = display_data->address; + framebuf.pitch = VITA_GXM_SCREEN_STRIDE; + framebuf.pixelformat = VITA_GXM_PIXEL_FORMAT; + framebuf.width = VITA_GXM_SCREEN_WIDTH; + framebuf.height = VITA_GXM_SCREEN_HEIGHT; + sceDisplaySetFrameBuf(&framebuf, SCE_DISPLAY_SETBUF_NEXTFRAME); + sceDisplayWaitSetFrameBuf(); } -static void load_razor() { +static void load_razor() +{ int mod_id = _sceKernelLoadModule("app0:librazorcapture_es4.suprx", 0, nullptr); int status; - if(!SCE_ERR(sceKernelStartModule, mod_id, 0, nullptr, 0, nullptr, &status)) { + if (!SCE_ERR(sceKernelStartModule, mod_id, 0, nullptr, 0, nullptr, &status)) { with_razor = true; } - if(with_razor) { + if (with_razor) { sceRazorGpuCaptureEnableSalvage("ux0:data/gpu_crash.sgx"); } } bool gxm_initialized = false; -bool gxm_init() { - if(gxm_initialized) { +bool gxm_init() +{ + if (gxm_initialized) { return true; } load_razor(); SceGxmInitializeParams initializeParams; - SDL_memset(&initializeParams, 0, sizeof(SceGxmInitializeParams)); - initializeParams.flags = 0; - initializeParams.displayQueueMaxPendingCount = VITA_GXM_PENDING_SWAPS; - initializeParams.displayQueueCallback = display_callback; - initializeParams.displayQueueCallbackDataSize = sizeof(GXMDisplayData); - initializeParams.parameterBufferSize = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE; + SDL_memset(&initializeParams, 0, sizeof(SceGxmInitializeParams)); + initializeParams.flags = 0; + initializeParams.displayQueueMaxPendingCount = VITA_GXM_PENDING_SWAPS; + initializeParams.displayQueueCallback = display_callback; + initializeParams.displayQueueCallbackDataSize = sizeof(GXMDisplayData); + initializeParams.parameterBufferSize = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE; - int err = sceGxmInitialize(&initializeParams); - if (err != 0) { - SDL_LogError(SDL_LOG_CATEGORY_RENDER, "gxm init failed: %d", err); - return err; - } + int err = sceGxmInitialize(&initializeParams); + if (err != 0) { + SDL_LogError(SDL_LOG_CATEGORY_RENDER, "gxm init failed: %d", err); + return err; + } gxm_initialized = true; return cdramPool_init(); } -static bool create_gxm_context() { +static bool create_gxm_context() +{ GXMRendererContext* data = &gxm_renderer_context; - if(data->context) { + if (data->context) { return true; } - if(!gxm_init()) { + if (!gxm_init()) { return false; } const unsigned int patcherBufferSize = 64 * 1024; - const unsigned int patcherVertexUsseSize = 64 * 1024; - const unsigned int patcherFragmentUsseSize = 64 * 1024; + const unsigned int patcherVertexUsseSize = 64 * 1024; + const unsigned int patcherFragmentUsseSize = 64 * 1024; data->cdramPool = cdramPool_get(); - if(!data->cdramPool) { + if (!data->cdramPool) { SDL_Log("failed to allocate cdramPool"); return false; } // allocate buffers data->vdmRingBuffer = vita_mem_alloc( - SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, - SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE, - 4, - SCE_GXM_MEMORY_ATTRIB_READ, - &data->vdmRingBufferUid + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE, + 4, + SCE_GXM_MEMORY_ATTRIB_READ, + &data->vdmRingBufferUid ); - data->vertexRingBuffer = vita_mem_alloc( - SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, - SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE, - 4, - SCE_GXM_MEMORY_ATTRIB_READ, - &data->vertexRingBufferUid + data->vertexRingBuffer = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE, + 4, + SCE_GXM_MEMORY_ATTRIB_READ, + &data->vertexRingBufferUid ); - data->fragmentRingBuffer = vita_mem_alloc( - SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, - SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE, - 4, - SCE_GXM_MEMORY_ATTRIB_READ, - &data->fragmentRingBufferUid + data->fragmentRingBuffer = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE, + 4, + SCE_GXM_MEMORY_ATTRIB_READ, + &data->fragmentRingBufferUid ); - data->fragmentUsseRingBuffer = vita_mem_fragment_usse_alloc( - SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE, - &data->fragmentUsseRingBufferUid, - &data->fragmentUsseRingBufferOffset); + data->fragmentUsseRingBuffer = vita_mem_fragment_usse_alloc( + SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE, + &data->fragmentUsseRingBufferUid, + &data->fragmentUsseRingBufferOffset + ); // create context SceGxmContextParams contextParams; memset(&contextParams, 0, sizeof(SceGxmContextParams)); - contextParams.hostMem = SDL_malloc(SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE); - contextParams.hostMemSize = SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE; - contextParams.vdmRingBufferMem = data->vdmRingBuffer; - contextParams.vdmRingBufferMemSize = SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE; - contextParams.vertexRingBufferMem = data->vertexRingBuffer; - contextParams.vertexRingBufferMemSize = SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE; - contextParams.fragmentRingBufferMem = data->fragmentRingBuffer; - contextParams.fragmentRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE; - contextParams.fragmentUsseRingBufferMem = data->fragmentUsseRingBuffer; - contextParams.fragmentUsseRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE; - contextParams.fragmentUsseRingBufferOffset = data->fragmentUsseRingBufferOffset; + contextParams.hostMem = SDL_malloc(SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE); + contextParams.hostMemSize = SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE; + contextParams.vdmRingBufferMem = data->vdmRingBuffer; + contextParams.vdmRingBufferMemSize = SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE; + contextParams.vertexRingBufferMem = data->vertexRingBuffer; + contextParams.vertexRingBufferMemSize = SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE; + contextParams.fragmentRingBufferMem = data->fragmentRingBuffer; + contextParams.fragmentRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE; + contextParams.fragmentUsseRingBufferMem = data->fragmentUsseRingBuffer; + contextParams.fragmentUsseRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE; + contextParams.fragmentUsseRingBufferOffset = data->fragmentUsseRingBufferOffset; - if(SCE_ERR(sceGxmCreateContext, &contextParams, &data->context)) { + if (SCE_ERR(sceGxmCreateContext, &contextParams, &data->context)) { return false; } data->contextHostMem = contextParams.hostMem; // shader patcher data->patcherBuffer = vita_mem_alloc( - SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, - patcherBufferSize, - 4, - SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, - &data->patcherBufferUid + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + patcherBufferSize, + 4, + SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, + &data->patcherBufferUid ); - data->patcherVertexUsse = vita_mem_vertex_usse_alloc( - patcherVertexUsseSize, - &data->patcherVertexUsseUid, - &data->patcherVertexUsseOffset); + data->patcherVertexUsse = + vita_mem_vertex_usse_alloc(patcherVertexUsseSize, &data->patcherVertexUsseUid, &data->patcherVertexUsseOffset); - data->patcherFragmentUsse = vita_mem_fragment_usse_alloc( - patcherFragmentUsseSize, - &data->patcherFragmentUsseUid, - &data->patcherFragmentUsseOffset); + data->patcherFragmentUsse = vita_mem_fragment_usse_alloc( + patcherFragmentUsseSize, + &data->patcherFragmentUsseUid, + &data->patcherFragmentUsseOffset + ); SceGxmShaderPatcherParams patcherParams; memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams)); - patcherParams.userData = NULL; - patcherParams.hostAllocCallback = &patcher_host_alloc; - patcherParams.hostFreeCallback = &patcher_host_free; - patcherParams.bufferAllocCallback = NULL; - patcherParams.bufferFreeCallback = NULL; - patcherParams.bufferMem = data->patcherBuffer; - patcherParams.bufferMemSize = patcherBufferSize; - patcherParams.vertexUsseAllocCallback = NULL; - patcherParams.vertexUsseFreeCallback = NULL; - patcherParams.vertexUsseMem = data->patcherVertexUsse; - patcherParams.vertexUsseMemSize = patcherVertexUsseSize; - patcherParams.vertexUsseOffset = data->patcherVertexUsseOffset; - patcherParams.fragmentUsseAllocCallback = NULL; - patcherParams.fragmentUsseFreeCallback = NULL; - patcherParams.fragmentUsseMem = data->patcherFragmentUsse; - patcherParams.fragmentUsseMemSize = patcherFragmentUsseSize; - patcherParams.fragmentUsseOffset = data->patcherFragmentUsseOffset; + patcherParams.userData = NULL; + patcherParams.hostAllocCallback = &patcher_host_alloc; + patcherParams.hostFreeCallback = &patcher_host_free; + patcherParams.bufferAllocCallback = NULL; + patcherParams.bufferFreeCallback = NULL; + patcherParams.bufferMem = data->patcherBuffer; + patcherParams.bufferMemSize = patcherBufferSize; + patcherParams.vertexUsseAllocCallback = NULL; + patcherParams.vertexUsseFreeCallback = NULL; + patcherParams.vertexUsseMem = data->patcherVertexUsse; + patcherParams.vertexUsseMemSize = patcherVertexUsseSize; + patcherParams.vertexUsseOffset = data->patcherVertexUsseOffset; + patcherParams.fragmentUsseAllocCallback = NULL; + patcherParams.fragmentUsseFreeCallback = NULL; + patcherParams.fragmentUsseMem = data->patcherFragmentUsse; + patcherParams.fragmentUsseMemSize = patcherFragmentUsseSize; + patcherParams.fragmentUsseOffset = data->patcherFragmentUsseOffset; - if(SCE_ERR(sceGxmShaderPatcherCreate, &patcherParams, &data->shaderPatcher)) { + if (SCE_ERR(sceGxmShaderPatcherCreate, &patcherParams, &data->shaderPatcher)) { return false; } return true; } -static void destroy_gxm_context() { +static void destroy_gxm_context() +{ sceGxmShaderPatcherDestroy(gxm_renderer_context.shaderPatcher); sceGxmDestroyContext(gxm_renderer_context.context); vita_mem_fragment_usse_free(gxm_renderer_context.fragmentUsseRingBufferUid); vita_mem_free(gxm_renderer_context.fragmentRingBufferUid); - vita_mem_free(gxm_renderer_context.vertexRingBufferUid); - vita_mem_free(gxm_renderer_context.vdmRingBufferUid); + vita_mem_free(gxm_renderer_context.vertexRingBufferUid); + vita_mem_free(gxm_renderer_context.vdmRingBufferUid); SDL_free(gxm_renderer_context.contextHostMem); } -bool get_gxm_context(SceGxmContext** context, SceGxmShaderPatcher** shaderPatcher, SceClibMspace* cdramPool) { - if(!create_gxm_context()) { +bool get_gxm_context(SceGxmContext** context, SceGxmShaderPatcher** shaderPatcher, SceClibMspace* cdramPool) +{ + if (!create_gxm_context()) { return false; } *context = gxm_renderer_context.context; @@ -285,39 +287,44 @@ Direct3DRMRenderer* GXMRenderer::Create(DWORD width, DWORD height) SDL_Log("GXMRenderer::Create width=%d height=%d", width, height); bool success = gxm_init(); - if(!success) { + if (!success) { return nullptr; } return new GXMRenderer(width, height); } -GXMRenderer::GXMRenderer(DWORD width, DWORD height) { +GXMRenderer::GXMRenderer(DWORD width, DWORD height) +{ m_width = VITA_GXM_SCREEN_WIDTH; m_height = VITA_GXM_SCREEN_HEIGHT; m_virtualWidth = width; m_virtualHeight = height; const unsigned int alignedWidth = ALIGN(m_width, SCE_GXM_TILE_SIZEX); - const unsigned int alignedHeight = ALIGN(m_height, SCE_GXM_TILE_SIZEY); + const unsigned int alignedHeight = ALIGN(m_height, SCE_GXM_TILE_SIZEY); const unsigned int sampleCount = alignedWidth * alignedHeight; - const unsigned int depthStrideInSamples = alignedWidth; + const unsigned int depthStrideInSamples = alignedWidth; - if(!get_gxm_context(&this->context, &this->shaderPatcher, &this->cdramPool)) return; + if (!get_gxm_context(&this->context, &this->shaderPatcher, &this->cdramPool)) { + return; + } // render target SceGxmRenderTargetParams renderTargetParams; - memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams)); - renderTargetParams.flags = 0; - renderTargetParams.width = m_width; - renderTargetParams.height = m_height; - renderTargetParams.scenesPerFrame = 1; - renderTargetParams.multisampleMode = 0; - renderTargetParams.multisampleLocations = 0; - renderTargetParams.driverMemBlock = -1; // Invalid UID - if(SCE_ERR(sceGxmCreateRenderTarget, &renderTargetParams, &this->renderTarget)) return; + memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams)); + renderTargetParams.flags = 0; + renderTargetParams.width = m_width; + renderTargetParams.height = m_height; + renderTargetParams.scenesPerFrame = 1; + renderTargetParams.multisampleMode = 0; + renderTargetParams.multisampleLocations = 0; + renderTargetParams.driverMemBlock = -1; // Invalid UID + if (SCE_ERR(sceGxmCreateRenderTarget, &renderTargetParams, &this->renderTarget)) { + return; + } - for(int i = 0; i < VITA_GXM_DISPLAY_BUFFER_COUNT; i++) { + for (int i = 0; i < VITA_GXM_DISPLAY_BUFFER_COUNT; i++) { this->displayBuffers[i] = vita_mem_alloc( SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, 4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT, @@ -326,138 +333,190 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height) { &this->displayBuffersUid[i] ); - if(SCE_ERR(sceGxmColorSurfaceInit, - &this->displayBuffersSurface[i], - SCE_GXM_COLOR_FORMAT_A8B8G8R8, - SCE_GXM_COLOR_SURFACE_LINEAR, - SCE_GXM_COLOR_SURFACE_SCALE_NONE, - SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT, - m_width, m_height, - m_width, - this->displayBuffers[i] - )) return; + if (SCE_ERR( + sceGxmColorSurfaceInit, + &this->displayBuffersSurface[i], + SCE_GXM_COLOR_FORMAT_A8B8G8R8, + SCE_GXM_COLOR_SURFACE_LINEAR, + SCE_GXM_COLOR_SURFACE_SCALE_NONE, + SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT, + m_width, + m_height, + m_width, + this->displayBuffers[i] + )) { + return; + } - if(SCE_ERR(sceGxmSyncObjectCreate, &this->displayBuffersSync[i])) return; + if (SCE_ERR(sceGxmSyncObjectCreate, &this->displayBuffersSync[i])) { + return; + } } - // depth & stencil - this->depthBufferData = vita_mem_alloc( - SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, - 4 * sampleCount, - SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, - SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, - &this->depthBufferUid + this->depthBufferData = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + 4 * sampleCount, + SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, + SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, + &this->depthBufferUid ); - this->stencilBufferData = vita_mem_alloc( - SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, - 4 * sampleCount, - SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, - SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, - &this->stencilBufferUid + this->stencilBufferData = vita_mem_alloc( + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, + 4 * sampleCount, + SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, + SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, + &this->stencilBufferUid ); - if(SCE_ERR(sceGxmDepthStencilSurfaceInit, - &this->depthSurface, - SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24, - SCE_GXM_DEPTH_STENCIL_SURFACE_TILED, - depthStrideInSamples, - this->depthBufferData, - this->stencilBufferData - )) return; + if (SCE_ERR( + sceGxmDepthStencilSurfaceInit, + &this->depthSurface, + SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24, + SCE_GXM_DEPTH_STENCIL_SURFACE_TILED, + depthStrideInSamples, + this->depthBufferData, + this->stencilBufferData + )) { + return; + } - // register shader programs - if(SCE_ERR(sceGxmShaderPatcherRegisterProgram, this->shaderPatcher, colorFragmentProgramGxp, &this->colorFragmentProgramId)) return; - if(SCE_ERR(sceGxmShaderPatcherRegisterProgram, this->shaderPatcher, mainVertexProgramGxp, &this->mainVertexProgramId)) return; - if(SCE_ERR(sceGxmShaderPatcherRegisterProgram, this->shaderPatcher, mainFragmentProgramGxp, &this->mainFragmentProgramId)) return; - if(SCE_ERR(sceGxmShaderPatcherRegisterProgram, this->shaderPatcher, imageFragmentProgramGxp, &this->imageFragmentProgramId)) return; + if (SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + this->shaderPatcher, + colorFragmentProgramGxp, + &this->colorFragmentProgramId + )) { + return; + } + if (SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + this->shaderPatcher, + mainVertexProgramGxp, + &this->mainVertexProgramId + )) { + return; + } + if (SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + this->shaderPatcher, + mainFragmentProgramGxp, + &this->mainFragmentProgramId + )) { + return; + } + if (SCE_ERR( + sceGxmShaderPatcherRegisterProgram, + this->shaderPatcher, + imageFragmentProgramGxp, + &this->imageFragmentProgramId + )) { + return; + } // main shader { - GET_SHADER_PARAM(positionAttribute, mainVertexProgramGxp, "aPosition",); - GET_SHADER_PARAM(normalAttribute, mainVertexProgramGxp, "aNormal",); - GET_SHADER_PARAM(texCoordAttribute, mainVertexProgramGxp, "aTexCoord",); + GET_SHADER_PARAM(positionAttribute, mainVertexProgramGxp, "aPosition", ); + GET_SHADER_PARAM(normalAttribute, mainVertexProgramGxp, "aNormal", ); + GET_SHADER_PARAM(texCoordAttribute, mainVertexProgramGxp, "aTexCoord", ); SceGxmVertexAttribute vertexAttributes[3]; SceGxmVertexStream vertexStreams[1]; // position vertexAttributes[0].streamIndex = 0; - vertexAttributes[0].offset = 0; - vertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; - vertexAttributes[0].componentCount = 3; - vertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(positionAttribute); + vertexAttributes[0].offset = 0; + vertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + vertexAttributes[0].componentCount = 3; + vertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(positionAttribute); // normal vertexAttributes[1].streamIndex = 0; - vertexAttributes[1].offset = 12; - vertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; - vertexAttributes[1].componentCount = 3; - vertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(normalAttribute); + vertexAttributes[1].offset = 12; + vertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + vertexAttributes[1].componentCount = 3; + vertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(normalAttribute); vertexAttributes[2].streamIndex = 0; - vertexAttributes[2].offset = 24; - vertexAttributes[2].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; - vertexAttributes[2].componentCount = 2; - vertexAttributes[2].regIndex = sceGxmProgramParameterGetResourceIndex(texCoordAttribute); + vertexAttributes[2].offset = 24; + vertexAttributes[2].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + vertexAttributes[2].componentCount = 2; + vertexAttributes[2].regIndex = sceGxmProgramParameterGetResourceIndex(texCoordAttribute); vertexStreams[0].stride = sizeof(Vertex); - vertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT; + vertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT; - if(SCE_ERR(sceGxmShaderPatcherCreateVertexProgram, - this->shaderPatcher, - this->mainVertexProgramId, - vertexAttributes, 3, - vertexStreams, 1, - &this->mainVertexProgram - )) return; + if (SCE_ERR( + sceGxmShaderPatcherCreateVertexProgram, + this->shaderPatcher, + this->mainVertexProgramId, + vertexAttributes, + 3, + vertexStreams, + 1, + &this->mainVertexProgram + )) { + return; + } } // main opaque - if(SCE_ERR(sceGxmShaderPatcherCreateFragmentProgram, - this->shaderPatcher, - this->mainFragmentProgramId, - SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, - SCE_GXM_MULTISAMPLE_NONE, - &blendInfoOpaque, - mainVertexProgramGxp, - &this->opaqueFragmentProgram - )) return; + if (SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + this->shaderPatcher, + this->mainFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + SCE_GXM_MULTISAMPLE_NONE, + &blendInfoOpaque, + mainVertexProgramGxp, + &this->opaqueFragmentProgram + )) { + return; + } // main transparent - if(SCE_ERR(sceGxmShaderPatcherCreateFragmentProgram, - this->shaderPatcher, - this->mainFragmentProgramId, - SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, - SCE_GXM_MULTISAMPLE_NONE, - &blendInfoTransparent, - mainVertexProgramGxp, - &this->transparentFragmentProgram - )) return; + if (SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + this->shaderPatcher, + this->mainFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + SCE_GXM_MULTISAMPLE_NONE, + &blendInfoTransparent, + mainVertexProgramGxp, + &this->transparentFragmentProgram + )) { + return; + } // image - if(SCE_ERR(sceGxmShaderPatcherCreateFragmentProgram, - this->shaderPatcher, - this->imageFragmentProgramId, - SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, - SCE_GXM_MULTISAMPLE_NONE, - &blendInfoTransparent, - mainVertexProgramGxp, - &this->imageFragmentProgram - )) return; + if (SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + this->shaderPatcher, + this->imageFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + SCE_GXM_MULTISAMPLE_NONE, + &blendInfoTransparent, + mainVertexProgramGxp, + &this->imageFragmentProgram + )) { + return; + } // color - if(SCE_ERR(sceGxmShaderPatcherCreateFragmentProgram, - this->shaderPatcher, - this->colorFragmentProgramId, - SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, - SCE_GXM_MULTISAMPLE_NONE, - NULL, - mainVertexProgramGxp, - &this->colorFragmentProgram - )) return; + if (SCE_ERR( + sceGxmShaderPatcherCreateFragmentProgram, + this->shaderPatcher, + this->colorFragmentProgramId, + SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4, + SCE_GXM_MULTISAMPLE_NONE, + NULL, + mainVertexProgramGxp, + &this->colorFragmentProgram + )) { + return; + } // vertex uniforms this->uModelViewMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uModelViewMatrix"); @@ -465,38 +524,39 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height) { this->uProjectionMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uProjectionMatrix"); // fragment uniforms - this->uLights = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uLights"); // SceneLight[3] + this->uLights = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uLights"); // SceneLight[3] this->uLightCount = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uLightCount"); // int - this->uShininess = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uShininess"); // float - this->uColor = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uColor"); // vec4 + this->uShininess = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uShininess"); // float + this->uColor = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uColor"); // vec4 this->uUseTexture = sceGxmProgramFindParameterByName(mainFragmentProgramGxp, "uUseTexture"); // int // clear uniforms this->colorShader_uColor = sceGxmProgramFindParameterByName(colorFragmentProgramGxp, "uColor"); // vec4 this->lights = static_castlights)>(sceClibMspaceMalloc(this->cdramPool, sizeof(*this->lights))); - for(int i = 0; i < VITA_GXM_UNIFORM_BUFFER_COUNT; i++) { - this->quadVertices[i] = (Vertex*)sceClibMspaceMalloc(this->cdramPool, sizeof(Vertex)*4*50); + for (int i = 0; i < VITA_GXM_UNIFORM_BUFFER_COUNT; i++) { + this->quadVertices[i] = (Vertex*) sceClibMspaceMalloc(this->cdramPool, sizeof(Vertex) * 4 * 50); } - this->quadIndices = (uint16_t*)sceClibMspaceMalloc(this->cdramPool, sizeof(uint16_t)*4); + this->quadIndices = (uint16_t*) sceClibMspaceMalloc(this->cdramPool, sizeof(uint16_t) * 4); this->quadIndices[0] = 0; this->quadIndices[1] = 1; this->quadIndices[2] = 2; this->quadIndices[3] = 3; - volatile uint32_t *const notificationMem = sceGxmGetNotificationRegion(); + volatile uint32_t* const notificationMem = sceGxmGetNotificationRegion(); for (uint32_t i = 0; i < VITA_GXM_UNIFORM_BUFFER_COUNT; i++) { - this->fragmentNotifications[i].address = notificationMem + (i*2); + this->fragmentNotifications[i].address = notificationMem + (i * 2); this->fragmentNotifications[i].value = 0; - this->vertexNotifications[i].address = notificationMem + (i*2)+1; + this->vertexNotifications[i].address = notificationMem + (i * 2) + 1; this->vertexNotifications[i].value = 0; } m_initialized = true; } -GXMRenderer::~GXMRenderer() { - if(!m_initialized) { +GXMRenderer::~GXMRenderer() +{ + if (!m_initialized) { return; } @@ -547,34 +607,43 @@ void GXMRenderer::AddTextureDestroyCallback(Uint32 id, IDirect3DRMTexture* textu ); } -static void convertTextureMetadata(SDL_Surface* surface, bool* supportedFormat, SceGxmTextureFormat* textureFormat, size_t* textureSize, size_t* textureAlignment, size_t* textureStride) { +static void convertTextureMetadata( + SDL_Surface* surface, + bool* supportedFormat, + SceGxmTextureFormat* textureFormat, + size_t* textureSize, + size_t* textureAlignment, + size_t* textureStride +) +{ *supportedFormat = true; *textureAlignment = SCE_GXM_TEXTURE_ALIGNMENT; - switch(surface->format) { - case SDL_PIXELFORMAT_ABGR8888: { - *textureFormat = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR; - *textureSize = surface->h * surface->pitch; - *textureStride = surface->pitch; - break; - } - /* - case SDL_PIXELFORMAT_INDEX8: { - *textureFormat = SCE_GXM_TEXTURE_FORMAT_P8_ABGR; - int pixelsSize = surface->h * surface->pitch; - int alignBytes = ALIGNMENT(pixelsSize, SCE_GXM_PALETTE_ALIGNMENT); - *textureSize = pixelsSize + alignBytes + 0xff; - *textureAlignment = SCE_GXM_PALETTE_ALIGNMENT; - *textureStride = surface->pitch; - break; - } - */ - default: { - *supportedFormat = false; - } + switch (surface->format) { + case SDL_PIXELFORMAT_ABGR8888: { + *textureFormat = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR; + *textureSize = surface->h * surface->pitch; + *textureStride = surface->pitch; + break; + } + /* + case SDL_PIXELFORMAT_INDEX8: { + *textureFormat = SCE_GXM_TEXTURE_FORMAT_P8_ABGR; + int pixelsSize = surface->h * surface->pitch; + int alignBytes = ALIGNMENT(pixelsSize, SCE_GXM_PALETTE_ALIGNMENT); + *textureSize = pixelsSize + alignBytes + 0xff; + *textureAlignment = SCE_GXM_PALETTE_ALIGNMENT; + *textureStride = surface->pitch; + break; + } + */ + default: { + *supportedFormat = false; + } } } -void copySurfaceTo(SDL_Surface* src, void* dstData, size_t textureStride) { +void copySurfaceTo(SDL_Surface* src, void* dstData, size_t textureStride) +{ SDL_Surface* dst = SDL_CreateSurfaceFrom(src->w, src->h, SDL_PIXELFORMAT_ABGR8888, dstData, textureStride); SDL_BlitSurface(src, nullptr, dst, nullptr); SDL_DestroySurface(dst); @@ -585,7 +654,6 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture) auto texture = static_cast(iTexture); auto surface = static_cast(texture->m_surface); - bool supportedFormat; size_t textureSize; size_t textureAlignment; @@ -594,9 +662,16 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture) int textureWidth = surface->m_surface->w; int textureHeight = surface->m_surface->h; - convertTextureMetadata(surface->m_surface, &supportedFormat, &textureFormat, &textureSize, &textureAlignment, &textureStride); + convertTextureMetadata( + surface->m_surface, + &supportedFormat, + &textureFormat, + &textureSize, + &textureAlignment, + &textureStride + ); - if(!supportedFormat) { + if (!supportedFormat) { textureAlignment = SCE_GXM_TEXTURE_ALIGNMENT; textureStride = textureWidth * 4; textureSize = textureHeight * textureStride; @@ -608,9 +683,10 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture) if (tex.texture == texture) { if (tex.version != texture->m_version) { void* textureData = sceGxmTextureGetData(&tex.gxmTexture); - if(!supportedFormat) { + if (!supportedFormat) { copySurfaceTo(surface->m_surface, textureData, textureStride); - } else { + } + else { memcpy(textureData, surface->m_surface->pixels, textureSize); } tex.version = texture->m_version; @@ -619,19 +695,26 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture) } } - SDL_Log("Create Texture %s w=%d h=%d s=%d", - SDL_GetPixelFormatName(surface->m_surface->format), textureWidth, textureHeight, textureStride); + SDL_Log( + "Create Texture %s w=%d h=%d s=%d", + SDL_GetPixelFormatName(surface->m_surface->format), + textureWidth, + textureHeight, + textureStride + ); // allocate gpu memory void* textureData = sceClibMspaceMemalign(this->cdramPool, textureAlignment, textureSize); uint8_t* paletteData = nullptr; - if(!supportedFormat) { - SDL_Log("unsupported SDL texture format %s, falling back on SDL_PIXELFORMAT_ABGR8888", SDL_GetPixelFormatName(surface->m_surface->format)); + if (!supportedFormat) { + SDL_Log( + "unsupported SDL texture format %s, falling back on SDL_PIXELFORMAT_ABGR8888", + SDL_GetPixelFormatName(surface->m_surface->format) + ); copySurfaceTo(surface->m_surface, textureData, textureStride); } - else if(surface->m_surface->format == SDL_PIXELFORMAT_INDEX8) - { + else if (surface->m_surface->format == SDL_PIXELFORMAT_INDEX8) { LPDIRECTDRAWPALETTE _palette; surface->GetPalette(&_palette); auto palette = static_cast(_palette); @@ -641,20 +724,27 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture) SDL_Log("copying indexed texture data from=%p to=%p", surface->m_surface->pixels, textureData); memcpy(textureData, surface->m_surface->pixels, pixelsSize); - paletteData = (uint8_t*)textureData + pixelsSize + alignBytes; - memcpy(paletteData, palette->m_palette->colors, palette->m_palette->ncolors*sizeof(SDL_Color)); + paletteData = (uint8_t*) textureData + pixelsSize + alignBytes; + memcpy(paletteData, palette->m_palette->colors, palette->m_palette->ncolors * sizeof(SDL_Color)); } - else - { + else { SDL_Log("copying texture data from=%p to=%p", surface->m_surface->pixels, textureData); memcpy(textureData, surface->m_surface->pixels, textureSize); } SceGxmTexture gxmTexture; - SCE_ERR(sceGxmTextureInitLinearStrided, &gxmTexture, textureData, textureFormat, textureWidth, textureHeight, textureStride); - //sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_LINEAR); + SCE_ERR( + sceGxmTextureInitLinearStrided, + &gxmTexture, + textureData, + textureFormat, + textureWidth, + textureHeight, + textureStride + ); + // sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_LINEAR); sceGxmTextureSetMagFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_LINEAR); - if(paletteData) { + if (paletteData) { sceGxmTextureSetPalette(&gxmTexture, paletteData); } @@ -703,33 +793,36 @@ GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup) }); } - size_t vertexBufferSize = sizeof(Vertex)*vertices.size(); - size_t indexBufferSize = sizeof(uint16_t)*indices.size(); - void* meshData = sceClibMspaceMemalign(this->cdramPool, 4, vertexBufferSize+indexBufferSize); + size_t vertexBufferSize = sizeof(Vertex) * vertices.size(); + size_t indexBufferSize = sizeof(uint16_t) * indices.size(); + void* meshData = sceClibMspaceMemalign(this->cdramPool, 4, vertexBufferSize + indexBufferSize); - Vertex* vertexBuffer = (Vertex*)meshData; - uint16_t* indexBuffer = (uint16_t*)((uint8_t*)meshData + vertexBufferSize); + Vertex* vertexBuffer = (Vertex*) meshData; + uint16_t* indexBuffer = (uint16_t*) ((uint8_t*) meshData + vertexBufferSize); - for(int i = 0; i < vertices.size(); i++) { + for (int i = 0; i < vertices.size(); i++) { D3DRMVERTEX vertex = vertices.data()[i]; vertexBuffer[i] = Vertex{ - .position = { - vertex.position.x, - vertex.position.y, - vertex.position.z, - }, - .normal = { - vertex.normal.x, - vertex.normal.y, - vertex.normal.z, - }, - .texCoord = { - vertex.tu, - vertex.tv, - } + .position = + { + vertex.position.x, + vertex.position.y, + vertex.position.z, + }, + .normal = + { + vertex.normal.x, + vertex.normal.y, + vertex.normal.z, + }, + .texCoord = + { + vertex.tu, + vertex.tv, + } }; } - memcpy(indexBuffer, indices.data(), indices.size()*sizeof(uint16_t)); + memcpy(indexBuffer, indices.data(), indices.size() * sizeof(uint16_t)); cache.meshData = meshData; cache.vertexBuffer = vertexBuffer; @@ -801,15 +894,18 @@ void GXMRenderer::GetDesc(D3DDEVICEDESC* halDesc, D3DDEVICEDESC* helDesc) memset(helDesc, 0, sizeof(D3DDEVICEDESC)); } -const char* GXMRenderer::GetName() { +const char* GXMRenderer::GetName() +{ return "GXM"; } - bool razor_triggered = false; -void GXMRenderer::StartScene() { - if(sceneStarted) return; +void GXMRenderer::StartScene() +{ + if (sceneStarted) { + return; + } sceGxmBeginScene( this->context, 0, @@ -827,15 +923,16 @@ void GXMRenderer::StartScene() { this->activeUniformBuffer = (this->activeUniformBuffer + 1) % VITA_GXM_UNIFORM_BUFFER_COUNT; sceGxmNotificationWait(&this->fragmentNotifications[this->activeUniformBuffer]); - //sceClibPrintf("this->activeUniformBuffer: %d notification: %d\n", this->activeUniformBuffer, this->fragmentNotifications[this->activeUniformBuffer].value); + // sceClibPrintf("this->activeUniformBuffer: %d notification: %d\n", this->activeUniformBuffer, + // this->fragmentNotifications[this->activeUniformBuffer].value); } int frames = 0; HRESULT GXMRenderer::BeginFrame() { frames++; - if(with_razor) { - if(!razor_triggered && frames == 10) { + if (with_razor) { + if (!razor_triggered && frames == 10) { SDL_Log("trigger razor"); sceRazorGpuCaptureSetTriggerNextFrame("ux0:/data/capture.sgx"); razor_triggered = true; @@ -869,14 +966,18 @@ HRESULT GXMRenderer::BeginFrame() return DD_OK; } -void GXMRenderer::EnableTransparency() { +void GXMRenderer::EnableTransparency() +{ this->transparencyEnabled = true; } -static void transpose4x4(const float src[4][4], float dst[4][4]) { - for (int i = 0; i < 4; ++i) - for (int j = 0; j < 4; ++j) - dst[j][i] = src[i][j]; +static void transpose4x4(const float src[4][4], float dst[4][4]) +{ + for (int i = 0; i < 4; ++i) { + for (int j = 0; j < 4; ++j) { + dst[j][i] = src[i][j]; + } + } } static const D3DRMMATRIX4D identity4x4 = { @@ -892,7 +993,6 @@ static const Matrix3x3 identity3x3 = { {0.0, 0.0, 1.0}, }; - void GXMRenderer::SubmitDraw( DWORD meshId, const D3DRMMATRIX4D& modelViewMatrix, @@ -900,7 +1000,8 @@ void GXMRenderer::SubmitDraw( const D3DRMMATRIX4D& viewMatrix, const Matrix3x3& normalMatrix, const Appearance& appearance -) { +) +{ auto& mesh = m_meshes[meshId]; char marker[256]; @@ -908,10 +1009,11 @@ void GXMRenderer::SubmitDraw( sceGxmPushUserMarker(this->context, marker); sceGxmSetVertexProgram(this->context, this->mainVertexProgram); - if(this->transparencyEnabled) { + if (this->transparencyEnabled) { sceGxmSetFragmentProgram(this->context, this->transparentFragmentProgram); - } else { - sceGxmSetFragmentProgram(this->context, this->opaqueFragmentProgram); + } + else { + sceGxmSetFragmentProgram(this->context, this->opaqueFragmentProgram); } void* vertUniforms; @@ -934,35 +1036,32 @@ void GXMRenderer::SubmitDraw( int useTexture = appearance.textureId != NO_TEXTURE_ID ? 1 : 0; SET_UNIFORM(fragUniforms, this->uUseTexture, useTexture); - if(useTexture) { + if (useTexture) { auto& texture = m_textures[appearance.textureId]; sceGxmSetFragmentTexture(this->context, 0, &texture.gxmTexture); } sceGxmSetVertexStream(this->context, 0, mesh.vertexBuffer); - sceGxmDraw( - this->context, - SCE_GXM_PRIMITIVE_TRIANGLES, - SCE_GXM_INDEX_FORMAT_U16, - mesh.indexBuffer, - mesh.indexCount - ); + sceGxmDraw(this->context, SCE_GXM_PRIMITIVE_TRIANGLES, SCE_GXM_INDEX_FORMAT_U16, mesh.indexBuffer, mesh.indexCount); sceGxmPopUserMarker(this->context); } -HRESULT GXMRenderer::FinalizeFrame() { +HRESULT GXMRenderer::FinalizeFrame() +{ return DD_OK; } -void GXMRenderer::Resize(int width, int height, const ViewportTransform& viewportTransform) { +void GXMRenderer::Resize(int width, int height, const ViewportTransform& viewportTransform) +{ m_width = width; m_height = height; m_viewportTransform = viewportTransform; SDL_Log("GXMRenderer::Resize TODO"); } -void GXMRenderer::Clear(float r, float g, float b) { +void GXMRenderer::Clear(float r, float g, float b) +{ this->StartScene(); char marker[256]; @@ -970,7 +1069,7 @@ void GXMRenderer::Clear(float r, float g, float b) { sceGxmPushUserMarker(this->context, marker); sceGxmSetVertexProgram(this->context, this->mainVertexProgram); - sceGxmSetFragmentProgram(this->context, this->colorFragmentProgram); + sceGxmSetFragmentProgram(this->context, this->colorFragmentProgram); void* vertUniforms; void* fragUniforms; @@ -983,10 +1082,10 @@ void GXMRenderer::Clear(float r, float g, float b) { Matrix3x3 normal = {{1.f, 0.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 0.f, 1.f}}; SET_UNIFORM(vertUniforms, this->uModelViewMatrix, identity4x4); // float4x4 - SET_UNIFORM(vertUniforms, this->uNormalMatrix, normal); // float3x3 + SET_UNIFORM(vertUniforms, this->uNormalMatrix, normal); // float3x3 SET_UNIFORM(vertUniforms, this->uProjectionMatrix, projection); // float4x4 - float color[] = {r,g,b,1}; + float color[] = {r, g, b, 1}; SET_UNIFORM(fragUniforms, this->colorShader_uColor, color); float x1 = 0; @@ -995,25 +1094,21 @@ void GXMRenderer::Clear(float r, float g, float b) { float y2 = y1 + 1.0; Vertex* quadVertices = this->QuadVerticesBuffer(); - quadVertices[0] = Vertex{ .position = {x1, y1, -1.0}, .normal = {0,0,0}, .texCoord = {0,0}}; - quadVertices[1] = Vertex{ .position = {x2, y1, -1.0}, .normal = {0,0,0}, .texCoord = {0,0}}; - quadVertices[2] = Vertex{ .position = {x1, y2, -1.0}, .normal = {0,0,0}, .texCoord = {0,0}}; - quadVertices[3] = Vertex{ .position = {x2, y2, -1.0}, .normal = {0,0,0}, .texCoord = {0,0}}; + quadVertices[0] = Vertex{.position = {x1, y1, -1.0}, .normal = {0, 0, 0}, .texCoord = {0, 0}}; + quadVertices[1] = Vertex{.position = {x2, y1, -1.0}, .normal = {0, 0, 0}, .texCoord = {0, 0}}; + quadVertices[2] = Vertex{.position = {x1, y2, -1.0}, .normal = {0, 0, 0}, .texCoord = {0, 0}}; + quadVertices[3] = Vertex{.position = {x2, y2, -1.0}, .normal = {0, 0, 0}, .texCoord = {0, 0}}; sceGxmSetVertexStream(this->context, 0, quadVertices); - sceGxmDraw( - this->context, - SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, - SCE_GXM_INDEX_FORMAT_U16, - this->quadIndices, 4 - ); + sceGxmDraw(this->context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, this->quadIndices, 4); sceGxmPopUserMarker(this->context); } -void GXMRenderer::Flip() { - if(!this->sceneStarted) { - this->Clear(0,0,0); +void GXMRenderer::Flip() +{ + if (!this->sceneStarted) { + this->Clear(0, 0, 0); } // end scene @@ -1022,8 +1117,9 @@ void GXMRenderer::Flip() { sceGxmEndScene( this->context, nullptr, //&this->vertexNotifications[this->activeUniformBuffer], - //nullptr - &this->fragmentNotifications[this->activeUniformBuffer] // wait for fragment processing to finish for this buffer, otherwise lighting corrupts + // nullptr + &this->fragmentNotifications[this->activeUniformBuffer] // wait for fragment processing to finish for this + // buffer, otherwise lighting corrupts ); sceGxmPadHeartbeat( &this->displayBuffersSurface[this->backBufferIndex], @@ -1042,10 +1138,11 @@ void GXMRenderer::Flip() { ); this->frontBufferIndex = this->backBufferIndex; - this->backBufferIndex = (this->backBufferIndex + 1) % VITA_GXM_DISPLAY_BUFFER_COUNT; + this->backBufferIndex = (this->backBufferIndex + 1) % VITA_GXM_DISPLAY_BUFFER_COUNT; } -void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const SDL_Rect& dstRect) { +void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const SDL_Rect& dstRect) +{ this->StartScene(); char marker[256]; @@ -1054,7 +1151,7 @@ void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const S sceGxmSetVertexProgram(this->context, this->mainVertexProgram); sceGxmSetFragmentProgram(this->context, this->imageFragmentProgram); - + void* vertUniforms; void* fragUniforms; sceGxmReserveVertexDefaultUniformBuffer(this->context, &vertUniforms); @@ -1065,8 +1162,8 @@ void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const S float top = -this->m_viewportTransform.offsetY / this->m_viewportTransform.scale; float bottom = (this->m_height - this->m_viewportTransform.offsetY) / this->m_viewportTransform.scale; - #define virtualToNDCX(x) (((x - left) / (right - left))); - #define virtualToNDCY(y) (((y - top) / (bottom - top))); +#define virtualToNDCX(x) (((x - left) / (right - left))); +#define virtualToNDCY(y) (((y - top) / (bottom - top))); float x1_virtual = static_cast(dstRect.x); float y1_virtual = static_cast(dstRect.y); @@ -1085,12 +1182,12 @@ void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const S D3DRMMATRIX4D identity; memset(identity, 0, sizeof(identity)); identity[0][0] = 1.0f; - identity[1][1] = 1.0f; - identity[2][2] = 1.0f; - identity[3][3] = 1.0f; + identity[1][1] = 1.0f; + identity[2][2] = 1.0f; + identity[3][3] = 1.0f; - SET_UNIFORM(vertUniforms, this->uModelViewMatrix, identity); // float4x4 - SET_UNIFORM(vertUniforms, this->uNormalMatrix, normal); // float3x3 + SET_UNIFORM(vertUniforms, this->uModelViewMatrix, identity); // float4x4 + SET_UNIFORM(vertUniforms, this->uNormalMatrix, normal); // float3x3 SET_UNIFORM(vertUniforms, this->uProjectionMatrix, projection); // float4x4 const GXMTextureCacheEntry& texture = m_textures[textureId]; @@ -1105,25 +1202,21 @@ void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const S float v2 = static_cast(srcRect.y + srcRect.h) / texH; Vertex* quadVertices = this->QuadVerticesBuffer(); - quadVertices[0] = Vertex{ .position = {x1, y1, 0}, .normal = {0,0,0}, .texCoord = {u1, v1}}; - quadVertices[1] = Vertex{ .position = {x2, y1, 0}, .normal = {0,0,0}, .texCoord = {u2, v1}}; - quadVertices[2] = Vertex{ .position = {x1, y2, 0}, .normal = {0,0,0}, .texCoord = {u1, v2}}; - quadVertices[3] = Vertex{ .position = {x2, y2, 0}, .normal = {0,0,0}, .texCoord = {u2, v2}}; + quadVertices[0] = Vertex{.position = {x1, y1, 0}, .normal = {0, 0, 0}, .texCoord = {u1, v1}}; + quadVertices[1] = Vertex{.position = {x2, y1, 0}, .normal = {0, 0, 0}, .texCoord = {u2, v1}}; + quadVertices[2] = Vertex{.position = {x1, y2, 0}, .normal = {0, 0, 0}, .texCoord = {u1, v2}}; + quadVertices[3] = Vertex{.position = {x2, y2, 0}, .normal = {0, 0, 0}, .texCoord = {u2, v2}}; sceGxmSetVertexStream(this->context, 0, quadVertices); sceGxmSetFrontDepthWriteEnable(this->context, SCE_GXM_DEPTH_WRITE_DISABLED); - sceGxmDraw( - this->context, - SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, - SCE_GXM_INDEX_FORMAT_U16, - this->quadIndices, 4 - ); + sceGxmDraw(this->context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, this->quadIndices, 4); sceGxmSetFrontDepthWriteEnable(this->context, SCE_GXM_DEPTH_WRITE_ENABLED); sceGxmPopUserMarker(this->context); } -void GXMRenderer::Download(SDL_Surface* target) { +void GXMRenderer::Download(SDL_Surface* target) +{ SDL_Rect srcRect = { static_cast(m_viewportTransform.offsetX), static_cast(m_viewportTransform.offsetY), @@ -1131,9 +1224,11 @@ void GXMRenderer::Download(SDL_Surface* target) { static_cast(target->h * m_viewportTransform.scale), }; SDL_Surface* src = SDL_CreateSurfaceFrom( - this->m_width, this->m_height, + this->m_width, + this->m_height, SDL_PIXELFORMAT_RGBA32, - this->displayBuffers[this->frontBufferIndex], VITA_GXM_SCREEN_STRIDE + this->displayBuffers[this->frontBufferIndex], + VITA_GXM_SCREEN_STRIDE ); SDL_BlitSurfaceScaled(src, &srcRect, target, nullptr, SDL_SCALEMODE_NEAREST); SDL_DestroySurface(src); diff --git a/miniwin/src/d3drm/backends/gxm/utils.h b/miniwin/src/d3drm/backends/gxm/utils.h index b19cce7d..b23c228d 100644 --- a/miniwin/src/d3drm/backends/gxm/utils.h +++ b/miniwin/src/d3drm/backends/gxm/utils.h @@ -4,38 +4,39 @@ #include #include -#define SCE_ERR(func, ...) ({ \ - sceClibPrintf(#func "\n"); \ - int __sce_err_ret_val = func(__VA_ARGS__); \ - if (__sce_err_ret_val < 0) { \ - sceClibPrintf(#func " error: 0x%x\n", __sce_err_ret_val); \ - } \ - __sce_err_ret_val < 0; \ -}) +#define SCE_ERR(func, ...) \ + ({ \ + sceClibPrintf(#func "\n"); \ + int __sce_err_ret_val = func(__VA_ARGS__); \ + if (__sce_err_ret_val < 0) { \ + sceClibPrintf(#func " error: 0x%x\n", __sce_err_ret_val); \ + } \ + __sce_err_ret_val < 0; \ + }) -#define ALIGN(x, a) (((x) + ((a)-1)) & ~((a)-1)) +#define ALIGN(x, a) (((x) + ((a) - 1)) & ~((a) - 1)) #define ALIGNMENT(n, a) (((a) - ((n) % (a))) % (a)) +#define SET_UNIFORM(buffer, param, value) \ + do { \ + size_t __offset = sceGxmProgramParameterGetResourceIndex(param); \ + void* __dst = (uint8_t*) (buffer) + (__offset * sizeof(uint32_t)); \ + memcpy(__dst, reinterpret_cast(&(value)), sizeof(value)); \ + } while (0) -#define SET_UNIFORM(buffer, param, value) \ - do { \ - size_t __offset = sceGxmProgramParameterGetResourceIndex(param); \ - void* __dst = (uint8_t*)(buffer) + (__offset * sizeof(uint32_t)); \ - memcpy(__dst, reinterpret_cast(&(value)), sizeof(value)); \ - } while (0) - -#define GET_SHADER_PARAM(var, gxp, name, ret) \ - const SceGxmProgramParameter* var = sceGxmProgramFindParameterByName(gxp, name); \ - if(!var) { \ - SDL_Log("Failed to find param %s", name); \ - return ret; \ +#define GET_SHADER_PARAM(var, gxp, name, ret) \ + const SceGxmProgramParameter* var = sceGxmProgramFindParameterByName(gxp, name); \ + if (!var) { \ + SDL_Log("Failed to find param %s", name); \ + return ret; \ } -static void printMatrix4x4(const float mat[4][4]) { - sceClibPrintf("mat4{\n"); - for(int i = 0; i < 4; i++) { - sceClibPrintf("%f %f %f %f\n", mat[i][0], mat[i][1], mat[i][2], mat[i][3]); - } - sceClibPrintf("}\n"); -} \ No newline at end of file +static void printMatrix4x4(const float mat[4][4]) +{ + sceClibPrintf("mat4{\n"); + for (int i = 0; i < 4; i++) { + sceClibPrintf("%f %f %f %f\n", mat[i][0], mat[i][1], mat[i][2], mat[i][3]); + } + sceClibPrintf("}\n"); +}