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/config.cpp

@@ -13,5 +13,5 @@ void VITA_SetupDefaultConfigOverrides(dictionary* p_dictionary)
 	iniparser_set(p_dictionary, "isle:Draw Cursor", "true");
 
 	// Use e_noAnimation/cut transition
-	//iniparser_set(p_dictionary, "isle:Transition Type", "1");
+	// iniparser_set(p_dictionary, "isle:Transition Type", "1");
 }

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;
@@ -28,28 +23,29 @@ bool Vita_ShowSimpleMessageBox(
 	char message_data[0x1000];
 	SDL_snprintf(message_data, sizeof(message_data), "%s\r\n\r\n%s", title, message);
 
-    msgParam.msg = (const SceChar8 *)message_data;
+	msgParam.msg = (const SceChar8*) message_data;
 	msgParam.buttonType = SCE_MSG_DIALOG_BUTTON_TYPE_OK;
 	param.userMsgParam = &msgParam;
 
-    if(!gxm) {
+	if (!gxm) {
-		gxm = (GXMContext*)SDL_malloc(sizeof(GXMContext));
+		gxm = (GXMContext*) SDL_malloc(sizeof(GXMContext));
 	}
-	if(ret = gxm->init(); ret < 0) {
+	if (ret = gxm->init(); ret < 0) {
 		return false;
 	}
 
-    init_result = (SceCommonDialogErrorCode)sceMsgDialogInit(&param);
+	init_result = (SceCommonDialogErrorCode) sceMsgDialogInit(&param);
 	if (init_result >= 0) {
 		while (sceMsgDialogGetStatus() == SCE_COMMON_DIALOG_STATUS_RUNNING) {
-            gxm->clear(0,0,1, true);
+			gxm->clear(0, 0, 1, true);
 			gxm->swap_display();
 		}
 		SDL_zero(dialog_result);
 		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"
@@ -29,7 +29,7 @@ bool gxm_initialized = false;
 #define VITA_GXM_SCREEN_HEIGHT 544
 #define VITA_GXM_SCREEN_STRIDE 1024
 #define VITA_GXM_PENDING_SWAPS 2
-#define CDRAM_POOL_SIZE 64*1024*1024
+#define CDRAM_POOL_SIZE 64 * 1024 * 1024
 
 #define VITA_GXM_COLOR_FORMAT SCE_GXM_COLOR_FORMAT_A8B8G8R8
 #define VITA_GXM_PIXEL_FORMAT SCE_DISPLAY_PIXELFORMAT_A8B8G8R8
@@ -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,
@@ -85,10 +86,10 @@ static void display_callback(const void* callback_data)
 }
 
 #ifdef WITH_RAZOR
-	#include <taihen.h>
+#include <taihen.h>
 
-	static int load_skprx(const char* name)
+static int load_skprx(const char* name)
-	{
+{
 	int modid = taiLoadKernelModule(name, 0, nullptr);
 	if (modid < 0) {
 		sceClibPrintf("%s load: 0x%08x\n", name, modid);
@@ -100,10 +101,10 @@ static void display_callback(const void* callback_data)
 		sceClibPrintf("%s start: 0x%08x\n", name, ret);
 	}
 	return ret;
-	}
+}
 
-	static int load_suprx(const char* name)
+static int load_suprx(const char* name)
-	{
+{
 	sceClibPrintf("loading %s\n", name);
 	int modid = _sceKernelLoadModule(name, 0, nullptr);
 	if (modid < 0) {
@@ -116,12 +117,12 @@ static void display_callback(const void* callback_data)
 		sceClibPrintf("%s start: 0x%08x\n", name, ret);
 	}
 	return ret;
-	}
+}
 
-	static const bool extra_debug = false;
+static const bool extra_debug = false;
 
-	static void load_razor()
+static void load_razor()
-	{
+{
 	if (load_suprx("app0:librazorcapture_es4.suprx") >= 0) {
 		with_razor = true;
 	}
@@ -139,17 +140,18 @@ static void display_callback(const void* callback_data)
 	}
 
 	if (with_razor) {
-			//sceRazorGpuCaptureEnableSalvage("ux0:data/gpu_crash.sgx");
+		// sceRazorGpuCaptureEnableSalvage("ux0:data/gpu_crash.sgx");
 	}
 
 	if (with_razor_hud) {
 		sceRazorGpuTraceSetFilename("ux0:data/gpu_trace", 3);
 	}
-	}
+}
 #else
-	bool load_razor() {
+bool load_razor()
+{
 	return true;
-	}
+}
 #endif
 
 int gxm_library_init()
@@ -181,12 +183,12 @@ GXMContext* gxm;
 
 int GXMContext::init()
 {
-	if(this->context) {
+	if (this->context) {
 		return 0;
 	}
 
 	int ret = gxm_library_init();
-	if(ret < 0) {
+	if (ret < 0) {
 		return ret;
 	}
 
@@ -199,11 +201,11 @@ int GXMContext::init()
 	uint32_t sampleCount = alignedWidth * alignedHeight;
 	uint32_t depthStrideInSamples = alignedWidth;
 
-	if(msaaMode == SCE_GXM_MULTISAMPLE_4X){
+	if (msaaMode == SCE_GXM_MULTISAMPLE_4X) {
 		sampleCount *= 4;
 		depthStrideInSamples *= 2;
 	}
-	else if(msaaMode == SCE_GXM_MULTISAMPLE_2X){
+	else if (msaaMode == SCE_GXM_MULTISAMPLE_2X) {
 		sampleCount *= 2;
 	}
 
@@ -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,18 +493,19 @@ int GXMContext::init()
 			&blendInfoTransparent,
 			planeVertexProgramGxp,
 			&this->imageFragmentProgram
-			); ret < 0) {
+		);
+		if (ret < 0) {
 			return ret;
 		}
 	}
 
 	this->color_uColor = sceGxmProgramFindParameterByName(colorFragmentProgramGxp, "uColor"); // vec4
 
-	this->clearVertices = static_cast<Vertex2D*>(this->alloc(sizeof(Vertex2D)*4, 4));
+	this->clearVertices = static_cast<Vertex2D*>(this->alloc(sizeof(Vertex2D) * 4, 4));
-	this->clearVertices[0] = Vertex2D{ .position = {-1.0, 1.0}, .texCoord = {0, 0} };
+	this->clearVertices[0] = Vertex2D{.position = {-1.0, 1.0}, .texCoord = {0, 0}};
-	this->clearVertices[1] = Vertex2D{ .position = {1.0, 1.0}, .texCoord = {0, 0} };
+	this->clearVertices[1] = Vertex2D{.position = {1.0, 1.0}, .texCoord = {0, 0}};
-	this->clearVertices[2] = Vertex2D{ .position = {-1.0, -1.0}, .texCoord = {0, 0} };
+	this->clearVertices[2] = Vertex2D{.position = {-1.0, -1.0}, .texCoord = {0, 0}};
-	this->clearVertices[3] = Vertex2D{ .position = {1.0,-1.0}, .texCoord = {0, 0} };
+	this->clearVertices[3] = Vertex2D{.position = {1.0, -1.0}, .texCoord = {0, 0}};
 
 	this->clearIndices = static_cast<uint16_t*>(this->alloc(sizeof(uint16_t) * 4, 4));
 	this->clearIndices[0] = 0;
@@ -512,9 +533,10 @@ 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) {
+	if (new_scene) {
 		sceGxmBeginScene(
 			this->context,
 			0,
@@ -543,20 +565,22 @@ void GXMContext::clear(float r, float g, float b, bool new_scene) {
 
 	sceGxmSetFrontDepthFunc(gxm->context, SCE_GXM_DEPTH_FUNC_ALWAYS);
 	sceGxmDraw(gxm->context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, this->clearIndices, 4);
-	if(new_scene) {
+	if (new_scene) {
 		sceGxmEndScene(this->context, nullptr, nullptr);
 		this->sceneStarted = false;
 	}
 }
 
-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,
 		VITA_GXM_SCREEN_HEIGHT,
-		VITA_GXM_SCREEN_STRIDE*4
+		VITA_GXM_SCREEN_STRIDE * 4
 	);
 	sceGxmSetVertexProgram(this->context, this->planeVertexProgram);
 	sceGxmSetFragmentProgram(this->context, this->imageFragmentProgram);
@@ -573,20 +597,29 @@ 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]) {
+		if (this->displayBuffersUid[i]) {
 			vita_mem_free(this->displayBuffersUid[i]);
 			this->displayBuffers[i] = nullptr;
 			sceGxmSyncObjectDestroy(this->displayBuffersSync[i]);
 		}
 	}
 
-	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, 
+	if (this->sceneStarted) {
-			gxm->context,
+		sceGxmEndScene(gxm->context, nullptr, nullptr);
-			nullptr,
-			nullptr
-		);
 		this->sceneStarted = false;
 	}
+
 	SceCommonDialogUpdateParam updateParam;
 	SDL_zero(updateParam);
 	updateParam.renderTarget.colorFormat = VITA_GXM_COLOR_FORMAT;
@@ -637,39 +668,10 @@ 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();
-	if(ret < 0) {
+	if (ret < 0) {
 		return nullptr;
 	}
 	return new GXMRenderer(width, height);
@@ -683,36 +685,42 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height)
 	m_virtualHeight = height;
 
 	int ret;
-	if(!gxm) {
+	if (!gxm) {
-		gxm = (GXMContext*)SDL_malloc(sizeof(GXMContext));
+		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)
@@ -917,8 +935,8 @@ void GXMRenderer::AddTextureDestroyCallback(Uint32 id, IDirect3DRMTexture* textu
 		[](IDirect3DRMObject* obj, void* arg) {
 			auto* ctx = static_cast<TextureDestroyContextGXM*>(arg);
 			auto& cache = ctx->renderer->m_textures[ctx->textureId];
-			for(int i = 0; i < cache.bufferCount; i++) {
+			for (int i = 0; i < cache.bufferCount; i++) {
-				if(cache.notifications[i]) {
+				if (cache.notifications[i]) {
 					sceGxmNotificationWait(cache.notifications[i]);
 				}
 				void* textureData = sceGxmTextureGetData(&cache.gxmTexture[i]);
@@ -1050,22 +1068,22 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture, bool isUi, float
 		auto& tex = m_textures[i];
 		if (tex.texture == texture) {
 			if (tex.version != texture->m_version) {
-				if(tex.bufferCount != GXM_TEXTURE_BUFFER_COUNT) {
+				if (tex.bufferCount != GXM_TEXTURE_BUFFER_COUNT) {
-					for(int i = 1; i < GXM_TEXTURE_BUFFER_COUNT; i++) {
+					for (int i = 1; i < GXM_TEXTURE_BUFFER_COUNT; i++) {
 						tex.gxmTexture[i] = tex.gxmTexture[0];
-						uint8_t* textureData = (uint8_t*)gxm->alloc(textureSize, textureAlignment);
+						uint8_t* textureData = (uint8_t*) gxm->alloc(textureSize, textureAlignment);
 						sceGxmTextureSetData(&tex.gxmTexture[i], textureData);
 					}
 					tex.bufferCount = GXM_TEXTURE_BUFFER_COUNT;
 				}
-				if(tex.bufferCount > 1) {
+				if (tex.bufferCount > 1) {
 					tex.currentIndex = (tex.currentIndex + 1) % GXM_TEXTURE_BUFFER_COUNT;
 				}
-				if(tex.notifications[tex.currentIndex]) {
+				if (tex.notifications[tex.currentIndex]) {
 					sceGxmNotificationWait(tex.notifications[tex.currentIndex]);
 				}
 				tex.notifications[tex.currentIndex] = &this->fragmentNotifications[this->currentFragmentBufferIndex];
-				uint8_t* textureData = (uint8_t*)sceGxmTextureGetData(&tex.gxmTexture[tex.currentIndex]);
+				uint8_t* textureData = (uint8_t*) sceGxmTextureGetData(&tex.gxmTexture[tex.currentIndex]);
 				copySurfaceToGxm(surface, textureData, textureStride, textureSize);
 				tex.version = texture->m_version;
 			}
@@ -1089,12 +1107,13 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture, bool isUi, float
 
 	SceGxmTexture gxmTexture;
 	SCE_ERR(sceGxmTextureInitLinear, &gxmTexture, textureData, gxmTextureFormat, textureWidth, textureHeight, 0);
-	if(isUi) {
+	if (isUi) {
 		sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT);
 		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);
@@ -1199,35 +1218,35 @@ GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup)
 #ifdef GXM_PRECOMPUTE
 	bool isOpaque = meshGroup.color.a == 0xff;
 	const SceGxmTexture* texture = nullptr;
-	if(meshGroup.texture) {
+	if (meshGroup.texture) {
 		Uint32 textureId = GetTextureId(meshGroup.texture, false);
 		texture = &this->m_textures[textureId].gxmTexture;
 	}
 
 	const SceGxmProgram* fragmentProgramGxp;
-	const SceGxmFragmentProgram *fragmentProgram;
+	const SceGxmFragmentProgram* fragmentProgram;
-	if(texture) {
+	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;
-		fragmentStateSize * GXM_FRAGMENT_BUFFER_COUNT;
 
 	sceClibPrintf("drawSize: %d\n", drawSize);
 	sceClibPrintf("vertexStateSize: %d\n", vertexStateSize);
@@ -1238,19 +1257,15 @@ GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup)
 	sceClibPrintf("uniformBuffersSize: %d\n", uniformBuffersSize);
 
 	// allocate the precompute buffer, combined for all
-	uint8_t* precomputeData = (uint8_t*)cdram_alloc(precomputeDataSize, SCE_GXM_PRECOMPUTED_ALIGNMENT);
+	uint8_t* precomputeData = (uint8_t*) cdram_alloc(precomputeDataSize, SCE_GXM_PRECOMPUTED_ALIGNMENT);
 	cache.precomputeData = precomputeData;
 
-	uint8_t* uniformBuffers = (uint8_t*)cdram_alloc(uniformBuffersSize, 4);
+	uint8_t* uniformBuffers = (uint8_t*) cdram_alloc(uniformBuffersSize, 4);
 	cache.uniformBuffers = uniformBuffers;
 
 	// init precomputed draw
-	SCE_ERR(sceGxmPrecomputedDrawInit,
+	SCE_ERR(sceGxmPrecomputedDrawInit, &cache.drawState, this->mainVertexProgram, precomputeData);
-		&cache.drawState,
+	void* vertexStreams[] = {vertexBuffer};
-		this->mainVertexProgram,
-		precomputeData
-	);
-	void* vertexStreams[] = { vertexBuffer };
 	sceGxmPrecomputedDrawSetAllVertexStreams(&cache.drawState, vertexStreams);
 	sceGxmPrecomputedDrawSetParams(
 		&cache.drawState,
@@ -1262,41 +1277,29 @@ GXMMeshCacheEntry GXMRenderer::GXMUploadMesh(const MeshGroup& meshGroup)
 	precomputeData += drawSize;
 
 	// init precomputed vertex state
-	for(int bufferIndex = 0; bufferIndex < GXM_VERTEX_BUFFER_COUNT; bufferIndex++) {
+	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++) {
+	for (int bufferIndex = 0; bufferIndex < GXM_FRAGMENT_BUFFER_COUNT; bufferIndex++) {
-		SCE_ERR(sceGxmPrecomputedFragmentStateInit,
+		SCE_ERR(sceGxmPrecomputedFragmentStateInit, &cache.fragmentState[bufferIndex], fragmentProgram, precomputeData);
-			&cache.fragmentState[bufferIndex],
+		if (texture) {
-			fragmentProgram,
+			sceGxmPrecomputedFragmentStateSetTexture(&cache.fragmentState[bufferIndex], 0, texture);
-			precomputeData
-		);
-		if(texture) {
-			sceGxmPrecomputedFragmentStateSetTexture(
-				&cache.fragmentState[bufferIndex],
-				0, texture
-			);
 		}
-		sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer(
+		sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer(&cache.fragmentState[bufferIndex], uniformBuffers);
-			&cache.fragmentState[bufferIndex],
-			uniformBuffers
-		);
 		precomputeData += fragmentStateSize;
 		uniformBuffers += fragmentDefaultBufferSize;
 	}
-	assert(precomputeData - (uint8_t*)cache.precomputeData <= precomputeDataSize);
+	assert(precomputeData - (uint8_t*) cache.precomputeData <= precomputeDataSize);
 #endif
 	return cache;
 }
@@ -1432,14 +1435,14 @@ HRESULT GXMRenderer::BeginFrame()
 
 	auto lightData = this->LightsBuffer();
 	int i = 0;
-	for(const auto& light : m_lights) {
+	for (const auto& light : m_lights) {
-		if(!light.directional && !light.positional) {
+		if (!light.directional && !light.positional) {
 			lightData->ambientLight[0] = light.color.r;
 			lightData->ambientLight[1] = light.color.g;
 			lightData->ambientLight[2] = light.color.b;
 			continue;
 		}
-		if(i == 2) {
+		if (i == 2) {
 			sceClibPrintf("light overflow\n");
 			continue;
 		}
@@ -1450,11 +1453,12 @@ HRESULT GXMRenderer::BeginFrame()
 		lightData->lights[i].color[3] = light.color.a;
 
 		bool isDirectional = light.directional == 1.0;
-		if(isDirectional) {
+		if (isDirectional) {
 			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;
+	const SceGxmFragmentProgram* fragmentProgram;
-	if(this->transparencyEnabled) {
+	if (this->transparencyEnabled) {
 		fragmentProgram = textured ? this->blendedTextureFragmentProgram : this->blendedColorFragmentProgram;
-	} else {
+	}
+	else {
 		fragmentProgram = textured ? this->opaqueTextureFragmentProgram : this->opaqueColorFragmentProgram;
 	}
 	sceGxmSetVertexProgram(gxm->context, this->mainVertexProgram);
@@ -1537,9 +1541,9 @@ void GXMRenderer::SubmitDraw(
 	sceGxmReserveFragmentDefaultUniformBuffer(gxm->context, &fragUniforms);
 
 	// vertex uniforms
-	sceGxmSetUniformDataF(vertUniforms, this->uModelViewMatrix, 0, 4*4, &modelViewMatrix[0][0]);
+	sceGxmSetUniformDataF(vertUniforms, this->uModelViewMatrix, 0, 4 * 4, &modelViewMatrix[0][0]);
-	sceGxmSetUniformDataF(vertUniforms, this->uNormalMatrix, 0, 3*3, &normalMatrix[0][0]);
+	sceGxmSetUniformDataF(vertUniforms, this->uNormalMatrix, 0, 3 * 3, &normalMatrix[0][0]);
-	sceGxmSetUniformDataF(vertUniforms, this->uProjectionMatrix, 0, 4*4, &this->m_projection[0][0]);
+	sceGxmSetUniformDataF(vertUniforms, this->uProjectionMatrix, 0, 4 * 4, &this->m_projection[0][0]);
 
 	// fragment uniforms
 	float color[4] = {
@@ -1613,9 +1617,10 @@ void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const S
 #endif
 
 	sceGxmSetVertexProgram(gxm->context, gxm->planeVertexProgram);
-	if(textureId != NO_TEXTURE_ID) {
+	if (textureId != NO_TEXTURE_ID) {
 		sceGxmSetFragmentProgram(gxm->context, gxm->imageFragmentProgram);
-	} else {
+	}
+	else {
 		sceGxmSetFragmentProgram(gxm->context, gxm->colorFragmentProgram);
 	}
 
@@ -1647,7 +1652,7 @@ void GXMRenderer::Draw2DImage(Uint32 textureId, const SDL_Rect& srcRect, const S
 	float u2 = 0.0;
 	float v2 = 0.0;
 
-	if(textureId != NO_TEXTURE_ID) {
+	if (textureId != NO_TEXTURE_ID) {
 		GXMTextureCacheEntry& texture = m_textures[textureId];
 		const SceGxmTexture* gxmTexture = this->UseTexture(texture);
 		float texW = sceGxmTextureGetWidth(gxmTexture);
@@ -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);
 	}
 
@@ -1696,7 +1702,7 @@ void GXMRenderer::Download(SDL_Surface* target)
 		VITA_GXM_SCREEN_HEIGHT,
 		SDL_PIXELFORMAT_ABGR8888,
 		gxm->displayBuffers[gxm->frontBufferIndex],
-		VITA_GXM_SCREEN_STRIDE*4
+		VITA_GXM_SCREEN_STRIDE * 4
 	);
 	SDL_BlitSurfaceScaled(src, &srcRect, target, nullptr, SDL_SCALEMODE_NEAREST);
 	SDL_DestroySurface(src);

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

@@ -20,7 +20,7 @@
 		__sce_err_ret_val;                                                                                             \
 	})
 
-#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))
 

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);
 
@@ -20,7 +18,7 @@ DEFINE_GUID(GXM_GUID, 0x682656F3, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00,
 #define GXM_FRAGMENT_BUFFER_COUNT 3
 #define GXM_TEXTURE_BUFFER_COUNT 2
 
-//#define GXM_PRECOMPUTE
+// #define GXM_PRECOMPUTE
 
 struct GXMTextureCacheEntry {
 	IDirect3DRMTexture* texture;
@@ -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,26 +106,26 @@ 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];
+	{
+		Vertex2D* verts = &this->quadVertices[this->currentVertexBufferIndex][this->quadsUsed * 4];
 		this->quadsUsed += 1;
-		if(this->quadsUsed >= 50) {
+		if (this->quadsUsed >= 50) {
 			SDL_Log("QuadVerticesBuffer overflow");
 			this->quadsUsed = 0; // declare bankruptcy
 		}
 		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;
@@ -205,11 +193,10 @@ inline static void GXMRenderer_EnumDevice(LPD3DENUMDEVICESCALLBACK cb, void* ctx
 	helDesc.dwDeviceRenderBitDepth = DDBD_32;
 
 	int ret = gxm_library_init();
-	if(ret < 0) {
+	if (ret < 0) {
 		SDL_Log("gxm_library_init failed: %08x", ret);
 		return;
 	}
 
 	EnumDevice(cb, ctx, "GXM HAL", &halDesc, &helDesc, GXM_GUID);
 }
-