isledecomp/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2026-01-12 02:41: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

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

@ -1,135 +1,133 @@
#include <stdint.h>
#include <stddef.h>
#include <psp2/kernel/threadmgr.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
extern "C"
{
#endif
typedef struct SceFiosBuffer {
void *pPtr;
size_t length;
} SceFiosBuffer;
typedef struct SceFiosBuffer {
void* pPtr;
size_t length;
} SceFiosBuffer;
#define SCE_FIOS_THREAD_TYPES 3
typedef struct SceFiosParams
{
uint32_t initialized : 1;
uint32_t paramsSize : 15;
uint32_t pathMax : 16;
uint32_t profiling;
uint32_t ioThreadCount;
uint32_t threadsPerScheduler;
uint32_t extraFlag1 : 1;
uint32_t extraFlags : 31;
uint32_t maxChunk;
uint8_t maxDecompressorThreadCount;
uint8_t reserved1;
uint8_t reserved2;
uint8_t reserved3;
intptr_t reserved4;
intptr_t reserved5;
SceFiosBuffer opStorage;
SceFiosBuffer fhStorage;
SceFiosBuffer dhStorage;
SceFiosBuffer chunkStorage;
void* pVprintf;
void* pMemcpy;
void* pProfileCallback;
int threadPriority[SCE_FIOS_THREAD_TYPES];
int threadAffinity[SCE_FIOS_THREAD_TYPES];
int threadStackSize[SCE_FIOS_THREAD_TYPES];
} SceFiosParams;
typedef struct SceFiosParams {
uint32_t initialized : 1;
uint32_t paramsSize : 15;
uint32_t pathMax : 16;
uint32_t profiling;
uint32_t ioThreadCount;
uint32_t threadsPerScheduler;
uint32_t extraFlag1 : 1;
uint32_t extraFlags : 31;
uint32_t maxChunk;
uint8_t maxDecompressorThreadCount;
uint8_t reserved1;
uint8_t reserved2;
uint8_t reserved3;
intptr_t reserved4;
intptr_t reserved5;
SceFiosBuffer opStorage;
SceFiosBuffer fhStorage;
SceFiosBuffer dhStorage;
SceFiosBuffer chunkStorage;
void* pVprintf;
void* pMemcpy;
void* pProfileCallback;
int threadPriority[SCE_FIOS_THREAD_TYPES];
int threadAffinity[SCE_FIOS_THREAD_TYPES];
int threadStackSize[SCE_FIOS_THREAD_TYPES];
} SceFiosParams;
#define SCE_KERNEL_HIGHEST_PRIORITY_USER (64)
#define SCE_KERNEL_LOWEST_PRIORITY_USER (191)
#define SCE_KERNEL_HIGHEST_PRIORITY_USER (64)
#define SCE_KERNEL_LOWEST_PRIORITY_USER (191)
#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_CALLBACK_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_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_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_CALLBACK_THREAD_DEFAULT_AFFINITY SCE_FIOS_THREAD_DEFAULT_AFFINITY
#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_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_IO_THREAD_DEFAULT_STACKSIZE (8*1024)
#define SCE_FIOS_DECOMPRESSOR_THREAD_DEFAULT_STACKSIZE (16*1024)
#define SCE_FIOS_CALLBACK_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_CALLBACK_THREAD_DEFAULT_STACKSIZE (8 * 1024)
#define SCE_FIOS_PARAMS_INITIALIZER { 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 }, \
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_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_PARAMS_INITIALIZER \
{ \
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}, \
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_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_DECOMPRESSOR_THREAD 1
#define SCE_FIOS_CALLBACK_THREAD 2
#define SCE_FIOS_FH_SIZE 80
#define SCE_FIOS_DH_SIZE 80
#define SCE_FIOS_OP_SIZE 168
#define SCE_FIOS_CHUNK_SIZE 64
#define SCE_FIOS_FH_SIZE 80
#define SCE_FIOS_DH_SIZE 80
#define SCE_FIOS_OP_SIZE 168
#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) \
(((num) * (size)) + SCE_FIOS_ALIGN_UP(SCE_FIOS_ALIGN_UP((num), 8) / 8, 8))
#define SCE_FIOS_STORAGE_SIZE(num, size) (((num) * (size)) + SCE_FIOS_ALIGN_UP(SCE_FIOS_ALIGN_UP((num), 8) / 8, 8))
#define SCE_FIOS_DH_STORAGE_SIZE(numDHs, pathMax) \
SCE_FIOS_STORAGE_SIZE(numDHs, SCE_FIOS_DH_SIZE + pathMax)
#define SCE_FIOS_DH_STORAGE_SIZE(numDHs, pathMax) SCE_FIOS_STORAGE_SIZE(numDHs, SCE_FIOS_DH_SIZE + pathMax)
#define SCE_FIOS_FH_STORAGE_SIZE(numFHs,pathMax) \
SCE_FIOS_STORAGE_SIZE(numFHs, SCE_FIOS_FH_SIZE + pathMax)
#define SCE_FIOS_FH_STORAGE_SIZE(numFHs, pathMax) SCE_FIOS_STORAGE_SIZE(numFHs, SCE_FIOS_FH_SIZE + pathMax)
#define SCE_FIOS_OP_STORAGE_SIZE(numOps,pathMax) \
SCE_FIOS_STORAGE_SIZE(numOps, SCE_FIOS_OP_SIZE + pathMax)
#define SCE_FIOS_OP_STORAGE_SIZE(numOps, pathMax) SCE_FIOS_STORAGE_SIZE(numOps, SCE_FIOS_OP_SIZE + pathMax)
#define SCE_FIOS_CHUNK_STORAGE_SIZE(numChunks) \
SCE_FIOS_STORAGE_SIZE(numChunks, SCE_FIOS_CHUNK_SIZE)
#define SCE_FIOS_CHUNK_STORAGE_SIZE(numChunks) 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;
uint32_t opFlags:16;
uint32_t reserved;
SceFiosBuffer buffer;
} SceFiosOpenParams;
typedef struct SceFiosOpAttr
{
SceFiosTime deadline;
void* pCallback;
void * pCallbackContext;
int32_t priority : 8;
uint32_t opflags : 24;
uint32_t userTag;
void * userPtr;
void * pReserved;
} SceFiosOpAttr;
int sceFiosFHOpenWithModeSync(const SceFiosOpAttr *pAttr, SceFiosFH *pOutFH, const char *pPath, const SceFiosOpenParams *pOpenParams, int32_t nativeMode);
typedef struct SceFiosOpenParams {
uint32_t openFlags : 16;
uint32_t opFlags : 16;
uint32_t reserved;
SceFiosBuffer buffer;
} SceFiosOpenParams;
typedef struct SceFiosOpAttr {
SceFiosTime deadline;
void* pCallback;
void* pCallbackContext;
int32_t priority : 8;
uint32_t opflags : 24;
uint32_t userTag;
void* userPtr;
void* pReserved;
} SceFiosOpAttr;
int sceFiosFHOpenWithModeSync(
const SceFiosOpAttr* pAttr,
SceFiosFH* pOutFH,
const char* pPath,
const SceFiosOpenParams* pOpenParams,
int32_t nativeMode
);
#ifdef __cplusplus
}

2
CONFIG/vita/include/pafinc.h
View File

@ -1,4 +1,4 @@
// clang-format off
#include <stdarg.h>
#include <paf.h>
// clang-format on
// clang-format on

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

