The-Homebrew-Cloud/wut
2
0
Fork 0
mirror of https://github.com/wiiu-env/wut.git synced 2024-12-05 03:24:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

Prefix structsize macros with WUT_

Browse Source
This commit is contained in:
James Benton 2018-06-20 10:31:53 +01:00
parent b4619783ca
commit 5f1b1902f6
45 changed files with 826 additions and 828 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
docs/CMakeLists.txt
View File

@ -23,11 +23,11 @@ if(DOXYGEN_FOUND)
set(DOXYGEN_EXCLUDE_PATTERNS set(DOXYGEN_EXCLUDE_PATTERNS
"wut_structsize.h") "wut_structsize.h")
set(DOXYGEN_EXCLUDE_SYMBOLS set(DOXYGEN_EXCLUDE_SYMBOLS
"UNKNOWN" "WUT_CHECK_OFFSET"
"CHECK_OFFSET" "WUT_CHECK_SIZE"
"CHECK_SIZE" "WUT_PADDING_BYTES"
"UNKNOWN_SIZE" "WUT_UNKNOWN_BYTES"
"PADDING") "WUT_UNKNOWN_SIZE")
set(DOXYGEN_SOURCE_BROWSER YES) set(DOXYGEN_SOURCE_BROWSER YES)
set(DOXYGEN_ENUM_VALUES_PER_LINE 1) set(DOXYGEN_ENUM_VALUES_PER_LINE 1)
set(DOXYGEN_CLASS_DIAGRAMS NO) set(DOXYGEN_CLASS_DIAGRAMS NO)

52
include/coreinit/alarm.h
View File

