clang format

ISLE/isleapp.cpp

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

ISLE/vita/messagebox.cpp

@@ -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;

ISLE/vita/messagebox.h

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

miniwin/src/d3drm/backends/gxm/gxm_context.h

@@ -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;

miniwin/src/d3drm/backends/gxm/incbin.h

@@ -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_EXTERNAL const INCBIN_ALIGN                                                                                 \
-		INCBIN_CONCATENATE(INCBIN_PREFIX, NAME),                                                                       \
+		TYPE* const INCBIN_CONCATENATE(INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), INCBIN_STYLE_IDENT(END));              \
-		INCBIN_STYLE_IDENT(END)                                                                                        \
-	);                                                                                                                 \
 	INCBIN_EXTERNAL const unsigned int INCBIN_CONCATENATE(                                                             \
 		INCBIN_CONCATENATE(INCBIN_PREFIX, NAME),                                                                       \
 		INCBIN_STYLE_IDENT(SIZE)                                                                                       \

miniwin/src/d3drm/backends/gxm/renderer.cpp

@@ -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 (gxm->context) {
-	if(this->renderTarget) sceGxmDestroyRenderTarget(this->renderTarget);
+		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->depthBufferUid) {
-	if(this->stencilBufferUid) vita_mem_free(this->stencilBufferUid);
+		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, 
+		sceGxmEndScene(gxm->context, nullptr, nullptr);
-			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 vertexStateSize =
-	const size_t fragmentStateSize = ALIGN(sceGxmGetPrecomputedFragmentStateSize(fragmentProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT);
+		ALIGN(sceGxmGetPrecomputedVertexStateSize(this->mainVertexProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT);
+	const size_t fragmentStateSize =
+		ALIGN(sceGxmGetPrecomputedFragmentStateSize(fragmentProgram), SCE_GXM_PRECOMPUTED_ALIGNMENT);
 	const size_t precomputeDataSize =
-		drawSize +
+		drawSize + vertexStateSize * GXM_VERTEX_BUFFER_COUNT + fragmentStateSize * GXM_FRAGMENT_BUFFER_COUNT;
-		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 =
+	const size_t uniformBuffersSize = vertexDefaultBufferSize * GXM_VERTEX_BUFFER_COUNT;
-		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,
+	SCE_ERR(sceGxmPrecomputedDrawInit, &cache.drawState, this->mainVertexProgram, precomputeData);
-		&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(
+		sceGxmPrecomputedVertexStateSetDefaultUniformBuffer(&cache.vertexState[bufferIndex], uniformBuffers);
-			&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,
+		SCE_ERR(sceGxmPrecomputedFragmentStateInit, &cache.fragmentState[bufferIndex], fragmentProgram, precomputeData);
-			&cache.fragmentState[bufferIndex],
-			fragmentProgram,
-			precomputeData
-		);
 		if (texture) {
-			sceGxmPrecomputedFragmentStateSetTexture(
+			sceGxmPrecomputedFragmentStateSetTexture(&cache.fragmentState[bufferIndex], 0, texture);
-				&cache.fragmentState[bufferIndex],
-				0, texture
-			);
 		}
-		sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer(
+		sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer(&cache.fragmentState[bufferIndex], uniformBuffers);
-			&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);
 	}
 

miniwin/src/d3drm/d3drm.cpp

@@ -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);

miniwin/src/ddraw/ddraw.cpp

@@ -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);

miniwin/src/internal/d3drmrenderer_gxm.h

@@ -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 <psp2/types.h>
-#include "gxm_context.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(
+	GXMRenderer(DWORD width, DWORD height);
-		DWORD width,
-		DWORD height
-	);
-	GXMRenderer(int forEnum) {};
 	~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() {
+	inline GXMSceneLightUniform* LightsBuffer() { return this->lights[this->currentFragmentBufferIndex]; }
-		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);
 }
-