@ -15,153 +15,150 @@
#define _DICTIONARY_H_
/*---------------------------------------------------------------------------
Includes
Includes
---------------------------------------------------------------------------*/
#include "pafstd.h"
#ifdef __cplusplus
extern "C" {
extern "C"
{
#endif
/*---------------------------------------------------------------------------
New types
---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------
New types
---------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/**
@brief Dictionary object
/*-------------------------------------------------------------------------*/
/**
@brief Dictionary object
This object contains a list of string/string associations. Each
association is identified by a unique string key. Looking up values
in the dictionary is speeded up by the use of a (hopefully collision-free)
hash function.
*/
/*-------------------------------------------------------------------------*/
typedef struct _dictionary_ {
unsigned n; /** Number of entries in dictionary */
size_t size; /** Storage size */
char** val; /** List of string values */
char** key; /** List of string keys */
unsigned* hash; /** List of hash values for keys */
} dictionary;
This object contains a list of string/string associations. Each
association is identified by a unique string key. Looking up values
in the dictionary is speeded up by the use of a (hopefully collision-free)
hash function.
*/
/*-------------------------------------------------------------------------*/
typedef struct _dictionary_ {
unsigned n ; /** Number of entries in dictionary */
size_t size ; /** Storage size */
char ** val ; /** List of string values */
char ** key ; /** List of string keys */
unsigned * hash ; /** List of hash values for keys */
} dictionary ;
/*---------------------------------------------------------------------------
Function prototypes
---------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/**
@brief Compute the hash key for a string.
@param key Character string to use for key.
@return 1 unsigned int on at least 32 bits.
/*---------------------------------------------------------------------------
Function prototypes
---------------------------------------------------------------------------*/
This hash function has been taken from an Article in Dr Dobbs Journal.
This is normally a collision-free function, distributing keys evenly.
The key is stored anyway in the struct so that collision can be avoided
by comparing the key itself in last resort.
*/
/*--------------------------------------------------------------------------*/
unsigned dictionary_hash(const char* key);
/*-------------------------------------------------------------------------*/
/**
@brief Compute the hash key for a string.
@param key Character string to use for key.
@return 1 unsigned int on at least 32 bits.
/*-------------------------------------------------------------------------*/
/**
@brief Create a new dictionary object.
@param size Optional initial size of the dictionary.
@return 1 newly allocated dictionary object.
This hash function has been taken from an Article in Dr Dobbs Journal.
This is normally a collision-free function, distributing keys evenly.
The key is stored anyway in the struct so that collision can be avoided
by comparing the key itself in last resort.
*/
/*--------------------------------------------------------------------------*/
unsigned dictionary_hash(const char * key);
This function allocates a new dictionary object of given size and returns
it. If you do not know in advance (roughly) the number of entries in the
dictionary, give size=0.
*/
/*--------------------------------------------------------------------------*/
dictionary* dictionary_new(size_t size);
/*-------------------------------------------------------------------------*/
/**
@brief Create a new dictionary object.
@param size Optional initial size of the dictionary.
@return 1 newly allocated dictionary object.
/*-------------------------------------------------------------------------*/
/**
@brief Delete a dictionary object
@param d dictionary object to deallocate.
@return void
This function allocates a new dictionary object of given size and returns
it. If you do not know in advance (roughly) the number of entries in the
dictionary, give size=0.
*/
/*--------------------------------------------------------------------------*/
dictionary * dictionary_new(size_t size);
Deallocate a dictionary object and all memory associated to it.
*/
/*--------------------------------------------------------------------------*/
void dictionary_del(dictionary* vd);
/*-------------------------------------------------------------------------*/
/**
@brief Delete a dictionary object
@param d dictionary object to deallocate.
@return void
/*-------------------------------------------------------------------------*/
/**
@brief Get a value from a dictionary.
@param d dictionary object to search.
@param key Key to look for in the dictionary.
@param def Default value to return if key not found.
@return 1 pointer to internally allocated character string.
Deallocate a dictionary object and all memory associated to it.
*/
/*--------------------------------------------------------------------------*/
void dictionary_del(dictionary * vd);
This function locates a key in a dictionary and returns a pointer to its
value, or the passed 'def' pointer if no such key can be found in
dictionary. The returned character pointer points to data internal to the
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);
/*-------------------------------------------------------------------------*/
/**
@brief Get a value from a dictionary.
@param d dictionary object to search.
@param key Key to look for in the dictionary.
@param def Default value to return if key not found.
@return 1 pointer to internally allocated character string.
/*-------------------------------------------------------------------------*/
/**
@brief Set a value in a dictionary.
@param d dictionary object to modify.
@param key Key to modify or add.
@param val Value to add.
@return int 0 if Ok, anything else otherwise
This function locates a key in a dictionary and returns a pointer to its
value, or the passed 'def' pointer if no such key can be found in
dictionary. The returned character pointer points to data internal to the
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);
If the given key is found in the dictionary, the associated value is
replaced by the provided one. If the key cannot be found in the
dictionary, it is added to it.
It is Ok to provide a NULL value for val, but NULL values for the dictionary
or the key are considered as errors: the function will return immediately
in such a case.
/*-------------------------------------------------------------------------*/
/**
@brief Set a value in a dictionary.
@param d dictionary object to modify.
@param key Key to modify or add.
@param val Value to add.
@return int 0 if Ok, anything else otherwise
Notice that if you dictionary_set a variable to NULL, a call to
dictionary_get will return a NULL value: the variable will be found, and
its value (NULL) is returned. In other words, setting the variable
content to NULL is equivalent to deleting the variable from the
dictionary. It is not possible (in this implementation) to have a key in
the dictionary without value.
If the given key is found in the dictionary, the associated value is
replaced by the provided one. If the key cannot be found in the
dictionary, it is added to it.
This function returns non-zero in case of failure.
*/
/*--------------------------------------------------------------------------*/
int dictionary_set(dictionary* vd, const char* key, const char* val);
It is Ok to provide a NULL value for val, but NULL values for the dictionary
or the key are considered as errors: the function will return immediately
in such a case.
/*-------------------------------------------------------------------------*/
/**
@brief Delete a key in a dictionary
@param d dictionary object to modify.
@param key Key to remove.
@return void
Notice that if you dictionary_set a variable to NULL, a call to
dictionary_get will return a NULL value: the variable will be found, and
its value (NULL) is returned. In other words, setting the variable
content to NULL is equivalent to deleting the variable from the
dictionary. It is not possible (in this implementation) to have a key in
the dictionary without value.
This function deletes a key in a dictionary. Nothing is done if the
key cannot be found.
*/
/*--------------------------------------------------------------------------*/
void dictionary_unset(dictionary* d, const char* key);
This function returns non-zero in case of failure.
*/
/*--------------------------------------------------------------------------*/
int dictionary_set(dictionary * vd, const char * key, const char * val);
/*-------------------------------------------------------------------------*/
/**
@brief Dump a dictionary to an opened file pointer.
@param d Dictionary to dump
@param f Opened file pointer.
@return void
/*-------------------------------------------------------------------------*/
/**
@brief Delete a key in a dictionary
@param d dictionary object to modify.
@param key Key to remove.
@return void
This function deletes a key in a dictionary. Nothing is done if the
key cannot be found.
*/
/*--------------------------------------------------------------------------*/
void dictionary_unset(dictionary * d, const char * key);
/*-------------------------------------------------------------------------*/
/**
@brief Dump a dictionary to an opened file pointer.
@param d Dictionary to dump
@param f Opened file pointer.
@return void
Dumps a dictionary onto an opened file pointer. Key pairs are printed out
as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as
output file pointers.
*/
/*--------------------------------------------------------------------------*/
void dictionary_dump(const dictionary * d, FILE * out);
Dumps a dictionary onto an opened file pointer. Key pairs are printed out
as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as
output file pointers.
*/
/*--------------------------------------------------------------------------*/
void dictionary_dump(const dictionary* d, FILE* out);
#ifdef __cplusplus
}

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

