isledecomp/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2026-02-15 08:47:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

clang format

Browse Source
This commit is contained in:
olebeck 2025-07-06 16:41:04 +02:00
parent 02371e33ba
commit 02b942b491
11 changed files with 418 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ISLE/isleapp.cpp
View File

@ -61,6 +61,7 @@
#ifdef __vita__
#include "vita/config.h"
#include "vita/messagebox.h"
#include <psp2/appmgr.h>
#include <psp2/kernel/clib.h>
#endif

14
ISLE/vita/messagebox.cpp
View File

@ -1,16 +1,11 @@
#include "messagebox.h"
#include "../../miniwin/src/d3drm/backends/gxm/gxm_context.h"
#include <psp2/common_dialog.h>
#include <psp2/message_dialog.h>
#include "../../miniwin/src/d3drm/backends/gxm/gxm_context.h"
bool Vita_ShowSimpleMessageBox(
SDL_MessageBoxFlags flags,
const char* title,
const char* message,
SDL_Window* window
)
bool Vita_ShowSimpleMessageBox(SDL_MessageBoxFlags flags, const char* title, const char* message, SDL_Window* window)
{
int ret;
SceMsgDialogParam param;
@ -49,7 +44,8 @@ bool Vita_ShowSimpleMessageBox(
sceMsgDialogGetResult(&dialog_result);
sceMsgDialogTerm();
return dialog_result.buttonId == SCE_MSG_DIALOG_BUTTON_ID_OK;
} else {
}
else {
return false;
}
return true;

7
ISLE/vita/messagebox.h
View File

@ -3,11 +3,6 @@
#include <SDL3/SDL_messagebox.h>
bool Vita_ShowSimpleMessageBox(
SDL_MessageBoxFlags flags,
const char* title,
const char* message,
SDL_Window* window
);
bool Vita_ShowSimpleMessageBox(SDL_MessageBoxFlags flags, const char* title, const char* message, SDL_Window* window);
#endif // VITA_MESSAGE_BOX_H

4
miniwin/src/d3drm/backends/gxm/gxm_context.h
View File

@ -1,8 +1,9 @@
#pragma once
#include <psp2/gxm.h>
#include "tlsf.h"
#include <psp2/gxm.h>
#define GXM_DISPLAY_BUFFER_COUNT 3
typedef struct Vertex2D {
@ -33,7 +34,6 @@ typedef struct GXMContext {
SceUID patcherVertexUsseUid;
size_t patcherVertexUsseOffset;
void* patcherVertexUsse;
SceUID patcherFragmentUsseUid;
size_t patcherFragmentUsseOffset;
void* patcherFragmentUsse;

6
miniwin/src/d3drm/backends/gxm/incbin.h
View File

@ -281,10 +281,8 @@
#define INCBIN_EXTERN_2(TYPE, NAME) \
INCBIN_EXTERNAL const INCBIN_ALIGN TYPE \
INCBIN_CONCATENATE(INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), INCBIN_STYLE_IDENT(DATA))[]; \
INCBIN_EXTERNAL const INCBIN_ALIGN TYPE* const INCBIN_CONCATENATE( \
INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \
INCBIN_STYLE_IDENT(END) \
); \
INCBIN_EXTERNAL const INCBIN_ALIGN \
TYPE* const INCBIN_CONCATENATE(INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), INCBIN_STYLE_IDENT(END)); \
INCBIN_EXTERNAL const unsigned int INCBIN_CONCATENATE( \
INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \
INCBIN_STYLE_IDENT(SIZE) \

278
miniwin/src/d3drm/backends/gxm/renderer.cpp
View File

@ -1,6 +1,6 @@
#include "d3drmrenderer_gxm.h"
#include "gxm_memory.h"
#include "gxm_context.h"
#include "gxm_memory.h"
#include "meshutils.h"
#include "razor.h"
#include "tlsf.h"
@ -8,12 +8,12 @@
#include <SDL3/SDL.h>
#include <algorithm>
#include <psp2/common_dialog.h>
#include <psp2/display.h>
#include <psp2/gxm.h>
#include <psp2/kernel/modulemgr.h>
#include <psp2/kernel/sysmem.h>
#include <psp2/types.h>
#include <psp2/common_dialog.h>
#include <string>
#define INCBIN_PREFIX _inc_
#include "incbin.h"
@ -37,7 +37,9 @@ const SceGxmMultisampleMode msaaMode = SCE_GXM_MULTISAMPLE_NONE;
#define SCE_GXM_PRECOMPUTED_ALIGNMENT 16
#define INCSHADER(filename, name) INCBIN(name, filename); const SceGxmProgram* name = (const SceGxmProgram*) _inc_##name##Data;
#define INCSHADER(filename, name) \
INCBIN(name, filename); \
const SceGxmProgram* name = (const SceGxmProgram*) _inc_##name##Data;
INCSHADER("shaders/main.vert.gxp", mainVertexProgramGxp);
INCSHADER("shaders/main.color.frag.gxp", mainColorFragmentProgramGxp);
@ -47,7 +49,6 @@ INCSHADER("shaders/plane.vert.gxp", planeVertexProgramGxp);
INCSHADER("shaders/image.frag.gxp", imageFragmentProgramGxp);
INCSHADER("shaders/color.frag.gxp", colorFragmentProgramGxp);
static const SceGxmBlendInfo blendInfoOpaque = {
.colorMask = SCE_GXM_COLOR_MASK_ALL,
.colorFunc = SCE_GXM_BLEND_FUNC_NONE,
@ -147,7 +148,8 @@ static void display_callback(const void* callback_data)
}
}
#else
bool load_razor() {
bool load_razor()
{
return true;
}
#endif
@ -256,7 +258,8 @@ int GXMContext::init()
contextParams.fragmentUsseRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE;
contextParams.fragmentUsseRingBufferOffset = this->fragmentUsseRingBufferOffset;
if (ret = SCE_ERR(sceGxmCreateContext, &contextParams, &this->context); ret < 0) {
ret = SCE_ERR(sceGxmCreateContext, &contextParams, &this->context);
if (ret < 0) {
return ret;
}
this->contextHostMem = contextParams.hostMem;
@ -300,7 +303,8 @@ int GXMContext::init()
patcherParams.fragmentUsseMemSize = patcherFragmentUsseSize;
patcherParams.fragmentUsseOffset = this->patcherFragmentUsseOffset;
if (ret = SCE_ERR(sceGxmShaderPatcherCreate, &patcherParams, &this->shaderPatcher); ret < 0) {
ret = SCE_ERR(sceGxmShaderPatcherCreate, &patcherParams, &this->shaderPatcher);
if (ret < 0) {
return ret;
}
@ -314,7 +318,8 @@ int GXMContext::init()
renderTargetParams.multisampleMode = msaaMode;
renderTargetParams.multisampleLocations = 0;
renderTargetParams.driverMemBlock = -1; // Invalid UID
if (ret = SCE_ERR(sceGxmCreateRenderTarget, &renderTargetParams, &this->renderTarget); ret < 0) {
ret = SCE_ERR(sceGxmCreateRenderTarget, &renderTargetParams, &this->renderTarget);
if (ret < 0) {
return ret;
}
@ -328,22 +333,25 @@ int GXMContext::init()
"displayBuffers"
);
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmColorSurfaceInit,
&this->displayBuffersSurface[i],
SCE_GXM_COLOR_FORMAT_A8B8G8R8,
SCE_GXM_COLOR_SURFACE_LINEAR,
(msaaMode == SCE_GXM_MULTISAMPLE_NONE) ? SCE_GXM_COLOR_SURFACE_SCALE_NONE : SCE_GXM_COLOR_SURFACE_SCALE_MSAA_DOWNSCALE,
(msaaMode == SCE_GXM_MULTISAMPLE_NONE) ? SCE_GXM_COLOR_SURFACE_SCALE_NONE
: SCE_GXM_COLOR_SURFACE_SCALE_MSAA_DOWNSCALE,
SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
VITA_GXM_SCREEN_WIDTH,
VITA_GXM_SCREEN_HEIGHT,
VITA_GXM_SCREEN_STRIDE,
this->displayBuffers[i]
); ret < 0) {
);
if (ret < 0) {
return ret;
}
if (ret = SCE_ERR(sceGxmSyncObjectCreate, &this->displayBuffersSync[i]); ret < 0) {
ret = SCE_ERR(sceGxmSyncObjectCreate, &this->displayBuffersSync[i]);
if (ret < 0) {
return ret;
}
}
@ -360,22 +368,23 @@ int GXMContext::init()
this->stencilBufferData = vita_mem_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
4 * sampleCount,
1 * sampleCount,
SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
&this->stencilBufferUid,
"stencilBufferData"
);
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmDepthStencilSurfaceInit,
&this->depthSurface,
SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24,
SCE_GXM_DEPTH_STENCIL_FORMAT_DF32_S8,
SCE_GXM_DEPTH_STENCIL_SURFACE_TILED,
depthStrideInSamples,
this->depthBufferData,
this->stencilBufferData
); ret < 0) {
);
if (ret < 0) {
return ret;
}
@ -385,32 +394,41 @@ int GXMContext::init()
CDRAM_POOL_SIZE,
16,
SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
&this->cdramUID, "cdram_pool"
&this->cdramUID,
"cdram_pool"
);
this->cdramPool = SDL_malloc(tlsf_size());
tlsf_create(this->cdramPool);
tlsf_add_pool(this->cdramPool, this->cdramMem, CDRAM_POOL_SIZE);
// register plane, color, image shaders
if (ret = SCE_ERR( sceGxmShaderPatcherRegisterProgram,
ret = SCE_ERR(
sceGxmShaderPatcherRegisterProgram,
this->shaderPatcher,
planeVertexProgramGxp,
&this->planeVertexProgramId
); ret < 0) {
);
if (ret < 0) {
return ret;
}
if (ret = SCE_ERR(sceGxmShaderPatcherRegisterProgram,
ret = SCE_ERR(
sceGxmShaderPatcherRegisterProgram,
this->shaderPatcher,
colorFragmentProgramGxp,
&this->colorFragmentProgramId
); ret < 0) {
);
if (ret < 0) {
return ret;
}
if (ret = SCE_ERR(sceGxmShaderPatcherRegisterProgram,
ret = SCE_ERR(
sceGxmShaderPatcherRegisterProgram,
this->shaderPatcher,
imageFragmentProgramGxp,
&this->imageFragmentProgramId
); ret < 0) {
);
if (ret < 0) {
return ret;
}
@ -438,7 +456,7 @@ int GXMContext::init()
vertexStreams[0].stride = sizeof(float) * 4;
vertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherCreateVertexProgram,
this->shaderPatcher,
this->planeVertexProgramId,
@ -447,11 +465,12 @@ int GXMContext::init()
vertexStreams,
1,
&this->planeVertexProgram
); ret < 0) {
);
if (ret < 0) {
return ret;
}
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherCreateFragmentProgram,
this->shaderPatcher,
this->colorFragmentProgramId,
@ -460,11 +479,12 @@ int GXMContext::init()
NULL,
planeVertexProgramGxp,
&this->colorFragmentProgram
); ret < 0) {
);
if (ret < 0) {
return ret;
}
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherCreateFragmentProgram,
this->shaderPatcher,
this->imageFragmentProgramId,
@ -473,7 +493,8 @@ int GXMContext::init()
&blendInfoTransparent,
planeVertexProgramGxp,
&this->imageFragmentProgram
); ret < 0) {
);
if (ret < 0) {
return ret;
}
}
@ -512,7 +533,8 @@ void GXMContext::free(void* ptr)
tlsf_free(this->cdramPool, ptr);
}
void GXMContext::clear(float r, float g, float b, bool new_scene) {
void GXMContext::clear(float r, float g, float b, bool new_scene)
{
new_scene = new_scene && !this->sceneStarted;
if (new_scene) {
sceGxmBeginScene(
@ -549,9 +571,11 @@ void GXMContext::clear(float r, float g, float b, bool new_scene) {
}
}
void GXMContext::copy_frontbuffer() {
void GXMContext::copy_frontbuffer()
{
SceGxmTexture texture;
sceGxmTextureInitLinearStrided(&texture,
sceGxmTextureInitLinearStrided(
&texture,
this->displayBuffers[this->frontBufferIndex],
SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR,
VITA_GXM_SCREEN_WIDTH,
@ -573,10 +597,15 @@ void GXMContext::copy_frontbuffer() {
sceGxmDraw(this->context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, this->clearIndices, 4);
}
void GXMContext::destroy() {
void GXMContext::destroy()
{
sceGxmDisplayQueueFinish();
if(gxm->context) sceGxmFinish(gxm->context);
if(this->renderTarget) sceGxmDestroyRenderTarget(this->renderTarget);
if (gxm->context) {
sceGxmFinish(gxm->context);
}
if (this->renderTarget) {
sceGxmDestroyRenderTarget(this->renderTarget);
}
for (int i = 0; i < GXM_DISPLAY_BUFFER_COUNT; i++) {
if (this->displayBuffersUid[i]) {
vita_mem_free(this->displayBuffersUid[i]);
@ -585,8 +614,12 @@ void GXMContext::destroy() {
}
}
if(this->depthBufferUid) vita_mem_free(this->depthBufferUid);
if(this->stencilBufferUid) vita_mem_free(this->stencilBufferUid);
if (this->depthBufferUid) {
vita_mem_free(this->depthBufferUid);
}
if (this->stencilBufferUid) {
vita_mem_free(this->stencilBufferUid);
}
this->stencilBufferData = nullptr;
this->depthBufferData = nullptr;
@ -599,15 +632,13 @@ void GXMContext::destroy() {
SDL_free(this->contextHostMem);
}
void GXMContext::swap_display() {
void GXMContext::swap_display()
{
if (this->sceneStarted) {
SCE_ERR(sceGxmEndScene,
gxm->context,
nullptr,
nullptr
);
sceGxmEndScene(gxm->context, nullptr, nullptr);
this->sceneStarted = false;
}
SceCommonDialogUpdateParam updateParam;
SDL_zero(updateParam);
updateParam.renderTarget.colorFormat = VITA_GXM_COLOR_FORMAT;
@ -637,35 +668,6 @@ void GXMContext::swap_display() {
this->backBufferIndex = (this->backBufferIndex + 1) % GXM_DISPLAY_BUFFER_COUNT;
}
static void CreateOrthoMatrix(float left, float right, float bottom, float top, D3DRMMATRIX4D& outMatrix)
{
float near = -1.0f;
float far = 1.0f;
float rl = right - left;
float tb = top - bottom;
float fn = far - near;
outMatrix[0][0] = 2.0f / rl;
outMatrix[0][1] = 0.0f;
outMatrix[0][2] = 0.0f;
outMatrix[0][3] = 0.0f;
outMatrix[1][0] = 0.0f;
outMatrix[1][1] = 2.0f / tb;
outMatrix[1][2] = 0.0f;
outMatrix[1][3] = 0.0f;
outMatrix[2][0] = 0.0f;
outMatrix[2][1] = 0.0f;
outMatrix[2][2] = -2.0f / fn;
outMatrix[2][3] = 0.0f;
outMatrix[3][0] = -(right + left) / rl;
outMatrix[3][1] = -(top + bottom) / tb;
outMatrix[3][2] = -(far + near) / fn;
outMatrix[3][3] = 1.0f;
}
Direct3DRMRenderer* GXMRenderer::Create(DWORD width, DWORD height)
{
int ret = gxm_library_init();
@ -686,33 +688,39 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
if (!gxm) {
gxm = (GXMContext*) SDL_malloc(sizeof(GXMContext));
}
if(ret = SCE_ERR(gxm->init); ret < 0) {
ret = SCE_ERR(gxm->init);
if (ret < 0) {
return;
}
// register shader programs
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherRegisterProgram,
gxm->shaderPatcher,
mainVertexProgramGxp,
&this->mainVertexProgramId
); ret < 0) {
);
if (ret < 0) {
return;
}
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherRegisterProgram,
gxm->shaderPatcher,
mainColorFragmentProgramGxp,
&this->mainColorFragmentProgramId
); ret < 0) {
);
if (ret < 0) {
return;
}
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherRegisterProgram,
gxm->shaderPatcher,
mainTextureFragmentProgramGxp,
&this->mainTextureFragmentProgramId
); ret < 0) {
);
if (ret < 0) {
return;
}
@ -748,7 +756,7 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
vertexStreams[0].stride = sizeof(Vertex);
vertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherCreateVertexProgram,
gxm->shaderPatcher,
this->mainVertexProgramId,
@ -757,13 +765,14 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
vertexStreams,
1,
&this->mainVertexProgram
); ret < 0) {
);
if (ret < 0) {
return;
}
}
// main color opaque
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherCreateFragmentProgram,
gxm->shaderPatcher,
this->mainColorFragmentProgramId,
@ -772,12 +781,13 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
&blendInfoOpaque,
mainVertexProgramGxp,
&this->opaqueColorFragmentProgram
); ret < 0) {
);
if (ret < 0) {
return;
}
// main color blended
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherCreateFragmentProgram,
gxm->shaderPatcher,
this->mainColorFragmentProgramId,
@ -786,12 +796,13 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
&blendInfoTransparent,
mainVertexProgramGxp,
&this->blendedColorFragmentProgram
); ret < 0) {
);
if (ret < 0) {
return;
}
// main texture opaque
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherCreateFragmentProgram,
gxm->shaderPatcher,
this->mainTextureFragmentProgramId,
@ -800,12 +811,13 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
&blendInfoOpaque,
mainVertexProgramGxp,
&this->opaqueTextureFragmentProgram
); ret < 0) {
);
if (ret < 0) {
return;
}
// main texture transparent
if (ret = SCE_ERR(
ret = SCE_ERR(
sceGxmShaderPatcherCreateFragmentProgram,
gxm->shaderPatcher,
this->mainTextureFragmentProgramId,
@ -814,16 +826,12 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
&blendInfoTransparent,
mainVertexProgramGxp,
&this->blendedTextureFragmentProgram
); ret < 0) {
);
if (ret < 0) {
return;
}
// vertex uniforms
//this->uNormalMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uNormalMatrix");
//this->uWorldViewProjection = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uWorldViewProjection");
//this->uWorld = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uWorld");
//this->uViewInverse = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uViewInverse");
this->uModelViewMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uModelViewMatrix");
this->uNormalMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uNormalMatrix");
this->uProjectionMatrix = sceGxmProgramFindParameterByName(mainVertexProgramGxp, "uProjectionMatrix");
@ -869,21 +877,31 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
break;
}
}
if(ids) SDL_free(ids);
if (ids) {
SDL_free(ids);
}
m_initialized = true;
}
GXMRenderer::~GXMRenderer()
{
for (int i = 0; i < GXM_FRAGMENT_BUFFER_COUNT; i++) {
if(this->lights[i]) gxm->free(this->lights[i]);
if (this->lights[i]) {
gxm->free(this->lights[i]);
}
}
for (int i = 0; i < GXM_VERTEX_BUFFER_COUNT; i++) {
if(this->quadVertices[i]) gxm->free(this->quadVertices[i]);
if (this->quadVertices[i]) {
gxm->free(this->quadVertices[i]);
}
}
if (this->quadIndices) {
gxm->free(this->quadIndices);
}
if(this->quadIndices) gxm->free(this->quadIndices);
if(this->gamepad) SDL_CloseGamepad(this->gamepad);
if (this->gamepad) {
SDL_CloseGamepad(this->gamepad);
}
}
void GXMRenderer::PushLights(const SceneLight* lightsArray, size_t count)
@ -1094,7 +1112,8 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture, bool isUi, float
sceGxmTextureSetMagFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT);
sceGxmTextureSetUAddrMode(&gxmTexture, SCE_GXM_TEXTURE_ADDR_CLAMP);
sceGxmTextureSetVAddrMode(&gxmTexture, SCE_GXM_TEXTURE_ADDR_CLAMP);
} else {
}
else {
sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_LINEAR);
sceGxmTextureSetMagFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_LINEAR);
sceGxmTextureSetUAddrMode(&gxmTexture, SCE_GXM_TEXTURE_ADDR_REPEAT);
@ -1209,24 +1228,24 @@ GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup)
if (texture) {
fragmentProgramGxp = mainTextureFragmentProgramGxp;
fragmentProgram = isOpaque ? this->opaqueTextureFragmentProgram : this->blendedTextureFragmentProgram;
} else {
}
else {
fragmentProgramGxp = mainColorFragmentProgramGxp;
fragmentProgram = isOpaque ? this->opaqueColorFragmentProgram : this->blendedColorFragmentProgram;
}
// get sizes
const size_t drawSize = ALIGN(sceGxmGetPrecomputedDrawSize(this->mainVertexProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT);
const size_t vertexStateSize = ALIGN(sceGxmGetPrecomputedVertexStateSize(this->mainVertexProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT);
const size_t fragmentStateSize = ALIGN(sceGxmGetPrecomputedFragmentStateSize(fragmentProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT);
const size_t vertexStateSize =
ALIGN(sceGxmGetPrecomputedVertexStateSize(this->mainVertexProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT);
const size_t fragmentStateSize =
ALIGN(sceGxmGetPrecomputedFragmentStateSize(fragmentProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT);
const size_t precomputeDataSize =
drawSize +
vertexStateSize * GXM_VERTEX_BUFFER_COUNT +
fragmentStateSize * GXM_FRAGMENT_BUFFER_COUNT;
drawSize + vertexStateSize * GXM_VERTEX_BUFFER_COUNT + fragmentStateSize * GXM_FRAGMENT_BUFFER_COUNT;
const size_t vertexDefaultBufferSize = sceGxmProgramGetDefaultUniformBufferSize(mainVertexProgramGxp);
const size_t fragmentDefaultBufferSize = sceGxmProgramGetDefaultUniformBufferSize(fragmentProgramGxp);
const size_t uniformBuffersSize =
vertexDefaultBufferSize * GXM_VERTEX_BUFFER_COUNT;
const size_t uniformBuffersSize = vertexDefaultBufferSize * GXM_VERTEX_BUFFER_COUNT;
fragmentStateSize* GXM_FRAGMENT_BUFFER_COUNT;
sceClibPrintf("drawSize: %d\n", drawSize);
@ -1245,11 +1264,7 @@ GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup)
cache.uniformBuffers = uniformBuffers;
// init precomputed draw
SCE_ERR(sceGxmPrecomputedDrawInit,
&cache.drawState,
this->mainVertexProgram,
precomputeData
);
SCE_ERR(sceGxmPrecomputedDrawInit, &cache.drawState, this->mainVertexProgram, precomputeData);
void* vertexStreams[] = {vertexBuffer};
sceGxmPrecomputedDrawSetAllVertexStreams(&cache.drawState, vertexStreams);
sceGxmPrecomputedDrawSetParams(
@ -1263,36 +1278,24 @@ GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup)
// init precomputed vertex state
for (int bufferIndex = 0; bufferIndex < GXM_VERTEX_BUFFER_COUNT; bufferIndex++) {
SCE_ERR(sceGxmPrecomputedVertexStateInit,
SCE_ERR(
sceGxmPrecomputedVertexStateInit,
&cache.vertexState[bufferIndex],
this->mainVertexProgram,
precomputeData
);
sceGxmPrecomputedVertexStateSetDefaultUniformBuffer(
&cache.vertexState[bufferIndex],
uniformBuffers
);
sceGxmPrecomputedVertexStateSetDefaultUniformBuffer(&cache.vertexState[bufferIndex], uniformBuffers);
precomputeData += vertexStateSize;
uniformBuffers += vertexDefaultBufferSize;
}
// init precomputed fragment state
for (int bufferIndex = 0; bufferIndex < GXM_FRAGMENT_BUFFER_COUNT; bufferIndex++) {
SCE_ERR(sceGxmPrecomputedFragmentStateInit,
&cache.fragmentState[bufferIndex],
fragmentProgram,
precomputeData
);
SCE_ERR(sceGxmPrecomputedFragmentStateInit, &cache.fragmentState[bufferIndex], fragmentProgram, precomputeData);
if (texture) {
sceGxmPrecomputedFragmentStateSetTexture(
&cache.fragmentState[bufferIndex],
0, texture
);
sceGxmPrecomputedFragmentStateSetTexture(&cache.fragmentState[bufferIndex], 0, texture);
}
sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer(
&cache.fragmentState[bufferIndex],
uniformBuffers
);
sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer(&cache.fragmentState[bufferIndex], uniformBuffers);
precomputeData += fragmentStateSize;
uniformBuffers += fragmentDefaultBufferSize;
}
@ -1454,7 +1457,8 @@ HRESULT GXMRenderer::BeginFrame()
lightData->lights[i].vec[0] = light.direction.x;
lightData->lights[i].vec[1] = light.direction.y;
lightData->lights[i].vec[2] = light.direction.z;
} else {
}
else {
lightData->lights[i].vec[0] = light.position.x;
lightData->lights[i].vec[1] = light.position.y;
lightData->lights[i].vec[2] = light.position.z;
@ -1520,12 +1524,12 @@ void GXMRenderer::SubmitDraw(
sceGxmPushUserMarker(gxm->context, marker);
#endif
bool textured = appearance.textureId != NO_TEXTURE_ID;
const SceGxmFragmentProgram* fragmentProgram;
if (this->transparencyEnabled) {
fragmentProgram = textured ? this->blendedTextureFragmentProgram : this->blendedColorFragmentProgram;
} else {
}
else {
fragmentProgram = textured ? this->opaqueTextureFragmentProgram : this->opaqueColorFragmentProgram;
}
sceGxmSetVertexProgram(gxm->context, this->mainVertexProgram);
@ -1615,7 +1619,8 @@ void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const S
sceGxmSetVertexProgram(gxm->context, gxm->planeVertexProgram);
if (textureId != NO_TEXTURE_ID) {
sceGxmSetFragmentProgram(gxm->context, gxm->imageFragmentProgram);
} else {
}
else {
sceGxmSetFragmentProgram(gxm->context, gxm->colorFragmentProgram);
}
@ -1657,7 +1662,8 @@ void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const S
v1 = static_cast<float>(srcRect.y) / texH;
u2 = static_cast<float>(srcRect.x + srcRect.w) / texW;
v2 = static_cast<float>(srcRect.y + srcRect.h) / texH;
} else {
}
else {
SET_UNIFORM(fragUniforms, gxm->color_uColor, color);
}

4
miniwin/src/d3drm/d3drm.cpp
View File

@ -153,8 +153,8 @@ HRESULT Direct3DRMImpl::CreateDeviceFromSurface(
DDSDesc.dwSize = sizeof(DDSURFACEDESC);
surface->GetSurfaceDesc(&DDSDesc);
if(false) {}
if (false) {
}
#ifdef USE_SDL_GPU
else if (SDL_memcmp(&guid, &SDL3_GPU_GUID, sizeof(GUID)) == 0) {
DDRenderer = Direct3DRMSDL3GPURenderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);

3
miniwin/src/ddraw/ddraw.cpp
View File

@ -352,7 +352,8 @@ HRESULT DirectDrawImpl::CreateDevice(
DDSDesc.dwSize = sizeof(DDSURFACEDESC);
pBackBuffer->GetSurfaceDesc(&DDSDesc);
if(false) {}
if (false) {
}
#ifdef USE_SDL_GPU
else if (SDL_memcmp(&guid, &SDL3_GPU_GUID, sizeof(GUID)) == 0) {
DDRenderer = Direct3DRMSDL3GPURenderer::Create(DDSDesc.dwWidth, DDSDesc.dwHeight);

33
miniwin/src/internal/d3drmrenderer_gxm.h
View File

@ -2,17 +2,15 @@
#include "d3drmrenderer.h"
#include "d3drmtexture_impl.h"
#include "ddraw_impl.h"
#include "ddpalette_impl.h"
#include "ddraw_impl.h"
#include "gxm_context.h"
#include <SDL3/SDL.h>
#include <vector>
#include <psp2/gxm.h>
#include <psp2/types.h>
#include <psp2/kernel/clib.h>
#include "gxm_context.h"
#include <psp2/types.h>
#include <vector>
DEFINE_GUID(GXM_GUID, 0x682656F3, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x58, 0x4D);
@ -66,7 +64,6 @@ struct GXMSceneLightUniform {
float ambientLight[3];
};
typedef struct Vertex {
float position[3];
float normal[3];
@ -76,11 +73,7 @@ typedef struct Vertex {
class GXMRenderer : public Direct3DRMRenderer {
public:
static Direct3DRMRenderer* Create(DWORD width, DWORD height);
GXMRenderer(
DWORD width,
DWORD height
);
GXMRenderer(int forEnum) {};
GXMRenderer(DWORD width, DWORD height);
~GXMRenderer() override;
void PushLights(const SceneLight* lightsArray, size_t count) override;
@ -113,14 +106,16 @@ class GXMRenderer : public Direct3DRMRenderer {
GXMMeshCacheEntry GXMUploadMesh(const MeshGroup& meshGroup);
void StartScene();
inline const SceGxmTexture* UseTexture(GXMTextureCacheEntry& texture) {
inline const SceGxmTexture* UseTexture(GXMTextureCacheEntry& texture)
{
texture.notifications[texture.currentIndex] = &this->fragmentNotifications[this->currentFragmentBufferIndex];
const SceGxmTexture* gxmTexture = &texture.gxmTexture[texture.currentIndex];
sceGxmSetFragmentTexture(gxm->context, 0, gxmTexture);
return gxmTexture;
}
inline Vertex2D* QuadVerticesBuffer() {
inline Vertex2D* QuadVerticesBuffer()
{
Vertex2D* verts = &this->quadVertices[this->currentVertexBufferIndex][this->quadsUsed * 4];
this->quadsUsed += 1;
if (this->quadsUsed >= 50) {
@ -130,9 +125,7 @@ class GXMRenderer : public Direct3DRMRenderer {
return verts;
}
inline GXMSceneLightUniform* LightsBuffer() {
return this->lights[this->currentFragmentBufferIndex];
}
inline GXMSceneLightUniform* LightsBuffer() { return this->lights[this->currentFragmentBufferIndex]; }
std::vector<GXMTextureCacheEntry> m_textures;
std::vector<GXMMeshCacheEntry> m_meshes;
@ -153,15 +146,10 @@ class GXMRenderer : public Direct3DRMRenderer {
SceGxmFragmentProgram* blendedTextureFragmentProgram;
// main shader vertex uniforms
//const SceGxmProgramParameter* uNormalMatrix;
//const SceGxmProgramParameter* uWorldViewProjection;
//const SceGxmProgramParameter* uWorld;
//const SceGxmProgramParameter* uViewInverse;
const SceGxmProgramParameter* uModelViewMatrix;
const SceGxmProgramParameter* uNormalMatrix;
const SceGxmProgramParameter* uProjectionMatrix;
// main shader fragment uniforms
const SceGxmProgramParameter* uShininess;
const SceGxmProgramParameter* uColor;
@ -212,4 +200,3 @@ inline static void GXMRenderer_EnumDevice(LPD3DENUMDEVICESCALLBACK cb, void* ctx
EnumDevice(cb, ctx, "GXM HAL", &halDesc, &helDesc, GXM_GUID);
}