isledecomp/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2026-01-19 22:01:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

clang-format

Browse Source
This commit is contained in:
olebeck 2025-08-13 01:30:32 +02:00
parent 78893bbeac
commit 3958762721
9 changed files with 1000 additions and 957 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
CONFIG/vita/include/fios2.h
View File

@ -1,22 +1,20 @@
#include <stdint.h>
#include <stddef.h>
#include <psp2/kernel/threadmgr.h> #include <psp2/kernel/threadmgr.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
typedef struct SceFiosBuffer {
typedef struct SceFiosBuffer { void* pPtr;
void *pPtr;
size_t length; size_t length;
} SceFiosBuffer; } SceFiosBuffer;
#define SCE_FIOS_THREAD_TYPES 3 #define SCE_FIOS_THREAD_TYPES 3
typedef struct SceFiosParams typedef struct SceFiosParams {
{
uint32_t initialized : 1; uint32_t initialized : 1;
uint32_t paramsSize : 15; uint32_t paramsSize : 15;
uint32_t pathMax : 16; uint32_t pathMax : 16;
@ -42,34 +40,39 @@ typedef struct SceFiosParams
int threadPriority[SCE_FIOS_THREAD_TYPES]; int threadPriority[SCE_FIOS_THREAD_TYPES];
int threadAffinity[SCE_FIOS_THREAD_TYPES]; int threadAffinity[SCE_FIOS_THREAD_TYPES];
int threadStackSize[SCE_FIOS_THREAD_TYPES]; int threadStackSize[SCE_FIOS_THREAD_TYPES];
} SceFiosParams; } SceFiosParams;
#define SCE_KERNEL_HIGHEST_PRIORITY_USER (64) #define SCE_KERNEL_HIGHEST_PRIORITY_USER (64)
#define SCE_KERNEL_LOWEST_PRIORITY_USER (191) #define SCE_KERNEL_LOWEST_PRIORITY_USER (191)
#define SCE_FIOS_IO_THREAD_DEFAULT_PRIORITY (SCE_KERNEL_HIGHEST_PRIORITY_USER+2) #define SCE_FIOS_IO_THREAD_DEFAULT_PRIORITY (SCE_KERNEL_HIGHEST_PRIORITY_USER + 2)
#define SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_PRIORITY (SCE_KERNEL_LOWEST_PRIORITY_USER-2) #define SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_PRIORITY (SCE_KERNEL_LOWEST_PRIORITY_USER - 2)
#define SCE_FIOS_CALLBACK_THREAD_DEFAULT_PRIORITY (SCE_KERNEL_HIGHEST_PRIORITY_USER+2) #define SCE_FIOS_CALLBACK_THREAD_DEFAULT_PRIORITY (SCE_KERNEL_HIGHEST_PRIORITY_USER + 2)
#define SCE_FIOS_THREAD_DEFAULT_AFFINITY SCE_KERNEL_CPU_MASK_USER_2 #define SCE_FIOS_THREAD_DEFAULT_AFFINITY SCE_KERNEL_CPU_MASK_USER_2
#define SCE_FIOS_IO_THREAD_DEFAULT_AFFINITY SCE_FIOS_THREAD_DEFAULT_AFFINITY #define SCE_FIOS_IO_THREAD_DEFAULT_AFFINITY SCE_FIOS_THREAD_DEFAULT_AFFINITY
#define SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_AFFINITY SCE_KERNEL_THREAD_CPU_AFFINITY_MASK_DEFAULT #define SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_AFFINITY SCE_KERNEL_THREAD_CPU_AFFINITY_MASK_DEFAULT
#define SCE_FIOS_CALLBACK_THREAD_DEFAULT_AFFINITY SCE_FIOS_THREAD_DEFAULT_AFFINITY #define SCE_FIOS_CALLBACK_THREAD_DEFAULT_AFFINITY SCE_FIOS_THREAD_DEFAULT_AFFINITY
#define SCE_FIOS_IO_THREAD_DEFAULT_STACKSIZE (8*1024) #define SCE_FIOS_IO_THREAD_DEFAULT_STACKSIZE (8 * 1024)
#define SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_STACKSIZE (16*1024) #define SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_STACKSIZE (16 * 1024)
#define SCE_FIOS_CALLBACK_THREAD_DEFAULT_STACKSIZE (8*1024) #define SCE_FIOS_CALLBACK_THREAD_DEFAULT_STACKSIZE (8 * 1024)
#define SCE_FIOS_PARAMS_INITIALIZER { 0, sizeof(SceFiosParams), 0, 0, \ #define SCE_FIOS_PARAMS_INITIALIZER \
2, 2, \ { \
0, 0, \ 0, sizeof(SceFiosParams), 0, 0, 2, 2, 0, 0, (256 * 1024), 2, 0, 0, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, {0, 0}, \
(256*1024), \
2, 0, 0, 0, 0, 0, \
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, \
NULL, NULL, NULL, \ NULL, NULL, NULL, \
{ SCE_FIOS_IO_THREAD_DEFAULT_PRIORITY, SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_PRIORITY, SCE_FIOS_CALLBACK_THREAD_DEFAULT_PRIORITY }, \ {SCE_FIOS_IO_THREAD_DEFAULT_PRIORITY, \
{ SCE_FIOS_IO_THREAD_DEFAULT_AFFINITY, SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_AFFINITY, SCE_FIOS_CALLBACK_THREAD_DEFAULT_AFFINITY}, \ SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_PRIORITY, \
{ SCE_FIOS_IO_THREAD_DEFAULT_STACKSIZE, SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_STACKSIZE, SCE_FIOS_CALLBACK_THREAD_DEFAULT_STACKSIZE}} SCE_FIOS_CALLBACK_THREAD_DEFAULT_PRIORITY}, \
{SCE_FIOS_IO_THREAD_DEFAULT_AFFINITY, \
SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_AFFINITY, \
SCE_FIOS_CALLBACK_THREAD_DEFAULT_AFFINITY}, \
{ \
SCE_FIOS_IO_THREAD_DEFAULT_STACKSIZE, SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_STACKSIZE, \
SCE_FIOS_CALLBACK_THREAD_DEFAULT_STACKSIZE \
} \
}
#define SCE_FIOS_IO_THREAD 0 #define SCE_FIOS_IO_THREAD 0
#define SCE_FIOS_DECOMPRESSOR_THREAD 1 #define SCE_FIOS_DECOMPRESSOR_THREAD 1
@ -80,56 +83,51 @@ typedef struct SceFiosParams
#define SCE_FIOS_OP_SIZE 168 #define SCE_FIOS_OP_SIZE 168
#define SCE_FIOS_CHUNK_SIZE 64 #define SCE_FIOS_CHUNK_SIZE 64
#define SCE_FIOS_ALIGN_UP(val,align) (((val) + ((align)-1)) & ~((align)-1)) #define SCE_FIOS_ALIGN_UP(val, align) (((val) + ((align) -1)) & ~((align) -1))
#define SCE_FIOS_STORAGE_SIZE(num, size) \ #define SCE_FIOS_STORAGE_SIZE(num, size) (((num) * (size)) + SCE_FIOS_ALIGN_UP(SCE_FIOS_ALIGN_UP((num), 8) / 8, 8))
(((num) * (size)) + SCE_FIOS_ALIGN_UP(SCE_FIOS_ALIGN_UP((num), 8) / 8, 8))
#define SCE_FIOS_DH_STORAGE_SIZE(numDHs, pathMax) \ #define SCE_FIOS_DH_STORAGE_SIZE(numDHs, pathMax) SCE_FIOS_STORAGE_SIZE(numDHs, SCE_FIOS_DH_SIZE + pathMax)
SCE_FIOS_STORAGE_SIZE(numDHs, SCE_FIOS_DH_SIZE + pathMax)
#define SCE_FIOS_FH_STORAGE_SIZE(numFHs,pathMax) \ #define SCE_FIOS_FH_STORAGE_SIZE(numFHs, pathMax) SCE_FIOS_STORAGE_SIZE(numFHs, SCE_FIOS_FH_SIZE + pathMax)
SCE_FIOS_STORAGE_SIZE(numFHs, SCE_FIOS_FH_SIZE + pathMax)
#define SCE_FIOS_OP_STORAGE_SIZE(numOps,pathMax) \ #define SCE_FIOS_OP_STORAGE_SIZE(numOps, pathMax) SCE_FIOS_STORAGE_SIZE(numOps, SCE_FIOS_OP_SIZE + pathMax)
SCE_FIOS_STORAGE_SIZE(numOps, SCE_FIOS_OP_SIZE + pathMax)
#define SCE_FIOS_CHUNK_STORAGE_SIZE(numChunks) \ #define SCE_FIOS_CHUNK_STORAGE_SIZE(numChunks) SCE_FIOS_STORAGE_SIZE(numChunks, SCE_FIOS_CHUNK_SIZE)
SCE_FIOS_STORAGE_SIZE(numChunks, SCE_FIOS_CHUNK_SIZE)
int sceFiosInitialize(SceFiosParams* params); int sceFiosInitialize(SceFiosParams* params);
typedef int64_t SceFiosTime;
typedef int64_t SceFiosTime; typedef int32_t SceFiosHandle;
typedef int32_t SceFiosHandle; typedef SceFiosHandle SceFiosFH;
typedef SceFiosHandle SceFiosFH; typedef struct SceFiosOpenParams {
uint32_t openFlags : 16;
typedef struct SceFiosOpenParams uint32_t opFlags : 16;
{
uint32_t openFlags:16;
uint32_t opFlags:16;
uint32_t reserved; uint32_t reserved;
SceFiosBuffer buffer; SceFiosBuffer buffer;
} SceFiosOpenParams; } SceFiosOpenParams;
typedef struct SceFiosOpAttr typedef struct SceFiosOpAttr {
{
SceFiosTime deadline; SceFiosTime deadline;
void* pCallback; void* pCallback;
void * pCallbackContext; void* pCallbackContext;
int32_t priority : 8; int32_t priority : 8;
uint32_t opflags : 24; uint32_t opflags : 24;
uint32_t userTag; uint32_t userTag;
void * userPtr; void* userPtr;
void * pReserved; void* pReserved;
} SceFiosOpAttr; } SceFiosOpAttr;
int sceFiosFHOpenWithModeSync(const SceFiosOpAttr *pAttr, SceFiosFH *pOutFH, const char *pPath, const SceFiosOpenParams *pOpenParams, int32_t nativeMode);
int sceFiosFHOpenWithModeSync(
const SceFiosOpAttr* pAttr,
SceFiosFH* pOutFH,
const char* pPath,
const SceFiosOpenParams* pOpenParams,
int32_t nativeMode
);
#ifdef __cplusplus #ifdef __cplusplus
} }