@ -36,27 +36,27 @@ struct OSAlarmQueue
//! Name set by OSInitAlarmQueueEx //! Name set by OSInitAlarmQueueEx
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
OSThreadQueue threadQueue; OSThreadQueue threadQueue;
OSAlarm *head; OSAlarm *head;
OSAlarm *tail; OSAlarm *tail;
}; };
CHECK_OFFSET(OSAlarmQueue, 0x00, tag); WUT_CHECK_OFFSET(OSAlarmQueue, 0x00, tag);
CHECK_OFFSET(OSAlarmQueue, 0x04, name); WUT_CHECK_OFFSET(OSAlarmQueue, 0x04, name);
CHECK_OFFSET(OSAlarmQueue, 0x0c, threadQueue); WUT_CHECK_OFFSET(OSAlarmQueue, 0x0c, threadQueue);
CHECK_OFFSET(OSAlarmQueue, 0x1c, head); WUT_CHECK_OFFSET(OSAlarmQueue, 0x1c, head);
CHECK_OFFSET(OSAlarmQueue, 0x20, tail); WUT_CHECK_OFFSET(OSAlarmQueue, 0x20, tail);
CHECK_SIZE(OSAlarmQueue, 0x24); WUT_CHECK_SIZE(OSAlarmQueue, 0x24);
struct OSAlarmLink struct OSAlarmLink
{ {
OSAlarm *prev; OSAlarm *prev;
OSAlarm *next; OSAlarm *next;
}; };
CHECK_OFFSET(OSAlarmLink, 0x00, prev); WUT_CHECK_OFFSET(OSAlarmLink, 0x00, prev);
CHECK_OFFSET(OSAlarmLink, 0x04, next); WUT_CHECK_OFFSET(OSAlarmLink, 0x04, next);
CHECK_SIZE(OSAlarmLink, 0x08); WUT_CHECK_SIZE(OSAlarmLink, 0x08);
#define OS_ALARM_TAG 0x614C724Du #define OS_ALARM_TAG 0x614C724Du
struct OSAlarm struct OSAlarm
@ -67,7 +67,7 @@ struct OSAlarm
//! Name set from OSCreateAlarmEx. //! Name set from OSCreateAlarmEx.
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
//! The callback to execute once the alarm is triggered. //! The callback to execute once the alarm is triggered.
OSAlarmCallback callback; OSAlarmCallback callback;
@ -75,7 +75,7 @@ struct OSAlarm
//! Used with OSCancelAlarms for bulk cancellation of alarms. //! Used with OSCancelAlarms for bulk cancellation of alarms.
uint32_t group; uint32_t group;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
//! The time when the alarm will next be triggered. //! The time when the alarm will next be triggered.
OSTime nextFire; OSTime nextFire;
@ -104,20 +104,20 @@ struct OSAlarm
//! The context the alarm was triggered on. //! The context the alarm was triggered on.
OSContext *context; OSContext *context;
}; };
CHECK_OFFSET(OSAlarm, 0x00, tag); WUT_CHECK_OFFSET(OSAlarm, 0x00, tag);
CHECK_OFFSET(OSAlarm, 0x04, name); WUT_CHECK_OFFSET(OSAlarm, 0x04, name);
CHECK_OFFSET(OSAlarm, 0x0c, callback); WUT_CHECK_OFFSET(OSAlarm, 0x0c, callback);
CHECK_OFFSET(OSAlarm, 0x10, group); WUT_CHECK_OFFSET(OSAlarm, 0x10, group);
CHECK_OFFSET(OSAlarm, 0x18, nextFire); WUT_CHECK_OFFSET(OSAlarm, 0x18, nextFire);
CHECK_OFFSET(OSAlarm, 0x20, link); WUT_CHECK_OFFSET(OSAlarm, 0x20, link);
CHECK_OFFSET(OSAlarm, 0x28, period); WUT_CHECK_OFFSET(OSAlarm, 0x28, period);
CHECK_OFFSET(OSAlarm, 0x30, start); WUT_CHECK_OFFSET(OSAlarm, 0x30, start);
CHECK_OFFSET(OSAlarm, 0x38, userData); WUT_CHECK_OFFSET(OSAlarm, 0x38, userData);
CHECK_OFFSET(OSAlarm, 0x3c, state); WUT_CHECK_OFFSET(OSAlarm, 0x3c, state);
CHECK_OFFSET(OSAlarm, 0x40, threadQueue); WUT_CHECK_OFFSET(OSAlarm, 0x40, threadQueue);
CHECK_OFFSET(OSAlarm, 0x50, alarmQueue); WUT_CHECK_OFFSET(OSAlarm, 0x50, alarmQueue);
CHECK_OFFSET(OSAlarm, 0x54, context); WUT_CHECK_OFFSET(OSAlarm, 0x54, context);
CHECK_SIZE(OSAlarm, 0x58); WUT_CHECK_SIZE(OSAlarm, 0x58);
/** /**

10
include/coreinit/condition.h
View File

@ -29,15 +29,15 @@ struct OSCondition
//! Name set by OSInitCondEx. //! Name set by OSInitCondEx.
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
//! Queue of threads currently waiting on condition with OSWaitCond. //! Queue of threads currently waiting on condition with OSWaitCond.
OSThreadQueue queue; OSThreadQueue queue;
}; };
CHECK_OFFSET(OSCondition, 0x00, tag); WUT_CHECK_OFFSET(OSCondition, 0x00, tag);
CHECK_OFFSET(OSCondition, 0x04, name); WUT_CHECK_OFFSET(OSCondition, 0x04, name);
CHECK_OFFSET(OSCondition, 0x0c, queue); WUT_CHECK_OFFSET(OSCondition, 0x0c, queue);
CHECK_SIZE(OSCondition, 0x1c); WUT_CHECK_SIZE(OSCondition, 0x1c);
/** /**

54
include/coreinit/context.h
View File

@ -21,18 +21,18 @@ struct OSContext
uint32_t xer; uint32_t xer;
uint32_t srr0; uint32_t srr0;
uint32_t srr1; uint32_t srr1;
UNKNOWN(0x14); WUT_UNKNOWN_BYTES(0x14);
uint32_t fpscr; uint32_t fpscr;
double fpr[32]; double fpr[32];
uint16_t spinLockCount; uint16_t spinLockCount;
uint16_t state; uint16_t state;
uint32_t gqr[8]; uint32_t gqr[8];
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
double psf[32]; double psf[32];
uint64_t coretime[3]; uint64_t coretime[3];
uint64_t starttime; uint64_t starttime;
uint32_t error; uint32_t error;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
uint32_t pmc1; uint32_t pmc1;
uint32_t pmc2; uint32_t pmc2;
uint32_t pmc3; uint32_t pmc3;
@ -40,30 +40,30 @@ struct OSContext
uint32_t mmcr0; uint32_t mmcr0;
uint32_t mmcr1; uint32_t mmcr1;
}; };
CHECK_OFFSET(OSContext, 0x00, tag); WUT_CHECK_OFFSET(OSContext, 0x00, tag);
CHECK_OFFSET(OSContext, 0x08, gpr); WUT_CHECK_OFFSET(OSContext, 0x08, gpr);
CHECK_OFFSET(OSContext, 0x88, cr); WUT_CHECK_OFFSET(OSContext, 0x88, cr);
CHECK_OFFSET(OSContext, 0x8c, lr); WUT_CHECK_OFFSET(OSContext, 0x8c, lr);
CHECK_OFFSET(OSContext, 0x90, ctr); WUT_CHECK_OFFSET(OSContext, 0x90, ctr);
CHECK_OFFSET(OSContext, 0x94, xer); WUT_CHECK_OFFSET(OSContext, 0x94, xer);
CHECK_OFFSET(OSContext, 0x98, srr0); WUT_CHECK_OFFSET(OSContext, 0x98, srr0);
CHECK_OFFSET(OSContext, 0x9c, srr1); WUT_CHECK_OFFSET(OSContext, 0x9c, srr1);
CHECK_OFFSET(OSContext, 0xb4, fpscr); WUT_CHECK_OFFSET(OSContext, 0xb4, fpscr);
CHECK_OFFSET(OSContext, 0xb8, fpr); WUT_CHECK_OFFSET(OSContext, 0xb8, fpr);
CHECK_OFFSET(OSContext, 0x1b8, spinLockCount); WUT_CHECK_OFFSET(OSContext, 0x1b8, spinLockCount);
CHECK_OFFSET(OSContext, 0x1ba, state); WUT_CHECK_OFFSET(OSContext, 0x1ba, state);
CHECK_OFFSET(OSContext, 0x1bc, gqr); WUT_CHECK_OFFSET(OSContext, 0x1bc, gqr);
CHECK_OFFSET(OSContext, 0x1e0, psf); WUT_CHECK_OFFSET(OSContext, 0x1e0, psf);
CHECK_OFFSET(OSContext, 0x2e0, coretime); WUT_CHECK_OFFSET(OSContext, 0x2e0, coretime);
CHECK_OFFSET(OSContext, 0x2f8, starttime); WUT_CHECK_OFFSET(OSContext, 0x2f8, starttime);
CHECK_OFFSET(OSContext, 0x300, error); WUT_CHECK_OFFSET(OSContext, 0x300, error);
CHECK_OFFSET(OSContext, 0x308, pmc1); WUT_CHECK_OFFSET(OSContext, 0x308, pmc1);
CHECK_OFFSET(OSContext, 0x30c, pmc2); WUT_CHECK_OFFSET(OSContext, 0x30c, pmc2);
CHECK_OFFSET(OSContext, 0x310, pmc3); WUT_CHECK_OFFSET(OSContext, 0x310, pmc3);
CHECK_OFFSET(OSContext, 0x314, pmc4); WUT_CHECK_OFFSET(OSContext, 0x314, pmc4);
CHECK_OFFSET(OSContext, 0x318, mmcr0); WUT_CHECK_OFFSET(OSContext, 0x318, mmcr0);
CHECK_OFFSET(OSContext, 0x31c, mmcr1); WUT_CHECK_OFFSET(OSContext, 0x31c, mmcr1);
CHECK_SIZE(OSContext, 0x320); WUT_CHECK_SIZE(OSContext, 0x320);
#ifdef __cplusplus #ifdef __cplusplus
} }

20
include/coreinit/coroutine.h
View File

@ -25,16 +25,16 @@ struct OSCoroutine
double fpr[18]; double fpr[18];
double psr[18]; double psr[18];
}; };
CHECK_OFFSET(OSCoroutine, 0x00, nia); WUT_CHECK_OFFSET(OSCoroutine, 0x00, nia);
CHECK_OFFSET(OSCoroutine, 0x04, cr); WUT_CHECK_OFFSET(OSCoroutine, 0x04, cr);
CHECK_OFFSET(OSCoroutine, 0x08, ugqr1); WUT_CHECK_OFFSET(OSCoroutine, 0x08, ugqr1);
CHECK_OFFSET(OSCoroutine, 0x0C, stack); WUT_CHECK_OFFSET(OSCoroutine, 0x0C, stack);
CHECK_OFFSET(OSCoroutine, 0x10, sda2Base); WUT_CHECK_OFFSET(OSCoroutine, 0x10, sda2Base);
CHECK_OFFSET(OSCoroutine, 0x14, sdaBase); WUT_CHECK_OFFSET(OSCoroutine, 0x14, sdaBase);
CHECK_OFFSET(OSCoroutine, 0x18, gpr); WUT_CHECK_OFFSET(OSCoroutine, 0x18, gpr);
CHECK_OFFSET(OSCoroutine, 0x60, fpr); WUT_CHECK_OFFSET(OSCoroutine, 0x60, fpr);
CHECK_OFFSET(OSCoroutine, 0xF0, psr); WUT_CHECK_OFFSET(OSCoroutine, 0xF0, psr);
CHECK_SIZE(OSCoroutine, 0x180); WUT_CHECK_SIZE(OSCoroutine, 0x180);
void void
OSInitCoroutine(OSCoroutine *coroutine, OSInitCoroutine(OSCoroutine *coroutine,

14
include/coreinit/event.h
View File

@ -38,7 +38,7 @@ struct OSEvent
//! Name set by OSInitEventEx. //! Name set by OSInitEventEx.
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
//! The current value of the event object. //! The current value of the event object.
BOOL value; BOOL value;
@ -49,12 +49,12 @@ struct OSEvent
//! The mode of the event object, set by OSInitEvent. //! The mode of the event object, set by OSInitEvent.
OSEventMode mode; OSEventMode mode;
}; };
CHECK_OFFSET(OSEvent, 0x0, tag); WUT_CHECK_OFFSET(OSEvent, 0x0, tag);
CHECK_OFFSET(OSEvent, 0x4, name); WUT_CHECK_OFFSET(OSEvent, 0x4, name);
CHECK_OFFSET(OSEvent, 0xc, value); WUT_CHECK_OFFSET(OSEvent, 0xc, value);
CHECK_OFFSET(OSEvent, 0x10, queue); WUT_CHECK_OFFSET(OSEvent, 0x10, queue);
CHECK_OFFSET(OSEvent, 0x20, mode); WUT_CHECK_OFFSET(OSEvent, 0x20, mode);
CHECK_SIZE(OSEvent, 0x24); WUT_CHECK_SIZE(OSEvent, 0x24);
/** /**

10
include/coreinit/fastcondition.h
View File

@ -24,13 +24,13 @@ struct OSFastCondition
{ {
uint32_t tag; uint32_t tag;
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
OSThreadQueue queue; OSThreadQueue queue;
}; };
CHECK_OFFSET(OSFastCondition, 0x00, tag); WUT_CHECK_OFFSET(OSFastCondition, 0x00, tag);
CHECK_OFFSET(OSFastCondition, 0x04, name); WUT_CHECK_OFFSET(OSFastCondition, 0x04, name);
CHECK_OFFSET(OSFastCondition, 0x0c, queue); WUT_CHECK_OFFSET(OSFastCondition, 0x0c, queue);
CHECK_SIZE(OSFastCondition, 0x1c); WUT_CHECK_SIZE(OSFastCondition, 0x1c);
void void
OSFastCond_Init(OSFastCondition *condition, OSFastCond_Init(OSFastCondition *condition,

20
include/coreinit/fastmutex.h
View File

@ -24,9 +24,9 @@ struct OSFastMutexLink
OSFastMutex *next; OSFastMutex *next;
OSFastMutex *prev; OSFastMutex *prev;
}; };
CHECK_OFFSET(OSFastMutexLink, 0x00, next); WUT_CHECK_OFFSET(OSFastMutexLink, 0x00, next);
CHECK_OFFSET(OSFastMutexLink, 0x04, prev); WUT_CHECK_OFFSET(OSFastMutexLink, 0x04, prev);
CHECK_SIZE(OSFastMutexLink, 0x08); WUT_CHECK_SIZE(OSFastMutexLink, 0x08);
#define OS_FAST_MUTEX_TAG 0x664D7458u #define OS_FAST_MUTEX_TAG 0x664D7458u
@ -34,16 +34,16 @@ struct OSFastMutex
{ {
uint32_t tag; uint32_t tag;
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
OSThreadSimpleQueue queue; OSThreadSimpleQueue queue;
OSFastMutexLink link; OSFastMutexLink link;
UNKNOWN(16); WUT_UNKNOWN_BYTES(16);
}; };
CHECK_OFFSET(OSFastMutex, 0x00, tag); WUT_CHECK_OFFSET(OSFastMutex, 0x00, tag);
CHECK_OFFSET(OSFastMutex, 0x04, name); WUT_CHECK_OFFSET(OSFastMutex, 0x04, name);
CHECK_OFFSET(OSFastMutex, 0x0c, queue); WUT_CHECK_OFFSET(OSFastMutex, 0x0c, queue);
CHECK_OFFSET(OSFastMutex, 0x14, link); WUT_CHECK_OFFSET(OSFastMutex, 0x14, link);
CHECK_SIZE(OSFastMutex, 0x2c); WUT_CHECK_SIZE(OSFastMutex, 0x2c);
void void
OSFastMutex_Init(OSFastMutex *mutex, OSFastMutex_Init(OSFastMutex *mutex,

36
include/coreinit/filesystem.h
View File

@ -140,15 +140,15 @@ typedef void(*FSAsyncCallback)(FSClient *, FSCmdBlock *, FSStatus, uint32_t);
struct FSClient struct FSClient
{ {
UNKNOWN(0x1700); WUT_UNKNOWN_BYTES(0x1700);
}; };
CHECK_SIZE(FSClient, 0x1700); WUT_CHECK_SIZE(FSClient, 0x1700);
struct FSCmdBlock struct FSCmdBlock
{ {
UNKNOWN(0xA80); WUT_UNKNOWN_BYTES(0xA80);
}; };
CHECK_SIZE(FSCmdBlock, 0xA80); WUT_CHECK_SIZE(FSCmdBlock, 0xA80);
struct FSStat struct FSStat
{ {
@ -157,41 +157,41 @@ struct FSStat
uint32_t owner; uint32_t owner;
uint32_t group; uint32_t group;
uint32_t size; uint32_t size;
UNKNOWN(0x50); WUT_UNKNOWN_BYTES(0x50);
}; };
CHECK_OFFSET(FSStat, 0x00, flags); WUT_CHECK_OFFSET(FSStat, 0x00, flags);
CHECK_OFFSET(FSStat, 0x10, size); WUT_CHECK_OFFSET(FSStat, 0x10, size);
CHECK_SIZE(FSStat, 0x64); WUT_CHECK_SIZE(FSStat, 0x64);
struct FSStateChangeInfo struct FSStateChangeInfo
{ {
UNKNOWN(0xC); WUT_UNKNOWN_BYTES(0xC);
}; };
CHECK_SIZE(FSStateChangeInfo, 0xC); WUT_CHECK_SIZE(FSStateChangeInfo, 0xC);
struct FSAsyncData struct FSAsyncData
{ {
uint32_t callback; uint32_t callback;
uint32_t param; uint32_t param;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
}; };
CHECK_OFFSET(FSAsyncData, 0x0, callback); WUT_CHECK_OFFSET(FSAsyncData, 0x0, callback);
CHECK_OFFSET(FSAsyncData, 0x4, param); WUT_CHECK_OFFSET(FSAsyncData, 0x4, param);
CHECK_SIZE(FSAsyncData, 0xC); WUT_CHECK_SIZE(FSAsyncData, 0xC);
struct FSDirectoryEntry struct FSDirectoryEntry
{ {
FSStat info; FSStat info;
char name[256]; char name[256];
}; };
CHECK_OFFSET(FSDirectoryEntry, 0x64, name); WUT_CHECK_OFFSET(FSDirectoryEntry, 0x64, name);
CHECK_SIZE(FSDirectoryEntry, 0x164); WUT_CHECK_SIZE(FSDirectoryEntry, 0x164);
struct FSMountSource struct FSMountSource
{ {
UNKNOWN(0x300); WUT_UNKNOWN_BYTES(0x300);
}; };
CHECK_SIZE(FSMountSource, 0x300); WUT_CHECK_SIZE(FSMountSource, 0x300);
void void
FSInit(); FSInit();

8
include/coreinit/ios.h
View File

@ -79,10 +79,10 @@ struct IOSVec
//! Virtual address of buffer. //! Virtual address of buffer.
void *vaddr; void *vaddr;
}; };
CHECK_OFFSET(IOSVec, 0x00, paddr); WUT_CHECK_OFFSET(IOSVec, 0x00, paddr);
CHECK_OFFSET(IOSVec, 0x04, len); WUT_CHECK_OFFSET(IOSVec, 0x04, len);
CHECK_OFFSET(IOSVec, 0x08, vaddr); WUT_CHECK_OFFSET(IOSVec, 0x08, vaddr);
CHECK_SIZE(IOSVec, 0x0C); WUT_CHECK_SIZE(IOSVec, 0x0C);
typedef void (*IOSAsyncCallbackFn)(IOSError, void *); typedef void (*IOSAsyncCallbackFn)(IOSError, void *);

26
include/coreinit/mcp.h
View File

@ -32,37 +32,37 @@ struct __attribute__((__packed__)) MCPInstallProgress
uint32_t contentsTotal; uint32_t contentsTotal;
uint32_t contentsProgress; uint32_t contentsProgress;
}; };
CHECK_OFFSET(MCPInstallProgress, 0x00, inProgress); WUT_CHECK_OFFSET(MCPInstallProgress, 0x00, inProgress);
CHECK_OFFSET(MCPInstallProgress, 0x04, tid); WUT_CHECK_OFFSET(MCPInstallProgress, 0x04, tid);
CHECK_OFFSET(MCPInstallProgress, 0x0C, sizeTotal); WUT_CHECK_OFFSET(MCPInstallProgress, 0x0C, sizeTotal);
CHECK_OFFSET(MCPInstallProgress, 0x14, sizeProgress); WUT_CHECK_OFFSET(MCPInstallProgress, 0x14, sizeProgress);
CHECK_OFFSET(MCPInstallProgress, 0x1C, contentsTotal); WUT_CHECK_OFFSET(MCPInstallProgress, 0x1C, contentsTotal);
CHECK_OFFSET(MCPInstallProgress, 0x20, contentsProgress); WUT_CHECK_OFFSET(MCPInstallProgress, 0x20, contentsProgress);
CHECK_SIZE(MCPInstallProgress, 0x24); WUT_CHECK_SIZE(MCPInstallProgress, 0x24);
struct MCPInstallInfo struct MCPInstallInfo
{ {
UNKNOWN(0x27F); WUT_UNKNOWN_BYTES(0x27F);
}; };
CHECK_SIZE(MCPInstallInfo, 0x27F); WUT_CHECK_SIZE(MCPInstallInfo, 0x27F);
struct MCPInstallTitleInfo struct MCPInstallTitleInfo
{ {
UNKNOWN(0x27F); WUT_UNKNOWN_BYTES(0x27F);
}; };
CHECK_SIZE(MCPInstallTitleInfo, 0x27F); WUT_CHECK_SIZE(MCPInstallTitleInfo, 0x27F);
struct MCPDevice struct MCPDevice
{ {
char name[0x31B]; char name[0x31B];
}; };
CHECK_SIZE(MCPDevice, 0x31B); WUT_CHECK_SIZE(MCPDevice, 0x31B);
struct MCPDeviceList struct MCPDeviceList
{ {
MCPDevice devices[32]; MCPDevice devices[32];
}; };
CHECK_SIZE(MCPDeviceList, 0x31B*32); WUT_CHECK_SIZE(MCPDeviceList, 0x31B*32);
int int
MCP_Open(); MCP_Open();

36
include/coreinit/memblockheap.h
View File

@ -18,7 +18,7 @@ typedef struct MEMBlockHeap MEMBlockHeap;
struct MEMBlockHeapTracking struct MEMBlockHeapTracking
{ {
UNKNOWN(0x8); WUT_UNKNOWN_BYTES(0x8);
//! Pointer to first memory block //! Pointer to first memory block
MEMBlockHeapBlock *blocks; MEMBlockHeapBlock *blocks;
@ -26,9 +26,9 @@ struct MEMBlockHeapTracking
//! Number of blocks in this tracking heap //! Number of blocks in this tracking heap
uint32_t blockCount; uint32_t blockCount;
}; };
CHECK_OFFSET(MEMBlockHeapTracking, 0x08, blocks); WUT_CHECK_OFFSET(MEMBlockHeapTracking, 0x08, blocks);
CHECK_OFFSET(MEMBlockHeapTracking, 0x0C, blockCount); WUT_CHECK_OFFSET(MEMBlockHeapTracking, 0x0C, blockCount);
CHECK_SIZE(MEMBlockHeapTracking, 0x10); WUT_CHECK_SIZE(MEMBlockHeapTracking, 0x10);
struct MEMBlockHeapBlock struct MEMBlockHeapBlock
{ {
@ -47,12 +47,12 @@ struct MEMBlockHeapBlock
//! Link to next block, always set //! Link to next block, always set
MEMBlockHeapBlock *next; MEMBlockHeapBlock *next;
}; };
CHECK_OFFSET(MEMBlockHeapBlock, 0x00, start); WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x00, start);
CHECK_OFFSET(MEMBlockHeapBlock, 0x04, end); WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x04, end);
CHECK_OFFSET(MEMBlockHeapBlock, 0x08, isFree); WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x08, isFree);
CHECK_OFFSET(MEMBlockHeapBlock, 0x0c, prev); WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x0c, prev);
CHECK_OFFSET(MEMBlockHeapBlock, 0x10, next); WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x10, next);
CHECK_SIZE(MEMBlockHeapBlock, 0x14); WUT_CHECK_SIZE(MEMBlockHeapBlock, 0x14);
struct MEMBlockHeap struct MEMBlockHeap
{ {
@ -76,14 +76,14 @@ struct MEMBlockHeap
//! Free block count //! Free block count
uint32_t numFreeBlocks; uint32_t numFreeBlocks;
}; };
CHECK_OFFSET(MEMBlockHeap, 0x00, header); WUT_CHECK_OFFSET(MEMBlockHeap, 0x00, header);
CHECK_OFFSET(MEMBlockHeap, 0x40, defaultTrack); WUT_CHECK_OFFSET(MEMBlockHeap, 0x40, defaultTrack);
CHECK_OFFSET(MEMBlockHeap, 0x50, defaultBlock); WUT_CHECK_OFFSET(MEMBlockHeap, 0x50, defaultBlock);
CHECK_OFFSET(MEMBlockHeap, 0x64, firstBlock); WUT_CHECK_OFFSET(MEMBlockHeap, 0x64, firstBlock);
CHECK_OFFSET(MEMBlockHeap, 0x68, lastBlock); WUT_CHECK_OFFSET(MEMBlockHeap, 0x68, lastBlock);
CHECK_OFFSET(MEMBlockHeap, 0x6C, firstFreeBlock); WUT_CHECK_OFFSET(MEMBlockHeap, 0x6C, firstFreeBlock);
CHECK_OFFSET(MEMBlockHeap, 0x70, numFreeBlocks); WUT_CHECK_OFFSET(MEMBlockHeap, 0x70, numFreeBlocks);
CHECK_SIZE(MEMBlockHeap, 0x74); WUT_CHECK_SIZE(MEMBlockHeap, 0x74);
MEMHeapHandle MEMHeapHandle
MEMInitBlockHeap(MEMBlockHeap *heap, MEMInitBlockHeap(MEMBlockHeap *heap,

32
include/coreinit/memexpheap.h
View File

@ -38,23 +38,23 @@ struct MEMExpHeapBlock
MEMExpHeapBlock *prev; MEMExpHeapBlock *prev;
MEMExpHeapBlock *next; MEMExpHeapBlock *next;
uint16_t tag; uint16_t tag;
UNKNOWN(0x02); WUT_UNKNOWN_BYTES(0x02);
}; };
CHECK_OFFSET(MEMExpHeapBlock, 0x00, attribs); WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x00, attribs);
CHECK_OFFSET(MEMExpHeapBlock, 0x04, blockSize); WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x04, blockSize);
CHECK_OFFSET(MEMExpHeapBlock, 0x08, prev); WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x08, prev);
CHECK_OFFSET(MEMExpHeapBlock, 0x0c, next); WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x0c, next);
CHECK_OFFSET(MEMExpHeapBlock, 0x10, tag); WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x10, tag);
CHECK_SIZE(MEMExpHeapBlock, 0x14); WUT_CHECK_SIZE(MEMExpHeapBlock, 0x14);
struct MEMExpHeapBlockList struct MEMExpHeapBlockList
{ {
MEMExpHeapBlock *head; MEMExpHeapBlock *head;
MEMExpHeapBlock *tail; MEMExpHeapBlock *tail;
}; };
CHECK_OFFSET(MEMExpHeapBlockList, 0x00, head); WUT_CHECK_OFFSET(MEMExpHeapBlockList, 0x00, head);
CHECK_OFFSET(MEMExpHeapBlockList, 0x04, tail); WUT_CHECK_OFFSET(MEMExpHeapBlockList, 0x04, tail);
CHECK_SIZE(MEMExpHeapBlockList, 0x08); WUT_CHECK_SIZE(MEMExpHeapBlockList, 0x08);
struct MEMExpHeap struct MEMExpHeap
{ {
@ -64,12 +64,12 @@ struct MEMExpHeap
uint16_t groupId; uint16_t groupId;
uint16_t attribs; uint16_t attribs;
}; };
CHECK_OFFSET(MEMExpHeap, 0x00, header); WUT_CHECK_OFFSET(MEMExpHeap, 0x00, header);
CHECK_OFFSET(MEMExpHeap, 0x40, freeList); WUT_CHECK_OFFSET(MEMExpHeap, 0x40, freeList);
CHECK_OFFSET(MEMExpHeap, 0x48, usedList); WUT_CHECK_OFFSET(MEMExpHeap, 0x48, usedList);
CHECK_OFFSET(MEMExpHeap, 0x50, groupId); WUT_CHECK_OFFSET(MEMExpHeap, 0x50, groupId);
CHECK_OFFSET(MEMExpHeap, 0x52, attribs); WUT_CHECK_OFFSET(MEMExpHeap, 0x52, attribs);
CHECK_SIZE(MEMExpHeap, 0x54); WUT_CHECK_SIZE(MEMExpHeap, 0x54);
MEMHeapHandle MEMHeapHandle
MEMCreateExpHeapEx(void *heap, MEMCreateExpHeapEx(void *heap,

20
include/coreinit/memfrmheap.h
View File

@ -29,11 +29,11 @@ struct MEMFrmHeapState
void *tail; void *tail;
MEMFrmHeapState *previous; MEMFrmHeapState *previous;
}; };
CHECK_OFFSET(MEMFrmHeapState, 0x00, tag); WUT_CHECK_OFFSET(MEMFrmHeapState, 0x00, tag);
CHECK_OFFSET(MEMFrmHeapState, 0x04, head); WUT_CHECK_OFFSET(MEMFrmHeapState, 0x04, head);
CHECK_OFFSET(MEMFrmHeapState, 0x08, tail); WUT_CHECK_OFFSET(MEMFrmHeapState, 0x08, tail);
CHECK_OFFSET(MEMFrmHeapState, 0x0C, previous); WUT_CHECK_OFFSET(MEMFrmHeapState, 0x0C, previous);
CHECK_SIZE(MEMFrmHeapState, 0x10); WUT_CHECK_SIZE(MEMFrmHeapState, 0x10);
struct MEMFrmHeap struct MEMFrmHeap
{ {
@ -42,11 +42,11 @@ struct MEMFrmHeap
void *tail; void *tail;
MEMFrmHeapState *previousState; MEMFrmHeapState *previousState;
}; };
CHECK_OFFSET(MEMFrmHeap, 0x00, header); WUT_CHECK_OFFSET(MEMFrmHeap, 0x00, header);
CHECK_OFFSET(MEMFrmHeap, 0x40, head); WUT_CHECK_OFFSET(MEMFrmHeap, 0x40, head);
CHECK_OFFSET(MEMFrmHeap, 0x44, tail); WUT_CHECK_OFFSET(MEMFrmHeap, 0x44, tail);
CHECK_OFFSET(MEMFrmHeap, 0x48, previousState); WUT_CHECK_OFFSET(MEMFrmHeap, 0x48, previousState);
CHECK_SIZE(MEMFrmHeap, 0x4C); WUT_CHECK_SIZE(MEMFrmHeap, 0x4C);
MEMHeapHandle MEMHeapHandle
MEMCreateFrmHeapEx(void *heap, MEMCreateFrmHeapEx(void *heap,

18
include/coreinit/memheap.h
View File

@ -71,16 +71,16 @@ struct MEMHeapHeader
//! Flags set during heap creation. //! Flags set during heap creation.
uint32_t flags; uint32_t flags;
UNKNOWN(0x0C); WUT_UNKNOWN_BYTES(0x0C);
}; };
CHECK_OFFSET(MEMHeapHeader, 0x00, tag); WUT_CHECK_OFFSET(MEMHeapHeader, 0x00, tag);
CHECK_OFFSET(MEMHeapHeader, 0x04, link); WUT_CHECK_OFFSET(MEMHeapHeader, 0x04, link);
CHECK_OFFSET(MEMHeapHeader, 0x0C, list); WUT_CHECK_OFFSET(MEMHeapHeader, 0x0C, list);
CHECK_OFFSET(MEMHeapHeader, 0x18, dataStart); WUT_CHECK_OFFSET(MEMHeapHeader, 0x18, dataStart);
CHECK_OFFSET(MEMHeapHeader, 0x1C, dataEnd); WUT_CHECK_OFFSET(MEMHeapHeader, 0x1C, dataEnd);
CHECK_OFFSET(MEMHeapHeader, 0x20, lock); WUT_CHECK_OFFSET(MEMHeapHeader, 0x20, lock);
CHECK_OFFSET(MEMHeapHeader, 0x30, flags); WUT_CHECK_OFFSET(MEMHeapHeader, 0x30, flags);
CHECK_SIZE(MEMHeapHeader, 0x40); WUT_CHECK_SIZE(MEMHeapHeader, 0x40);
/** /**

16
include/coreinit/memlist.h
View File

@ -19,9 +19,9 @@ struct MEMMemoryLink
void *prev; void *prev;
void *next; void *next;
}; };
CHECK_OFFSET(MEMMemoryLink, 0x0, prev); WUT_CHECK_OFFSET(MEMMemoryLink, 0x0, prev);
CHECK_OFFSET(MEMMemoryLink, 0x4, next); WUT_CHECK_OFFSET(MEMMemoryLink, 0x4, next);
CHECK_SIZE(MEMMemoryLink, 0x8); WUT_CHECK_SIZE(MEMMemoryLink, 0x8);
struct MEMMemoryList struct MEMMemoryList
{ {
@ -30,11 +30,11 @@ struct MEMMemoryList
uint16_t count; uint16_t count;
uint16_t offsetToMemoryLink; uint16_t offsetToMemoryLink;
}; };
CHECK_OFFSET(MEMMemoryList, 0x0, head); WUT_CHECK_OFFSET(MEMMemoryList, 0x0, head);
CHECK_OFFSET(MEMMemoryList, 0x4, tail); WUT_CHECK_OFFSET(MEMMemoryList, 0x4, tail);
CHECK_OFFSET(MEMMemoryList, 0x8, count); WUT_CHECK_OFFSET(MEMMemoryList, 0x8, count);
CHECK_OFFSET(MEMMemoryList, 0xa, offsetToMemoryLink); WUT_CHECK_OFFSET(MEMMemoryList, 0xa, offsetToMemoryLink);
CHECK_SIZE(MEMMemoryList, 0xc); WUT_CHECK_SIZE(MEMMemoryList, 0xc);
void void
MEMInitList(MEMMemoryList *list, MEMInitList(MEMMemoryList *list,

12
include/coreinit/memunitheap.h
View File

@ -19,8 +19,8 @@ struct MEMUnitHeapFreeBlock
{ {
MEMUnitHeapFreeBlock *next; MEMUnitHeapFreeBlock *next;
}; };
CHECK_OFFSET(MEMUnitHeapFreeBlock, 0x00, next); WUT_CHECK_OFFSET(MEMUnitHeapFreeBlock, 0x00, next);
CHECK_SIZE(MEMUnitHeapFreeBlock, 0x04); WUT_CHECK_SIZE(MEMUnitHeapFreeBlock, 0x04);
struct MEMUnitHeap struct MEMUnitHeap
{ {
@ -28,10 +28,10 @@ struct MEMUnitHeap
MEMUnitHeapFreeBlock *freeBlocks; MEMUnitHeapFreeBlock *freeBlocks;
uint32_t blockSize; uint32_t blockSize;
}; };
CHECK_OFFSET(MEMUnitHeap, 0x00, header); WUT_CHECK_OFFSET(MEMUnitHeap, 0x00, header);
CHECK_OFFSET(MEMUnitHeap, 0x40, freeBlocks); WUT_CHECK_OFFSET(MEMUnitHeap, 0x40, freeBlocks);
CHECK_OFFSET(MEMUnitHeap, 0x44, blockSize); WUT_CHECK_OFFSET(MEMUnitHeap, 0x44, blockSize);
CHECK_SIZE(MEMUnitHeap, 0x48); WUT_CHECK_SIZE(MEMUnitHeap, 0x48);
MEMHeapHandle MEMHeapHandle
MEMCreateUnitHeapEx(void *heap, MEMCreateUnitHeapEx(void *heap,

26
include/coreinit/messagequeue.h
View File

@ -27,9 +27,9 @@ struct OSMessage
void *message; void *message;
uint32_t args[3]; uint32_t args[3];
}; };
CHECK_OFFSET(OSMessage, 0x00, message); WUT_CHECK_OFFSET(OSMessage, 0x00, message);
CHECK_OFFSET(OSMessage, 0x04, args); WUT_CHECK_OFFSET(OSMessage, 0x04, args);
CHECK_SIZE(OSMessage, 0x10); WUT_CHECK_SIZE(OSMessage, 0x10);
#define OS_MESSAGE_QUEUE_TAG 0x6D536751u #define OS_MESSAGE_QUEUE_TAG 0x6D536751u
@ -37,7 +37,7 @@ struct OSMessageQueue
{ {
uint32_t tag; uint32_t tag;
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
OSThreadQueue sendQueue; OSThreadQueue sendQueue;
OSThreadQueue recvQueue; OSThreadQueue recvQueue;
OSMessage *messages; OSMessage *messages;
@ -45,15 +45,15 @@ struct OSMessageQueue
uint32_t first; uint32_t first;
uint32_t used; uint32_t used;
}; };
CHECK_OFFSET(OSMessageQueue, 0x00, tag); WUT_CHECK_OFFSET(OSMessageQueue, 0x00, tag);
CHECK_OFFSET(OSMessageQueue, 0x04, name); WUT_CHECK_OFFSET(OSMessageQueue, 0x04, name);
CHECK_OFFSET(OSMessageQueue, 0x0c, sendQueue); WUT_CHECK_OFFSET(OSMessageQueue, 0x0c, sendQueue);
CHECK_OFFSET(OSMessageQueue, 0x1c, recvQueue); WUT_CHECK_OFFSET(OSMessageQueue, 0x1c, recvQueue);
CHECK_OFFSET(OSMessageQueue, 0x2c, messages); WUT_CHECK_OFFSET(OSMessageQueue, 0x2c, messages);
CHECK_OFFSET(OSMessageQueue, 0x30, size); WUT_CHECK_OFFSET(OSMessageQueue, 0x30, size);
CHECK_OFFSET(OSMessageQueue, 0x34, first); WUT_CHECK_OFFSET(OSMessageQueue, 0x34, first);
CHECK_OFFSET(OSMessageQueue, 0x38, used); WUT_CHECK_OFFSET(OSMessageQueue, 0x38, used);
CHECK_SIZE(OSMessageQueue, 0x3c); WUT_CHECK_SIZE(OSMessageQueue, 0x3c);
void void
OSInitMessageQueue(OSMessageQueue *queue, OSInitMessageQueue(OSMessageQueue *queue,

22
include/coreinit/mutex.h
View File

@ -26,9 +26,9 @@ struct OSMutexLink
OSMutex *next; OSMutex *next;
OSMutex *prev; OSMutex *prev;
}; };
CHECK_OFFSET(OSMutexLink, 0x00, next); WUT_CHECK_OFFSET(OSMutexLink, 0x00, next);
CHECK_OFFSET(OSMutexLink, 0x04, prev); WUT_CHECK_OFFSET(OSMutexLink, 0x04, prev);
CHECK_SIZE(OSMutexLink, 0x8); WUT_CHECK_SIZE(OSMutexLink, 0x8);
#define OS_MUTEX_TAG 0x6D557458u #define OS_MUTEX_TAG 0x6D557458u
@ -40,7 +40,7 @@ struct OSMutex
//! Name set by OSInitMutexEx. //! Name set by OSInitMutexEx.
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
//! Queue of threads waiting for this mutex to unlock. //! Queue of threads waiting for this mutex to unlock.
OSThreadQueue queue; OSThreadQueue queue;
@ -54,13 +54,13 @@ struct OSMutex
//! Link used inside OSThread's mutex queue. //! Link used inside OSThread's mutex queue.
OSMutexLink link; OSMutexLink link;
}; };
CHECK_OFFSET(OSMutex, 0x00, tag); WUT_CHECK_OFFSET(OSMutex, 0x00, tag);
CHECK_OFFSET(OSMutex, 0x04, name); WUT_CHECK_OFFSET(OSMutex, 0x04, name);
CHECK_OFFSET(OSMutex, 0x0c, queue); WUT_CHECK_OFFSET(OSMutex, 0x0c, queue);
CHECK_OFFSET(OSMutex, 0x1c, owner); WUT_CHECK_OFFSET(OSMutex, 0x1c, owner);
CHECK_OFFSET(OSMutex, 0x20, count); WUT_CHECK_OFFSET(OSMutex, 0x20, count);
CHECK_OFFSET(OSMutex, 0x24, link); WUT_CHECK_OFFSET(OSMutex, 0x24, link);
CHECK_SIZE(OSMutex, 0x2c); WUT_CHECK_SIZE(OSMutex, 0x2c);
/** /**

6
include/coreinit/rendezvous.h
View File

@ -16,10 +16,10 @@ typedef struct OSRendezvous OSRendezvous;
struct OSRendezvous struct OSRendezvous
{ {
uint32_t core[3]; uint32_t core[3];
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
}; };
CHECK_OFFSET(OSRendezvous, 0x00, core); WUT_CHECK_OFFSET(OSRendezvous, 0x00, core);
CHECK_SIZE(OSRendezvous, 0x10); WUT_CHECK_SIZE(OSRendezvous, 0x10);
void void
OSInitRendezvous(OSRendezvous *rendezvous); OSInitRendezvous(OSRendezvous *rendezvous);

12
include/coreinit/semaphore.h
View File

@ -26,7 +26,7 @@ struct OSSemaphore
//! Name set by OSInitMutexEx. //! Name set by OSInitMutexEx.
const char *name; const char *name;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
//! Current count of semaphore //! Current count of semaphore
int32_t count; int32_t count;
@ -34,11 +34,11 @@ struct OSSemaphore
//! Queue of threads waiting on semaphore object with OSWaitSemaphore //! Queue of threads waiting on semaphore object with OSWaitSemaphore
OSThreadQueue queue; OSThreadQueue queue;
}; };
CHECK_OFFSET(OSSemaphore, 0x00, tag); WUT_CHECK_OFFSET(OSSemaphore, 0x00, tag);
CHECK_OFFSET(OSSemaphore, 0x04, name); WUT_CHECK_OFFSET(OSSemaphore, 0x04, name);
CHECK_OFFSET(OSSemaphore, 0x0C, count); WUT_CHECK_OFFSET(OSSemaphore, 0x0C, count);
CHECK_OFFSET(OSSemaphore, 0x10, queue); WUT_CHECK_OFFSET(OSSemaphore, 0x10, queue);
CHECK_SIZE(OSSemaphore, 0x20); WUT_CHECK_SIZE(OSSemaphore, 0x20);
/** /**

10
include/coreinit/spinlock.h
View File

@ -17,13 +17,13 @@ typedef struct OSSpinLock OSSpinLock;
struct OSSpinLock struct OSSpinLock
{ {
uint32_t owner; uint32_t owner;
UNKNOWN(0x4); WUT_UNKNOWN_BYTES(0x4);
uint32_t recursion; uint32_t recursion;
UNKNOWN(0x4); WUT_UNKNOWN_BYTES(0x4);
}; };
CHECK_OFFSET(OSSpinLock, 0x0, owner); WUT_CHECK_OFFSET(OSSpinLock, 0x0, owner);
CHECK_OFFSET(OSSpinLock, 0x8, recursion); WUT_CHECK_OFFSET(OSSpinLock, 0x8, recursion);
CHECK_SIZE(OSSpinLock, 0x10); WUT_CHECK_SIZE(OSSpinLock, 0x10);
void void
OSInitSpinLock(OSSpinLock *spinlock); OSInitSpinLock(OSSpinLock *spinlock);

10
include/coreinit/systeminfo.h
View File

@ -18,12 +18,12 @@ struct OSSystemInfo
uint32_t busClockSpeed; uint32_t busClockSpeed;
uint32_t coreClockSpeed; uint32_t coreClockSpeed;
int64_t baseTime; int64_t baseTime;
UNKNOWN(0x10); WUT_UNKNOWN_BYTES(0x10);
}; };
CHECK_OFFSET(OSSystemInfo, 0x0, busClockSpeed); WUT_CHECK_OFFSET(OSSystemInfo, 0x0, busClockSpeed);
CHECK_OFFSET(OSSystemInfo, 0x4, coreClockSpeed); WUT_CHECK_OFFSET(OSSystemInfo, 0x4, coreClockSpeed);
CHECK_OFFSET(OSSystemInfo, 0x8, baseTime); WUT_CHECK_OFFSET(OSSystemInfo, 0x8, baseTime);
CHECK_SIZE(OSSystemInfo, 0x20); WUT_CHECK_SIZE(OSSystemInfo, 0x20);
OSSystemInfo * OSSystemInfo *
OSGetSystemInfo(); OSGetSystemInfo();

76
include/coreinit/taskqueue.h
View File

@ -45,11 +45,11 @@ struct MPTaskInfo
OSTime duration; OSTime duration;
}; };
#pragma pack(pop) #pragma pack(pop)
CHECK_OFFSET(MPTaskInfo, 0x00, state); WUT_CHECK_OFFSET(MPTaskInfo, 0x00, state);
CHECK_OFFSET(MPTaskInfo, 0x04, result); WUT_CHECK_OFFSET(MPTaskInfo, 0x04, result);
CHECK_OFFSET(MPTaskInfo, 0x08, coreID); WUT_CHECK_OFFSET(MPTaskInfo, 0x08, coreID);
CHECK_OFFSET(MPTaskInfo, 0x0C, duration); WUT_CHECK_OFFSET(MPTaskInfo, 0x0C, duration);
CHECK_SIZE(MPTaskInfo, 0x14); WUT_CHECK_SIZE(MPTaskInfo, 0x14);
#pragma pack(push, 1) #pragma pack(push, 1)
struct MPTask struct MPTask
@ -66,17 +66,17 @@ struct MPTask
void *userData; void *userData;
}; };
#pragma pack(pop) #pragma pack(pop)
CHECK_OFFSET(MPTask, 0x00, self); WUT_CHECK_OFFSET(MPTask, 0x00, self);
CHECK_OFFSET(MPTask, 0x04, queue); WUT_CHECK_OFFSET(MPTask, 0x04, queue);
CHECK_OFFSET(MPTask, 0x08, state); WUT_CHECK_OFFSET(MPTask, 0x08, state);
CHECK_OFFSET(MPTask, 0x0C, func); WUT_CHECK_OFFSET(MPTask, 0x0C, func);
CHECK_OFFSET(MPTask, 0x10, userArg1); WUT_CHECK_OFFSET(MPTask, 0x10, userArg1);
CHECK_OFFSET(MPTask, 0x14, userArg2); WUT_CHECK_OFFSET(MPTask, 0x14, userArg2);
CHECK_OFFSET(MPTask, 0x18, result); WUT_CHECK_OFFSET(MPTask, 0x18, result);
CHECK_OFFSET(MPTask, 0x1C, coreID); WUT_CHECK_OFFSET(MPTask, 0x1C, coreID);
CHECK_OFFSET(MPTask, 0x20, duration); WUT_CHECK_OFFSET(MPTask, 0x20, duration);
CHECK_OFFSET(MPTask, 0x28, userData); WUT_CHECK_OFFSET(MPTask, 0x28, userData);
CHECK_SIZE(MPTask, 0x2C); WUT_CHECK_SIZE(MPTask, 0x2C);
struct MPTaskQueueInfo struct MPTaskQueueInfo
{ {
@ -86,12 +86,12 @@ struct MPTaskQueueInfo
uint32_t tasksRunning; uint32_t tasksRunning;
uint32_t tasksFinished; uint32_t tasksFinished;
}; };
CHECK_OFFSET(MPTaskQueueInfo, 0x00, state); WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x00, state);
CHECK_OFFSET(MPTaskQueueInfo, 0x04, tasks); WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x04, tasks);
CHECK_OFFSET(MPTaskQueueInfo, 0x08, tasksReady); WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x08, tasksReady);
CHECK_OFFSET(MPTaskQueueInfo, 0x0C, tasksRunning); WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x0C, tasksRunning);
CHECK_OFFSET(MPTaskQueueInfo, 0x10, tasksFinished); WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x10, tasksFinished);
CHECK_SIZE(MPTaskQueueInfo, 0x14); WUT_CHECK_SIZE(MPTaskQueueInfo, 0x14);
struct MPTaskQueue struct MPTaskQueue
{ {
@ -100,29 +100,29 @@ struct MPTaskQueue
uint32_t tasks; uint32_t tasks;
uint32_t tasksReady; uint32_t tasksReady;
uint32_t tasksRunning; uint32_t tasksRunning;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
uint32_t tasksFinished; uint32_t tasksFinished;
UNKNOWN(8); WUT_UNKNOWN_BYTES(8);
uint32_t queueIndex; uint32_t queueIndex;
UNKNOWN(8); WUT_UNKNOWN_BYTES(8);
uint32_t queueSize; uint32_t queueSize;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
MPTask **queue; MPTask **queue;
uint32_t queueMaxSize; uint32_t queueMaxSize;
OSSpinLock lock; OSSpinLock lock;
}; };
CHECK_OFFSET(MPTaskQueue, 0x00, self); WUT_CHECK_OFFSET(MPTaskQueue, 0x00, self);
CHECK_OFFSET(MPTaskQueue, 0x04, state); WUT_CHECK_OFFSET(MPTaskQueue, 0x04, state);
CHECK_OFFSET(MPTaskQueue, 0x08, tasks); WUT_CHECK_OFFSET(MPTaskQueue, 0x08, tasks);
CHECK_OFFSET(MPTaskQueue, 0x0C, tasksReady); WUT_CHECK_OFFSET(MPTaskQueue, 0x0C, tasksReady);
CHECK_OFFSET(MPTaskQueue, 0x10, tasksRunning); WUT_CHECK_OFFSET(MPTaskQueue, 0x10, tasksRunning);
CHECK_OFFSET(MPTaskQueue, 0x18, tasksFinished); WUT_CHECK_OFFSET(MPTaskQueue, 0x18, tasksFinished);
CHECK_OFFSET(MPTaskQueue, 0x24, queueIndex); WUT_CHECK_OFFSET(MPTaskQueue, 0x24, queueIndex);
CHECK_OFFSET(MPTaskQueue, 0x30, queueSize); WUT_CHECK_OFFSET(MPTaskQueue, 0x30, queueSize);
CHECK_OFFSET(MPTaskQueue, 0x38, queue); WUT_CHECK_OFFSET(MPTaskQueue, 0x38, queue);
CHECK_OFFSET(MPTaskQueue, 0x3C, queueMaxSize); WUT_CHECK_OFFSET(MPTaskQueue, 0x3C, queueMaxSize);
CHECK_OFFSET(MPTaskQueue, 0x40, lock); WUT_CHECK_OFFSET(MPTaskQueue, 0x40, lock);
CHECK_SIZE(MPTaskQueue, 0x50); WUT_CHECK_SIZE(MPTaskQueue, 0x50);
void void
MPInitTaskQ(MPTaskQueue *queue, MPInitTaskQ(MPTaskQueue *queue,

82
include/coreinit/thread.h
View File

@ -97,21 +97,21 @@ struct OSMutexQueue
OSMutex *head; OSMutex *head;
OSMutex *tail; OSMutex *tail;
void *parent; void *parent;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
}; };
CHECK_OFFSET(OSMutexQueue, 0x0, head); WUT_CHECK_OFFSET(OSMutexQueue, 0x0, head);
CHECK_OFFSET(OSMutexQueue, 0x4, tail); WUT_CHECK_OFFSET(OSMutexQueue, 0x4, tail);
CHECK_OFFSET(OSMutexQueue, 0x8, parent); WUT_CHECK_OFFSET(OSMutexQueue, 0x8, parent);
CHECK_SIZE(OSMutexQueue, 0x10); WUT_CHECK_SIZE(OSMutexQueue, 0x10);
struct OSFastMutexQueue struct OSFastMutexQueue
{ {
OSFastMutex *head; OSFastMutex *head;
OSFastMutex *tail; OSFastMutex *tail;
}; };
CHECK_OFFSET(OSFastMutexQueue, 0x00, head); WUT_CHECK_OFFSET(OSFastMutexQueue, 0x00, head);
CHECK_OFFSET(OSFastMutexQueue, 0x04, tail); WUT_CHECK_OFFSET(OSFastMutexQueue, 0x04, tail);
CHECK_SIZE(OSFastMutexQueue, 0x08); WUT_CHECK_SIZE(OSFastMutexQueue, 0x08);
#define OS_THREAD_TAG 0x74487244u #define OS_THREAD_TAG 0x74487244u
#pragma pack(push, 1) #pragma pack(push, 1)
@ -143,7 +143,7 @@ struct OSThread
//! Exit value //! Exit value
int32_t exitValue; int32_t exitValue;
UNKNOWN(0x35C - 0x338); WUT_UNKNOWN_BYTES(0x35C - 0x338);
//! Queue the thread is currently waiting on //! Queue the thread is currently waiting on
OSThreadQueue *queue; OSThreadQueue *queue;
@ -172,17 +172,17 @@ struct OSThread
//! Thread entry point //! Thread entry point
OSThreadEntryPointFn entryPoint; OSThreadEntryPointFn entryPoint;
UNKNOWN(0x57c - 0x3a0); WUT_UNKNOWN_BYTES(0x57c - 0x3a0);
//! Thread specific values, accessed with OSSetThreadSpecific and OSGetThreadSpecific. //! Thread specific values, accessed with OSSetThreadSpecific and OSGetThreadSpecific.
void *specific[0x10]; void *specific[0x10];
UNKNOWN(0x5c0 - 0x5bc); WUT_UNKNOWN_BYTES(0x5c0 - 0x5bc);
//! Thread name, accessed with OSSetThreadName and OSGetThreadName. //! Thread name, accessed with OSSetThreadName and OSGetThreadName.
const char *name; const char *name;
UNKNOWN(0x4); WUT_UNKNOWN_BYTES(0x4);
//! The stack pointer passed in OSCreateThread. //! The stack pointer passed in OSCreateThread.
void *userStackPointer; void *userStackPointer;
@ -208,37 +208,37 @@ struct OSThread
//! Queue of threads waiting for a thread to be suspended. //! Queue of threads waiting for a thread to be suspended.
OSThreadQueue suspendQueue; OSThreadQueue suspendQueue;
UNKNOWN(0x6a0 - 0x5f4); WUT_UNKNOWN_BYTES(0x6a0 - 0x5f4);
}; };
#pragma pack(pop) #pragma pack(pop)
CHECK_OFFSET(OSThread, 0x320, tag); WUT_CHECK_OFFSET(OSThread, 0x320, tag);
CHECK_OFFSET(OSThread, 0x324, state); WUT_CHECK_OFFSET(OSThread, 0x324, state);
CHECK_OFFSET(OSThread, 0x325, attr); WUT_CHECK_OFFSET(OSThread, 0x325, attr);
CHECK_OFFSET(OSThread, 0x326, id); WUT_CHECK_OFFSET(OSThread, 0x326, id);
CHECK_OFFSET(OSThread, 0x328, suspendCounter); WUT_CHECK_OFFSET(OSThread, 0x328, suspendCounter);
CHECK_OFFSET(OSThread, 0x32c, priority); WUT_CHECK_OFFSET(OSThread, 0x32c, priority);
CHECK_OFFSET(OSThread, 0x330, basePriority); WUT_CHECK_OFFSET(OSThread, 0x330, basePriority);
CHECK_OFFSET(OSThread, 0x334, exitValue); WUT_CHECK_OFFSET(OSThread, 0x334, exitValue);
CHECK_OFFSET(OSThread, 0x35c, queue); WUT_CHECK_OFFSET(OSThread, 0x35c, queue);
CHECK_OFFSET(OSThread, 0x360, link); WUT_CHECK_OFFSET(OSThread, 0x360, link);
CHECK_OFFSET(OSThread, 0x368, joinQueue); WUT_CHECK_OFFSET(OSThread, 0x368, joinQueue);
CHECK_OFFSET(OSThread, 0x378, mutex); WUT_CHECK_OFFSET(OSThread, 0x378, mutex);
CHECK_OFFSET(OSThread, 0x37c, mutexQueue); WUT_CHECK_OFFSET(OSThread, 0x37c, mutexQueue);
CHECK_OFFSET(OSThread, 0x38c, activeLink); WUT_CHECK_OFFSET(OSThread, 0x38c, activeLink);
CHECK_OFFSET(OSThread, 0x394, stackStart); WUT_CHECK_OFFSET(OSThread, 0x394, stackStart);
CHECK_OFFSET(OSThread, 0x398, stackEnd); WUT_CHECK_OFFSET(OSThread, 0x398, stackEnd);
CHECK_OFFSET(OSThread, 0x39c, entryPoint); WUT_CHECK_OFFSET(OSThread, 0x39c, entryPoint);
CHECK_OFFSET(OSThread, 0x57c, specific); WUT_CHECK_OFFSET(OSThread, 0x57c, specific);
CHECK_OFFSET(OSThread, 0x5c0, name); WUT_CHECK_OFFSET(OSThread, 0x5c0, name);
CHECK_OFFSET(OSThread, 0x5c8, userStackPointer); WUT_CHECK_OFFSET(OSThread, 0x5c8, userStackPointer);
CHECK_OFFSET(OSThread, 0x5cc, cleanupCallback); WUT_CHECK_OFFSET(OSThread, 0x5cc, cleanupCallback);
CHECK_OFFSET(OSThread, 0x5d0, deallocator); WUT_CHECK_OFFSET(OSThread, 0x5d0, deallocator);
CHECK_OFFSET(OSThread, 0x5d4, cancelState); WUT_CHECK_OFFSET(OSThread, 0x5d4, cancelState);
CHECK_OFFSET(OSThread, 0x5d8, requestFlag); WUT_CHECK_OFFSET(OSThread, 0x5d8, requestFlag);
CHECK_OFFSET(OSThread, 0x5dc, needSuspend); WUT_CHECK_OFFSET(OSThread, 0x5dc, needSuspend);
CHECK_OFFSET(OSThread, 0x5e0, suspendResult); WUT_CHECK_OFFSET(OSThread, 0x5e0, suspendResult);
CHECK_OFFSET(OSThread, 0x5e4, suspendQueue); WUT_CHECK_OFFSET(OSThread, 0x5e4, suspendQueue);
CHECK_SIZE(OSThread, 0x6a0); WUT_CHECK_SIZE(OSThread, 0x6a0);
/** /**

22
include/coreinit/threadqueue.h
View File

@ -22,30 +22,30 @@ struct OSThreadLink
OSThread *prev; OSThread *prev;
OSThread *next; OSThread *next;
}; };
CHECK_OFFSET(OSThreadLink, 0x00, prev); WUT_CHECK_OFFSET(OSThreadLink, 0x00, prev);
CHECK_OFFSET(OSThreadLink, 0x04, next); WUT_CHECK_OFFSET(OSThreadLink, 0x04, next);
CHECK_SIZE(OSThreadLink, 0x8); WUT_CHECK_SIZE(OSThreadLink, 0x8);
struct OSThreadQueue struct OSThreadQueue
{ {
OSThread *head; OSThread *head;
OSThread *tail; OSThread *tail;
void *parent; void *parent;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
}; };
CHECK_OFFSET(OSThreadQueue, 0x00, head); WUT_CHECK_OFFSET(OSThreadQueue, 0x00, head);
CHECK_OFFSET(OSThreadQueue, 0x04, tail); WUT_CHECK_OFFSET(OSThreadQueue, 0x04, tail);
CHECK_OFFSET(OSThreadQueue, 0x08, parent); WUT_CHECK_OFFSET(OSThreadQueue, 0x08, parent);
CHECK_SIZE(OSThreadQueue, 0x10); WUT_CHECK_SIZE(OSThreadQueue, 0x10);
struct OSThreadSimpleQueue struct OSThreadSimpleQueue
{ {
OSThread *head; OSThread *head;
OSThread *tail; OSThread *tail;
}; };
CHECK_OFFSET(OSThreadSimpleQueue, 0x00, head); WUT_CHECK_OFFSET(OSThreadSimpleQueue, 0x00, head);
CHECK_OFFSET(OSThreadSimpleQueue, 0x04, tail); WUT_CHECK_OFFSET(OSThreadSimpleQueue, 0x04, tail);
CHECK_SIZE(OSThreadSimpleQueue, 0x08); WUT_CHECK_SIZE(OSThreadSimpleQueue, 0x08);
void void
OSInitThreadQueue(OSThreadQueue *queue); OSInitThreadQueue(OSThreadQueue *queue);

22
include/coreinit/time.h
View File

@ -31,17 +31,17 @@ struct OSCalendarTime
int32_t tm_msec; int32_t tm_msec;
int32_t tm_usec; int32_t tm_usec;
}; };
CHECK_OFFSET(OSCalendarTime, 0x00, tm_sec); WUT_CHECK_OFFSET(OSCalendarTime, 0x00, tm_sec);
CHECK_OFFSET(OSCalendarTime, 0x04, tm_min); WUT_CHECK_OFFSET(OSCalendarTime, 0x04, tm_min);
CHECK_OFFSET(OSCalendarTime, 0x08, tm_hour); WUT_CHECK_OFFSET(OSCalendarTime, 0x08, tm_hour);
CHECK_OFFSET(OSCalendarTime, 0x0C, tm_mday); WUT_CHECK_OFFSET(OSCalendarTime, 0x0C, tm_mday);
CHECK_OFFSET(OSCalendarTime, 0x10, tm_mon); WUT_CHECK_OFFSET(OSCalendarTime, 0x10, tm_mon);
CHECK_OFFSET(OSCalendarTime, 0x14, tm_year); WUT_CHECK_OFFSET(OSCalendarTime, 0x14, tm_year);
CHECK_OFFSET(OSCalendarTime, 0x18, tm_wday); WUT_CHECK_OFFSET(OSCalendarTime, 0x18, tm_wday);
CHECK_OFFSET(OSCalendarTime, 0x1C, tm_yday); WUT_CHECK_OFFSET(OSCalendarTime, 0x1C, tm_yday);
CHECK_OFFSET(OSCalendarTime, 0x20, tm_msec); WUT_CHECK_OFFSET(OSCalendarTime, 0x20, tm_msec);
CHECK_OFFSET(OSCalendarTime, 0x24, tm_usec); WUT_CHECK_OFFSET(OSCalendarTime, 0x24, tm_usec);
CHECK_SIZE(OSCalendarTime, 0x28); WUT_CHECK_SIZE(OSCalendarTime, 0x28);
#define OSTimerClockSpeed ((OSGetSystemInfo()->busClockSpeed) / 4) #define OSTimerClockSpeed ((OSGetSystemInfo()->busClockSpeed) / 4)

32
include/gx2/context.h
View File

@ -20,32 +20,32 @@ struct GX2ShadowState
uint32_t context[0x400]; uint32_t context[0x400];
uint32_t alu[0x800]; uint32_t alu[0x800];
uint32_t loop[0x60]; uint32_t loop[0x60];
PADDING((0x80 - 0x60) * 4); WUT_PADDING_BYTES((0x80 - 0x60) * 4);
uint32_t resource[0xD9E]; uint32_t resource[0xD9E];
PADDING((0xDC0 - 0xD9E) * 4); WUT_PADDING_BYTES((0xDC0 - 0xD9E) * 4);
uint32_t sampler[0xA2]; uint32_t sampler[0xA2];
PADDING((0xC0 - 0xA2) * 4); WUT_PADDING_BYTES((0xC0 - 0xA2) * 4);
}; };
CHECK_OFFSET(GX2ShadowState, 0x0000, config); WUT_CHECK_OFFSET(GX2ShadowState, 0x0000, config);
CHECK_OFFSET(GX2ShadowState, 0x2C00, context); WUT_CHECK_OFFSET(GX2ShadowState, 0x2C00, context);
CHECK_OFFSET(GX2ShadowState, 0x3C00, alu); WUT_CHECK_OFFSET(GX2ShadowState, 0x3C00, alu);
CHECK_OFFSET(GX2ShadowState, 0x5C00, loop); WUT_CHECK_OFFSET(GX2ShadowState, 0x5C00, loop);
CHECK_OFFSET(GX2ShadowState, 0x5E00, resource); WUT_CHECK_OFFSET(GX2ShadowState, 0x5E00, resource);
CHECK_OFFSET(GX2ShadowState, 0x9500, sampler); WUT_CHECK_OFFSET(GX2ShadowState, 0x9500, sampler);
CHECK_SIZE(GX2ShadowState, 0x9800); WUT_CHECK_SIZE(GX2ShadowState, 0x9800);
struct GX2ContextState struct GX2ContextState
{ {
GX2ShadowState shadowState; GX2ShadowState shadowState;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
uint32_t shadowDisplayListSize; uint32_t shadowDisplayListSize;
UNKNOWN(0x9e00 - 0x9808); WUT_UNKNOWN_BYTES(0x9e00 - 0x9808);
uint32_t shadowDisplayList[192]; uint32_t shadowDisplayList[192];
}; };
CHECK_OFFSET(GX2ContextState, 0x0000, shadowState); WUT_CHECK_OFFSET(GX2ContextState, 0x0000, shadowState);
CHECK_OFFSET(GX2ContextState, 0x9804, shadowDisplayListSize); WUT_CHECK_OFFSET(GX2ContextState, 0x9804, shadowDisplayListSize);
CHECK_OFFSET(GX2ContextState, 0x9e00, shadowDisplayList); WUT_CHECK_OFFSET(GX2ContextState, 0x9e00, shadowDisplayList);
CHECK_SIZE(GX2ContextState, 0xa100); WUT_CHECK_SIZE(GX2ContextState, 0xa100);
void void
GX2SetupContextStateEx(GX2ContextState *state, GX2SetupContextStateEx(GX2ContextState *state,

12
include/gx2/event.h
View File

@ -30,13 +30,13 @@ struct GX2DisplayListOverrunData
//! Size of new display list //! Size of new display list
uint32_t newSize; uint32_t newSize;
UNKNOWN(8); WUT_UNKNOWN_BYTES(8);
}; };
CHECK_OFFSET(GX2DisplayListOverrunData, 0x00, oldList); WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x00, oldList);
CHECK_OFFSET(GX2DisplayListOverrunData, 0x04, oldSize); WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x04, oldSize);
CHECK_OFFSET(GX2DisplayListOverrunData, 0x08, newList); WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x08, newList);
CHECK_OFFSET(GX2DisplayListOverrunData, 0x0C, newSize); WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x0C, newSize);
CHECK_SIZE(GX2DisplayListOverrunData, 0x18); WUT_CHECK_SIZE(GX2DisplayListOverrunData, 0x18);
BOOL BOOL
GX2DrawDone(); GX2DrawDone();

108
include/gx2/registers.h
View File

@ -34,33 +34,33 @@ struct GX2AAMaskReg
{ {
uint32_t pa_sc_aa_mask; uint32_t pa_sc_aa_mask;
}; };
CHECK_OFFSET(GX2AAMaskReg, 0, pa_sc_aa_mask); WUT_CHECK_OFFSET(GX2AAMaskReg, 0, pa_sc_aa_mask);
CHECK_SIZE(GX2AAMaskReg, 4); WUT_CHECK_SIZE(GX2AAMaskReg, 4);
struct GX2AlphaTestReg struct GX2AlphaTestReg
{ {
uint32_t sx_alpha_test_control; uint32_t sx_alpha_test_control;
uint32_t sx_alpha_ref; uint32_t sx_alpha_ref;
}; };
CHECK_OFFSET(GX2AlphaTestReg, 0, sx_alpha_test_control); WUT_CHECK_OFFSET(GX2AlphaTestReg, 0, sx_alpha_test_control);
CHECK_OFFSET(GX2AlphaTestReg, 4, sx_alpha_ref); WUT_CHECK_OFFSET(GX2AlphaTestReg, 4, sx_alpha_ref);
CHECK_SIZE(GX2AlphaTestReg, 8); WUT_CHECK_SIZE(GX2AlphaTestReg, 8);
struct GX2AlphaToMaskReg struct GX2AlphaToMaskReg
{ {
uint32_t db_alpha_to_mask; uint32_t db_alpha_to_mask;
}; };
CHECK_OFFSET(GX2AlphaToMaskReg, 0, db_alpha_to_mask); WUT_CHECK_OFFSET(GX2AlphaToMaskReg, 0, db_alpha_to_mask);
CHECK_SIZE(GX2AlphaToMaskReg, 4); WUT_CHECK_SIZE(GX2AlphaToMaskReg, 4);
struct GX2BlendControlReg struct GX2BlendControlReg
{ {
GX2RenderTarget target; GX2RenderTarget target;
uint32_t cb_blend_control; uint32_t cb_blend_control;
}; };
CHECK_OFFSET(GX2BlendControlReg, 0, target); WUT_CHECK_OFFSET(GX2BlendControlReg, 0, target);
CHECK_OFFSET(GX2BlendControlReg, 4, cb_blend_control); WUT_CHECK_OFFSET(GX2BlendControlReg, 4, cb_blend_control);
CHECK_SIZE(GX2BlendControlReg, 8); WUT_CHECK_SIZE(GX2BlendControlReg, 8);
struct GX2BlendConstantColorReg struct GX2BlendConstantColorReg
{ {
@ -69,62 +69,62 @@ struct GX2BlendConstantColorReg
float blue; float blue;
float alpha; float alpha;
}; };
CHECK_OFFSET(GX2BlendConstantColorReg, 0x00, red); WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x00, red);
CHECK_OFFSET(GX2BlendConstantColorReg, 0x04, green); WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x04, green);
CHECK_OFFSET(GX2BlendConstantColorReg, 0x08, blue); WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x08, blue);
CHECK_OFFSET(GX2BlendConstantColorReg, 0x0c, alpha); WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x0c, alpha);
CHECK_SIZE(GX2BlendConstantColorReg, 0x10); WUT_CHECK_SIZE(GX2BlendConstantColorReg, 0x10);
struct GX2ColorControlReg struct GX2ColorControlReg
{ {
uint32_t cb_color_control; uint32_t cb_color_control;
}; };
CHECK_OFFSET(GX2ColorControlReg, 0x00, cb_color_control); WUT_CHECK_OFFSET(GX2ColorControlReg, 0x00, cb_color_control);
CHECK_SIZE(GX2ColorControlReg, 4); WUT_CHECK_SIZE(GX2ColorControlReg, 4);
struct GX2DepthStencilControlReg struct GX2DepthStencilControlReg
{ {
uint32_t db_depth_control; uint32_t db_depth_control;
}; };
CHECK_OFFSET(GX2DepthStencilControlReg, 0, db_depth_control); WUT_CHECK_OFFSET(GX2DepthStencilControlReg, 0, db_depth_control);
CHECK_SIZE(GX2DepthStencilControlReg, 4); WUT_CHECK_SIZE(GX2DepthStencilControlReg, 4);
struct GX2StencilMaskReg struct GX2StencilMaskReg
{ {
uint32_t db_stencilrefmask; uint32_t db_stencilrefmask;
uint32_t db_stencilrefmask_bf; uint32_t db_stencilrefmask_bf;
}; };
CHECK_OFFSET(GX2StencilMaskReg, 0, db_stencilrefmask); WUT_CHECK_OFFSET(GX2StencilMaskReg, 0, db_stencilrefmask);
CHECK_OFFSET(GX2StencilMaskReg, 4, db_stencilrefmask_bf); WUT_CHECK_OFFSET(GX2StencilMaskReg, 4, db_stencilrefmask_bf);
CHECK_SIZE(GX2StencilMaskReg, 8); WUT_CHECK_SIZE(GX2StencilMaskReg, 8);
struct GX2LineWidthReg struct GX2LineWidthReg
{ {
uint32_t pa_su_line_cntl; uint32_t pa_su_line_cntl;
}; };
CHECK_OFFSET(GX2LineWidthReg, 0, pa_su_line_cntl); WUT_CHECK_OFFSET(GX2LineWidthReg, 0, pa_su_line_cntl);
CHECK_SIZE(GX2LineWidthReg, 4); WUT_CHECK_SIZE(GX2LineWidthReg, 4);
struct GX2PointSizeReg struct GX2PointSizeReg
{ {
uint32_t pa_su_point_size; uint32_t pa_su_point_size;
}; };
CHECK_OFFSET(GX2PointSizeReg, 0, pa_su_point_size); WUT_CHECK_OFFSET(GX2PointSizeReg, 0, pa_su_point_size);
CHECK_SIZE(GX2PointSizeReg, 4); WUT_CHECK_SIZE(GX2PointSizeReg, 4);
struct GX2PointLimitsReg struct GX2PointLimitsReg
{ {
uint32_t pa_su_point_minmax; uint32_t pa_su_point_minmax;
}; };
CHECK_OFFSET(GX2PointLimitsReg, 0, pa_su_point_minmax); WUT_CHECK_OFFSET(GX2PointLimitsReg, 0, pa_su_point_minmax);
CHECK_SIZE(GX2PointLimitsReg, 4); WUT_CHECK_SIZE(GX2PointLimitsReg, 4);
struct GX2PolygonControlReg struct GX2PolygonControlReg
{ {
uint32_t pa_su_sc_mode_cntl; uint32_t pa_su_sc_mode_cntl;
}; };
CHECK_OFFSET(GX2PolygonControlReg, 0, pa_su_sc_mode_cntl); WUT_CHECK_OFFSET(GX2PolygonControlReg, 0, pa_su_sc_mode_cntl);
CHECK_SIZE(GX2PolygonControlReg, 4); WUT_CHECK_SIZE(GX2PolygonControlReg, 4);
struct GX2PolygonOffsetReg struct GX2PolygonOffsetReg
{ {
@ -134,28 +134,28 @@ struct GX2PolygonOffsetReg
uint32_t pa_su_poly_offset_back_offset; uint32_t pa_su_poly_offset_back_offset;
uint32_t pa_su_poly_offset_clamp; uint32_t pa_su_poly_offset_clamp;
}; };
CHECK_OFFSET(GX2PolygonOffsetReg, 0x00, pa_su_poly_offset_front_scale); WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x00, pa_su_poly_offset_front_scale);
CHECK_OFFSET(GX2PolygonOffsetReg, 0x04, pa_su_poly_offset_front_offset); WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x04, pa_su_poly_offset_front_offset);
CHECK_OFFSET(GX2PolygonOffsetReg, 0x08, pa_su_poly_offset_back_scale); WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x08, pa_su_poly_offset_back_scale);
CHECK_OFFSET(GX2PolygonOffsetReg, 0x0C, pa_su_poly_offset_back_offset); WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x0C, pa_su_poly_offset_back_offset);
CHECK_OFFSET(GX2PolygonOffsetReg, 0x10, pa_su_poly_offset_clamp); WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x10, pa_su_poly_offset_clamp);
CHECK_SIZE(GX2PolygonOffsetReg, 20); WUT_CHECK_SIZE(GX2PolygonOffsetReg, 20);
struct GX2ScissorReg struct GX2ScissorReg
{ {
uint32_t pa_sc_generic_scissor_tl; uint32_t pa_sc_generic_scissor_tl;
uint32_t pa_sc_generic_scissor_br; uint32_t pa_sc_generic_scissor_br;
}; };
CHECK_OFFSET(GX2ScissorReg, 0x00, pa_sc_generic_scissor_tl); WUT_CHECK_OFFSET(GX2ScissorReg, 0x00, pa_sc_generic_scissor_tl);
CHECK_OFFSET(GX2ScissorReg, 0x04, pa_sc_generic_scissor_br); WUT_CHECK_OFFSET(GX2ScissorReg, 0x04, pa_sc_generic_scissor_br);
CHECK_SIZE(GX2ScissorReg, 8); WUT_CHECK_SIZE(GX2ScissorReg, 8);
struct GX2TargetChannelMaskReg struct GX2TargetChannelMaskReg
{ {
uint32_t cb_target_mask; uint32_t cb_target_mask;
}; };
CHECK_OFFSET(GX2TargetChannelMaskReg, 0x00, cb_target_mask); WUT_CHECK_OFFSET(GX2TargetChannelMaskReg, 0x00, cb_target_mask);
CHECK_SIZE(GX2TargetChannelMaskReg, 4); WUT_CHECK_SIZE(GX2TargetChannelMaskReg, 4);
struct GX2ViewportReg struct GX2ViewportReg
{ {
@ -172,19 +172,19 @@ struct GX2ViewportReg
uint32_t pa_sc_vport_zmin; uint32_t pa_sc_vport_zmin;
uint32_t pa_sc_vport_zmax; uint32_t pa_sc_vport_zmax;
}; };
CHECK_OFFSET(GX2ViewportReg, 0x00, pa_cl_vport_xscale); WUT_CHECK_OFFSET(GX2ViewportReg, 0x00, pa_cl_vport_xscale);
CHECK_OFFSET(GX2ViewportReg, 0x04, pa_cl_vport_xoffset); WUT_CHECK_OFFSET(GX2ViewportReg, 0x04, pa_cl_vport_xoffset);
CHECK_OFFSET(GX2ViewportReg, 0x08, pa_cl_vport_yscale); WUT_CHECK_OFFSET(GX2ViewportReg, 0x08, pa_cl_vport_yscale);
CHECK_OFFSET(GX2ViewportReg, 0x0C, pa_cl_vport_yoffset); WUT_CHECK_OFFSET(GX2ViewportReg, 0x0C, pa_cl_vport_yoffset);
CHECK_OFFSET(GX2ViewportReg, 0x10, pa_cl_vport_zscale); WUT_CHECK_OFFSET(GX2ViewportReg, 0x10, pa_cl_vport_zscale);
CHECK_OFFSET(GX2ViewportReg, 0x14, pa_cl_vport_zoffset); WUT_CHECK_OFFSET(GX2ViewportReg, 0x14, pa_cl_vport_zoffset);
CHECK_OFFSET(GX2ViewportReg, 0x18, pa_cl_gb_vert_clip_adj); WUT_CHECK_OFFSET(GX2ViewportReg, 0x18, pa_cl_gb_vert_clip_adj);
CHECK_OFFSET(GX2ViewportReg, 0x1C, pa_cl_gb_vert_disc_adj); WUT_CHECK_OFFSET(GX2ViewportReg, 0x1C, pa_cl_gb_vert_disc_adj);
CHECK_OFFSET(GX2ViewportReg, 0x20, pa_cl_gb_horz_clip_adj); WUT_CHECK_OFFSET(GX2ViewportReg, 0x20, pa_cl_gb_horz_clip_adj);
CHECK_OFFSET(GX2ViewportReg, 0x24, pa_cl_gb_horz_disc_adj); WUT_CHECK_OFFSET(GX2ViewportReg, 0x24, pa_cl_gb_horz_disc_adj);
CHECK_OFFSET(GX2ViewportReg, 0x28, pa_sc_vport_zmin); WUT_CHECK_OFFSET(GX2ViewportReg, 0x28, pa_sc_vport_zmin);
CHECK_OFFSET(GX2ViewportReg, 0x2C, pa_sc_vport_zmax); WUT_CHECK_OFFSET(GX2ViewportReg, 0x2C, pa_sc_vport_zmax);
CHECK_SIZE(GX2ViewportReg, 48); WUT_CHECK_SIZE(GX2ViewportReg, 48);
void void
GX2SetAAMask(uint8_t upperLeft, GX2SetAAMask(uint8_t upperLeft,

2
include/gx2/sampler.h
View File

@ -18,7 +18,7 @@ struct GX2Sampler
{ {
uint32_t regs[3]; uint32_t regs[3];
}; };
CHECK_SIZE(GX2Sampler, 12); WUT_CHECK_SIZE(GX2Sampler, 12);
void void
GX2InitSampler(GX2Sampler *sampler, GX2InitSampler(GX2Sampler *sampler,

258
include/gx2/shaders.h
View File

@ -41,14 +41,14 @@ struct GX2FetchShader
uint32_t numDivisors; uint32_t numDivisors;
uint32_t divisors[2]; uint32_t divisors[2];
}; };
CHECK_OFFSET(GX2FetchShader, 0x0, type); WUT_CHECK_OFFSET(GX2FetchShader, 0x0, type);
CHECK_OFFSET(GX2FetchShader, 0x4, regs.sq_pgm_resources_fs); WUT_CHECK_OFFSET(GX2FetchShader, 0x4, regs.sq_pgm_resources_fs);
CHECK_OFFSET(GX2FetchShader, 0x8, size); WUT_CHECK_OFFSET(GX2FetchShader, 0x8, size);
CHECK_OFFSET(GX2FetchShader, 0xc, program); WUT_CHECK_OFFSET(GX2FetchShader, 0xc, program);
CHECK_OFFSET(GX2FetchShader, 0x10, attribCount); WUT_CHECK_OFFSET(GX2FetchShader, 0x10, attribCount);
CHECK_OFFSET(GX2FetchShader, 0x14, numDivisors); WUT_CHECK_OFFSET(GX2FetchShader, 0x14, numDivisors);
CHECK_OFFSET(GX2FetchShader, 0x18, divisors); WUT_CHECK_OFFSET(GX2FetchShader, 0x18, divisors);
CHECK_SIZE(GX2FetchShader, 0x20); WUT_CHECK_SIZE(GX2FetchShader, 0x20);
struct GX2UniformBlock struct GX2UniformBlock
{ {
@ -56,10 +56,10 @@ struct GX2UniformBlock
uint32_t offset; uint32_t offset;
uint32_t size; uint32_t size;
}; };
CHECK_OFFSET(GX2UniformBlock, 0x00, name); WUT_CHECK_OFFSET(GX2UniformBlock, 0x00, name);
CHECK_OFFSET(GX2UniformBlock, 0x04, offset); WUT_CHECK_OFFSET(GX2UniformBlock, 0x04, offset);
CHECK_OFFSET(GX2UniformBlock, 0x08, size); WUT_CHECK_OFFSET(GX2UniformBlock, 0x08, size);
CHECK_SIZE(GX2UniformBlock, 0x0C); WUT_CHECK_SIZE(GX2UniformBlock, 0x0C);
struct GX2UniformVar struct GX2UniformVar
{ {
@ -69,30 +69,30 @@ struct GX2UniformVar
uint32_t offset; uint32_t offset;
int32_t block; int32_t block;
}; };
CHECK_OFFSET(GX2UniformVar, 0x00, name); WUT_CHECK_OFFSET(GX2UniformVar, 0x00, name);
CHECK_OFFSET(GX2UniformVar, 0x04, type); WUT_CHECK_OFFSET(GX2UniformVar, 0x04, type);
CHECK_OFFSET(GX2UniformVar, 0x08, count); WUT_CHECK_OFFSET(GX2UniformVar, 0x08, count);
CHECK_OFFSET(GX2UniformVar, 0x0C, offset); WUT_CHECK_OFFSET(GX2UniformVar, 0x0C, offset);
CHECK_OFFSET(GX2UniformVar, 0x10, block); WUT_CHECK_OFFSET(GX2UniformVar, 0x10, block);
CHECK_SIZE(GX2UniformVar, 0x14); WUT_CHECK_SIZE(GX2UniformVar, 0x14);
struct GX2UniformInitialValue struct GX2UniformInitialValue
{ {
float value[4]; float value[4];
uint32_t offset; uint32_t offset;
}; };
CHECK_OFFSET(GX2UniformInitialValue, 0x00, value); WUT_CHECK_OFFSET(GX2UniformInitialValue, 0x00, value);
CHECK_OFFSET(GX2UniformInitialValue, 0x10, offset); WUT_CHECK_OFFSET(GX2UniformInitialValue, 0x10, offset);
CHECK_SIZE(GX2UniformInitialValue, 0x14); WUT_CHECK_SIZE(GX2UniformInitialValue, 0x14);
struct GX2LoopVar struct GX2LoopVar
{ {
uint32_t offset; uint32_t offset;
uint32_t value; uint32_t value;
}; };
CHECK_OFFSET(GX2LoopVar, 0x00, offset); WUT_CHECK_OFFSET(GX2LoopVar, 0x00, offset);
CHECK_OFFSET(GX2LoopVar, 0x04, value); WUT_CHECK_OFFSET(GX2LoopVar, 0x04, value);
CHECK_SIZE(GX2LoopVar, 0x08); WUT_CHECK_SIZE(GX2LoopVar, 0x08);
struct GX2SamplerVar struct GX2SamplerVar
{ {
@ -100,10 +100,10 @@ struct GX2SamplerVar
GX2SamplerVarType type; GX2SamplerVarType type;
uint32_t location; uint32_t location;
}; };
CHECK_OFFSET(GX2SamplerVar, 0x00, name); WUT_CHECK_OFFSET(GX2SamplerVar, 0x00, name);
CHECK_OFFSET(GX2SamplerVar, 0x04, type); WUT_CHECK_OFFSET(GX2SamplerVar, 0x04, type);
CHECK_OFFSET(GX2SamplerVar, 0x08, location); WUT_CHECK_OFFSET(GX2SamplerVar, 0x08, location);
CHECK_SIZE(GX2SamplerVar, 0x0C); WUT_CHECK_SIZE(GX2SamplerVar, 0x0C);
struct GX2AttribVar struct GX2AttribVar
{ {
@ -112,11 +112,11 @@ struct GX2AttribVar
uint32_t count; uint32_t count;
uint32_t location; uint32_t location;
}; };
CHECK_OFFSET(GX2AttribVar, 0x00, name); WUT_CHECK_OFFSET(GX2AttribVar, 0x00, name);
CHECK_OFFSET(GX2AttribVar, 0x04, type); WUT_CHECK_OFFSET(GX2AttribVar, 0x04, type);
CHECK_OFFSET(GX2AttribVar, 0x08, count); WUT_CHECK_OFFSET(GX2AttribVar, 0x08, count);
CHECK_OFFSET(GX2AttribVar, 0x0C, location); WUT_CHECK_OFFSET(GX2AttribVar, 0x0C, location);
CHECK_SIZE(GX2AttribVar, 0x10); WUT_CHECK_SIZE(GX2AttribVar, 0x10);
struct GX2VertexShader struct GX2VertexShader
{ {
@ -165,38 +165,38 @@ struct GX2VertexShader
GX2RBuffer gx2rBuffer; GX2RBuffer gx2rBuffer;
}; };
CHECK_OFFSET(GX2VertexShader, 0x00, regs.sq_pgm_resources_vs); WUT_CHECK_OFFSET(GX2VertexShader, 0x00, regs.sq_pgm_resources_vs);
CHECK_OFFSET(GX2VertexShader, 0x04, regs.vgt_primitiveid_en); WUT_CHECK_OFFSET(GX2VertexShader, 0x04, regs.vgt_primitiveid_en);
CHECK_OFFSET(GX2VertexShader, 0x08, regs.spi_vs_out_config); WUT_CHECK_OFFSET(GX2VertexShader, 0x08, regs.spi_vs_out_config);
CHECK_OFFSET(GX2VertexShader, 0x0C, regs.num_spi_vs_out_id); WUT_CHECK_OFFSET(GX2VertexShader, 0x0C, regs.num_spi_vs_out_id);
CHECK_OFFSET(GX2VertexShader, 0x10, regs.spi_vs_out_id); WUT_CHECK_OFFSET(GX2VertexShader, 0x10, regs.spi_vs_out_id);
CHECK_OFFSET(GX2VertexShader, 0x38, regs.pa_cl_vs_out_cntl); WUT_CHECK_OFFSET(GX2VertexShader, 0x38, regs.pa_cl_vs_out_cntl);
CHECK_OFFSET(GX2VertexShader, 0x3C, regs.sq_vtx_semantic_clear); WUT_CHECK_OFFSET(GX2VertexShader, 0x3C, regs.sq_vtx_semantic_clear);
CHECK_OFFSET(GX2VertexShader, 0x40, regs.num_sq_vtx_semantic); WUT_CHECK_OFFSET(GX2VertexShader, 0x40, regs.num_sq_vtx_semantic);
CHECK_OFFSET(GX2VertexShader, 0x44, regs.sq_vtx_semantic); WUT_CHECK_OFFSET(GX2VertexShader, 0x44, regs.sq_vtx_semantic);
CHECK_OFFSET(GX2VertexShader, 0xC4, regs.vgt_strmout_buffer_en); WUT_CHECK_OFFSET(GX2VertexShader, 0xC4, regs.vgt_strmout_buffer_en);
CHECK_OFFSET(GX2VertexShader, 0xC8, regs.vgt_vertex_reuse_block_cntl); WUT_CHECK_OFFSET(GX2VertexShader, 0xC8, regs.vgt_vertex_reuse_block_cntl);
CHECK_OFFSET(GX2VertexShader, 0xCC, regs.vgt_hos_reuse_depth); WUT_CHECK_OFFSET(GX2VertexShader, 0xCC, regs.vgt_hos_reuse_depth);
CHECK_OFFSET(GX2VertexShader, 0xD0, size); WUT_CHECK_OFFSET(GX2VertexShader, 0xD0, size);
CHECK_OFFSET(GX2VertexShader, 0xD4, program); WUT_CHECK_OFFSET(GX2VertexShader, 0xD4, program);
CHECK_OFFSET(GX2VertexShader, 0xD8, mode); WUT_CHECK_OFFSET(GX2VertexShader, 0xD8, mode);
CHECK_OFFSET(GX2VertexShader, 0xDc, uniformBlockCount); WUT_CHECK_OFFSET(GX2VertexShader, 0xDc, uniformBlockCount);
CHECK_OFFSET(GX2VertexShader, 0xE0, uniformBlocks); WUT_CHECK_OFFSET(GX2VertexShader, 0xE0, uniformBlocks);
CHECK_OFFSET(GX2VertexShader, 0xE4, uniformVarCount); WUT_CHECK_OFFSET(GX2VertexShader, 0xE4, uniformVarCount);
CHECK_OFFSET(GX2VertexShader, 0xE8, uniformVars); WUT_CHECK_OFFSET(GX2VertexShader, 0xE8, uniformVars);
CHECK_OFFSET(GX2VertexShader, 0xEc, initialValueCount); WUT_CHECK_OFFSET(GX2VertexShader, 0xEc, initialValueCount);
CHECK_OFFSET(GX2VertexShader, 0xF0, initialValues); WUT_CHECK_OFFSET(GX2VertexShader, 0xF0, initialValues);
CHECK_OFFSET(GX2VertexShader, 0xF4, loopVarCount); WUT_CHECK_OFFSET(GX2VertexShader, 0xF4, loopVarCount);
CHECK_OFFSET(GX2VertexShader, 0xF8, loopVars); WUT_CHECK_OFFSET(GX2VertexShader, 0xF8, loopVars);
CHECK_OFFSET(GX2VertexShader, 0xFc, samplerVarCount); WUT_CHECK_OFFSET(GX2VertexShader, 0xFc, samplerVarCount);
CHECK_OFFSET(GX2VertexShader, 0x100, samplerVars); WUT_CHECK_OFFSET(GX2VertexShader, 0x100, samplerVars);
CHECK_OFFSET(GX2VertexShader, 0x104, attribVarCount); WUT_CHECK_OFFSET(GX2VertexShader, 0x104, attribVarCount);
CHECK_OFFSET(GX2VertexShader, 0x108, attribVars); WUT_CHECK_OFFSET(GX2VertexShader, 0x108, attribVars);
CHECK_OFFSET(GX2VertexShader, 0x10c, ringItemsize); WUT_CHECK_OFFSET(GX2VertexShader, 0x10c, ringItemsize);
CHECK_OFFSET(GX2VertexShader, 0x110, hasStreamOut); WUT_CHECK_OFFSET(GX2VertexShader, 0x110, hasStreamOut);
CHECK_OFFSET(GX2VertexShader, 0x114, streamOutStride); WUT_CHECK_OFFSET(GX2VertexShader, 0x114, streamOutStride);
CHECK_OFFSET(GX2VertexShader, 0x124, gx2rBuffer); WUT_CHECK_OFFSET(GX2VertexShader, 0x124, gx2rBuffer);
CHECK_SIZE(GX2VertexShader, 0x134); WUT_CHECK_SIZE(GX2VertexShader, 0x134);
struct GX2PixelShader struct GX2PixelShader
{ {
@ -235,31 +235,31 @@ struct GX2PixelShader
GX2RBuffer gx2rBuffer; GX2RBuffer gx2rBuffer;
}; };
CHECK_OFFSET(GX2PixelShader, 0x00, regs.sq_pgm_resources_ps); WUT_CHECK_OFFSET(GX2PixelShader, 0x00, regs.sq_pgm_resources_ps);
CHECK_OFFSET(GX2PixelShader, 0x04, regs.sq_pgm_exports_ps); WUT_CHECK_OFFSET(GX2PixelShader, 0x04, regs.sq_pgm_exports_ps);
CHECK_OFFSET(GX2PixelShader, 0x08, regs.spi_ps_in_control_0); WUT_CHECK_OFFSET(GX2PixelShader, 0x08, regs.spi_ps_in_control_0);
CHECK_OFFSET(GX2PixelShader, 0x0C, regs.spi_ps_in_control_1); WUT_CHECK_OFFSET(GX2PixelShader, 0x0C, regs.spi_ps_in_control_1);
CHECK_OFFSET(GX2PixelShader, 0x10, regs.num_spi_ps_input_cntl); WUT_CHECK_OFFSET(GX2PixelShader, 0x10, regs.num_spi_ps_input_cntl);
CHECK_OFFSET(GX2PixelShader, 0x14, regs.spi_ps_input_cntls); WUT_CHECK_OFFSET(GX2PixelShader, 0x14, regs.spi_ps_input_cntls);
CHECK_OFFSET(GX2PixelShader, 0x94, regs.cb_shader_mask); WUT_CHECK_OFFSET(GX2PixelShader, 0x94, regs.cb_shader_mask);
CHECK_OFFSET(GX2PixelShader, 0x98, regs.cb_shader_control); WUT_CHECK_OFFSET(GX2PixelShader, 0x98, regs.cb_shader_control);
CHECK_OFFSET(GX2PixelShader, 0x9C, regs.db_shader_control); WUT_CHECK_OFFSET(GX2PixelShader, 0x9C, regs.db_shader_control);
CHECK_OFFSET(GX2PixelShader, 0xA0, regs.spi_input_z); WUT_CHECK_OFFSET(GX2PixelShader, 0xA0, regs.spi_input_z);
CHECK_OFFSET(GX2PixelShader, 0xA4, size); WUT_CHECK_OFFSET(GX2PixelShader, 0xA4, size);
CHECK_OFFSET(GX2PixelShader, 0xA8, program); WUT_CHECK_OFFSET(GX2PixelShader, 0xA8, program);
CHECK_OFFSET(GX2PixelShader, 0xAC, mode); WUT_CHECK_OFFSET(GX2PixelShader, 0xAC, mode);
CHECK_OFFSET(GX2PixelShader, 0xB0, uniformBlockCount); WUT_CHECK_OFFSET(GX2PixelShader, 0xB0, uniformBlockCount);
CHECK_OFFSET(GX2PixelShader, 0xB4, uniformBlocks); WUT_CHECK_OFFSET(GX2PixelShader, 0xB4, uniformBlocks);
CHECK_OFFSET(GX2PixelShader, 0xB8, uniformVarCount); WUT_CHECK_OFFSET(GX2PixelShader, 0xB8, uniformVarCount);
CHECK_OFFSET(GX2PixelShader, 0xBC, uniformVars); WUT_CHECK_OFFSET(GX2PixelShader, 0xBC, uniformVars);
CHECK_OFFSET(GX2PixelShader, 0xC0, initialValueCount); WUT_CHECK_OFFSET(GX2PixelShader, 0xC0, initialValueCount);
CHECK_OFFSET(GX2PixelShader, 0xC4, initialValues); WUT_CHECK_OFFSET(GX2PixelShader, 0xC4, initialValues);
CHECK_OFFSET(GX2PixelShader, 0xC8, loopVarCount); WUT_CHECK_OFFSET(GX2PixelShader, 0xC8, loopVarCount);
CHECK_OFFSET(GX2PixelShader, 0xCC, loopVars); WUT_CHECK_OFFSET(GX2PixelShader, 0xCC, loopVars);
CHECK_OFFSET(GX2PixelShader, 0xD0, samplerVarCount); WUT_CHECK_OFFSET(GX2PixelShader, 0xD0, samplerVarCount);
CHECK_OFFSET(GX2PixelShader, 0xD4, samplerVars); WUT_CHECK_OFFSET(GX2PixelShader, 0xD4, samplerVars);
CHECK_OFFSET(GX2PixelShader, 0xD8, gx2rBuffer); WUT_CHECK_OFFSET(GX2PixelShader, 0xD8, gx2rBuffer);
CHECK_SIZE(GX2PixelShader, 0xE8); WUT_CHECK_SIZE(GX2PixelShader, 0xE8);
struct GX2GeometryShader struct GX2GeometryShader
{ {
@ -304,36 +304,36 @@ struct GX2GeometryShader
GX2RBuffer gx2rBuffer; GX2RBuffer gx2rBuffer;
}; };
CHECK_OFFSET(GX2GeometryShader, 0x00, regs.sq_pgm_resources_gs); WUT_CHECK_OFFSET(GX2GeometryShader, 0x00, regs.sq_pgm_resources_gs);
CHECK_OFFSET(GX2GeometryShader, 0x04, regs.vgt_gs_out_prim_type); WUT_CHECK_OFFSET(GX2GeometryShader, 0x04, regs.vgt_gs_out_prim_type);
CHECK_OFFSET(GX2GeometryShader, 0x08, regs.vgt_gs_mode); WUT_CHECK_OFFSET(GX2GeometryShader, 0x08, regs.vgt_gs_mode);
CHECK_OFFSET(GX2GeometryShader, 0x0C, regs.pa_cl_vs_out_cntl); WUT_CHECK_OFFSET(GX2GeometryShader, 0x0C, regs.pa_cl_vs_out_cntl);
CHECK_OFFSET(GX2GeometryShader, 0x10, regs.sq_pgm_resources_vs); WUT_CHECK_OFFSET(GX2GeometryShader, 0x10, regs.sq_pgm_resources_vs);
CHECK_OFFSET(GX2GeometryShader, 0x14, regs.sq_gs_vert_itemsize); WUT_CHECK_OFFSET(GX2GeometryShader, 0x14, regs.sq_gs_vert_itemsize);
CHECK_OFFSET(GX2GeometryShader, 0x18, regs.spi_vs_out_config); WUT_CHECK_OFFSET(GX2GeometryShader, 0x18, regs.spi_vs_out_config);
CHECK_OFFSET(GX2GeometryShader, 0x1C, regs.num_spi_vs_out_id); WUT_CHECK_OFFSET(GX2GeometryShader, 0x1C, regs.num_spi_vs_out_id);
CHECK_OFFSET(GX2GeometryShader, 0x20, regs.spi_vs_out_id); WUT_CHECK_OFFSET(GX2GeometryShader, 0x20, regs.spi_vs_out_id);
CHECK_OFFSET(GX2GeometryShader, 0x48, regs.vgt_strmout_buffer_en); WUT_CHECK_OFFSET(GX2GeometryShader, 0x48, regs.vgt_strmout_buffer_en);
CHECK_OFFSET(GX2GeometryShader, 0x4C, size); WUT_CHECK_OFFSET(GX2GeometryShader, 0x4C, size);
CHECK_OFFSET(GX2GeometryShader, 0x50, program); WUT_CHECK_OFFSET(GX2GeometryShader, 0x50, program);
CHECK_OFFSET(GX2GeometryShader, 0x54, vertexProgramSize); WUT_CHECK_OFFSET(GX2GeometryShader, 0x54, vertexProgramSize);
CHECK_OFFSET(GX2GeometryShader, 0x58, vertexProgram); WUT_CHECK_OFFSET(GX2GeometryShader, 0x58, vertexProgram);
CHECK_OFFSET(GX2GeometryShader, 0x5C, mode); WUT_CHECK_OFFSET(GX2GeometryShader, 0x5C, mode);
CHECK_OFFSET(GX2GeometryShader, 0x60, uniformBlockCount); WUT_CHECK_OFFSET(GX2GeometryShader, 0x60, uniformBlockCount);
CHECK_OFFSET(GX2GeometryShader, 0x64, uniformBlocks); WUT_CHECK_OFFSET(GX2GeometryShader, 0x64, uniformBlocks);
CHECK_OFFSET(GX2GeometryShader, 0x68, uniformVarCount); WUT_CHECK_OFFSET(GX2GeometryShader, 0x68, uniformVarCount);
CHECK_OFFSET(GX2GeometryShader, 0x6C, uniformVars); WUT_CHECK_OFFSET(GX2GeometryShader, 0x6C, uniformVars);
CHECK_OFFSET(GX2GeometryShader, 0x70, initialValueCount); WUT_CHECK_OFFSET(GX2GeometryShader, 0x70, initialValueCount);
CHECK_OFFSET(GX2GeometryShader, 0x74, initialValues); WUT_CHECK_OFFSET(GX2GeometryShader, 0x74, initialValues);
CHECK_OFFSET(GX2GeometryShader, 0x78, loopVarCount); WUT_CHECK_OFFSET(GX2GeometryShader, 0x78, loopVarCount);
CHECK_OFFSET(GX2GeometryShader, 0x7C, loopVars); WUT_CHECK_OFFSET(GX2GeometryShader, 0x7C, loopVars);
CHECK_OFFSET(GX2GeometryShader, 0x80, samplerVarCount); WUT_CHECK_OFFSET(GX2GeometryShader, 0x80, samplerVarCount);
CHECK_OFFSET(GX2GeometryShader, 0x84, samplerVars); WUT_CHECK_OFFSET(GX2GeometryShader, 0x84, samplerVars);
CHECK_OFFSET(GX2GeometryShader, 0x88, ringItemSize); WUT_CHECK_OFFSET(GX2GeometryShader, 0x88, ringItemSize);
CHECK_OFFSET(GX2GeometryShader, 0x8C, hasStreamOut); WUT_CHECK_OFFSET(GX2GeometryShader, 0x8C, hasStreamOut);
CHECK_OFFSET(GX2GeometryShader, 0x90, streamOutStride); WUT_CHECK_OFFSET(GX2GeometryShader, 0x90, streamOutStride);
CHECK_OFFSET(GX2GeometryShader, 0xA0, gx2rBuffer); WUT_CHECK_OFFSET(GX2GeometryShader, 0xA0, gx2rBuffer);
CHECK_SIZE(GX2GeometryShader, 0xB0); WUT_CHECK_SIZE(GX2GeometryShader, 0xB0);
struct GX2AttribStream struct GX2AttribStream
{ {
@ -346,15 +346,15 @@ struct GX2AttribStream
uint32_t mask; uint32_t mask;
GX2EndianSwapMode endianSwap; GX2EndianSwapMode endianSwap;
}; };
CHECK_OFFSET(GX2AttribStream, 0x0, location); WUT_CHECK_OFFSET(GX2AttribStream, 0x0, location);
CHECK_OFFSET(GX2AttribStream, 0x4, buffer); WUT_CHECK_OFFSET(GX2AttribStream, 0x4, buffer);
CHECK_OFFSET(GX2AttribStream, 0x8, offset); WUT_CHECK_OFFSET(GX2AttribStream, 0x8, offset);
CHECK_OFFSET(GX2AttribStream, 0xc, format); WUT_CHECK_OFFSET(GX2AttribStream, 0xc, format);
CHECK_OFFSET(GX2AttribStream, 0x10, type); WUT_CHECK_OFFSET(GX2AttribStream, 0x10, type);
CHECK_OFFSET(GX2AttribStream, 0x14, aluDivisor); WUT_CHECK_OFFSET(GX2AttribStream, 0x14, aluDivisor);
CHECK_OFFSET(GX2AttribStream, 0x18, mask); WUT_CHECK_OFFSET(GX2AttribStream, 0x18, mask);
CHECK_OFFSET(GX2AttribStream, 0x1c, endianSwap); WUT_CHECK_OFFSET(GX2AttribStream, 0x1c, endianSwap);
CHECK_SIZE(GX2AttribStream, 0x20); WUT_CHECK_SIZE(GX2AttribStream, 0x20);
uint32_t uint32_t
GX2CalcGeometryShaderInputRingBufferSize(uint32_t ringItemSize); GX2CalcGeometryShaderInputRingBufferSize(uint32_t ringItemSize);

70
include/gx2/surface.h
View File

@ -40,25 +40,25 @@ struct GX2Surface
uint32_t pitch; uint32_t pitch;
uint32_t mipLevelOffset[13]; uint32_t mipLevelOffset[13];
}; };
CHECK_OFFSET(GX2Surface, 0x0, dim); WUT_CHECK_OFFSET(GX2Surface, 0x0, dim);
CHECK_OFFSET(GX2Surface, 0x4, width); WUT_CHECK_OFFSET(GX2Surface, 0x4, width);
CHECK_OFFSET(GX2Surface, 0x8, height); WUT_CHECK_OFFSET(GX2Surface, 0x8, height);
CHECK_OFFSET(GX2Surface, 0xc, depth); WUT_CHECK_OFFSET(GX2Surface, 0xc, depth);
CHECK_OFFSET(GX2Surface, 0x10, mipLevels); WUT_CHECK_OFFSET(GX2Surface, 0x10, mipLevels);
CHECK_OFFSET(GX2Surface, 0x14, format); WUT_CHECK_OFFSET(GX2Surface, 0x14, format);
CHECK_OFFSET(GX2Surface, 0x18, aa); WUT_CHECK_OFFSET(GX2Surface, 0x18, aa);
CHECK_OFFSET(GX2Surface, 0x1c, use); WUT_CHECK_OFFSET(GX2Surface, 0x1c, use);
CHECK_OFFSET(GX2Surface, 0x1c, resourceFlags); WUT_CHECK_OFFSET(GX2Surface, 0x1c, resourceFlags);
CHECK_OFFSET(GX2Surface, 0x20, imageSize); WUT_CHECK_OFFSET(GX2Surface, 0x20, imageSize);
CHECK_OFFSET(GX2Surface, 0x24, image); WUT_CHECK_OFFSET(GX2Surface, 0x24, image);
CHECK_OFFSET(GX2Surface, 0x28, mipmapSize); WUT_CHECK_OFFSET(GX2Surface, 0x28, mipmapSize);
CHECK_OFFSET(GX2Surface, 0x2c, mipmaps); WUT_CHECK_OFFSET(GX2Surface, 0x2c, mipmaps);
CHECK_OFFSET(GX2Surface, 0x30, tileMode); WUT_CHECK_OFFSET(GX2Surface, 0x30, tileMode);
CHECK_OFFSET(GX2Surface, 0x34, swizzle); WUT_CHECK_OFFSET(GX2Surface, 0x34, swizzle);
CHECK_OFFSET(GX2Surface, 0x38, alignment); WUT_CHECK_OFFSET(GX2Surface, 0x38, alignment);
CHECK_OFFSET(GX2Surface, 0x3C, pitch); WUT_CHECK_OFFSET(GX2Surface, 0x3C, pitch);
CHECK_OFFSET(GX2Surface, 0x40, mipLevelOffset); WUT_CHECK_OFFSET(GX2Surface, 0x40, mipLevelOffset);
CHECK_SIZE(GX2Surface, 0x74); WUT_CHECK_SIZE(GX2Surface, 0x74);
struct GX2DepthBuffer struct GX2DepthBuffer
{ {
@ -74,15 +74,15 @@ struct GX2DepthBuffer
uint32_t regs[7]; uint32_t regs[7];
}; };
CHECK_OFFSET(GX2DepthBuffer, 0x74, viewMip); WUT_CHECK_OFFSET(GX2DepthBuffer, 0x74, viewMip);
CHECK_OFFSET(GX2DepthBuffer, 0x78, viewFirstSlice); WUT_CHECK_OFFSET(GX2DepthBuffer, 0x78, viewFirstSlice);
CHECK_OFFSET(GX2DepthBuffer, 0x7C, viewNumSlices); WUT_CHECK_OFFSET(GX2DepthBuffer, 0x7C, viewNumSlices);
CHECK_OFFSET(GX2DepthBuffer, 0x80, hiZPtr); WUT_CHECK_OFFSET(GX2DepthBuffer, 0x80, hiZPtr);
CHECK_OFFSET(GX2DepthBuffer, 0x84, hiZSize); WUT_CHECK_OFFSET(GX2DepthBuffer, 0x84, hiZSize);
CHECK_OFFSET(GX2DepthBuffer, 0x88, depthClear); WUT_CHECK_OFFSET(GX2DepthBuffer, 0x88, depthClear);
CHECK_OFFSET(GX2DepthBuffer, 0x8C, stencilClear); WUT_CHECK_OFFSET(GX2DepthBuffer, 0x8C, stencilClear);
CHECK_OFFSET(GX2DepthBuffer, 0x90, regs); WUT_CHECK_OFFSET(GX2DepthBuffer, 0x90, regs);
CHECK_SIZE(GX2DepthBuffer, 0xAC); WUT_CHECK_SIZE(GX2DepthBuffer, 0xAC);
struct GX2ColorBuffer struct GX2ColorBuffer
{ {
@ -96,13 +96,13 @@ struct GX2ColorBuffer
uint32_t regs[5]; uint32_t regs[5];
}; };
CHECK_OFFSET(GX2ColorBuffer, 0x74, viewMip); WUT_CHECK_OFFSET(GX2ColorBuffer, 0x74, viewMip);
CHECK_OFFSET(GX2ColorBuffer, 0x78, viewFirstSlice); WUT_CHECK_OFFSET(GX2ColorBuffer, 0x78, viewFirstSlice);
CHECK_OFFSET(GX2ColorBuffer, 0x7C, viewNumSlices); WUT_CHECK_OFFSET(GX2ColorBuffer, 0x7C, viewNumSlices);
CHECK_OFFSET(GX2ColorBuffer, 0x80, aaBuffer); WUT_CHECK_OFFSET(GX2ColorBuffer, 0x80, aaBuffer);
CHECK_OFFSET(GX2ColorBuffer, 0x84, aaSize); WUT_CHECK_OFFSET(GX2ColorBuffer, 0x84, aaSize);
CHECK_OFFSET(GX2ColorBuffer, 0x88, regs); WUT_CHECK_OFFSET(GX2ColorBuffer, 0x88, regs);
CHECK_SIZE(GX2ColorBuffer, 0x9C); WUT_CHECK_SIZE(GX2ColorBuffer, 0x9C);
void void
GX2CalcSurfaceSizeAndAlignment(GX2Surface *surface); GX2CalcSurfaceSizeAndAlignment(GX2Surface *surface);

16
include/gx2/texture.h
View File

@ -25,14 +25,14 @@ struct GX2Texture
uint32_t regs[5]; uint32_t regs[5];
}; };
CHECK_OFFSET(GX2Texture, 0x0, surface); WUT_CHECK_OFFSET(GX2Texture, 0x0, surface);
CHECK_OFFSET(GX2Texture, 0x74, viewFirstMip); WUT_CHECK_OFFSET(GX2Texture, 0x74, viewFirstMip);
CHECK_OFFSET(GX2Texture, 0x78, viewNumMips); WUT_CHECK_OFFSET(GX2Texture, 0x78, viewNumMips);
CHECK_OFFSET(GX2Texture, 0x7c, viewFirstSlice); WUT_CHECK_OFFSET(GX2Texture, 0x7c, viewFirstSlice);
CHECK_OFFSET(GX2Texture, 0x80, viewNumSlices); WUT_CHECK_OFFSET(GX2Texture, 0x80, viewNumSlices);
CHECK_OFFSET(GX2Texture, 0x84, compMap); WUT_CHECK_OFFSET(GX2Texture, 0x84, compMap);
CHECK_OFFSET(GX2Texture, 0x88, regs); WUT_CHECK_OFFSET(GX2Texture, 0x88, regs);
CHECK_SIZE(GX2Texture, 0x9c); WUT_CHECK_SIZE(GX2Texture, 0x9c);
void void
GX2InitTextureRegs(GX2Texture *texture); GX2InitTextureRegs(GX2Texture *texture);

10
include/gx2r/buffer.h
View File

@ -21,11 +21,11 @@ struct GX2RBuffer
uint32_t elemCount; uint32_t elemCount;
void *buffer; void *buffer;
}; };
CHECK_SIZE(GX2RBuffer, 0x10); WUT_CHECK_SIZE(GX2RBuffer, 0x10);
CHECK_OFFSET(GX2RBuffer, 0x00, flags); WUT_CHECK_OFFSET(GX2RBuffer, 0x00, flags);
CHECK_OFFSET(GX2RBuffer, 0x04, elemSize); WUT_CHECK_OFFSET(GX2RBuffer, 0x04, elemSize);
CHECK_OFFSET(GX2RBuffer, 0x08, elemCount); WUT_CHECK_OFFSET(GX2RBuffer, 0x08, elemCount);
CHECK_OFFSET(GX2RBuffer, 0x0C, buffer); WUT_CHECK_OFFSET(GX2RBuffer, 0x0C, buffer);
BOOL BOOL
GX2RBufferExists(GX2RBuffer *buffer); GX2RBufferExists(GX2RBuffer *buffer);

90
include/nn/swkbd/swkbd_cpp.h
View File

@ -62,20 +62,20 @@ struct ConfigArg
uint32_t unk_0x0C; uint32_t unk_0x0C;
uint32_t unk_0x10; uint32_t unk_0x10;
int32_t unk_0x14; int32_t unk_0x14;
UNKNOWN(0x9C - 0x18); WUT_UNKNOWN_BYTES(0x9C - 0x18);
uint32_t unk_0x9C; uint32_t unk_0x9C;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
int32_t unk_0xA4; int32_t unk_0xA4;
}; };
CHECK_OFFSET(ConfigArg, languageType, 0x00); WUT_CHECK_OFFSET(ConfigArg, languageType, 0x00);
CHECK_OFFSET(ConfigArg, unk_0x04, 0x04); WUT_CHECK_OFFSET(ConfigArg, unk_0x04, 0x04);
CHECK_OFFSET(ConfigArg, unk_0x08, 0x08); WUT_CHECK_OFFSET(ConfigArg, unk_0x08, 0x08);
CHECK_OFFSET(ConfigArg, unk_0x0C, 0x0C); WUT_CHECK_OFFSET(ConfigArg, unk_0x0C, 0x0C);
CHECK_OFFSET(ConfigArg, unk_0x10, 0x10); WUT_CHECK_OFFSET(ConfigArg, unk_0x10, 0x10);
CHECK_OFFSET(ConfigArg, unk_0x14, 0x14); WUT_CHECK_OFFSET(ConfigArg, unk_0x14, 0x14);
CHECK_OFFSET(ConfigArg, unk_0x9C, 0x9C); WUT_CHECK_OFFSET(ConfigArg, unk_0x9C, 0x9C);
CHECK_OFFSET(ConfigArg, unk_0xA4, 0xA4); WUT_CHECK_OFFSET(ConfigArg, unk_0xA4, 0xA4);
CHECK_SIZE(ConfigArg, 0xA8); WUT_CHECK_SIZE(ConfigArg, 0xA8);
struct ReceiverArg struct ReceiverArg
{ {
@ -86,20 +86,20 @@ struct ReceiverArg
uint32_t unk_0x10 = 0; uint32_t unk_0x10 = 0;
int32_t unk_0x14 = -1; int32_t unk_0x14 = -1;
}; };
CHECK_OFFSET(ReceiverArg, unk_0x00, 0x00); WUT_CHECK_OFFSET(ReceiverArg, unk_0x00, 0x00);
CHECK_OFFSET(ReceiverArg, unk_0x04, 0x04); WUT_CHECK_OFFSET(ReceiverArg, unk_0x04, 0x04);
CHECK_OFFSET(ReceiverArg, unk_0x08, 0x08); WUT_CHECK_OFFSET(ReceiverArg, unk_0x08, 0x08);
CHECK_OFFSET(ReceiverArg, unk_0x0C, 0x0C); WUT_CHECK_OFFSET(ReceiverArg, unk_0x0C, 0x0C);
CHECK_OFFSET(ReceiverArg, unk_0x10, 0x10); WUT_CHECK_OFFSET(ReceiverArg, unk_0x10, 0x10);
CHECK_OFFSET(ReceiverArg, unk_0x14, 0x14); WUT_CHECK_OFFSET(ReceiverArg, unk_0x14, 0x14);
CHECK_SIZE(ReceiverArg, 0x18); WUT_CHECK_SIZE(ReceiverArg, 0x18);
struct KeyboardArg struct KeyboardArg
{ {
ConfigArg configArg; ConfigArg configArg;
ReceiverArg receiverArg; ReceiverArg receiverArg;
}; };
CHECK_SIZE(KeyboardArg, 0xC0); WUT_CHECK_SIZE(KeyboardArg, 0xC0);
struct InputFormArg struct InputFormArg
{ {
@ -113,26 +113,26 @@ struct InputFormArg
bool unk_0x1C = false; bool unk_0x1C = false;
bool unk_0x1D = false; bool unk_0x1D = false;
bool unk_0x1E = false; bool unk_0x1E = false;
PADDING(1); WUT_PADDING_BYTES(1);
}; };
CHECK_OFFSET(InputFormArg, unk_0x00, 0x00); WUT_CHECK_OFFSET(InputFormArg, unk_0x00, 0x00);
CHECK_OFFSET(InputFormArg, unk_0x04, 0x04); WUT_CHECK_OFFSET(InputFormArg, unk_0x04, 0x04);
CHECK_OFFSET(InputFormArg, unk_0x08, 0x08); WUT_CHECK_OFFSET(InputFormArg, unk_0x08, 0x08);
CHECK_OFFSET(InputFormArg, unk_0x0C, 0x0C); WUT_CHECK_OFFSET(InputFormArg, unk_0x0C, 0x0C);
CHECK_OFFSET(InputFormArg, maxTextLength, 0x10); WUT_CHECK_OFFSET(InputFormArg, maxTextLength, 0x10);
CHECK_OFFSET(InputFormArg, unk_0x14, 0x14); WUT_CHECK_OFFSET(InputFormArg, unk_0x14, 0x14);
CHECK_OFFSET(InputFormArg, unk_0x18, 0x18); WUT_CHECK_OFFSET(InputFormArg, unk_0x18, 0x18);
CHECK_OFFSET(InputFormArg, unk_0x1C, 0x1C); WUT_CHECK_OFFSET(InputFormArg, unk_0x1C, 0x1C);
CHECK_OFFSET(InputFormArg, unk_0x1D, 0x1D); WUT_CHECK_OFFSET(InputFormArg, unk_0x1D, 0x1D);
CHECK_OFFSET(InputFormArg, unk_0x1E, 0x1E); WUT_CHECK_OFFSET(InputFormArg, unk_0x1E, 0x1E);
CHECK_SIZE(InputFormArg, 0x20); WUT_CHECK_SIZE(InputFormArg, 0x20);
struct AppearArg struct AppearArg
{ {
KeyboardArg keyboardArg; KeyboardArg keyboardArg;
InputFormArg inputFormArg; InputFormArg inputFormArg;
}; };
CHECK_SIZE(AppearArg, 0xE0); WUT_CHECK_SIZE(AppearArg, 0xE0);
struct CreateArg struct CreateArg
{ {
@ -141,20 +141,20 @@ struct CreateArg
uint32_t unk_0x08 = 0; uint32_t unk_0x08 = 0;
FSClient *fsClient = nullptr; FSClient *fsClient = nullptr;
}; };
CHECK_OFFSET(CreateArg, 0x00, workMemory); WUT_CHECK_OFFSET(CreateArg, 0x00, workMemory);
CHECK_OFFSET(CreateArg, 0x04, regionType); WUT_CHECK_OFFSET(CreateArg, 0x04, regionType);
CHECK_OFFSET(CreateArg, 0x08, unk_0x08); WUT_CHECK_OFFSET(CreateArg, 0x08, unk_0x08);
CHECK_OFFSET(CreateArg, 0x0C, fsClient); WUT_CHECK_OFFSET(CreateArg, 0x0C, fsClient);
CHECK_SIZE(CreateArg, 0x10); WUT_CHECK_SIZE(CreateArg, 0x10);
struct ControllerInfo struct ControllerInfo
{ {
VPADStatus *vpad = nullptr; VPADStatus *vpad = nullptr;
KPADStatus *kpad[4] = { nullptr, nullptr, nullptr, nullptr }; KPADStatus *kpad[4] = { nullptr, nullptr, nullptr, nullptr };
}; };
CHECK_OFFSET(ControllerInfo, 0x00, vpad); WUT_CHECK_OFFSET(ControllerInfo, 0x00, vpad);
CHECK_OFFSET(ControllerInfo, 0x04, kpad); WUT_CHECK_OFFSET(ControllerInfo, 0x04, kpad);
CHECK_SIZE(ControllerInfo, 0x14); WUT_CHECK_SIZE(ControllerInfo, 0x14);
struct DrawStringInfo struct DrawStringInfo
{ {
@ -163,18 +163,18 @@ struct DrawStringInfo
memset(this, 0, sizeof(*this)); memset(this, 0, sizeof(*this));
} }
UNKNOWN(0x1C); WUT_UNKNOWN_BYTES(0x1C);
}; };
CHECK_SIZE(DrawStringInfo, 0x1C); WUT_CHECK_SIZE(DrawStringInfo, 0x1C);
struct KeyboardCondition struct KeyboardCondition
{ {
uint32_t unk_0x00 = 0; uint32_t unk_0x00 = 0;
uint32_t unk_0x04 = 0; uint32_t unk_0x04 = 0;
}; };
CHECK_OFFSET(KeyboardCondition, unk_0x00, 0x00); WUT_CHECK_OFFSET(KeyboardCondition, unk_0x00, 0x00);
CHECK_OFFSET(KeyboardCondition, unk_0x04, 0x04); WUT_CHECK_OFFSET(KeyboardCondition, unk_0x04, 0x04);
CHECK_SIZE(KeyboardCondition, 0x8); WUT_CHECK_SIZE(KeyboardCondition, 0x8);
struct IEventReceiver; struct IEventReceiver;
struct IControllerEventObj; struct IControllerEventObj;

28
include/nsyshid/hid.h
View File

@ -40,29 +40,29 @@ struct HIDDevice
uint8_t interfaceIndex; uint8_t interfaceIndex;
uint8_t subClass; uint8_t subClass;
uint8_t protocol; uint8_t protocol;
PADDING(1); WUT_PADDING_BYTES(1);
uint16_t maxPacketSizeRx; uint16_t maxPacketSizeRx;
uint16_t maxPacketSizeTx; uint16_t maxPacketSizeTx;
}; };
CHECK_OFFSET(HIDDevice, 0x00, handle); WUT_CHECK_OFFSET(HIDDevice, 0x00, handle);
CHECK_OFFSET(HIDDevice, 0x04, physicalDeviceInst); WUT_CHECK_OFFSET(HIDDevice, 0x04, physicalDeviceInst);
CHECK_OFFSET(HIDDevice, 0x08, vid); WUT_CHECK_OFFSET(HIDDevice, 0x08, vid);
CHECK_OFFSET(HIDDevice, 0x0A, pid); WUT_CHECK_OFFSET(HIDDevice, 0x0A, pid);
CHECK_OFFSET(HIDDevice, 0x0C, interfaceIndex); WUT_CHECK_OFFSET(HIDDevice, 0x0C, interfaceIndex);
CHECK_OFFSET(HIDDevice, 0x0D, subClass); WUT_CHECK_OFFSET(HIDDevice, 0x0D, subClass);
CHECK_OFFSET(HIDDevice, 0x0E, protocol); WUT_CHECK_OFFSET(HIDDevice, 0x0E, protocol);
CHECK_OFFSET(HIDDevice, 0x10, maxPacketSizeRx); WUT_CHECK_OFFSET(HIDDevice, 0x10, maxPacketSizeRx);
CHECK_OFFSET(HIDDevice, 0x12, maxPacketSizeTx); WUT_CHECK_OFFSET(HIDDevice, 0x12, maxPacketSizeTx);
CHECK_SIZE(HIDDevice, 0x14); WUT_CHECK_SIZE(HIDDevice, 0x14);
struct HIDClient struct HIDClient
{ {
HIDClient *next; HIDClient *next;
HIDAttachCallback attachCallback; HIDAttachCallback attachCallback;
}; };
CHECK_OFFSET(HIDClient, 0x00, next); WUT_CHECK_OFFSET(HIDClient, 0x00, next);
CHECK_OFFSET(HIDClient, 0x04, attachCallback); WUT_CHECK_OFFSET(HIDClient, 0x04, attachCallback);
CHECK_SIZE(HIDClient, 0x08); WUT_CHECK_SIZE(HIDClient, 0x08);
int32_t int32_t

66
include/padscore/kpad.h
View File

@ -28,9 +28,9 @@ struct KPADVec2D
float x; float x;
float y; float y;
}; };
CHECK_OFFSET(KPADVec2D, 0x00, x); WUT_CHECK_OFFSET(KPADVec2D, 0x00, x);
CHECK_OFFSET(KPADVec2D, 0x04, y); WUT_CHECK_OFFSET(KPADVec2D, 0x04, y);
CHECK_SIZE(KPADVec2D, 0x08); WUT_CHECK_SIZE(KPADVec2D, 0x08);
struct KPADStatus struct KPADStatus
{ {
@ -43,15 +43,15 @@ struct KPADStatus
//! Indicates what KPADButtons have been released since last sample //! Indicates what KPADButtons have been released since last sample
uint32_t release; uint32_t release;
UNKNOWN(5 * 4); WUT_UNKNOWN_BYTES(5 * 4);
KPADVec2D pos; KPADVec2D pos;
UNKNOWN(3 * 4); WUT_UNKNOWN_BYTES(3 * 4);
KPADVec2D angle; KPADVec2D angle;
UNKNOWN(8 * 4); WUT_UNKNOWN_BYTES(8 * 4);
//! Value from KPADExtensionType //! Value from KPADExtensionType
uint8_t extensionType; uint8_t extensionType;
@ -97,39 +97,39 @@ struct KPADStatus
int32_t wired; int32_t wired;
} pro; } pro;
UNKNOWN(20 * 4); WUT_UNKNOWN_BYTES(20 * 4);
}; };
UNKNOWN(16 * 4); WUT_UNKNOWN_BYTES(16 * 4);
}; };
CHECK_OFFSET(KPADStatus, 0x00, hold); WUT_CHECK_OFFSET(KPADStatus, 0x00, hold);
CHECK_OFFSET(KPADStatus, 0x04, trigger); WUT_CHECK_OFFSET(KPADStatus, 0x04, trigger);
CHECK_OFFSET(KPADStatus, 0x08, release); WUT_CHECK_OFFSET(KPADStatus, 0x08, release);
CHECK_OFFSET(KPADStatus, 0x20, pos); WUT_CHECK_OFFSET(KPADStatus, 0x20, pos);
CHECK_OFFSET(KPADStatus, 0x34, angle); WUT_CHECK_OFFSET(KPADStatus, 0x34, angle);
CHECK_OFFSET(KPADStatus, 0x5C, extensionType); WUT_CHECK_OFFSET(KPADStatus, 0x5C, extensionType);
CHECK_OFFSET(KPADStatus, 0x5D, error); WUT_CHECK_OFFSET(KPADStatus, 0x5D, error);
CHECK_OFFSET(KPADStatus, 0x5E, posValid); WUT_CHECK_OFFSET(KPADStatus, 0x5E, posValid);
CHECK_OFFSET(KPADStatus, 0x5F, format); WUT_CHECK_OFFSET(KPADStatus, 0x5F, format);
// For WPAD_EXT_NUNCHUK // For WPAD_EXT_NUNCHUK
CHECK_OFFSET(KPADStatus, 0x60, nunchuck.stick); WUT_CHECK_OFFSET(KPADStatus, 0x60, nunchuck.stick);
// For WPAD_EXT_CLASSIC // For WPAD_EXT_CLASSIC
CHECK_OFFSET(KPADStatus, 0x60, classic.hold); WUT_CHECK_OFFSET(KPADStatus, 0x60, classic.hold);
CHECK_OFFSET(KPADStatus, 0x64, classic.trigger); WUT_CHECK_OFFSET(KPADStatus, 0x64, classic.trigger);
CHECK_OFFSET(KPADStatus, 0x68, classic.release); WUT_CHECK_OFFSET(KPADStatus, 0x68, classic.release);
CHECK_OFFSET(KPADStatus, 0x6C, classic.leftStick); WUT_CHECK_OFFSET(KPADStatus, 0x6C, classic.leftStick);
CHECK_OFFSET(KPADStatus, 0x74, classic.rightStick); WUT_CHECK_OFFSET(KPADStatus, 0x74, classic.rightStick);
CHECK_OFFSET(KPADStatus, 0x7C, classic.leftTrigger); WUT_CHECK_OFFSET(KPADStatus, 0x7C, classic.leftTrigger);
CHECK_OFFSET(KPADStatus, 0x80, classic.rightTrigger); WUT_CHECK_OFFSET(KPADStatus, 0x80, classic.rightTrigger);
// For WPAD_EXT_PRO_CONTROLLER // For WPAD_EXT_PRO_CONTROLLER
CHECK_OFFSET(KPADStatus, 0x60, pro.hold); WUT_CHECK_OFFSET(KPADStatus, 0x60, pro.hold);
CHECK_OFFSET(KPADStatus, 0x64, pro.trigger); WUT_CHECK_OFFSET(KPADStatus, 0x64, pro.trigger);
CHECK_OFFSET(KPADStatus, 0x68, pro.release); WUT_CHECK_OFFSET(KPADStatus, 0x68, pro.release);
CHECK_OFFSET(KPADStatus, 0x6C, pro.leftStick); WUT_CHECK_OFFSET(KPADStatus, 0x6C, pro.leftStick);
CHECK_OFFSET(KPADStatus, 0x74, pro.rightStick); WUT_CHECK_OFFSET(KPADStatus, 0x74, pro.rightStick);
CHECK_OFFSET(KPADStatus, 0x7C, pro.charging); WUT_CHECK_OFFSET(KPADStatus, 0x7C, pro.charging);
CHECK_OFFSET(KPADStatus, 0x80, pro.wired); WUT_CHECK_OFFSET(KPADStatus, 0x80, pro.wired);
CHECK_SIZE(KPADStatus, 0xF0); WUT_CHECK_SIZE(KPADStatus, 0xF0);
void void
KPADInit(); KPADInit();

26
include/padscore/wpad.h
View File

@ -108,32 +108,32 @@ struct WPADVec2D
int16_t x; int16_t x;
int16_t y; int16_t y;
}; };
CHECK_OFFSET(WPADVec2D, 0x00, x); WUT_CHECK_OFFSET(WPADVec2D, 0x00, x);
CHECK_OFFSET(WPADVec2D, 0x02, y); WUT_CHECK_OFFSET(WPADVec2D, 0x02, y);
CHECK_SIZE(WPADVec2D, 0x04); WUT_CHECK_SIZE(WPADVec2D, 0x04);
struct WPADStatusProController struct WPADStatusProController
{ {
UNKNOWN(0x28); WUT_UNKNOWN_BYTES(0x28);
//! A value from WPADExtensionType //! A value from WPADExtensionType
uint8_t extensionType; uint8_t extensionType;
uint8_t err; uint8_t err;
PADDING(2); WUT_PADDING_BYTES(2);
uint32_t buttons; uint32_t buttons;
WPADVec2D leftStick; WPADVec2D leftStick;
WPADVec2D rightStick; WPADVec2D rightStick;
UNKNOWN(8); WUT_UNKNOWN_BYTES(8);
WPADDataFormat dataFormat; WPADDataFormat dataFormat;
}; };
CHECK_OFFSET(WPADStatusProController, 0x28, extensionType); WUT_CHECK_OFFSET(WPADStatusProController, 0x28, extensionType);
CHECK_OFFSET(WPADStatusProController, 0x29, err); WUT_CHECK_OFFSET(WPADStatusProController, 0x29, err);
CHECK_OFFSET(WPADStatusProController, 0x2C, buttons); WUT_CHECK_OFFSET(WPADStatusProController, 0x2C, buttons);
CHECK_OFFSET(WPADStatusProController, 0x30, leftStick); WUT_CHECK_OFFSET(WPADStatusProController, 0x30, leftStick);
CHECK_OFFSET(WPADStatusProController, 0x34, rightStick); WUT_CHECK_OFFSET(WPADStatusProController, 0x34, rightStick);
CHECK_OFFSET(WPADStatusProController, 0x40, dataFormat); WUT_CHECK_OFFSET(WPADStatusProController, 0x40, dataFormat);
CHECK_SIZE(WPADStatusProController, 0x44); WUT_CHECK_SIZE(WPADStatusProController, 0x44);
typedef void (*WPADSamplingCallback)(WPADChan chan); typedef void (*WPADSamplingCallback)(WPADChan chan);
typedef void (*WPADExtensionCallback)(WPADChan chan, int32_t status); typedef void (*WPADExtensionCallback)(WPADChan chan, int32_t status);

8
include/sndcore2/core.h
View File

@ -44,12 +44,12 @@ struct AXProfile
struct AXInitParams struct AXInitParams
{ {
AXInitRenderer renderer; AXInitRenderer renderer;
UNKNOWN(4); WUT_UNKNOWN_BYTES(4);
AXInitPipeline pipeline; AXInitPipeline pipeline;
}; };
CHECK_OFFSET(AXInitParams, 0x00, renderer); WUT_CHECK_OFFSET(AXInitParams, 0x00, renderer);
CHECK_OFFSET(AXInitParams, 0x08, pipeline); WUT_CHECK_OFFSET(AXInitParams, 0x08, pipeline);
CHECK_SIZE(AXInitParams, 0x0C); WUT_CHECK_SIZE(AXInitParams, 0x0C);
void void
AXInit(); AXInit();

94
include/sndcore2/voice.h
View File

@ -101,9 +101,9 @@ struct AXVoiceLink
AXVoice *next; AXVoice *next;
AXVoice *prev; AXVoice *prev;
}; };
CHECK_OFFSET(AXVoiceLink, 0x0, next); WUT_CHECK_OFFSET(AXVoiceLink, 0x0, next);
CHECK_OFFSET(AXVoiceLink, 0x4, prev); WUT_CHECK_OFFSET(AXVoiceLink, 0x4, prev);
CHECK_SIZE(AXVoiceLink, 0x8); WUT_CHECK_SIZE(AXVoiceLink, 0x8);
struct AXVoiceOffsets struct AXVoiceOffsets
{ {
@ -114,13 +114,13 @@ struct AXVoiceOffsets
uint32_t currentOffset; uint32_t currentOffset;
const void *data; const void *data;
}; };
CHECK_OFFSET(AXVoiceOffsets, 0x0, dataType); WUT_CHECK_OFFSET(AXVoiceOffsets, 0x0, dataType);
CHECK_OFFSET(AXVoiceOffsets, 0x2, loopingEnabled); WUT_CHECK_OFFSET(AXVoiceOffsets, 0x2, loopingEnabled);
CHECK_OFFSET(AXVoiceOffsets, 0x4, loopOffset); WUT_CHECK_OFFSET(AXVoiceOffsets, 0x4, loopOffset);
CHECK_OFFSET(AXVoiceOffsets, 0x8, endOffset); WUT_CHECK_OFFSET(AXVoiceOffsets, 0x8, endOffset);
CHECK_OFFSET(AXVoiceOffsets, 0xc, currentOffset); WUT_CHECK_OFFSET(AXVoiceOffsets, 0xc, currentOffset);
CHECK_OFFSET(AXVoiceOffsets, 0x10, data); WUT_CHECK_OFFSET(AXVoiceOffsets, 0x10, data);
CHECK_SIZE(AXVoiceOffsets, 0x14); WUT_CHECK_SIZE(AXVoiceOffsets, 0x14);
struct AXVoice struct AXVoice
{ {
@ -154,7 +154,7 @@ struct AXVoice
//! A bitfield representing different things needing to be synced. //! A bitfield representing different things needing to be synced.
uint32_t syncBits; uint32_t syncBits;
UNKNOWN(0x8); WUT_UNKNOWN_BYTES(0x8);
//! The current offset data! //! The current offset data!
AXVoiceOffsets offsets; AXVoiceOffsets offsets;
@ -168,56 +168,56 @@ struct AXVoice
float unk0; float unk0;
float unk1; float unk1;
}; };
CHECK_OFFSET(AXVoice, 0x0, index); WUT_CHECK_OFFSET(AXVoice, 0x0, index);
CHECK_OFFSET(AXVoice, 0x4, state); WUT_CHECK_OFFSET(AXVoice, 0x4, state);
CHECK_OFFSET(AXVoice, 0x8, volume); WUT_CHECK_OFFSET(AXVoice, 0x8, volume);
CHECK_OFFSET(AXVoice, 0xc, renderer); WUT_CHECK_OFFSET(AXVoice, 0xc, renderer);
CHECK_OFFSET(AXVoice, 0x10, link); WUT_CHECK_OFFSET(AXVoice, 0x10, link);
CHECK_OFFSET(AXVoice, 0x18, cbNext); WUT_CHECK_OFFSET(AXVoice, 0x18, cbNext);
CHECK_OFFSET(AXVoice, 0x1c, priority); WUT_CHECK_OFFSET(AXVoice, 0x1c, priority);
CHECK_OFFSET(AXVoice, 0x20, callback); WUT_CHECK_OFFSET(AXVoice, 0x20, callback);
CHECK_OFFSET(AXVoice, 0x24, userContext); WUT_CHECK_OFFSET(AXVoice, 0x24, userContext);
CHECK_OFFSET(AXVoice, 0x28, syncBits); WUT_CHECK_OFFSET(AXVoice, 0x28, syncBits);
CHECK_OFFSET(AXVoice, 0x34, offsets); WUT_CHECK_OFFSET(AXVoice, 0x34, offsets);
CHECK_OFFSET(AXVoice, 0x48, callbackEx); WUT_CHECK_OFFSET(AXVoice, 0x48, callbackEx);
CHECK_OFFSET(AXVoice, 0x4c, callbackReason); WUT_CHECK_OFFSET(AXVoice, 0x4c, callbackReason);
CHECK_OFFSET(AXVoice, 0x50, unk0); WUT_CHECK_OFFSET(AXVoice, 0x50, unk0);
CHECK_OFFSET(AXVoice, 0x54, unk1); WUT_CHECK_OFFSET(AXVoice, 0x54, unk1);
CHECK_SIZE(AXVoice, 0x58); WUT_CHECK_SIZE(AXVoice, 0x58);
struct AXVoiceDeviceBusMixData struct AXVoiceDeviceBusMixData
{ {
uint16_t volume; uint16_t volume;
int16_t delta; int16_t delta;
}; };
CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x0, volume); WUT_CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x0, volume);
CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x2, delta); WUT_CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x2, delta);
CHECK_SIZE(AXVoiceDeviceBusMixData, 0x4); WUT_CHECK_SIZE(AXVoiceDeviceBusMixData, 0x4);
struct AXVoiceDeviceMixData struct AXVoiceDeviceMixData
{ {
AXVoiceDeviceBusMixData bus[4]; AXVoiceDeviceBusMixData bus[4];
}; };
CHECK_OFFSET(AXVoiceDeviceMixData, 0x0, bus); WUT_CHECK_OFFSET(AXVoiceDeviceMixData, 0x0, bus);
CHECK_SIZE(AXVoiceDeviceMixData, 0x10); WUT_CHECK_SIZE(AXVoiceDeviceMixData, 0x10);
struct AXVoiceVeData struct AXVoiceVeData
{ {
uint16_t volume; uint16_t volume;
int16_t delta; int16_t delta;
}; };
CHECK_OFFSET(AXVoiceVeData, 0x0, volume); WUT_CHECK_OFFSET(AXVoiceVeData, 0x0, volume);
CHECK_OFFSET(AXVoiceVeData, 0x2, delta); WUT_CHECK_OFFSET(AXVoiceVeData, 0x2, delta);
CHECK_SIZE(AXVoiceVeData, 0x4); WUT_CHECK_SIZE(AXVoiceVeData, 0x4);
struct AXVoiceAdpcmLoopData struct AXVoiceAdpcmLoopData
{ {
uint16_t predScale; uint16_t predScale;
int16_t prevSample[2]; int16_t prevSample[2];
}; };
CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x0, predScale); WUT_CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x0, predScale);
CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x2, prevSample); WUT_CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x2, prevSample);
CHECK_SIZE(AXVoiceAdpcmLoopData, 0x6); WUT_CHECK_SIZE(AXVoiceAdpcmLoopData, 0x6);
struct AXVoiceAdpcm struct AXVoiceAdpcm
{ {
@ -226,11 +226,11 @@ struct AXVoiceAdpcm
uint16_t predScale; uint16_t predScale;
int16_t prevSample[2]; int16_t prevSample[2];
}; };
CHECK_OFFSET(AXVoiceAdpcm, 0x0, coefficients); WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x0, coefficients);
CHECK_OFFSET(AXVoiceAdpcm, 0x20, gain); WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x20, gain);
CHECK_OFFSET(AXVoiceAdpcm, 0x22, predScale); WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x22, predScale);
CHECK_OFFSET(AXVoiceAdpcm, 0x24, prevSample); WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x24, prevSample);
CHECK_SIZE(AXVoiceAdpcm, 0x28); WUT_CHECK_SIZE(AXVoiceAdpcm, 0x28);
#pragma pack(push, 1) #pragma pack(push, 1)
@ -246,10 +246,10 @@ struct AXVoiceSrc
uint16_t currentOffsetFrac; uint16_t currentOffsetFrac;
int16_t lastSample[4]; int16_t lastSample[4];
}; };
CHECK_OFFSET(AXVoiceSrc, 0x0, ratio); WUT_CHECK_OFFSET(AXVoiceSrc, 0x0, ratio);
CHECK_OFFSET(AXVoiceSrc, 0x4, currentOffsetFrac); WUT_CHECK_OFFSET(AXVoiceSrc, 0x4, currentOffsetFrac);
CHECK_OFFSET(AXVoiceSrc, 0x6, lastSample); WUT_CHECK_OFFSET(AXVoiceSrc, 0x6, lastSample);
CHECK_SIZE(AXVoiceSrc, 0xe); WUT_CHECK_SIZE(AXVoiceSrc, 0xe);
#pragma pack(pop) #pragma pack(pop)

68
include/vpad/input.h
View File

@ -78,9 +78,9 @@ struct VPADVec2D
float x; float x;
float y; float y;
}; };
CHECK_OFFSET(VPADVec2D, 0x00, x); WUT_CHECK_OFFSET(VPADVec2D, 0x00, x);
CHECK_OFFSET(VPADVec2D, 0x04, y); WUT_CHECK_OFFSET(VPADVec2D, 0x04, y);
CHECK_SIZE(VPADVec2D, 0x08); WUT_CHECK_SIZE(VPADVec2D, 0x08);
struct VPADVec3D struct VPADVec3D
{ {
@ -88,10 +88,10 @@ struct VPADVec3D
float y; float y;
float z; float z;
}; };
CHECK_OFFSET(VPADVec3D, 0x00, x); WUT_CHECK_OFFSET(VPADVec3D, 0x00, x);
CHECK_OFFSET(VPADVec3D, 0x04, y); WUT_CHECK_OFFSET(VPADVec3D, 0x04, y);
CHECK_OFFSET(VPADVec3D, 0x08, z); WUT_CHECK_OFFSET(VPADVec3D, 0x08, z);
CHECK_SIZE(VPADVec3D, 0x0C); WUT_CHECK_SIZE(VPADVec3D, 0x0C);
struct VPADTouchData struct VPADTouchData
{ {
@ -104,11 +104,11 @@ struct VPADTouchData
//! Bitfield of VPADTouchPadValidity to indicate how touch sample accuracy //! Bitfield of VPADTouchPadValidity to indicate how touch sample accuracy
uint16_t validity; uint16_t validity;
}; };
CHECK_OFFSET(VPADTouchData, 0x00, x); WUT_CHECK_OFFSET(VPADTouchData, 0x00, x);
CHECK_OFFSET(VPADTouchData, 0x02, y); WUT_CHECK_OFFSET(VPADTouchData, 0x02, y);
CHECK_OFFSET(VPADTouchData, 0x04, touched); WUT_CHECK_OFFSET(VPADTouchData, 0x04, touched);
CHECK_OFFSET(VPADTouchData, 0x06, validity); WUT_CHECK_OFFSET(VPADTouchData, 0x06, validity);
CHECK_SIZE(VPADTouchData, 0x08); WUT_CHECK_SIZE(VPADTouchData, 0x08);
struct VPADAccStatus struct VPADAccStatus
{ {
@ -119,8 +119,8 @@ struct VPADAccStatus
float unk5; float unk5;
VPADVec2D vertical; VPADVec2D vertical;
}; };
CHECK_OFFSET(VPADAccStatus, 0x14, vertical); WUT_CHECK_OFFSET(VPADAccStatus, 0x14, vertical);
CHECK_SIZE(VPADAccStatus, 0x1c); WUT_CHECK_SIZE(VPADAccStatus, 0x1c);
struct VPADGyroStatus struct VPADGyroStatus
{ {
@ -131,7 +131,7 @@ struct VPADGyroStatus
float unk5; float unk5;
float unk6; float unk6;
}; };
CHECK_SIZE(VPADGyroStatus, 0x18); WUT_CHECK_SIZE(VPADGyroStatus, 0x18);
struct VPADStatus struct VPADStatus
{ {
@ -156,7 +156,7 @@ struct VPADStatus
//! Status of DRC gyro //! Status of DRC gyro
VPADGyroStatus gyro; VPADGyroStatus gyro;
UNKNOWN(2); WUT_UNKNOWN_BYTES(2);
//! Current touch position on DRC //! Current touch position on DRC
VPADTouchData tpNormal; VPADTouchData tpNormal;
@ -167,7 +167,7 @@ struct VPADStatus
//! Filtered touch position, second level of smoothing //! Filtered touch position, second level of smoothing
VPADTouchData tpFiltered2; VPADTouchData tpFiltered2;
UNKNOWN(0x28); WUT_UNKNOWN_BYTES(0x28);
//! Status of DRC magnetometer //! Status of DRC magnetometer
VPADVec3D mag; VPADVec3D mag;
@ -184,24 +184,24 @@ struct VPADStatus
//! Unknown volume related value //! Unknown volume related value
uint8_t slideVolumeEx; uint8_t slideVolumeEx;
UNKNOWN(0x7); WUT_UNKNOWN_BYTES(0x7);
}; };
CHECK_OFFSET(VPADStatus, 0x00, hold); WUT_CHECK_OFFSET(VPADStatus, 0x00, hold);
CHECK_OFFSET(VPADStatus, 0x04, trigger); WUT_CHECK_OFFSET(VPADStatus, 0x04, trigger);
CHECK_OFFSET(VPADStatus, 0x08, release); WUT_CHECK_OFFSET(VPADStatus, 0x08, release);
CHECK_OFFSET(VPADStatus, 0x0C, leftStick); WUT_CHECK_OFFSET(VPADStatus, 0x0C, leftStick);
CHECK_OFFSET(VPADStatus, 0x14, rightStick); WUT_CHECK_OFFSET(VPADStatus, 0x14, rightStick);
CHECK_OFFSET(VPADStatus, 0x1C, accelorometer); WUT_CHECK_OFFSET(VPADStatus, 0x1C, accelorometer);
CHECK_OFFSET(VPADStatus, 0x38, gyro); WUT_CHECK_OFFSET(VPADStatus, 0x38, gyro);
CHECK_OFFSET(VPADStatus, 0x52, tpNormal); WUT_CHECK_OFFSET(VPADStatus, 0x52, tpNormal);
CHECK_OFFSET(VPADStatus, 0x5A, tpFiltered1); WUT_CHECK_OFFSET(VPADStatus, 0x5A, tpFiltered1);
CHECK_OFFSET(VPADStatus, 0x62, tpFiltered2); WUT_CHECK_OFFSET(VPADStatus, 0x62, tpFiltered2);
CHECK_OFFSET(VPADStatus, 0x94, mag); WUT_CHECK_OFFSET(VPADStatus, 0x94, mag);
CHECK_OFFSET(VPADStatus, 0xA0, slideVolume); WUT_CHECK_OFFSET(VPADStatus, 0xA0, slideVolume);
CHECK_OFFSET(VPADStatus, 0xA1, battery); WUT_CHECK_OFFSET(VPADStatus, 0xA1, battery);
CHECK_OFFSET(VPADStatus, 0xA2, micStatus); WUT_CHECK_OFFSET(VPADStatus, 0xA2, micStatus);
CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx); WUT_CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx);
CHECK_SIZE(VPADStatus, 0xAC); WUT_CHECK_SIZE(VPADStatus, 0xAC);
//! Deprecated //! Deprecated
void void

24
include/wut_structsize.h
View File

@ -4,29 +4,27 @@
// Ensure structs are correct size & offsets // Ensure structs are correct size & offsets
#if defined(static_assert) #if defined(static_assert)
# define CHECK_SIZE(Type, Size) \ # define WUT_CHECK_SIZE(Type, Size) \
static_assert(sizeof(Type) == Size, \ static_assert(sizeof(Type) == Size, \
#Type " must be " #Size " bytes") #Type " must be " #Size " bytes")
# define CHECK_OFFSET(Type, Offset, Field) \ # define WUT_CHECK_OFFSET(Type, Offset, Field) \
static_assert(offsetof(Type, Field) == Offset, \ static_assert(offsetof(Type, Field) == Offset, \
#Type "::" #Field " must be at offset " #Offset) #Type "::" #Field " must be at offset " #Offset)
#else #else
# define CHECK_SIZE(Type, Size) # define WUT_CHECK_SIZE(Type, Size)
# define CHECK_OFFSET(Type, Offset, Field) # define WUT_CHECK_OFFSET(Type, Offset, Field)
#endif #endif
// Workaround weird macro concat ## behaviour // Workaround weird macro concat ## behaviour
#define PP_CAT(a, b) PP_CAT_I(a, b) #define WUT_PP_CAT(a, b) WUT_PP_CAT_I(a, b)
#define PP_CAT_I(a, b) PP_CAT_II(~, a ## b) #define WUT_PP_CAT_I(a, b) WUT_PP_CAT_II(~, a ## b)
#define PP_CAT_II(p, res) res #define WUT_PP_CAT_II(p, res) res
// Allow us to easily add UNKNOWN / PADDING bytes into our structs, // Allow us to easily add UNKNOWN / PADDING bytes into our structs,
// generates unique variable names using __COUNTER__ // generates unique variable names using __COUNTER__
#define UNKNOWN(Size) char PP_CAT(__unk, __COUNTER__) [Size] #define WUT_UNKNOWN_BYTES(Size) char WUT_PP_CAT(__unk, __COUNTER__) [Size]
#define PADDING(Size) UNKNOWN(Size) #define WUT_PADDING_BYTES(Size) WUT_UNKNOWN_BYTES(Size)
// Just some placeholder defines //! Unknown struct size
#define UNKNOWN_ARG uint32_t #define WUT_UNKNOWN_SIZE(x)
#define UNKNOWN_ARGS void
#define UNKNOWN_SIZE(x)

58
libraries/libgfd/include/gfd.h
View File

@ -52,15 +52,15 @@ struct GFDHeader
uint32_t unk1; uint32_t unk1;
uint32_t unk2; uint32_t unk2;
}; };
CHECK_OFFSET(GFDHeader, 0x00, magic); WUT_CHECK_OFFSET(GFDHeader, 0x00, magic);
CHECK_OFFSET(GFDHeader, 0x04, headerSize); WUT_CHECK_OFFSET(GFDHeader, 0x04, headerSize);
CHECK_OFFSET(GFDHeader, 0x08, majorVersion); WUT_CHECK_OFFSET(GFDHeader, 0x08, majorVersion);
CHECK_OFFSET(GFDHeader, 0x0C, minorVersion); WUT_CHECK_OFFSET(GFDHeader, 0x0C, minorVersion);
CHECK_OFFSET(GFDHeader, 0x10, gpuVersion); WUT_CHECK_OFFSET(GFDHeader, 0x10, gpuVersion);
CHECK_OFFSET(GFDHeader, 0x14, align); WUT_CHECK_OFFSET(GFDHeader, 0x14, align);
CHECK_OFFSET(GFDHeader, 0x18, unk1); WUT_CHECK_OFFSET(GFDHeader, 0x18, unk1);
CHECK_OFFSET(GFDHeader, 0x1C, unk2); WUT_CHECK_OFFSET(GFDHeader, 0x1C, unk2);
CHECK_SIZE(GFDHeader, 0x20); WUT_CHECK_SIZE(GFDHeader, 0x20);
struct GFDBlockHeader struct GFDBlockHeader
{ {
@ -73,15 +73,15 @@ struct GFDBlockHeader
uint32_t id; uint32_t id;
uint32_t index; uint32_t index;
}; };
CHECK_OFFSET(GFDBlockHeader, 0x00, magic); WUT_CHECK_OFFSET(GFDBlockHeader, 0x00, magic);
CHECK_OFFSET(GFDBlockHeader, 0x04, headerSize); WUT_CHECK_OFFSET(GFDBlockHeader, 0x04, headerSize);
CHECK_OFFSET(GFDBlockHeader, 0x08, majorVersion); WUT_CHECK_OFFSET(GFDBlockHeader, 0x08, majorVersion);
CHECK_OFFSET(GFDBlockHeader, 0x0C, minorVersion); WUT_CHECK_OFFSET(GFDBlockHeader, 0x0C, minorVersion);
CHECK_OFFSET(GFDBlockHeader, 0x10, type); WUT_CHECK_OFFSET(GFDBlockHeader, 0x10, type);
CHECK_OFFSET(GFDBlockHeader, 0x14, dataSize); WUT_CHECK_OFFSET(GFDBlockHeader, 0x14, dataSize);
CHECK_OFFSET(GFDBlockHeader, 0x18, id); WUT_CHECK_OFFSET(GFDBlockHeader, 0x18, id);
CHECK_OFFSET(GFDBlockHeader, 0x1C, index); WUT_CHECK_OFFSET(GFDBlockHeader, 0x1C, index);
CHECK_SIZE(GFDHeader, 0x20); WUT_CHECK_SIZE(GFDHeader, 0x20);
struct GFDRelocationHeader struct GFDRelocationHeader
{ {
@ -96,17 +96,17 @@ struct GFDRelocationHeader
uint32_t patchCount; uint32_t patchCount;
uint32_t patchOffset; uint32_t patchOffset;
}; };
CHECK_OFFSET(GFDRelocationHeader, 0x00, magic); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x00, magic);
CHECK_OFFSET(GFDRelocationHeader, 0x04, headerSize); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x04, headerSize);
CHECK_OFFSET(GFDRelocationHeader, 0x08, unk1); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x08, unk1);
CHECK_OFFSET(GFDRelocationHeader, 0x0C, dataSize); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x0C, dataSize);
CHECK_OFFSET(GFDRelocationHeader, 0x10, dataOffset); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x10, dataOffset);
CHECK_OFFSET(GFDRelocationHeader, 0x14, textSize); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x14, textSize);
CHECK_OFFSET(GFDRelocationHeader, 0x18, textOffset); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x18, textOffset);
CHECK_OFFSET(GFDRelocationHeader, 0x1C, patchBase); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x1C, patchBase);
CHECK_OFFSET(GFDRelocationHeader, 0x20, patchCount); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x20, patchCount);
CHECK_OFFSET(GFDRelocationHeader, 0x24, patchOffset); WUT_CHECK_OFFSET(GFDRelocationHeader, 0x24, patchOffset);
CHECK_SIZE(GFDRelocationHeader, 0x28); WUT_CHECK_SIZE(GFDRelocationHeader, 0x28);
char * char *
GFDGetLastErrorString(); GFDGetLastErrorString();

2
libraries/wutdevoptab_sd/devoptab_sd.h
View File

@ -34,7 +34,7 @@ typedef struct
typedef struct typedef struct
{ {
//! Should be set to FS_DIRITER_MAGIC //! Should be set to FS_DIRITER_MAGIC
u32 magic; uint32_t magic;
//! FS handle //! FS handle
FSDirectoryHandle fd; FSDirectoryHandle fd;