@ -11,433 +11,430 @@
#define _INIPARSER_H_
/*---------------------------------------------------------------------------
Includes
Includes
---------------------------------------------------------------------------*/
#include "dictionary.h"
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
extern "C"
{
#endif
/*-------------------------------------------------------------------------*/
/**
@brief Configure a function to receive the error messages.
@param errback Function to call.
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.
*/
/*--------------------------------------------------------------------------*/
void iniparser_set_error_callback(int (*errback)(const char *, ...));
/*-------------------------------------------------------------------------*/
/**
@brief Get number of sections in a dictionary
@param d Dictionary to examine
@return int Number of sections found in dictionary
This function returns the number of sections found in a dictionary.
The test to recognize sections is done on the string stored in the
dictionary: a section name is given as "section" whereas a key is
stored as "section:key", thus the test looks for entries that do not
contain a colon.
This clearly fails in the case a section name contains a colon, but
this should simply be avoided.
This function returns -1 in case of error.
*/
/*--------------------------------------------------------------------------*/
int iniparser_getnsec(const dictionary * d);
/*-------------------------------------------------------------------------*/
/**
@brief Get name for section n in a dictionary.
@param d Dictionary to examine
@param n Section number (from 0 to nsec-1).
@return Pointer to char string
This function locates the n-th section in a dictionary and returns
its name as a pointer to a string statically allocated inside the
dictionary. Do not free or modify the returned string!
This function returns NULL in case of error.
*/
/*--------------------------------------------------------------------------*/
const char * iniparser_getsecname(const dictionary * d, int n);
/*-------------------------------------------------------------------------*/
/**
@brief Save a dictionary to a loadable ini file
@param d Dictionary to dump
@param f Opened file pointer to dump to
This function dumps a given dictionary into a loadable ini file.
It is Ok to specify @c stderr or @c stdout as output files.
All values are quoted, these charecters are escaped:
- ' : the quote character (e.g. "String with \"Quotes\"")
- \ : the backslash character (e.g. "C:\\tmp")
*/
/*--------------------------------------------------------------------------*/
void iniparser_dump_ini(const dictionary * d, FILE * f);
/*-------------------------------------------------------------------------*/
/**
@brief Save a dictionary section to a loadable ini file
@param d Dictionary to dump
@param s Section name of dictionary to dump
@param f Opened file pointer to dump to
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.
*/
/*--------------------------------------------------------------------------*/
void iniparser_dumpsection_ini(const dictionary * d, const char * s, FILE * f);
/*-------------------------------------------------------------------------*/
/**
@brief Dump a dictionary to an opened file pointer.
@param d Dictionary to dump.
@param f Opened file pointer to dump to.
This function prints out the contents of a dictionary, one element by
line, onto the provided file pointer. It is OK to specify @c stderr
or @c stdout as output files. This function is meant for debugging
purposes mostly.
*/
/*--------------------------------------------------------------------------*/
void iniparser_dump(const dictionary * d, FILE * f);
/*-------------------------------------------------------------------------*/
/**
@brief Get the number of keys in a section of a dictionary.
@param d Dictionary to examine
@param s Section name of dictionary to examine
@return Number of keys in section
*/
/*--------------------------------------------------------------------------*/
int iniparser_getsecnkeys(const dictionary * d, const char * s);
/*-------------------------------------------------------------------------*/
/**
@brief Get the number of keys in a section of a dictionary.
@param d Dictionary to examine
@param s Section name of dictionary to examine
@param keys Already allocated array to store the keys in
@return The pointer passed as `keys` argument or NULL in case of error
This function queries a dictionary and finds all keys in a given section.
The keys argument should be an array of pointers which size has been
determined by calling `iniparser_getsecnkeys` function prior to this one.
Each pointer in the returned char pointer-to-pointer is pointing to
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);
/*-------------------------------------------------------------------------*/
/**
@brief Get the string associated to a key
@param d Dictionary to search
@param key Key string to look for
@param def Default value to return if key not found.
@return pointer to statically allocated character string
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the pointer passed as 'def' is returned.
The returned char pointer is pointing to a string allocated in
the dictionary, do not free or modify it.
*/
/*--------------------------------------------------------------------------*/
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
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
Supported values for integers include the usual C notation
so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
are supported. Examples:
- "42" -> 42
- "042" -> 34 (octal -> decimal)
- "0x42" -> 66 (hexa -> decimal)
Warning: the conversion may overflow in various ways. Conversion is
totally outsourced to strtol(), see the associated man page for overflow
handling.
Credits: Thanks to A. Becker for suggesting strtol()
*/
/*--------------------------------------------------------------------------*/
int iniparser_getint(const dictionary * d, const char * key, int notfound);
/*-------------------------------------------------------------------------*/
/**
@brief Get the string associated to a key, convert to an long int
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
Supported values for integers include the usual C notation
so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
are supported. Examples:
- "42" -> 42
- "042" -> 34 (octal -> decimal)
- "0x42" -> 66 (hexa -> decimal)
Warning: the conversion may overflow in various ways. Conversion is
totally outsourced to strtol(), see the associated man page for overflow
handling.
*/
/*--------------------------------------------------------------------------*/
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
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
Supported values for integers include the usual C notation
so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
are supported. Examples:
- "42" -> 42
- "042" -> 34 (octal -> decimal)
- "0x42" -> 66 (hexa -> decimal)
Warning: the conversion may overflow in various ways. Conversion is
totally outsourced to strtoimax(), see the associated man page for overflow
handling.
This function is usefull on 32bit architectures where `long int` is only
32bit.
*/
/*--------------------------------------------------------------------------*/
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
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
Supported values for integers include the usual C notation
so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
are supported. Examples:
- "42" -> 42
- "042" -> 34 (octal -> decimal)
- "0x42" -> 66 (hexa -> decimal)
Warning: the conversion may overflow in various ways. Conversion is
totally outsourced to strtoumax(), see the associated man page for overflow
handling.
This function is usefull on 32bit architectures where `long int` is only
32bit.
*/
/*--------------------------------------------------------------------------*/
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
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return double
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
*/
/*--------------------------------------------------------------------------*/
double iniparser_getdouble(const dictionary * d, const char * key, double notfound);
/*-------------------------------------------------------------------------*/
/**
@brief Get the string associated to a key, convert to a boolean
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
A true boolean is found if one of the following is matched:
- A string starting with 'y'
- A string starting with 'Y'
- A string starting with 't'
- A string starting with 'T'
- A string starting with '1'
A false boolean is found if one of the following is matched:
- A string starting with 'n'
- A string starting with 'N'
- A string starting with 'f'
- A string starting with 'F'
- A string starting with '0'
The notfound value returned if no boolean is identified, does not
necessarily have to be 0 or 1.
*/
/*--------------------------------------------------------------------------*/
int iniparser_getboolean(const dictionary * d, const char * key, int notfound);
/*-------------------------------------------------------------------------*/
/**
@brief Set an entry in a dictionary.
@param ini Dictionary to modify.
@param entry Entry to modify (entry name)
@param val New value to associate to the entry.
@return int 0 if Ok, -1 otherwise.
If the given entry can be found in the dictionary, it is modified to
contain the provided value. If it cannot be found, the entry is created.
It is Ok to set val to NULL.
*/
/*--------------------------------------------------------------------------*/
int iniparser_set(dictionary * ini, const char * entry, const char * val);
/*-------------------------------------------------------------------------*/
/**
@brief Delete an entry in a dictionary
@param ini Dictionary to modify
@param entry Entry to delete (entry name)
If the given entry can be found, it is deleted from the dictionary.
*/
/*--------------------------------------------------------------------------*/
void iniparser_unset(dictionary * ini, const char * entry);
/*-------------------------------------------------------------------------*/
/**
@brief Finds out if a given entry exists in a dictionary
@param ini Dictionary to search
@param entry Name of the entry to look for
@return integer 1 if entry exists, 0 otherwise
Finds out if a given entry exists in the dictionary. Since sections
are stored as keys with NULL associated values, this is the only way
of querying for the presence of sections in a dictionary.
*/
/*--------------------------------------------------------------------------*/
int iniparser_find_entry(const dictionary * ini, const char * entry) ;
/*-------------------------------------------------------------------------*/
/**
@brief Parse an ini file and return an allocated dictionary object
@param ininame Name of the ini file to read.
@return Pointer to newly allocated dictionary
This is the parser for ini files. This function is called, providing
the name of the file to be read. It returns a dictionary object that
should not be accessed directly, but through accessor functions
instead.
Iff the value is a quoted string it supports some escape sequences:
- \" or ' : the quote character
(e.g. 'String with "Quotes"' or "String with 'Quotes'")
- \ : the backslash character (e.g. "C:\tmp")
Escape sequences always start with a backslash. Additional escape sequences
might be added in the future. Backslash characters must be escaped. Any other
sequence then those outlined above is invalid and may lead to unpredictable
results.
The returned dictionary must be freed using iniparser_freedict().
*/
/*--------------------------------------------------------------------------*/
dictionary * iniparser_load(const char * ininame);
/*-------------------------------------------------------------------------*/
/**
@brief Parse an ini file and return an allocated dictionary object
@param in File to read.
@param ininame Name of the ini file to read (only used for nicer error messages)
@return Pointer to newly allocated dictionary
This is the parser for ini files. This function is called, providing
the file to be read. It returns a dictionary object that should not
be accessed directly, but through accessor functions instead.
Iff the value is a quoted string it supports some escape sequences:
- \" or ' : the quote character
(e.g. 'String with "Quotes"' or "String with 'Quotes'")
- \ : the backslash character (e.g. "C:\tmp")
Escape sequences always start with a backslash. Additional escape sequences
might be added in the future. Backslash characters must be escaped. Any other
sequence then those outlined above is invalid and may lead to unpredictable
results.
The returned dictionary must be freed using iniparser_freedict().
*/
/*--------------------------------------------------------------------------*/
dictionary * iniparser_load_file(FILE * in, const char * ininame);
/*-------------------------------------------------------------------------*/
/**
@brief Free all memory associated to an ini dictionary
@param d Dictionary to free
Free all memory associated to an ini dictionary.
It is mandatory to call this function before the dictionary object
gets out of the current context.
*/
/*--------------------------------------------------------------------------*/
void iniparser_freedict(dictionary * d);
/*-------------------------------------------------------------------------*/
/**
@brief Configure a function to receive the error messages.
@param errback Function to call.
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.
*/
/*--------------------------------------------------------------------------*/
void iniparser_set_error_callback(int (*errback)(const char*, ...));
/*-------------------------------------------------------------------------*/
/**
@brief Get number of sections in a dictionary
@param d Dictionary to examine
@return int Number of sections found in dictionary
This function returns the number of sections found in a dictionary.
The test to recognize sections is done on the string stored in the
dictionary: a section name is given as "section" whereas a key is
stored as "section:key", thus the test looks for entries that do not
contain a colon.
This clearly fails in the case a section name contains a colon, but
this should simply be avoided.
This function returns -1 in case of error.
*/
/*--------------------------------------------------------------------------*/
int iniparser_getnsec(const dictionary* d);
/*-------------------------------------------------------------------------*/
/**
@brief Get name for section n in a dictionary.
@param d Dictionary to examine
@param n Section number (from 0 to nsec-1).
@return Pointer to char string
This function locates the n-th section in a dictionary and returns
its name as a pointer to a string statically allocated inside the
dictionary. Do not free or modify the returned string!
This function returns NULL in case of error.
*/
/*--------------------------------------------------------------------------*/
const char* iniparser_getsecname(const dictionary* d, int n);
/*-------------------------------------------------------------------------*/
/**
@brief Save a dictionary to a loadable ini file
@param d Dictionary to dump
@param f Opened file pointer to dump to
This function dumps a given dictionary into a loadable ini file.
It is Ok to specify @c stderr or @c stdout as output files.
All values are quoted, these charecters are escaped:
- ' : the quote character (e.g. "String with \"Quotes\"")
- \ : the backslash character (e.g. "C:\\tmp")
*/
/*--------------------------------------------------------------------------*/
void iniparser_dump_ini(const dictionary* d, FILE* f);
/*-------------------------------------------------------------------------*/
/**
@brief Save a dictionary section to a loadable ini file
@param d Dictionary to dump
@param s Section name of dictionary to dump
@param f Opened file pointer to dump to
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.
*/
/*--------------------------------------------------------------------------*/
void iniparser_dumpsection_ini(const dictionary* d, const char* s, FILE* f);
/*-------------------------------------------------------------------------*/
/**
@brief Dump a dictionary to an opened file pointer.
@param d Dictionary to dump.
@param f Opened file pointer to dump to.
This function prints out the contents of a dictionary, one element by
line, onto the provided file pointer. It is OK to specify @c stderr
or @c stdout as output files. This function is meant for debugging
purposes mostly.
*/
/*--------------------------------------------------------------------------*/
void iniparser_dump(const dictionary* d, FILE* f);
/*-------------------------------------------------------------------------*/
/**
@brief Get the number of keys in a section of a dictionary.
@param d Dictionary to examine
@param s Section name of dictionary to examine
@return Number of keys in section
*/
/*--------------------------------------------------------------------------*/
int iniparser_getsecnkeys(const dictionary* d, const char* s);
/*-------------------------------------------------------------------------*/
/**
@brief Get the number of keys in a section of a dictionary.
@param d Dictionary to examine
@param s Section name of dictionary to examine
@param keys Already allocated array to store the keys in
@return The pointer passed as `keys` argument or NULL in case of error
This function queries a dictionary and finds all keys in a given section.
The keys argument should be an array of pointers which size has been
determined by calling `iniparser_getsecnkeys` function prior to this one.
Each pointer in the returned char pointer-to-pointer is pointing to
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);
/*-------------------------------------------------------------------------*/
/**
@brief Get the string associated to a key
@param d Dictionary to search
@param key Key string to look for
@param def Default value to return if key not found.
@return pointer to statically allocated character string
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the pointer passed as 'def' is returned.
The returned char pointer is pointing to a string allocated in
the dictionary, do not free or modify it.
*/
/*--------------------------------------------------------------------------*/
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
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
Supported values for integers include the usual C notation
so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
are supported. Examples:
- "42" -> 42
- "042" -> 34 (octal -> decimal)
- "0x42" -> 66 (hexa -> decimal)
Warning: the conversion may overflow in various ways. Conversion is
totally outsourced to strtol(), see the associated man page for overflow
handling.
Credits: Thanks to A. Becker for suggesting strtol()
*/
/*--------------------------------------------------------------------------*/
int iniparser_getint(const dictionary* d, const char* key, int notfound);
/*-------------------------------------------------------------------------*/
/**
@brief Get the string associated to a key, convert to an long int
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
Supported values for integers include the usual C notation
so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
are supported. Examples:
- "42" -> 42
- "042" -> 34 (octal -> decimal)
- "0x42" -> 66 (hexa -> decimal)
Warning: the conversion may overflow in various ways. Conversion is
totally outsourced to strtol(), see the associated man page for overflow
handling.
*/
/*--------------------------------------------------------------------------*/
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
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
Supported values for integers include the usual C notation
so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
are supported. Examples:
- "42" -> 42
- "042" -> 34 (octal -> decimal)
- "0x42" -> 66 (hexa -> decimal)
Warning: the conversion may overflow in various ways. Conversion is
totally outsourced to strtoimax(), see the associated man page for overflow
handling.
This function is usefull on 32bit architectures where `long int` is only
32bit.
*/
/*--------------------------------------------------------------------------*/
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
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
Supported values for integers include the usual C notation
so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
are supported. Examples:
- "42" -> 42
- "042" -> 34 (octal -> decimal)
- "0x42" -> 66 (hexa -> decimal)
Warning: the conversion may overflow in various ways. Conversion is
totally outsourced to strtoumax(), see the associated man page for overflow
handling.
This function is usefull on 32bit architectures where `long int` is only
32bit.
*/
/*--------------------------------------------------------------------------*/
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
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return double
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
*/
/*--------------------------------------------------------------------------*/
double iniparser_getdouble(const dictionary* d, const char* key, double notfound);
/*-------------------------------------------------------------------------*/
/**
@brief Get the string associated to a key, convert to a boolean
@param d Dictionary to search
@param key Key string to look for
@param notfound Value to return in case of error
@return integer
This function queries a dictionary for a key. A key as read from an
ini file is given as "section:key". If the key cannot be found,
the notfound value is returned.
A true boolean is found if one of the following is matched:
- A string starting with 'y'
- A string starting with 'Y'
- A string starting with 't'
- A string starting with 'T'
- A string starting with '1'
A false boolean is found if one of the following is matched:
- A string starting with 'n'
- A string starting with 'N'
- A string starting with 'f'
- A string starting with 'F'
- A string starting with '0'
The notfound value returned if no boolean is identified, does not
necessarily have to be 0 or 1.
*/
/*--------------------------------------------------------------------------*/
int iniparser_getboolean(const dictionary* d, const char* key, int notfound);
/*-------------------------------------------------------------------------*/
/**
@brief Set an entry in a dictionary.
@param ini Dictionary to modify.
@param entry Entry to modify (entry name)
@param val New value to associate to the entry.
@return int 0 if Ok, -1 otherwise.
If the given entry can be found in the dictionary, it is modified to
contain the provided value. If it cannot be found, the entry is created.
It is Ok to set val to NULL.
*/
/*--------------------------------------------------------------------------*/
int iniparser_set(dictionary* ini, const char* entry, const char* val);
/*-------------------------------------------------------------------------*/
/**
@brief Delete an entry in a dictionary
@param ini Dictionary to modify
@param entry Entry to delete (entry name)
If the given entry can be found, it is deleted from the dictionary.
*/
/*--------------------------------------------------------------------------*/
void iniparser_unset(dictionary* ini, const char* entry);
/*-------------------------------------------------------------------------*/
/**
@brief Finds out if a given entry exists in a dictionary
@param ini Dictionary to search
@param entry Name of the entry to look for
@return integer 1 if entry exists, 0 otherwise
Finds out if a given entry exists in the dictionary. Since sections
are stored as keys with NULL associated values, this is the only way
of querying for the presence of sections in a dictionary.
*/
/*--------------------------------------------------------------------------*/
int iniparser_find_entry(const dictionary* ini, const char* entry);
/*-------------------------------------------------------------------------*/
/**
@brief Parse an ini file and return an allocated dictionary object
@param ininame Name of the ini file to read.
@return Pointer to newly allocated dictionary
This is the parser for ini files. This function is called, providing
the name of the file to be read. It returns a dictionary object that
should not be accessed directly, but through accessor functions
instead.
Iff the value is a quoted string it supports some escape sequences:
- \" or ' : the quote character
(e.g. 'String with "Quotes"' or "String with 'Quotes'")
- \ : the backslash character (e.g. "C:\tmp")
Escape sequences always start with a backslash. Additional escape sequences
might be added in the future. Backslash characters must be escaped. Any other
sequence then those outlined above is invalid and may lead to unpredictable
results.
The returned dictionary must be freed using iniparser_freedict().
*/
/*--------------------------------------------------------------------------*/
dictionary* iniparser_load(const char* ininame);
/*-------------------------------------------------------------------------*/
/**
@brief Parse an ini file and return an allocated dictionary object
@param in File to read.
@param ininame Name of the ini file to read (only used for nicer error messages)
@return Pointer to newly allocated dictionary
This is the parser for ini files. This function is called, providing
the file to be read. It returns a dictionary object that should not
be accessed directly, but through accessor functions instead.
Iff the value is a quoted string it supports some escape sequences:
- \" or ' : the quote character
(e.g. 'String with "Quotes"' or "String with 'Quotes'")
- \ : the backslash character (e.g. "C:\tmp")
Escape sequences always start with a backslash. Additional escape sequences
might be added in the future. Backslash characters must be escaped. Any other
sequence then those outlined above is invalid and may lead to unpredictable
results.
The returned dictionary must be freed using iniparser_freedict().
*/
/*--------------------------------------------------------------------------*/
dictionary* iniparser_load_file(FILE* in, const char* ininame);
/*-------------------------------------------------------------------------*/
/**
@brief Free all memory associated to an ini dictionary
@param d Dictionary to free
Free all memory associated to an ini dictionary.
It is mandatory to call this function before the dictionary object
gets out of the current context.
*/
/*--------------------------------------------------------------------------*/
void iniparser_freedict(dictionary* d);
#ifdef __cplusplus
}

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

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