87
CONFIG/vita/iniparser_paf/src/dictionary.h
View File

@ -21,16 +21,16 @@
#include "pafstd.h" #include "pafstd.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
New types New types
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /**
/**
@brief Dictionary object @brief Dictionary object
This object contains a list of string/string associations. Each This object contains a list of string/string associations. Each
@ -38,22 +38,21 @@ extern "C" {
in the dictionary is speeded up by the use of a (hopefully collision-free) in the dictionary is speeded up by the use of a (hopefully collision-free)
hash function. hash function.
*/ */
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
typedef struct _dictionary_ { typedef struct _dictionary_ {
unsigned n ; /** Number of entries in dictionary */ unsigned n; /** Number of entries in dictionary */
size_t size ; /** Storage size */ size_t size; /** Storage size */
char ** val ; /** List of string values */ char** val; /** List of string values */
char ** key ; /** List of string keys */ char** key; /** List of string keys */
unsigned * hash ; /** List of hash values for keys */ unsigned* hash; /** List of hash values for keys */
} dictionary ; } dictionary;
/*---------------------------------------------------------------------------
/*---------------------------------------------------------------------------
Function prototypes Function prototypes
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Compute the hash key for a string. @brief Compute the hash key for a string.
@param key Character string to use for key. @param key Character string to use for key.
@return 1 unsigned int on at least 32 bits. @return 1 unsigned int on at least 32 bits.
@ -63,11 +62,11 @@ typedef struct _dictionary_ {
The key is stored anyway in the struct so that collision can be avoided The key is stored anyway in the struct so that collision can be avoided
by comparing the key itself in last resort. by comparing the key itself in last resort.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
unsigned dictionary_hash(const char * key); unsigned dictionary_hash(const char* key);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Create a new dictionary object. @brief Create a new dictionary object.
@param size Optional initial size of the dictionary. @param size Optional initial size of the dictionary.
@return 1 newly allocated dictionary object. @return 1 newly allocated dictionary object.
@ -76,22 +75,22 @@ unsigned dictionary_hash(const char * key);
it. If you do not know in advance (roughly) the number of entries in the it. If you do not know in advance (roughly) the number of entries in the
dictionary, give size=0. dictionary, give size=0.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
dictionary * dictionary_new(size_t size); dictionary* dictionary_new(size_t size);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Delete a dictionary object @brief Delete a dictionary object
@param d dictionary object to deallocate. @param d dictionary object to deallocate.
@return void @return void
Deallocate a dictionary object and all memory associated to it. Deallocate a dictionary object and all memory associated to it.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void dictionary_del(dictionary * vd); void dictionary_del(dictionary* vd);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get a value from a dictionary. @brief Get a value from a dictionary.
@param d dictionary object to search. @param d dictionary object to search.
@param key Key to look for in the dictionary. @param key Key to look for in the dictionary.
@ -103,12 +102,11 @@ void dictionary_del(dictionary * vd);
dictionary. The returned character pointer points to data internal to the dictionary. The returned character pointer points to data internal to the
dictionary object, you should not try to free it or modify it. dictionary object, you should not try to free it or modify it.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
const char * dictionary_get(const dictionary * d, const char * key, const char * def); const char* dictionary_get(const dictionary* d, const char* key, const char* def);
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /**
/**
@brief Set a value in a dictionary. @brief Set a value in a dictionary.
@param d dictionary object to modify. @param d dictionary object to modify.
@param key Key to modify or add. @param key Key to modify or add.
@ -132,11 +130,11 @@ const char * dictionary_get(const dictionary * d, const char * key, const char *
This function returns non-zero in case of failure. This function returns non-zero in case of failure.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int dictionary_set(dictionary * vd, const char * key, const char * val); int dictionary_set(dictionary* vd, const char* key, const char* val);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Delete a key in a dictionary @brief Delete a key in a dictionary
@param d dictionary object to modify. @param d dictionary object to modify.
@param key Key to remove. @param key Key to remove.
@ -145,12 +143,11 @@ int dictionary_set(dictionary * vd, const char * key, const char * val);
This function deletes a key in a dictionary. Nothing is done if the This function deletes a key in a dictionary. Nothing is done if the
key cannot be found. key cannot be found.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void dictionary_unset(dictionary * d, const char * key); void dictionary_unset(dictionary* d, const char* key);
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /**
/**
@brief Dump a dictionary to an opened file pointer. @brief Dump a dictionary to an opened file pointer.
@param d Dictionary to dump @param d Dictionary to dump
@param f Opened file pointer. @param f Opened file pointer.
@ -160,8 +157,8 @@ void dictionary_unset(dictionary * d, const char * key);
as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as
output file pointers. output file pointers.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void dictionary_dump(const dictionary * d, FILE * out); void dictionary_dump(const dictionary* d, FILE* out);
#ifdef __cplusplus #ifdef __cplusplus
} }

177
CONFIG/vita/iniparser_paf/src/iniparser.h
View File

@ -15,26 +15,28 @@
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
#include "dictionary.h" #include "dictionary.h"
#include <stdint.h> #include <stdint.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Configure a function to receive the error messages. @brief Configure a function to receive the error messages.
@param errback Function to call. @param errback Function to call.
By default, the error will be printed on stderr. If a null pointer is passed By default, the error will be printed on stderr. If a null pointer is passed
as errback the error callback will be switched back to default. as errback the error callback will be switched back to default.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void iniparser_set_error_callback(int (*errback)(const char *, ...)); void iniparser_set_error_callback(int (*errback)(const char*, ...));
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get number of sections in a dictionary @brief Get number of sections in a dictionary
@param d Dictionary to examine @param d Dictionary to examine
@return int Number of sections found in dictionary @return int Number of sections found in dictionary
@ -50,13 +52,12 @@ void iniparser_set_error_callback(int (*errback)(const char *, ...));
This function returns -1 in case of error. This function returns -1 in case of error.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int iniparser_getnsec(const dictionary * d); int iniparser_getnsec(const dictionary* d);
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /**
/**
@brief Get name for section n in a dictionary. @brief Get name for section n in a dictionary.
@param d Dictionary to examine @param d Dictionary to examine
@param n Section number (from 0 to nsec-1). @param n Section number (from 0 to nsec-1).
@ -68,13 +69,12 @@ int iniparser_getnsec(const dictionary * d);
This function returns NULL in case of error. This function returns NULL in case of error.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
const char * iniparser_getsecname(const dictionary * d, int n); const char* iniparser_getsecname(const dictionary* d, int n);
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /**
/**
@brief Save a dictionary to a loadable ini file @brief Save a dictionary to a loadable ini file
@param d Dictionary to dump @param d Dictionary to dump
@param f Opened file pointer to dump to @param f Opened file pointer to dump to
@ -88,12 +88,12 @@ const char * iniparser_getsecname(const dictionary * d, int n);
- \ : the backslash character (e.g. "C:\\tmp") - \ : the backslash character (e.g. "C:\\tmp")
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void iniparser_dump_ini(const dictionary * d, FILE * f); void iniparser_dump_ini(const dictionary* d, FILE* f);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Save a dictionary section to a loadable ini file @brief Save a dictionary section to a loadable ini file
@param d Dictionary to dump @param d Dictionary to dump
@param s Section name of dictionary to dump @param s Section name of dictionary to dump
@ -102,12 +102,12 @@ void iniparser_dump_ini(const dictionary * d, FILE * f);
This function dumps a given section of a given dictionary into a loadable ini This function dumps a given section of a given dictionary into a loadable ini
file. It is Ok to specify @c stderr or @c stdout as output files. file. It is Ok to specify @c stderr or @c stdout as output files.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void iniparser_dumpsection_ini(const dictionary * d, const char * s, FILE * f); void iniparser_dumpsection_ini(const dictionary* d, const char* s, FILE* f);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Dump a dictionary to an opened file pointer. @brief Dump a dictionary to an opened file pointer.
@param d Dictionary to dump. @param d Dictionary to dump.
@param f Opened file pointer to dump to. @param f Opened file pointer to dump to.
@ -117,21 +117,21 @@ void iniparser_dumpsection_ini(const dictionary * d, const char * s, FILE * f);
or @c stdout as output files. This function is meant for debugging or @c stdout as output files. This function is meant for debugging
purposes mostly. purposes mostly.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void iniparser_dump(const dictionary * d, FILE * f); void iniparser_dump(const dictionary* d, FILE* f);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get the number of keys in a section of a dictionary. @brief Get the number of keys in a section of a dictionary.
@param d Dictionary to examine @param d Dictionary to examine
@param s Section name of dictionary to examine @param s Section name of dictionary to examine
@return Number of keys in section @return Number of keys in section
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int iniparser_getsecnkeys(const dictionary * d, const char * s); int iniparser_getsecnkeys(const dictionary* d, const char* s);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get the number of keys in a section of a dictionary. @brief Get the number of keys in a section of a dictionary.
@param d Dictionary to examine @param d Dictionary to examine
@param s Section name of dictionary to examine @param s Section name of dictionary to examine
@ -145,12 +145,11 @@ int iniparser_getsecnkeys(const dictionary * d, const char * s);
Each pointer in the returned char pointer-to-pointer is pointing to Each pointer in the returned char pointer-to-pointer is pointing to
a string allocated in the dictionary; do not free or modify them. a string allocated in the dictionary; do not free or modify them.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
const char ** iniparser_getseckeys(const dictionary * d, const char * s, const char ** keys); const char** iniparser_getseckeys(const dictionary* d, const char* s, const char** keys);
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /**
/**
@brief Get the string associated to a key @brief Get the string associated to a key
@param d Dictionary to search @param d Dictionary to search
@param key Key string to look for @param key Key string to look for
@ -163,11 +162,11 @@ const char ** iniparser_getseckeys(const dictionary * d, const char * s, const c
The returned char pointer is pointing to a string allocated in The returned char pointer is pointing to a string allocated in
the dictionary, do not free or modify it. the dictionary, do not free or modify it.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
const char * iniparser_getstring(const dictionary * d, const char * key, const char * def); const char* iniparser_getstring(const dictionary* d, const char* key, const char* def);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get the string associated to a key, convert to an int @brief Get the string associated to a key, convert to an int
@param d Dictionary to search @param d Dictionary to search
@param key Key string to look for @param key Key string to look for
@ -192,11 +191,11 @@ const char * iniparser_getstring(const dictionary * d, const char * key, const c
Credits: Thanks to A. Becker for suggesting strtol() Credits: Thanks to A. Becker for suggesting strtol()
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int iniparser_getint(const dictionary * d, const char * key, int notfound); int iniparser_getint(const dictionary* d, const char* key, int notfound);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get the string associated to a key, convert to an long int @brief Get the string associated to a key, convert to an long int
@param d Dictionary to search @param d Dictionary to search
@param key Key string to look for @param key Key string to look for
@ -219,11 +218,11 @@ int iniparser_getint(const dictionary * d, const char * key, int notfound);
totally outsourced to strtol(), see the associated man page for overflow totally outsourced to strtol(), see the associated man page for overflow
handling. handling.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
long int iniparser_getlongint(const dictionary * d, const char * key, long int notfound); long int iniparser_getlongint(const dictionary* d, const char* key, long int notfound);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get the string associated to a key, convert to an int64_t @brief Get the string associated to a key, convert to an int64_t
@param d Dictionary to search @param d Dictionary to search
@param key Key string to look for @param key Key string to look for
@ -249,11 +248,11 @@ long int iniparser_getlongint(const dictionary * d, const char * key, long int n
This function is usefull on 32bit architectures where `long int` is only This function is usefull on 32bit architectures where `long int` is only
32bit. 32bit.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int64_t iniparser_getint64(const dictionary * d, const char * key, int64_t notfound); int64_t iniparser_getint64(const dictionary* d, const char* key, int64_t notfound);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get the string associated to a key, convert to an uint64_t @brief Get the string associated to a key, convert to an uint64_t
@param d Dictionary to search @param d Dictionary to search
@param key Key string to look for @param key Key string to look for
@ -279,11 +278,11 @@ int64_t iniparser_getint64(const dictionary * d, const char * key, int64_t notfo
This function is usefull on 32bit architectures where `long int` is only This function is usefull on 32bit architectures where `long int` is only
32bit. 32bit.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
uint64_t iniparser_getuint64(const dictionary * d, const char * key, uint64_t notfound); uint64_t iniparser_getuint64(const dictionary* d, const char* key, uint64_t notfound);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get the string associated to a key, convert to a double @brief Get the string associated to a key, convert to a double
@param d Dictionary to search @param d Dictionary to search
@param key Key string to look for @param key Key string to look for
@ -294,11 +293,11 @@ uint64_t iniparser_getuint64(const dictionary * d, const char * key, uint64_t no
ini file is given as "section:key". If the key cannot be found, ini file is given as "section:key". If the key cannot be found,
the notfound value is returned. the notfound value is returned.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
double iniparser_getdouble(const dictionary * d, const char * key, double notfound); double iniparser_getdouble(const dictionary* d, const char* key, double notfound);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Get the string associated to a key, convert to a boolean @brief Get the string associated to a key, convert to a boolean
@param d Dictionary to search @param d Dictionary to search
@param key Key string to look for @param key Key string to look for
@ -328,12 +327,11 @@ double iniparser_getdouble(const dictionary * d, const char * key, double notfou
The notfound value returned if no boolean is identified, does not The notfound value returned if no boolean is identified, does not
necessarily have to be 0 or 1. necessarily have to be 0 or 1.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int iniparser_getboolean(const dictionary * d, const char * key, int notfound); int iniparser_getboolean(const dictionary* d, const char* key, int notfound);
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /**
/**
@brief Set an entry in a dictionary. @brief Set an entry in a dictionary.
@param ini Dictionary to modify. @param ini Dictionary to modify.
@param entry Entry to modify (entry name) @param entry Entry to modify (entry name)
@ -344,23 +342,22 @@ int iniparser_getboolean(const dictionary * d, const char * key, int notfound);
contain the provided value. If it cannot be found, the entry is created. contain the provided value. If it cannot be found, the entry is created.
It is Ok to set val to NULL. It is Ok to set val to NULL.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int iniparser_set(dictionary * ini, const char * entry, const char * val); int iniparser_set(dictionary* ini, const char* entry, const char* val);
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/ /**
/**
@brief Delete an entry in a dictionary @brief Delete an entry in a dictionary
@param ini Dictionary to modify @param ini Dictionary to modify
@param entry Entry to delete (entry name) @param entry Entry to delete (entry name)
If the given entry can be found, it is deleted from the dictionary. If the given entry can be found, it is deleted from the dictionary.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void iniparser_unset(dictionary * ini, const char * entry); void iniparser_unset(dictionary* ini, const char* entry);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Finds out if a given entry exists in a dictionary @brief Finds out if a given entry exists in a dictionary
@param ini Dictionary to search @param ini Dictionary to search
@param entry Name of the entry to look for @param entry Name of the entry to look for
@ -370,11 +367,11 @@ void iniparser_unset(dictionary * ini, const char * entry);
are stored as keys with NULL associated values, this is the only way are stored as keys with NULL associated values, this is the only way
of querying for the presence of sections in a dictionary. of querying for the presence of sections in a dictionary.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int iniparser_find_entry(const dictionary * ini, const char * entry) ; int iniparser_find_entry(const dictionary* ini, const char* entry);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Parse an ini file and return an allocated dictionary object @brief Parse an ini file and return an allocated dictionary object
@param ininame Name of the ini file to read. @param ininame Name of the ini file to read.
@return Pointer to newly allocated dictionary @return Pointer to newly allocated dictionary
@ -397,11 +394,11 @@ int iniparser_find_entry(const dictionary * ini, const char * entry) ;
The returned dictionary must be freed using iniparser_freedict(). The returned dictionary must be freed using iniparser_freedict().
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
dictionary * iniparser_load(const char * ininame); dictionary* iniparser_load(const char* ininame);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Parse an ini file and return an allocated dictionary object @brief Parse an ini file and return an allocated dictionary object
@param in File to read. @param in File to read.
@param ininame Name of the ini file to read (only used for nicer error messages) @param ininame Name of the ini file to read (only used for nicer error messages)
@ -424,11 +421,11 @@ dictionary * iniparser_load(const char * ininame);
The returned dictionary must be freed using iniparser_freedict(). The returned dictionary must be freed using iniparser_freedict().
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
dictionary * iniparser_load_file(FILE * in, const char * ininame); dictionary* iniparser_load_file(FILE* in, const char* ininame);
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
/** /**
@brief Free all memory associated to an ini dictionary @brief Free all memory associated to an ini dictionary
@param d Dictionary to free @param d Dictionary to free
@ -436,8 +433,8 @@ dictionary * iniparser_load_file(FILE * in, const char * ininame);
It is mandatory to call this function before the dictionary object It is mandatory to call this function before the dictionary object
gets out of the current context. gets out of the current context.
*/ */
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
void iniparser_freedict(dictionary * d); void iniparser_freedict(dictionary* d);
#ifdef __cplusplus #ifdef __cplusplus
} }

