mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-30 07:20:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

(WiiU) cleanups.

Browse Source
This commit is contained in:
aliaspider 2017-01-22 18:57:25 +01:00
parent ae0e519639
commit 272f7c0a85
61 changed files with 1383 additions and 3893 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
wiiu/wut/include/coreinit/alarm.h
View File

@ -4,62 +4,36 @@
#include "threadqueue.h"
#include "time.h"
/**
* \defgroup coreinit_alarms Alarms
* \ingroup coreinit
*
* The alarm family of functions are used for creating alarms which call
* a callback or wake up waiting threads after a period of time.
*
* Alarms can be one shot alarms which trigger once after a period of time,
* or periodic which trigger at regular intervals until they are cancelled.
*
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct OSAlarm OSAlarm;
typedef struct OSAlarmLink OSAlarmLink;
typedef struct OSAlarmQueue OSAlarmQueue;
typedef void (*OSAlarmCallback)(OSAlarm *, OSContext *);
#define OS_ALARM_QUEUE_TAG 0x614C6D51u
struct OSAlarmQueue
typedef struct OSAlarmQueue
{
//! Should always be set to the value OS_ALARM_QUEUE_TAG.
uint32_t tag;
//! Name set by OSInitAlarmQueueEx
const char *name;
UNKNOWN(4);
uint32_t __unknown;
OSThreadQueue threadQueue;
OSAlarm *head;
OSAlarm *tail;
};
CHECK_OFFSET(OSAlarmQueue, 0x00, tag);
CHECK_OFFSET(OSAlarmQueue, 0x04, name);
CHECK_OFFSET(OSAlarmQueue, 0x0c, threadQueue);
CHECK_OFFSET(OSAlarmQueue, 0x1c, head);
CHECK_OFFSET(OSAlarmQueue, 0x20, tail);
CHECK_SIZE(OSAlarmQueue, 0x24);
}OSAlarmQueue;
struct OSAlarmLink
typedef struct OSAlarmLink
{
OSAlarm *prev;
OSAlarm *next;
};
CHECK_OFFSET(OSAlarmLink, 0x00, prev);
CHECK_OFFSET(OSAlarmLink, 0x04, next);
CHECK_SIZE(OSAlarmLink, 0x08);
struct OSAlarm *prev;
struct OSAlarm *next;
}OSAlarmLink;
#define OS_ALARM_TAG 0x614C724Du
struct OSAlarm
typedef struct OSAlarm
{
//! Should always be set to the value OS_ALARM_TAG.
uint32_t tag;
@ -67,7 +41,7 @@ struct OSAlarm
//! Name set from OSCreateAlarmEx.
const char *name;
UNKNOWN(4);
uint32_t __unknown;
//! The callback to execute once the alarm is triggered.
OSAlarmCallback callback;
@ -75,7 +49,7 @@ struct OSAlarm
//! Used with OSCancelAlarms for bulk cancellation of alarms.
uint32_t group;
UNKNOWN(4);
uint32_t __unknown;
//! The time when the alarm will next be triggered.
OSTime nextFire;
@ -103,128 +77,21 @@ struct OSAlarm
//! The context the alarm was triggered on.
OSContext *context;
};
CHECK_OFFSET(OSAlarm, 0x00, tag);
CHECK_OFFSET(OSAlarm, 0x04, name);
CHECK_OFFSET(OSAlarm, 0x0c, callback);
CHECK_OFFSET(OSAlarm, 0x10, group);
CHECK_OFFSET(OSAlarm, 0x18, nextFire);
CHECK_OFFSET(OSAlarm, 0x20, link);
CHECK_OFFSET(OSAlarm, 0x28, period);
CHECK_OFFSET(OSAlarm, 0x30, start);
CHECK_OFFSET(OSAlarm, 0x38, userData);
CHECK_OFFSET(OSAlarm, 0x3c, state);
CHECK_OFFSET(OSAlarm, 0x40, threadQueue);
CHECK_OFFSET(OSAlarm, 0x50, alarmQueue);
CHECK_OFFSET(OSAlarm, 0x54, context);
CHECK_SIZE(OSAlarm, 0x58);
}OSAlarm;
/**
* Cancel an alarm.
*/
BOOL
OSCancelAlarm(OSAlarm *alarm);
/**
* Cancel all alarms which have a matching tag set by OSSetAlarmTag.
*
* \param group The alarm tag to cancel.
*/
void
OSCancelAlarms(uint32_t group);
/**
* Initialise an alarm structure.
*/
void
OSCreateAlarm(OSAlarm *alarm);
/**
* Initialise an alarm structure with a name.
*/
void
OSCreateAlarmEx(OSAlarm *alarm,
const char *name);
/**
* Return user data set by OSSetAlarmUserData.
*/
void *
OSGetAlarmUserData(OSAlarm *alarm);
/**
* Initialise an alarm queue structure.
*/
void
OSInitAlarmQueue(OSAlarmQueue *queue);
/**
* Initialise an alarm queue structure with a name.
*/
void
OSInitAlarmQueueEx(OSAlarmQueue *queue,
const char *name);
/**
* Set a one shot alarm to perform a callback after a set amount of time.
*
* \param alarm The alarm to set.
* \param time The duration until the alarm should be triggered.
* \param callback The alarm callback to call when the alarm is triggered.
*/
BOOL
OSSetAlarm(OSAlarm *alarm,
OSTime time,
OSAlarmCallback callback);
/**
* Set a repeated alarm to execute a callback every interval from start.
*
* \param alarm The alarm to set.
* \param start The duration until the alarm should first be triggered.
* \param interval The interval between triggers after the first trigger.
* \param callback The alarm callback to call when the alarm is triggered.
*/
BOOL
OSSetPeriodicAlarm(OSAlarm *alarm,
OSTime start,
OSTime interval,
OSAlarmCallback callback);
/**
* Set an alarm tag which is used in OSCancelAlarms for bulk cancellation.
*/
void
OSSetAlarmTag(OSAlarm *alarm,
uint32_t group);
/**
* Set alarm user data which is returned by OSGetAlarmUserData.
*/
void
OSSetAlarmUserData(OSAlarm *alarm,
void *data);
/**
* Sleep the current thread until the alarm has been triggered or cancelled.
*/
BOOL
OSWaitAlarm(OSAlarm *alarm);
void OSCreateAlarm(OSAlarm *alarm);
void OSCreateAlarmEx(OSAlarm *alarm, const char *name);
void OSSetAlarmUserData(OSAlarm *alarm, void *data);
void *OSGetAlarmUserData(OSAlarm *alarm);
void OSInitAlarmQueue(OSAlarmQueue *queue);
void OSInitAlarmQueueEx(OSAlarmQueue *queue, const char *name);
BOOL OSSetAlarm(OSAlarm *alarm, OSTime time, OSAlarmCallback callback);
BOOL OSSetPeriodicAlarm(OSAlarm *alarm, OSTime start, OSTime interval, OSAlarmCallback callback);
void OSSetAlarmTag(OSAlarm *alarm, uint32_t group);
BOOL OSCancelAlarm(OSAlarm *alarm);
void OSCancelAlarms(uint32_t group);
BOOL OSWaitAlarm(OSAlarm *alarm);
#ifdef __cplusplus
}
#endif
/** @} */

66
wiiu/wut/include/coreinit/atomic64.h
View File

@ -1,66 +1,22 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_atomic64 Atomic 64 bit
* \ingroup coreinit
*
* These functions are used for atomically operating on 64 bit values in memory.
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
uint64_t
OSGetAtomic64(uint64_t *ptr);
uint64_t
OSSetAtomic64(uint64_t *ptr,
uint64_t value);
BOOL
OSCompareAndSwapAtomic64(uint64_t *ptr,
uint64_t compare,
uint64_t value);
BOOL
OSCompareAndSwapAtomicEx64(uint64_t *ptr,
uint64_t compare,
uint64_t value,
uint64_t *old);
uint64_t
OSSwapAtomic64(uint64_t *ptr,
uint64_t value);
int64_t
OSAddAtomic64(int64_t *ptr,
int64_t value);
uint64_t
OSAndAtomic64(uint64_t *ptr,
uint64_t value);
uint64_t
OSOrAtomic64(uint64_t *ptr,
uint64_t value);
uint64_t
OSXorAtomic64(uint64_t *ptr,
uint64_t value);
BOOL
OSTestAndClearAtomic64(uint64_t *ptr,
uint32_t bit);
BOOL
OSTestAndSetAtomic64(uint64_t *ptr,
uint32_t bit);
uint64_t OSGetAtomic64(uint64_t *ptr);
uint64_t OSSetAtomic64(uint64_t *ptr, uint64_t value);
BOOL OSCompareAndSwapAtomic64(uint64_t *ptr, uint64_t compare, uint64_t value);
BOOL OSCompareAndSwapAtomicEx64(uint64_t *ptr, uint64_t compare, uint64_t value, uint64_t *old);
uint64_t OSSwapAtomic64(uint64_t *ptr, uint64_t value);
int64_t OSAddAtomic64(int64_t *ptr, int64_t value);
uint64_t OSAndAtomic64(uint64_t *ptr, uint64_t value);
uint64_t OSOrAtomic64(uint64_t *ptr, uint64_t value);
uint64_t OSXorAtomic64(uint64_t *ptr, uint64_t value);
BOOL OSTestAndClearAtomic64(uint64_t *ptr, uint32_t bit);
BOOL OSTestAndSetAtomic64(uint64_t *ptr, uint32_t bit);
#ifdef __cplusplus
}
#endif
/** @} */

118
wiiu/wut/include/coreinit/blockheap.h
View File

@ -2,12 +2,6 @@
#include <wut.h>
#include "memheap.h"
/**
* \defgroup coreinit_blockheap Block Heap
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -16,117 +10,65 @@ typedef struct MEMBlockHeapBlock MEMBlockHeapBlock;
typedef struct MEMBlockHeapTracking MEMBlockHeapTracking;
typedef struct MEMBlockHeap MEMBlockHeap;
struct MEMBlockHeapTracking
typedef struct MEMBlockHeapTracking
{
UNKNOWN(0x8);
//! Pointer to first memory block
uint32_t __unknown0;
uint32_t __unknown1;
MEMBlockHeapBlock *blocks;
//! Number of blocks in this tracking heap
uint32_t blockCount;
};
CHECK_OFFSET(MEMBlockHeapTracking, 0x08, blocks);
CHECK_OFFSET(MEMBlockHeapTracking, 0x0C, blockCount);
CHECK_SIZE(MEMBlockHeapTracking, 0x10);
} MEMBlockHeapTracking;
struct MEMBlockHeapBlock
typedef struct MEMBlockHeapBlock
{
//! First address of the data region this block has allocated
void *start;
//! End address of the data region this block has allocated
void *end;
//! TRUE if the block is free, FALSE if allocated
BOOL isFree;
//! Link to previous block, note that this is only set for allocated blocks
MEMBlockHeapBlock *prev;
//! Link to next block, always set
MEMBlockHeapBlock *next;
};
CHECK_OFFSET(MEMBlockHeapBlock, 0x00, start);
CHECK_OFFSET(MEMBlockHeapBlock, 0x04, end);
CHECK_OFFSET(MEMBlockHeapBlock, 0x08, isFree);
CHECK_OFFSET(MEMBlockHeapBlock, 0x0c, prev);
CHECK_OFFSET(MEMBlockHeapBlock, 0x10, next);
CHECK_SIZE(MEMBlockHeapBlock, 0x14);
} MEMBlockHeapBlock;
struct MEMBlockHeap
typedef struct MEMBlockHeap
{
MEMHeapHeader header;
//! Default tracking heap, tracks only defaultBlock
MEMBlockHeapTracking defaultTrack;
//! Default block, used so we don't have an empty block list
MEMBlockHeapBlock defaultBlock;
//! First block in this heap
MEMBlockHeapBlock *firstBlock;
//! Last block in this heap
MEMBlockHeapBlock *lastBlock;
//! First free block
MEMBlockHeapBlock *firstFreeBlock;
//! Free block count
uint32_t numFreeBlocks;
};
CHECK_OFFSET(MEMBlockHeap, 0x00, header);
CHECK_OFFSET(MEMBlockHeap, 0x40, defaultTrack);
CHECK_OFFSET(MEMBlockHeap, 0x50, defaultBlock);
CHECK_OFFSET(MEMBlockHeap, 0x64, firstBlock);
CHECK_OFFSET(MEMBlockHeap, 0x68, lastBlock);
CHECK_OFFSET(MEMBlockHeap, 0x6C, firstFreeBlock);
CHECK_OFFSET(MEMBlockHeap, 0x70, numFreeBlocks);
CHECK_SIZE(MEMBlockHeap, 0x74);
} MEMBlockHeap;
MEMBlockHeap *
MEMInitBlockHeap(MEMBlockHeap *heap,
void *start,
void *end,
MEMBlockHeapTracking *blocks,
uint32_t size,
uint32_t flags);
MEMBlockHeap *MEMInitBlockHeap(MEMBlockHeap *heap,
void *start,
void *end,
MEMBlockHeapTracking *blocks,
uint32_t size,
uint32_t flags);
void *
MEMDestroyBlockHeap(MEMBlockHeap *heap);
void *MEMDestroyBlockHeap(MEMBlockHeap *heap);
int
MEMAddBlockHeapTracking(MEMBlockHeap *heap,
MEMBlockHeapTracking *tracking,
uint32_t size);
int MEMAddBlockHeapTracking(MEMBlockHeap *heap,
MEMBlockHeapTracking *tracking,
uint32_t size);
void *
MEMAllocFromBlockHeapAt(MEMBlockHeap *heap,
void *addr,
uint32_t size);
void *MEMAllocFromBlockHeapAt(MEMBlockHeap *heap,
void *addr,
uint32_t size);
void *
MEMAllocFromBlockHeapEx(MEMBlockHeap *heap,
uint32_t size,
int32_t align);
void *MEMAllocFromBlockHeapEx(MEMBlockHeap *heap,
uint32_t size,
int32_t align);
void
MEMFreeToBlockHeap(MEMBlockHeap *heap,
void *data);
void MEMFreeToBlockHeap(MEMBlockHeap *heap,
void *data);
uint32_t
MEMGetAllocatableSizeForBlockHeapEx(MEMBlockHeap *heap,
int32_t align);
uint32_t MEMGetAllocatableSizeForBlockHeapEx(MEMBlockHeap *heap,
int32_t align);
uint32_t
MEMGetTrackingLeftInBlockHeap(MEMBlockHeap *heap);
uint32_t MEMGetTrackingLeftInBlockHeap(MEMBlockHeap *heap);
uint32_t
MEMGetTotalFreeSizeForBlockHeap(MEMBlockHeap *heap);
uint32_t MEMGetTotalFreeSizeForBlockHeap(MEMBlockHeap *heap);
#ifdef __cplusplus
}
#endif
/** @} */

50
wiiu/wut/include/coreinit/cache.h
View File

@ -1,14 +1,6 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_cache Cache
* \ingroup coreinit
*
* Cache synchronisation functions.
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -17,25 +9,22 @@ extern "C" {
/**
* Equivalent to dcbi instruction.
*/
void
DCInvalidateRange(void *addr,
uint32_t size);
void DCInvalidateRange(void *addr,
uint32_t size);
/**
* Equivalent to dcbf, sync, eieio.
*/
void
DCFlushRange(void *addr,
uint32_t size);
void DCFlushRange(void *addr,
uint32_t size);
/**
* Equivalent to dcbst, sync, eieio.
*/
void
DCStoreRange(void *addr,
uint32_t size);
void DCStoreRange(void *addr,
uint32_t size);
/**
@ -43,9 +32,8 @@ DCStoreRange(void *addr,
*
* Does not perform sync, eieio like DCFlushRange.
*/
void
DCFlushRangeNoSync(void *addr,
uint32_t size);
void DCFlushRangeNoSync(void *addr,
uint32_t size);
/**
@ -53,36 +41,30 @@ DCFlushRangeNoSync(void *addr,
*
* Does not perform sync, eieio like DCStoreRange.
*/
void
DCStoreRangeNoSync(void *addr,
uint32_t size);
void DCStoreRangeNoSync(void *addr,
uint32_t size);
/**
* Equivalent to dcbz instruction.
*/
void
DCZeroRange(void *addr,
uint32_t size);
void DCZeroRange(void *addr,
uint32_t size);
/**
* Equivalent to dcbt instruction.
*/
void
DCTouchRange(void *addr,
uint32_t size);
void DCTouchRange(void *addr,
uint32_t size);
/**
* Equivalent to icbi instruction.
*/
void
ICInvalidateRange(void *addr,
uint32_t size);
void ICInvalidateRange(void *addr,
uint32_t size);
#ifdef __cplusplus
}
#endif
/** @} */

39
wiiu/wut/include/coreinit/condition.h
View File

@ -1,27 +1,15 @@
#pragma once
#include <wut.h>
#include "threadqueue.h"
/**
* \defgroup coreinit_cond Condition Variable
* \ingroup coreinit
*
* Standard condition variable implementation.
*
* Similar to <a href="http://en.cppreference.com/w/cpp/thread/condition_variable">std::condition_variable</a>.
* @{
*/
#include "mutex.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct OSCondition OSCondition;
typedef struct OSMutex OSMutex;
#define OS_CONDITION_TAG 0x634E6456u
struct OSCondition
typedef struct OSCondition
{
//! Should always be set to the value OS_CONDITION_TAG.
uint32_t tag;
@ -29,29 +17,22 @@ struct OSCondition
//! Name set by OSInitCondEx.
const char *name;
UNKNOWN(4);
uint32_t __unknown;
//! Queue of threads currently waiting on condition with OSWaitCond.
OSThreadQueue queue;
};
CHECK_OFFSET(OSCondition, 0x00, tag);
CHECK_OFFSET(OSCondition, 0x04, name);
CHECK_OFFSET(OSCondition, 0x0c, queue);
CHECK_SIZE(OSCondition, 0x1c);
}OSCondition;
/**
* Initialise a condition variable structure.
*/
void
OSInitCond(OSCondition *condition);
void OSInitCond(OSCondition *condition);
/**
* Initialise a condition variable structure with a name.
*/
void
OSInitCondEx(OSCondition *condition,
void OSInitCondEx(OSCondition *condition,
const char *name);
@ -63,8 +44,7 @@ OSInitCondEx(OSCondition *condition,
*
* Similar to <a href="http://en.cppreference.com/w/cpp/thread/condition_variable/wait">std::condition_variable::wait</a>.
*/
void
OSWaitCond(OSCondition *condition,
void OSWaitCond(OSCondition *condition,
OSMutex *mutex);
@ -73,12 +53,9 @@ OSWaitCond(OSCondition *condition,
*
* Similar to <a href="http://en.cppreference.com/w/cpp/thread/condition_variable/notify_all">std::condition_variable::notify_all</a>.
*/
void
OSSignalCond(OSCondition *condition);
void OSSignalCond(OSCondition *condition);
#ifdef __cplusplus
}
#endif
/** @} */

43
wiiu/wut/include/coreinit/coroutine.h
View File

@ -1,19 +1,11 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_coroutine Coroutines
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct OSCoroutine OSCoroutine;
struct OSCoroutine
typedef struct OSCoroutine
{
uint32_t nia;
uint32_t cr;
@ -24,36 +16,13 @@ struct OSCoroutine
uint32_t gpr[18];
double fpr[18];
double psr[18];
};
CHECK_OFFSET(OSCoroutine, 0x00, nia);
CHECK_OFFSET(OSCoroutine, 0x04, cr);
CHECK_OFFSET(OSCoroutine, 0x08, ugqr1);
CHECK_OFFSET(OSCoroutine, 0x0C, stack);
CHECK_OFFSET(OSCoroutine, 0x10, sda2Base);
CHECK_OFFSET(OSCoroutine, 0x14, sdaBase);
CHECK_OFFSET(OSCoroutine, 0x18, gpr);
CHECK_OFFSET(OSCoroutine, 0x60, fpr);
CHECK_OFFSET(OSCoroutine, 0xF0, psr);
CHECK_SIZE(OSCoroutine, 0x180);
}OSCoroutine;
void
OSInitCoroutine(OSCoroutine *coroutine,
void *entry,
void *stack);
uint32_t
OSLoadCoroutine(OSCoroutine *coroutine,
uint32_t result);
uint32_t
OSSaveCoroutine(OSCoroutine *coroutine);
void
OSSwitchCoroutine(OSCoroutine *from,
OSCoroutine *to);
void OSInitCoroutine(OSCoroutine *coroutine, void *entry, void *stack);
uint32_t OSLoadCoroutine(OSCoroutine *coroutine, uint32_t result);
uint32_t OSSaveCoroutine(OSCoroutine *coroutine);
void OSSwitchCoroutine(OSCoroutine *from, OSCoroutine *to);
#ifdef __cplusplus
}
#endif
/** @} */

31
wiiu/wut/include/coreinit/debug.h
View File

@ -1,38 +1,15 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_debug Debug
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void
OSConsoleWrite(const char *msg,
uint32_t size);
void
OSReport(const char *fmt, ...);
void
OSPanic(const char *file,
uint32_t line,
const char *fmt, ...);
void
OSFatal(const char *msg);
void OSConsoleWrite(const char *msg, uint32_t size);
void OSReport(const char *fmt, ...);
void OSPanic(const char *file, uint32_t line, const char *fmt, ...);
void OSFatal(const char *msg);
#ifdef __cplusplus
}
#endif
/** @} */

62
wiiu/wut/include/coreinit/dynload.h
View File

@ -3,72 +3,20 @@
#include "thread.h"
#include "time.h"
/**
* \defgroup coreinit_dynload Dynamic Loading
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef void *OSDynLoadModule;
typedef int (*OSDynLoadAllocFn)(int size, int align, void **outAddr);
typedef void (*OSDynLoadFreeFn)(void *addr);
/**
* Set the allocator function to use for dynamic loading.
*/
int32_t
OSDynLoad_SetAllocator(OSDynLoadAllocFn allocFn,
OSDynLoadFreeFn freeFn);
/**
* Get the allocator function used for dynamic loading.
*/
int32_t
OSDynLoad_GetAllocator(OSDynLoadAllocFn *outAllocFn,
OSDynLoadFreeFn *outFreeFn);
/**
* Load a module.
*
* If the module is already loaded, increase reference count.
* Similar to LoadLibrary on Windows.
*/
int32_t
OSDynLoad_Acquire(char const *name,
OSDynLoadModule *outModule);
/**
* Retrieve the address of a function or data export from a module.
*
* Similar to GetProcAddress on Windows.
*/
int32_t
OSDynLoad_FindExport(OSDynLoadModule module,
int32_t isData,
char const *name,
void **outAddr);
/**
* Free a module handle returned from OSDynLoad_Acquire.
*
* Will decrease reference count and only unload the module if count reaches 0.
* Similar to FreeLibrary on Windows.
*/
void
OSDynLoad_Release(OSDynLoadModule module);
int32_t OSDynLoad_SetAllocator(OSDynLoadAllocFn allocFn, OSDynLoadFreeFn freeFn);
int32_t OSDynLoad_GetAllocator(OSDynLoadAllocFn *outAllocFn, OSDynLoadFreeFn *outFreeFn);
int32_t OSDynLoad_Acquire(char const *name, OSDynLoadModule *outModule);
int32_t OSDynLoad_FindExport(OSDynLoadModule module, int32_t isData, char const *name, void **outAddr);
void OSDynLoad_Release(OSDynLoadModule module);
#ifdef __cplusplus
}
#endif
/** @} */

45
wiiu/wut/include/coreinit/event.h
View File

@ -3,16 +3,6 @@
#include "thread.h"
#include "threadqueue.h"
/**
* \defgroup coreinit_event Event Object
* \ingroup coreinit
*
* Standard event object implementation. There are two supported event object modes, check OSEventMode.
*
* Similar to Windows <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms682655(v=vs.85).aspx">Event Objects</a>.
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -35,12 +25,8 @@ struct OSEvent
//! Should always be set to the value OS_EVENT_TAG.
uint32_t tag;
//! Name set by OSInitEventEx.
const char *name;
UNKNOWN(4);
//! The current value of the event object.
uint32_t __unknown;
BOOL value;
//! The threads currently waiting on this event object with OSWaitEvent.
@ -49,32 +35,18 @@ struct OSEvent
//! The mode of the event object, set by OSInitEvent.
OSEventMode mode;
};
CHECK_OFFSET(OSEvent, 0x0, tag);
CHECK_OFFSET(OSEvent, 0x4, name);
CHECK_OFFSET(OSEvent, 0xc, value);
CHECK_OFFSET(OSEvent, 0x10, queue);
CHECK_OFFSET(OSEvent, 0x20, mode);
CHECK_SIZE(OSEvent, 0x24);
/**
* Initialise an event object with value and mode.
*/
void
OSInitEvent(OSEvent *event,
BOOL value,
OSEventMode mode);
void OSInitEvent(OSEvent *event, BOOL value, OSEventMode mode);
/**
* Initialise an event object with value, mode and name.
*/
void
OSInitEventEx(OSEvent *event,
BOOL value,
OSEventMode mode,
char *name);
void OSInitEventEx(OSEvent *event, BOOL value, OSEventMode mode, char *name);
/**
* Signals the event.
@ -89,8 +61,7 @@ OSInitEventEx(OSEvent *event,
*
* Similar to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms686211(v=vs.85).aspx">SetEvent</a>.
*/
void
OSSignalEvent(OSEvent *event);
void OSSignalEvent(OSEvent *event);
/**
* Signals all threads waiting on an event.
@ -117,8 +88,7 @@ OSSignalEventAll(OSEvent *event);
*
* Similar to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx">WaitForSingleObject</a>.
*/
void
OSWaitEvent(OSEvent *event);
void OSWaitEvent(OSEvent *event);
/**
@ -126,8 +96,7 @@ OSWaitEvent(OSEvent *event);
*
* Similar to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms685081(v=vs.85).aspx">ResetEvent</a>.
*/
void
OSResetEvent(OSEvent *event);
void OSResetEvent(OSEvent *event);
/**
@ -142,5 +111,3 @@ OSWaitEventWithTimeout(OSEvent *event,
#ifdef __cplusplus
}
#endif
/** @} */

17
wiiu/wut/include/coreinit/exception.h
View File

@ -1,12 +1,6 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_exception Exception Handling
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -32,17 +26,10 @@ typedef enum OSExceptionType
OS_EXCEPTION_TYPE_ICI = 14,
} OSExceptionType;
OSExceptionCallbackFn
OSSetExceptionCallback(OSExceptionType exceptionType,
OSExceptionCallbackFn callback);
OSExceptionCallbackFn
OSSetExceptionCallbackEx(UNKNOWN_ARG,
OSExceptionType exceptionType,
OSExceptionCallbackFn callback);
OSExceptionCallbackFn OSSetExceptionCallback(OSExceptionType exceptionType, OSExceptionCallbackFn callback);
OSExceptionCallbackFn OSSetExceptionCallbackEx(int unknown, OSExceptionType exceptionType, OSExceptionCallbackFn callback);
#ifdef __cplusplus
}
#endif
/** @} */

7
wiiu/wut/include/coreinit/exit.h
View File

@ -1,12 +1,6 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_exit Exit
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -21,4 +15,3 @@ _Exit();
}
#endif
/** @} */

108
wiiu/wut/include/coreinit/expandedheap.h
View File

@ -1,20 +1,11 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_expheap Expanded Heap
* \ingroup coreinit
* @{
*/
#include "memheap.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct MEMExpandedHeap MEMExpandedHeap;
typedef struct MEMExpandedHeapBlock MEMExpandedHeapBlock;
typedef struct MEMExpandedHeapBlockList MEMExpandedHeapBlockList;
typedef enum MEMExpandedHeapMode
{
MEM_EXP_HEAP_MODE_FIRST_FREE = 0,
@ -27,6 +18,7 @@ typedef enum MEMExpandedHeapDirection
MEM_EXP_HEAP_DIR_FROM_BOTTOM = 1,
} MEMExpandedHeapDirection;
typedef struct MEMExpandedHeapBlock MEMExpandedHeapBlock;
struct MEMExpandedHeapBlock
{
uint32_t attribs;
@ -34,96 +26,40 @@ struct MEMExpandedHeapBlock
MEMExpandedHeapBlock *prev;
MEMExpandedHeapBlock *next;
uint16_t tag;
UNKNOWN(0x02);
uint16_t __unknown;
};
CHECK_OFFSET(MEMExpandedHeapBlock, 0x00, attribs);
CHECK_OFFSET(MEMExpandedHeapBlock, 0x04, blockSize);
CHECK_OFFSET(MEMExpandedHeapBlock, 0x08, prev);
CHECK_OFFSET(MEMExpandedHeapBlock, 0x0c, next);
CHECK_OFFSET(MEMExpandedHeapBlock, 0x10, tag);
CHECK_SIZE(MEMExpandedHeapBlock, 0x14);
struct MEMExpandedHeapBlockList
typedef struct MEMExpandedHeapBlockList
{
MEMExpandedHeapBlock *head;
MEMExpandedHeapBlock *tail;
};
CHECK_OFFSET(MEMExpandedHeapBlockList, 0x00, head);
CHECK_OFFSET(MEMExpandedHeapBlockList, 0x04, tail);
CHECK_SIZE(MEMExpandedHeapBlockList, 0x08);
}MEMExpandedHeapBlockList;
struct MEMExpandedHeap
typedef struct MEMExpandedHeap
{
MEMHeapHeader header;
MEMExpandedHeapBlockList freeList;
MEMExpandedHeapBlockList usedList;
uint16_t groupId;
uint16_t attribs;
};
CHECK_OFFSET(MEMExpandedHeap, 0x00, header);
CHECK_OFFSET(MEMExpandedHeap, 0x40, freeList);
CHECK_OFFSET(MEMExpandedHeap, 0x48, usedList);
CHECK_OFFSET(MEMExpandedHeap, 0x50, groupId);
CHECK_OFFSET(MEMExpandedHeap, 0x52, attribs);
CHECK_SIZE(MEMExpandedHeap, 0x54);
}MEMExpandedHeap;
MEMExpandedHeap *
MEMCreateExpHeapEx(MEMExpandedHeap *heap,
uint32_t size,
uint16_t flags);
MEMExpandedHeap *
MEMDestroyExpHeap(MEMExpandedHeap *heap);
void *
MEMAllocFromExpHeapEx(MEMExpandedHeap *heap,
uint32_t size,
int alignment);
void
MEMFreeToExpHeap(MEMExpandedHeap *heap,
uint8_t *block);
MEMExpandedHeapMode
MEMSetAllocModeForExpHeap(MEMExpandedHeap *heap,
MEMExpandedHeapMode mode);
MEMExpandedHeapMode
MEMGetAllocModeForExpHeap(MEMExpandedHeap *heap);
uint32_t
MEMAdjustExpHeap(MEMExpandedHeap *heap);
uint32_t
MEMResizeForMBlockExpHeap(MEMExpandedHeap *heap,
uint8_t *address,
uint32_t size);
uint32_t
MEMGetTotalFreeSizeForExpHeap(MEMExpandedHeap *heap);
uint32_t
MEMGetAllocatableSizeForExpHeapEx(MEMExpandedHeap *heap,
int alignment);
uint16_t
MEMSetGroupIDForExpHeap(MEMExpandedHeap *heap,
uint16_t id);
uint16_t
MEMGetGroupIDForExpHeap(MEMExpandedHeap *heap);
uint32_t
MEMGetSizeForMBlockExpHeap(uint8_t *addr);
uint16_t
MEMGetGroupIDForMBlockExpHeap(uint8_t *addr);
MEMExpandedHeapDirection
MEMGetAllocDirForMBlockExpHeap(uint8_t *addr);
MEMExpandedHeap *MEMCreateExpHeapEx(MEMExpandedHeap *heap, uint32_t size, uint16_t flags);
MEMExpandedHeap *MEMDestroyExpHeap(MEMExpandedHeap *heap);
void *MEMAllocFromExpHeapEx(MEMExpandedHeap *heap, uint32_t size, int alignment);
void MEMFreeToExpHeap(MEMExpandedHeap *heap, uint8_t *block);
MEMExpandedHeapMode MEMSetAllocModeForExpHeap(MEMExpandedHeap *heap, MEMExpandedHeapMode mode);
MEMExpandedHeapMode MEMGetAllocModeForExpHeap(MEMExpandedHeap *heap);
uint32_t MEMAdjustExpHeap(MEMExpandedHeap *heap);
uint32_t MEMResizeForMBlockExpHeap(MEMExpandedHeap *heap, uint8_t *address, uint32_t size);
uint32_t MEMGetTotalFreeSizeForExpHeap(MEMExpandedHeap *heap);
uint32_t MEMGetAllocatableSizeForExpHeapEx(MEMExpandedHeap *heap, int alignment);
uint16_t MEMSetGroupIDForExpHeap(MEMExpandedHeap *heap, uint16_t id);
uint16_t MEMGetGroupIDForExpHeap(MEMExpandedHeap *heap);
uint32_t MEMGetSizeForMBlockExpHeap(uint8_t *addr);
uint16_t MEMGetGroupIDForMBlockExpHeap(uint8_t *addr);
MEMExpandedHeapDirection MEMGetAllocDirForMBlockExpHeap(uint8_t *addr);
#ifdef __cplusplus
}
#endif
/** @} */

38
wiiu/wut/include/coreinit/fastcondition.h
View File

@ -1,50 +1,26 @@
#pragma once
#include <wut.h>
#include "threadqueue.h"
/**
* \defgroup coreinit_fastcond Fast Condition Variable
* \ingroup coreinit
*
* A condition variable to be used with an OSFastMutex.
*
* @{
*/
#include "fastmutex.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct OSFastCondition OSFastCondition;
typedef struct OSFastMutex OSFastMutex;
#define OS_FAST_CONDITION_TAG 0x664E6456u
struct OSFastCondition
typedef struct OSFastCondition
{
uint32_t tag;
const char *name;
UNKNOWN(4);
uint32_t __unknown;
OSThreadQueue queue;
};
CHECK_OFFSET(OSFastCondition, 0x00, tag);
CHECK_OFFSET(OSFastCondition, 0x04, name);
CHECK_OFFSET(OSFastCondition, 0x0c, queue);
CHECK_SIZE(OSFastCondition, 0x1c);
}OSFastCondition;
void
OSFastCond_Init(OSFastCondition *condition,
const char *name);
void
OSFastCond_Wait(OSFastCondition *condition,
OSFastMutex *mutex);
void
OSFastCond_Signal(OSFastCondition *condition);
void OSFastCond_Init(OSFastCondition *condition, const char *name);
void OSFastCond_Wait(OSFastCondition *condition, OSFastMutex *mutex);
void OSFastCond_Signal(OSFastCondition *condition);
#ifdef __cplusplus
}
#endif
/** @} */

38
wiiu/wut/include/coreinit/fastmutex.h
View File

@ -16,47 +16,29 @@ extern "C" {
#endif
typedef struct OSFastMutex OSFastMutex;
typedef struct OSFastMutexLink OSFastMutexLink;
typedef struct OSFastCondition OSFastCondition;
struct OSFastMutexLink
typedef struct OSFastMutexLink
{
OSFastMutex *next;
OSFastMutex *prev;
};
CHECK_OFFSET(OSFastMutexLink, 0x00, next);
CHECK_OFFSET(OSFastMutexLink, 0x04, prev);
CHECK_SIZE(OSFastMutexLink, 0x08);
}OSFastMutexLink;
#define OS_FAST_MUTEX_TAG 0x664D7458u
struct OSFastMutex
typedef struct OSFastMutex
{
uint32_t tag;
const char *name;
UNKNOWN(4);
uint32_t __unknown;
OSThreadSimpleQueue queue;
OSFastMutexLink link;
UNKNOWN(16);
};
CHECK_OFFSET(OSFastMutex, 0x00, tag);
CHECK_OFFSET(OSFastMutex, 0x04, name);
CHECK_OFFSET(OSFastMutex, 0x0c, queue);
CHECK_OFFSET(OSFastMutex, 0x14, link);
CHECK_SIZE(OSFastMutex, 0x2c);
uint32_t __unknown[4];
}OSFastMutex;
void
OSFastMutex_Init(OSFastMutex *mutex,
const char *name);
void
OSFastMutex_Lock(OSFastMutex *mutex);
void
OSFastMutex_Unlock(OSFastMutex *mutex);
BOOL
OSFastMutex_TryLock(OSFastMutex *mutex);
void OSFastMutex_Init(OSFastMutex *mutex, const char *name);
void OSFastMutex_Lock(OSFastMutex *mutex);
void OSFastMutex_Unlock(OSFastMutex *mutex);
BOOL OSFastMutex_TryLock(OSFastMutex *mutex);
#ifdef __cplusplus
}

732
wiiu/wut/include/coreinit/filesystem.h
View File

@ -1,22 +1,6 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_fs Filesystem
* \ingroup coreinit
*
* First call FSInit to initialise the file system library, then call
* FSAddClient to initialise your FSClient structure, then you need to use
* FSInitCmdBlock to initialise an FSCmdBlock structure for each command you
* want to run in parallel. You must ensure the previous filesystem command
* has been completed before reusing the same FSCmdBlock, you do not need to
* reinitialise an FSCmdBlock before reusing it.
*
* Calling fsDevInit initializes the stdlib devoptab, allowing for standard
* file IO.
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -25,14 +9,6 @@ typedef uint32_t FSDirectoryHandle;
typedef uint32_t FSFileHandle;
typedef uint32_t FSPriority;
typedef struct FSAsyncData FSAsyncData;
typedef struct FSCmdBlock FSCmdBlock;
typedef struct FSClient FSClient;
typedef struct FSDirectoryEntry FSDirectoryEntry;
typedef struct FSStat FSStat;
typedef struct FSStateChangeInfo FSStateChangeInfo;
typedef struct FSMountSource FSMountSource;
typedef enum FSStatus
{
FS_STATUS_OK = 0,
@ -139,483 +115,359 @@ typedef enum FSMountSourceType
FS_MOUNT_SOURCE_UNK = 1,
} FSMountSourceType;
typedef void(*FSAsyncCallback)(FSClient *, FSCmdBlock *, FSStatus, uint32_t);
struct FSClient
typedef struct FSClient
{
UNKNOWN(0x1700);
};
CHECK_SIZE(FSClient, 0x1700);
uint32_t __unknown[0x5C0];
} FSClient;
struct FSCmdBlock
typedef struct FSCmdBlock
{
UNKNOWN(0xA80);
};
CHECK_SIZE(FSCmdBlock, 0xA80);
uint32_t __unknown[0x2A0];
} FSCmdBlock;
struct FSStat
typedef struct FSStat
{
FSStatFlags flags;
FSMode mode;
uint32_t owner;
uint32_t group;
uint32_t size;
UNKNOWN(0x50);
};
CHECK_OFFSET(FSStat, 0x00, flags);
CHECK_OFFSET(FSStat, 0x10, size);
CHECK_SIZE(FSStat, 0x64);
uint32_t __unknown[0x14];
} FSStat;
struct FSStateChangeInfo
typedef struct FSStateChangeInfo
{
UNKNOWN(0xC);
};
CHECK_SIZE(FSStateChangeInfo, 0xC);
uint32_t __unknown[0x3];
} FSStateChangeInfo;
struct FSAsyncData
typedef void(*FSAsyncCallback)(FSClient *, FSCmdBlock *, FSStatus, uint32_t);
typedef struct FSAsyncData
{
uint32_t callback;
uint32_t param;
UNKNOWN(4);
};
CHECK_OFFSET(FSAsyncData, 0x0, callback);
CHECK_OFFSET(FSAsyncData, 0x4, param);
CHECK_SIZE(FSAsyncData, 0xC);
uint32_t __unknown;
} FSAsyncData;
struct FSDirectoryEntry
typedef struct FSDirectoryEntry
{
FSStat info;
char name[256];
};
CHECK_OFFSET(FSDirectoryEntry, 0x64, name);
CHECK_SIZE(FSDirectoryEntry, 0x164);
} FSDirectoryEntry;
struct FSMountSource
typedef struct FSMountSource
{
UNKNOWN(0x300);
};
CHECK_SIZE(FSMountSource, 0x300);
uint32_t __unknown[0xC0];
} FSMountSource;
FSStatus
fsDevInit();
FSStatus fsDevInit();
FSStatus fsDevExit();
FSStatus
fsDevExit();
void FSInit();
void FSShutdown();
void
FSInit();
FSStatus FSAddClient(FSClient *client,
uint32_t flags);
void
FSShutdown();
FSStatus FSDelClient(FSClient *client,
uint32_t flags);
FSStatus
FSAddClient(FSClient *client,
uint32_t flags);
uint32_t FSGetClientNum();
FSStatus
FSDelClient(FSClient *client,
uint32_t flags);
void FSInitCmdBlock(FSCmdBlock *block);
uint32_t
FSGetClientNum();
FSStatus FSSetCmdPriority(FSCmdBlock *block,
FSPriority priority);
void
FSInitCmdBlock(FSCmdBlock *block);
void FSSetStateChangeNotification(FSClient *client,
FSStateChangeInfo *info);
FSStatus
FSSetCmdPriority(FSCmdBlock *block,
FSPriority priority);
FSStatus FSGetCwd(FSClient *client, FSCmdBlock *block, char *buffer, uint32_t bufferSize, uint32_t flags);
FSStatus FSChangeDir(FSClient *client, FSCmdBlock *block, const char *path, uint32_t flags);
FSStatus FSChangeDirAsync(FSClient *client, FSCmdBlock *block, const char *path, uint32_t flags, FSAsyncData *asyncData);
FSStatus FSGetStat(FSClient *client, FSCmdBlock *block, const char *path, FSStat *stat, uint32_t flags);
FSStatus FSGetStatAsync(FSClient *client, FSCmdBlock *block, const char *path, FSStat *stat, uint32_t flags, FSAsyncData *asyncData);
FSStatus FSRemove(FSClient *client, FSCmdBlock *block, const char *path, uint32_t flags);
FSStatus FSRemoveAsync(FSClient *client, FSCmdBlock *block, const char *path, uint32_t flags, FSAsyncData *asyncData);
FSStatus FSOpenFile(FSClient *client, FSCmdBlock *block, const char *path, const char *mode, FSFileHandle *handle, uint32_t flags);
FSStatus FSOpenFileAsync(FSClient *client, FSCmdBlock *block, const char *path, const char *mode, FSFileHandle *outHandle, uint32_t flags, FSAsyncData *asyncData);
void
FSSetStateChangeNotification(FSClient *client,
FSStateChangeInfo *info);
FSStatus FSCloseFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags);
FSStatus
FSGetCwd(FSClient *client,
FSCmdBlock *block,
char *buffer,
uint32_t bufferSize,
uint32_t flags);
FSStatus FSCloseFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSChangeDir(FSClient *client,
FSCmdBlock *block,
const char *path,
uint32_t flags);
FSStatus
FSChangeDirAsync(FSClient *client,
FSCmdBlock *block,
const char *path,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSGetStat(FSClient *client,
FSCmdBlock *block,
const char *path,
FSStat *stat,
uint32_t flags);
FSStatus
FSGetStatAsync(FSClient *client,
FSCmdBlock *block,
const char *path,
FSStat *stat,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSRemove(FSClient *client,
FSCmdBlock *block,
const char *path,
uint32_t flags);
FSStatus
FSRemoveAsync(FSClient *client,
FSCmdBlock *block,
const char *path,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSOpenFile(FSClient *client,
FSCmdBlock *block,
const char *path,
const char *mode,
FSFileHandle *handle,
uint32_t flags);
FSStatus
FSOpenFileAsync(FSClient *client,
FSCmdBlock *block,
const char *path,
const char *mode,
FSFileHandle *outHandle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSCloseFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags);
FSStatus
FSCloseFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSOpenDir(FSClient *client,
FSCmdBlock *block,
const char *path,
FSDirectoryHandle *handle,
uint32_t flags);
FSStatus
FSOpenDirAsync(FSClient *client,
FSCmdBlock *block,
const char *path,
FSDirectoryHandle *handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSMakeDir(FSClient *client,
FSCmdBlock *block,
const char *path,
uint32_t flags);
FSStatus
FSMakeDirAsync(FSClient *client,
FSCmdBlock *block,
const char *path,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSReadDir(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
FSDirectoryEntry *entry,
uint32_t flags);
FSStatus
FSReadDirAsync(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
FSDirectoryEntry *entry,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSRewindDir(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
uint32_t flags);
FSStatus
FSCloseDir(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
uint32_t flags);
FSStatus
FSCloseDirAsync(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSChangeMode(FSClient *client,
FSCmdBlock *block,
char *path,
FSMode mode,
uint32_t flags);
FSStatus
FSChangeModeAsync(FSClient *client,
FSCmdBlock *block,
char *path,
FSMode mode,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSGetFreeSpaceSize(FSClient *client,
FSStatus FSOpenDir(FSClient *client,
FSCmdBlock *block,
char *path,
u64 *outSize,
const char *path,
FSDirectoryHandle *handle,
uint32_t flags);
FSStatus
FSGetFreeSpaceSizeAsync(FSClient *client,
FSStatus FSOpenDirAsync(FSClient *client,
FSCmdBlock *block,
char *path,
u64 *outSize,
const char *path,
FSDirectoryHandle *handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSGetStatFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
FSStat *stat,
uint32_t flags);
FSStatus
FSGetStatFileAsync(FSClient *client,
FSStatus FSMakeDir(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
FSStat *stat,
uint32_t flags,
FSAsyncData *asyncData);
const char *path,
uint32_t flags);
FSStatus
FSReadFile(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags);
FSStatus FSMakeDirAsync(FSClient *client,
FSCmdBlock *block,
const char *path,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSReadFileAsync(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSReadDir(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
FSDirectoryEntry *entry,
uint32_t flags);
FSStatus
FSReadFileWithPos(FSClient *client,
FSStatus FSReadDirAsync(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
FSDirectoryEntry *entry,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSRewindDir(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
uint32_t flags);
FSStatus FSCloseDir(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
uint32_t flags);
FSStatus FSCloseDirAsync(FSClient *client,
FSCmdBlock *block,
FSDirectoryHandle handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSChangeMode(FSClient *client,
FSCmdBlock *block,
char *path,
FSMode mode,
uint32_t flags);
FSStatus FSChangeModeAsync(FSClient *client,
FSCmdBlock *block,
char *path,
FSMode mode,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSGetFreeSpaceSize(FSClient *client,
FSCmdBlock *block,
char *path,
u64 *outSize,
uint32_t flags);
FSStatus FSGetFreeSpaceSizeAsync(FSClient *client,
FSCmdBlock *block,
char *path,
u64 *outSize,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSGetStatFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
FSStat *stat,
uint32_t flags);
FSStatus FSGetStatFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
FSStat *stat,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSReadFile(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags);
FSStatus FSReadFileAsync(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSReadFileWithPos(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
uint32_t pos,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags);
FSStatus FSReadFileWithPosAsync(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
uint32_t pos,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSWriteFile(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags);
FSStatus FSWriteFileAsync(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSWriteFileWithPos(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
uint32_t pos,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags);
FSStatus FSWriteFileWithPosAsync(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
uint32_t pos,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSGetPosFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle fileHandle,
uint32_t *pos,
uint32_t flags);
FSStatus FSGetPosFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle fileHandle,
uint32_t *pos,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSSetPosFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t pos,
uint32_t flags);
FSStatus FSSetPosFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t pos,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSFlushFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags);
FSStatus FSFlushFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSTruncateFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags);
FSStatus FSTruncateFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus FSRename(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
uint32_t pos,
FSFileHandle handle,
uint32_t unk1,
const char *oldPath,
const char *newPath,
uint32_t flags);
FSStatus
FSReadFileWithPosAsync(FSClient *client,
FSStatus FSRenameAsync(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
uint32_t pos,
FSFileHandle handle,
uint32_t unk1,
const char *oldPath,
const char *newPath,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSWriteFile(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags);
FSVolumeState FSGetVolumeState(FSClient *client);
FSStatus
FSWriteFileAsync(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags,
FSAsyncData *asyncData);
FSError FSGetLastErrorCodeForViewer(FSClient *client);
FSStatus
FSWriteFileWithPos(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
uint32_t pos,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags);
FSStatus FSGetMountSource(FSClient *client,
FSCmdBlock *cmd,
FSMountSourceType type,
FSMountSource *out,
uint32_t flags);
FSStatus
FSWriteFileWithPosAsync(FSClient *client,
FSCmdBlock *block,
uint8_t *buffer,
uint32_t size,
uint32_t count,
uint32_t pos,
FSFileHandle handle,
uint32_t unk1,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSGetPosFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle fileHandle,
uint32_t *pos,
uint32_t flags);
FSStatus
FSGetPosFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle fileHandle,
uint32_t *pos,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSSetPosFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t pos,
uint32_t flags);
FSStatus
FSSetPosFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t pos,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSFlushFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags);
FSStatus
FSFlushFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSTruncateFile(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags);
FSStatus
FSTruncateFileAsync(FSClient *client,
FSCmdBlock *block,
FSFileHandle handle,
uint32_t flags,
FSAsyncData *asyncData);
FSStatus
FSRename(FSClient *client,
FSCmdBlock *block,
const char *oldPath,
const char *newPath,
uint32_t flags);
FSStatus
FSRenameAsync(FSClient *client,
FSCmdBlock *block,
const char *oldPath,
const char *newPath,
uint32_t flags,
FSAsyncData *asyncData);
FSVolumeState
FSGetVolumeState(FSClient *client);
FSError
FSGetLastErrorCodeForViewer(FSClient *client);
FSStatus
FSGetMountSource(FSClient *client,
FSStatus FSMount(FSClient *client,
FSCmdBlock *cmd,
FSMountSourceType type,
FSMountSource *out,
FSMountSource *source,
const char *target,
uint32_t bytes,
uint32_t flags);
FSStatus
FSMount(FSClient *client,
FSCmdBlock *cmd,
FSMountSource *source,
const char *target,
uint32_t bytes,
uint32_t flags);
FSStatus FSUnmount(FSClient *client,
FSCmdBlock *cmd,
const char *target,
uint32_t flags);
FSStatus
FSUnmount(FSClient *client,
FSCmdBlock *cmd,
const char *target,
uint32_t flags);
FSStatus FSBindMount(FSClient *client,
FSCmdBlock *cmd,
const char *source,
const char *target,
uint32_t flags);
FSStatus
FSBindMount(FSClient *client,
FSCmdBlock *cmd,
const char *source,
const char *target,
uint32_t flags);
FSStatus
FSbindUnmount(FSClient *client,
FSCmdBlock *cmd,
const char *target,
uint32_t flags);
FSStatus FSbindUnmount(FSClient *client,
FSCmdBlock *cmd,
const char *target,
uint32_t flags);
#ifdef __cplusplus
}
#endif
/** @} */

19
wiiu/wut/include/coreinit/foreground.h
View File

@ -1,27 +1,14 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_foreground Foreground Management
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void
OSEnableForegroundExit();
void
OSReleaseForeground();
void
OSSavesDone_ReadyToRelease();
void OSEnableForegroundExit();
void OSReleaseForeground();
void OSSavesDone_ReadyToRelease();
#ifdef __cplusplus
}
#endif
/** @} */

76
wiiu/wut/include/coreinit/frameheap.h
View File

@ -2,12 +2,6 @@
#include <wut.h>
#include "memheap.h"
/**
* \defgroup coreinit_frameheap Frame Heap
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -19,74 +13,32 @@ typedef enum MEMFrameHeapFreeMode
MEM_FRAME_HEAP_FREE_ALL = MEM_FRAME_HEAP_FREE_HEAD | MEM_FRAME_HEAP_FREE_TAIL,
} MEMFrameHeapFreeMode;
typedef struct MEMFrameHeap MEMFrameHeap;
typedef struct MEMFrameHeapState MEMFrameHeapState;
struct MEMFrameHeapState
typedef struct MEMFrameHeapState
{
uint32_t tag;
void *head;
void *tail;
MEMFrameHeapState *previous;
};
CHECK_OFFSET(MEMFrameHeapState, 0x00, tag);
CHECK_OFFSET(MEMFrameHeapState, 0x04, head);
CHECK_OFFSET(MEMFrameHeapState, 0x08, tail);
CHECK_OFFSET(MEMFrameHeapState, 0x0C, previous);
CHECK_SIZE(MEMFrameHeapState, 0x10);
struct MEMFrameHeapState *previous;
} MEMFrameHeapState;
struct MEMFrameHeap
typedef struct MEMFrameHeap
{
MEMHeapHeader header;
void *head;
void *tail;
MEMFrameHeapState *previousState;
};
CHECK_OFFSET(MEMFrameHeap, 0x00, header);
CHECK_OFFSET(MEMFrameHeap, 0x40, head);
CHECK_OFFSET(MEMFrameHeap, 0x44, tail);
CHECK_OFFSET(MEMFrameHeap, 0x48, previousState);
CHECK_SIZE(MEMFrameHeap, 0x4C);
} MEMFrameHeap;
MEMFrameHeap *
MEMCreateFrmHeapEx(void *heap,
uint32_t size,
uint32_t flags);
void *
MEMDestroyFrmHeap(MEMFrameHeap *heap);
void *
MEMAllocFromFrmHeapEx(MEMFrameHeap *heap,
uint32_t size,
int alignment);
void
MEMFreeToFrmHeap(MEMFrameHeap *heap,
MEMFrameHeapFreeMode mode);
BOOL
MEMRecordStateForFrmHeap(MEMFrameHeap *heap,
uint32_t tag);
BOOL
MEMFreeByStateToFrmHeap(MEMFrameHeap *heap,
uint32_t tag);
uint32_t
MEMAdjustFrmHeap(MEMFrameHeap *heap);
uint32_t
MEMResizeForMBlockFrmHeap(MEMFrameHeap *heap,
uint32_t addr,
uint32_t size);
uint32_t
MEMGetAllocatableSizeForFrmHeapEx(MEMFrameHeap *heap,
int alignment);
MEMFrameHeap *MEMCreateFrmHeapEx(void *heap, uint32_t size, uint32_t flags);
void *MEMDestroyFrmHeap(MEMFrameHeap *heap);
void *MEMAllocFromFrmHeapEx(MEMFrameHeap *heap, uint32_t size, int alignment);
void MEMFreeToFrmHeap(MEMFrameHeap *heap, MEMFrameHeapFreeMode mode);
BOOL MEMRecordStateForFrmHeap(MEMFrameHeap *heap, uint32_t tag);
BOOL MEMFreeByStateToFrmHeap(MEMFrameHeap *heap, uint32_t tag);
uint32_t MEMAdjustFrmHeap(MEMFrameHeap *heap);
uint32_t MEMResizeForMBlockFrmHeap(MEMFrameHeap *heap, uint32_t addr, uint32_t size);
uint32_t MEMGetAllocatableSizeForFrmHeapEx(MEMFrameHeap *heap, int alignment);
#ifdef __cplusplus
}
#endif
/** @} */

3
wiiu/wut/include/coreinit/internal.h
View File

@ -5,8 +5,7 @@
extern "C" {
#endif
int
__os_snprintf(char *buf, size_t n, const char *format, ... );
int __os_snprintf(char *buf, size_t n, const char *format, ... );
#ifdef __cplusplus
}

18
wiiu/wut/include/coreinit/mcp.h
View File

@ -11,12 +11,6 @@
extern "C" {
#endif
typedef struct MCPInstallProgress MCPInstallProgress;
typedef struct MCPInstallInfo MCPInstallInfo;
typedef struct MCPInstallTitleInfo MCPInstallTitleInfo;
typedef struct MCPDevice MCPDevice;
typedef struct MCPDeviceList MCPDeviceList;
typedef enum MCPInstallTarget
{
MCP_INSTALL_TARGET_MLC = 0,
@ -32,18 +26,12 @@ struct __attribute__((__packed__)) MCPInstallProgress
uint32_t contentsTotal;
uint32_t contentsProgress;
};
CHECK_OFFSET(MCPInstallProgress, 0x00, inProgress);
CHECK_OFFSET(MCPInstallProgress, 0x04, tid);
CHECK_OFFSET(MCPInstallProgress, 0x0C, sizeTotal);
CHECK_OFFSET(MCPInstallProgress, 0x14, sizeProgress);
CHECK_OFFSET(MCPInstallProgress, 0x1C, contentsTotal);
CHECK_OFFSET(MCPInstallProgress, 0x20, contentsProgress);
CHECK_SIZE(MCPInstallProgress, 0x24);
struct MCPInstallInfo
typedef struct MCPInstallInfo
{
UNKNOWN(0x27F);
};
}MCPInstallInfo;
CHECK_SIZE(MCPInstallInfo, 0x27F);
struct MCPInstallTitleInfo

55
wiiu/wut/include/coreinit/memheap.h
View File

@ -3,20 +3,10 @@
#include "spinlock.h"
#include "memlist.h"
/**
* \defgroup coreinit_memheap Common Memory Heap
* \ingroup coreinit
*
* Common memory heap fucntions.
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct MEMHeapHeader MEMHeapHeader;
typedef enum MEMHeapFillType
{
MEM_HEAP_FILL_TYPE_UNUSED = 0,
@ -26,21 +16,21 @@ typedef enum MEMHeapFillType
typedef enum MEMHeapTag
{
MEM_BLOCK_HEAP_TAG = 0x424C4B48u,
MEM_EXPANDED_HEAP_TAG = 0x45585048u,
MEM_FRAME_HEAP_TAG = 0x46524D48u,
MEM_UNIT_HEAP_TAG = 0x554E5448u,
MEM_USER_HEAP_TAG = 0x55535248u,
MEM_BLOCK_HEAP_TAG = 0x424C4B48u,
MEM_EXPANDED_HEAP_TAG = 0x45585048u,
MEM_FRAME_HEAP_TAG = 0x46524D48u,
MEM_UNIT_HEAP_TAG = 0x554E5448u,
MEM_USER_HEAP_TAG = 0x55535248u,
} MEMHeapTag;
typedef enum MEMHeapFlags
{
MEM_HEAP_FLAG_ZERO_ALLOCATED = 1 << 0,
MEM_HEAP_FLAG_DEBUG_MODE = 1 << 1,
MEM_HEAP_FLAG_USE_LOCK = 1 << 2,
MEM_HEAP_FLAG_ZERO_ALLOCATED = 1 << 0,
MEM_HEAP_FLAG_DEBUG_MODE = 1 << 1,
MEM_HEAP_FLAG_USE_LOCK = 1 << 2,
} MEMHeapFlags;
struct MEMHeapHeader
typedef struct MEMHeapHeader
{
//! Tag indicating which type of heap this is
MEMHeapTag tag;
@ -63,44 +53,29 @@ struct MEMHeapHeader
//! Flags set during heap creation.
uint32_t flags;
UNKNOWN(0x0C);
};
CHECK_OFFSET(MEMHeapHeader, 0x00, tag);
CHECK_OFFSET(MEMHeapHeader, 0x04, link);
CHECK_OFFSET(MEMHeapHeader, 0x0C, list);
CHECK_OFFSET(MEMHeapHeader, 0x18, dataStart);
CHECK_OFFSET(MEMHeapHeader, 0x1C, dataEnd);
CHECK_OFFSET(MEMHeapHeader, 0x20, lock);
CHECK_OFFSET(MEMHeapHeader, 0x30, flags);
CHECK_SIZE(MEMHeapHeader, 0x40);
uint32_t __unknown[0x3];
} MEMHeapHeader;
/**
* Print details about heap to COSWarn
*/
void
MEMDumpHeap(MEMHeapHeader *heap);
void MEMDumpHeap(MEMHeapHeader *heap);
/**
* Find heap which contains a memory block.
*/
MEMHeapHeader *
MEMFindContainHeap(void *block);
MEMHeapHeader *MEMFindContainHeap(void *block);
/**
* Get the data fill value used when MEM_HEAP_FLAG_DEBUG_MODE is set.
*/
uint32_t
MEMGetFillValForHeap(MEMHeapFillType type);
uint32_t MEMGetFillValForHeap(MEMHeapFillType type);
/**
* Set the data fill value used when MEM_HEAP_FLAG_DEBUG_MODE is set.
*/
void
MEMSetFillValForHeap(MEMHeapFillType type,
uint32_t value);
void MEMSetFillValForHeap(MEMHeapFillType type, uint32_t value);
#ifdef __cplusplus
}
#endif
/** @} */

67
wiiu/wut/include/coreinit/memlist.h
View File

@ -1,76 +1,33 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_memlist Memory List
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct MEMMemoryLink MEMMemoryLink;
typedef struct MEMMemoryList MEMMemoryList;
struct MEMMemoryLink
typedef struct MEMMemoryLink
{
void *prev;
void *next;
};
CHECK_OFFSET(MEMMemoryLink, 0x0, prev);
CHECK_OFFSET(MEMMemoryLink, 0x4, next);
CHECK_SIZE(MEMMemoryLink, 0x8);
} MEMMemoryLink;
struct MEMMemoryList
typedef struct MEMMemoryList
{
void *head;
void *tail;
uint16_t count;
uint16_t offsetToMemoryLink;
};
CHECK_OFFSET(MEMMemoryList, 0x0, head);
CHECK_OFFSET(MEMMemoryList, 0x4, tail);
CHECK_OFFSET(MEMMemoryList, 0x8, count);
CHECK_OFFSET(MEMMemoryList, 0xa, offsetToMemoryLink);
CHECK_SIZE(MEMMemoryList, 0xc);
} MEMMemoryList;
void
MEMInitList(MEMMemoryList *list,
uint16_t offsetToMemoryLink);
void
MEMAppendListObject(MEMMemoryList *list,
void *object);
void
MEMPrependListObject(MEMMemoryList *list,
void *object);
void
MEMInsertListObject(MEMMemoryList *list,
void *before,
void *object);
void
MEMRemoveListObject(MEMMemoryList *list,
void *object);
void *
MEMGetNextListObject(MEMMemoryList *list,
void *object);
void *
MEMGetPrevListObject(MEMMemoryList *list,
void *object);
void *
MEMGetNthListObject(MEMMemoryList *list,
uint16_t n);
void MEMInitList(MEMMemoryList *list, uint16_t offsetToMemoryLink);
void MEMAppendListObject(MEMMemoryList *list, void *object);
void MEMPrependListObject(MEMMemoryList *list, void *object);
void MEMInsertListObject(MEMMemoryList *list, void *before, void *object);
void MEMRemoveListObject(MEMMemoryList *list, void *object);
void *MEMGetNextListObject(MEMMemoryList *list, void *object);
void *MEMGetPrevListObject(MEMMemoryList *list, void *object);
void *MEMGetNthListObject(MEMMemoryList *list, uint16_t n);
#ifdef __cplusplus
}
#endif
/** @} */

32
wiiu/wut/include/coreinit/memory.h
View File

@ -1,37 +1,15 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_memory Memory
* \ingroup coreinit
*
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void *
OSBlockMove(void *dst,
const void *src,
uint32_t size,
BOOL flush);
void *
OSBlockSet(void *dst,
uint8_t val,
uint32_t size);
uint32_t
OSEffectiveToPhysical(void *vaddr);
void*
OSAllocFromSystem(uint32_t size,
int align);
void
OSFreeToSystem(void *ptr);
void *OSBlockMove(void *dst, const void *src, uint32_t size, BOOL flush);
void *OSBlockSet(void *dst, uint8_t val, uint32_t size);
uint32_t OSEffectiveToPhysical(void *vaddr);
void *OSAllocFromSystem(uint32_t size, int align);
void OSFreeToSystem(void *ptr);
#ifdef __cplusplus
}

66
wiiu/wut/include/coreinit/messagequeue.h
View File

@ -1,88 +1,44 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_msgq Message Queue
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct OSMessage OSMessage;
typedef struct OSMessageQueue OSMessageQueue;
typedef enum OSMessageFlags
{
OS_MESSAGE_QUEUE_BLOCKING = 1 << 0,
OS_MESSAGE_QUEUE_HIGH_PRIORITY = 1 << 1,
} OSMessageFlags;
struct OSMessage
typedef struct OSMessage
{
void *message;
uint32_t args[3];
};
CHECK_OFFSET(OSMessage, 0x00, message);
CHECK_OFFSET(OSMessage, 0x04, args);
CHECK_SIZE(OSMessage, 0x10);
} OSMessage;
#define OS_MESSAGE_QUEUE_TAG 0x6D536751u
struct OSMessageQueue
typedef struct OSMessageQueue
{
uint32_t tag;
const char *name;
UNKNOWN(4);
uint32_t __unknown;
OSThreadQueue sendQueue;
OSThreadQueue recvQueue;
OSMessage *messages;
uint32_t size;
uint32_t first;
uint32_t used;
};
CHECK_OFFSET(OSMessageQueue, 0x00, tag);
CHECK_OFFSET(OSMessageQueue, 0x04, name);
CHECK_OFFSET(OSMessageQueue, 0x0c, sendQueue);
CHECK_OFFSET(OSMessageQueue, 0x1c, recvQueue);
CHECK_OFFSET(OSMessageQueue, 0x2c, messages);
CHECK_OFFSET(OSMessageQueue, 0x30, size);
CHECK_OFFSET(OSMessageQueue, 0x34, first);
CHECK_OFFSET(OSMessageQueue, 0x38, used);
CHECK_SIZE(OSMessageQueue, 0x3c);
} OSMessageQueue;
void
OSInitMessageQueue(OSMessageQueue *queue,
OSMessage *messages,
int32_t size);
void
OSInitMessageQueueEx(OSMessageQueue *queue,
OSMessage *messages,
int32_t size,
const char *name);
BOOL
OSSendMessage(OSMessageQueue *queue,
OSMessage *message,
OSMessageFlags flags);
BOOL
OSReceiveMessage(OSMessageQueue *queue,
OSMessage *message,
OSMessageFlags flags);
BOOL
OSPeekMessage(OSMessageQueue *queue,
OSMessage *message);
OSMessageQueue *
OSGetSystemMessageQueue();
void OSInitMessageQueue(OSMessageQueue *queue, OSMessage *messages, int32_t size);
void OSInitMessageQueueEx(OSMessageQueue *queue, OSMessage *messages, int32_t size, const char *name);
BOOL OSSendMessage(OSMessageQueue *queue, OSMessage *message, OSMessageFlags flags);
BOOL OSReceiveMessage(OSMessageQueue *queue, OSMessage *message, OSMessageFlags flags);
BOOL OSPeekMessage(OSMessageQueue *queue, OSMessage *message);
OSMessageQueue *OSGetSystemMessageQueue();
#ifdef __cplusplus
}
#endif
/** @} */

32
wiiu/wut/include/coreinit/mutex.h
View File

@ -2,16 +2,6 @@
#include <wut.h>
#include "threadqueue.h"
/**
* \defgroup coreinit_mutex Mutex
* \ingroup coreinit
*
* Standard mutex object, supports recursive locking.
*
* Similar to <a href="http://en.cppreference.com/w/cpp/thread/recursive_mutex">std::recursive_mutex</a>.
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -19,20 +9,15 @@ extern "C" {
typedef struct OSThread OSThread;
typedef struct OSMutex OSMutex;
typedef struct OSMutexLink OSMutexLink;
struct OSMutexLink
typedef struct OSMutexLink
{
OSMutex *next;
OSMutex *prev;
};
CHECK_OFFSET(OSMutexLink, 0x00, next);
CHECK_OFFSET(OSMutexLink, 0x04, prev);
CHECK_SIZE(OSMutexLink, 0x8);
}OSMutexLink;
#define OS_MUTEX_TAG 0x6D557458u
struct OSMutex
typedef struct OSMutex
{
//! Should always be set to the value OS_MUTEX_TAG.
uint32_t tag;
@ -40,7 +25,7 @@ struct OSMutex
//! Name set by OSInitMutexEx.
const char *name;
UNKNOWN(4);
uint32_t __unknown;
//! Queue of threads waiting for this mutex to unlock.
OSThreadQueue queue;
@ -53,14 +38,7 @@ struct OSMutex
//! Link used inside OSThread's mutex queue.
OSMutexLink link;
};
CHECK_OFFSET(OSMutex, 0x00, tag);
CHECK_OFFSET(OSMutex, 0x04, name);
CHECK_OFFSET(OSMutex, 0x0c, queue);
CHECK_OFFSET(OSMutex, 0x1c, owner);
CHECK_OFFSET(OSMutex, 0x20, count);
CHECK_OFFSET(OSMutex, 0x24, link);
CHECK_SIZE(OSMutex, 0x2c);
}OSMutex;
/**

26
wiiu/wut/include/coreinit/rendezvous.h
View File

@ -1,12 +1,6 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_rendezvous Rendezvous
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -16,25 +10,13 @@ typedef struct OSRendezvous OSRendezvous;
struct OSRendezvous
{
uint32_t core[3];
UNKNOWN(4);
uint32_t __unknown;
};
CHECK_OFFSET(OSRendezvous, 0x00, core);
CHECK_SIZE(OSRendezvous, 0x10);
void
OSInitRendezvous(OSRendezvous *rendezvous);
BOOL
OSWaitRendezvous(OSRendezvous *rendezvous,
uint32_t coreMask);
BOOL
OSWaitRendezvousWithTimeout(OSRendezvous *rendezvous,
uint32_t coreMask,
OSTime timeout);
void OSInitRendezvous(OSRendezvous *rendezvous);
BOOL OSWaitRendezvous(OSRendezvous *rendezvous, uint32_t coreMask);
BOOL OSWaitRendezvousWithTimeout(OSRendezvous *rendezvous, uint32_t coreMask, OSTime timeout);
#ifdef __cplusplus
}
#endif
/** @} */

2
wiiu/wut/include/coreinit/semaphore.h
View File

@ -26,7 +26,7 @@ struct OSSemaphore
//! Name set by OSInitMutexEx.
const char *name;
UNKNOWN(4);
uint32_t __unknown;
//! Current count of semaphore
int32_t count;

10
wiiu/wut/include/coreinit/taskqueue.h
View File

@ -100,13 +100,15 @@ struct MPTaskQueue
uint32_t tasks;
uint32_t tasksReady;
uint32_t tasksRunning;
UNKNOWN(4);
uint32_t __unknown0;
uint32_t tasksFinished;
UNKNOWN(8);
uint32_t __unknown1;
uint32_t __unknown2;
uint32_t queueIndex;
UNKNOWN(8);
uint32_t __unknown3;
uint32_t __unknown4;
uint32_t queueSize;
UNKNOWN(4);
uint32_t __unknown5;
MPTask **queue;
uint32_t queueMaxSize;
OSSpinLock lock;

190
wiiu/wut/include/coreinit/thread.h
View File

@ -3,46 +3,10 @@
#include "time.h"
#include "threadqueue.h"
/**
* \defgroup coreinit_thread Thread
* \ingroup coreinit
*
* The thread scheduler in the Wii U uses co-operative scheduling, this is different
* to the usual pre-emptive scheduling that most operating systems use (such as
* Windows, Linux, etc). In co-operative scheduling threads must voluntarily yield
* execution to other threads. In pre-emptive threads are switched by the operating
* system after an amount of time.
*
* With the Wii U's scheduling model the thread with the highest priority which
* is in a non-waiting state will always be running (where 0 is the highest
* priority and 31 is the lowest). Execution will only switch to other threads
* once this thread has been forced to wait, such as when waiting to acquire a
* mutex, or when the thread voluntarily yields execution to other threads which
* have the same priority using OSYieldThread. OSYieldThread will never yield to
* a thread with lower priority than the current thread.
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct OSContext OSContext;
typedef struct OSFastMutex OSFastMutex;
typedef struct OSFastMutexQueue OSFastMutexQueue;
typedef struct OSMutex OSMutex;
typedef struct OSMutexQueue OSMutexQueue;
typedef struct OSThread OSThread;
//! A value from enum OS_THREAD_STATE.
typedef uint8_t OSThreadState;
//! A value from enum OS_THREAD_REQUEST.
typedef uint32_t OSThreadRequest;
//! A bitfield of enum OS_THREAD_ATTRIB.
typedef uint8_t OSThreadAttributes;
typedef int (*OSThreadEntryPointFn)(int argc, const char **argv);
typedef void (*OSThreadCleanupCallbackFn)(OSThread *thread, void *stack);
typedef void (*OSThreadDeallocatorFn)(OSThread *thread, void *stack);
@ -63,6 +27,7 @@ enum OS_THREAD_STATE
//! Thread is about to terminate
OS_THREAD_STATE_MORIBUND = 1 << 3,
};
typedef uint8_t OSThreadState;
enum OS_THREAD_REQUEST
{
@ -70,6 +35,7 @@ enum OS_THREAD_REQUEST
OS_THREAD_REQUEST_SUSPEND = 1,
OS_THREAD_REQUEST_CANCEL = 2,
};
typedef uint32_t OSThreadRequest;
enum OS_THREAD_ATTRIB
{
@ -91,10 +57,11 @@ enum OS_THREAD_ATTRIB
//! Enables tracking of stack usage.
OS_THREAD_ATTRIB_STACK_USAGE = 1 << 5
};
typedef uint8_t OSThreadAttributes;
#define OS_CONTEXT_TAG 0x4F53436F6E747874ull
struct OSContext
typedef struct OSContext
{
//! Should always be set to the value OS_CONTEXT_TAG.
uint64_t tag;
@ -112,68 +79,40 @@ struct OSContext
uint16_t spinLockCount;
uint16_t state;
uint32_t gqr[8];
UNKNOWN(4);
uint32_t __unknown0;
double psf[32];
uint64_t coretime[3];
uint64_t starttime;
uint32_t error;
UNKNOWN(4);
uint32_t __unknown1;
uint32_t pmc1;
uint32_t pmc2;
uint32_t pmc3;
uint32_t pmc4;
uint32_t mmcr0;
uint32_t mmcr1;
};
CHECK_OFFSET(OSContext, 0x00, tag);
CHECK_OFFSET(OSContext, 0x08, gpr);
CHECK_OFFSET(OSContext, 0x88, cr);
CHECK_OFFSET(OSContext, 0x8c, lr);
CHECK_OFFSET(OSContext, 0x90, ctr);
CHECK_OFFSET(OSContext, 0x94, xer);
CHECK_OFFSET(OSContext, 0x98, srr0);
CHECK_OFFSET(OSContext, 0x9c, srr1);
CHECK_OFFSET(OSContext, 0xb4, fpscr);
CHECK_OFFSET(OSContext, 0xb8, fpr);
CHECK_OFFSET(OSContext, 0x1b8, spinLockCount);
CHECK_OFFSET(OSContext, 0x1ba, state);
CHECK_OFFSET(OSContext, 0x1bc, gqr);
CHECK_OFFSET(OSContext, 0x1e0, psf);
CHECK_OFFSET(OSContext, 0x2e0, coretime);
CHECK_OFFSET(OSContext, 0x2f8, starttime);
CHECK_OFFSET(OSContext, 0x300, error);
CHECK_OFFSET(OSContext, 0x308, pmc1);
CHECK_OFFSET(OSContext, 0x30c, pmc2);
CHECK_OFFSET(OSContext, 0x310, pmc3);
CHECK_OFFSET(OSContext, 0x314, pmc4);
CHECK_OFFSET(OSContext, 0x318, mmcr0);
CHECK_OFFSET(OSContext, 0x31c, mmcr1);
CHECK_SIZE(OSContext, 0x320);
}OSContext;
struct OSMutexQueue
typedef struct OSMutex OSMutex;
typedef struct OSFastMutex OSFastMutex;
typedef struct OSMutexQueue
{
OSMutex *head;
OSMutex *tail;
void *parent;
UNKNOWN(4);
};
CHECK_OFFSET(OSMutexQueue, 0x0, head);
CHECK_OFFSET(OSMutexQueue, 0x4, tail);
CHECK_OFFSET(OSMutexQueue, 0x8, parent);
CHECK_SIZE(OSMutexQueue, 0x10);
uint32_t __unknown;
}OSMutexQueue;
struct OSFastMutexQueue
typedef struct OSFastMutexQueue
{
OSFastMutex *head;
OSFastMutex *tail;
};
CHECK_OFFSET(OSFastMutexQueue, 0x00, head);
CHECK_OFFSET(OSFastMutexQueue, 0x04, tail);
CHECK_SIZE(OSFastMutexQueue, 0x08);
}OSFastMutexQueue;
#define OS_THREAD_TAG 0x74487244u
#pragma pack(push, 1)
struct OSThread
typedef struct OSThread
{
OSContext context;
@ -201,7 +140,7 @@ struct OSThread
//! Exit value
int32_t exitValue;
UNKNOWN(0x35C - 0x338);
uint32_t unknown0[0x9];
//! Queue the thread is currently waiting on
OSThreadQueue *queue;
@ -230,17 +169,17 @@ struct OSThread
//! Thread entry point
OSThreadEntryPointFn entryPoint;
UNKNOWN(0x57c - 0x3a0);
uint32_t unknown1[0x77];
//! Thread specific values, accessed with OSSetThreadSpecific and OSGetThreadSpecific.
uint32_t specific[0x10];
UNKNOWN(0x5c0 - 0x5bc);
uint32_t unknown2;
//! Thread name, accessed with OSSetThreadName and OSGetThreadName.
const char *name;
UNKNOWN(0x4);
uint32_t unknown3;
//! The stack pointer passed in OSCreateThread.
void *userStackPointer;
@ -266,9 +205,10 @@ struct OSThread
//! Queue of threads waiting for a thread to be suspended.
OSThreadQueue suspendQueue;
UNKNOWN(0x69c - 0x5f4);
};
uint32_t unknown4[0x2A];
}OSThread;
#pragma pack(pop)
CHECK_OFFSET(OSThread, 0x320, tag);
CHECK_OFFSET(OSThread, 0x324, state);
CHECK_OFFSET(OSThread, 0x325, attr);
@ -298,7 +238,6 @@ CHECK_OFFSET(OSThread, 0x5e0, suspendResult);
CHECK_OFFSET(OSThread, 0x5e4, suspendQueue);
CHECK_SIZE(OSThread, 0x69c);
/**
* Cancels a thread.
*
@ -312,29 +251,25 @@ OSCancelThread(OSThread *thread);
/**
* Returns the count of active threads.
*/
int32_t
OSCheckActiveThreads();
int32_t OSCheckActiveThreads();
/**
* Get the maximum amount of stack the thread has used.
*/
int32_t
OSCheckThreadStackUsage(OSThread *thread);
int32_t OSCheckThreadStackUsage(OSThread *thread);
/**
* Disable tracking of thread stack usage
*/
void
OSClearThreadStackUsage(OSThread *thread);
void OSClearThreadStackUsage(OSThread *thread);
/**
* Clears a thread's suspend counter and resumes it.
*/
void
OSContinueThread(OSThread *thread);
void OSContinueThread(OSThread *thread);
/**
@ -349,22 +284,20 @@ OSContinueThread(OSThread *thread);
* \param priority Thread priority, 0 is highest priorty, 31 is lowest.
* \param attributes Thread attributes, see OSThreadAttributes.
*/
BOOL
OSCreateThread(OSThread *thread,
OSThreadEntryPointFn entry,
int32_t argc,
char *argv,
void *stack,
uint32_t stackSize,
int32_t priority,
OSThreadAttributes attributes);
BOOL OSCreateThread(OSThread *thread,
OSThreadEntryPointFn entry,
int32_t argc,
char *argv,
void *stack,
uint32_t stackSize,
int32_t priority,
OSThreadAttributes attributes);
/**
* Detach thread.
*/
void
OSDetachThread(OSThread *thread);
void OSDetachThread(OSThread *thread);
/**
@ -372,23 +305,20 @@ OSDetachThread(OSThread *thread);
*
* This function is implicitly called when the thread entry point returns.
*/
void
OSExitThread(int32_t result);
void OSExitThread(int32_t result);
/**
* Get the next and previous thread in the thread's active queue.
*/
void
OSGetActiveThreadLink(OSThread *thread,
OSThreadLink *link);
void OSGetActiveThreadLink(OSThread *thread,
OSThreadLink *link);
/**
* Return pointer to OSThread object for the current thread.
*/
OSThread *
OSGetCurrentThread();
OSThread *OSGetCurrentThread();
/**
@ -398,29 +328,25 @@ OSGetCurrentThread();
* thread for core 1 calls the RPX entry point, the default threads for core 0
* and 2 are suspended and can be used with OSRunThread.
*/
OSThread *
OSGetDefaultThread(uint32_t coreID);
OSThread *OSGetDefaultThread(uint32_t coreID);
/**
* Return current stack pointer, value of r1 register.
*/
uint32_t
OSGetStackPointer();
uint32_t OSGetStackPointer();
/**
* Get a thread's affinity.
*/
uint32_t
OSGetThreadAffinity(OSThread *thread);
uint32_t OSGetThreadAffinity(OSThread *thread);
/**
* Get a thread's name.
*/
const char *
OSGetThreadName(OSThread *thread);
const char *OSGetThreadName(OSThread *thread);
/**
@ -433,22 +359,19 @@ OSGetThreadPriority(OSThread *thread);
/**
* Get a thread's specific value set by OSSetThreadSpecific.
*/
uint32_t
OSGetThreadSpecific(uint32_t id);
uint32_t OSGetThreadSpecific(uint32_t id);
/**
* Returns TRUE if a thread is suspended.
*/
BOOL
OSIsThreadSuspended(OSThread *thread);
BOOL OSIsThreadSuspended(OSThread *thread);
/**
* Returns TRUE if a thread is terminated.
*/
BOOL
OSIsThreadTerminated(OSThread *thread);
BOOL OSIsThreadTerminated(OSThread *thread);
/**
@ -460,9 +383,8 @@ OSIsThreadTerminated(OSThread *thread);
* \param threadResult Pointer to store thread exit value in.
* \returns Returns TRUE if thread has terminated, FALSE if thread is detached.
*/
BOOL
OSJoinThread(OSThread *thread,
int *threadResult);
BOOL OSJoinThread(OSThread *thread,
int *threadResult);
/**
@ -473,8 +395,7 @@ OSJoinThread(OSThread *thread,
*
* \returns Returns the previous value of the suspend counter.
*/
int32_t
OSResumeThread(OSThread *thread);
int32_t OSResumeThread(OSThread *thread);
/**
@ -482,11 +403,10 @@ OSResumeThread(OSThread *thread);
*
* Can only be used on idle threads.
*/
BOOL
OSRunThread(OSThread *thread,
OSThreadEntryPointFn entry,
int argc,
const char **argv);
BOOL OSRunThread(OSThread *thread,
OSThreadEntryPointFn entry,
int argc,
const char **argv);
/**
@ -633,5 +553,3 @@ OSYieldThread();
#ifdef __cplusplus
}
#endif
/** @} */

44
wiiu/wut/include/coreinit/threadqueue.h
View File

@ -1,61 +1,35 @@
#pragma once
#include <wut.h>
/**
* \defgroup coreinit_threadq Thread Queue
* \ingroup coreinit
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct OSThread OSThread;
typedef struct OSThreadLink OSThreadLink;
typedef struct OSThreadQueue OSThreadQueue;
typedef struct OSThreadSimpleQueue OSThreadSimpleQueue;
struct OSThreadLink
typedef struct
{
OSThread *prev;
OSThread *next;
};
CHECK_OFFSET(OSThreadLink, 0x00, prev);
CHECK_OFFSET(OSThreadLink, 0x04, next);
CHECK_SIZE(OSThreadLink, 0x8);
}OSThreadLink;
struct OSThreadQueue
typedef struct
{
OSThread *head;
OSThread *tail;
void *parent;
UNKNOWN(4);
};
CHECK_OFFSET(OSThreadQueue, 0x00, head);
CHECK_OFFSET(OSThreadQueue, 0x04, tail);
CHECK_OFFSET(OSThreadQueue, 0x08, parent);
CHECK_SIZE(OSThreadQueue, 0x10);
uint32_t __unknown;
}OSThreadQueue;
struct OSThreadSimpleQueue
typedef struct
{
OSThread *head;
OSThread *tail;
};
CHECK_OFFSET(OSThreadSimpleQueue, 0x00, head);
CHECK_OFFSET(OSThreadSimpleQueue, 0x04, tail);
CHECK_SIZE(OSThreadSimpleQueue, 0x08);
}OSThreadSimpleQueue;
void
OSInitThreadQueue(OSThreadQueue *queue);
void
OSInitThreadQueueEx(OSThreadQueue *queue,
void *parent);
void OSInitThreadQueue(OSThreadQueue *queue);
void OSInitThreadQueueEx(OSThreadQueue *queue, void *parent);
#ifdef __cplusplus
}
#endif
/** @} */

59
wiiu/wut/include/gx2/clear.h
View File

@ -1,59 +0,0 @@
#pragma once
#include <wut.h>
#include "enum.h"
/**
* \defgroup gx2_clear Clear
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2ColorBuffer GX2ColorBuffer;
typedef struct GX2DepthBuffer GX2DepthBuffer;
void
GX2ClearColor(GX2ColorBuffer *colorBuffer,
float red,
float green,
float blue,
float alpha);
void
GX2ClearDepthStencilEx(GX2DepthBuffer *depthBuffer,
float depth,
uint8_t stencil,
GX2ClearFlags clearMode);
void
GX2ClearBuffersEx(GX2ColorBuffer *colorBuffer,
GX2DepthBuffer *depthBuffer,
float red,
float green,
float blue,
float alpha,
float depth,
uint8_t stencil,
GX2ClearFlags clearMode);
void
GX2SetClearDepth(GX2DepthBuffer *depthBuffer,
float depth);
void
GX2SetClearStencil(GX2DepthBuffer *depthBuffer,
uint8_t stencil);
void
GX2SetClearDepthStencil(GX2DepthBuffer *depthBuffer,
float depth,
uint8_t stencil);
#ifdef __cplusplus
}
#endif
/** @} */

58
wiiu/wut/include/gx2/context.h
View File

@ -1,69 +1,37 @@
#pragma once
#include <wut.h>
/**
* \defgroup gx2_context Context State
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2ShadowState GX2ShadowState;
typedef struct GX2ContextState GX2ContextState;
struct GX2ShadowState
typedef struct GX2ShadowState
{
uint32_t config[0xB00];
uint32_t context[0x400];
uint32_t alu[0x800];
uint32_t loop[0x60];
PADDING((0x80 - 0x60) * 4);
uint32_t __unk_0[0x20];
uint32_t resource[0xD9E];
PADDING((0xDC0 - 0xD9E) * 4);
uint32_t __unk_1[0x22];
uint32_t sampler[0xA2];
PADDING((0xC0 - 0xA2) * 4);
};
CHECK_OFFSET(GX2ShadowState, 0x0000, config);
CHECK_OFFSET(GX2ShadowState, 0x2C00, context);
CHECK_OFFSET(GX2ShadowState, 0x3C00, alu);
CHECK_OFFSET(GX2ShadowState, 0x5C00, loop);
CHECK_OFFSET(GX2ShadowState, 0x5E00, resource);
CHECK_OFFSET(GX2ShadowState, 0x9500, sampler);
CHECK_SIZE(GX2ShadowState, 0x9800);
uint32_t __unk_2[0x3C];
} GX2ShadowState;
struct GX2ContextState
typedef struct GX2ContextState
{
GX2ShadowState shadowState;
UNKNOWN(4);
uint32_t __unk_0;
uint32_t shadowDisplayListSize;
UNKNOWN(0x9e00 - 0x9808);
uint32_t __unk_1[0x2FC];
uint32_t shadowDisplayList[192];
};
CHECK_OFFSET(GX2ContextState, 0x0000, shadowState);
CHECK_OFFSET(GX2ContextState, 0x9804, shadowDisplayListSize);
CHECK_OFFSET(GX2ContextState, 0x9e00, shadowDisplayList);
CHECK_SIZE(GX2ContextState, 0xa100);
} GX2ContextState;
void
GX2SetupContextStateEx(GX2ContextState *state,
BOOL unk1);
void
GX2GetContextStateDisplayList(GX2ContextState *state,
void *outDisplayList,
uint32_t *outSize);
void
GX2SetContextState(GX2ContextState *state);
void
GX2SetDefaultState();
void GX2SetupContextStateEx(GX2ContextState *state, BOOL unk1);
void GX2GetContextStateDisplayList(GX2ContextState *state, void *outDisplayList, uint32_t *outSize);
void GX2SetContextState(GX2ContextState *state);
void GX2SetDefaultState();
#ifdef __cplusplus
}
#endif
/** @} */

73
wiiu/wut/include/gx2/display.h
View File

@ -3,66 +3,39 @@
#include "enum.h"
#include "surface.h"
/**
* \defgroup gx2_display Display
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void
GX2SetTVEnable(BOOL enable);
void GX2SetTVEnable(BOOL enable);
void GX2SetDRCEnable(BOOL enable);
void
GX2SetDRCEnable(BOOL enable);
void GX2CalcTVSize(GX2TVRenderMode tvRenderMode,
GX2SurfaceFormat surfaceFormat,
GX2BufferingMode bufferingMode,
uint32_t *size, uint32_t *unkOut);
void
GX2CalcTVSize(GX2TVRenderMode tvRenderMode,
GX2SurfaceFormat surfaceFormat,
GX2BufferingMode bufferingMode,
uint32_t *size,
uint32_t *unkOut);
void GX2CalcDRCSize(GX2DrcRenderMode drcRenderMode,
GX2SurfaceFormat surfaceFormat,
GX2BufferingMode bufferingMode,
uint32_t *size, uint32_t *unkOut);
void
GX2CalcDRCSize(GX2DrcRenderMode drcRenderMode,
GX2SurfaceFormat surfaceFormat,
GX2BufferingMode bufferingMode,
uint32_t *size,
uint32_t *unkOut);
void GX2SetTVBuffer(void *buffer, uint32_t size,
GX2TVRenderMode tvRenderMode,
GX2SurfaceFormat surfaceFormat,
GX2BufferingMode bufferingMode);
void
GX2SetTVBuffer(void *buffer,
uint32_t size,
GX2TVRenderMode tvRenderMode,
GX2SurfaceFormat surfaceFormat,
GX2BufferingMode bufferingMode);
void GX2SetDRCBuffer(void *buffer, uint32_t size,
GX2DrcRenderMode drcRenderMode,
GX2SurfaceFormat surfaceFormat,
GX2BufferingMode bufferingMode);
void
GX2SetDRCBuffer(void *buffer,
uint32_t size,
GX2DrcRenderMode drcRenderMode,
GX2SurfaceFormat surfaceFormat,
GX2BufferingMode bufferingMode);
void GX2SetTVScale(uint32_t x, uint32_t y);
void GX2SetDRCScale(uint32_t x, uint32_t y);
void
GX2SetTVScale(uint32_t x,
uint32_t y);
void
GX2SetDRCScale(uint32_t x,
uint32_t y);
GX2TVScanMode
GX2GetSystemTVScanMode();
GX2TVScanMode
GX2GetSystemDRCScanMode();
GX2DrcRenderMode
GX2GetSystemDRCMode();
GX2TVScanMode GX2GetSystemTVScanMode();
GX2TVScanMode GX2GetSystemDRCScanMode();
GX2DrcRenderMode GX2GetSystemDRCMode();
#ifdef __cplusplus
}

38
wiiu/wut/include/gx2/displaylist.h
View File

@ -1,42 +1,18 @@
#pragma once
#include <wut.h>
/**
* \defgroup gx2_displaylist Display List
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void
GX2BeginDisplayListEx(void *displayList,
uint32_t bytes,
BOOL unk1);
uint32_t
GX2EndDisplayList(void *displayList);
void
GX2DirectCallDisplayList(void *displayList,
uint32_t bytes);
void
GX2CallDisplayList(void *displayList,
uint32_t bytes);
BOOL
GX2GetDisplayListWriteStatus();
BOOL
GX2GetCurrentDisplayList(void **outDisplayList,
uint32_t *outSize);
void
GX2CopyDisplayList(void *displayList,
uint32_t bytes);
GX2BeginDisplayListEx(void *displayList, uint32_t bytes, BOOL unk1);
uint32_t GX2EndDisplayList(void *displayList);
void GX2DirectCallDisplayList(void *displayList, uint32_t bytes);
void GX2CallDisplayList(void *displayList, uint32_t bytes);
BOOL GX2GetDisplayListWriteStatus();
BOOL GX2GetCurrentDisplayList(void **outDisplayList, uint32_t *outSize);
void GX2CopyDisplayList(void *displayList, uint32_t bytes);
#ifdef __cplusplus
}

75
wiiu/wut/include/gx2/draw.h
View File

@ -2,62 +2,47 @@
#include <wut.h>
#include "enum.h"
/**
* \defgroup gx2_draw Draw
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void
GX2SetAttribBuffer(uint32_t index,
uint32_t size,
uint32_t stride,
void *buffer);
void GX2SetAttribBuffer(uint32_t index, uint32_t size, uint32_t stride, void *buffer);
void
GX2DrawEx(GX2PrimitiveMode mode,
uint32_t count,
uint32_t offset,
uint32_t numInstances);
void GX2DrawEx(GX2PrimitiveMode mode,
uint32_t count,
uint32_t offset,
uint32_t numInstances);
void
GX2DrawEx2(GX2PrimitiveMode mode,
uint32_t count,
uint32_t offset,
uint32_t numInstances,
uint32_t baseInstance);
void GX2DrawEx2(GX2PrimitiveMode mode,
uint32_t count,
uint32_t offset,
uint32_t numInstances,
uint32_t baseInstance);
void
GX2DrawIndexedEx(GX2PrimitiveMode mode,
uint32_t count,
GX2IndexType indexType,
void *indices,
uint32_t offset,
uint32_t numInstances);
void GX2DrawIndexedEx(GX2PrimitiveMode mode,
uint32_t count,
GX2IndexType indexType,
void *indices,
uint32_t offset,
uint32_t numInstances);
void
GX2DrawIndexedEx2(GX2PrimitiveMode mode,
uint32_t count,
GX2IndexType indexType,
void *indices,
uint32_t offset,
uint32_t numInstances,
uint32_t baseInstance);
void GX2DrawIndexedEx2(GX2PrimitiveMode mode,
uint32_t count,
GX2IndexType indexType,
void *indices,
uint32_t offset,
uint32_t numInstances,
uint32_t baseInstance);
void
GX2DrawIndexedImmediateEx(GX2PrimitiveMode mode,
uint32_t count,
GX2IndexType indexType,
void *indices,
uint32_t offset,
uint32_t numInstances);
void GX2DrawIndexedImmediateEx(GX2PrimitiveMode mode,
uint32_t count,
GX2IndexType indexType,
void *indices,
uint32_t offset,
uint32_t numInstances);
void
GX2SetPrimitiveRestartIndex(uint32_t index);
void GX2SetPrimitiveRestartIndex(uint32_t index);
#ifdef __cplusplus
}

8
wiiu/wut/include/gx2/enum.h
View File

@ -1,12 +1,6 @@
#pragma once
#include <wut.h>
/**
* \defgroup gx2_enum Enums
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -502,5 +496,3 @@ typedef enum GX2TVScanMode
#ifdef __cplusplus
}
#endif
/** @} */

68
wiiu/wut/include/gx2/event.h
View File

@ -3,74 +3,30 @@
#include <coreinit/time.h>
#include "enum.h"
/**
* \defgroup gx2_event Event
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2DisplayListOverrunData GX2DisplayListOverrunData;
typedef void (*GX2EventCallbackFunction)(GX2EventType, void *);
struct GX2DisplayListOverrunData
typedef struct GX2DisplayListOverrunData
{
//! Pointer to overrun display list
void *oldList;
//! Size of overrun display list
uint32_t oldSize;
//! Pointer to new display list
void *newList;
//! Size of new display list
uint32_t newSize;
uint32_t __unk[0x2];
} GX2DisplayListOverrunData;
UNKNOWN(8);
};
CHECK_OFFSET(GX2DisplayListOverrunData, 0x00, oldList);
CHECK_OFFSET(GX2DisplayListOverrunData, 0x04, oldSize);
CHECK_OFFSET(GX2DisplayListOverrunData, 0x08, newList);
CHECK_OFFSET(GX2DisplayListOverrunData, 0x0C, newSize);
CHECK_SIZE(GX2DisplayListOverrunData, 0x18);
BOOL
GX2DrawDone();
void
GX2WaitForVsync();
void
GX2WaitForFlip();
void
GX2SetEventCallback(GX2EventType type,
GX2EventCallbackFunction func,
void *userData);
void
GX2GetEventCallback(GX2EventType type,
GX2EventCallbackFunction *funcOut,
void **userDataOut);
OSTime
GX2GetRetiredTimeStamp();
OSTime
GX2GetLastSubmittedTimeStamp();
BOOL
GX2WaitTimeStamp(OSTime time);
void
GX2GetSwapStatus(uint32_t *swapCount,
uint32_t *flipCount,
OSTime *lastFlip,
OSTime *lastVsync);
BOOL GX2DrawDone();
void GX2WaitForVsync();
void GX2WaitForFlip();
void GX2SetEventCallback(GX2EventType type, GX2EventCallbackFunction func, void *userData);
void GX2GetEventCallback(GX2EventType type, GX2EventCallbackFunction *funcOut, void **userDataOut);
OSTime GX2GetRetiredTimeStamp();
OSTime GX2GetLastSubmittedTimeStamp();
BOOL GX2WaitTimeStamp(OSTime time);
void GX2GetSwapStatus(uint32_t *swapCount, uint32_t *flipCount, OSTime *lastFlip, OSTime *lastVsync);
#ifdef __cplusplus
}

11
wiiu/wut/include/gx2/mem.h
View File

@ -2,20 +2,11 @@
#include <wut.h>
#include "enum.h"
/**
* \defgroup gx2_mem Memory
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void
GX2Invalidate(GX2InvalidateMode mode,
void *buffer,
uint32_t size);
void GX2Invalidate(GX2InvalidateMode mode, void *buffer, uint32_t size);
#ifdef __cplusplus
}

848
wiiu/wut/include/gx2/registers.h
View File

@ -3,161 +3,97 @@
#include "enum.h"
#include "surface.h"
/**
* \defgroup gx2_registers Registers
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2AAMaskReg GX2AAMaskReg;
typedef struct GX2AlphaTestReg GX2AlphaTestReg;
typedef struct GX2AlphaToMaskReg GX2AlphaToMaskReg;
typedef struct GX2BlendControlReg GX2BlendControlReg;
typedef struct GX2BlendConstantColorReg GX2BlendConstantColorReg;
typedef struct GX2ColorControlReg GX2ColorControlReg;
typedef struct GX2DepthStencilControlReg GX2DepthStencilControlReg;
typedef struct GX2StencilMaskReg GX2StencilMaskReg;
typedef struct GX2LineWidthReg GX2LineWidthReg;
typedef struct GX2PointSizeReg GX2PointSizeReg;
typedef struct GX2PointLimitsReg GX2PointLimitsReg;
typedef struct GX2PolygonControlReg GX2PolygonControlReg;
typedef struct GX2PolygonOffsetReg GX2PolygonOffsetReg;
typedef struct GX2ScissorReg GX2ScissorReg;
typedef struct GX2TargetChannelMaskReg GX2TargetChannelMaskReg;
typedef struct GX2ViewportReg GX2ViewportReg;
struct GX2AAMaskReg
typedef struct GX2AAMaskReg
{
uint32_t pa_sc_aa_mask;
};
CHECK_OFFSET(GX2AAMaskReg, 0, pa_sc_aa_mask);
CHECK_SIZE(GX2AAMaskReg, 4);
} GX2AAMaskReg;
struct GX2AlphaTestReg
typedef struct GX2AlphaTestReg
{
uint32_t sx_alpha_test_control;
uint32_t sx_alpha_ref;
};
CHECK_OFFSET(GX2AlphaTestReg, 0, sx_alpha_test_control);
CHECK_OFFSET(GX2AlphaTestReg, 4, sx_alpha_ref);
CHECK_SIZE(GX2AlphaTestReg, 8);
} GX2AlphaTestReg;
struct GX2AlphaToMaskReg
typedef struct GX2AlphaToMaskReg
{
uint32_t db_alpha_to_mask;
};
CHECK_OFFSET(GX2AlphaToMaskReg, 0, db_alpha_to_mask);
CHECK_SIZE(GX2AlphaToMaskReg, 4);
} GX2AlphaToMaskReg;
struct GX2BlendControlReg
typedef struct GX2BlendControlReg
{
GX2RenderTarget target;
uint32_t cb_blend_control;
};
CHECK_OFFSET(GX2BlendControlReg, 0, target);
CHECK_OFFSET(GX2BlendControlReg, 4, cb_blend_control);
CHECK_SIZE(GX2BlendControlReg, 8);
} GX2BlendControlReg;
struct GX2BlendConstantColorReg
typedef struct GX2BlendConstantColorReg
{
float red;
float green;
float blue;
float alpha;
};
CHECK_OFFSET(GX2BlendConstantColorReg, 0x00, red);
CHECK_OFFSET(GX2BlendConstantColorReg, 0x04, green);
CHECK_OFFSET(GX2BlendConstantColorReg, 0x08, blue);
CHECK_OFFSET(GX2BlendConstantColorReg, 0x0c, alpha);
CHECK_SIZE(GX2BlendConstantColorReg, 0x10);
} GX2BlendConstantColorReg;
struct GX2ColorControlReg
typedef struct GX2ColorControlReg
{
uint32_t cb_color_control;
};
CHECK_OFFSET(GX2ColorControlReg, 0x00, cb_color_control);
CHECK_SIZE(GX2ColorControlReg, 4);
} GX2ColorControlReg;
struct GX2DepthStencilControlReg
typedef struct GX2DepthStencilControlReg
{
uint32_t db_depth_control;
};
CHECK_OFFSET(GX2DepthStencilControlReg, 0, db_depth_control);
CHECK_SIZE(GX2DepthStencilControlReg, 4);
} GX2DepthStencilControlReg;
struct GX2StencilMaskReg
typedef struct GX2StencilMaskReg
{
uint32_t db_stencilrefmask;
uint32_t db_stencilrefmask_bf;
};
CHECK_OFFSET(GX2StencilMaskReg, 0, db_stencilrefmask);
CHECK_OFFSET(GX2StencilMaskReg, 4, db_stencilrefmask_bf);
CHECK_SIZE(GX2StencilMaskReg, 8);
} GX2StencilMaskReg;
struct GX2LineWidthReg
typedef struct GX2LineWidthReg
{
uint32_t pa_su_line_cntl;
};
CHECK_OFFSET(GX2LineWidthReg, 0, pa_su_line_cntl);
CHECK_SIZE(GX2LineWidthReg, 4);
} GX2LineWidthReg;
struct GX2PointSizeReg
typedef struct GX2PointSizeReg
{
uint32_t pa_su_point_size;
};
CHECK_OFFSET(GX2PointSizeReg, 0, pa_su_point_size);
CHECK_SIZE(GX2PointSizeReg, 4);
} GX2PointSizeReg;
struct GX2PointLimitsReg
typedef struct GX2PointLimitsReg
{
uint32_t pa_su_point_minmax;
};
CHECK_OFFSET(GX2PointLimitsReg, 0, pa_su_point_minmax);
CHECK_SIZE(GX2PointLimitsReg, 4);
} GX2PointLimitsReg;
struct GX2PolygonControlReg
typedef struct GX2PolygonControlReg
{
uint32_t pa_su_sc_mode_cntl;
};
CHECK_OFFSET(GX2PolygonControlReg, 0, pa_su_sc_mode_cntl);
CHECK_SIZE(GX2PolygonControlReg, 4);
} GX2PolygonControlReg;
struct GX2PolygonOffsetReg
typedef struct GX2PolygonOffsetReg
{
uint32_t pa_su_poly_offset_front_scale;
uint32_t pa_su_poly_offset_front_offset;
uint32_t pa_su_poly_offset_back_scale;
uint32_t pa_su_poly_offset_back_offset;
uint32_t pa_su_poly_offset_clamp;
};
CHECK_OFFSET(GX2PolygonOffsetReg, 0x00, pa_su_poly_offset_front_scale);
CHECK_OFFSET(GX2PolygonOffsetReg, 0x04, pa_su_poly_offset_front_offset);
CHECK_OFFSET(GX2PolygonOffsetReg, 0x08, pa_su_poly_offset_back_scale);
CHECK_OFFSET(GX2PolygonOffsetReg, 0x0C, pa_su_poly_offset_back_offset);
CHECK_OFFSET(GX2PolygonOffsetReg, 0x10, pa_su_poly_offset_clamp);
CHECK_SIZE(GX2PolygonOffsetReg, 20);
} GX2PolygonOffsetReg;
struct GX2ScissorReg
typedef struct GX2ScissorReg
{
uint32_t pa_sc_generic_scissor_tl;
uint32_t pa_sc_generic_scissor_br;
};
CHECK_OFFSET(GX2ScissorReg, 0x00, pa_sc_generic_scissor_tl);
CHECK_OFFSET(GX2ScissorReg, 0x04, pa_sc_generic_scissor_br);
CHECK_SIZE(GX2ScissorReg, 8);
} GX2ScissorReg;
struct GX2TargetChannelMaskReg
typedef struct GX2TargetChannelMaskReg
{
uint32_t cb_target_mask;
};
CHECK_OFFSET(GX2TargetChannelMaskReg, 0x00, cb_target_mask);
CHECK_SIZE(GX2TargetChannelMaskReg, 4);
} GX2TargetChannelMaskReg;
struct GX2ViewportReg
typedef struct GX2ViewportReg
{
uint32_t pa_cl_vport_xscale;
uint32_t pa_cl_vport_xoffset;
@ -171,450 +107,370 @@ struct GX2ViewportReg
uint32_t pa_cl_gb_horz_disc_adj;
uint32_t pa_sc_vport_zmin;
uint32_t pa_sc_vport_zmax;
};
CHECK_OFFSET(GX2ViewportReg, 0x00, pa_cl_vport_xscale);
CHECK_OFFSET(GX2ViewportReg, 0x04, pa_cl_vport_xoffset);
CHECK_OFFSET(GX2ViewportReg, 0x08, pa_cl_vport_yscale);
CHECK_OFFSET(GX2ViewportReg, 0x0C, pa_cl_vport_yoffset);
CHECK_OFFSET(GX2ViewportReg, 0x10, pa_cl_vport_zscale);
CHECK_OFFSET(GX2ViewportReg, 0x14, pa_cl_vport_zoffset);
CHECK_OFFSET(GX2ViewportReg, 0x18, pa_cl_gb_vert_clip_adj);
CHECK_OFFSET(GX2ViewportReg, 0x1C, pa_cl_gb_vert_disc_adj);
CHECK_OFFSET(GX2ViewportReg, 0x20, pa_cl_gb_horz_clip_adj);
CHECK_OFFSET(GX2ViewportReg, 0x24, pa_cl_gb_horz_disc_adj);
CHECK_OFFSET(GX2ViewportReg, 0x28, pa_sc_vport_zmin);
CHECK_OFFSET(GX2ViewportReg, 0x2C, pa_sc_vport_zmax);
CHECK_SIZE(GX2ViewportReg, 48);
} GX2ViewportReg;
void
GX2SetAAMask(uint8_t upperLeft,
uint8_t upperRight,
uint8_t lowerLeft,
uint8_t lowerRight);
void GX2SetAAMask(uint8_t upperLeft,
uint8_t upperRight,
uint8_t lowerLeft,
uint8_t lowerRight);
void
GX2InitAAMaskReg(GX2AAMaskReg *reg,
uint8_t upperLeft,
uint8_t upperRight,
uint8_t lowerLeft,
uint8_t lowerRight);
void GX2InitAAMaskReg(GX2AAMaskReg *reg,
uint8_t upperLeft,
uint8_t upperRight,
uint8_t lowerLeft,
uint8_t lowerRight);
void
GX2GetAAMaskReg(GX2AAMaskReg *reg,
uint8_t *upperLeft,
uint8_t *upperRight,
uint8_t *lowerLeft,
uint8_t *lowerRight);
void GX2GetAAMaskReg(GX2AAMaskReg *reg,
uint8_t *upperLeft,
uint8_t *upperRight,
uint8_t *lowerLeft,
uint8_t *lowerRight);
void
GX2SetAAMaskReg(GX2AAMaskReg *reg);
void GX2SetAAMaskReg(GX2AAMaskReg *reg);
void
GX2SetAlphaTest(BOOL alphaTest,
GX2CompareFunction func,
float ref);
void GX2SetAlphaTest(BOOL alphaTest,
GX2CompareFunction func,
float ref);
void
GX2InitAlphaTestReg(GX2AlphaTestReg *reg,
BOOL alphaTest,
GX2CompareFunction func,
float ref);
void GX2InitAlphaTestReg(GX2AlphaTestReg *reg,
BOOL alphaTest,
GX2CompareFunction func,
float ref);
void
GX2GetAlphaTestReg(const GX2AlphaTestReg *reg,
BOOL *alphaTest,
GX2CompareFunction *func,
float *ref);
void GX2GetAlphaTestReg(const GX2AlphaTestReg *reg,
BOOL *alphaTest,
GX2CompareFunction *func,
float *ref);
void
GX2SetAlphaTestReg(GX2AlphaTestReg *reg);
void GX2SetAlphaTestReg(GX2AlphaTestReg *reg);
void
GX2SetAlphaToMask(BOOL alphaToMask,
GX2AlphaToMaskMode mode);
void GX2SetAlphaToMask(BOOL alphaToMask,
GX2AlphaToMaskMode mode);
void
GX2InitAlphaToMaskReg(GX2AlphaToMaskReg *reg,
BOOL alphaToMask,
GX2AlphaToMaskMode mode);
void GX2InitAlphaToMaskReg(GX2AlphaToMaskReg *reg,
BOOL alphaToMask,
GX2AlphaToMaskMode mode);
void
GX2GetAlphaToMaskReg(const GX2AlphaToMaskReg *reg,
BOOL *alphaToMask,
GX2AlphaToMaskMode *mode);
void GX2GetAlphaToMaskReg(const GX2AlphaToMaskReg *reg,
BOOL *alphaToMask,
GX2AlphaToMaskMode *mode);
void
GX2SetAlphaToMaskReg(GX2AlphaToMaskReg *reg);
void GX2SetAlphaToMaskReg(GX2AlphaToMaskReg *reg);
void
GX2SetBlendConstantColor(float red,
float green,
float blue,
float alpha);
void GX2SetBlendConstantColor(float red,
float green,
float blue,
float alpha);
void
GX2InitBlendConstantColorReg(GX2BlendConstantColorReg *reg,
float red,
float green,
float blue,
float alpha);
void GX2InitBlendConstantColorReg(GX2BlendConstantColorReg *reg,
float red,
float green,
float blue,
float alpha);
void
GX2GetBlendConstantColorReg(GX2BlendConstantColorReg *reg,
float *red,
float *green,
float *blue,
float *alpha);
void GX2GetBlendConstantColorReg(GX2BlendConstantColorReg *reg,
float *red,
float *green,
float *blue,
float *alpha);
void
GX2SetBlendConstantColorReg(GX2BlendConstantColorReg *reg);
void GX2SetBlendConstantColorReg(GX2BlendConstantColorReg *reg);
void
GX2SetBlendControl(GX2RenderTarget target,
GX2BlendMode colorSrcBlend,
GX2BlendMode colorDstBlend,
GX2BlendCombineMode colorCombine,
BOOL useAlphaBlend,
GX2BlendMode alphaSrcBlend,
GX2BlendMode alphaDstBlend,
GX2BlendCombineMode alphaCombine);
void GX2SetBlendControl(GX2RenderTarget target,
GX2BlendMode colorSrcBlend,
GX2BlendMode colorDstBlend,
GX2BlendCombineMode colorCombine,
BOOL useAlphaBlend,
GX2BlendMode alphaSrcBlend,
GX2BlendMode alphaDstBlend,
GX2BlendCombineMode alphaCombine);
void
GX2InitBlendControlReg(GX2BlendControlReg *reg,
GX2RenderTarget target,
GX2BlendMode colorSrcBlend,
GX2BlendMode colorDstBlend,
GX2BlendCombineMode colorCombine,
BOOL useAlphaBlend,
GX2BlendMode alphaSrcBlend,
GX2BlendMode alphaDstBlend,
GX2BlendCombineMode alphaCombine);
void GX2InitBlendControlReg(GX2BlendControlReg *reg,
GX2RenderTarget target,
GX2BlendMode colorSrcBlend,
GX2BlendMode colorDstBlend,
GX2BlendCombineMode colorCombine,
BOOL useAlphaBlend,
GX2BlendMode alphaSrcBlend,
GX2BlendMode alphaDstBlend,
GX2BlendCombineMode alphaCombine);
void
GX2GetBlendControlReg(GX2BlendControlReg *reg,
GX2RenderTarget *target,
GX2BlendMode *colorSrcBlend,
GX2BlendMode *colorDstBlend,
GX2BlendCombineMode *colorCombine,
BOOL *useAlphaBlend,
GX2BlendMode *alphaSrcBlend,
GX2BlendMode *alphaDstBlend,
GX2BlendCombineMode *alphaCombine);
void GX2GetBlendControlReg(GX2BlendControlReg *reg,
GX2RenderTarget *target,
GX2BlendMode *colorSrcBlend,
GX2BlendMode *colorDstBlend,
GX2BlendCombineMode *colorCombine,
BOOL *useAlphaBlend,
GX2BlendMode *alphaSrcBlend,
GX2BlendMode *alphaDstBlend,
GX2BlendCombineMode *alphaCombine);
void
GX2SetBlendControlReg(GX2BlendControlReg *reg);
void GX2SetBlendControlReg(GX2BlendControlReg *reg);
void
GX2SetColorControl(GX2LogicOp rop3,
uint8_t targetBlendEnable,
BOOL multiWriteEnable,
BOOL colorWriteEnable);
void GX2SetColorControl(GX2LogicOp rop3,
uint8_t targetBlendEnable,
BOOL multiWriteEnable,
BOOL colorWriteEnable);
void
GX2InitColorControlReg(GX2ColorControlReg *reg,
GX2LogicOp rop3,
uint8_t targetBlendEnable,
BOOL multiWriteEnable,
BOOL colorWriteEnable);
void GX2InitColorControlReg(GX2ColorControlReg *reg,
GX2LogicOp rop3,
uint8_t targetBlendEnable,
BOOL multiWriteEnable,
BOOL colorWriteEnable);
void
GX2GetColorControlReg(GX2ColorControlReg *reg,
GX2LogicOp *rop3,
uint8_t *targetBlendEnable,
BOOL *multiWriteEnable,
BOOL *colorWriteEnable);
void GX2GetColorControlReg(GX2ColorControlReg *reg,
GX2LogicOp *rop3,
uint8_t *targetBlendEnable,
BOOL *multiWriteEnable,
BOOL *colorWriteEnable);
void
GX2SetColorControlReg(GX2ColorControlReg *reg);
void GX2SetColorControlReg(GX2ColorControlReg *reg);
void
GX2SetDepthOnlyControl(BOOL depthTest,
BOOL depthWrite,
GX2CompareFunction depthCompare);
void GX2SetDepthOnlyControl(BOOL depthTest,
BOOL depthWrite,
GX2CompareFunction depthCompare);
void
GX2SetDepthStencilControl(BOOL depthTest,
BOOL depthWrite,
GX2CompareFunction depthCompare,
BOOL stencilTest,
BOOL backfaceStencil,
GX2CompareFunction frontStencilFunc,
GX2StencilFunction frontStencilZPass,
GX2StencilFunction frontStencilZFail,
GX2StencilFunction frontStencilFail,
GX2CompareFunction backStencilFunc,
GX2StencilFunction backStencilZPass,
GX2StencilFunction backStencilZFail,
GX2StencilFunction backStencilFail);
void GX2SetDepthStencilControl(BOOL depthTest,
BOOL depthWrite,
GX2CompareFunction depthCompare,
BOOL stencilTest,
BOOL backfaceStencil,
GX2CompareFunction frontStencilFunc,
GX2StencilFunction frontStencilZPass,
GX2StencilFunction frontStencilZFail,
GX2StencilFunction frontStencilFail,
GX2CompareFunction backStencilFunc,
GX2StencilFunction backStencilZPass,
GX2StencilFunction backStencilZFail,
GX2StencilFunction backStencilFail);
void
GX2InitDepthStencilControlReg(GX2DepthStencilControlReg *reg,
BOOL depthTest,
BOOL depthWrite,
GX2CompareFunction depthCompare,
BOOL stencilTest,
BOOL backfaceStencil,
GX2CompareFunction frontStencilFunc,
GX2StencilFunction frontStencilZPass,
GX2StencilFunction frontStencilZFail,
GX2StencilFunction frontStencilFail,
GX2CompareFunction backStencilFunc,
GX2StencilFunction backStencilZPass,
GX2StencilFunction backStencilZFail,
GX2StencilFunction backStencilFail);
void GX2InitDepthStencilControlReg(GX2DepthStencilControlReg *reg,
BOOL depthTest,
BOOL depthWrite,
GX2CompareFunction depthCompare,
BOOL stencilTest,
BOOL backfaceStencil,
GX2CompareFunction frontStencilFunc,
GX2StencilFunction frontStencilZPass,
GX2StencilFunction frontStencilZFail,
GX2StencilFunction frontStencilFail,
GX2CompareFunction backStencilFunc,
GX2StencilFunction backStencilZPass,
GX2StencilFunction backStencilZFail,
GX2StencilFunction backStencilFail);
void
GX2GetDepthStencilControlReg(GX2DepthStencilControlReg *reg,
BOOL *depthTest,
BOOL *depthWrite,
GX2CompareFunction *depthCompare,
BOOL *stencilTest,
BOOL *backfaceStencil,
GX2CompareFunction *frontStencilFunc,
GX2StencilFunction *frontStencilZPass,
GX2StencilFunction *frontStencilZFail,
GX2StencilFunction *frontStencilFail,
GX2CompareFunction *backStencilFunc,
GX2StencilFunction *backStencilZPass,
GX2StencilFunction *backStencilZFail,
GX2StencilFunction *backStencilFail);
void GX2GetDepthStencilControlReg(GX2DepthStencilControlReg *reg,
BOOL *depthTest,
BOOL *depthWrite,
GX2CompareFunction *depthCompare,
BOOL *stencilTest,
BOOL *backfaceStencil,
GX2CompareFunction *frontStencilFunc,
GX2StencilFunction *frontStencilZPass,
GX2StencilFunction *frontStencilZFail,
GX2StencilFunction *frontStencilFail,
GX2CompareFunction *backStencilFunc,
GX2StencilFunction *backStencilZPass,
GX2StencilFunction *backStencilZFail,
GX2StencilFunction *backStencilFail);
void
GX2SetDepthStencilControlReg(GX2DepthStencilControlReg *reg);
void GX2SetDepthStencilControlReg(GX2DepthStencilControlReg *reg);
void
GX2SetStencilMask(uint8_t frontMask,
uint8_t frontWriteMask,
uint8_t frontRef,
uint8_t backMask,
uint8_t backWriteMask,
uint8_t backRef);
void GX2SetStencilMask(uint8_t frontMask,
uint8_t frontWriteMask,
uint8_t frontRef,
uint8_t backMask,
uint8_t backWriteMask,
uint8_t backRef);
void
GX2InitStencilMaskReg(GX2StencilMaskReg *reg,
uint8_t frontMask,
uint8_t frontWriteMask,
uint8_t frontRef,
uint8_t backMask,
uint8_t backWriteMask,
uint8_t backRef);
void GX2InitStencilMaskReg(GX2StencilMaskReg *reg,
uint8_t frontMask,
uint8_t frontWriteMask,
uint8_t frontRef,
uint8_t backMask,
uint8_t backWriteMask,
uint8_t backRef);
void
GX2GetStencilMaskReg(GX2StencilMaskReg *reg,
uint8_t *frontMask,
uint8_t *frontWriteMask,
uint8_t *frontRef,
uint8_t *backMask,
uint8_t *backWriteMask,
uint8_t *backRef);
void GX2GetStencilMaskReg(GX2StencilMaskReg *reg,
uint8_t *frontMask,
uint8_t *frontWriteMask,
uint8_t *frontRef,
uint8_t *backMask,
uint8_t *backWriteMask,
uint8_t *backRef);
void
GX2SetStencilMaskReg(GX2StencilMaskReg *reg);
void GX2SetStencilMaskReg(GX2StencilMaskReg *reg);
void
GX2SetLineWidth(float width);
void GX2SetLineWidth(float width);
void
GX2InitLineWidthReg(GX2LineWidthReg *reg,
float width);
void GX2InitLineWidthReg(GX2LineWidthReg *reg,
float width);
void
GX2GetLineWidthReg(GX2LineWidthReg *reg,
float *width);
void GX2GetLineWidthReg(GX2LineWidthReg *reg,
float *width);
void
GX2SetLineWidthReg(GX2LineWidthReg *reg);
void GX2SetLineWidthReg(GX2LineWidthReg *reg);
void
GX2SetPointSize(float width,
float height);
void GX2SetPointSize(float width,
float height);
void
GX2InitPointSizeReg(GX2PointSizeReg *reg,
void GX2InitPointSizeReg(GX2PointSizeReg *reg,
float width,
float height);
void GX2GetPointSizeReg(GX2PointSizeReg *reg,
float *width,
float *height);
void GX2SetPointSizeReg(GX2PointSizeReg *reg);
void GX2SetPointLimits(float min,
float max);
void GX2InitPointLimitsReg(GX2PointLimitsReg *reg,
float min,
float max);
void GX2GetPointLimitsReg(GX2PointLimitsReg *reg,
float *min,
float *max);
void GX2SetPointLimitsReg(GX2PointLimitsReg *reg);
void GX2SetCullOnlyControl(GX2FrontFace frontFace,
BOOL cullFront,
BOOL cullBack);
void GX2SetPolygonControl(GX2FrontFace frontFace,
BOOL cullFront,
BOOL cullBack,
BOOL polyMode,
GX2PolygonMode polyModeFront,
GX2PolygonMode polyModeBack,
BOOL polyOffsetFrontEnable,
BOOL polyOffsetBackEnable,
BOOL polyOffsetParaEnable);
void GX2InitPolygonControlReg(GX2PolygonControlReg *reg,
GX2FrontFace frontFace,
BOOL cullFront,
BOOL cullBack,
BOOL polyMode,
GX2PolygonMode polyModeFront,
GX2PolygonMode polyModeBack,
BOOL polyOffsetFrontEnable,
BOOL polyOffsetBackEnable,
BOOL polyOffsetParaEnable);
void GX2GetPolygonControlReg(GX2PolygonControlReg *reg,
GX2FrontFace *frontFace,
BOOL *cullFront,
BOOL *cullBack,
BOOL *polyMode,
GX2PolygonMode *polyModeFront,
GX2PolygonMode *polyModeBack,
BOOL *polyOffsetFrontEnable,
BOOL *polyOffsetBackEnable,
BOOL *polyOffsetParaEnable);
void GX2SetPolygonControlReg(GX2PolygonControlReg *reg);
void GX2SetPolygonOffset(float frontOffset,
float frontScale,
float backOffset,
float backScale,
float clamp);
void GX2InitPolygonOffsetReg(GX2PolygonOffsetReg *reg,
float frontOffset,
float frontScale,
float backOffset,
float backScale,
float clamp);
void GX2GetPolygonOffsetReg(GX2PolygonOffsetReg *reg,
float *frontOffset,
float *frontScale,
float *backOffset,
float *backScale,
float *clamp);
void GX2SetPolygonOffsetReg(GX2PolygonOffsetReg *reg);
void GX2SetScissor(uint32_t x,
uint32_t y,
uint32_t width,
uint32_t height);
void GX2InitScissorReg(GX2ScissorReg *reg,
uint32_t x,
uint32_t y,
uint32_t width,
uint32_t height);
void GX2GetScissorReg(GX2ScissorReg *reg,
uint32_t *x,
uint32_t *y,
uint32_t *width,
uint32_t *height);
void GX2SetScissorReg(GX2ScissorReg *reg);
void GX2SetTargetChannelMasks(GX2ChannelMask mask0,
GX2ChannelMask mask1,
GX2ChannelMask mask2,
GX2ChannelMask mask3,
GX2ChannelMask mask4,
GX2ChannelMask mask5,
GX2ChannelMask mask6,
GX2ChannelMask mask7);
void GX2InitTargetChannelMasksReg(GX2TargetChannelMaskReg *reg,
GX2ChannelMask mask0,
GX2ChannelMask mask1,
GX2ChannelMask mask2,
GX2ChannelMask mask3,
GX2ChannelMask mask4,
GX2ChannelMask mask5,
GX2ChannelMask mask6,
GX2ChannelMask mask7);
void GX2GetTargetChannelMasksReg(GX2TargetChannelMaskReg *reg,
GX2ChannelMask *mask0,
GX2ChannelMask *mask1,
GX2ChannelMask *mask2,
GX2ChannelMask *mask3,
GX2ChannelMask *mask4,
GX2ChannelMask *mask5,
GX2ChannelMask *mask6,
GX2ChannelMask *mask7);
void GX2SetTargetChannelMasksReg(GX2TargetChannelMaskReg *reg);
void GX2SetViewport(float x,
float y,
float width,
float height);
float height,
float nearZ,
float farZ);
void
GX2GetPointSizeReg(GX2PointSizeReg *reg,
float *width,
float *height);
void GX2InitViewportReg(GX2ViewportReg *reg,
float x,
float y,
float width,
float height,
float nearZ,
float farZ);
void
GX2SetPointSizeReg(GX2PointSizeReg *reg);
void
GX2SetPointLimits(float min,
float max);
void
GX2InitPointLimitsReg(GX2PointLimitsReg *reg,
float min,
float max);
void
GX2GetPointLimitsReg(GX2PointLimitsReg *reg,
float *min,
float *max);
void
GX2SetPointLimitsReg(GX2PointLimitsReg *reg);
void
GX2SetCullOnlyControl(GX2FrontFace frontFace,
BOOL cullFront,
BOOL cullBack);
void
GX2SetPolygonControl(GX2FrontFace frontFace,
BOOL cullFront,
BOOL cullBack,
BOOL polyMode,
GX2PolygonMode polyModeFront,
GX2PolygonMode polyModeBack,
BOOL polyOffsetFrontEnable,
BOOL polyOffsetBackEnable,
BOOL polyOffsetParaEnable);
void
GX2InitPolygonControlReg(GX2PolygonControlReg *reg,
GX2FrontFace frontFace,
BOOL cullFront,
BOOL cullBack,
BOOL polyMode,
GX2PolygonMode polyModeFront,
GX2PolygonMode polyModeBack,
BOOL polyOffsetFrontEnable,
BOOL polyOffsetBackEnable,
BOOL polyOffsetParaEnable);
void
GX2GetPolygonControlReg(GX2PolygonControlReg *reg,
GX2FrontFace *frontFace,
BOOL *cullFront,
BOOL *cullBack,
BOOL *polyMode,
GX2PolygonMode *polyModeFront,
GX2PolygonMode *polyModeBack,
BOOL *polyOffsetFrontEnable,
BOOL *polyOffsetBackEnable,
BOOL *polyOffsetParaEnable);
void
GX2SetPolygonControlReg(GX2PolygonControlReg *reg);
void
GX2SetPolygonOffset(float frontOffset,
float frontScale,
float backOffset,
float backScale,
float clamp);
void
GX2InitPolygonOffsetReg(GX2PolygonOffsetReg *reg,
float frontOffset,
float frontScale,
float backOffset,
float backScale,
float clamp);
void
GX2GetPolygonOffsetReg(GX2PolygonOffsetReg *reg,
float *frontOffset,
float *frontScale,
float *backOffset,
float *backScale,
float *clamp);
void
GX2SetPolygonOffsetReg(GX2PolygonOffsetReg *reg);
void
GX2SetScissor(uint32_t x,
uint32_t y,
uint32_t width,
uint32_t height);
void
GX2InitScissorReg(GX2ScissorReg *reg,
uint32_t x,
uint32_t y,
uint32_t width,
uint32_t height);
void
GX2GetScissorReg(GX2ScissorReg *reg,
uint32_t *x,
uint32_t *y,
uint32_t *width,
uint32_t *height);
void
GX2SetScissorReg(GX2ScissorReg *reg);
void
GX2SetTargetChannelMasks(GX2ChannelMask mask0,
GX2ChannelMask mask1,
GX2ChannelMask mask2,
GX2ChannelMask mask3,
GX2ChannelMask mask4,
GX2ChannelMask mask5,
GX2ChannelMask mask6,
GX2ChannelMask mask7);
void
GX2InitTargetChannelMasksReg(GX2TargetChannelMaskReg *reg,
GX2ChannelMask mask0,
GX2ChannelMask mask1,
GX2ChannelMask mask2,
GX2ChannelMask mask3,
GX2ChannelMask mask4,
GX2ChannelMask mask5,
GX2ChannelMask mask6,
GX2ChannelMask mask7);
void
GX2GetTargetChannelMasksReg(GX2TargetChannelMaskReg *reg,
GX2ChannelMask *mask0,
GX2ChannelMask *mask1,
GX2ChannelMask *mask2,
GX2ChannelMask *mask3,
GX2ChannelMask *mask4,
GX2ChannelMask *mask5,
GX2ChannelMask *mask6,
GX2ChannelMask *mask7);
void
GX2SetTargetChannelMasksReg(GX2TargetChannelMaskReg *reg);
void
GX2SetViewport(float x,
float y,
float width,
float height,
float nearZ,
float farZ);
void
GX2InitViewportReg(GX2ViewportReg *reg,
float x,
float y,
float width,
float height,
float nearZ,
float farZ);
void
GX2GetViewportReg(GX2ViewportReg *reg,
float *x,
float *y,
float *width,
float *height,
float *nearZ,
float *farZ);
void
GX2SetViewportReg(GX2ViewportReg *reg);
void GX2GetViewportReg(GX2ViewportReg *reg,
float *x,
float *y,
float *width,
float *height,
float *nearZ,
float *farZ);
void GX2SetViewportReg(GX2ViewportReg *reg);
#ifdef __cplusplus
}
#endif

84
wiiu/wut/include/gx2/sampler.h
View File

@ -2,74 +2,56 @@
#include <wut.h>
#include "enum.h"
/**
* \defgroup gx2_sampler Sampler
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2Sampler GX2Sampler;
struct GX2Sampler
typedef struct GX2Sampler
{
uint32_t regs[3];
};
CHECK_SIZE(GX2Sampler, 12);
} GX2Sampler;
void
GX2InitSampler(GX2Sampler *sampler,
GX2TexClampMode clampMode,
GX2TexXYFilterMode minMagFilterMode);
void GX2InitSampler(GX2Sampler *sampler,
GX2TexClampMode clampMode,
GX2TexXYFilterMode minMagFilterMode);
void
GX2InitSamplerBorderType(GX2Sampler *sampler,
GX2TexBorderType borderType);
void GX2InitSamplerBorderType(GX2Sampler *sampler,
GX2TexBorderType borderType);
void
GX2InitSamplerClamping(GX2Sampler *sampler,
GX2TexClampMode clampX,
GX2TexClampMode clampY,
GX2TexClampMode clampZ);
void GX2InitSamplerClamping(GX2Sampler *sampler,
GX2TexClampMode clampX,
GX2TexClampMode clampY,
GX2TexClampMode clampZ);
void
GX2InitSamplerDepthCompare(GX2Sampler *sampler,
GX2CompareFunction depthCompare);
void GX2InitSamplerDepthCompare(GX2Sampler *sampler,
GX2CompareFunction depthCompare);
void
GX2InitSamplerFilterAdjust(GX2Sampler *sampler,
BOOL highPrecision,
GX2TexMipPerfMode perfMip,
GX2TexZPerfMode perfZ);
void GX2InitSamplerFilterAdjust(GX2Sampler *sampler,
BOOL highPrecision,
GX2TexMipPerfMode perfMip,
GX2TexZPerfMode perfZ);
void
GX2InitSamplerLOD(GX2Sampler *sampler,
float lodMin,
float lodMax,
float lodBias);
void GX2InitSamplerLOD(GX2Sampler *sampler,
float lodMin,
float lodMax,
float lodBias);
void
GX2InitSamplerLODAdjust(GX2Sampler *sampler,
float unk1,
BOOL unk2);
void GX2InitSamplerLODAdjust(GX2Sampler *sampler,
float unk1,
BOOL unk2);
void
GX2InitSamplerRoundingMode(GX2Sampler *sampler,
GX2RoundingMode roundingMode);
void GX2InitSamplerRoundingMode(GX2Sampler *sampler,
GX2RoundingMode roundingMode);
void
GX2InitSamplerXYFilter(GX2Sampler *sampler,
GX2TexXYFilterMode filterMag,
GX2TexXYFilterMode filterMin,
GX2TexAnisoRatio maxAniso);
void GX2InitSamplerXYFilter(GX2Sampler *sampler,
GX2TexXYFilterMode filterMag,
GX2TexXYFilterMode filterMin,
GX2TexAnisoRatio maxAniso);
void
GX2InitSamplerZMFilter(GX2Sampler *sampler,
GX2TexZFilterMode filterZ,
GX2TexMipFilterMode filterMip);
void GX2InitSamplerZMFilter(GX2Sampler *sampler,
GX2TexZFilterMode filterZ,
GX2TexMipFilterMode filterMip);
#ifdef __cplusplus
}

317
wiiu/wut/include/gx2/shaders.h
View File

@ -4,29 +4,11 @@
#include "sampler.h"
#include "gx2r/buffer.h"
/**
* \defgroup gx2_shader Shaders
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2AttribVar GX2AttribVar;
typedef struct GX2AttribStream GX2AttribStream;
typedef struct GX2FetchShader GX2FetchShader;
typedef struct GX2GeometryShader GX2GeometryShader;
typedef struct GX2LoopVar GX2LoopVar;
typedef struct GX2PixelShader GX2PixelShader;
typedef struct GX2SamplerVar GX2SamplerVar;
typedef struct GX2UniformBlock GX2UniformBlock;
typedef struct GX2UniformVar GX2UniformVar;
typedef struct GX2UniformInitialValue GX2UniformInitialValue;
typedef struct GX2VertexShader GX2VertexShader;
struct GX2FetchShader
typedef struct GX2FetchShader
{
GX2FetchShaderType type;
@ -40,85 +22,52 @@ struct GX2FetchShader
uint32_t attribCount;
uint32_t numDivisors;
uint32_t divisors[2];
};
CHECK_OFFSET(GX2FetchShader, 0x0, type);
CHECK_OFFSET(GX2FetchShader, 0x4, regs.sq_pgm_resources_fs);
CHECK_OFFSET(GX2FetchShader, 0x8, size);
CHECK_OFFSET(GX2FetchShader, 0xc, program);
CHECK_OFFSET(GX2FetchShader, 0x10, attribCount);
CHECK_OFFSET(GX2FetchShader, 0x14, numDivisors);
CHECK_OFFSET(GX2FetchShader, 0x18, divisors);
CHECK_SIZE(GX2FetchShader, 0x20);
} GX2FetchShader;
struct GX2UniformBlock
typedef struct GX2UniformBlock
{
const char *name;
uint32_t offset;
uint32_t size;
};
CHECK_OFFSET(GX2UniformBlock, 0x00, name);
CHECK_OFFSET(GX2UniformBlock, 0x04, offset);
CHECK_OFFSET(GX2UniformBlock, 0x08, size);
CHECK_SIZE(GX2UniformBlock, 0x0C);
} GX2UniformBlock;
struct GX2UniformVar
typedef struct GX2UniformVar
{
const char *name;
GX2ShaderVarType type;
uint32_t count;
uint32_t offset;
int32_t block;
};
CHECK_OFFSET(GX2UniformVar, 0x00, name);
CHECK_OFFSET(GX2UniformVar, 0x04, type);
CHECK_OFFSET(GX2UniformVar, 0x08, count);
CHECK_OFFSET(GX2UniformVar, 0x0C, offset);
CHECK_OFFSET(GX2UniformVar, 0x10, block);
CHECK_SIZE(GX2UniformVar, 0x14);
} GX2UniformVar;
struct GX2UniformInitialValue
typedef struct GX2UniformInitialValue
{
float value[4];
uint32_t offset;
};
CHECK_OFFSET(GX2UniformInitialValue, 0x00, value);
CHECK_OFFSET(GX2UniformInitialValue, 0x10, offset);
CHECK_SIZE(GX2UniformInitialValue, 0x14);
} GX2UniformInitialValue;
struct GX2LoopVar
typedef struct GX2LoopVar
{
uint32_t offset;
uint32_t value;
};
CHECK_OFFSET(GX2LoopVar, 0x00, offset);
CHECK_OFFSET(GX2LoopVar, 0x04, value);
CHECK_SIZE(GX2LoopVar, 0x08);
} GX2LoopVar;
struct GX2SamplerVar
typedef struct GX2SamplerVar
{
const char *name;
GX2SamplerVarType type;
uint32_t location;
};
CHECK_OFFSET(GX2SamplerVar, 0x00, name);
CHECK_OFFSET(GX2SamplerVar, 0x04, type);
CHECK_OFFSET(GX2SamplerVar, 0x08, location);
CHECK_SIZE(GX2SamplerVar, 0x0C);
} GX2SamplerVar;
struct GX2AttribVar
typedef struct GX2AttribVar
{
const char *name;
GX2ShaderVarType type;
uint32_t count;
uint32_t location;
};
CHECK_OFFSET(GX2AttribVar, 0x00, name);
CHECK_OFFSET(GX2AttribVar, 0x04, type);
CHECK_OFFSET(GX2AttribVar, 0x08, count);
CHECK_OFFSET(GX2AttribVar, 0x0C, location);
CHECK_SIZE(GX2AttribVar, 0x10);
} GX2AttribVar;
struct GX2VertexShader
typedef struct GX2VertexShader
{
struct
{
@ -164,41 +113,9 @@ struct GX2VertexShader
uint32_t streamOutStride[4];
GX2RBuffer gx2rBuffer;
};
CHECK_OFFSET(GX2VertexShader, 0x00, regs.sq_pgm_resources_vs);
CHECK_OFFSET(GX2VertexShader, 0x04, regs.vgt_primitiveid_en);
CHECK_OFFSET(GX2VertexShader, 0x08, regs.spi_vs_out_config);
CHECK_OFFSET(GX2VertexShader, 0x0C, regs.num_spi_vs_out_id);
CHECK_OFFSET(GX2VertexShader, 0x10, regs.spi_vs_out_id);
CHECK_OFFSET(GX2VertexShader, 0x38, regs.pa_cl_vs_out_cntl);
CHECK_OFFSET(GX2VertexShader, 0x3C, regs.sq_vtx_semantic_clear);
CHECK_OFFSET(GX2VertexShader, 0x40, regs.num_sq_vtx_semantic);
CHECK_OFFSET(GX2VertexShader, 0x44, regs.sq_vtx_semantic);
CHECK_OFFSET(GX2VertexShader, 0xC4, regs.vgt_strmout_buffer_en);
CHECK_OFFSET(GX2VertexShader, 0xC8, regs.vgt_vertex_reuse_block_cntl);
CHECK_OFFSET(GX2VertexShader, 0xCC, regs.vgt_hos_reuse_depth);
CHECK_OFFSET(GX2VertexShader, 0xD0, size);
CHECK_OFFSET(GX2VertexShader, 0xD4, program);
CHECK_OFFSET(GX2VertexShader, 0xD8, mode);
CHECK_OFFSET(GX2VertexShader, 0xDc, uniformBlockCount);
CHECK_OFFSET(GX2VertexShader, 0xE0, uniformBlocks);
CHECK_OFFSET(GX2VertexShader, 0xE4, uniformVarCount);
CHECK_OFFSET(GX2VertexShader, 0xE8, uniformVars);
CHECK_OFFSET(GX2VertexShader, 0xEc, initialValueCount);
CHECK_OFFSET(GX2VertexShader, 0xF0, initialValues);
CHECK_OFFSET(GX2VertexShader, 0xF4, loopVarCount);
CHECK_OFFSET(GX2VertexShader, 0xF8, loopVars);
CHECK_OFFSET(GX2VertexShader, 0xFc, samplerVarCount);
CHECK_OFFSET(GX2VertexShader, 0x100, samplerVars);
CHECK_OFFSET(GX2VertexShader, 0x104, attribVarCount);
CHECK_OFFSET(GX2VertexShader, 0x108, attribVars);
CHECK_OFFSET(GX2VertexShader, 0x10c, ringItemsize);
CHECK_OFFSET(GX2VertexShader, 0x110, hasStreamOut);
CHECK_OFFSET(GX2VertexShader, 0x114, streamOutStride);
CHECK_OFFSET(GX2VertexShader, 0x124, gx2rBuffer);
CHECK_SIZE(GX2VertexShader, 0x134);
} GX2VertexShader;
struct GX2PixelShader
typedef struct GX2PixelShader
{
struct
{
@ -234,34 +151,9 @@ struct GX2PixelShader
GX2SamplerVar *samplerVars;
GX2RBuffer gx2rBuffer;
};
CHECK_OFFSET(GX2PixelShader, 0x00, regs.sq_pgm_resources_ps);
CHECK_OFFSET(GX2PixelShader, 0x04, regs.sq_pgm_exports_ps);
CHECK_OFFSET(GX2PixelShader, 0x08, regs.spi_ps_in_control_0);
CHECK_OFFSET(GX2PixelShader, 0x0C, regs.spi_ps_in_control_1);
CHECK_OFFSET(GX2PixelShader, 0x10, regs.num_spi_ps_input_cntl);
CHECK_OFFSET(GX2PixelShader, 0x14, regs.spi_ps_input_cntls);
CHECK_OFFSET(GX2PixelShader, 0x94, regs.cb_shader_mask);
CHECK_OFFSET(GX2PixelShader, 0x98, regs.cb_shader_control);
CHECK_OFFSET(GX2PixelShader, 0x9C, regs.db_shader_control);
CHECK_OFFSET(GX2PixelShader, 0xA0, regs.spi_input_z);
CHECK_OFFSET(GX2PixelShader, 0xA4, size);
CHECK_OFFSET(GX2PixelShader, 0xA8, program);
CHECK_OFFSET(GX2PixelShader, 0xAC, mode);
CHECK_OFFSET(GX2PixelShader, 0xB0, uniformBlockCount);
CHECK_OFFSET(GX2PixelShader, 0xB4, uniformBlocks);
CHECK_OFFSET(GX2PixelShader, 0xB8, uniformVarCount);
CHECK_OFFSET(GX2PixelShader, 0xBC, uniformVars);
CHECK_OFFSET(GX2PixelShader, 0xC0, initialValueCount);
CHECK_OFFSET(GX2PixelShader, 0xC4, initialValues);
CHECK_OFFSET(GX2PixelShader, 0xC8, loopVarCount);
CHECK_OFFSET(GX2PixelShader, 0xCC, loopVars);
CHECK_OFFSET(GX2PixelShader, 0xD0, samplerVarCount);
CHECK_OFFSET(GX2PixelShader, 0xD4, samplerVars);
CHECK_OFFSET(GX2PixelShader, 0xD8, gx2rBuffer);
CHECK_SIZE(GX2PixelShader, 0xE8);
} GX2PixelShader;
struct GX2GeometryShader
typedef struct GX2GeometryShader
{
struct
{
@ -303,39 +195,9 @@ struct GX2GeometryShader
uint32_t streamOutStride[4];
GX2RBuffer gx2rBuffer;
};
CHECK_OFFSET(GX2GeometryShader, 0x00, regs.sq_pgm_resources_gs);
CHECK_OFFSET(GX2GeometryShader, 0x04, regs.vgt_gs_out_prim_type);
CHECK_OFFSET(GX2GeometryShader, 0x08, regs.vgt_gs_mode);
CHECK_OFFSET(GX2GeometryShader, 0x0C, regs.pa_cl_vs_out_cntl);
CHECK_OFFSET(GX2GeometryShader, 0x10, regs.sq_pgm_resources_vs);
CHECK_OFFSET(GX2GeometryShader, 0x14, regs.sq_gs_vert_itemsize);
CHECK_OFFSET(GX2GeometryShader, 0x18, regs.spi_vs_out_config);
CHECK_OFFSET(GX2GeometryShader, 0x1C, regs.num_spi_vs_out_id);
CHECK_OFFSET(GX2GeometryShader, 0x20, regs.spi_vs_out_id);
CHECK_OFFSET(GX2GeometryShader, 0x48, regs.vgt_strmout_buffer_en);
CHECK_OFFSET(GX2GeometryShader, 0x4C, size);
CHECK_OFFSET(GX2GeometryShader, 0x50, program);
CHECK_OFFSET(GX2GeometryShader, 0x54, vertexProgramSize);
CHECK_OFFSET(GX2GeometryShader, 0x58, vertexProgram);
CHECK_OFFSET(GX2GeometryShader, 0x5C, mode);
CHECK_OFFSET(GX2GeometryShader, 0x60, uniformBlockCount);
CHECK_OFFSET(GX2GeometryShader, 0x64, uniformBlocks);
CHECK_OFFSET(GX2GeometryShader, 0x68, uniformVarCount);
CHECK_OFFSET(GX2GeometryShader, 0x6C, uniformVars);
CHECK_OFFSET(GX2GeometryShader, 0x70, initialValueCount);
CHECK_OFFSET(GX2GeometryShader, 0x74, initialValues);
CHECK_OFFSET(GX2GeometryShader, 0x78, loopVarCount);
CHECK_OFFSET(GX2GeometryShader, 0x7C, loopVars);
CHECK_OFFSET(GX2GeometryShader, 0x80, samplerVarCount);
CHECK_OFFSET(GX2GeometryShader, 0x84, samplerVars);
CHECK_OFFSET(GX2GeometryShader, 0x88, ringItemSize);
CHECK_OFFSET(GX2GeometryShader, 0x8C, hasStreamOut);
CHECK_OFFSET(GX2GeometryShader, 0x90, streamOutStride);
CHECK_OFFSET(GX2GeometryShader, 0xA0, gx2rBuffer);
CHECK_SIZE(GX2GeometryShader, 0xB0);
} GX2GeometryShader;
struct GX2AttribStream
typedef struct GX2AttribStream
{
uint32_t location;
uint32_t buffer;
@ -345,119 +207,46 @@ struct GX2AttribStream
uint32_t aluDivisor;
uint32_t mask;
GX2EndianSwapMode endianSwap;
};
CHECK_OFFSET(GX2AttribStream, 0x0, location);
CHECK_OFFSET(GX2AttribStream, 0x4, buffer);
CHECK_OFFSET(GX2AttribStream, 0x8, offset);
CHECK_OFFSET(GX2AttribStream, 0xc, format);
CHECK_OFFSET(GX2AttribStream, 0x10, type);
CHECK_OFFSET(GX2AttribStream, 0x14, aluDivisor);
CHECK_OFFSET(GX2AttribStream, 0x18, mask);
CHECK_OFFSET(GX2AttribStream, 0x1c, endianSwap);
CHECK_SIZE(GX2AttribStream, 0x20);
} GX2AttribStream;
uint32_t
GX2CalcGeometryShaderInputRingBufferSize(uint32_t ringItemSize);
uint32_t GX2CalcGeometryShaderInputRingBufferSize(uint32_t ringItemSize);
uint32_t GX2CalcGeometryShaderOutputRingBufferSize(uint32_t ringItemSize);
uint32_t
GX2CalcGeometryShaderOutputRingBufferSize(uint32_t ringItemSize);
uint32_t GX2CalcFetchShaderSizeEx(uint32_t attribs, GX2FetchShaderType fetchShaderType,
GX2TessellationMode tesellationMode);
uint32_t
GX2CalcFetchShaderSizeEx(uint32_t attribs,
GX2FetchShaderType fetchShaderType,
GX2TessellationMode tesellationMode);
void GX2InitFetchShaderEx(GX2FetchShader *fetchShader, uint8_t *buffer, uint32_t attribCount,
GX2AttribStream *attribs, GX2FetchShaderType type, GX2TessellationMode tessMode);
void
GX2InitFetchShaderEx(GX2FetchShader *fetchShader,
uint8_t *buffer,
uint32_t attribCount,
GX2AttribStream *attribs,
GX2FetchShaderType type,
GX2TessellationMode tessMode);
void GX2SetFetchShader(GX2FetchShader *shader);
void GX2SetVertexShader(GX2VertexShader *shader);
void GX2SetPixelShader(GX2PixelShader *shader);
void GX2SetGeometryShader(GX2GeometryShader *shader);
void
GX2SetFetchShader(GX2FetchShader *shader);
void GX2SetVertexSampler(GX2Sampler *sampler, uint32_t id);
void GX2SetPixelSampler(GX2Sampler *sampler, uint32_t id);
void GX2SetGeometrySampler(GX2Sampler *sampler, uint32_t id);
void GX2SetVertexUniformReg(uint32_t offset, uint32_t count, uint32_t *data);
void GX2SetPixelUniformReg(uint32_t offset, uint32_t count, uint32_t *data);
void GX2SetVertexUniformBlock(uint32_t location, uint32_t size, const void *data);
void GX2SetPixelUniformBlock(uint32_t location, uint32_t size, const void *data);
void GX2SetGeometryUniformBlock(uint32_t location, uint32_t size, const void *data);
void
GX2SetVertexShader(GX2VertexShader *shader);
void GX2SetShaderModeEx(GX2ShaderMode mode,
uint32_t numVsGpr, uint32_t numVsStackEntries,
uint32_t numGsGpr, uint32_t numGsStackEntries,
uint32_t numPsGpr, uint32_t numPsStackEntries);
void
GX2SetPixelShader(GX2PixelShader *shader);
void GX2SetStreamOutEnable(BOOL enable);
void GX2SetGeometryShaderInputRingBuffer(void *buffer, uint32_t size);
void GX2SetGeometryShaderOutputRingBuffer(void *buffer, uint32_t size);
void
GX2SetGeometryShader(GX2GeometryShader *shader);
void
GX2SetVertexSampler(GX2Sampler *sampler,
uint32_t id);
void
GX2SetPixelSampler(GX2Sampler *sampler,
uint32_t id);
void
GX2SetGeometrySampler(GX2Sampler *sampler,
uint32_t id);
void
GX2SetVertexUniformReg(uint32_t offset,
uint32_t count,
uint32_t *data);
void
GX2SetPixelUniformReg(uint32_t offset,
uint32_t count,
uint32_t *data);
void
GX2SetVertexUniformBlock(uint32_t location,
uint32_t size,
const void *data);
void
GX2SetPixelUniformBlock(uint32_t location,
uint32_t size,
const void *data);
void
GX2SetGeometryUniformBlock(uint32_t location,
uint32_t size,
const void *data);
void
GX2SetShaderModeEx(GX2ShaderMode mode,
uint32_t numVsGpr, uint32_t numVsStackEntries,
uint32_t numGsGpr, uint32_t numGsStackEntries,
uint32_t numPsGpr, uint32_t numPsStackEntries);
void
GX2SetStreamOutEnable(BOOL enable);
void
GX2SetGeometryShaderInputRingBuffer(void *buffer,
uint32_t size);
void
GX2SetGeometryShaderOutputRingBuffer(void *buffer,
uint32_t size);
uint32_t
GX2GetPixelShaderGPRs(GX2PixelShader *shader);
uint32_t
GX2GetPixelShaderStackEntries(GX2PixelShader *shader);
uint32_t
GX2GetVertexShaderGPRs(GX2VertexShader *shader);
uint32_t
GX2GetVertexShaderStackEntries(GX2VertexShader *shader);
uint32_t
GX2GetGeometryShaderGPRs(GX2GeometryShader *shader);
uint32_t
GX2GetGeometryShaderStackEntries(GX2GeometryShader *shader);
uint32_t GX2GetPixelShaderGPRs(GX2PixelShader *shader);
uint32_t GX2GetPixelShaderStackEntries(GX2PixelShader *shader);
uint32_t GX2GetVertexShaderGPRs(GX2VertexShader *shader);
uint32_t GX2GetVertexShaderStackEntries(GX2VertexShader *shader);
uint32_t GX2GetGeometryShaderGPRs(GX2GeometryShader *shader);
uint32_t GX2GetGeometryShaderStackEntries(GX2GeometryShader *shader);
#ifdef __cplusplus
}

125
wiiu/wut/include/gx2/surface.h
View File

@ -2,21 +2,11 @@
#include <wut.h>
#include "enum.h"
/**
* \defgroup gx2_surface Surface
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2Surface GX2Surface;
typedef struct GX2DepthBuffer GX2DepthBuffer;
typedef struct GX2ColorBuffer GX2ColorBuffer;
struct GX2Surface
typedef struct GX2Surface
{
GX2SurfaceDim dim;
uint32_t width;
@ -35,30 +25,11 @@ struct GX2Surface
uint32_t alignment;
uint32_t pitch;
uint32_t mipLevelOffset[13];
};
CHECK_OFFSET(GX2Surface, 0x0, dim);
CHECK_OFFSET(GX2Surface, 0x4, width);
CHECK_OFFSET(GX2Surface, 0x8, height);
CHECK_OFFSET(GX2Surface, 0xc, depth);
CHECK_OFFSET(GX2Surface, 0x10, mipLevels);
CHECK_OFFSET(GX2Surface, 0x14, format);
CHECK_OFFSET(GX2Surface, 0x18, aa);
CHECK_OFFSET(GX2Surface, 0x1c, use);
CHECK_OFFSET(GX2Surface, 0x20, imageSize);
CHECK_OFFSET(GX2Surface, 0x24, image);
CHECK_OFFSET(GX2Surface, 0x28, mipmapSize);
CHECK_OFFSET(GX2Surface, 0x2c, mipmaps);
CHECK_OFFSET(GX2Surface, 0x30, tileMode);
CHECK_OFFSET(GX2Surface, 0x34, swizzle);
CHECK_OFFSET(GX2Surface, 0x38, alignment);
CHECK_OFFSET(GX2Surface, 0x3C, pitch);
CHECK_OFFSET(GX2Surface, 0x40, mipLevelOffset);
CHECK_SIZE(GX2Surface, 0x74);
} GX2Surface;
struct GX2DepthBuffer
typedef struct GX2DepthBuffer
{
GX2Surface surface;
uint32_t viewMip;
uint32_t viewFirstSlice;
uint32_t viewNumSlices;
@ -66,86 +37,42 @@ struct GX2DepthBuffer
uint32_t hiZSize;
float depthClear;
uint32_t stencilClear;
uint32_t regs[7];
};
CHECK_OFFSET(GX2DepthBuffer, 0x74, viewMip);
CHECK_OFFSET(GX2DepthBuffer, 0x78, viewFirstSlice);
CHECK_OFFSET(GX2DepthBuffer, 0x7C, viewNumSlices);
CHECK_OFFSET(GX2DepthBuffer, 0x80, hiZPtr);
CHECK_OFFSET(GX2DepthBuffer, 0x84, hiZSize);
CHECK_OFFSET(GX2DepthBuffer, 0x88, depthClear);
CHECK_OFFSET(GX2DepthBuffer, 0x8C, stencilClear);
CHECK_OFFSET(GX2DepthBuffer, 0x90, regs);
CHECK_SIZE(GX2DepthBuffer, 0xAC);
} GX2DepthBuffer;
struct GX2ColorBuffer
typedef struct GX2ColorBuffer
{
GX2Surface surface;
uint32_t viewMip;
uint32_t viewFirstSlice;
uint32_t viewNumSlices;
void *aaBuffer;
uint32_t aaSize;
uint32_t regs[5];
};
CHECK_OFFSET(GX2ColorBuffer, 0x74, viewMip);
CHECK_OFFSET(GX2ColorBuffer, 0x78, viewFirstSlice);
CHECK_OFFSET(GX2ColorBuffer, 0x7C, viewNumSlices);
CHECK_OFFSET(GX2ColorBuffer, 0x80, aaBuffer);
CHECK_OFFSET(GX2ColorBuffer, 0x84, aaSize);
CHECK_OFFSET(GX2ColorBuffer, 0x88, regs);
CHECK_SIZE(GX2ColorBuffer, 0x9C);
} GX2ColorBuffer;
void
GX2CalcSurfaceSizeAndAlignment(GX2Surface *surface);
void GX2CalcSurfaceSizeAndAlignment(GX2Surface *surface);
void GX2CalcDepthBufferHiZInfo(GX2DepthBuffer *depthBuffer, uint32_t *outSize, uint32_t *outAlignment);
void GX2CalcColorBufferAuxInfo(GX2ColorBuffer *surface, uint32_t *outSize, uint32_t *outAlignment);
void GX2SetColorBuffer(GX2ColorBuffer *colorBuffer, GX2RenderTarget target);
void GX2SetDepthBuffer(GX2DepthBuffer *depthBuffer);
void GX2InitColorBufferRegs(GX2ColorBuffer *colorBuffer);
void GX2InitDepthBufferRegs(GX2DepthBuffer *depthBuffer);
void GX2InitDepthBufferHiZEnable(GX2DepthBuffer *depthBuffer, BOOL enable);
void
GX2CalcDepthBufferHiZInfo(GX2DepthBuffer *depthBuffer,
uint32_t *outSize,
uint32_t *outAlignment);
void
GX2CalcColorBufferAuxInfo(GX2ColorBuffer *surface,
uint32_t *outSize,
uint32_t *outAlignment);
void
GX2SetColorBuffer(GX2ColorBuffer *colorBuffer,
GX2RenderTarget target);
void
GX2SetDepthBuffer(GX2DepthBuffer *depthBuffer);
void
GX2InitColorBufferRegs(GX2ColorBuffer *colorBuffer);
void
GX2InitDepthBufferRegs(GX2DepthBuffer *depthBuffer);
void
GX2InitDepthBufferHiZEnable(GX2DepthBuffer *depthBuffer,
BOOL enable);
uint32_t
GX2GetSurfaceSwizzle(GX2Surface *surface);
void
GX2SetSurfaceSwizzle(GX2Surface *surface,
uint32_t swizzle);
void
GX2CopySurface(GX2Surface *src,
uint32_t srcLevel,
uint32_t srcDepth,
GX2Surface *dst,
uint32_t dstLevel,
uint32_t dstDepth);
uint32_t GX2GetSurfaceSwizzle(GX2Surface *surface);
void GX2SetSurfaceSwizzle(GX2Surface *surface, uint32_t swizzle);
void GX2CopySurface(GX2Surface *src, uint32_t srcLevel, uint32_t srcDepth, GX2Surface *dst, uint32_t dstLevel,
uint32_t dstDepth);
void GX2ClearColor(GX2ColorBuffer *colorBuffer, float red, float green, float blue, float alpha);
void GX2ClearDepthStencilEx(GX2DepthBuffer *depthBuffer, float depth, uint8_t stencil, GX2ClearFlags clearMode);
void GX2ClearBuffersEx(GX2ColorBuffer *colorBuffer, GX2DepthBuffer *depthBuffer,
float red, float green, float blue, float alpha, float depth,
uint8_t stencil, GX2ClearFlags clearMode);
void GX2SetClearDepth(GX2DepthBuffer *depthBuffer, float depth);
void GX2SetClearStencil(GX2DepthBuffer *depthBuffer, uint8_t stencil);
void GX2SetClearDepthStencil(GX2DepthBuffer *depthBuffer, float depth, uint8_t stencil);
#ifdef __cplusplus
}
#endif
/** @} */

21
wiiu/wut/include/gx2/tessellation.h
View File

@ -3,29 +3,14 @@
#include <coreinit/time.h>
#include "enum.h"
/**
* \defgroup gx2_tessellation Tessellation
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void
GX2SetTessellation(GX2TessellationMode tessellationMode,
GX2PrimitiveMode primitiveMode,
GX2IndexType indexType);
void
GX2SetMinTessellationLevel(float min);
void
GX2SetMaxTessellationLevel(float max);
void GX2SetTessellation(GX2TessellationMode tessellationMode, GX2PrimitiveMode primitiveMode, GX2IndexType indexType);
void GX2SetMinTessellationLevel(float min);
void GX2SetMaxTessellationLevel(float max);
#ifdef __cplusplus
}
#endif
/** @} */

31
wiiu/wut/include/gx2/texture.h
View File

@ -2,11 +2,6 @@
#include <wut.h>
#include "surface.h"
/**
* \defgroup gx2_texture Texture
* \ingroup gx2
* @{
*/
#ifdef __cplusplus
extern "C" {
@ -25,29 +20,11 @@ struct GX2Texture
uint32_t regs[5];
};
CHECK_OFFSET(GX2Texture, 0x0, surface);
CHECK_OFFSET(GX2Texture, 0x74, viewFirstMip);
CHECK_OFFSET(GX2Texture, 0x78, viewNumMips);
CHECK_OFFSET(GX2Texture, 0x7c, viewFirstSlice);
CHECK_OFFSET(GX2Texture, 0x80, viewNumSlices);
CHECK_OFFSET(GX2Texture, 0x84, compMap);
CHECK_OFFSET(GX2Texture, 0x88, regs);
CHECK_SIZE(GX2Texture, 0x9c);
void
GX2InitTextureRegs(GX2Texture *texture);
void
GX2SetPixelTexture(GX2Texture *texture,
uint32_t unit);
void
GX2SetVertexTexture(GX2Texture *texture,
uint32_t unit);
void
GX2SetGeometryTexture(GX2Texture *texture,
uint32_t unit);
void GX2InitTextureRegs(GX2Texture *texture);
void GX2SetPixelTexture(GX2Texture *texture, uint32_t unit);
void GX2SetVertexTexture(GX2Texture *texture, uint32_t unit);
void GX2SetGeometryTexture(GX2Texture *texture, uint32_t unit);
#ifdef __cplusplus
}

78
wiiu/wut/include/gx2r/buffer.h
View File

@ -2,81 +2,31 @@
#include <wut.h>
#include "resource.h"
/**
* \defgroup gx2r_buffer Buffer
* \ingroup gx2r
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2RBuffer GX2RBuffer;
struct GX2RBuffer
typedef struct
{
GX2RResourceFlags flags;
uint32_t elemSize;
uint32_t elemCount;
void *buffer;
};
CHECK_SIZE(GX2RBuffer, 0x10);
CHECK_OFFSET(GX2RBuffer, 0x00, flags);
CHECK_OFFSET(GX2RBuffer, 0x04, elemSize);
CHECK_OFFSET(GX2RBuffer, 0x08, elemCount);
CHECK_OFFSET(GX2RBuffer, 0x0C, buffer);
} GX2RBuffer;
BOOL
GX2RBufferExists(GX2RBuffer *buffer);
BOOL
GX2RCreateBuffer(GX2RBuffer *buffer);
BOOL
GX2RCreateBufferUserMemory(GX2RBuffer *buffer,
void *memory,
uint32_t size);
void
GX2RDestroyBufferEx(GX2RBuffer *buffer,
GX2RResourceFlags flags);
uint32_t
GX2RGetBufferAlignment(GX2RResourceFlags flags);
uint32_t
GX2RGetBufferAllocationSize(GX2RBuffer *buffer);
void
GX2RInvalidateBuffer(GX2RBuffer *buffer,
GX2RResourceFlags flags);
void *
GX2RLockBufferEx(GX2RBuffer *buffer,
GX2RResourceFlags flags);
void
GX2RUnlockBufferEx(GX2RBuffer *buffer,
GX2RResourceFlags flags);
void
GX2RSetVertexUniformBlock(GX2RBuffer *buffer,
uint32_t location,
uint32_t offset);
void
GX2RSetPixelUniformBlock(GX2RBuffer *buffer,
uint32_t location,
uint32_t offset);
void
GX2RSetGeometryUniformBlock(GX2RBuffer *buffer,
uint32_t location,
uint32_t offset);
BOOL X2RBufferExists(GX2RBuffer *buffer);
BOOL X2RCreateBuffer(GX2RBuffer *buffer);
BOOL GX2RCreateBufferUserMemory(GX2RBuffer *buffer, void *memory, uint32_t size);
void GX2RDestroyBufferEx(GX2RBuffer *buffer, GX2RResourceFlags flags);
uint32_t GX2RGetBufferAlignment(GX2RResourceFlags flags);
uint32_t GX2RGetBufferAllocationSize(GX2RBuffer *buffer);
void GX2RInvalidateBuffer(GX2RBuffer *buffer, GX2RResourceFlags flags);
void *GX2RLockBufferEx(GX2RBuffer *buffer, GX2RResourceFlags flags);
void GX2RUnlockBufferEx(GX2RBuffer *buffer, GX2RResourceFlags flags);
void GX2RSetVertexUniformBlock(GX2RBuffer *buffer, uint32_t location, uint32_t offset);
void GX2RSetPixelUniformBlock(GX2RBuffer *buffer, uint32_t location, uint32_t offset);
void GX2RSetGeometryUniformBlock(GX2RBuffer *buffer, uint32_t location, uint32_t offset);
#ifdef __cplusplus
}
#endif
/** @} */

30
wiiu/wut/include/gx2r/displaylist.h
View File

@ -1,37 +1,17 @@
#pragma once
#include <wut.h>
#include "resource.h"
/**
* \defgroup gx2r_displaylist Display List
* \ingroup gx2r
* @{
*/
#include "buffer.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2RBuffer GX2RBuffer;
void
GX2RBeginDisplayListEx(GX2RBuffer *displayList,
uint32_t unknown,
GX2RResourceFlags flags);
uint32_t
GX2REndDisplayList(GX2RBuffer *displayList);
void
GX2RCallDisplayList(GX2RBuffer *displayList,
uint32_t size);
void
GX2RDirectCallDisplayList(GX2RBuffer *displayList,
uint32_t size);
void GX2RBeginDisplayListEx(GX2RBuffer *displayList, uint32_t unknown, GX2RResourceFlags flags);
uint32_t GX2REndDisplayList(GX2RBuffer *displayList);
void GX2RCallDisplayList(GX2RBuffer *displayList, uint32_t size);
void GX2RDirectCallDisplayList(GX2RBuffer *displayList, uint32_t size);
#ifdef __cplusplus
}
#endif
/** @} */

28
wiiu/wut/include/gx2r/draw.h
View File

@ -2,36 +2,16 @@
#include <wut.h>
#include <gx2/enum.h>
#include "resource.h"
/**
* \defgroup gx2r_draw Draw
* \ingroup gx2r
* @{
*/
#include "buffer.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2RBuffer GX2RBuffer;
void
GX2RSetAttributeBuffer(GX2RBuffer *buffer,
uint32_t index,
uint32_t stride,
uint32_t offset);
void
GX2RDrawIndexed(GX2PrimitiveMode mode,
GX2RBuffer *buffer,
GX2IndexType indexType,
uint32_t count,
uint32_t indexOffset,
uint32_t vertexOffset,
uint32_t numInstances);
void GX2RSetAttributeBuffer(GX2RBuffer *buffer, uint32_t index, uint32_t stride, uint32_t offset);
void GX2RDrawIndexed(GX2PrimitiveMode mode, GX2RBuffer *buffer, GX2IndexType indexType, uint32_t count,
uint32_t indexOffset, uint32_t vertexOffset, uint32_t numInstances);
#ifdef __cplusplus
}
#endif
/** @} */

22
wiiu/wut/include/gx2r/mem.h
View File

@ -2,30 +2,16 @@
#include <wut.h>
#include "resource.h"
/**
* \defgroup gx2r_mem Memory
* \ingroup gx2r
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef void * (*GX2RAllocFunction)(GX2RResourceFlags, uint32_t, uint32_t);
typedef void *(*GX2RAllocFunction)(GX2RResourceFlags, uint32_t, uint32_t);
typedef void (*GX2RFreeFunction)(GX2RResourceFlags, void *);
void
GX2RInvalidateMemory(GX2RResourceFlags flags,
void *buffer,
uint32_t size);
BOOL
GX2RIsUserMemory(GX2RResourceFlags flags);
void
GX2RSetAllocator(GX2RAllocFunction allocFn,
GX2RFreeFunction freeFn);
void GX2RInvalidateMemory(GX2RResourceFlags flags, void *buffer, uint32_t size);
BOOL GX2RIsUserMemory(GX2RResourceFlags flags);
void GX2RSetAllocator(GX2RAllocFunction allocFn, GX2RFreeFunction freeFn);
#ifdef __cplusplus
}

52
wiiu/wut/include/gx2r/resource.h
View File

@ -1,88 +1,38 @@
#pragma once
#include <wut.h>
/**
* \defgroup gx2r_resource Resource
* \ingroup gx2r
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef enum GX2RResourceFlags
typedef enum
{
//! This resource is to be used as a texture
GX2R_RESOURCE_BIND_TEXTURE = 1 << 0,
//! This resource is to be used as a colour buffer
GX2R_RESOURCE_BIND_COLOR_BUFFER = 1 << 1,
//! This resource is to be used as a depth buffer
GX2R_RESOURCE_BIND_DEPTH_BUFFER = 1 << 2,
//! This resource is to be used as a scan buffer
GX2R_RESOURCE_BIND_SCAN_BUFFER = 1 << 3,
//! This resource is to be used as a vertex buffer
GX2R_RESOURCE_BIND_VERTEX_BUFFER = 1 << 4,
//! This resource is to be used as a index buffer
GX2R_RESOURCE_BIND_INDEX_BUFFER = 1 << 5,
//! This resource is to be used as a uniform block
GX2R_RESOURCE_BIND_UNIFORM_BLOCK = 1 << 6,
//! This resource is to be used as a shader program
GX2R_RESOURCE_BIND_SHADER_PROGRAM = 1 << 7,
//! This resource is to be used as a stream output
GX2R_RESOURCE_BIND_STREAM_OUTPUT = 1 << 8,
//! This resource is to be used as a display list
GX2R_RESOURCE_BIND_DISPLAY_LIST = 1 << 9,
//! This resource is to be used as a geometry shader ring buffer
GX2R_RESOURCE_BIND_GS_RING_BUFFER = 1 << 10,
//! Invalidate resource for a CPU read
GX2R_RESOURCE_USAGE_CPU_READ = 1 << 11,
//! Invalidate resource for a CPU write
GX2R_RESOURCE_USAGE_CPU_WRITE = 1 << 12,
//! Invalidate resource for a GPU read
GX2R_RESOURCE_USAGE_GPU_READ = 1 << 13,
//! Invalidate resource for a GPU write
GX2R_RESOURCE_USAGE_GPU_WRITE = 1 << 14,
//! Invalidate resource for a DMA read
GX2R_RESOURCE_USAGE_DMA_READ = 1 << 15,
//! Invalidate resource for a DMA write
GX2R_RESOURCE_USAGE_DMA_WRITE = 1 << 16,
//! Force resource allocation to be in MEM1
GX2R_RESOURCE_USAGE_FORCE_MEM1 = 1 << 17,
//! Force resource allocation to be in MEM2
GX2R_RESOURCE_USAGE_FORCE_MEM2 = 1 << 18,
//! Disable CPU invalidation
GX2R_RESOURCE_DISABLE_CPU_INVALIDATE = 1 << 20,
//! Disable GPU invalidation
GX2R_RESOURCE_DISABLE_GPU_INVALIDATE = 1 << 21,
//! Resource is locked for read-only access
GX2R_RESOURCE_LOCKED_READ_ONLY = 1 << 22,
//! Resource is to be allocated in user memory
GX2R_RESOURCE_USER_MEMORY = 1 << 29,
//! Resource is locked for all access
GX2R_RESOURCE_LOCKED = 1 << 30,
} GX2RResourceFlags;

45
wiiu/wut/include/gx2r/surface.h
View File

@ -1,50 +1,19 @@
#pragma once
#include <wut.h>
#include <gx2/surface.h>
#include "resource.h"
/**
* \defgroup gx2r_surface Surface
* \ingroup gx2r
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct GX2Surface GX2Surface;
bool
GX2RCreateSurface(GX2Surface *surface,
GX2RResourceFlags flags);
bool
GX2RCreateSurfaceUserMemory(GX2Surface *surface,
uint8_t *image,
uint8_t *mipmap,
GX2RResourceFlags flags);
void
GX2RDestroySurfaceEx(GX2Surface *surface,
GX2RResourceFlags flags);
void
GX2RInvalidateSurface(GX2Surface *surface,
int32_t level,
GX2RResourceFlags flags);
void *
GX2RLockSurfaceEx(GX2Surface *surface,
int32_t level,
GX2RResourceFlags flags);
void
GX2RUnlockSurfaceEx(GX2Surface *surface,
int32_t level,
GX2RResourceFlags flags);
bool GX2RCreateSurface(GX2Surface *surface, GX2RResourceFlags flags);
bool GX2RCreateSurfaceUserMemory(GX2Surface *surface, uint8_t *image, uint8_t *mipmap, GX2RResourceFlags flags);
void GX2RDestroySurfaceEx(GX2Surface *surface, GX2RResourceFlags flags);
void GX2RInvalidateSurface(GX2Surface *surface, int32_t level, GX2RResourceFlags flags);
void *GX2RLockSurfaceEx(GX2Surface *surface, int32_t level, GX2RResourceFlags flags);
void GX2RUnlockSurfaceEx(GX2Surface *surface, int32_t level, GX2RResourceFlags flags);
#ifdef __cplusplus
}
#endif
/** @} */

148
wiiu/wut/include/nsysnet/socket.h
View File

@ -3,11 +3,9 @@
#include <stdint.h>
#include <sys/time.h>
/**
* \defgroup nsysnet_socket Socket
* \ingroup nsysnet
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
#define SOL_SOCKET 0xFFFF
@ -74,121 +72,39 @@ struct linger
int l_linger;
};
struct in_addr {
unsigned int s_addr;
};
struct sockaddr_in {
short sin_family;
unsigned short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
struct in_addr
{
unsigned int s_addr;
};
#ifdef __cplusplus
extern "C" {
#endif
struct sockaddr_in
{
short sin_family;
unsigned short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
void
socket_lib_init();
int
accept(int sockfd,
struct sockaddr *addr,
socklen_t *addrlen);
int
bind(int sockfd,
const struct sockaddr *addr,
socklen_t addrlen);
int
socketclose(int sockfd);
int
connect(int sockfd,
const struct sockaddr *addr,
socklen_t addrlen);
int
getpeername(int sockfd,
struct sockaddr *addr,
socklen_t *addrlen);
int
getsockname(int sockfd,
struct sockaddr *addr,
socklen_t *addrlen);
int
getsockopt(int sockfd,
int level,
int optname,
void *optval,
socklen_t *optlen);
int
listen(int sockfd,
int backlog);
ssize_t
recv(int sockfd,
void *buf,
size_t len,
int flags);
ssize_t
recvfrom(int sockfd,
void *buf,
size_t len,
int flags,
struct sockaddr *src_addr,
socklen_t *addrlen);
ssize_t
send(int sockfd,
const void *buf,
size_t len,
int flags);
ssize_t
sendto(int sockfd,
const void *buf,
size_t len,
int flags,
const struct sockaddr *dest_addr,
socklen_t addrlen);
int
setsockopt(int sockfd,
int level,
int optname,
const void *optval,
socklen_t optlen);
int
shutdown(int sockfd,
int how);
int
socket(int domain,
int type,
int protocol);
int
select(int nfds,
fd_set *readfds,
fd_set *writefds,
fd_set *exceptfds,
struct timeval *timeout);
char *
inet_ntoa(struct in_addr in);
int
inet_aton(const char *cp, struct in_addr *inp);
void socket_lib_init();
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
int socketclose(int sockfd);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
int getpeername(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
int listen(int sockfd, int backlog);
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
int shutdown(int sockfd, int how);
int socket(int domain, int type, int protocol);
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
char *inet_ntoa(struct in_addr in);
int inet_aton(const char *cp, struct in_addr *inp);
#ifdef __cplusplus
}
#endif
/** @} */

53
wiiu/wut/include/proc_ui/procui.h
View File

@ -12,8 +12,8 @@ extern "C" {
#endif
typedef void (*ProcUISaveCallback)(void);
typedef uint32_t (*ProcUISaveCallbackEx)(void*);
typedef uint32_t (*ProcUICallback)(void*);
typedef uint32_t (*ProcUISaveCallbackEx)(void *);
typedef uint32_t (*ProcUICallback)(void *);
typedef enum ProcUIStatus
{
@ -23,43 +23,18 @@ typedef enum ProcUIStatus
PROCUI_STATUS_EXITING,
} ProcUIStatus;
uint32_t
ProcUICalcMemorySize(uint32_t unk);
void
ProcUIClearCallbacks();
void
ProcUIDrawDoneRelease();
BOOL
ProcUIInForeground();
BOOL
ProcUIInShutdown();
void
ProcUIInit(ProcUISaveCallback saveCallback);
void
ProcUIInitEx(ProcUISaveCallbackEx saveCallback,
void *arg);
BOOL
ProcUIIsRunning();
ProcUIStatus
ProcUIProcessMessages(BOOL block);
void
ProcUISetSaveCallback(ProcUISaveCallbackEx saveCallback,
void *arg);
void
ProcUIShutdown();
ProcUIStatus
ProcUISubProcessMessages(BOOL block);
uint32_t ProcUICalcMemorySize(uint32_t unk);
void ProcUIClearCallbacks();
void ProcUIDrawDoneRelease();
BOOL ProcUIInForeground();
BOOL ProcUIInShutdown();
void ProcUIInit(ProcUISaveCallback saveCallback);
void ProcUIInitEx(ProcUISaveCallbackEx saveCallback, void *arg);
BOOL ProcUIIsRunning();
ProcUIStatus ProcUIProcessMessages(BOOL block);
void ProcUISetSaveCallback(ProcUISaveCallbackEx saveCallback, void *arg);
void ProcUIShutdown();
ProcUIStatus ProcUISubProcessMessages(BOOL block);
#ifdef __cplusplus
}

76
wiiu/wut/include/sndcore2/core.h
View File

@ -2,89 +2,49 @@
#include <wut.h>
#include "result.h"
/**
* \defgroup sndcore2_core Core
* \ingroup sndcore2
*
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct AXProfile AXProfile;
typedef struct AXInitParams AXInitParams;
typedef void(*AXFrameCallback)(void);
//! A value from enum AX_INIT_RENDERER.
typedef uint32_t AXInitRenderer;
//! A value from enum AX_INIT_PIPELINE.
typedef uint32_t AXInitPipeline;
enum AX_INIT_RENDERER
{
AX_INIT_RENDERER_32KHZ = 0,
AX_INIT_RENDERER_48KHZ = 1,
};
typedef uint32_t AXInitRenderer;
enum AX_INIT_PIPELINE
{
AX_INIT_PIPELINE_SINGLE = 0,
AX_INIT_PIPELINE_FOUR_STAGE = 1,
};
typedef uint32_t AXInitPipeline;
struct AXProfile
typedef struct AXProfile
{
// Unknown
};
uint32_t __unknown[0x22];
}AXProfile;
struct AXInitParams
typedef struct AXInitParams
{
AXInitRenderer renderer;
UNKNOWN(4);
uint32_t __unknown;
AXInitPipeline pipeline;
};
CHECK_OFFSET(AXInitParams, 0x00, renderer);
CHECK_OFFSET(AXInitParams, 0x08, pipeline);
CHECK_SIZE(AXInitParams, 0x0C);
}AXInitParams;
void
AXInit();
void
AXQuit();
void
AXInitWithParams(AXInitParams *params);
BOOL
AXIsInit();
void
AXInitProfile(AXProfile *profile,
uint32_t count);
uint32_t
AXGetSwapProfile(AXProfile *profile,
uint32_t count);
AXResult
AXSetDefaultMixerSelect(uint32_t unk0);
AXResult
AXRegisterAppFrameCallback(AXFrameCallback callback);
uint32_t
AXGetInputSamplesPerFrame();
uint32_t
AXGetInputSamplesPerSec();
void AXInit();
void AXQuit();
void AXInitWithParams(AXInitParams *params);
BOOL AXIsInit();
void AXInitProfile(AXProfile *profile, uint32_t count);
uint32_t AXGetSwapProfile(AXProfile *profile, uint32_t count);
AXResult AXSetDefaultMixerSelect(uint32_t unk0);
AXResult AXRegisterAppFrameCallback(AXFrameCallback callback);
uint32_t AXGetInputSamplesPerFrame();
uint32_t AXGetInputSamplesPerSec();
#ifdef __cplusplus
}
#endif
/** @} */

69
wiiu/wut/include/sndcore2/device.h
View File

@ -2,13 +2,6 @@
#include <wut.h>
#include "result.h"
/**
* \defgroup sndcore2_device Device
* \ingroup sndcore2
*
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -16,17 +9,12 @@ extern "C" {
typedef void(*AXDeviceFinalMixCallback)(void*);
typedef void(*AXAuxCallback)(void*, void*);
//! A value from enum AX_DEVICE_MODE.
typedef uint32_t AXDeviceMode;
//! A value from enum AX_DEVICE_TYPE.
typedef uint32_t AXDeviceType;
enum AX_DEVICE_MODE
{
// Unknown
AX_DEVICE_MODE_UNKNOWN
};
typedef uint32_t AXDeviceMode;
enum AX_DEVICE_TYPE
{
@ -34,53 +22,18 @@ enum AX_DEVICE_TYPE
AX_DEVICE_TYPE_DRC = 1,
AX_DEVICE_TYPE_CONTROLLER = 2,
};
typedef uint32_t AXDeviceType;
AXResult
AXGetDeviceMode(AXDeviceType type,
AXDeviceMode *mode);
AXResult
AXGetDeviceFinalMixCallback(AXDeviceType type,
AXDeviceFinalMixCallback *func);
AXResult
AXRegisterDeviceFinalMixCallback(AXDeviceType type,
AXDeviceFinalMixCallback func);
AXResult
AXGetAuxCallback(AXDeviceType type,
uint32_t unk0,
uint32_t unk1,
AXAuxCallback *callback,
void **userData);
AXResult
AXRegisterAuxCallback(AXDeviceType type,
uint32_t unk0,
uint32_t unk1,
AXAuxCallback callback,
void *userData);
AXResult
AXSetDeviceLinearUpsampler(AXDeviceType type,
uint32_t unk0,
uint32_t unk1);
AXResult
AXSetDeviceCompressor(AXDeviceType type,
uint32_t unk0);
AXResult
AXSetDeviceUpsampleStage(AXDeviceType type,
BOOL postFinalMix);
AXResult
AXSetDeviceVolume(AXDeviceType type,
uint32_t id,
uint16_t volume);
AXResult AXGetDeviceMode(AXDeviceType type, AXDeviceMode *mode);
AXResult AXGetDeviceFinalMixCallback(AXDeviceType type, AXDeviceFinalMixCallback *func);
AXResult AXRegisterDeviceFinalMixCallback(AXDeviceType type, AXDeviceFinalMixCallback func);
AXResult AXGetAuxCallback(AXDeviceType type, uint32_t unk0, uint32_t unk1, AXAuxCallback *callback, void **userData);
AXResult AXRegisterAuxCallback(AXDeviceType type, uint32_t unk0, uint32_t unk1, AXAuxCallback callback, void *userData);
AXResult AXSetDeviceLinearUpsampler(AXDeviceType type, uint32_t unk0, uint32_t unk1);
AXResult AXSetDeviceCompressor(AXDeviceType type, uint32_t unk0);
AXResult AXSetDeviceUpsampleStage(AXDeviceType type, BOOL postFinalMix);
AXResult AXSetDeviceVolume(AXDeviceType type, uint32_t id, uint16_t volume);
#ifdef __cplusplus
}
#endif
/** @} */

85
wiiu/wut/include/sndcore2/drcvs.h
View File

@ -2,95 +2,50 @@
#include <wut.h>
#include "result.h"
/**
* \defgroup sndcore2_drcvs DRC VS
* \ingroup sndcore2
*
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
//! A value from enum AX_DRC_VS_MODE.
typedef uint32_t AXDRCVSMode;
//! A value from enum AX_DRC_VS_OUTPUT.
typedef uint32_t AXDRCVSOutput;
//! A value from enum AX_DRC_VS_LC.
typedef uint32_t AXDRCVSLC;
//! A value from enum AX_DRC_VS_SPEAKER_POS.
typedef uint32_t AXDRCVSSpeakerPosition;
//! A value from enum AX_DRC_VS_SURROUND_GAIN.
typedef uint32_t AXDRCVSSurroundLevelGain;
enum AX_DRC_VS_MODE
typedef enum
{
// Unknown
AX_DRC_VS_MODE_UNKNOWN
};
} AXDRCVSMode;
enum AX_DRC_VS_OUTPUT
typedef enum
{
// Unknown
AX_DRC_VS_OUTPUT_UNKNOWN
};
} AXDRCVSOutput;
enum AX_DRC_VS_LC
typedef enum
{
// Unknown
AX_DRC_VS_LC_UNKNOWN
};
} AXDRCVSLC;
enum AX_DRC_VS_SPEAKER_POS
typedef enum
{
// Unknown
AX_DRC_VS_SPEAKER_POS_UNKNOWN
};
} AXDRCVSSpeakerPosition;
enum AX_DRC_VS_SURROUND_GAIN
typedef enum AX_DRC_VS_SURROUND_GAIN
{
// Unknown
AX_DRC_VS_SURROUND_GAIN_UNKNOWN
};
} AXDRCVSSurroundLevelGain;
AXResult
AXGetDRCVSMode(AXDRCVSMode *mode);
AXResult
AXSetDRCVSMode(AXDRCVSMode mode);
AXResult
AXSetDRCVSDownmixBalance(AXDRCVSOutput output,
float balance);
AXResult
AXSetDRCVSLC(AXDRCVSLC lc);
AXResult
AXSetDRCVSLimiter(BOOL limit);
AXResult
AXSetDRCVSLimiterThreshold(float threshold);
AXResult
AXSetDRCVSOutputGain(AXDRCVSOutput output,
float gain);
AXResult
AXSetDRCVSSpeakerPosition(AXDRCVSOutput output,
AXDRCVSSpeakerPosition pos);
AXResult
AXSetDRCVSSurroundDepth(AXDRCVSOutput output,
float depth);
AXResult
AXSetDRCVSSurroundLevelGain(AXDRCVSSurroundLevelGain gain);
AXResult AXGetDRCVSMode(AXDRCVSMode *mode);
AXResult AXSetDRCVSMode(AXDRCVSMode mode);
AXResult AXSetDRCVSDownmixBalance(AXDRCVSOutput output, float balance);
AXResult AXSetDRCVSLC(AXDRCVSLC lc);
AXResult AXSetDRCVSLimiter(BOOL limit);
AXResult AXSetDRCVSLimiterThreshold(float threshold);
AXResult AXSetDRCVSOutputGain(AXDRCVSOutput output, float gain);
AXResult AXSetDRCVSSpeakerPosition(AXDRCVSOutput output, AXDRCVSSpeakerPosition pos);
AXResult AXSetDRCVSSurroundDepth(AXDRCVSOutput output, float depth);
AXResult AXSetDRCVSSurroundLevelGain(AXDRCVSSurroundLevelGain gain);
#ifdef __cplusplus
}

16
wiiu/wut/include/sndcore2/result.h
View File

@ -1,31 +1,19 @@
#pragma once
#include <wut.h>
/**
* \defgroup sndcore2_result Result
* \ingroup sndcore2
*
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
//! A value from enum AX_RESULT.
typedef int32_t AXResult;
enum AX_RESULT
typedef enum
{
AX_RESULT_SUCCESS = 0,
AX_RESULT_INVALID_DEVICE_TYPE = -1,
AX_RESULT_INVALID_DRC_VS_MODE = -13,
AX_RESULT_VOICE_IS_RUNNING = -18,
AX_RESULT_DELAY_TOO_BIG = -19,
};
}AXResult;
#ifdef __cplusplus
}
#endif
/** @} */

324
wiiu/wut/include/sndcore2/voice.h
View File

@ -3,48 +3,10 @@
#include "device.h"
#include "result.h"
/**
* \defgroup sndcore2_voice Voice
* \ingroup sndcore2
*
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct AXVoice AXVoice;
typedef struct AXVoiceAdpcmLoopData AXVoiceAdpcmLoopData;
typedef struct AXVoiceAdpcm AXVoiceAdpcm;
typedef struct AXVoiceDeviceBusMixData AXVoiceDeviceBusMixData;
typedef struct AXVoiceDeviceMixData AXVoiceDeviceMixData;
typedef struct AXVoiceLink AXVoiceLink;
typedef struct AXVoiceOffsets AXVoiceOffsets;
typedef struct AXVoiceSrc AXVoiceSrc;
typedef struct AXVoiceVeData AXVoiceVeData;
//! A value from enum AX_VOICE_FORMAT.
typedef uint16_t AXVoiceFormat;
//! A value from enum AX_VOICE_LOOP.
typedef uint16_t AXVoiceLoop;
//! A value from enum AX_VOICE_SRC_TYPE.
typedef uint32_t AXVoiceSrcType;
//! A value from enum AX_VOICE_STATE.
typedef uint32_t AXVoiceState;
//! A value from enum AX_VOICE_RENDERER.
typedef uint32_t AXVoiceRenderer;
//! A value from enum AX_VOICE_RATIO_RESULT.
typedef int32_t AXVoiceSrcRatioResult;
//! A value from enum AX_VOICE_TYPE.
typedef uint32_t AXVoiceType;
typedef void(*AXVoiceCallbackFn)(void *);
typedef void(*AXVoiceCallbackExFn)(void *, uint32_t, uint32_t);
@ -54,12 +16,14 @@ enum AX_VOICE_FORMAT
AX_VOICE_FORMAT_LPCM16 = 10,
AX_VOICE_FORMAT_LPCM8 = 25,
};
typedef uint16_t AXVoiceFormat;
enum AX_VOICE_LOOP
{
AX_VOICE_LOOP_DISABLED = 0,
AX_VOICE_LOOP_ENABLED = 1,
};
typedef uint16_t AXVoiceLoop;
enum AX_VOICE_RENDERER
{
@ -67,6 +31,7 @@ enum AX_VOICE_RENDERER
AX_VOICE_RENDERER_CPU = 1,
AX_VOICE_RENDERER_AUTO = 2,
};
typedef uint32_t AXVoiceRenderer;
enum AX_VOICE_RATIO_RESULT
{
@ -74,6 +39,7 @@ enum AX_VOICE_RATIO_RESULT
AX_VOICE_RATIO_RESULT_LESS_THAN_ZERO = -1,
AX_VOICE_RATIO_RESULT_GREATER_THAN_SOMETHING = -2,
};
typedef int32_t AXVoiceSrcRatioResult;
enum AX_VOICE_SRC_TYPE
{
@ -83,29 +49,23 @@ enum AX_VOICE_SRC_TYPE
AX_VOICE_SRC_TYPE_UNK1 = 3,
AX_VOICE_SRC_TYPE_UNK2 = 4,
};
typedef uint32_t AXVoiceSrcType;
enum AX_VOICE_STATE
{
AX_VOICE_STATE_STOPPED = 0,
AX_VOICE_STATE_PLAYING = 1,
};
typedef uint32_t AXVoiceState;
enum AX_VOICE_TYPE
{
// Unknown
AX_VOICE_TYPE_UNKNOWN
};
typedef uint32_t AXVoiceType;
struct AXVoiceLink
{
AXVoice *next;
AXVoice *prev;
};
CHECK_OFFSET(AXVoiceLink, 0x0, next);
CHECK_OFFSET(AXVoiceLink, 0x4, prev);
CHECK_SIZE(AXVoiceLink, 0x8);
struct AXVoiceOffsets
typedef struct
{
AXVoiceFormat dataType;
AXVoiceLoop loopingEnabled;
@ -113,266 +73,106 @@ struct AXVoiceOffsets
uint32_t endOffset;
uint32_t currentOffset;
const void *data;
};
CHECK_OFFSET(AXVoiceOffsets, 0x0, dataType);
CHECK_OFFSET(AXVoiceOffsets, 0x2, loopingEnabled);
CHECK_OFFSET(AXVoiceOffsets, 0x4, loopOffset);
CHECK_OFFSET(AXVoiceOffsets, 0x8, endOffset);
CHECK_OFFSET(AXVoiceOffsets, 0xc, currentOffset);
CHECK_OFFSET(AXVoiceOffsets, 0x10, data);
CHECK_SIZE(AXVoiceOffsets, 0x14);
} AXVoiceOffsets;
typedef struct AXVoice AXVoice;
typedef struct
{
AXVoice *next;
AXVoice *prev;
} AXVoiceLink;
struct AXVoice
{
//! The index of this voice out of the total voices
uint32_t index;
//! Current play state of this voice
AXVoiceState state;
//! Current volume of this voice
uint32_t volume;
//! The renderer to use for this voice
AXVoiceRenderer renderer;
//! this is a link used in the stack, we do this in host-memory currently
AXVoiceLink link;
//! A link to the next callback to invoke
AXVoice *cbNext;
//! The priority of this voice used for force-acquiring a voice
uint32_t priority;
//! The callback to call if this is force-free'd by another acquire
AXVoiceCallbackFn callback;
//! The user context to send to the callbacks
void *userContext;
//! A bitfield representing different things needing to be synced.
uint32_t syncBits;
UNKNOWN(0x8);
//! The current offset data!
uint32_t _unknown[0x2];
AXVoiceOffsets offsets;
//! An extended version of the callback above
AXVoiceCallbackExFn callbackEx;
//! The reason for the callback being invoked
uint32_t callbackReason;
float unk0;
float unk1;
};
CHECK_OFFSET(AXVoice, 0x0, index);
CHECK_OFFSET(AXVoice, 0x4, state);
CHECK_OFFSET(AXVoice, 0x8, volume);
CHECK_OFFSET(AXVoice, 0xc, renderer);
CHECK_OFFSET(AXVoice, 0x10, link);
CHECK_OFFSET(AXVoice, 0x18, cbNext);
CHECK_OFFSET(AXVoice, 0x1c, priority);
CHECK_OFFSET(AXVoice, 0x20, callback);
CHECK_OFFSET(AXVoice, 0x24, userContext);
CHECK_OFFSET(AXVoice, 0x28, syncBits);
CHECK_OFFSET(AXVoice, 0x34, offsets);
CHECK_OFFSET(AXVoice, 0x48, callbackEx);
CHECK_OFFSET(AXVoice, 0x4c, callbackReason);
CHECK_OFFSET(AXVoice, 0x50, unk0);
CHECK_OFFSET(AXVoice, 0x54, unk1);
CHECK_SIZE(AXVoice, 0x58);
struct AXVoiceDeviceBusMixData
typedef struct
{
uint16_t volume;
int16_t delta;
};
CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x0, volume);
CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x2, delta);
CHECK_SIZE(AXVoiceDeviceBusMixData, 0x4);
} AXVoiceDeviceBusMixData;
struct AXVoiceDeviceMixData
typedef struct
{
AXVoiceDeviceBusMixData bus[4];
};
CHECK_OFFSET(AXVoiceDeviceMixData, 0x0, bus);
CHECK_SIZE(AXVoiceDeviceMixData, 0x10);
} AXVoiceDeviceMixData;
struct AXVoiceVeData
typedef struct
{
uint16_t volume;
int16_t delta;
};
CHECK_OFFSET(AXVoiceVeData, 0x0, volume);
CHECK_OFFSET(AXVoiceVeData, 0x2, delta);
CHECK_SIZE(AXVoiceVeData, 0x4);
} AXVoiceVeData;
struct AXVoiceAdpcmLoopData
typedef struct
{
uint16_t predScale;
int16_t prevSample[2];
};
CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x0, predScale);
CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x2, prevSample);
CHECK_SIZE(AXVoiceAdpcmLoopData, 0x6);
} AXVoiceAdpcmLoopData;
struct AXVoiceAdpcm
typedef struct
{
int16_t coefficients[16];
uint16_t gain;
uint16_t predScale;
int16_t prevSample[2];
};
CHECK_OFFSET(AXVoiceAdpcm, 0x0, coefficients);
CHECK_OFFSET(AXVoiceAdpcm, 0x20, gain);
CHECK_OFFSET(AXVoiceAdpcm, 0x22, predScale);
CHECK_OFFSET(AXVoiceAdpcm, 0x24, prevSample);
CHECK_SIZE(AXVoiceAdpcm, 0x28);
} AXVoiceAdpcm;
#pragma pack(push, 1)
/**
* AXVoice Sample Rate Converter
*/
struct AXVoiceSrc
/* AXVoice Sample Rate Converter */
typedef struct
{
//! Playback rate, fixed 16.16
uint32_t ratio;
//! Used by the resampler, fixed 0.16
uint16_t ratio_int;
uint16_t ratio_fraction;
uint16_t currentOffsetFrac;
int16_t lastSample[4];
};
CHECK_OFFSET(AXVoiceSrc, 0x0, ratio);
CHECK_OFFSET(AXVoiceSrc, 0x4, currentOffsetFrac);
CHECK_OFFSET(AXVoiceSrc, 0x6, lastSample);
CHECK_SIZE(AXVoiceSrc, 0xe);
} AXVoiceSrc;
#pragma pack(pop)
AXVoice *
AXAcquireVoice(uint32_t priority,
AXVoiceCallbackFn callback,
void *userContext);
AXVoice *
AXAcquireVoiceEx(uint32_t priority,
AXVoiceCallbackExFn callback,
void *userContext);
BOOL
AXCheckVoiceOffsets(AXVoiceOffsets *offsets);
void
AXFreeVoice(AXVoice *voice);
uint32_t
AXGetMaxVoices();
uint32_t
AXGetVoiceCurrentOffsetEx(AXVoice *voice,
const void *samples);
uint32_t
AXGetVoiceLoopCount(AXVoice *voice);
void
AXGetVoiceOffsets(AXVoice *voice,
AXVoiceOffsets *offsets);
BOOL
AXIsVoiceRunning(AXVoice *voice);
void
AXSetVoiceAdpcm(AXVoice *voice,
AXVoiceAdpcm *adpcm);
void
AXSetVoiceAdpcmLoop(AXVoice *voice,
AXVoiceAdpcmLoopData *loopData);
void
AXSetVoiceCurrentOffset(AXVoice *voice,
uint32_t offset);
AXResult
AXSetVoiceDeviceMix(AXVoice *voice,
AXDeviceType type,
uint32_t id,
AXVoiceDeviceMixData *mixData);
void
AXSetVoiceEndOffset(AXVoice *voice,
uint32_t offset);
void
AXSetVoiceEndOffsetEx(AXVoice *voice,
uint32_t offset,
const void *samples);
AXResult
AXSetVoiceInitialTimeDelay(AXVoice *voice,
uint16_t delay);
void
AXSetVoiceLoopOffset(AXVoice *voice,
uint32_t offset);
void
AXSetVoiceLoopOffsetEx(AXVoice *voice,
uint32_t offset,
const void *samples);
void
AXSetVoiceLoop(AXVoice *voice,
AXVoiceLoop loop);
void
AXSetVoiceOffsets(AXVoice *voice,
AXVoiceOffsets *offsets);
void
AXSetVoicePriority(AXVoice *voice,
uint32_t priority);
void
AXSetVoiceRmtIIRCoefs(AXVoice *voice,
uint16_t filter,
...);
void
AXSetVoiceSrc(AXVoice *voice,
AXVoiceSrc *src);
AXVoiceSrcRatioResult
AXSetVoiceSrcRatio(AXVoice *voice,
float ratio);
void
AXSetVoiceSrcType(AXVoice *voice,
AXVoiceSrcType type);
void
AXSetVoiceState(AXVoice *voice,
AXVoiceState state);
void
AXSetVoiceType(AXVoice *voice,
AXVoiceType type);
void
AXSetVoiceVe(AXVoice *voice,
AXVoiceVeData *veData);
void
AXSetVoiceVeDelta(AXVoice *voice,
int16_t delta);
AXVoice *AXAcquireVoice(uint32_t priority, AXVoiceCallbackFn callback, void *userContext);
AXVoice *AXAcquireVoiceEx(uint32_t priority, AXVoiceCallbackExFn callback, void *userContext);
BOOL AXCheckVoiceOffsets(AXVoiceOffsets *offsets);
void AXFreeVoice(AXVoice *voice);
uint32_t AXGetMaxVoices();
uint32_t AXGetVoiceCurrentOffsetEx(AXVoice *voice, const void *samples);
uint32_t AXGetVoiceLoopCount(AXVoice *voice);
void AXGetVoiceOffsets(AXVoice *voice, AXVoiceOffsets *offsets);
BOOL AXIsVoiceRunning(AXVoice *voice);
void AXSetVoiceAdpcm(AXVoice *voice, AXVoiceAdpcm *adpcm);
void AXSetVoiceAdpcmLoop(AXVoice *voice, AXVoiceAdpcmLoopData *loopData);
void AXSetVoiceCurrentOffset(AXVoice *voice, uint32_t offset);
AXResult AXSetVoiceDeviceMix(AXVoice *voice, AXDeviceType type, uint32_t id, AXVoiceDeviceMixData *mixData);
void AXSetVoiceEndOffset(AXVoice *voice, uint32_t offset);
void AXSetVoiceEndOffsetEx(AXVoice *voice, uint32_t offset, const void *samples);
AXResult AXSetVoiceInitialTimeDelay(AXVoice *voice, uint16_t delay);
void AXSetVoiceLoopOffset(AXVoice *voice, uint32_t offset);
void AXSetVoiceLoopOffsetEx(AXVoice *voice, uint32_t offset, const void *samples);
void AXSetVoiceLoop(AXVoice *voice, AXVoiceLoop loop);
void AXSetVoiceOffsets(AXVoice *voice, AXVoiceOffsets *offsets);
void AXSetVoicePriority(AXVoice *voice, uint32_t priority);
void AXSetVoiceRmtIIRCoefs(AXVoice *voice, uint16_t filter, ...);
void AXSetVoiceSrc(AXVoice *voice, AXVoiceSrc *src);
AXVoiceSrcRatioResult AXSetVoiceSrcRatio(AXVoice *voice, float ratio);
void AXSetVoiceSrcType(AXVoice *voice, AXVoiceSrcType type);
void AXSetVoiceState(AXVoice *voice, AXVoiceState state);
void AXSetVoiceType(AXVoice *voice, AXVoiceType type);
void AXSetVoiceVe(AXVoice *voice, AXVoiceVeData *veData);
void AXSetVoiceVeDelta(AXVoice *voice, int16_t delta);
#ifdef __cplusplus
}
#endif
/** @} */

36
wiiu/wut/include/sysapp/launch.h
View File

@ -1,40 +1,18 @@
#pragma once
#include <wut.h>
/**
* \defgroup sysapp_launch SYSAPP Launch
* \ingroup sysapp
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
void
SYSRelaunchTitle(uint32_t argc,
char *pa_Argv[]);
void
SYSLaunchMenu();
void
SYSLaunchTitle(uint64_t TitleId);
void
_SYSLaunchMiiStudio();
void
_SYSLaunchSettings();
void
_SYSLaunchParental();
void
_SYSLaunchNotifications();
void SYSRelaunchTitle(uint32_t argc, char *pa_Argv[]);
void SYSLaunchMenu();
void SYSLaunchTitle(uint64_t TitleId);
void _SYSLaunchMiiStudio();
void _SYSLaunchSettings();
void _SYSLaunchParental();
void _SYSLaunchNotifications();
#ifdef __cplusplus
}
#endif
/** @} */

27
wiiu/wut/include/sysapp/switch.h
View File

@ -1,12 +1,6 @@
#pragma once
#include <wut.h>
/**
* \defgroup sysapp_switch SYSAPP Switch
* \ingroup sysapp
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
@ -14,23 +8,12 @@ extern "C" {
//TODO
typedef void sysapp_input_struct;
void
SYSSwitchToSyncControllerOnHBM();
void
SYSSwitchToEManual();
void
SYSSwitchToEShop();
void
_SYSSwitchToMainApp();
void
SYSSwitchToBrowserForViewer(sysapp_input_struct*);
void SYSSwitchToSyncControllerOnHBM();
void SYSSwitchToEManual();
void SYSSwitchToEShop();
void _SYSSwitchToMainApp();
void SYSSwitchToBrowserForViewer(sysapp_input_struct *);
#ifdef __cplusplus
}
#endif
/** @} */

149
wiiu/wut/include/vpad/input.h
View File

@ -1,44 +1,31 @@
#pragma once
#include <wut.h>
/**
* \defgroup vpad_input VPAD Input
* \ingroup vpad
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct VPADVec2D VPADVec2D;
typedef struct VPADVec3D VPADVec3D;
typedef struct VPADTouchData VPADTouchData;
typedef struct VPADAccStatus VPADAccStatus;
typedef struct VPADGyroStatus VPADGyroStatus;
typedef struct VPADStatus VPADStatus;
typedef enum VPADButtons
{
VPAD_BUTTON_A = 0x8000,
VPAD_BUTTON_B = 0x4000,
VPAD_BUTTON_X = 0x2000,
VPAD_BUTTON_Y = 0x1000,
VPAD_BUTTON_LEFT = 0x0800,
VPAD_BUTTON_RIGHT = 0x0400,
VPAD_BUTTON_UP = 0x0200,
VPAD_BUTTON_DOWN = 0x0100,
VPAD_BUTTON_ZL = 0x0080,
VPAD_BUTTON_ZR = 0x0040,
VPAD_BUTTON_L = 0x0020,
VPAD_BUTTON_R = 0x0010,
VPAD_BUTTON_PLUS = 0x0008,
VPAD_BUTTON_MINUS = 0x0004,
VPAD_BUTTON_HOME = 0x0002,
VPAD_BUTTON_SYNC = 0x0001,
VPAD_BUTTON_SYNC = 0x00000001,
VPAD_BUTTON_HOME = 0x00000002,
VPAD_BUTTON_MINUS = 0x00000004,
VPAD_BUTTON_PLUS = 0x00000008,
VPAD_BUTTON_R = 0x00000010,
VPAD_BUTTON_L = 0x00000020,
VPAD_BUTTON_ZR = 0x00000040,
VPAD_BUTTON_ZL = 0x00000080,
VPAD_BUTTON_DOWN = 0x00000100,
VPAD_BUTTON_UP = 0x00000200,
VPAD_BUTTON_RIGHT = 0x00000400,
VPAD_BUTTON_LEFT = 0x00000800,
VPAD_BUTTON_Y = 0x00001000,
VPAD_BUTTON_X = 0x00002000,
VPAD_BUTTON_B = 0x00004000,
VPAD_BUTTON_A = 0x00008000,
VPAD_BUTTON_TV = 0x00010000,
VPAD_BUTTON_STICK_R = 0x00020000,
VPAD_BUTTON_STICK_L = 0x00040000,
VPAD_BUTTON_TV = 0x00010000,
} VPADButtons;
typedef enum VPADTouchPadValidity
@ -61,44 +48,28 @@ typedef enum VPADReadError
VPAD_READ_INVALID_CONTROLLER = -2,
} VPADReadError;
struct VPADVec2D
typedef struct VPADVec2D
{
float x;
float y;
};
CHECK_OFFSET(VPADVec2D, 0x00, x);
CHECK_OFFSET(VPADVec2D, 0x04, y);
CHECK_SIZE(VPADVec2D, 0x08);
}VPADVec2D;
struct VPADVec3D
typedef struct VPADVec3D
{
float x;
float y;
float z;
};
CHECK_OFFSET(VPADVec3D, 0x00, x);
CHECK_OFFSET(VPADVec3D, 0x04, y);
CHECK_OFFSET(VPADVec3D, 0x08, z);
CHECK_SIZE(VPADVec3D, 0x0C);
}VPADVec3D;
struct VPADTouchData
typedef struct VPADTouchData
{
uint16_t x;
uint16_t y;
//! 0 if screen is not currently being touched
uint16_t touched;
//! Bitfield of VPADTouchPadValidity to indicate how touch sample accuracy
uint16_t validity;
};
CHECK_OFFSET(VPADTouchData, 0x00, x);
CHECK_OFFSET(VPADTouchData, 0x02, y);
CHECK_OFFSET(VPADTouchData, 0x04, touched);
CHECK_OFFSET(VPADTouchData, 0x06, validity);
CHECK_SIZE(VPADTouchData, 0x08);
}VPADTouchData;
struct VPADAccStatus
typedef struct VPADAccStatus
{
float unk1;
float unk2;
@ -106,11 +77,9 @@ struct VPADAccStatus
float unk4;
float unk5;
VPADVec2D vertical;
};
CHECK_OFFSET(VPADAccStatus, 0x14, vertical);
CHECK_SIZE(VPADAccStatus, 0x1c);
}VPADAccStatus;
struct VPADGyroStatus
typedef struct VPADGyroStatus
{
float unk1;
float unk2;
@ -118,33 +87,20 @@ struct VPADGyroStatus
float unk4;
float unk5;
float unk6;
};
CHECK_SIZE(VPADGyroStatus, 0x18);
}VPADGyroStatus;
struct VPADStatus
typedef struct VPADStatus
{
//! Indicates what VPADButtons are held down
uint32_t hold;
//! Indicates what VPADButtons have been pressed since last sample
uint32_t trigger;
//! Indicates what VPADButtons have been released since last sample
uint32_t release;
//! Position of left analog stick
VPADVec2D leftStick;
//! Position of right analog stick
VPADVec2D rightStick;
//! Status of DRC accelorometer
VPADAccStatus accelorometer;
//! Status of DRC gyro
VPADGyroStatus gyro;
UNKNOWN(2);
uint16_t __unknown0;
//! Current touch position on DRC
VPADTouchData tpNormal;
@ -155,56 +111,21 @@ struct VPADStatus
//! Filtered touch position, second level of smoothing
VPADTouchData tpFiltered2;
UNKNOWN(0x28);
uint32_t __unknown1[0xA];
//! Status of DRC magnetometer
VPADVec3D mag;
//! Current volume set by the slide control
uint8_t slideVolume;
//! Battery level of controller
uint8_t battery;
//! Status of DRC microphone
uint8_t micStatus;
//! Unknown volume related value
uint8_t slideVolumeEx;
UNKNOWN(0x7);
};
CHECK_OFFSET(VPADStatus, 0x00, hold);
CHECK_OFFSET(VPADStatus, 0x04, trigger);
CHECK_OFFSET(VPADStatus, 0x08, release);
CHECK_OFFSET(VPADStatus, 0x0C, leftStick);
CHECK_OFFSET(VPADStatus, 0x14, rightStick);
CHECK_OFFSET(VPADStatus, 0x1C, accelorometer);
CHECK_OFFSET(VPADStatus, 0x38, gyro);
CHECK_OFFSET(VPADStatus, 0x52, tpNormal);
CHECK_OFFSET(VPADStatus, 0x5A, tpFiltered1);
CHECK_OFFSET(VPADStatus, 0x62, tpFiltered2);
CHECK_OFFSET(VPADStatus, 0x94, mag);
CHECK_OFFSET(VPADStatus, 0xA0, slideVolume);
CHECK_OFFSET(VPADStatus, 0xA1, battery);
CHECK_OFFSET(VPADStatus, 0xA2, micStatus);
CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx);
CHECK_SIZE(VPADStatus, 0xAC);
uint32_t __unknown2[0x2];
}VPADStatus;
//! Deprecated
void
VPADInit();
void VPADInit();
int32_t
VPADRead(uint32_t chan,
VPADStatus *buffers,
uint32_t count,
VPADReadError *error);
void
VPADGetTPCalibratedPoint(uint32_t chan,
VPADTouchData *calibratedData,
VPADTouchData *uncalibratedData);
int32_t VPADRead(uint32_t chan, VPADStatus *buffers, uint32_t count, VPADReadError *error);
void VPADGetTPCalibratedPoint(uint32_t chan, VPADTouchData *calibratedData, VPADTouchData *uncalibratedData);
#ifdef __cplusplus
}

4
wiiu/wut/include/wut_structsize.h
View File

@ -21,7 +21,3 @@
#define UNKNOWN(Size) char PP_CAT(__unk, __COUNTER__) [Size]
#define PADDING(Size) UNKNOWN(Size)
// Just some placeholder defines
#define UNKNOWN_ARG uint32_t
#define UNKNOWN_ARGS void
#define UNKNOWN_SIZE(x)

5
wiiu/wut/include/wut_types.h
View File

@ -32,11 +32,6 @@ typedef volatile s16 vs16;
typedef volatile s32 vs32;
typedef volatile s64 vs64;
typedef s16 sfp16;
typedef s32 sfp32;
typedef u16 ufp16;
typedef u32 ufp32;
typedef float f32;
typedef double f64;