466
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 "pafinc.h"
#include <app_settings.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";
@ -16,177 +16,184 @@ paf::Plugin* g_configPlugin;
sce::AppSettings* g_appSettings;
sce::AppSettings::Interface* g_appSetIf;
struct Config {
paf::string m_base_path;
paf::string m_cd_path;
paf::string m_save_path;
int m_transition_type;
int m_texture_quality;
int m_model_quality;
int m_touch_scheme;
bool m_wide_view_angle;
bool m_music;
bool m_3d_sound;
bool m_haptic;
bool m_draw_cursor;
bool m_texture_load;
paf::string m_texture_path;
float m_max_lod;
int m_max_actors;
float m_frame_delta;
paf::string m_base_path;
paf::string m_cd_path;
paf::string m_save_path;
int m_transition_type;
int m_texture_quality;
int m_model_quality;
int m_touch_scheme;
bool m_wide_view_angle;
bool m_music;
bool m_3d_sound;
bool m_haptic;
bool m_draw_cursor;
bool m_texture_load;
paf::string m_texture_path;
float m_max_lod;
int m_max_actors;
float m_frame_delta;
void Init() {
m_frame_delta = 10.0f;
m_transition_type = 3; // 3: Mosaic
m_wide_view_angle = true;
m_music = true;
m_3d_sound = true;
m_haptic = true;
m_touch_scheme = 2;
m_texture_load = true;
m_texture_path = "/textures/";
m_model_quality = 2;
m_texture_quality = 1;
m_max_lod = 3.5f;
m_max_actors = 20;
}
void Init()
{
m_frame_delta = 10.0f;
m_transition_type = 3; // 3: Mosaic
m_wide_view_angle = true;
m_music = true;
m_3d_sound = true;
m_haptic = true;
m_touch_scheme = 2;
m_texture_load = true;
m_texture_path = "/textures/";
m_model_quality = 2;
m_texture_quality = 1;
m_max_lod = 3.5f;
m_max_actors = 20;
}
void LoadIni() {
dictionary* dict = iniparser_load(g_iniPath);
if (!dict) {
dict = dictionary_new(0);
}
void LoadIni()
{
dictionary* dict = iniparser_load(g_iniPath);
if (!dict) {
dict = dictionary_new(0);
}
#define GET_INT(x, name) x = iniparser_getint(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)
GET_STRING(m_base_path, "isle:diskpath");
GET_STRING(m_cd_path, "isle:cdpath");
GET_STRING(m_save_path, "isle:savepath");
GET_STRING(m_base_path, "isle:diskpath");
GET_STRING(m_cd_path, "isle:cdpath");
GET_STRING(m_save_path, "isle:savepath");
//m_display_bit_depth = iniparser_getint(dict, "isle:Display Bit Depth", -1);
//GET_BOOLEAN(m_flip_surfaces, "isle:Flip Surfaces");
//GET_BOOLEAN(m_full_screen, "isle:Full Screen");
//GET_BOOLEAN(m_exclusive_full_screen, "isle:Exclusive Full Screen");
GET_INT(m_transition_type, "isle:Transition Type");
GET_INT(m_touch_scheme, "isle:Touch Scheme");
//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_3d_sound, "isle:3DSound");
GET_BOOLEAN(m_draw_cursor, "isle:Draw Cursor");
GET_INT(m_model_quality, "isle:Island Quality");
GET_INT(m_texture_quality, "isle:Island Texture");
//GET_BOOLEAN(m_use_joystick, "isle:UseJoystick");
GET_BOOLEAN(m_haptic, "isle:Haptic");
GET_BOOLEAN(m_music, "isle:Music");
//GET_INT(m_joystick_index, "isle:JoystickIndex");
GET_FLOAT(m_max_lod, "isle:Max LOD");
GET_INT(m_max_actors, "isle:Max Allowed Extras");
GET_BOOLEAN(m_texture_load, "extensions:texture loader");
GET_STRING(m_texture_path, "texture loader:texture path");
//GET_INT(m_aspect_ratio, "isle:Aspect Ratio");
//GET_INT(m_x_res, "isle:Horizontal Resolution");
//GET_INT(m_y_res, "isle:Vertical Resolution");
GET_FLOAT(m_frame_delta, "isle:Frame Delta");
// m_display_bit_depth = iniparser_getint(dict, "isle:Display Bit Depth", -1);
// GET_BOOLEAN(m_flip_surfaces, "isle:Flip Surfaces");
// GET_BOOLEAN(m_full_screen, "isle:Full Screen");
// GET_BOOLEAN(m_exclusive_full_screen, "isle:Exclusive Full Screen");
GET_INT(m_transition_type, "isle:Transition Type");
GET_INT(m_touch_scheme, "isle:Touch Scheme");
// 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_3d_sound, "isle:3DSound");
GET_BOOLEAN(m_draw_cursor, "isle:Draw Cursor");
GET_INT(m_model_quality, "isle:Island Quality");
GET_INT(m_texture_quality, "isle:Island Texture");
// GET_BOOLEAN(m_use_joystick, "isle:UseJoystick");
GET_BOOLEAN(m_haptic, "isle:Haptic");
GET_BOOLEAN(m_music, "isle:Music");
// GET_INT(m_joystick_index, "isle:JoystickIndex");
GET_FLOAT(m_max_lod, "isle:Max LOD");
GET_INT(m_max_actors, "isle:Max Allowed Extras");
GET_BOOLEAN(m_texture_load, "extensions:texture loader");
GET_STRING(m_texture_path, "texture loader:texture path");
// GET_INT(m_aspect_ratio, "isle:Aspect Ratio");
// GET_INT(m_x_res, "isle:Horizontal Resolution");
// GET_INT(m_y_res, "isle:Vertical Resolution");
GET_FLOAT(m_frame_delta, "isle:Frame Delta");
#undef GET_INT
#undef GET_FLOAT
#undef GET_STRING
#undef GET_BOOLEAN
iniparser_freedict(dict);
}
iniparser_freedict(dict);
}
bool SaveIni() {
dictionary* dict = dictionary_new(0);
bool SaveIni()
{
dictionary* dict = dictionary_new(0);
char buffer[128];
char buffer[128];
#define SetIniBool(NAME, VALUE) iniparser_set(dict, NAME, VALUE ? "true" : "false")
#define SetIniInt(NAME, VALUE) { \
sceClibPrintf(buffer, "%d", VALUE); \
iniparser_set(dict, NAME, buffer); \
}
#define SetIniFloat(NAME, VALUE) { \
sceClibPrintf(buffer, "%f", VALUE); \
iniparser_set(dict, NAME, buffer); \
}
#define SetIniInt(NAME, VALUE) \
{ \
sceClibPrintf(buffer, "%d", VALUE); \
iniparser_set(dict, NAME, buffer); \
}
#define SetIniFloat(NAME, VALUE) \
{ \
sceClibPrintf(buffer, "%f", VALUE); \
iniparser_set(dict, NAME, buffer); \
}
#define SetString(NAME, VALUE) iniparser_set(dict, NAME, VALUE)
SetIniInt("isle:Display Bit Depth", 32);
SetIniBool("isle:Flip Surfaces", false);
SetIniBool("isle:Full Screen", true);
SetIniBool("isle:Exclusive Full Screen", true);
SetIniBool("isle:Wide View Angle", true); // option?
SetIniInt("isle:Display Bit Depth", 32);
SetIniBool("isle:Flip Surfaces", false);
SetIniBool("isle:Full Screen", true);
SetIniBool("isle:Exclusive Full Screen", true);
SetIniBool("isle:Wide View Angle", true); // option?
SetIniInt("isle:Transition Type", m_transition_type);
SetIniInt("isle:Touch Scheme", m_touch_scheme);
SetIniInt("isle:Transition Type", m_transition_type);
SetIniInt("isle:Touch Scheme", m_touch_scheme);
SetIniBool("isle:3DSound", m_3d_sound);
SetIniBool("isle:Music", m_music);
SetIniBool("isle:Haptic", m_haptic);
SetIniBool("isle:3DSound", m_3d_sound);
SetIniBool("isle:Music", m_music);
SetIniBool("isle:Haptic", m_haptic);
SetIniBool("isle:UseJoystick", true);
SetIniInt("isle:JoystickIndex", 0);
SetIniBool("isle:Draw Cursor", m_draw_cursor);
SetIniBool("isle:UseJoystick", true);
SetIniInt("isle:JoystickIndex", 0);
SetIniBool("isle:Draw Cursor", m_draw_cursor);
SetIniBool("extensions:texture loader", m_texture_load);
SetString("texture loader:texture path", m_texture_path.c_str());
SetIniBool("extensions:texture loader", m_texture_load);
SetString("texture loader:texture path", m_texture_path.c_str());
SetIniBool("isle:Back Buffers in Video RAM", true);
SetIniInt("isle:Island Quality", m_model_quality);
SetIniInt("isle:Island Texture", m_texture_quality);
SetIniBool("isle:Back Buffers in Video RAM", true);
SetIniFloat("isle:Max LOD", m_max_lod);
SetIniInt("isle:Max Allowed Extras", m_max_actors);
SetIniInt("isle:Island Quality", m_model_quality);
SetIniInt("isle:Island Texture", m_texture_quality);
SetIniInt("isle:Aspect Ratio", 0);
SetIniInt("isle:Horizontal Resolution", 640);
SetIniInt("isle:Vertical Resolution", 480);
SetIniFloat("isle:Frame Delta", 10.0f);
SetIniFloat("isle:Max LOD", m_max_lod);
SetIniInt("isle:Max Allowed Extras", m_max_actors);
SetIniInt("isle:Aspect Ratio", 0);
SetIniInt("isle:Horizontal Resolution", 640);
SetIniInt("isle:Vertical Resolution", 480);
SetIniFloat("isle:Frame Delta", 10.0f);
#undef SetIniBool
#undef SetIniInt
#undef SetIniFloat
#undef SetString
FILE* fd = fopen(g_iniPath, "w");
if(fd) {
iniparser_dump_ini(dict, fd);
}
iniparser_freedict(dict);
FILE* fd = fopen(g_iniPath, "w");
if (fd) {
iniparser_dump_ini(dict, fd);
}
iniparser_freedict(dict);
return true;
}
return true;
}
void ToSettings(sce::AppSettings* appSettings) {
appSettings->SetString("data_path", this->m_base_path.c_str());
appSettings->SetString("save_path", this->m_save_path.c_str());
}
void ToSettings(sce::AppSettings* appSettings)
{
appSettings->SetString("data_path", this->m_base_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;
paf::Plugin* load_config_plugin(paf::Framework* paf_fw) {
paf::Plugin::InitParam pluginParam;
pluginParam.name = "config_plugin";
pluginParam.caller_name = "__main__";
pluginParam.resource_file = "app0:/config_plugin.rco";
pluginParam.init_func = NULL;
pluginParam.start_func = NULL;
pluginParam.stop_func = NULL;
pluginParam.exit_func = NULL;
paf::Plugin::LoadSync(pluginParam);
return paf_fw->FindPlugin("config_plugin");
paf::Plugin* load_config_plugin(paf::Framework* paf_fw)
{
paf::Plugin::InitParam pluginParam;
pluginParam.name = "config_plugin";
pluginParam.caller_name = "__main__";
pluginParam.resource_file = "app0:/config_plugin.rco";
pluginParam.init_func = NULL;
pluginParam.start_func = NULL;
pluginParam.stop_func = NULL;
pluginParam.exit_func = NULL;
paf::Plugin::LoadSync(pluginParam);
return paf_fw->FindPlugin("config_plugin");
}
int load_app_settings_plugin() {
paf::Plugin::InitParam pluginParam;
int load_app_settings_plugin()
{
paf::Plugin::InitParam pluginParam;
sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_BXCE);
sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_INI_FILE_PROCESSOR);
sceSysmoduleLoadModuleInternal(SCE_SYSMODULE_INTERNAL_COMMON_GUI_DIALOG);
@ -201,102 +208,102 @@ int load_app_settings_plugin() {
pluginParam.exit_func = sce::AppSettings::PluginExitCB;
pluginParam.module_file = "vs0:vsh/common/app_settings.suprx";
pluginParam.draw_priority = 0x96;
paf::Plugin::LoadSync(pluginParam);
return 0;
paf::Plugin::LoadSync(pluginParam);
return 0;
}
bool do_launch = false;
void save_and_exit() {
g_config.FromSettings(g_appSettings);
g_config.SaveIni();
g_fw->RequestShutdown();
}
void save_and_launch() {
g_config.FromSettings(g_appSettings);
g_config.SaveIni();
g_fw->RequestShutdown();
do_launch = true;
}
void CBOnStartPageTransition(const char *elementId, int32_t type)
void save_and_exit()
{
g_config.FromSettings(g_appSettings);
g_config.SaveIni();
g_fw->RequestShutdown();
}
void CBOnPageActivate(const char *elementId, int32_t type)
void save_and_launch()
{
g_config.FromSettings(g_appSettings);
g_config.SaveIni();
g_fw->RequestShutdown();
do_launch = true;
}
void CBOnPageDeactivate(const char *elementId, int32_t type)
void CBOnStartPageTransition(const char* elementId, int32_t type)
{
}
int32_t CBOnCheckVisible(const char *elementId, bool *pIsVisible)
void CBOnPageActivate(const char* elementId, int32_t type)
{
}
void CBOnPageDeactivate(const char* elementId, int32_t type)
{
}
int32_t CBOnCheckVisible(const char* elementId, bool* pIsVisible)
{
*pIsVisible = true;
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;
}
int32_t CBOnPostCreate(const char *elementId, paf::ui::Widget *widget)
int32_t CBOnPostCreate(const char* elementId, paf::ui::Widget* widget)
{
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) {
save_and_exit();
return SCE_OK;
}
if (sce_paf_strcmp(elementId, "save_exit_button") == 0) {
save_and_exit();
return SCE_OK;
}
if(sce_paf_strcmp(elementId, "save_launch_button") == 0) {
save_and_launch();
return SCE_OK;
}
if (sce_paf_strcmp(elementId, "save_launch_button") == 0) {
save_and_launch();
return SCE_OK;
}
sceClibPrintf("OnPress %s %s\n", elementId, newValue);
sceClibPrintf("OnPress %s %s\n", elementId, newValue);
return SCE_OK;
}
int32_t CBOnPress2(const char *elementId, const char *newValue)
int32_t CBOnPress2(const char* elementId, const char* newValue)
{
return SCE_OK;
}
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);
if(res[0] != 0) {
return res;
}
return L"unknown string";
wchar_t* res = g_configPlugin->GetString(elementId);
if (res[0] != 0) {
return res;
}
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;
}
void open_settings() {
g_config.Init();
g_config.LoadIni();
g_config.ToSettings(g_appSettings);
void open_settings()
{
g_config.Init();
g_config.LoadIni();
g_config.ToSettings(g_appSettings);
sce::AppSettings::InterfaceCallbacks ifCb;
sce::AppSettings::InterfaceCallbacks ifCb;
ifCb.onStartPageTransitionCb = CBOnStartPageTransition;
ifCb.onPageActivateCb = CBOnPageActivate;
ifCb.onPageDeactivateCb = CBOnPageDeactivate;
@ -306,22 +313,21 @@ void open_settings() {
ifCb.onPressCb = CBOnPress;
ifCb.onPressCb2 = CBOnPress2;
ifCb.onTermCb = CBOnTerm;
ifCb.onGetStringCb = (sce::AppSettings::InterfaceCallbacks::GetStringCallback)CBOnGetString;
ifCb.onGetStringCb = (sce::AppSettings::InterfaceCallbacks::GetStringCallback) CBOnGetString;
ifCb.onGetSurfaceCb = CBOnGetSurface;
paf::wstring msg_save_exit(g_configPlugin->GetString("msg_save_exit"));
paf::wstring msg_save_launch(g_configPlugin->GetString("msg_save_launch"));
paf::wstring msg_exit(g_configPlugin->GetString("msg_exit"));
paf::wstring msg_save_exit(g_configPlugin->GetString("msg_save_exit"));
paf::wstring msg_save_launch(g_configPlugin->GetString("msg_save_launch"));
paf::wstring msg_exit(g_configPlugin->GetString("msg_exit"));
paf::Plugin* appSetPlug = paf::Plugin::Find("app_settings_plugin");
g_appSetIf = (sce::AppSettings::Interface *)appSetPlug->GetInterface(1);
g_appSetIf->Show(&ifCb);
g_appSetIf->AddFooterButton("save_exit_button", &msg_save_exit, 1);
g_appSetIf->AddFooterButton("save_launch_button", &msg_save_launch, 2);
g_appSetIf->ShowFooter();
paf::Plugin* appSetPlug = paf::Plugin::Find("app_settings_plugin");
g_appSetIf = (sce::AppSettings::Interface*) appSetPlug->GetInterface(1);
g_appSetIf->Show(&ifCb);
g_appSetIf->AddFooterButton("save_exit_button", &msg_save_exit, 1);
g_appSetIf->AddFooterButton("save_launch_button", &msg_save_launch, 2);
g_appSetIf->ShowFooter();
}
#define MAX_PATH_LENGTH 256
static int64_t g_OpStorage[SCE_FIOS_OP_STORAGE_SIZE(64, MAX_PATH_LENGTH) / sizeof(int64_t) + 1];
@ -329,9 +335,10 @@ 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_DHStorage[SCE_FIOS_DH_STORAGE_SIZE(32, MAX_PATH_LENGTH) / sizeof(int64_t) + 1];
void init_fios2() {
sceSysmoduleLoadModule(SCE_SYSMODULE_FIOS2);
SceFiosParams params = SCE_FIOS_PARAMS_INITIALIZER;
void init_fios2()
{
sceSysmoduleLoadModule(SCE_SYSMODULE_FIOS2);
SceFiosParams params = SCE_FIOS_PARAMS_INITIALIZER;
params.opStorage.pPtr = g_OpStorage;
params.opStorage.length = sizeof(g_OpStorage);
params.chunkStorage.pPtr = g_ChunkStorage;
@ -349,47 +356,48 @@ void init_fios2() {
params.threadPriority[SCE_FIOS_IO_THREAD] = 64;
params.threadPriority[SCE_FIOS_CALLBACK_THREAD] = 191;
params.threadPriority[SCE_FIOS_DECOMPRESSOR_THREAD] = 191;
int ret = sceFiosInitialize(&params);
if(ret < 0) {
sceClibPrintf("sceFiosInitialize: %08x\n", ret);
}
int ret = sceFiosInitialize(&params);
if (ret < 0) {
sceClibPrintf("sceFiosInitialize: %08x\n", ret);
}
}
int paf_main(void) {
init_fios2();
int paf_main(void)
{
init_fios2();
paf::Framework::InitParam fwParam;
paf::Framework::InitParam fwParam;
fwParam.mode = paf::Framework::Mode_Normal;
paf::Framework* paf_fw = new paf::Framework(fwParam);
g_fw = paf_fw;
paf::Framework* paf_fw = new paf::Framework(fwParam);
g_fw = paf_fw;
paf_fw->LoadCommonResourceSync();
load_app_settings_plugin();
paf::Plugin* configPlugin = load_config_plugin(paf_fw);
g_configPlugin = configPlugin;
configPlugin->SetLocale(Locale_EN);
paf_fw->LoadCommonResourceSync();
load_app_settings_plugin();
paf::Plugin* configPlugin = load_config_plugin(paf_fw);
g_configPlugin = configPlugin;
configPlugin->SetLocale(Locale_EN);
size_t fileSize = 0;
const char *mimeType = nullptr;
auto settingsXmlFile = configPlugin->GetResource()->GetFile("settings.xml", &fileSize, &mimeType);
size_t fileSize = 0;
const char* mimeType = nullptr;
auto settingsXmlFile = configPlugin->GetResource()->GetFile("settings.xml", &fileSize, &mimeType);
sce::AppSettings::InitParam settingsParam;
settingsParam.xml_file = settingsXmlFile;
settingsParam.alloc_cb = sce_paf_malloc;
sce::AppSettings::InitParam settingsParam;
settingsParam.xml_file = settingsXmlFile;
settingsParam.alloc_cb = sce_paf_malloc;
settingsParam.free_cb = sce_paf_free;
settingsParam.realloc_cb = sce_paf_realloc;
settingsParam.safemem_offset = 0;
settingsParam.safemem_size = 0x400;
sce::AppSettings::GetInstance(settingsParam, &g_appSettings);
g_appSettings->Initialize();
sce::AppSettings::GetInstance(settingsParam, &g_appSettings);
g_appSettings->Initialize();
open_settings();
paf_fw->Run();
open_settings();
paf_fw->Run();
if(do_launch) {
sceAppMgrLoadExec("app0:/eboot.bin", NULL, NULL);
}
return 0;
if (do_launch) {
sceAppMgrLoadExec("app0:/eboot.bin", NULL, NULL);
}
return 0;
}

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

@ -1,4 +1,5 @@
#include "pafinc.h"
#include <psp2/kernel/clib.h>
#include <psp2/kernel/modulemgr.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__
// reject back touch panel
switch(event->type) {
switch (event->type) {
case SDL_EVENT_FINGER_MOTION:
case SDL_EVENT_FINGER_DOWN:
case SDL_EVENT_FINGER_UP:
case SDL_EVENT_FINGER_CANCELED:
if(event->tfinger.touchID == 2) return SDL_APP_CONTINUE;
if (event->tfinger.touchID == 2) {
return SDL_APP_CONTINUE;
}
}
#endif

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

@ -685,8 +685,12 @@ GXMRenderer::GXMRenderer(DWORD width, DWORD height, DWORD msaaSamples)
m_virtualHeight = height;
SceGxmMultisampleMode msaaMode = SCE_GXM_MULTISAMPLE_NONE;
if(msaaSamples == 2) msaaMode = SCE_GXM_MULTISAMPLE_2X;
if(msaaSamples == 4) msaaMode = SCE_GXM_MULTISAMPLE_4X;
if (msaaSamples == 2) {
msaaMode = SCE_GXM_MULTISAMPLE_2X;
}
if (msaaSamples == 4) {
msaaMode = SCE_GXM_MULTISAMPLE_4X;
}
int ret;
if (!gxm) {
@ -944,27 +948,30 @@ void GXMRenderer::DeferredDelete(int index)
this->m_buffers_delete[index].clear();
}
static int calculateMipLevels(int width, int height) {
if (width <= 0 || height <= 0) {
return 1;
}
int maxDim = (width > height) ? width : height;
return floor(log2(maxDim)) + 1;
static int calculateMipLevels(int width, int height)
{
if (width <= 0 || height <= 0) {
return 1;
}
int maxDim = (width > height) ? width : height;
return floor(log2(maxDim)) + 1;
}
static int nextPowerOf2(int n) {
if (n <= 0) return 1;
n--;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n++;
return n;
static int nextPowerOf2(int n)
{
if (n <= 0) {
return 1;
}
n--;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n++;
return n;
}
static void convertTextureMetadata(
SDL_Surface* surface,
bool isUi,
@ -988,8 +995,8 @@ static void convertTextureMetadata(
*textureAlignment = SCE_GXM_PALETTE_ALIGNMENT;
bytesPerPixel = 1;
if (!isUi) {
*mipLevels = calculateMipLevels(surface->w, surface->h);
}
*mipLevels = calculateMipLevels(surface->w, surface->h);
}
paletteSize = 256 * 4; // palette
break;
}
@ -1016,24 +1023,24 @@ static void convertTextureMetadata(
*mipLevels = 1; // look weird right now
size_t totalSize = 0;
int currentW = surface->w;
int currentH = surface->h;
int currentW = surface->w;
int currentH = surface->h;
// top mip
totalSize += (ALIGN(currentW, 8) * currentH) * bytesPerPixel;
for (size_t i = 1; i < *mipLevels; ++i) {
currentW = currentW > 1 ? currentW / 2 : 1;
currentH = currentH > 1 ? currentH / 2 : 1;
int po2W = nextPowerOf2(currentW * 2);
int po2H = nextPowerOf2(currentH * 2);
if (po2W < 8) {
po2W = 8;
}
totalSize += po2W * po2H * bytesPerPixel;
}
for (size_t i = 1; i < *mipLevels; ++i) {
currentW = currentW > 1 ? currentW / 2 : 1;
currentH = currentH > 1 ? currentH / 2 : 1;
int po2W = nextPowerOf2(currentW * 2);
int po2H = nextPowerOf2(currentH * 2);
if (po2W < 8) {
po2W = 8;
}
totalSize += po2W * po2H * bytesPerPixel;
}
if(paletteSize != 0) {
if (paletteSize != 0) {
int alignBytes = ALIGNMENT(totalSize, SCE_GXM_PALETTE_ALIGNMENT);
totalSize += alignBytes;
*paletteOffset = totalSize;
@ -1043,16 +1050,17 @@ static void convertTextureMetadata(
*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;
uint32_t currentLevelWidth = src->w;
uint32_t currentLevelHeight = src->h;
size_t bytesPerPixel = 4;
// copy top level mip (cant use transfer because this isnt gpu mapped)
size_t topLevelStride = ALIGN(currentLevelWidth, 8) * bytesPerPixel;
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);
memcpy(dstRow, srcRow, currentLevelWidth * bytesPerPixel);
}
@ -1063,26 +1071,38 @@ void copySurfaceToGxmARGB888(SDL_Surface* src, uint8_t* textureData, size_t dstS
uint8_t* nextLevelData = currentLevelData + (currentLevelSrcStride * currentLevelHeight);
sceGxmTransferDownscale(
SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // src format
currentLevelData, // src address
0, 0, currentLevelWidth, currentLevelHeight, // x,y,w,h
currentLevelSrcStride, // stride
SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // dst format
nextLevelData, // dst address
0, 0, // x,y
currentLevelDestStride, // stride
NULL, // sync
SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag
NULL // notification
SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // src format
currentLevelData, // src address
0,
0,
currentLevelWidth,
currentLevelHeight, // x,y,w,h
currentLevelSrcStride, // stride
SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR, // dst format
nextLevelData, // dst address
0,
0, // x,y
currentLevelDestStride, // stride
NULL, // sync
SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag
NULL // notification
);
currentLevelData = nextLevelData;
currentLevelWidth = currentLevelWidth / 2;
currentLevelHeight = currentLevelHeight / 2;
currentLevelData = nextLevelData;
currentLevelWidth = currentLevelWidth / 2;
currentLevelHeight = currentLevelHeight / 2;
}
}
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;
surface->GetPalette(&_palette);
auto palette = static_cast<DirectDrawPaletteImpl*>(_palette);
@ -1094,11 +1114,11 @@ void copySurfaceToGxmIndexed8(DirectDrawSurfaceImpl* surface, SDL_Surface* src,
uint32_t currentLevelWidth = src->w;
uint32_t currentLevelHeight = src->h;
size_t bytesPerPixel = 1;
// copy top level mip (cant use transfer because this isnt gpu mapped)
size_t topLevelStride = ALIGN(currentLevelWidth, 8) * bytesPerPixel;
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);
memcpy(dstRow, srcRow, currentLevelWidth * bytesPerPixel);
}
@ -1109,28 +1129,38 @@ void copySurfaceToGxmIndexed8(DirectDrawSurfaceImpl* surface, SDL_Surface* src,
uint8_t* nextLevelData = currentLevelData + (currentLevelSrcStride * currentLevelHeight);
sceGxmTransferDownscale(
SCE_GXM_TRANSFER_FORMAT_U8_R, // src format
currentLevelData, // src address
0, 0, currentLevelWidth, currentLevelHeight, // x,y,w,h
currentLevelSrcStride, // stride
SCE_GXM_TRANSFER_FORMAT_U8_R, // dst format
nextLevelData, // dst address
0, 0, // x,y
currentLevelDestStride, // stride
NULL, // sync
SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag
NULL // notification
SCE_GXM_TRANSFER_FORMAT_U8_R, // src format
currentLevelData, // src address
0,
0,
currentLevelWidth,
currentLevelHeight, // x,y,w,h
currentLevelSrcStride, // stride
SCE_GXM_TRANSFER_FORMAT_U8_R, // dst format
nextLevelData, // dst address
0,
0, // x,y
currentLevelDestStride, // stride
NULL, // sync
SCE_GXM_TRANSFER_FRAGMENT_SYNC, // flag
NULL // notification
);
currentLevelData = nextLevelData;
currentLevelWidth = currentLevelWidth / 2;
currentLevelHeight = currentLevelHeight / 2;
currentLevelData = nextLevelData;
currentLevelWidth = currentLevelWidth / 2;
currentLevelHeight = currentLevelHeight / 2;
}
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;
@ -1140,7 +1170,7 @@ void copySurfaceToGxm(DirectDrawSurfaceImpl* surface, uint8_t* textureData, size
break;
}
case SDL_PIXELFORMAT_INDEX8: {
copySurfaceToGxmIndexed8(surface, src, textureData, dstStride, textureData+paletteOffset, mipLevels);
copySurfaceToGxmIndexed8(surface, src, textureData, dstStride, textureData + paletteOffset, mipLevels);
break;
}
default: {
@ -1211,11 +1241,19 @@ Uint32 GXMRenderer::GetTextureId(IDirect3DRMTexture* iTexture, bool isUi, float
);
// 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);
SceGxmTexture gxmTexture;
SCE_ERR(sceGxmTextureInitLinear, &gxmTexture, textureData, gxmTextureFormat, textureWidth, textureHeight, mipLevels);
SCE_ERR(
sceGxmTextureInitLinear,
&gxmTexture,
textureData,
gxmTextureFormat,
textureWidth,
textureHeight,
mipLevels
);
if (isUi) {
sceGxmTextureSetMinFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT);
sceGxmTextureSetMagFilter(&gxmTexture, SCE_GXM_TEXTURE_FILTER_POINT);