16
CONFIG/vita/iniparser_paf/src/pafstd.h
View File

@ -1,13 +1,13 @@
#ifndef __PAFSTD__ #ifndef __PAFSTD__
#define __PAFSTD__ #define __PAFSTD__
#include <inttypes.h>
#include <paf/std/stdlib.h> #include <paf/std/stdlib.h>
#include <paf/std/string.h> #include <paf/std/string.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <inttypes.h> #include <string.h>
#define malloc sce_paf_malloc #define malloc sce_paf_malloc
#define memcpy sce_paf_memcpy #define memcpy sce_paf_memcpy
@ -18,19 +18,21 @@
// _ctype_ isnt called that in scelibc, so just stub the functions that are needed // _ctype_ isnt called that in scelibc, so just stub the functions that are needed
inline int _is_space(char c) { inline int _is_space(char c)
return (c == ' ' || c == '\f' || c == '\n' || {
c == '\r' || c == '\t' || c == '\v'); return (c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v');
} }
inline int _to_lower(int c) { inline int _to_lower(int c)
{
if (c >= 'A' && c <= 'Z') { if (c >= 'A' && c <= 'Z') {
return c + ('a' - 'A'); return c + ('a' - 'A');
} }
return c; return c;
} }
inline int _is_digit(int c) { inline int _is_digit(int c)
{
return (c >= '0' && c <= '9'); return (c >= '0' && c <= '9');
} }

126
CONFIG/vita/src/app.cpp
View File

@ -1,13 +1,13 @@
#include "pafinc.h"
#include <app_settings.h>
#include <psp2/kernel/clib.h>
#include <psp2/io/fcntl.h>
#include <psp2/sysmodule.h>
#include <psp2/kernel/modulemgr.h>
#include <psp2/appmgr.h>
#include "fios2.h" #include "fios2.h"
#include "pafinc.h"
#include <app_settings.h>
#include <iniparser.h> #include <iniparser.h>
#include <psp2/appmgr.h>
#include <psp2/io/fcntl.h>
#include <psp2/kernel/clib.h>
#include <psp2/kernel/modulemgr.h>
#include <psp2/sysmodule.h>
const char* g_iniPath = "ux0:data/isledecomp/isle/isle.ini"; const char* g_iniPath = "ux0:data/isledecomp/isle/isle.ini";
@ -16,7 +16,6 @@ paf::Plugin* g_configPlugin;
sce::AppSettings* g_appSettings; sce::AppSettings* g_appSettings;
sce::AppSettings::Interface* g_appSetIf; sce::AppSettings::Interface* g_appSetIf;
struct Config { struct Config {
paf::string m_base_path; paf::string m_base_path;
paf::string m_cd_path; paf::string m_cd_path;
@ -36,7 +35,8 @@ struct Config {
int m_max_actors; int m_max_actors;
float m_frame_delta; float m_frame_delta;
void Init() { void Init()
{
m_frame_delta = 10.0f; m_frame_delta = 10.0f;
m_transition_type = 3; // 3: Mosaic m_transition_type = 3; // 3: Mosaic
m_wide_view_angle = true; m_wide_view_angle = true;
@ -52,7 +52,8 @@ struct Config {
m_max_actors = 20; m_max_actors = 20;
} }
void LoadIni() { void LoadIni()
{
dictionary* dict = iniparser_load(g_iniPath); dictionary* dict = iniparser_load(g_iniPath);
if (!dict) { if (!dict) {
dict = dictionary_new(0); dict = dictionary_new(0);
@ -60,36 +61,38 @@ struct Config {
#define GET_INT(x, name) x = iniparser_getint(dict, name, x) #define GET_INT(x, name) x = iniparser_getint(dict, name, x)
#define GET_FLOAT(x, name) x = iniparser_getdouble(dict, name, x) #define GET_FLOAT(x, name) x = iniparser_getdouble(dict, name, x)
#define GET_STRING(x, name) x = iniparser_getstring(dict, name, x.c_str()); sceClibPrintf("%s: %s\n", name, x.c_str()) #define GET_STRING(x, name) \
x = iniparser_getstring(dict, name, x.c_str()); \
sceClibPrintf("%s: %s\n", name, x.c_str())
#define GET_BOOLEAN(x, name) x = iniparser_getboolean(dict, name, x) #define GET_BOOLEAN(x, name) x = iniparser_getboolean(dict, name, x)
GET_STRING(m_base_path, "isle:diskpath"); GET_STRING(m_base_path, "isle:diskpath");
GET_STRING(m_cd_path, "isle:cdpath"); GET_STRING(m_cd_path, "isle:cdpath");
GET_STRING(m_save_path, "isle:savepath"); GET_STRING(m_save_path, "isle:savepath");
//m_display_bit_depth = iniparser_getint(dict, "isle:Display Bit Depth", -1); // m_display_bit_depth = iniparser_getint(dict, "isle:Display Bit Depth", -1);
//GET_BOOLEAN(m_flip_surfaces, "isle:Flip Surfaces"); // GET_BOOLEAN(m_flip_surfaces, "isle:Flip Surfaces");
//GET_BOOLEAN(m_full_screen, "isle:Full Screen"); // GET_BOOLEAN(m_full_screen, "isle:Full Screen");
//GET_BOOLEAN(m_exclusive_full_screen, "isle:Exclusive Full Screen"); // GET_BOOLEAN(m_exclusive_full_screen, "isle:Exclusive Full Screen");
GET_INT(m_transition_type, "isle:Transition Type"); GET_INT(m_transition_type, "isle:Transition Type");
GET_INT(m_touch_scheme, "isle:Touch Scheme"); GET_INT(m_touch_scheme, "isle:Touch Scheme");
//GET_BOOLEAN(m_3d_video_ram, "isle:Back Buffers in Video RAM"); // GET_BOOLEAN(m_3d_video_ram, "isle:Back Buffers in Video RAM");
GET_BOOLEAN(m_wide_view_angle, "isle:Wide View Angle"); GET_BOOLEAN(m_wide_view_angle, "isle:Wide View Angle");
GET_BOOLEAN(m_3d_sound, "isle:3DSound"); GET_BOOLEAN(m_3d_sound, "isle:3DSound");
GET_BOOLEAN(m_draw_cursor, "isle:Draw Cursor"); GET_BOOLEAN(m_draw_cursor, "isle:Draw Cursor");
GET_INT(m_model_quality, "isle:Island Quality"); GET_INT(m_model_quality, "isle:Island Quality");
GET_INT(m_texture_quality, "isle:Island Texture"); GET_INT(m_texture_quality, "isle:Island Texture");
//GET_BOOLEAN(m_use_joystick, "isle:UseJoystick"); // GET_BOOLEAN(m_use_joystick, "isle:UseJoystick");
GET_BOOLEAN(m_haptic, "isle:Haptic"); GET_BOOLEAN(m_haptic, "isle:Haptic");
GET_BOOLEAN(m_music, "isle:Music"); GET_BOOLEAN(m_music, "isle:Music");
//GET_INT(m_joystick_index, "isle:JoystickIndex"); // GET_INT(m_joystick_index, "isle:JoystickIndex");
GET_FLOAT(m_max_lod, "isle:Max LOD"); GET_FLOAT(m_max_lod, "isle:Max LOD");
GET_INT(m_max_actors, "isle:Max Allowed Extras"); GET_INT(m_max_actors, "isle:Max Allowed Extras");
GET_BOOLEAN(m_texture_load, "extensions:texture loader"); GET_BOOLEAN(m_texture_load, "extensions:texture loader");
GET_STRING(m_texture_path, "texture loader:texture path"); GET_STRING(m_texture_path, "texture loader:texture path");
//GET_INT(m_aspect_ratio, "isle:Aspect Ratio"); // GET_INT(m_aspect_ratio, "isle:Aspect Ratio");
//GET_INT(m_x_res, "isle:Horizontal Resolution"); // GET_INT(m_x_res, "isle:Horizontal Resolution");
//GET_INT(m_y_res, "isle:Vertical Resolution"); // GET_INT(m_y_res, "isle:Vertical Resolution");
GET_FLOAT(m_frame_delta, "isle:Frame Delta"); GET_FLOAT(m_frame_delta, "isle:Frame Delta");
#undef GET_INT #undef GET_INT
#undef GET_FLOAT #undef GET_FLOAT
@ -98,16 +101,19 @@ struct Config {
iniparser_freedict(dict); iniparser_freedict(dict);
} }
bool SaveIni() { bool SaveIni()
{
dictionary* dict = dictionary_new(0); dictionary* dict = dictionary_new(0);
char buffer[128]; char buffer[128];
#define SetIniBool(NAME, VALUE) iniparser_set(dict, NAME, VALUE ? "true" : "false") #define SetIniBool(NAME, VALUE) iniparser_set(dict, NAME, VALUE ? "true" : "false")
#define SetIniInt(NAME, VALUE) { \ #define SetIniInt(NAME, VALUE) \
{ \
sceClibPrintf(buffer, "%d", VALUE); \ sceClibPrintf(buffer, "%d", VALUE); \
iniparser_set(dict, NAME, buffer); \ iniparser_set(dict, NAME, buffer); \
} }
#define SetIniFloat(NAME, VALUE) { \ #define SetIniFloat(NAME, VALUE) \
{ \
sceClibPrintf(buffer, "%f", VALUE); \ sceClibPrintf(buffer, "%f", VALUE); \
iniparser_set(dict, NAME, buffer); \ iniparser_set(dict, NAME, buffer); \
} }
@ -152,7 +158,7 @@ struct Config {
#undef SetString #undef SetString
FILE* fd = fopen(g_iniPath, "w"); FILE* fd = fopen(g_iniPath, "w");
if(fd) { if (fd) {
iniparser_dump_ini(dict, fd); iniparser_dump_ini(dict, fd);
} }
iniparser_freedict(dict); iniparser_freedict(dict);
@ -160,19 +166,19 @@ struct Config {
return true; return true;
} }
void ToSettings(sce::AppSettings* appSettings) { void ToSettings(sce::AppSettings* appSettings)
{
appSettings->SetString("data_path", this->m_base_path.c_str()); appSettings->SetString("data_path", this->m_base_path.c_str());
appSettings->SetString("save_path", this->m_save_path.c_str()); appSettings->SetString("save_path", this->m_save_path.c_str());
} }
void FromSettings(sce::AppSettings* appSettings) { void FromSettings(sce::AppSettings* appSettings) {}
}
}; };
Config g_config; Config g_config;
paf::Plugin* load_config_plugin(paf::Framework* paf_fw) { paf::Plugin* load_config_plugin(paf::Framework* paf_fw)
{
paf::Plugin::InitParam pluginParam; paf::Plugin::InitParam pluginParam;
pluginParam.name = "config_plugin"; pluginParam.name = "config_plugin";
pluginParam.caller_name = "__main__"; pluginParam.caller_name = "__main__";
@ -185,7 +191,8 @@ paf::Plugin* load_config_plugin(paf::Framework* paf_fw) {
return paf_fw->FindPlugin("config_plugin"); return paf_fw->FindPlugin("config_plugin");
} }
int load_app_settings_plugin() { int load_app_settings_plugin()
{
paf::Plugin::InitParam pluginParam; paf::Plugin::InitParam pluginParam;
sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_BXCE); sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_BXCE);
sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_INI_FILE_PROCESSOR); sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_INI_FILE_PROCESSOR);
@ -207,58 +214,57 @@ int load_app_settings_plugin() {
bool do_launch = false; bool do_launch = false;
void save_and_exit() { void save_and_exit()
{
g_config.FromSettings(g_appSettings); g_config.FromSettings(g_appSettings);
g_config.SaveIni(); g_config.SaveIni();
g_fw->RequestShutdown(); g_fw->RequestShutdown();
} }
void save_and_launch() { void save_and_launch()
{
g_config.FromSettings(g_appSettings); g_config.FromSettings(g_appSettings);
g_config.SaveIni(); g_config.SaveIni();
g_fw->RequestShutdown(); g_fw->RequestShutdown();
do_launch = true; do_launch = true;
} }
void CBOnStartPageTransition(const char *elementId, int32_t type) void CBOnStartPageTransition(const char* elementId, int32_t type)
{ {
} }
void CBOnPageActivate(const char *elementId, int32_t type) void CBOnPageActivate(const char* elementId, int32_t type)
{ {
} }
void CBOnPageDeactivate(const char *elementId, int32_t type) void CBOnPageDeactivate(const char* elementId, int32_t type)
{ {
} }
int32_t CBOnCheckVisible(const char *elementId, bool *pIsVisible) int32_t CBOnCheckVisible(const char* elementId, bool* pIsVisible)
{ {
*pIsVisible = true; *pIsVisible = true;
return SCE_OK; return SCE_OK;
} }
int32_t CBOnPreCreate(const char *elementId, sce::AppSettings::Element *element) int32_t CBOnPreCreate(const char* elementId, sce::AppSettings::Element* element)
{ {
return SCE_OK; return SCE_OK;
} }
int32_t CBOnPostCreate(const char *elementId, paf::ui::Widget *widget) int32_t CBOnPostCreate(const char* elementId, paf::ui::Widget* widget)
{ {
return SCE_OK; return SCE_OK;
} }
int32_t CBOnPress(const char *elementId, const char *newValue) int32_t CBOnPress(const char* elementId, const char* newValue)
{ {
if(sce_paf_strcmp(elementId, "save_exit_button") == 0) { if (sce_paf_strcmp(elementId, "save_exit_button") == 0) {
save_and_exit(); save_and_exit();
return SCE_OK; return SCE_OK;
} }
if(sce_paf_strcmp(elementId, "save_launch_button") == 0) { if (sce_paf_strcmp(elementId, "save_launch_button") == 0) {
save_and_launch(); save_and_launch();
return SCE_OK; return SCE_OK;
} }
@ -267,7 +273,7 @@ int32_t CBOnPress(const char *elementId, const char *newValue)
return SCE_OK; return SCE_OK;
} }
int32_t CBOnPress2(const char *elementId, const char *newValue) int32_t CBOnPress2(const char* elementId, const char* newValue)
{ {
return SCE_OK; return SCE_OK;
} }
@ -277,21 +283,22 @@ void CBOnTerm(int32_t result)
sceKernelExitProcess(0); sceKernelExitProcess(0);
} }
const wchar_t *CBOnGetString(const char *elementId) const wchar_t* CBOnGetString(const char* elementId)
{ {
wchar_t* res = g_configPlugin->GetString(elementId); wchar_t* res = g_configPlugin->GetString(elementId);
if(res[0] != 0) { if (res[0] != 0) {
return res; return res;
} }
return L"unknown string"; return L"unknown string";
} }
int32_t CBOnGetSurface(paf::graph::Surface **surf, const char *elementId) int32_t CBOnGetSurface(paf::graph::Surface** surf, const char* elementId)
{ {
return SCE_OK; return SCE_OK;
} }
void open_settings() { void open_settings()
{
g_config.Init(); g_config.Init();
g_config.LoadIni(); g_config.LoadIni();
g_config.ToSettings(g_appSettings); g_config.ToSettings(g_appSettings);
@ -306,7 +313,7 @@ void open_settings() {
ifCb.onPressCb = CBOnPress; ifCb.onPressCb = CBOnPress;
ifCb.onPressCb2 = CBOnPress2; ifCb.onPressCb2 = CBOnPress2;
ifCb.onTermCb = CBOnTerm; ifCb.onTermCb = CBOnTerm;
ifCb.onGetStringCb = (sce::AppSettings::InterfaceCallbacks::GetStringCallback)CBOnGetString; ifCb.onGetStringCb = (sce::AppSettings::InterfaceCallbacks::GetStringCallback) CBOnGetString;
ifCb.onGetSurfaceCb = CBOnGetSurface; ifCb.onGetSurfaceCb = CBOnGetSurface;
paf::wstring msg_save_exit(g_configPlugin->GetString("msg_save_exit")); paf::wstring msg_save_exit(g_configPlugin->GetString("msg_save_exit"));
@ -314,14 +321,13 @@ void open_settings() {
paf::wstring msg_exit(g_configPlugin->GetString("msg_exit")); paf::wstring msg_exit(g_configPlugin->GetString("msg_exit"));
paf::Plugin* appSetPlug = paf::Plugin::Find("app_settings_plugin"); paf::Plugin* appSetPlug = paf::Plugin::Find("app_settings_plugin");
g_appSetIf = (sce::AppSettings::Interface *)appSetPlug->GetInterface(1); g_appSetIf = (sce::AppSettings::Interface*) appSetPlug->GetInterface(1);
g_appSetIf->Show(&ifCb); g_appSetIf->Show(&ifCb);
g_appSetIf->AddFooterButton("save_exit_button", &msg_save_exit, 1); g_appSetIf->AddFooterButton("save_exit_button", &msg_save_exit, 1);
g_appSetIf->AddFooterButton("save_launch_button", &msg_save_launch, 2); g_appSetIf->AddFooterButton("save_launch_button", &msg_save_launch, 2);
g_appSetIf->ShowFooter(); g_appSetIf->ShowFooter();
} }
#define MAX_PATH_LENGTH 256 #define MAX_PATH_LENGTH 256
static int64_t g_OpStorage[SCE_FIOS_OP_STORAGE_SIZE(64, MAX_PATH_LENGTH) / sizeof(int64_t) + 1]; static int64_t g_OpStorage[SCE_FIOS_OP_STORAGE_SIZE(64, MAX_PATH_LENGTH) / sizeof(int64_t) + 1];
@ -329,7 +335,8 @@ static int64_t g_ChunkStorage[SCE_FIOS_CHUNK_STORAGE_SIZE(1024) / sizeof(int64_t
static int64_t g_FHStorage[SCE_FIOS_FH_STORAGE_SIZE(1024, MAX_PATH_LENGTH) / sizeof(int64_t) + 1]; static int64_t g_FHStorage[SCE_FIOS_FH_STORAGE_SIZE(1024, MAX_PATH_LENGTH) / sizeof(int64_t) + 1];
static int64_t g_DHStorage[SCE_FIOS_DH_STORAGE_SIZE(32, MAX_PATH_LENGTH) / sizeof(int64_t) + 1]; static int64_t g_DHStorage[SCE_FIOS_DH_STORAGE_SIZE(32, MAX_PATH_LENGTH) / sizeof(int64_t) + 1];
void init_fios2() { void init_fios2()
{
sceSysmoduleLoadModule(SCE_SYSMODULE_FIOS2); sceSysmoduleLoadModule(SCE_SYSMODULE_FIOS2);
SceFiosParams params = SCE_FIOS_PARAMS_INITIALIZER; SceFiosParams params = SCE_FIOS_PARAMS_INITIALIZER;
params.opStorage.pPtr = g_OpStorage; params.opStorage.pPtr = g_OpStorage;
@ -350,12 +357,13 @@ void init_fios2() {
params.threadPriority[SCE_FIOS_CALLBACK_THREAD] = 191; params.threadPriority[SCE_FIOS_CALLBACK_THREAD] = 191;
params.threadPriority[SCE_FIOS_DECOMPRESSOR_THREAD] = 191; params.threadPriority[SCE_FIOS_DECOMPRESSOR_THREAD] = 191;
int ret = sceFiosInitialize(&params); int ret = sceFiosInitialize(&params);
if(ret < 0) { if (ret < 0) {
sceClibPrintf("sceFiosInitialize: %08x\n", ret); sceClibPrintf("sceFiosInitialize: %08x\n", ret);
} }
} }
int paf_main(void) { int paf_main(void)
{
init_fios2(); init_fios2();
paf::Framework::InitParam fwParam; paf::Framework::InitParam fwParam;
@ -371,7 +379,7 @@ int paf_main(void) {
configPlugin->SetLocale(Locale_EN); configPlugin->SetLocale(Locale_EN);
size_t fileSize = 0; size_t fileSize = 0;
const char *mimeType = nullptr; const char* mimeType = nullptr;
auto settingsXmlFile = configPlugin->GetResource()->GetFile("settings.xml", &fileSize, &mimeType); auto settingsXmlFile = configPlugin->GetResource()->GetFile("settings.xml", &fileSize, &mimeType);
sce::AppSettings::InitParam settingsParam; sce::AppSettings::InitParam settingsParam;
@ -388,7 +396,7 @@ int paf_main(void) {
open_settings(); open_settings();
paf_fw->Run(); paf_fw->Run();
if(do_launch) { if (do_launch) {
sceAppMgrLoadExec("app0:/eboot.bin", NULL, NULL); sceAppMgrLoadExec("app0:/eboot.bin", NULL, NULL);
} }
return 0; return 0;

1
CONFIG/vita/src/main.cpp
View File

@ -1,4 +1,5 @@
#include "pafinc.h" #include "pafinc.h"
#include <psp2/kernel/clib.h> #include <psp2/kernel/clib.h>
#include <psp2/kernel/modulemgr.h> #include <psp2/kernel/modulemgr.h>
#include <psp2/kernel/processmgr.h> #include <psp2/kernel/processmgr.h>

6
ISLE/isleapp.cpp
View File

@ -503,12 +503,14 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event)
#ifdef __vita__ #ifdef __vita__
// reject back touch panel // reject back touch panel
switch(event->type) { switch (event->type) {
case SDL_EVENT_FINGER_MOTION: case SDL_EVENT_FINGER_MOTION:
case SDL_EVENT_FINGER_DOWN: case SDL_EVENT_FINGER_DOWN:
case SDL_EVENT_FINGER_UP: case SDL_EVENT_FINGER_UP:
case SDL_EVENT_FINGER_CANCELED: case SDL_EVENT_FINGER_CANCELED:
if(event->tfinger.touchID == 2) return SDL_APP_CONTINUE; if (event->tfinger.touchID == 2) {
return SDL_APP_CONTINUE;
}
} }
#endif #endif

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

@ -685,8 +685,12 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height, DWORD msaaSamples)
m_virtualHeight = height; m_virtualHeight = height;
SceGxmMultisampleMode msaaMode = SCE_GXM_MULTISAMPLE_NONE; SceGxmMultisampleMode msaaMode = SCE_GXM_MULTISAMPLE_NONE;
if(msaaSamples == 2) msaaMode = SCE_GXM_MULTISAMPLE_2X; if (msaaSamples == 2) {
if(msaaSamples == 4) msaaMode = SCE_GXM_MULTISAMPLE_4X; msaaMode = SCE_GXM_MULTISAMPLE_2X;
}
if (msaaSamples == 4) {
msaaMode = SCE_GXM_MULTISAMPLE_4X;
}
int ret; int ret;
if (!gxm) { if (!gxm) {
@ -944,7 +948,8 @@ void GXMRenderer::DeferredDelete(int index)
this->m_buffers_delete[index].clear(); this->m_buffers_delete[index].clear();
} }
static int calculateMipLevels(int width, int height) { static int calculateMipLevels(int width, int height)
{
if (width <= 0 || height <= 0) { if (width <= 0 || height <= 0) {
return 1; return 1;
} }
@ -952,8 +957,11 @@ static int calculateMipLevels(int width, int height) {
return floor(log2(maxDim)) + 1; return floor(log2(maxDim)) + 1;
} }
static int nextPowerOf2(int n) { static int nextPowerOf2(int n)
if (n <= 0) return 1; {
if (n <= 0) {
return 1;
}
n--; n--;
n |= n >> 1; n |= n >> 1;
n |= n >> 2; n |= n >> 2;
@ -964,7 +972,6 @@ static int nextPowerOf2(int n) {
return n; return n;
} }
static void convertTextureMetadata( static void convertTextureMetadata(
SDL_Surface* surface, SDL_Surface* surface,
bool isUi, bool isUi,
@ -1033,7 +1040,7 @@ static void convertTextureMetadata(
totalSize += po2W * po2H * bytesPerPixel; totalSize += po2W * po2H * bytesPerPixel;
} }
if(paletteSize != 0) { if (paletteSize != 0) {
int alignBytes = ALIGNMENT(totalSize, SCE_GXM_PALETTE_ALIGNMENT); int alignBytes = ALIGNMENT(totalSize, SCE_GXM_PALETTE_ALIGNMENT);
totalSize += alignBytes; totalSize += alignBytes;
*paletteOffset = totalSize; *paletteOffset = totalSize;
@ -1043,7 +1050,8 @@ static void convertTextureMetadata(
*textureSize = totalSize; *textureSize = totalSize;
} }
void copySurfaceToGxmARGB888(SDL_Surface* src, uint8_t* textureData, size_t dstStride, size_t mipLevels) { void copySurfaceToGxmARGB888(SDL_Surface* src, uint8_t* textureData, size_t dstStride, size_t mipLevels)
{
uint8_t* currentLevelData = textureData; uint8_t* currentLevelData = textureData;
uint32_t currentLevelWidth = src->w; uint32_t currentLevelWidth = src->w;
uint32_t currentLevelHeight = src->h; uint32_t currentLevelHeight = src->h;
@ -1052,7 +1060,7 @@ void copySurfaceToGxmARGB888(SDL_Surface* src, uint8_t* textureData, size_t dstS
// copy top level mip (cant use transfer because this isnt gpu mapped) // copy top level mip (cant use transfer because this isnt gpu mapped)
size_t topLevelStride = ALIGN(currentLevelWidth, 8) * bytesPerPixel; size_t topLevelStride = ALIGN(currentLevelWidth, 8) * bytesPerPixel;
for (int y = 0; y < currentLevelHeight; y++) { for (int y = 0; y < currentLevelHeight; y++) {
uint8_t* srcRow = (uint8_t*)src->pixels + (y * src->pitch); uint8_t* srcRow = (uint8_t*) src->pixels + (y * src->pitch);
uint8_t* dstRow = textureData + (y * topLevelStride); uint8_t* dstRow = textureData + (y * topLevelStride);
memcpy(dstRow, srcRow, currentLevelWidth * bytesPerPixel); memcpy(dstRow, srcRow, currentLevelWidth * bytesPerPixel);
} }
@ -1065,11 +1073,15 @@ void copySurfaceToGxmARGB888(SDL_Surface* src, uint8_t* textureData, size_t dstS
sceGxmTransferDownscale( sceGxmTransferDownscale(
SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // src format SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // src format
currentLevelData, // src address currentLevelData, // src address
0, 0, currentLevelWidth, currentLevelHeight, // x,y,w,h 0,
0,
currentLevelWidth,
currentLevelHeight, // x,y,w,h
currentLevelSrcStride, // stride currentLevelSrcStride, // stride
SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // dst format SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // dst format
nextLevelData, // dst address nextLevelData, // dst address
0, 0, // x,y 0,
0, // x,y
currentLevelDestStride, // stride currentLevelDestStride, // stride
NULL, // sync NULL, // sync
SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag
@ -1082,7 +1094,15 @@ void copySurfaceToGxmARGB888(SDL_Surface* src, uint8_t* textureData, size_t dstS
} }
} }
void copySurfaceToGxmIndexed8(DirectDrawSurfaceImpl* surface, SDL_Surface* src, uint8_t* textureData, size_t dstStride, uint8_t* paletteData, size_t mipLevels) { void copySurfaceToGxmIndexed8(
DirectDrawSurfaceImpl* surface,
SDL_Surface* src,
uint8_t* textureData,
size_t dstStride,
uint8_t* paletteData,
size_t mipLevels
)
{
LPDIRECTDRAWPALETTE _palette; LPDIRECTDRAWPALETTE _palette;
surface->GetPalette(&_palette); surface->GetPalette(&_palette);
auto palette = static_cast<DirectDrawPaletteImpl*>(_palette); auto palette = static_cast<DirectDrawPaletteImpl*>(_palette);
@ -1098,7 +1118,7 @@ void copySurfaceToGxmIndexed8(DirectDrawSurfaceImpl* surface, SDL_Surface* src,
// copy top level mip (cant use transfer because this isnt gpu mapped) // copy top level mip (cant use transfer because this isnt gpu mapped)
size_t topLevelStride = ALIGN(currentLevelWidth, 8) * bytesPerPixel; size_t topLevelStride = ALIGN(currentLevelWidth, 8) * bytesPerPixel;
for (int y = 0; y < currentLevelHeight; y++) { for (int y = 0; y < currentLevelHeight; y++) {
uint8_t* srcRow = (uint8_t*)src->pixels + (y * src->pitch); uint8_t* srcRow = (uint8_t*) src->pixels + (y * src->pitch);
uint8_t* dstRow = textureData + (y * topLevelStride); uint8_t* dstRow = textureData + (y * topLevelStride);
memcpy(dstRow, srcRow, currentLevelWidth * bytesPerPixel); memcpy(dstRow, srcRow, currentLevelWidth * bytesPerPixel);
} }
@ -1111,11 +1131,15 @@ void copySurfaceToGxmIndexed8(DirectDrawSurfaceImpl* surface, SDL_Surface* src,
sceGxmTransferDownscale( sceGxmTransferDownscale(
SCE_GXM_TRANSFER_FORMAT_U8_R, // src format SCE_GXM_TRANSFER_FORMAT_U8_R, // src format
currentLevelData, // src address currentLevelData, // src address
0, 0, currentLevelWidth, currentLevelHeight, // x,y,w,h 0,
0,
currentLevelWidth,
currentLevelHeight, // x,y,w,h
currentLevelSrcStride, // stride currentLevelSrcStride, // stride
SCE_GXM_TRANSFER_FORMAT_U8_R, // dst format SCE_GXM_TRANSFER_FORMAT_U8_R, // dst format
nextLevelData, // dst address nextLevelData, // dst address
0, 0, // x,y 0,
0, // x,y
currentLevelDestStride, // stride currentLevelDestStride, // stride
NULL, // sync NULL, // sync
SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag
@ -1130,7 +1154,13 @@ void copySurfaceToGxmIndexed8(DirectDrawSurfaceImpl* surface, SDL_Surface* src,
palette->Release(); palette->Release();
} }
void copySurfaceToGxm(DirectDrawSurfaceImpl* surface, uint8_t* textureData, size_t dstStride, size_t paletteOffset, size_t mipLevels) void copySurfaceToGxm(
DirectDrawSurfaceImpl* surface,
uint8_t* textureData,
size_t dstStride,
size_t paletteOffset,
size_t mipLevels
)
{ {
SDL_Surface* src = surface->m_surface; SDL_Surface* src = surface->m_surface;
@ -1140,7 +1170,7 @@ void copySurfaceToGxm(DirectDrawSurfaceImpl* surface, uint8_t* textureData, size
break; break;
} }
case SDL_PIXELFORMAT_INDEX8: { case SDL_PIXELFORMAT_INDEX8: {
copySurfaceToGxmIndexed8(surface, src, textureData, dstStride, textureData+paletteOffset, mipLevels); copySurfaceToGxmIndexed8(surface, src, textureData, dstStride, textureData + paletteOffset, mipLevels);
break; break;
} }
default: { default: {
@ -1211,11 +1241,19 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture, bool isUi, float
); );
// allocate gpu memory // allocate gpu memory
uint8_t* textureData = (uint8_t*)gxm->alloc(textureSize, textureAlignment); uint8_t* textureData = (uint8_t*) gxm->alloc(textureSize, textureAlignment);
copySurfaceToGxm(surface, (uint8_t*) textureData, textureStride, paletteOffset, mipLevels); copySurfaceToGxm(surface, (uint8_t*) textureData, textureStride, paletteOffset, mipLevels);
SceGxmTexture gxmTexture; SceGxmTexture gxmTexture;
SCE_ERR(sceGxmTextureInitLinear, &gxmTexture, textureData, gxmTextureFormat, textureWidth, textureHeight, mipLevels); SCE_ERR(
sceGxmTextureInitLinear,
&gxmTexture,
textureData,
gxmTextureFormat,
textureWidth,
textureHeight,
mipLevels
);
if (isUi) { if (isUi) {
sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT); sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT);
sceGxmTextureSetMagFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT); sceGxmTextureSetMagFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT);