From 5f1b1902f6a1d219b062ec429868a266bb63708b Mon Sep 17 00:00:00 2001 From: James Benton Date: Wed, 20 Jun 2018 10:31:53 +0100 Subject: [PATCH] Prefix structsize macros with WUT_ --- docs/CMakeLists.txt | 10 +- include/coreinit/alarm.h | 52 ++--- include/coreinit/condition.h | 10 +- include/coreinit/context.h | 54 +++--- include/coreinit/coroutine.h | 20 +- include/coreinit/event.h | 14 +- include/coreinit/fastcondition.h | 10 +- include/coreinit/fastmutex.h | 20 +- include/coreinit/filesystem.h | 36 ++-- include/coreinit/ios.h | 8 +- include/coreinit/mcp.h | 26 +-- include/coreinit/memblockheap.h | 36 ++-- include/coreinit/memexpheap.h | 32 +-- include/coreinit/memfrmheap.h | 20 +- include/coreinit/memheap.h | 18 +- include/coreinit/memlist.h | 16 +- include/coreinit/memunitheap.h | 12 +- include/coreinit/messagequeue.h | 26 +-- include/coreinit/mutex.h | 22 +-- include/coreinit/rendezvous.h | 6 +- include/coreinit/semaphore.h | 12 +- include/coreinit/spinlock.h | 10 +- include/coreinit/systeminfo.h | 10 +- include/coreinit/taskqueue.h | 76 ++++---- include/coreinit/thread.h | 82 ++++---- include/coreinit/threadqueue.h | 22 +-- include/coreinit/time.h | 22 +-- include/gx2/context.h | 32 +-- include/gx2/event.h | 12 +- include/gx2/registers.h | 108 +++++------ include/gx2/sampler.h | 2 +- include/gx2/shaders.h | 258 ++++++++++++------------- include/gx2/surface.h | 70 +++---- include/gx2/texture.h | 16 +- include/gx2r/buffer.h | 10 +- include/nn/swkbd/swkbd_cpp.h | 90 ++++----- include/nsyshid/hid.h | 28 +-- include/padscore/kpad.h | 66 +++---- include/padscore/wpad.h | 26 +-- include/sndcore2/core.h | 8 +- include/sndcore2/voice.h | 94 ++++----- include/vpad/input.h | 68 +++---- include/wut_structsize.h | 24 ++- libraries/libgfd/include/gfd.h | 58 +++--- libraries/wutdevoptab_sd/devoptab_sd.h | 2 +- 45 files changed, 826 insertions(+), 828 deletions(-) diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt index 67273c2..2e767fc 100644 --- a/docs/CMakeLists.txt +++ b/docs/CMakeLists.txt @@ -23,11 +23,11 @@ if(DOXYGEN_FOUND) set(DOXYGEN_EXCLUDE_PATTERNS "wut_structsize.h") set(DOXYGEN_EXCLUDE_SYMBOLS - "UNKNOWN" - "CHECK_OFFSET" - "CHECK_SIZE" - "UNKNOWN_SIZE" - "PADDING") + "WUT_CHECK_OFFSET" + "WUT_CHECK_SIZE" + "WUT_PADDING_BYTES" + "WUT_UNKNOWN_BYTES" + "WUT_UNKNOWN_SIZE") set(DOXYGEN_SOURCE_BROWSER YES) set(DOXYGEN_ENUM_VALUES_PER_LINE 1) set(DOXYGEN_CLASS_DIAGRAMS NO) diff --git a/include/coreinit/alarm.h b/include/coreinit/alarm.h index 12426aa..a623c1b 100644 --- a/include/coreinit/alarm.h +++ b/include/coreinit/alarm.h @@ -36,27 +36,27 @@ struct OSAlarmQueue //! Name set by OSInitAlarmQueueEx const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); OSThreadQueue threadQueue; OSAlarm *head; OSAlarm *tail; }; -CHECK_OFFSET(OSAlarmQueue, 0x00, tag); -CHECK_OFFSET(OSAlarmQueue, 0x04, name); -CHECK_OFFSET(OSAlarmQueue, 0x0c, threadQueue); -CHECK_OFFSET(OSAlarmQueue, 0x1c, head); -CHECK_OFFSET(OSAlarmQueue, 0x20, tail); -CHECK_SIZE(OSAlarmQueue, 0x24); +WUT_CHECK_OFFSET(OSAlarmQueue, 0x00, tag); +WUT_CHECK_OFFSET(OSAlarmQueue, 0x04, name); +WUT_CHECK_OFFSET(OSAlarmQueue, 0x0c, threadQueue); +WUT_CHECK_OFFSET(OSAlarmQueue, 0x1c, head); +WUT_CHECK_OFFSET(OSAlarmQueue, 0x20, tail); +WUT_CHECK_SIZE(OSAlarmQueue, 0x24); struct OSAlarmLink { OSAlarm *prev; OSAlarm *next; }; -CHECK_OFFSET(OSAlarmLink, 0x00, prev); -CHECK_OFFSET(OSAlarmLink, 0x04, next); -CHECK_SIZE(OSAlarmLink, 0x08); +WUT_CHECK_OFFSET(OSAlarmLink, 0x00, prev); +WUT_CHECK_OFFSET(OSAlarmLink, 0x04, next); +WUT_CHECK_SIZE(OSAlarmLink, 0x08); #define OS_ALARM_TAG 0x614C724Du struct OSAlarm @@ -67,7 +67,7 @@ struct OSAlarm //! Name set from OSCreateAlarmEx. const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); //! The callback to execute once the alarm is triggered. OSAlarmCallback callback; @@ -75,7 +75,7 @@ struct OSAlarm //! Used with OSCancelAlarms for bulk cancellation of alarms. uint32_t group; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); //! The time when the alarm will next be triggered. OSTime nextFire; @@ -104,20 +104,20 @@ struct OSAlarm //! The context the alarm was triggered on. OSContext *context; }; -CHECK_OFFSET(OSAlarm, 0x00, tag); -CHECK_OFFSET(OSAlarm, 0x04, name); -CHECK_OFFSET(OSAlarm, 0x0c, callback); -CHECK_OFFSET(OSAlarm, 0x10, group); -CHECK_OFFSET(OSAlarm, 0x18, nextFire); -CHECK_OFFSET(OSAlarm, 0x20, link); -CHECK_OFFSET(OSAlarm, 0x28, period); -CHECK_OFFSET(OSAlarm, 0x30, start); -CHECK_OFFSET(OSAlarm, 0x38, userData); -CHECK_OFFSET(OSAlarm, 0x3c, state); -CHECK_OFFSET(OSAlarm, 0x40, threadQueue); -CHECK_OFFSET(OSAlarm, 0x50, alarmQueue); -CHECK_OFFSET(OSAlarm, 0x54, context); -CHECK_SIZE(OSAlarm, 0x58); +WUT_CHECK_OFFSET(OSAlarm, 0x00, tag); +WUT_CHECK_OFFSET(OSAlarm, 0x04, name); +WUT_CHECK_OFFSET(OSAlarm, 0x0c, callback); +WUT_CHECK_OFFSET(OSAlarm, 0x10, group); +WUT_CHECK_OFFSET(OSAlarm, 0x18, nextFire); +WUT_CHECK_OFFSET(OSAlarm, 0x20, link); +WUT_CHECK_OFFSET(OSAlarm, 0x28, period); +WUT_CHECK_OFFSET(OSAlarm, 0x30, start); +WUT_CHECK_OFFSET(OSAlarm, 0x38, userData); +WUT_CHECK_OFFSET(OSAlarm, 0x3c, state); +WUT_CHECK_OFFSET(OSAlarm, 0x40, threadQueue); +WUT_CHECK_OFFSET(OSAlarm, 0x50, alarmQueue); +WUT_CHECK_OFFSET(OSAlarm, 0x54, context); +WUT_CHECK_SIZE(OSAlarm, 0x58); /** diff --git a/include/coreinit/condition.h b/include/coreinit/condition.h index de2b18c..841db2e 100644 --- a/include/coreinit/condition.h +++ b/include/coreinit/condition.h @@ -29,15 +29,15 @@ struct OSCondition //! Name set by OSInitCondEx. const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); //! Queue of threads currently waiting on condition with OSWaitCond. OSThreadQueue queue; }; -CHECK_OFFSET(OSCondition, 0x00, tag); -CHECK_OFFSET(OSCondition, 0x04, name); -CHECK_OFFSET(OSCondition, 0x0c, queue); -CHECK_SIZE(OSCondition, 0x1c); +WUT_CHECK_OFFSET(OSCondition, 0x00, tag); +WUT_CHECK_OFFSET(OSCondition, 0x04, name); +WUT_CHECK_OFFSET(OSCondition, 0x0c, queue); +WUT_CHECK_SIZE(OSCondition, 0x1c); /** diff --git a/include/coreinit/context.h b/include/coreinit/context.h index 9548ada..e718263 100644 --- a/include/coreinit/context.h +++ b/include/coreinit/context.h @@ -21,18 +21,18 @@ struct OSContext uint32_t xer; uint32_t srr0; uint32_t srr1; - UNKNOWN(0x14); + WUT_UNKNOWN_BYTES(0x14); uint32_t fpscr; double fpr[32]; uint16_t spinLockCount; uint16_t state; uint32_t gqr[8]; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); double psf[32]; uint64_t coretime[3]; uint64_t starttime; uint32_t error; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); uint32_t pmc1; uint32_t pmc2; uint32_t pmc3; @@ -40,30 +40,30 @@ struct OSContext uint32_t mmcr0; uint32_t mmcr1; }; -CHECK_OFFSET(OSContext, 0x00, tag); -CHECK_OFFSET(OSContext, 0x08, gpr); -CHECK_OFFSET(OSContext, 0x88, cr); -CHECK_OFFSET(OSContext, 0x8c, lr); -CHECK_OFFSET(OSContext, 0x90, ctr); -CHECK_OFFSET(OSContext, 0x94, xer); -CHECK_OFFSET(OSContext, 0x98, srr0); -CHECK_OFFSET(OSContext, 0x9c, srr1); -CHECK_OFFSET(OSContext, 0xb4, fpscr); -CHECK_OFFSET(OSContext, 0xb8, fpr); -CHECK_OFFSET(OSContext, 0x1b8, spinLockCount); -CHECK_OFFSET(OSContext, 0x1ba, state); -CHECK_OFFSET(OSContext, 0x1bc, gqr); -CHECK_OFFSET(OSContext, 0x1e0, psf); -CHECK_OFFSET(OSContext, 0x2e0, coretime); -CHECK_OFFSET(OSContext, 0x2f8, starttime); -CHECK_OFFSET(OSContext, 0x300, error); -CHECK_OFFSET(OSContext, 0x308, pmc1); -CHECK_OFFSET(OSContext, 0x30c, pmc2); -CHECK_OFFSET(OSContext, 0x310, pmc3); -CHECK_OFFSET(OSContext, 0x314, pmc4); -CHECK_OFFSET(OSContext, 0x318, mmcr0); -CHECK_OFFSET(OSContext, 0x31c, mmcr1); -CHECK_SIZE(OSContext, 0x320); +WUT_CHECK_OFFSET(OSContext, 0x00, tag); +WUT_CHECK_OFFSET(OSContext, 0x08, gpr); +WUT_CHECK_OFFSET(OSContext, 0x88, cr); +WUT_CHECK_OFFSET(OSContext, 0x8c, lr); +WUT_CHECK_OFFSET(OSContext, 0x90, ctr); +WUT_CHECK_OFFSET(OSContext, 0x94, xer); +WUT_CHECK_OFFSET(OSContext, 0x98, srr0); +WUT_CHECK_OFFSET(OSContext, 0x9c, srr1); +WUT_CHECK_OFFSET(OSContext, 0xb4, fpscr); +WUT_CHECK_OFFSET(OSContext, 0xb8, fpr); +WUT_CHECK_OFFSET(OSContext, 0x1b8, spinLockCount); +WUT_CHECK_OFFSET(OSContext, 0x1ba, state); +WUT_CHECK_OFFSET(OSContext, 0x1bc, gqr); +WUT_CHECK_OFFSET(OSContext, 0x1e0, psf); +WUT_CHECK_OFFSET(OSContext, 0x2e0, coretime); +WUT_CHECK_OFFSET(OSContext, 0x2f8, starttime); +WUT_CHECK_OFFSET(OSContext, 0x300, error); +WUT_CHECK_OFFSET(OSContext, 0x308, pmc1); +WUT_CHECK_OFFSET(OSContext, 0x30c, pmc2); +WUT_CHECK_OFFSET(OSContext, 0x310, pmc3); +WUT_CHECK_OFFSET(OSContext, 0x314, pmc4); +WUT_CHECK_OFFSET(OSContext, 0x318, mmcr0); +WUT_CHECK_OFFSET(OSContext, 0x31c, mmcr1); +WUT_CHECK_SIZE(OSContext, 0x320); #ifdef __cplusplus } diff --git a/include/coreinit/coroutine.h b/include/coreinit/coroutine.h index aa4b351..4bd063a 100644 --- a/include/coreinit/coroutine.h +++ b/include/coreinit/coroutine.h @@ -25,16 +25,16 @@ struct OSCoroutine double fpr[18]; double psr[18]; }; -CHECK_OFFSET(OSCoroutine, 0x00, nia); -CHECK_OFFSET(OSCoroutine, 0x04, cr); -CHECK_OFFSET(OSCoroutine, 0x08, ugqr1); -CHECK_OFFSET(OSCoroutine, 0x0C, stack); -CHECK_OFFSET(OSCoroutine, 0x10, sda2Base); -CHECK_OFFSET(OSCoroutine, 0x14, sdaBase); -CHECK_OFFSET(OSCoroutine, 0x18, gpr); -CHECK_OFFSET(OSCoroutine, 0x60, fpr); -CHECK_OFFSET(OSCoroutine, 0xF0, psr); -CHECK_SIZE(OSCoroutine, 0x180); +WUT_CHECK_OFFSET(OSCoroutine, 0x00, nia); +WUT_CHECK_OFFSET(OSCoroutine, 0x04, cr); +WUT_CHECK_OFFSET(OSCoroutine, 0x08, ugqr1); +WUT_CHECK_OFFSET(OSCoroutine, 0x0C, stack); +WUT_CHECK_OFFSET(OSCoroutine, 0x10, sda2Base); +WUT_CHECK_OFFSET(OSCoroutine, 0x14, sdaBase); +WUT_CHECK_OFFSET(OSCoroutine, 0x18, gpr); +WUT_CHECK_OFFSET(OSCoroutine, 0x60, fpr); +WUT_CHECK_OFFSET(OSCoroutine, 0xF0, psr); +WUT_CHECK_SIZE(OSCoroutine, 0x180); void OSInitCoroutine(OSCoroutine *coroutine, diff --git a/include/coreinit/event.h b/include/coreinit/event.h index 91362af..7d94397 100644 --- a/include/coreinit/event.h +++ b/include/coreinit/event.h @@ -38,7 +38,7 @@ struct OSEvent //! Name set by OSInitEventEx. const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); //! The current value of the event object. BOOL value; @@ -49,12 +49,12 @@ struct OSEvent //! The mode of the event object, set by OSInitEvent. OSEventMode mode; }; -CHECK_OFFSET(OSEvent, 0x0, tag); -CHECK_OFFSET(OSEvent, 0x4, name); -CHECK_OFFSET(OSEvent, 0xc, value); -CHECK_OFFSET(OSEvent, 0x10, queue); -CHECK_OFFSET(OSEvent, 0x20, mode); -CHECK_SIZE(OSEvent, 0x24); +WUT_CHECK_OFFSET(OSEvent, 0x0, tag); +WUT_CHECK_OFFSET(OSEvent, 0x4, name); +WUT_CHECK_OFFSET(OSEvent, 0xc, value); +WUT_CHECK_OFFSET(OSEvent, 0x10, queue); +WUT_CHECK_OFFSET(OSEvent, 0x20, mode); +WUT_CHECK_SIZE(OSEvent, 0x24); /** diff --git a/include/coreinit/fastcondition.h b/include/coreinit/fastcondition.h index bc2b836..8757ab7 100644 --- a/include/coreinit/fastcondition.h +++ b/include/coreinit/fastcondition.h @@ -24,13 +24,13 @@ struct OSFastCondition { uint32_t tag; const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); OSThreadQueue queue; }; -CHECK_OFFSET(OSFastCondition, 0x00, tag); -CHECK_OFFSET(OSFastCondition, 0x04, name); -CHECK_OFFSET(OSFastCondition, 0x0c, queue); -CHECK_SIZE(OSFastCondition, 0x1c); +WUT_CHECK_OFFSET(OSFastCondition, 0x00, tag); +WUT_CHECK_OFFSET(OSFastCondition, 0x04, name); +WUT_CHECK_OFFSET(OSFastCondition, 0x0c, queue); +WUT_CHECK_SIZE(OSFastCondition, 0x1c); void OSFastCond_Init(OSFastCondition *condition, diff --git a/include/coreinit/fastmutex.h b/include/coreinit/fastmutex.h index 98dd477..d2d8096 100644 --- a/include/coreinit/fastmutex.h +++ b/include/coreinit/fastmutex.h @@ -24,9 +24,9 @@ struct OSFastMutexLink OSFastMutex *next; OSFastMutex *prev; }; -CHECK_OFFSET(OSFastMutexLink, 0x00, next); -CHECK_OFFSET(OSFastMutexLink, 0x04, prev); -CHECK_SIZE(OSFastMutexLink, 0x08); +WUT_CHECK_OFFSET(OSFastMutexLink, 0x00, next); +WUT_CHECK_OFFSET(OSFastMutexLink, 0x04, prev); +WUT_CHECK_SIZE(OSFastMutexLink, 0x08); #define OS_FAST_MUTEX_TAG 0x664D7458u @@ -34,16 +34,16 @@ struct OSFastMutex { uint32_t tag; const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); OSThreadSimpleQueue queue; OSFastMutexLink link; - UNKNOWN(16); + WUT_UNKNOWN_BYTES(16); }; -CHECK_OFFSET(OSFastMutex, 0x00, tag); -CHECK_OFFSET(OSFastMutex, 0x04, name); -CHECK_OFFSET(OSFastMutex, 0x0c, queue); -CHECK_OFFSET(OSFastMutex, 0x14, link); -CHECK_SIZE(OSFastMutex, 0x2c); +WUT_CHECK_OFFSET(OSFastMutex, 0x00, tag); +WUT_CHECK_OFFSET(OSFastMutex, 0x04, name); +WUT_CHECK_OFFSET(OSFastMutex, 0x0c, queue); +WUT_CHECK_OFFSET(OSFastMutex, 0x14, link); +WUT_CHECK_SIZE(OSFastMutex, 0x2c); void OSFastMutex_Init(OSFastMutex *mutex, diff --git a/include/coreinit/filesystem.h b/include/coreinit/filesystem.h index 37652b6..e4a0c32 100644 --- a/include/coreinit/filesystem.h +++ b/include/coreinit/filesystem.h @@ -140,15 +140,15 @@ typedef void(*FSAsyncCallback)(FSClient *, FSCmdBlock *, FSStatus, uint32_t); struct FSClient { - UNKNOWN(0x1700); + WUT_UNKNOWN_BYTES(0x1700); }; -CHECK_SIZE(FSClient, 0x1700); +WUT_CHECK_SIZE(FSClient, 0x1700); struct FSCmdBlock { - UNKNOWN(0xA80); + WUT_UNKNOWN_BYTES(0xA80); }; -CHECK_SIZE(FSCmdBlock, 0xA80); +WUT_CHECK_SIZE(FSCmdBlock, 0xA80); struct FSStat { @@ -157,41 +157,41 @@ struct FSStat uint32_t owner; uint32_t group; uint32_t size; - UNKNOWN(0x50); + WUT_UNKNOWN_BYTES(0x50); }; -CHECK_OFFSET(FSStat, 0x00, flags); -CHECK_OFFSET(FSStat, 0x10, size); -CHECK_SIZE(FSStat, 0x64); +WUT_CHECK_OFFSET(FSStat, 0x00, flags); +WUT_CHECK_OFFSET(FSStat, 0x10, size); +WUT_CHECK_SIZE(FSStat, 0x64); struct FSStateChangeInfo { - UNKNOWN(0xC); + WUT_UNKNOWN_BYTES(0xC); }; -CHECK_SIZE(FSStateChangeInfo, 0xC); +WUT_CHECK_SIZE(FSStateChangeInfo, 0xC); struct FSAsyncData { uint32_t callback; uint32_t param; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); }; -CHECK_OFFSET(FSAsyncData, 0x0, callback); -CHECK_OFFSET(FSAsyncData, 0x4, param); -CHECK_SIZE(FSAsyncData, 0xC); +WUT_CHECK_OFFSET(FSAsyncData, 0x0, callback); +WUT_CHECK_OFFSET(FSAsyncData, 0x4, param); +WUT_CHECK_SIZE(FSAsyncData, 0xC); struct FSDirectoryEntry { FSStat info; char name[256]; }; -CHECK_OFFSET(FSDirectoryEntry, 0x64, name); -CHECK_SIZE(FSDirectoryEntry, 0x164); +WUT_CHECK_OFFSET(FSDirectoryEntry, 0x64, name); +WUT_CHECK_SIZE(FSDirectoryEntry, 0x164); struct FSMountSource { - UNKNOWN(0x300); + WUT_UNKNOWN_BYTES(0x300); }; -CHECK_SIZE(FSMountSource, 0x300); +WUT_CHECK_SIZE(FSMountSource, 0x300); void FSInit(); diff --git a/include/coreinit/ios.h b/include/coreinit/ios.h index c88ca06..3b62ffc 100644 --- a/include/coreinit/ios.h +++ b/include/coreinit/ios.h @@ -79,10 +79,10 @@ struct IOSVec //! Virtual address of buffer. void *vaddr; }; -CHECK_OFFSET(IOSVec, 0x00, paddr); -CHECK_OFFSET(IOSVec, 0x04, len); -CHECK_OFFSET(IOSVec, 0x08, vaddr); -CHECK_SIZE(IOSVec, 0x0C); +WUT_CHECK_OFFSET(IOSVec, 0x00, paddr); +WUT_CHECK_OFFSET(IOSVec, 0x04, len); +WUT_CHECK_OFFSET(IOSVec, 0x08, vaddr); +WUT_CHECK_SIZE(IOSVec, 0x0C); typedef void (*IOSAsyncCallbackFn)(IOSError, void *); diff --git a/include/coreinit/mcp.h b/include/coreinit/mcp.h index f54d485..d027a20 100644 --- a/include/coreinit/mcp.h +++ b/include/coreinit/mcp.h @@ -32,37 +32,37 @@ struct __attribute__((__packed__)) MCPInstallProgress uint32_t contentsTotal; uint32_t contentsProgress; }; -CHECK_OFFSET(MCPInstallProgress, 0x00, inProgress); -CHECK_OFFSET(MCPInstallProgress, 0x04, tid); -CHECK_OFFSET(MCPInstallProgress, 0x0C, sizeTotal); -CHECK_OFFSET(MCPInstallProgress, 0x14, sizeProgress); -CHECK_OFFSET(MCPInstallProgress, 0x1C, contentsTotal); -CHECK_OFFSET(MCPInstallProgress, 0x20, contentsProgress); -CHECK_SIZE(MCPInstallProgress, 0x24); +WUT_CHECK_OFFSET(MCPInstallProgress, 0x00, inProgress); +WUT_CHECK_OFFSET(MCPInstallProgress, 0x04, tid); +WUT_CHECK_OFFSET(MCPInstallProgress, 0x0C, sizeTotal); +WUT_CHECK_OFFSET(MCPInstallProgress, 0x14, sizeProgress); +WUT_CHECK_OFFSET(MCPInstallProgress, 0x1C, contentsTotal); +WUT_CHECK_OFFSET(MCPInstallProgress, 0x20, contentsProgress); +WUT_CHECK_SIZE(MCPInstallProgress, 0x24); struct MCPInstallInfo { - UNKNOWN(0x27F); + WUT_UNKNOWN_BYTES(0x27F); }; -CHECK_SIZE(MCPInstallInfo, 0x27F); +WUT_CHECK_SIZE(MCPInstallInfo, 0x27F); struct MCPInstallTitleInfo { - UNKNOWN(0x27F); + WUT_UNKNOWN_BYTES(0x27F); }; -CHECK_SIZE(MCPInstallTitleInfo, 0x27F); +WUT_CHECK_SIZE(MCPInstallTitleInfo, 0x27F); struct MCPDevice { char name[0x31B]; }; -CHECK_SIZE(MCPDevice, 0x31B); +WUT_CHECK_SIZE(MCPDevice, 0x31B); struct MCPDeviceList { MCPDevice devices[32]; }; -CHECK_SIZE(MCPDeviceList, 0x31B*32); +WUT_CHECK_SIZE(MCPDeviceList, 0x31B*32); int MCP_Open(); diff --git a/include/coreinit/memblockheap.h b/include/coreinit/memblockheap.h index 6136c0e..6325b40 100644 --- a/include/coreinit/memblockheap.h +++ b/include/coreinit/memblockheap.h @@ -18,7 +18,7 @@ typedef struct MEMBlockHeap MEMBlockHeap; struct MEMBlockHeapTracking { - UNKNOWN(0x8); + WUT_UNKNOWN_BYTES(0x8); //! Pointer to first memory block MEMBlockHeapBlock *blocks; @@ -26,9 +26,9 @@ struct MEMBlockHeapTracking //! Number of blocks in this tracking heap uint32_t blockCount; }; -CHECK_OFFSET(MEMBlockHeapTracking, 0x08, blocks); -CHECK_OFFSET(MEMBlockHeapTracking, 0x0C, blockCount); -CHECK_SIZE(MEMBlockHeapTracking, 0x10); +WUT_CHECK_OFFSET(MEMBlockHeapTracking, 0x08, blocks); +WUT_CHECK_OFFSET(MEMBlockHeapTracking, 0x0C, blockCount); +WUT_CHECK_SIZE(MEMBlockHeapTracking, 0x10); struct MEMBlockHeapBlock { @@ -47,12 +47,12 @@ struct MEMBlockHeapBlock //! Link to next block, always set MEMBlockHeapBlock *next; }; -CHECK_OFFSET(MEMBlockHeapBlock, 0x00, start); -CHECK_OFFSET(MEMBlockHeapBlock, 0x04, end); -CHECK_OFFSET(MEMBlockHeapBlock, 0x08, isFree); -CHECK_OFFSET(MEMBlockHeapBlock, 0x0c, prev); -CHECK_OFFSET(MEMBlockHeapBlock, 0x10, next); -CHECK_SIZE(MEMBlockHeapBlock, 0x14); +WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x00, start); +WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x04, end); +WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x08, isFree); +WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x0c, prev); +WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x10, next); +WUT_CHECK_SIZE(MEMBlockHeapBlock, 0x14); struct MEMBlockHeap { @@ -76,14 +76,14 @@ struct MEMBlockHeap //! Free block count uint32_t numFreeBlocks; }; -CHECK_OFFSET(MEMBlockHeap, 0x00, header); -CHECK_OFFSET(MEMBlockHeap, 0x40, defaultTrack); -CHECK_OFFSET(MEMBlockHeap, 0x50, defaultBlock); -CHECK_OFFSET(MEMBlockHeap, 0x64, firstBlock); -CHECK_OFFSET(MEMBlockHeap, 0x68, lastBlock); -CHECK_OFFSET(MEMBlockHeap, 0x6C, firstFreeBlock); -CHECK_OFFSET(MEMBlockHeap, 0x70, numFreeBlocks); -CHECK_SIZE(MEMBlockHeap, 0x74); +WUT_CHECK_OFFSET(MEMBlockHeap, 0x00, header); +WUT_CHECK_OFFSET(MEMBlockHeap, 0x40, defaultTrack); +WUT_CHECK_OFFSET(MEMBlockHeap, 0x50, defaultBlock); +WUT_CHECK_OFFSET(MEMBlockHeap, 0x64, firstBlock); +WUT_CHECK_OFFSET(MEMBlockHeap, 0x68, lastBlock); +WUT_CHECK_OFFSET(MEMBlockHeap, 0x6C, firstFreeBlock); +WUT_CHECK_OFFSET(MEMBlockHeap, 0x70, numFreeBlocks); +WUT_CHECK_SIZE(MEMBlockHeap, 0x74); MEMHeapHandle MEMInitBlockHeap(MEMBlockHeap *heap, diff --git a/include/coreinit/memexpheap.h b/include/coreinit/memexpheap.h index 5323f6e..8bbacc9 100644 --- a/include/coreinit/memexpheap.h +++ b/include/coreinit/memexpheap.h @@ -38,23 +38,23 @@ struct MEMExpHeapBlock MEMExpHeapBlock *prev; MEMExpHeapBlock *next; uint16_t tag; - UNKNOWN(0x02); + WUT_UNKNOWN_BYTES(0x02); }; -CHECK_OFFSET(MEMExpHeapBlock, 0x00, attribs); -CHECK_OFFSET(MEMExpHeapBlock, 0x04, blockSize); -CHECK_OFFSET(MEMExpHeapBlock, 0x08, prev); -CHECK_OFFSET(MEMExpHeapBlock, 0x0c, next); -CHECK_OFFSET(MEMExpHeapBlock, 0x10, tag); -CHECK_SIZE(MEMExpHeapBlock, 0x14); +WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x00, attribs); +WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x04, blockSize); +WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x08, prev); +WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x0c, next); +WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x10, tag); +WUT_CHECK_SIZE(MEMExpHeapBlock, 0x14); struct MEMExpHeapBlockList { MEMExpHeapBlock *head; MEMExpHeapBlock *tail; }; -CHECK_OFFSET(MEMExpHeapBlockList, 0x00, head); -CHECK_OFFSET(MEMExpHeapBlockList, 0x04, tail); -CHECK_SIZE(MEMExpHeapBlockList, 0x08); +WUT_CHECK_OFFSET(MEMExpHeapBlockList, 0x00, head); +WUT_CHECK_OFFSET(MEMExpHeapBlockList, 0x04, tail); +WUT_CHECK_SIZE(MEMExpHeapBlockList, 0x08); struct MEMExpHeap { @@ -64,12 +64,12 @@ struct MEMExpHeap uint16_t groupId; uint16_t attribs; }; -CHECK_OFFSET(MEMExpHeap, 0x00, header); -CHECK_OFFSET(MEMExpHeap, 0x40, freeList); -CHECK_OFFSET(MEMExpHeap, 0x48, usedList); -CHECK_OFFSET(MEMExpHeap, 0x50, groupId); -CHECK_OFFSET(MEMExpHeap, 0x52, attribs); -CHECK_SIZE(MEMExpHeap, 0x54); +WUT_CHECK_OFFSET(MEMExpHeap, 0x00, header); +WUT_CHECK_OFFSET(MEMExpHeap, 0x40, freeList); +WUT_CHECK_OFFSET(MEMExpHeap, 0x48, usedList); +WUT_CHECK_OFFSET(MEMExpHeap, 0x50, groupId); +WUT_CHECK_OFFSET(MEMExpHeap, 0x52, attribs); +WUT_CHECK_SIZE(MEMExpHeap, 0x54); MEMHeapHandle MEMCreateExpHeapEx(void *heap, diff --git a/include/coreinit/memfrmheap.h b/include/coreinit/memfrmheap.h index cd5f514..e963890 100644 --- a/include/coreinit/memfrmheap.h +++ b/include/coreinit/memfrmheap.h @@ -29,11 +29,11 @@ struct MEMFrmHeapState void *tail; MEMFrmHeapState *previous; }; -CHECK_OFFSET(MEMFrmHeapState, 0x00, tag); -CHECK_OFFSET(MEMFrmHeapState, 0x04, head); -CHECK_OFFSET(MEMFrmHeapState, 0x08, tail); -CHECK_OFFSET(MEMFrmHeapState, 0x0C, previous); -CHECK_SIZE(MEMFrmHeapState, 0x10); +WUT_CHECK_OFFSET(MEMFrmHeapState, 0x00, tag); +WUT_CHECK_OFFSET(MEMFrmHeapState, 0x04, head); +WUT_CHECK_OFFSET(MEMFrmHeapState, 0x08, tail); +WUT_CHECK_OFFSET(MEMFrmHeapState, 0x0C, previous); +WUT_CHECK_SIZE(MEMFrmHeapState, 0x10); struct MEMFrmHeap { @@ -42,11 +42,11 @@ struct MEMFrmHeap void *tail; MEMFrmHeapState *previousState; }; -CHECK_OFFSET(MEMFrmHeap, 0x00, header); -CHECK_OFFSET(MEMFrmHeap, 0x40, head); -CHECK_OFFSET(MEMFrmHeap, 0x44, tail); -CHECK_OFFSET(MEMFrmHeap, 0x48, previousState); -CHECK_SIZE(MEMFrmHeap, 0x4C); +WUT_CHECK_OFFSET(MEMFrmHeap, 0x00, header); +WUT_CHECK_OFFSET(MEMFrmHeap, 0x40, head); +WUT_CHECK_OFFSET(MEMFrmHeap, 0x44, tail); +WUT_CHECK_OFFSET(MEMFrmHeap, 0x48, previousState); +WUT_CHECK_SIZE(MEMFrmHeap, 0x4C); MEMHeapHandle MEMCreateFrmHeapEx(void *heap, diff --git a/include/coreinit/memheap.h b/include/coreinit/memheap.h index fccf82b..37f8d14 100644 --- a/include/coreinit/memheap.h +++ b/include/coreinit/memheap.h @@ -71,16 +71,16 @@ struct MEMHeapHeader //! Flags set during heap creation. uint32_t flags; - UNKNOWN(0x0C); + WUT_UNKNOWN_BYTES(0x0C); }; -CHECK_OFFSET(MEMHeapHeader, 0x00, tag); -CHECK_OFFSET(MEMHeapHeader, 0x04, link); -CHECK_OFFSET(MEMHeapHeader, 0x0C, list); -CHECK_OFFSET(MEMHeapHeader, 0x18, dataStart); -CHECK_OFFSET(MEMHeapHeader, 0x1C, dataEnd); -CHECK_OFFSET(MEMHeapHeader, 0x20, lock); -CHECK_OFFSET(MEMHeapHeader, 0x30, flags); -CHECK_SIZE(MEMHeapHeader, 0x40); +WUT_CHECK_OFFSET(MEMHeapHeader, 0x00, tag); +WUT_CHECK_OFFSET(MEMHeapHeader, 0x04, link); +WUT_CHECK_OFFSET(MEMHeapHeader, 0x0C, list); +WUT_CHECK_OFFSET(MEMHeapHeader, 0x18, dataStart); +WUT_CHECK_OFFSET(MEMHeapHeader, 0x1C, dataEnd); +WUT_CHECK_OFFSET(MEMHeapHeader, 0x20, lock); +WUT_CHECK_OFFSET(MEMHeapHeader, 0x30, flags); +WUT_CHECK_SIZE(MEMHeapHeader, 0x40); /** diff --git a/include/coreinit/memlist.h b/include/coreinit/memlist.h index 4841e0c..b98d024 100644 --- a/include/coreinit/memlist.h +++ b/include/coreinit/memlist.h @@ -19,9 +19,9 @@ struct MEMMemoryLink void *prev; void *next; }; -CHECK_OFFSET(MEMMemoryLink, 0x0, prev); -CHECK_OFFSET(MEMMemoryLink, 0x4, next); -CHECK_SIZE(MEMMemoryLink, 0x8); +WUT_CHECK_OFFSET(MEMMemoryLink, 0x0, prev); +WUT_CHECK_OFFSET(MEMMemoryLink, 0x4, next); +WUT_CHECK_SIZE(MEMMemoryLink, 0x8); struct MEMMemoryList { @@ -30,11 +30,11 @@ struct MEMMemoryList uint16_t count; uint16_t offsetToMemoryLink; }; -CHECK_OFFSET(MEMMemoryList, 0x0, head); -CHECK_OFFSET(MEMMemoryList, 0x4, tail); -CHECK_OFFSET(MEMMemoryList, 0x8, count); -CHECK_OFFSET(MEMMemoryList, 0xa, offsetToMemoryLink); -CHECK_SIZE(MEMMemoryList, 0xc); +WUT_CHECK_OFFSET(MEMMemoryList, 0x0, head); +WUT_CHECK_OFFSET(MEMMemoryList, 0x4, tail); +WUT_CHECK_OFFSET(MEMMemoryList, 0x8, count); +WUT_CHECK_OFFSET(MEMMemoryList, 0xa, offsetToMemoryLink); +WUT_CHECK_SIZE(MEMMemoryList, 0xc); void MEMInitList(MEMMemoryList *list, diff --git a/include/coreinit/memunitheap.h b/include/coreinit/memunitheap.h index 9b2f8b2..1623bed 100644 --- a/include/coreinit/memunitheap.h +++ b/include/coreinit/memunitheap.h @@ -19,8 +19,8 @@ struct MEMUnitHeapFreeBlock { MEMUnitHeapFreeBlock *next; }; -CHECK_OFFSET(MEMUnitHeapFreeBlock, 0x00, next); -CHECK_SIZE(MEMUnitHeapFreeBlock, 0x04); +WUT_CHECK_OFFSET(MEMUnitHeapFreeBlock, 0x00, next); +WUT_CHECK_SIZE(MEMUnitHeapFreeBlock, 0x04); struct MEMUnitHeap { @@ -28,10 +28,10 @@ struct MEMUnitHeap MEMUnitHeapFreeBlock *freeBlocks; uint32_t blockSize; }; -CHECK_OFFSET(MEMUnitHeap, 0x00, header); -CHECK_OFFSET(MEMUnitHeap, 0x40, freeBlocks); -CHECK_OFFSET(MEMUnitHeap, 0x44, blockSize); -CHECK_SIZE(MEMUnitHeap, 0x48); +WUT_CHECK_OFFSET(MEMUnitHeap, 0x00, header); +WUT_CHECK_OFFSET(MEMUnitHeap, 0x40, freeBlocks); +WUT_CHECK_OFFSET(MEMUnitHeap, 0x44, blockSize); +WUT_CHECK_SIZE(MEMUnitHeap, 0x48); MEMHeapHandle MEMCreateUnitHeapEx(void *heap, diff --git a/include/coreinit/messagequeue.h b/include/coreinit/messagequeue.h index be5e098..9bab844 100644 --- a/include/coreinit/messagequeue.h +++ b/include/coreinit/messagequeue.h @@ -27,9 +27,9 @@ struct OSMessage void *message; uint32_t args[3]; }; -CHECK_OFFSET(OSMessage, 0x00, message); -CHECK_OFFSET(OSMessage, 0x04, args); -CHECK_SIZE(OSMessage, 0x10); +WUT_CHECK_OFFSET(OSMessage, 0x00, message); +WUT_CHECK_OFFSET(OSMessage, 0x04, args); +WUT_CHECK_SIZE(OSMessage, 0x10); #define OS_MESSAGE_QUEUE_TAG 0x6D536751u @@ -37,7 +37,7 @@ struct OSMessageQueue { uint32_t tag; const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); OSThreadQueue sendQueue; OSThreadQueue recvQueue; OSMessage *messages; @@ -45,15 +45,15 @@ struct OSMessageQueue uint32_t first; uint32_t used; }; -CHECK_OFFSET(OSMessageQueue, 0x00, tag); -CHECK_OFFSET(OSMessageQueue, 0x04, name); -CHECK_OFFSET(OSMessageQueue, 0x0c, sendQueue); -CHECK_OFFSET(OSMessageQueue, 0x1c, recvQueue); -CHECK_OFFSET(OSMessageQueue, 0x2c, messages); -CHECK_OFFSET(OSMessageQueue, 0x30, size); -CHECK_OFFSET(OSMessageQueue, 0x34, first); -CHECK_OFFSET(OSMessageQueue, 0x38, used); -CHECK_SIZE(OSMessageQueue, 0x3c); +WUT_CHECK_OFFSET(OSMessageQueue, 0x00, tag); +WUT_CHECK_OFFSET(OSMessageQueue, 0x04, name); +WUT_CHECK_OFFSET(OSMessageQueue, 0x0c, sendQueue); +WUT_CHECK_OFFSET(OSMessageQueue, 0x1c, recvQueue); +WUT_CHECK_OFFSET(OSMessageQueue, 0x2c, messages); +WUT_CHECK_OFFSET(OSMessageQueue, 0x30, size); +WUT_CHECK_OFFSET(OSMessageQueue, 0x34, first); +WUT_CHECK_OFFSET(OSMessageQueue, 0x38, used); +WUT_CHECK_SIZE(OSMessageQueue, 0x3c); void OSInitMessageQueue(OSMessageQueue *queue, diff --git a/include/coreinit/mutex.h b/include/coreinit/mutex.h index 2b7c9e2..043b0a4 100644 --- a/include/coreinit/mutex.h +++ b/include/coreinit/mutex.h @@ -26,9 +26,9 @@ struct OSMutexLink OSMutex *next; OSMutex *prev; }; -CHECK_OFFSET(OSMutexLink, 0x00, next); -CHECK_OFFSET(OSMutexLink, 0x04, prev); -CHECK_SIZE(OSMutexLink, 0x8); +WUT_CHECK_OFFSET(OSMutexLink, 0x00, next); +WUT_CHECK_OFFSET(OSMutexLink, 0x04, prev); +WUT_CHECK_SIZE(OSMutexLink, 0x8); #define OS_MUTEX_TAG 0x6D557458u @@ -40,7 +40,7 @@ struct OSMutex //! Name set by OSInitMutexEx. const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); //! Queue of threads waiting for this mutex to unlock. OSThreadQueue queue; @@ -54,13 +54,13 @@ struct OSMutex //! Link used inside OSThread's mutex queue. OSMutexLink link; }; -CHECK_OFFSET(OSMutex, 0x00, tag); -CHECK_OFFSET(OSMutex, 0x04, name); -CHECK_OFFSET(OSMutex, 0x0c, queue); -CHECK_OFFSET(OSMutex, 0x1c, owner); -CHECK_OFFSET(OSMutex, 0x20, count); -CHECK_OFFSET(OSMutex, 0x24, link); -CHECK_SIZE(OSMutex, 0x2c); +WUT_CHECK_OFFSET(OSMutex, 0x00, tag); +WUT_CHECK_OFFSET(OSMutex, 0x04, name); +WUT_CHECK_OFFSET(OSMutex, 0x0c, queue); +WUT_CHECK_OFFSET(OSMutex, 0x1c, owner); +WUT_CHECK_OFFSET(OSMutex, 0x20, count); +WUT_CHECK_OFFSET(OSMutex, 0x24, link); +WUT_CHECK_SIZE(OSMutex, 0x2c); /** diff --git a/include/coreinit/rendezvous.h b/include/coreinit/rendezvous.h index edb44f6..87e1a7f 100644 --- a/include/coreinit/rendezvous.h +++ b/include/coreinit/rendezvous.h @@ -16,10 +16,10 @@ typedef struct OSRendezvous OSRendezvous; struct OSRendezvous { uint32_t core[3]; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); }; -CHECK_OFFSET(OSRendezvous, 0x00, core); -CHECK_SIZE(OSRendezvous, 0x10); +WUT_CHECK_OFFSET(OSRendezvous, 0x00, core); +WUT_CHECK_SIZE(OSRendezvous, 0x10); void OSInitRendezvous(OSRendezvous *rendezvous); diff --git a/include/coreinit/semaphore.h b/include/coreinit/semaphore.h index 2d1b0f9..29d7bfb 100644 --- a/include/coreinit/semaphore.h +++ b/include/coreinit/semaphore.h @@ -26,7 +26,7 @@ struct OSSemaphore //! Name set by OSInitMutexEx. const char *name; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); //! Current count of semaphore int32_t count; @@ -34,11 +34,11 @@ struct OSSemaphore //! Queue of threads waiting on semaphore object with OSWaitSemaphore OSThreadQueue queue; }; -CHECK_OFFSET(OSSemaphore, 0x00, tag); -CHECK_OFFSET(OSSemaphore, 0x04, name); -CHECK_OFFSET(OSSemaphore, 0x0C, count); -CHECK_OFFSET(OSSemaphore, 0x10, queue); -CHECK_SIZE(OSSemaphore, 0x20); +WUT_CHECK_OFFSET(OSSemaphore, 0x00, tag); +WUT_CHECK_OFFSET(OSSemaphore, 0x04, name); +WUT_CHECK_OFFSET(OSSemaphore, 0x0C, count); +WUT_CHECK_OFFSET(OSSemaphore, 0x10, queue); +WUT_CHECK_SIZE(OSSemaphore, 0x20); /** diff --git a/include/coreinit/spinlock.h b/include/coreinit/spinlock.h index 440c815..64923d1 100644 --- a/include/coreinit/spinlock.h +++ b/include/coreinit/spinlock.h @@ -17,13 +17,13 @@ typedef struct OSSpinLock OSSpinLock; struct OSSpinLock { uint32_t owner; - UNKNOWN(0x4); + WUT_UNKNOWN_BYTES(0x4); uint32_t recursion; - UNKNOWN(0x4); + WUT_UNKNOWN_BYTES(0x4); }; -CHECK_OFFSET(OSSpinLock, 0x0, owner); -CHECK_OFFSET(OSSpinLock, 0x8, recursion); -CHECK_SIZE(OSSpinLock, 0x10); +WUT_CHECK_OFFSET(OSSpinLock, 0x0, owner); +WUT_CHECK_OFFSET(OSSpinLock, 0x8, recursion); +WUT_CHECK_SIZE(OSSpinLock, 0x10); void OSInitSpinLock(OSSpinLock *spinlock); diff --git a/include/coreinit/systeminfo.h b/include/coreinit/systeminfo.h index 5d61774..613b247 100644 --- a/include/coreinit/systeminfo.h +++ b/include/coreinit/systeminfo.h @@ -18,12 +18,12 @@ struct OSSystemInfo uint32_t busClockSpeed; uint32_t coreClockSpeed; int64_t baseTime; - UNKNOWN(0x10); + WUT_UNKNOWN_BYTES(0x10); }; -CHECK_OFFSET(OSSystemInfo, 0x0, busClockSpeed); -CHECK_OFFSET(OSSystemInfo, 0x4, coreClockSpeed); -CHECK_OFFSET(OSSystemInfo, 0x8, baseTime); -CHECK_SIZE(OSSystemInfo, 0x20); +WUT_CHECK_OFFSET(OSSystemInfo, 0x0, busClockSpeed); +WUT_CHECK_OFFSET(OSSystemInfo, 0x4, coreClockSpeed); +WUT_CHECK_OFFSET(OSSystemInfo, 0x8, baseTime); +WUT_CHECK_SIZE(OSSystemInfo, 0x20); OSSystemInfo * OSGetSystemInfo(); diff --git a/include/coreinit/taskqueue.h b/include/coreinit/taskqueue.h index ad7d572..374cfdd 100644 --- a/include/coreinit/taskqueue.h +++ b/include/coreinit/taskqueue.h @@ -45,11 +45,11 @@ struct MPTaskInfo OSTime duration; }; #pragma pack(pop) -CHECK_OFFSET(MPTaskInfo, 0x00, state); -CHECK_OFFSET(MPTaskInfo, 0x04, result); -CHECK_OFFSET(MPTaskInfo, 0x08, coreID); -CHECK_OFFSET(MPTaskInfo, 0x0C, duration); -CHECK_SIZE(MPTaskInfo, 0x14); +WUT_CHECK_OFFSET(MPTaskInfo, 0x00, state); +WUT_CHECK_OFFSET(MPTaskInfo, 0x04, result); +WUT_CHECK_OFFSET(MPTaskInfo, 0x08, coreID); +WUT_CHECK_OFFSET(MPTaskInfo, 0x0C, duration); +WUT_CHECK_SIZE(MPTaskInfo, 0x14); #pragma pack(push, 1) struct MPTask @@ -66,17 +66,17 @@ struct MPTask void *userData; }; #pragma pack(pop) -CHECK_OFFSET(MPTask, 0x00, self); -CHECK_OFFSET(MPTask, 0x04, queue); -CHECK_OFFSET(MPTask, 0x08, state); -CHECK_OFFSET(MPTask, 0x0C, func); -CHECK_OFFSET(MPTask, 0x10, userArg1); -CHECK_OFFSET(MPTask, 0x14, userArg2); -CHECK_OFFSET(MPTask, 0x18, result); -CHECK_OFFSET(MPTask, 0x1C, coreID); -CHECK_OFFSET(MPTask, 0x20, duration); -CHECK_OFFSET(MPTask, 0x28, userData); -CHECK_SIZE(MPTask, 0x2C); +WUT_CHECK_OFFSET(MPTask, 0x00, self); +WUT_CHECK_OFFSET(MPTask, 0x04, queue); +WUT_CHECK_OFFSET(MPTask, 0x08, state); +WUT_CHECK_OFFSET(MPTask, 0x0C, func); +WUT_CHECK_OFFSET(MPTask, 0x10, userArg1); +WUT_CHECK_OFFSET(MPTask, 0x14, userArg2); +WUT_CHECK_OFFSET(MPTask, 0x18, result); +WUT_CHECK_OFFSET(MPTask, 0x1C, coreID); +WUT_CHECK_OFFSET(MPTask, 0x20, duration); +WUT_CHECK_OFFSET(MPTask, 0x28, userData); +WUT_CHECK_SIZE(MPTask, 0x2C); struct MPTaskQueueInfo { @@ -86,12 +86,12 @@ struct MPTaskQueueInfo uint32_t tasksRunning; uint32_t tasksFinished; }; -CHECK_OFFSET(MPTaskQueueInfo, 0x00, state); -CHECK_OFFSET(MPTaskQueueInfo, 0x04, tasks); -CHECK_OFFSET(MPTaskQueueInfo, 0x08, tasksReady); -CHECK_OFFSET(MPTaskQueueInfo, 0x0C, tasksRunning); -CHECK_OFFSET(MPTaskQueueInfo, 0x10, tasksFinished); -CHECK_SIZE(MPTaskQueueInfo, 0x14); +WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x00, state); +WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x04, tasks); +WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x08, tasksReady); +WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x0C, tasksRunning); +WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x10, tasksFinished); +WUT_CHECK_SIZE(MPTaskQueueInfo, 0x14); struct MPTaskQueue { @@ -100,29 +100,29 @@ struct MPTaskQueue uint32_t tasks; uint32_t tasksReady; uint32_t tasksRunning; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); uint32_t tasksFinished; - UNKNOWN(8); + WUT_UNKNOWN_BYTES(8); uint32_t queueIndex; - UNKNOWN(8); + WUT_UNKNOWN_BYTES(8); uint32_t queueSize; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); MPTask **queue; uint32_t queueMaxSize; OSSpinLock lock; }; -CHECK_OFFSET(MPTaskQueue, 0x00, self); -CHECK_OFFSET(MPTaskQueue, 0x04, state); -CHECK_OFFSET(MPTaskQueue, 0x08, tasks); -CHECK_OFFSET(MPTaskQueue, 0x0C, tasksReady); -CHECK_OFFSET(MPTaskQueue, 0x10, tasksRunning); -CHECK_OFFSET(MPTaskQueue, 0x18, tasksFinished); -CHECK_OFFSET(MPTaskQueue, 0x24, queueIndex); -CHECK_OFFSET(MPTaskQueue, 0x30, queueSize); -CHECK_OFFSET(MPTaskQueue, 0x38, queue); -CHECK_OFFSET(MPTaskQueue, 0x3C, queueMaxSize); -CHECK_OFFSET(MPTaskQueue, 0x40, lock); -CHECK_SIZE(MPTaskQueue, 0x50); +WUT_CHECK_OFFSET(MPTaskQueue, 0x00, self); +WUT_CHECK_OFFSET(MPTaskQueue, 0x04, state); +WUT_CHECK_OFFSET(MPTaskQueue, 0x08, tasks); +WUT_CHECK_OFFSET(MPTaskQueue, 0x0C, tasksReady); +WUT_CHECK_OFFSET(MPTaskQueue, 0x10, tasksRunning); +WUT_CHECK_OFFSET(MPTaskQueue, 0x18, tasksFinished); +WUT_CHECK_OFFSET(MPTaskQueue, 0x24, queueIndex); +WUT_CHECK_OFFSET(MPTaskQueue, 0x30, queueSize); +WUT_CHECK_OFFSET(MPTaskQueue, 0x38, queue); +WUT_CHECK_OFFSET(MPTaskQueue, 0x3C, queueMaxSize); +WUT_CHECK_OFFSET(MPTaskQueue, 0x40, lock); +WUT_CHECK_SIZE(MPTaskQueue, 0x50); void MPInitTaskQ(MPTaskQueue *queue, diff --git a/include/coreinit/thread.h b/include/coreinit/thread.h index cccfcc6..0f43098 100644 --- a/include/coreinit/thread.h +++ b/include/coreinit/thread.h @@ -97,21 +97,21 @@ struct OSMutexQueue OSMutex *head; OSMutex *tail; void *parent; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); }; -CHECK_OFFSET(OSMutexQueue, 0x0, head); -CHECK_OFFSET(OSMutexQueue, 0x4, tail); -CHECK_OFFSET(OSMutexQueue, 0x8, parent); -CHECK_SIZE(OSMutexQueue, 0x10); +WUT_CHECK_OFFSET(OSMutexQueue, 0x0, head); +WUT_CHECK_OFFSET(OSMutexQueue, 0x4, tail); +WUT_CHECK_OFFSET(OSMutexQueue, 0x8, parent); +WUT_CHECK_SIZE(OSMutexQueue, 0x10); struct OSFastMutexQueue { OSFastMutex *head; OSFastMutex *tail; }; -CHECK_OFFSET(OSFastMutexQueue, 0x00, head); -CHECK_OFFSET(OSFastMutexQueue, 0x04, tail); -CHECK_SIZE(OSFastMutexQueue, 0x08); +WUT_CHECK_OFFSET(OSFastMutexQueue, 0x00, head); +WUT_CHECK_OFFSET(OSFastMutexQueue, 0x04, tail); +WUT_CHECK_SIZE(OSFastMutexQueue, 0x08); #define OS_THREAD_TAG 0x74487244u #pragma pack(push, 1) @@ -143,7 +143,7 @@ struct OSThread //! Exit value int32_t exitValue; - UNKNOWN(0x35C - 0x338); + WUT_UNKNOWN_BYTES(0x35C - 0x338); //! Queue the thread is currently waiting on OSThreadQueue *queue; @@ -172,17 +172,17 @@ struct OSThread //! Thread entry point OSThreadEntryPointFn entryPoint; - UNKNOWN(0x57c - 0x3a0); + WUT_UNKNOWN_BYTES(0x57c - 0x3a0); //! Thread specific values, accessed with OSSetThreadSpecific and OSGetThreadSpecific. void *specific[0x10]; - UNKNOWN(0x5c0 - 0x5bc); + WUT_UNKNOWN_BYTES(0x5c0 - 0x5bc); //! Thread name, accessed with OSSetThreadName and OSGetThreadName. const char *name; - UNKNOWN(0x4); + WUT_UNKNOWN_BYTES(0x4); //! The stack pointer passed in OSCreateThread. void *userStackPointer; @@ -208,37 +208,37 @@ struct OSThread //! Queue of threads waiting for a thread to be suspended. OSThreadQueue suspendQueue; - UNKNOWN(0x6a0 - 0x5f4); + WUT_UNKNOWN_BYTES(0x6a0 - 0x5f4); }; #pragma pack(pop) -CHECK_OFFSET(OSThread, 0x320, tag); -CHECK_OFFSET(OSThread, 0x324, state); -CHECK_OFFSET(OSThread, 0x325, attr); -CHECK_OFFSET(OSThread, 0x326, id); -CHECK_OFFSET(OSThread, 0x328, suspendCounter); -CHECK_OFFSET(OSThread, 0x32c, priority); -CHECK_OFFSET(OSThread, 0x330, basePriority); -CHECK_OFFSET(OSThread, 0x334, exitValue); -CHECK_OFFSET(OSThread, 0x35c, queue); -CHECK_OFFSET(OSThread, 0x360, link); -CHECK_OFFSET(OSThread, 0x368, joinQueue); -CHECK_OFFSET(OSThread, 0x378, mutex); -CHECK_OFFSET(OSThread, 0x37c, mutexQueue); -CHECK_OFFSET(OSThread, 0x38c, activeLink); -CHECK_OFFSET(OSThread, 0x394, stackStart); -CHECK_OFFSET(OSThread, 0x398, stackEnd); -CHECK_OFFSET(OSThread, 0x39c, entryPoint); -CHECK_OFFSET(OSThread, 0x57c, specific); -CHECK_OFFSET(OSThread, 0x5c0, name); -CHECK_OFFSET(OSThread, 0x5c8, userStackPointer); -CHECK_OFFSET(OSThread, 0x5cc, cleanupCallback); -CHECK_OFFSET(OSThread, 0x5d0, deallocator); -CHECK_OFFSET(OSThread, 0x5d4, cancelState); -CHECK_OFFSET(OSThread, 0x5d8, requestFlag); -CHECK_OFFSET(OSThread, 0x5dc, needSuspend); -CHECK_OFFSET(OSThread, 0x5e0, suspendResult); -CHECK_OFFSET(OSThread, 0x5e4, suspendQueue); -CHECK_SIZE(OSThread, 0x6a0); +WUT_CHECK_OFFSET(OSThread, 0x320, tag); +WUT_CHECK_OFFSET(OSThread, 0x324, state); +WUT_CHECK_OFFSET(OSThread, 0x325, attr); +WUT_CHECK_OFFSET(OSThread, 0x326, id); +WUT_CHECK_OFFSET(OSThread, 0x328, suspendCounter); +WUT_CHECK_OFFSET(OSThread, 0x32c, priority); +WUT_CHECK_OFFSET(OSThread, 0x330, basePriority); +WUT_CHECK_OFFSET(OSThread, 0x334, exitValue); +WUT_CHECK_OFFSET(OSThread, 0x35c, queue); +WUT_CHECK_OFFSET(OSThread, 0x360, link); +WUT_CHECK_OFFSET(OSThread, 0x368, joinQueue); +WUT_CHECK_OFFSET(OSThread, 0x378, mutex); +WUT_CHECK_OFFSET(OSThread, 0x37c, mutexQueue); +WUT_CHECK_OFFSET(OSThread, 0x38c, activeLink); +WUT_CHECK_OFFSET(OSThread, 0x394, stackStart); +WUT_CHECK_OFFSET(OSThread, 0x398, stackEnd); +WUT_CHECK_OFFSET(OSThread, 0x39c, entryPoint); +WUT_CHECK_OFFSET(OSThread, 0x57c, specific); +WUT_CHECK_OFFSET(OSThread, 0x5c0, name); +WUT_CHECK_OFFSET(OSThread, 0x5c8, userStackPointer); +WUT_CHECK_OFFSET(OSThread, 0x5cc, cleanupCallback); +WUT_CHECK_OFFSET(OSThread, 0x5d0, deallocator); +WUT_CHECK_OFFSET(OSThread, 0x5d4, cancelState); +WUT_CHECK_OFFSET(OSThread, 0x5d8, requestFlag); +WUT_CHECK_OFFSET(OSThread, 0x5dc, needSuspend); +WUT_CHECK_OFFSET(OSThread, 0x5e0, suspendResult); +WUT_CHECK_OFFSET(OSThread, 0x5e4, suspendQueue); +WUT_CHECK_SIZE(OSThread, 0x6a0); /** diff --git a/include/coreinit/threadqueue.h b/include/coreinit/threadqueue.h index 32a70ed..58197af 100644 --- a/include/coreinit/threadqueue.h +++ b/include/coreinit/threadqueue.h @@ -22,30 +22,30 @@ struct OSThreadLink OSThread *prev; OSThread *next; }; -CHECK_OFFSET(OSThreadLink, 0x00, prev); -CHECK_OFFSET(OSThreadLink, 0x04, next); -CHECK_SIZE(OSThreadLink, 0x8); +WUT_CHECK_OFFSET(OSThreadLink, 0x00, prev); +WUT_CHECK_OFFSET(OSThreadLink, 0x04, next); +WUT_CHECK_SIZE(OSThreadLink, 0x8); struct OSThreadQueue { OSThread *head; OSThread *tail; void *parent; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); }; -CHECK_OFFSET(OSThreadQueue, 0x00, head); -CHECK_OFFSET(OSThreadQueue, 0x04, tail); -CHECK_OFFSET(OSThreadQueue, 0x08, parent); -CHECK_SIZE(OSThreadQueue, 0x10); +WUT_CHECK_OFFSET(OSThreadQueue, 0x00, head); +WUT_CHECK_OFFSET(OSThreadQueue, 0x04, tail); +WUT_CHECK_OFFSET(OSThreadQueue, 0x08, parent); +WUT_CHECK_SIZE(OSThreadQueue, 0x10); struct OSThreadSimpleQueue { OSThread *head; OSThread *tail; }; -CHECK_OFFSET(OSThreadSimpleQueue, 0x00, head); -CHECK_OFFSET(OSThreadSimpleQueue, 0x04, tail); -CHECK_SIZE(OSThreadSimpleQueue, 0x08); +WUT_CHECK_OFFSET(OSThreadSimpleQueue, 0x00, head); +WUT_CHECK_OFFSET(OSThreadSimpleQueue, 0x04, tail); +WUT_CHECK_SIZE(OSThreadSimpleQueue, 0x08); void OSInitThreadQueue(OSThreadQueue *queue); diff --git a/include/coreinit/time.h b/include/coreinit/time.h index 2145575..051d970 100644 --- a/include/coreinit/time.h +++ b/include/coreinit/time.h @@ -31,17 +31,17 @@ struct OSCalendarTime int32_t tm_msec; int32_t tm_usec; }; -CHECK_OFFSET(OSCalendarTime, 0x00, tm_sec); -CHECK_OFFSET(OSCalendarTime, 0x04, tm_min); -CHECK_OFFSET(OSCalendarTime, 0x08, tm_hour); -CHECK_OFFSET(OSCalendarTime, 0x0C, tm_mday); -CHECK_OFFSET(OSCalendarTime, 0x10, tm_mon); -CHECK_OFFSET(OSCalendarTime, 0x14, tm_year); -CHECK_OFFSET(OSCalendarTime, 0x18, tm_wday); -CHECK_OFFSET(OSCalendarTime, 0x1C, tm_yday); -CHECK_OFFSET(OSCalendarTime, 0x20, tm_msec); -CHECK_OFFSET(OSCalendarTime, 0x24, tm_usec); -CHECK_SIZE(OSCalendarTime, 0x28); +WUT_CHECK_OFFSET(OSCalendarTime, 0x00, tm_sec); +WUT_CHECK_OFFSET(OSCalendarTime, 0x04, tm_min); +WUT_CHECK_OFFSET(OSCalendarTime, 0x08, tm_hour); +WUT_CHECK_OFFSET(OSCalendarTime, 0x0C, tm_mday); +WUT_CHECK_OFFSET(OSCalendarTime, 0x10, tm_mon); +WUT_CHECK_OFFSET(OSCalendarTime, 0x14, tm_year); +WUT_CHECK_OFFSET(OSCalendarTime, 0x18, tm_wday); +WUT_CHECK_OFFSET(OSCalendarTime, 0x1C, tm_yday); +WUT_CHECK_OFFSET(OSCalendarTime, 0x20, tm_msec); +WUT_CHECK_OFFSET(OSCalendarTime, 0x24, tm_usec); +WUT_CHECK_SIZE(OSCalendarTime, 0x28); #define OSTimerClockSpeed ((OSGetSystemInfo()->busClockSpeed) / 4) diff --git a/include/gx2/context.h b/include/gx2/context.h index 2c2ed39..76afcff 100644 --- a/include/gx2/context.h +++ b/include/gx2/context.h @@ -20,32 +20,32 @@ struct GX2ShadowState uint32_t context[0x400]; uint32_t alu[0x800]; uint32_t loop[0x60]; - PADDING((0x80 - 0x60) * 4); + WUT_PADDING_BYTES((0x80 - 0x60) * 4); uint32_t resource[0xD9E]; - PADDING((0xDC0 - 0xD9E) * 4); + WUT_PADDING_BYTES((0xDC0 - 0xD9E) * 4); uint32_t sampler[0xA2]; - PADDING((0xC0 - 0xA2) * 4); + WUT_PADDING_BYTES((0xC0 - 0xA2) * 4); }; -CHECK_OFFSET(GX2ShadowState, 0x0000, config); -CHECK_OFFSET(GX2ShadowState, 0x2C00, context); -CHECK_OFFSET(GX2ShadowState, 0x3C00, alu); -CHECK_OFFSET(GX2ShadowState, 0x5C00, loop); -CHECK_OFFSET(GX2ShadowState, 0x5E00, resource); -CHECK_OFFSET(GX2ShadowState, 0x9500, sampler); -CHECK_SIZE(GX2ShadowState, 0x9800); +WUT_CHECK_OFFSET(GX2ShadowState, 0x0000, config); +WUT_CHECK_OFFSET(GX2ShadowState, 0x2C00, context); +WUT_CHECK_OFFSET(GX2ShadowState, 0x3C00, alu); +WUT_CHECK_OFFSET(GX2ShadowState, 0x5C00, loop); +WUT_CHECK_OFFSET(GX2ShadowState, 0x5E00, resource); +WUT_CHECK_OFFSET(GX2ShadowState, 0x9500, sampler); +WUT_CHECK_SIZE(GX2ShadowState, 0x9800); struct GX2ContextState { GX2ShadowState shadowState; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); uint32_t shadowDisplayListSize; - UNKNOWN(0x9e00 - 0x9808); + WUT_UNKNOWN_BYTES(0x9e00 - 0x9808); uint32_t shadowDisplayList[192]; }; -CHECK_OFFSET(GX2ContextState, 0x0000, shadowState); -CHECK_OFFSET(GX2ContextState, 0x9804, shadowDisplayListSize); -CHECK_OFFSET(GX2ContextState, 0x9e00, shadowDisplayList); -CHECK_SIZE(GX2ContextState, 0xa100); +WUT_CHECK_OFFSET(GX2ContextState, 0x0000, shadowState); +WUT_CHECK_OFFSET(GX2ContextState, 0x9804, shadowDisplayListSize); +WUT_CHECK_OFFSET(GX2ContextState, 0x9e00, shadowDisplayList); +WUT_CHECK_SIZE(GX2ContextState, 0xa100); void GX2SetupContextStateEx(GX2ContextState *state, diff --git a/include/gx2/event.h b/include/gx2/event.h index 7810a8c..59f978c 100644 --- a/include/gx2/event.h +++ b/include/gx2/event.h @@ -30,13 +30,13 @@ struct GX2DisplayListOverrunData //! Size of new display list uint32_t newSize; - UNKNOWN(8); + WUT_UNKNOWN_BYTES(8); }; -CHECK_OFFSET(GX2DisplayListOverrunData, 0x00, oldList); -CHECK_OFFSET(GX2DisplayListOverrunData, 0x04, oldSize); -CHECK_OFFSET(GX2DisplayListOverrunData, 0x08, newList); -CHECK_OFFSET(GX2DisplayListOverrunData, 0x0C, newSize); -CHECK_SIZE(GX2DisplayListOverrunData, 0x18); +WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x00, oldList); +WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x04, oldSize); +WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x08, newList); +WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x0C, newSize); +WUT_CHECK_SIZE(GX2DisplayListOverrunData, 0x18); BOOL GX2DrawDone(); diff --git a/include/gx2/registers.h b/include/gx2/registers.h index 6181335..01079c7 100644 --- a/include/gx2/registers.h +++ b/include/gx2/registers.h @@ -34,33 +34,33 @@ struct GX2AAMaskReg { uint32_t pa_sc_aa_mask; }; -CHECK_OFFSET(GX2AAMaskReg, 0, pa_sc_aa_mask); -CHECK_SIZE(GX2AAMaskReg, 4); +WUT_CHECK_OFFSET(GX2AAMaskReg, 0, pa_sc_aa_mask); +WUT_CHECK_SIZE(GX2AAMaskReg, 4); struct GX2AlphaTestReg { uint32_t sx_alpha_test_control; uint32_t sx_alpha_ref; }; -CHECK_OFFSET(GX2AlphaTestReg, 0, sx_alpha_test_control); -CHECK_OFFSET(GX2AlphaTestReg, 4, sx_alpha_ref); -CHECK_SIZE(GX2AlphaTestReg, 8); +WUT_CHECK_OFFSET(GX2AlphaTestReg, 0, sx_alpha_test_control); +WUT_CHECK_OFFSET(GX2AlphaTestReg, 4, sx_alpha_ref); +WUT_CHECK_SIZE(GX2AlphaTestReg, 8); struct GX2AlphaToMaskReg { uint32_t db_alpha_to_mask; }; -CHECK_OFFSET(GX2AlphaToMaskReg, 0, db_alpha_to_mask); -CHECK_SIZE(GX2AlphaToMaskReg, 4); +WUT_CHECK_OFFSET(GX2AlphaToMaskReg, 0, db_alpha_to_mask); +WUT_CHECK_SIZE(GX2AlphaToMaskReg, 4); struct GX2BlendControlReg { GX2RenderTarget target; uint32_t cb_blend_control; }; -CHECK_OFFSET(GX2BlendControlReg, 0, target); -CHECK_OFFSET(GX2BlendControlReg, 4, cb_blend_control); -CHECK_SIZE(GX2BlendControlReg, 8); +WUT_CHECK_OFFSET(GX2BlendControlReg, 0, target); +WUT_CHECK_OFFSET(GX2BlendControlReg, 4, cb_blend_control); +WUT_CHECK_SIZE(GX2BlendControlReg, 8); struct GX2BlendConstantColorReg { @@ -69,62 +69,62 @@ struct GX2BlendConstantColorReg float blue; float alpha; }; -CHECK_OFFSET(GX2BlendConstantColorReg, 0x00, red); -CHECK_OFFSET(GX2BlendConstantColorReg, 0x04, green); -CHECK_OFFSET(GX2BlendConstantColorReg, 0x08, blue); -CHECK_OFFSET(GX2BlendConstantColorReg, 0x0c, alpha); -CHECK_SIZE(GX2BlendConstantColorReg, 0x10); +WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x00, red); +WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x04, green); +WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x08, blue); +WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x0c, alpha); +WUT_CHECK_SIZE(GX2BlendConstantColorReg, 0x10); struct GX2ColorControlReg { uint32_t cb_color_control; }; -CHECK_OFFSET(GX2ColorControlReg, 0x00, cb_color_control); -CHECK_SIZE(GX2ColorControlReg, 4); +WUT_CHECK_OFFSET(GX2ColorControlReg, 0x00, cb_color_control); +WUT_CHECK_SIZE(GX2ColorControlReg, 4); struct GX2DepthStencilControlReg { uint32_t db_depth_control; }; -CHECK_OFFSET(GX2DepthStencilControlReg, 0, db_depth_control); -CHECK_SIZE(GX2DepthStencilControlReg, 4); +WUT_CHECK_OFFSET(GX2DepthStencilControlReg, 0, db_depth_control); +WUT_CHECK_SIZE(GX2DepthStencilControlReg, 4); struct GX2StencilMaskReg { uint32_t db_stencilrefmask; uint32_t db_stencilrefmask_bf; }; -CHECK_OFFSET(GX2StencilMaskReg, 0, db_stencilrefmask); -CHECK_OFFSET(GX2StencilMaskReg, 4, db_stencilrefmask_bf); -CHECK_SIZE(GX2StencilMaskReg, 8); +WUT_CHECK_OFFSET(GX2StencilMaskReg, 0, db_stencilrefmask); +WUT_CHECK_OFFSET(GX2StencilMaskReg, 4, db_stencilrefmask_bf); +WUT_CHECK_SIZE(GX2StencilMaskReg, 8); struct GX2LineWidthReg { uint32_t pa_su_line_cntl; }; -CHECK_OFFSET(GX2LineWidthReg, 0, pa_su_line_cntl); -CHECK_SIZE(GX2LineWidthReg, 4); +WUT_CHECK_OFFSET(GX2LineWidthReg, 0, pa_su_line_cntl); +WUT_CHECK_SIZE(GX2LineWidthReg, 4); struct GX2PointSizeReg { uint32_t pa_su_point_size; }; -CHECK_OFFSET(GX2PointSizeReg, 0, pa_su_point_size); -CHECK_SIZE(GX2PointSizeReg, 4); +WUT_CHECK_OFFSET(GX2PointSizeReg, 0, pa_su_point_size); +WUT_CHECK_SIZE(GX2PointSizeReg, 4); struct GX2PointLimitsReg { uint32_t pa_su_point_minmax; }; -CHECK_OFFSET(GX2PointLimitsReg, 0, pa_su_point_minmax); -CHECK_SIZE(GX2PointLimitsReg, 4); +WUT_CHECK_OFFSET(GX2PointLimitsReg, 0, pa_su_point_minmax); +WUT_CHECK_SIZE(GX2PointLimitsReg, 4); struct GX2PolygonControlReg { uint32_t pa_su_sc_mode_cntl; }; -CHECK_OFFSET(GX2PolygonControlReg, 0, pa_su_sc_mode_cntl); -CHECK_SIZE(GX2PolygonControlReg, 4); +WUT_CHECK_OFFSET(GX2PolygonControlReg, 0, pa_su_sc_mode_cntl); +WUT_CHECK_SIZE(GX2PolygonControlReg, 4); struct GX2PolygonOffsetReg { @@ -134,28 +134,28 @@ struct GX2PolygonOffsetReg uint32_t pa_su_poly_offset_back_offset; uint32_t pa_su_poly_offset_clamp; }; -CHECK_OFFSET(GX2PolygonOffsetReg, 0x00, pa_su_poly_offset_front_scale); -CHECK_OFFSET(GX2PolygonOffsetReg, 0x04, pa_su_poly_offset_front_offset); -CHECK_OFFSET(GX2PolygonOffsetReg, 0x08, pa_su_poly_offset_back_scale); -CHECK_OFFSET(GX2PolygonOffsetReg, 0x0C, pa_su_poly_offset_back_offset); -CHECK_OFFSET(GX2PolygonOffsetReg, 0x10, pa_su_poly_offset_clamp); -CHECK_SIZE(GX2PolygonOffsetReg, 20); +WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x00, pa_su_poly_offset_front_scale); +WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x04, pa_su_poly_offset_front_offset); +WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x08, pa_su_poly_offset_back_scale); +WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x0C, pa_su_poly_offset_back_offset); +WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x10, pa_su_poly_offset_clamp); +WUT_CHECK_SIZE(GX2PolygonOffsetReg, 20); struct GX2ScissorReg { uint32_t pa_sc_generic_scissor_tl; uint32_t pa_sc_generic_scissor_br; }; -CHECK_OFFSET(GX2ScissorReg, 0x00, pa_sc_generic_scissor_tl); -CHECK_OFFSET(GX2ScissorReg, 0x04, pa_sc_generic_scissor_br); -CHECK_SIZE(GX2ScissorReg, 8); +WUT_CHECK_OFFSET(GX2ScissorReg, 0x00, pa_sc_generic_scissor_tl); +WUT_CHECK_OFFSET(GX2ScissorReg, 0x04, pa_sc_generic_scissor_br); +WUT_CHECK_SIZE(GX2ScissorReg, 8); struct GX2TargetChannelMaskReg { uint32_t cb_target_mask; }; -CHECK_OFFSET(GX2TargetChannelMaskReg, 0x00, cb_target_mask); -CHECK_SIZE(GX2TargetChannelMaskReg, 4); +WUT_CHECK_OFFSET(GX2TargetChannelMaskReg, 0x00, cb_target_mask); +WUT_CHECK_SIZE(GX2TargetChannelMaskReg, 4); struct GX2ViewportReg { @@ -172,19 +172,19 @@ struct GX2ViewportReg uint32_t pa_sc_vport_zmin; uint32_t pa_sc_vport_zmax; }; -CHECK_OFFSET(GX2ViewportReg, 0x00, pa_cl_vport_xscale); -CHECK_OFFSET(GX2ViewportReg, 0x04, pa_cl_vport_xoffset); -CHECK_OFFSET(GX2ViewportReg, 0x08, pa_cl_vport_yscale); -CHECK_OFFSET(GX2ViewportReg, 0x0C, pa_cl_vport_yoffset); -CHECK_OFFSET(GX2ViewportReg, 0x10, pa_cl_vport_zscale); -CHECK_OFFSET(GX2ViewportReg, 0x14, pa_cl_vport_zoffset); -CHECK_OFFSET(GX2ViewportReg, 0x18, pa_cl_gb_vert_clip_adj); -CHECK_OFFSET(GX2ViewportReg, 0x1C, pa_cl_gb_vert_disc_adj); -CHECK_OFFSET(GX2ViewportReg, 0x20, pa_cl_gb_horz_clip_adj); -CHECK_OFFSET(GX2ViewportReg, 0x24, pa_cl_gb_horz_disc_adj); -CHECK_OFFSET(GX2ViewportReg, 0x28, pa_sc_vport_zmin); -CHECK_OFFSET(GX2ViewportReg, 0x2C, pa_sc_vport_zmax); -CHECK_SIZE(GX2ViewportReg, 48); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x00, pa_cl_vport_xscale); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x04, pa_cl_vport_xoffset); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x08, pa_cl_vport_yscale); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x0C, pa_cl_vport_yoffset); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x10, pa_cl_vport_zscale); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x14, pa_cl_vport_zoffset); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x18, pa_cl_gb_vert_clip_adj); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x1C, pa_cl_gb_vert_disc_adj); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x20, pa_cl_gb_horz_clip_adj); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x24, pa_cl_gb_horz_disc_adj); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x28, pa_sc_vport_zmin); +WUT_CHECK_OFFSET(GX2ViewportReg, 0x2C, pa_sc_vport_zmax); +WUT_CHECK_SIZE(GX2ViewportReg, 48); void GX2SetAAMask(uint8_t upperLeft, diff --git a/include/gx2/sampler.h b/include/gx2/sampler.h index cdb1a1d..1b805fe 100644 --- a/include/gx2/sampler.h +++ b/include/gx2/sampler.h @@ -18,7 +18,7 @@ struct GX2Sampler { uint32_t regs[3]; }; -CHECK_SIZE(GX2Sampler, 12); +WUT_CHECK_SIZE(GX2Sampler, 12); void GX2InitSampler(GX2Sampler *sampler, diff --git a/include/gx2/shaders.h b/include/gx2/shaders.h index 11598b4..bbca84f 100644 --- a/include/gx2/shaders.h +++ b/include/gx2/shaders.h @@ -41,14 +41,14 @@ struct GX2FetchShader uint32_t numDivisors; uint32_t divisors[2]; }; -CHECK_OFFSET(GX2FetchShader, 0x0, type); -CHECK_OFFSET(GX2FetchShader, 0x4, regs.sq_pgm_resources_fs); -CHECK_OFFSET(GX2FetchShader, 0x8, size); -CHECK_OFFSET(GX2FetchShader, 0xc, program); -CHECK_OFFSET(GX2FetchShader, 0x10, attribCount); -CHECK_OFFSET(GX2FetchShader, 0x14, numDivisors); -CHECK_OFFSET(GX2FetchShader, 0x18, divisors); -CHECK_SIZE(GX2FetchShader, 0x20); +WUT_CHECK_OFFSET(GX2FetchShader, 0x0, type); +WUT_CHECK_OFFSET(GX2FetchShader, 0x4, regs.sq_pgm_resources_fs); +WUT_CHECK_OFFSET(GX2FetchShader, 0x8, size); +WUT_CHECK_OFFSET(GX2FetchShader, 0xc, program); +WUT_CHECK_OFFSET(GX2FetchShader, 0x10, attribCount); +WUT_CHECK_OFFSET(GX2FetchShader, 0x14, numDivisors); +WUT_CHECK_OFFSET(GX2FetchShader, 0x18, divisors); +WUT_CHECK_SIZE(GX2FetchShader, 0x20); struct GX2UniformBlock { @@ -56,10 +56,10 @@ struct GX2UniformBlock uint32_t offset; uint32_t size; }; -CHECK_OFFSET(GX2UniformBlock, 0x00, name); -CHECK_OFFSET(GX2UniformBlock, 0x04, offset); -CHECK_OFFSET(GX2UniformBlock, 0x08, size); -CHECK_SIZE(GX2UniformBlock, 0x0C); +WUT_CHECK_OFFSET(GX2UniformBlock, 0x00, name); +WUT_CHECK_OFFSET(GX2UniformBlock, 0x04, offset); +WUT_CHECK_OFFSET(GX2UniformBlock, 0x08, size); +WUT_CHECK_SIZE(GX2UniformBlock, 0x0C); struct GX2UniformVar { @@ -69,30 +69,30 @@ struct GX2UniformVar uint32_t offset; int32_t block; }; -CHECK_OFFSET(GX2UniformVar, 0x00, name); -CHECK_OFFSET(GX2UniformVar, 0x04, type); -CHECK_OFFSET(GX2UniformVar, 0x08, count); -CHECK_OFFSET(GX2UniformVar, 0x0C, offset); -CHECK_OFFSET(GX2UniformVar, 0x10, block); -CHECK_SIZE(GX2UniformVar, 0x14); +WUT_CHECK_OFFSET(GX2UniformVar, 0x00, name); +WUT_CHECK_OFFSET(GX2UniformVar, 0x04, type); +WUT_CHECK_OFFSET(GX2UniformVar, 0x08, count); +WUT_CHECK_OFFSET(GX2UniformVar, 0x0C, offset); +WUT_CHECK_OFFSET(GX2UniformVar, 0x10, block); +WUT_CHECK_SIZE(GX2UniformVar, 0x14); struct GX2UniformInitialValue { float value[4]; uint32_t offset; }; -CHECK_OFFSET(GX2UniformInitialValue, 0x00, value); -CHECK_OFFSET(GX2UniformInitialValue, 0x10, offset); -CHECK_SIZE(GX2UniformInitialValue, 0x14); +WUT_CHECK_OFFSET(GX2UniformInitialValue, 0x00, value); +WUT_CHECK_OFFSET(GX2UniformInitialValue, 0x10, offset); +WUT_CHECK_SIZE(GX2UniformInitialValue, 0x14); struct GX2LoopVar { uint32_t offset; uint32_t value; }; -CHECK_OFFSET(GX2LoopVar, 0x00, offset); -CHECK_OFFSET(GX2LoopVar, 0x04, value); -CHECK_SIZE(GX2LoopVar, 0x08); +WUT_CHECK_OFFSET(GX2LoopVar, 0x00, offset); +WUT_CHECK_OFFSET(GX2LoopVar, 0x04, value); +WUT_CHECK_SIZE(GX2LoopVar, 0x08); struct GX2SamplerVar { @@ -100,10 +100,10 @@ struct GX2SamplerVar GX2SamplerVarType type; uint32_t location; }; -CHECK_OFFSET(GX2SamplerVar, 0x00, name); -CHECK_OFFSET(GX2SamplerVar, 0x04, type); -CHECK_OFFSET(GX2SamplerVar, 0x08, location); -CHECK_SIZE(GX2SamplerVar, 0x0C); +WUT_CHECK_OFFSET(GX2SamplerVar, 0x00, name); +WUT_CHECK_OFFSET(GX2SamplerVar, 0x04, type); +WUT_CHECK_OFFSET(GX2SamplerVar, 0x08, location); +WUT_CHECK_SIZE(GX2SamplerVar, 0x0C); struct GX2AttribVar { @@ -112,11 +112,11 @@ struct GX2AttribVar uint32_t count; uint32_t location; }; -CHECK_OFFSET(GX2AttribVar, 0x00, name); -CHECK_OFFSET(GX2AttribVar, 0x04, type); -CHECK_OFFSET(GX2AttribVar, 0x08, count); -CHECK_OFFSET(GX2AttribVar, 0x0C, location); -CHECK_SIZE(GX2AttribVar, 0x10); +WUT_CHECK_OFFSET(GX2AttribVar, 0x00, name); +WUT_CHECK_OFFSET(GX2AttribVar, 0x04, type); +WUT_CHECK_OFFSET(GX2AttribVar, 0x08, count); +WUT_CHECK_OFFSET(GX2AttribVar, 0x0C, location); +WUT_CHECK_SIZE(GX2AttribVar, 0x10); struct GX2VertexShader { @@ -165,38 +165,38 @@ struct GX2VertexShader GX2RBuffer gx2rBuffer; }; -CHECK_OFFSET(GX2VertexShader, 0x00, regs.sq_pgm_resources_vs); -CHECK_OFFSET(GX2VertexShader, 0x04, regs.vgt_primitiveid_en); -CHECK_OFFSET(GX2VertexShader, 0x08, regs.spi_vs_out_config); -CHECK_OFFSET(GX2VertexShader, 0x0C, regs.num_spi_vs_out_id); -CHECK_OFFSET(GX2VertexShader, 0x10, regs.spi_vs_out_id); -CHECK_OFFSET(GX2VertexShader, 0x38, regs.pa_cl_vs_out_cntl); -CHECK_OFFSET(GX2VertexShader, 0x3C, regs.sq_vtx_semantic_clear); -CHECK_OFFSET(GX2VertexShader, 0x40, regs.num_sq_vtx_semantic); -CHECK_OFFSET(GX2VertexShader, 0x44, regs.sq_vtx_semantic); -CHECK_OFFSET(GX2VertexShader, 0xC4, regs.vgt_strmout_buffer_en); -CHECK_OFFSET(GX2VertexShader, 0xC8, regs.vgt_vertex_reuse_block_cntl); -CHECK_OFFSET(GX2VertexShader, 0xCC, regs.vgt_hos_reuse_depth); -CHECK_OFFSET(GX2VertexShader, 0xD0, size); -CHECK_OFFSET(GX2VertexShader, 0xD4, program); -CHECK_OFFSET(GX2VertexShader, 0xD8, mode); -CHECK_OFFSET(GX2VertexShader, 0xDc, uniformBlockCount); -CHECK_OFFSET(GX2VertexShader, 0xE0, uniformBlocks); -CHECK_OFFSET(GX2VertexShader, 0xE4, uniformVarCount); -CHECK_OFFSET(GX2VertexShader, 0xE8, uniformVars); -CHECK_OFFSET(GX2VertexShader, 0xEc, initialValueCount); -CHECK_OFFSET(GX2VertexShader, 0xF0, initialValues); -CHECK_OFFSET(GX2VertexShader, 0xF4, loopVarCount); -CHECK_OFFSET(GX2VertexShader, 0xF8, loopVars); -CHECK_OFFSET(GX2VertexShader, 0xFc, samplerVarCount); -CHECK_OFFSET(GX2VertexShader, 0x100, samplerVars); -CHECK_OFFSET(GX2VertexShader, 0x104, attribVarCount); -CHECK_OFFSET(GX2VertexShader, 0x108, attribVars); -CHECK_OFFSET(GX2VertexShader, 0x10c, ringItemsize); -CHECK_OFFSET(GX2VertexShader, 0x110, hasStreamOut); -CHECK_OFFSET(GX2VertexShader, 0x114, streamOutStride); -CHECK_OFFSET(GX2VertexShader, 0x124, gx2rBuffer); -CHECK_SIZE(GX2VertexShader, 0x134); +WUT_CHECK_OFFSET(GX2VertexShader, 0x00, regs.sq_pgm_resources_vs); +WUT_CHECK_OFFSET(GX2VertexShader, 0x04, regs.vgt_primitiveid_en); +WUT_CHECK_OFFSET(GX2VertexShader, 0x08, regs.spi_vs_out_config); +WUT_CHECK_OFFSET(GX2VertexShader, 0x0C, regs.num_spi_vs_out_id); +WUT_CHECK_OFFSET(GX2VertexShader, 0x10, regs.spi_vs_out_id); +WUT_CHECK_OFFSET(GX2VertexShader, 0x38, regs.pa_cl_vs_out_cntl); +WUT_CHECK_OFFSET(GX2VertexShader, 0x3C, regs.sq_vtx_semantic_clear); +WUT_CHECK_OFFSET(GX2VertexShader, 0x40, regs.num_sq_vtx_semantic); +WUT_CHECK_OFFSET(GX2VertexShader, 0x44, regs.sq_vtx_semantic); +WUT_CHECK_OFFSET(GX2VertexShader, 0xC4, regs.vgt_strmout_buffer_en); +WUT_CHECK_OFFSET(GX2VertexShader, 0xC8, regs.vgt_vertex_reuse_block_cntl); +WUT_CHECK_OFFSET(GX2VertexShader, 0xCC, regs.vgt_hos_reuse_depth); +WUT_CHECK_OFFSET(GX2VertexShader, 0xD0, size); +WUT_CHECK_OFFSET(GX2VertexShader, 0xD4, program); +WUT_CHECK_OFFSET(GX2VertexShader, 0xD8, mode); +WUT_CHECK_OFFSET(GX2VertexShader, 0xDc, uniformBlockCount); +WUT_CHECK_OFFSET(GX2VertexShader, 0xE0, uniformBlocks); +WUT_CHECK_OFFSET(GX2VertexShader, 0xE4, uniformVarCount); +WUT_CHECK_OFFSET(GX2VertexShader, 0xE8, uniformVars); +WUT_CHECK_OFFSET(GX2VertexShader, 0xEc, initialValueCount); +WUT_CHECK_OFFSET(GX2VertexShader, 0xF0, initialValues); +WUT_CHECK_OFFSET(GX2VertexShader, 0xF4, loopVarCount); +WUT_CHECK_OFFSET(GX2VertexShader, 0xF8, loopVars); +WUT_CHECK_OFFSET(GX2VertexShader, 0xFc, samplerVarCount); +WUT_CHECK_OFFSET(GX2VertexShader, 0x100, samplerVars); +WUT_CHECK_OFFSET(GX2VertexShader, 0x104, attribVarCount); +WUT_CHECK_OFFSET(GX2VertexShader, 0x108, attribVars); +WUT_CHECK_OFFSET(GX2VertexShader, 0x10c, ringItemsize); +WUT_CHECK_OFFSET(GX2VertexShader, 0x110, hasStreamOut); +WUT_CHECK_OFFSET(GX2VertexShader, 0x114, streamOutStride); +WUT_CHECK_OFFSET(GX2VertexShader, 0x124, gx2rBuffer); +WUT_CHECK_SIZE(GX2VertexShader, 0x134); struct GX2PixelShader { @@ -235,31 +235,31 @@ struct GX2PixelShader GX2RBuffer gx2rBuffer; }; -CHECK_OFFSET(GX2PixelShader, 0x00, regs.sq_pgm_resources_ps); -CHECK_OFFSET(GX2PixelShader, 0x04, regs.sq_pgm_exports_ps); -CHECK_OFFSET(GX2PixelShader, 0x08, regs.spi_ps_in_control_0); -CHECK_OFFSET(GX2PixelShader, 0x0C, regs.spi_ps_in_control_1); -CHECK_OFFSET(GX2PixelShader, 0x10, regs.num_spi_ps_input_cntl); -CHECK_OFFSET(GX2PixelShader, 0x14, regs.spi_ps_input_cntls); -CHECK_OFFSET(GX2PixelShader, 0x94, regs.cb_shader_mask); -CHECK_OFFSET(GX2PixelShader, 0x98, regs.cb_shader_control); -CHECK_OFFSET(GX2PixelShader, 0x9C, regs.db_shader_control); -CHECK_OFFSET(GX2PixelShader, 0xA0, regs.spi_input_z); -CHECK_OFFSET(GX2PixelShader, 0xA4, size); -CHECK_OFFSET(GX2PixelShader, 0xA8, program); -CHECK_OFFSET(GX2PixelShader, 0xAC, mode); -CHECK_OFFSET(GX2PixelShader, 0xB0, uniformBlockCount); -CHECK_OFFSET(GX2PixelShader, 0xB4, uniformBlocks); -CHECK_OFFSET(GX2PixelShader, 0xB8, uniformVarCount); -CHECK_OFFSET(GX2PixelShader, 0xBC, uniformVars); -CHECK_OFFSET(GX2PixelShader, 0xC0, initialValueCount); -CHECK_OFFSET(GX2PixelShader, 0xC4, initialValues); -CHECK_OFFSET(GX2PixelShader, 0xC8, loopVarCount); -CHECK_OFFSET(GX2PixelShader, 0xCC, loopVars); -CHECK_OFFSET(GX2PixelShader, 0xD0, samplerVarCount); -CHECK_OFFSET(GX2PixelShader, 0xD4, samplerVars); -CHECK_OFFSET(GX2PixelShader, 0xD8, gx2rBuffer); -CHECK_SIZE(GX2PixelShader, 0xE8); +WUT_CHECK_OFFSET(GX2PixelShader, 0x00, regs.sq_pgm_resources_ps); +WUT_CHECK_OFFSET(GX2PixelShader, 0x04, regs.sq_pgm_exports_ps); +WUT_CHECK_OFFSET(GX2PixelShader, 0x08, regs.spi_ps_in_control_0); +WUT_CHECK_OFFSET(GX2PixelShader, 0x0C, regs.spi_ps_in_control_1); +WUT_CHECK_OFFSET(GX2PixelShader, 0x10, regs.num_spi_ps_input_cntl); +WUT_CHECK_OFFSET(GX2PixelShader, 0x14, regs.spi_ps_input_cntls); +WUT_CHECK_OFFSET(GX2PixelShader, 0x94, regs.cb_shader_mask); +WUT_CHECK_OFFSET(GX2PixelShader, 0x98, regs.cb_shader_control); +WUT_CHECK_OFFSET(GX2PixelShader, 0x9C, regs.db_shader_control); +WUT_CHECK_OFFSET(GX2PixelShader, 0xA0, regs.spi_input_z); +WUT_CHECK_OFFSET(GX2PixelShader, 0xA4, size); +WUT_CHECK_OFFSET(GX2PixelShader, 0xA8, program); +WUT_CHECK_OFFSET(GX2PixelShader, 0xAC, mode); +WUT_CHECK_OFFSET(GX2PixelShader, 0xB0, uniformBlockCount); +WUT_CHECK_OFFSET(GX2PixelShader, 0xB4, uniformBlocks); +WUT_CHECK_OFFSET(GX2PixelShader, 0xB8, uniformVarCount); +WUT_CHECK_OFFSET(GX2PixelShader, 0xBC, uniformVars); +WUT_CHECK_OFFSET(GX2PixelShader, 0xC0, initialValueCount); +WUT_CHECK_OFFSET(GX2PixelShader, 0xC4, initialValues); +WUT_CHECK_OFFSET(GX2PixelShader, 0xC8, loopVarCount); +WUT_CHECK_OFFSET(GX2PixelShader, 0xCC, loopVars); +WUT_CHECK_OFFSET(GX2PixelShader, 0xD0, samplerVarCount); +WUT_CHECK_OFFSET(GX2PixelShader, 0xD4, samplerVars); +WUT_CHECK_OFFSET(GX2PixelShader, 0xD8, gx2rBuffer); +WUT_CHECK_SIZE(GX2PixelShader, 0xE8); struct GX2GeometryShader { @@ -304,36 +304,36 @@ struct GX2GeometryShader GX2RBuffer gx2rBuffer; }; -CHECK_OFFSET(GX2GeometryShader, 0x00, regs.sq_pgm_resources_gs); -CHECK_OFFSET(GX2GeometryShader, 0x04, regs.vgt_gs_out_prim_type); -CHECK_OFFSET(GX2GeometryShader, 0x08, regs.vgt_gs_mode); -CHECK_OFFSET(GX2GeometryShader, 0x0C, regs.pa_cl_vs_out_cntl); -CHECK_OFFSET(GX2GeometryShader, 0x10, regs.sq_pgm_resources_vs); -CHECK_OFFSET(GX2GeometryShader, 0x14, regs.sq_gs_vert_itemsize); -CHECK_OFFSET(GX2GeometryShader, 0x18, regs.spi_vs_out_config); -CHECK_OFFSET(GX2GeometryShader, 0x1C, regs.num_spi_vs_out_id); -CHECK_OFFSET(GX2GeometryShader, 0x20, regs.spi_vs_out_id); -CHECK_OFFSET(GX2GeometryShader, 0x48, regs.vgt_strmout_buffer_en); -CHECK_OFFSET(GX2GeometryShader, 0x4C, size); -CHECK_OFFSET(GX2GeometryShader, 0x50, program); -CHECK_OFFSET(GX2GeometryShader, 0x54, vertexProgramSize); -CHECK_OFFSET(GX2GeometryShader, 0x58, vertexProgram); -CHECK_OFFSET(GX2GeometryShader, 0x5C, mode); -CHECK_OFFSET(GX2GeometryShader, 0x60, uniformBlockCount); -CHECK_OFFSET(GX2GeometryShader, 0x64, uniformBlocks); -CHECK_OFFSET(GX2GeometryShader, 0x68, uniformVarCount); -CHECK_OFFSET(GX2GeometryShader, 0x6C, uniformVars); -CHECK_OFFSET(GX2GeometryShader, 0x70, initialValueCount); -CHECK_OFFSET(GX2GeometryShader, 0x74, initialValues); -CHECK_OFFSET(GX2GeometryShader, 0x78, loopVarCount); -CHECK_OFFSET(GX2GeometryShader, 0x7C, loopVars); -CHECK_OFFSET(GX2GeometryShader, 0x80, samplerVarCount); -CHECK_OFFSET(GX2GeometryShader, 0x84, samplerVars); -CHECK_OFFSET(GX2GeometryShader, 0x88, ringItemSize); -CHECK_OFFSET(GX2GeometryShader, 0x8C, hasStreamOut); -CHECK_OFFSET(GX2GeometryShader, 0x90, streamOutStride); -CHECK_OFFSET(GX2GeometryShader, 0xA0, gx2rBuffer); -CHECK_SIZE(GX2GeometryShader, 0xB0); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x00, regs.sq_pgm_resources_gs); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x04, regs.vgt_gs_out_prim_type); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x08, regs.vgt_gs_mode); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x0C, regs.pa_cl_vs_out_cntl); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x10, regs.sq_pgm_resources_vs); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x14, regs.sq_gs_vert_itemsize); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x18, regs.spi_vs_out_config); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x1C, regs.num_spi_vs_out_id); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x20, regs.spi_vs_out_id); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x48, regs.vgt_strmout_buffer_en); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x4C, size); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x50, program); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x54, vertexProgramSize); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x58, vertexProgram); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x5C, mode); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x60, uniformBlockCount); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x64, uniformBlocks); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x68, uniformVarCount); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x6C, uniformVars); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x70, initialValueCount); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x74, initialValues); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x78, loopVarCount); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x7C, loopVars); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x80, samplerVarCount); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x84, samplerVars); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x88, ringItemSize); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x8C, hasStreamOut); +WUT_CHECK_OFFSET(GX2GeometryShader, 0x90, streamOutStride); +WUT_CHECK_OFFSET(GX2GeometryShader, 0xA0, gx2rBuffer); +WUT_CHECK_SIZE(GX2GeometryShader, 0xB0); struct GX2AttribStream { @@ -346,15 +346,15 @@ struct GX2AttribStream uint32_t mask; GX2EndianSwapMode endianSwap; }; -CHECK_OFFSET(GX2AttribStream, 0x0, location); -CHECK_OFFSET(GX2AttribStream, 0x4, buffer); -CHECK_OFFSET(GX2AttribStream, 0x8, offset); -CHECK_OFFSET(GX2AttribStream, 0xc, format); -CHECK_OFFSET(GX2AttribStream, 0x10, type); -CHECK_OFFSET(GX2AttribStream, 0x14, aluDivisor); -CHECK_OFFSET(GX2AttribStream, 0x18, mask); -CHECK_OFFSET(GX2AttribStream, 0x1c, endianSwap); -CHECK_SIZE(GX2AttribStream, 0x20); +WUT_CHECK_OFFSET(GX2AttribStream, 0x0, location); +WUT_CHECK_OFFSET(GX2AttribStream, 0x4, buffer); +WUT_CHECK_OFFSET(GX2AttribStream, 0x8, offset); +WUT_CHECK_OFFSET(GX2AttribStream, 0xc, format); +WUT_CHECK_OFFSET(GX2AttribStream, 0x10, type); +WUT_CHECK_OFFSET(GX2AttribStream, 0x14, aluDivisor); +WUT_CHECK_OFFSET(GX2AttribStream, 0x18, mask); +WUT_CHECK_OFFSET(GX2AttribStream, 0x1c, endianSwap); +WUT_CHECK_SIZE(GX2AttribStream, 0x20); uint32_t GX2CalcGeometryShaderInputRingBufferSize(uint32_t ringItemSize); diff --git a/include/gx2/surface.h b/include/gx2/surface.h index 93b3418..7930fd2 100644 --- a/include/gx2/surface.h +++ b/include/gx2/surface.h @@ -40,25 +40,25 @@ struct GX2Surface uint32_t pitch; uint32_t mipLevelOffset[13]; }; -CHECK_OFFSET(GX2Surface, 0x0, dim); -CHECK_OFFSET(GX2Surface, 0x4, width); -CHECK_OFFSET(GX2Surface, 0x8, height); -CHECK_OFFSET(GX2Surface, 0xc, depth); -CHECK_OFFSET(GX2Surface, 0x10, mipLevels); -CHECK_OFFSET(GX2Surface, 0x14, format); -CHECK_OFFSET(GX2Surface, 0x18, aa); -CHECK_OFFSET(GX2Surface, 0x1c, use); -CHECK_OFFSET(GX2Surface, 0x1c, resourceFlags); -CHECK_OFFSET(GX2Surface, 0x20, imageSize); -CHECK_OFFSET(GX2Surface, 0x24, image); -CHECK_OFFSET(GX2Surface, 0x28, mipmapSize); -CHECK_OFFSET(GX2Surface, 0x2c, mipmaps); -CHECK_OFFSET(GX2Surface, 0x30, tileMode); -CHECK_OFFSET(GX2Surface, 0x34, swizzle); -CHECK_OFFSET(GX2Surface, 0x38, alignment); -CHECK_OFFSET(GX2Surface, 0x3C, pitch); -CHECK_OFFSET(GX2Surface, 0x40, mipLevelOffset); -CHECK_SIZE(GX2Surface, 0x74); +WUT_CHECK_OFFSET(GX2Surface, 0x0, dim); +WUT_CHECK_OFFSET(GX2Surface, 0x4, width); +WUT_CHECK_OFFSET(GX2Surface, 0x8, height); +WUT_CHECK_OFFSET(GX2Surface, 0xc, depth); +WUT_CHECK_OFFSET(GX2Surface, 0x10, mipLevels); +WUT_CHECK_OFFSET(GX2Surface, 0x14, format); +WUT_CHECK_OFFSET(GX2Surface, 0x18, aa); +WUT_CHECK_OFFSET(GX2Surface, 0x1c, use); +WUT_CHECK_OFFSET(GX2Surface, 0x1c, resourceFlags); +WUT_CHECK_OFFSET(GX2Surface, 0x20, imageSize); +WUT_CHECK_OFFSET(GX2Surface, 0x24, image); +WUT_CHECK_OFFSET(GX2Surface, 0x28, mipmapSize); +WUT_CHECK_OFFSET(GX2Surface, 0x2c, mipmaps); +WUT_CHECK_OFFSET(GX2Surface, 0x30, tileMode); +WUT_CHECK_OFFSET(GX2Surface, 0x34, swizzle); +WUT_CHECK_OFFSET(GX2Surface, 0x38, alignment); +WUT_CHECK_OFFSET(GX2Surface, 0x3C, pitch); +WUT_CHECK_OFFSET(GX2Surface, 0x40, mipLevelOffset); +WUT_CHECK_SIZE(GX2Surface, 0x74); struct GX2DepthBuffer { @@ -74,15 +74,15 @@ struct GX2DepthBuffer uint32_t regs[7]; }; -CHECK_OFFSET(GX2DepthBuffer, 0x74, viewMip); -CHECK_OFFSET(GX2DepthBuffer, 0x78, viewFirstSlice); -CHECK_OFFSET(GX2DepthBuffer, 0x7C, viewNumSlices); -CHECK_OFFSET(GX2DepthBuffer, 0x80, hiZPtr); -CHECK_OFFSET(GX2DepthBuffer, 0x84, hiZSize); -CHECK_OFFSET(GX2DepthBuffer, 0x88, depthClear); -CHECK_OFFSET(GX2DepthBuffer, 0x8C, stencilClear); -CHECK_OFFSET(GX2DepthBuffer, 0x90, regs); -CHECK_SIZE(GX2DepthBuffer, 0xAC); +WUT_CHECK_OFFSET(GX2DepthBuffer, 0x74, viewMip); +WUT_CHECK_OFFSET(GX2DepthBuffer, 0x78, viewFirstSlice); +WUT_CHECK_OFFSET(GX2DepthBuffer, 0x7C, viewNumSlices); +WUT_CHECK_OFFSET(GX2DepthBuffer, 0x80, hiZPtr); +WUT_CHECK_OFFSET(GX2DepthBuffer, 0x84, hiZSize); +WUT_CHECK_OFFSET(GX2DepthBuffer, 0x88, depthClear); +WUT_CHECK_OFFSET(GX2DepthBuffer, 0x8C, stencilClear); +WUT_CHECK_OFFSET(GX2DepthBuffer, 0x90, regs); +WUT_CHECK_SIZE(GX2DepthBuffer, 0xAC); struct GX2ColorBuffer { @@ -96,13 +96,13 @@ struct GX2ColorBuffer uint32_t regs[5]; }; -CHECK_OFFSET(GX2ColorBuffer, 0x74, viewMip); -CHECK_OFFSET(GX2ColorBuffer, 0x78, viewFirstSlice); -CHECK_OFFSET(GX2ColorBuffer, 0x7C, viewNumSlices); -CHECK_OFFSET(GX2ColorBuffer, 0x80, aaBuffer); -CHECK_OFFSET(GX2ColorBuffer, 0x84, aaSize); -CHECK_OFFSET(GX2ColorBuffer, 0x88, regs); -CHECK_SIZE(GX2ColorBuffer, 0x9C); +WUT_CHECK_OFFSET(GX2ColorBuffer, 0x74, viewMip); +WUT_CHECK_OFFSET(GX2ColorBuffer, 0x78, viewFirstSlice); +WUT_CHECK_OFFSET(GX2ColorBuffer, 0x7C, viewNumSlices); +WUT_CHECK_OFFSET(GX2ColorBuffer, 0x80, aaBuffer); +WUT_CHECK_OFFSET(GX2ColorBuffer, 0x84, aaSize); +WUT_CHECK_OFFSET(GX2ColorBuffer, 0x88, regs); +WUT_CHECK_SIZE(GX2ColorBuffer, 0x9C); void GX2CalcSurfaceSizeAndAlignment(GX2Surface *surface); diff --git a/include/gx2/texture.h b/include/gx2/texture.h index 3f4d8b9..dc522d4 100644 --- a/include/gx2/texture.h +++ b/include/gx2/texture.h @@ -25,14 +25,14 @@ struct GX2Texture uint32_t regs[5]; }; -CHECK_OFFSET(GX2Texture, 0x0, surface); -CHECK_OFFSET(GX2Texture, 0x74, viewFirstMip); -CHECK_OFFSET(GX2Texture, 0x78, viewNumMips); -CHECK_OFFSET(GX2Texture, 0x7c, viewFirstSlice); -CHECK_OFFSET(GX2Texture, 0x80, viewNumSlices); -CHECK_OFFSET(GX2Texture, 0x84, compMap); -CHECK_OFFSET(GX2Texture, 0x88, regs); -CHECK_SIZE(GX2Texture, 0x9c); +WUT_CHECK_OFFSET(GX2Texture, 0x0, surface); +WUT_CHECK_OFFSET(GX2Texture, 0x74, viewFirstMip); +WUT_CHECK_OFFSET(GX2Texture, 0x78, viewNumMips); +WUT_CHECK_OFFSET(GX2Texture, 0x7c, viewFirstSlice); +WUT_CHECK_OFFSET(GX2Texture, 0x80, viewNumSlices); +WUT_CHECK_OFFSET(GX2Texture, 0x84, compMap); +WUT_CHECK_OFFSET(GX2Texture, 0x88, regs); +WUT_CHECK_SIZE(GX2Texture, 0x9c); void GX2InitTextureRegs(GX2Texture *texture); diff --git a/include/gx2r/buffer.h b/include/gx2r/buffer.h index 6bd8e88..a349281 100644 --- a/include/gx2r/buffer.h +++ b/include/gx2r/buffer.h @@ -21,11 +21,11 @@ struct GX2RBuffer uint32_t elemCount; void *buffer; }; -CHECK_SIZE(GX2RBuffer, 0x10); -CHECK_OFFSET(GX2RBuffer, 0x00, flags); -CHECK_OFFSET(GX2RBuffer, 0x04, elemSize); -CHECK_OFFSET(GX2RBuffer, 0x08, elemCount); -CHECK_OFFSET(GX2RBuffer, 0x0C, buffer); +WUT_CHECK_SIZE(GX2RBuffer, 0x10); +WUT_CHECK_OFFSET(GX2RBuffer, 0x00, flags); +WUT_CHECK_OFFSET(GX2RBuffer, 0x04, elemSize); +WUT_CHECK_OFFSET(GX2RBuffer, 0x08, elemCount); +WUT_CHECK_OFFSET(GX2RBuffer, 0x0C, buffer); BOOL GX2RBufferExists(GX2RBuffer *buffer); diff --git a/include/nn/swkbd/swkbd_cpp.h b/include/nn/swkbd/swkbd_cpp.h index b704fc0..a78b6ea 100644 --- a/include/nn/swkbd/swkbd_cpp.h +++ b/include/nn/swkbd/swkbd_cpp.h @@ -62,20 +62,20 @@ struct ConfigArg uint32_t unk_0x0C; uint32_t unk_0x10; int32_t unk_0x14; - UNKNOWN(0x9C - 0x18); + WUT_UNKNOWN_BYTES(0x9C - 0x18); uint32_t unk_0x9C; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); int32_t unk_0xA4; }; -CHECK_OFFSET(ConfigArg, languageType, 0x00); -CHECK_OFFSET(ConfigArg, unk_0x04, 0x04); -CHECK_OFFSET(ConfigArg, unk_0x08, 0x08); -CHECK_OFFSET(ConfigArg, unk_0x0C, 0x0C); -CHECK_OFFSET(ConfigArg, unk_0x10, 0x10); -CHECK_OFFSET(ConfigArg, unk_0x14, 0x14); -CHECK_OFFSET(ConfigArg, unk_0x9C, 0x9C); -CHECK_OFFSET(ConfigArg, unk_0xA4, 0xA4); -CHECK_SIZE(ConfigArg, 0xA8); +WUT_CHECK_OFFSET(ConfigArg, languageType, 0x00); +WUT_CHECK_OFFSET(ConfigArg, unk_0x04, 0x04); +WUT_CHECK_OFFSET(ConfigArg, unk_0x08, 0x08); +WUT_CHECK_OFFSET(ConfigArg, unk_0x0C, 0x0C); +WUT_CHECK_OFFSET(ConfigArg, unk_0x10, 0x10); +WUT_CHECK_OFFSET(ConfigArg, unk_0x14, 0x14); +WUT_CHECK_OFFSET(ConfigArg, unk_0x9C, 0x9C); +WUT_CHECK_OFFSET(ConfigArg, unk_0xA4, 0xA4); +WUT_CHECK_SIZE(ConfigArg, 0xA8); struct ReceiverArg { @@ -86,20 +86,20 @@ struct ReceiverArg uint32_t unk_0x10 = 0; int32_t unk_0x14 = -1; }; -CHECK_OFFSET(ReceiverArg, unk_0x00, 0x00); -CHECK_OFFSET(ReceiverArg, unk_0x04, 0x04); -CHECK_OFFSET(ReceiverArg, unk_0x08, 0x08); -CHECK_OFFSET(ReceiverArg, unk_0x0C, 0x0C); -CHECK_OFFSET(ReceiverArg, unk_0x10, 0x10); -CHECK_OFFSET(ReceiverArg, unk_0x14, 0x14); -CHECK_SIZE(ReceiverArg, 0x18); +WUT_CHECK_OFFSET(ReceiverArg, unk_0x00, 0x00); +WUT_CHECK_OFFSET(ReceiverArg, unk_0x04, 0x04); +WUT_CHECK_OFFSET(ReceiverArg, unk_0x08, 0x08); +WUT_CHECK_OFFSET(ReceiverArg, unk_0x0C, 0x0C); +WUT_CHECK_OFFSET(ReceiverArg, unk_0x10, 0x10); +WUT_CHECK_OFFSET(ReceiverArg, unk_0x14, 0x14); +WUT_CHECK_SIZE(ReceiverArg, 0x18); struct KeyboardArg { ConfigArg configArg; ReceiverArg receiverArg; }; -CHECK_SIZE(KeyboardArg, 0xC0); +WUT_CHECK_SIZE(KeyboardArg, 0xC0); struct InputFormArg { @@ -113,26 +113,26 @@ struct InputFormArg bool unk_0x1C = false; bool unk_0x1D = false; bool unk_0x1E = false; - PADDING(1); + WUT_PADDING_BYTES(1); }; -CHECK_OFFSET(InputFormArg, unk_0x00, 0x00); -CHECK_OFFSET(InputFormArg, unk_0x04, 0x04); -CHECK_OFFSET(InputFormArg, unk_0x08, 0x08); -CHECK_OFFSET(InputFormArg, unk_0x0C, 0x0C); -CHECK_OFFSET(InputFormArg, maxTextLength, 0x10); -CHECK_OFFSET(InputFormArg, unk_0x14, 0x14); -CHECK_OFFSET(InputFormArg, unk_0x18, 0x18); -CHECK_OFFSET(InputFormArg, unk_0x1C, 0x1C); -CHECK_OFFSET(InputFormArg, unk_0x1D, 0x1D); -CHECK_OFFSET(InputFormArg, unk_0x1E, 0x1E); -CHECK_SIZE(InputFormArg, 0x20); +WUT_CHECK_OFFSET(InputFormArg, unk_0x00, 0x00); +WUT_CHECK_OFFSET(InputFormArg, unk_0x04, 0x04); +WUT_CHECK_OFFSET(InputFormArg, unk_0x08, 0x08); +WUT_CHECK_OFFSET(InputFormArg, unk_0x0C, 0x0C); +WUT_CHECK_OFFSET(InputFormArg, maxTextLength, 0x10); +WUT_CHECK_OFFSET(InputFormArg, unk_0x14, 0x14); +WUT_CHECK_OFFSET(InputFormArg, unk_0x18, 0x18); +WUT_CHECK_OFFSET(InputFormArg, unk_0x1C, 0x1C); +WUT_CHECK_OFFSET(InputFormArg, unk_0x1D, 0x1D); +WUT_CHECK_OFFSET(InputFormArg, unk_0x1E, 0x1E); +WUT_CHECK_SIZE(InputFormArg, 0x20); struct AppearArg { KeyboardArg keyboardArg; InputFormArg inputFormArg; }; -CHECK_SIZE(AppearArg, 0xE0); +WUT_CHECK_SIZE(AppearArg, 0xE0); struct CreateArg { @@ -141,20 +141,20 @@ struct CreateArg uint32_t unk_0x08 = 0; FSClient *fsClient = nullptr; }; -CHECK_OFFSET(CreateArg, 0x00, workMemory); -CHECK_OFFSET(CreateArg, 0x04, regionType); -CHECK_OFFSET(CreateArg, 0x08, unk_0x08); -CHECK_OFFSET(CreateArg, 0x0C, fsClient); -CHECK_SIZE(CreateArg, 0x10); +WUT_CHECK_OFFSET(CreateArg, 0x00, workMemory); +WUT_CHECK_OFFSET(CreateArg, 0x04, regionType); +WUT_CHECK_OFFSET(CreateArg, 0x08, unk_0x08); +WUT_CHECK_OFFSET(CreateArg, 0x0C, fsClient); +WUT_CHECK_SIZE(CreateArg, 0x10); struct ControllerInfo { VPADStatus *vpad = nullptr; KPADStatus *kpad[4] = { nullptr, nullptr, nullptr, nullptr }; }; -CHECK_OFFSET(ControllerInfo, 0x00, vpad); -CHECK_OFFSET(ControllerInfo, 0x04, kpad); -CHECK_SIZE(ControllerInfo, 0x14); +WUT_CHECK_OFFSET(ControllerInfo, 0x00, vpad); +WUT_CHECK_OFFSET(ControllerInfo, 0x04, kpad); +WUT_CHECK_SIZE(ControllerInfo, 0x14); struct DrawStringInfo { @@ -163,18 +163,18 @@ struct DrawStringInfo memset(this, 0, sizeof(*this)); } - UNKNOWN(0x1C); + WUT_UNKNOWN_BYTES(0x1C); }; -CHECK_SIZE(DrawStringInfo, 0x1C); +WUT_CHECK_SIZE(DrawStringInfo, 0x1C); struct KeyboardCondition { uint32_t unk_0x00 = 0; uint32_t unk_0x04 = 0; }; -CHECK_OFFSET(KeyboardCondition, unk_0x00, 0x00); -CHECK_OFFSET(KeyboardCondition, unk_0x04, 0x04); -CHECK_SIZE(KeyboardCondition, 0x8); +WUT_CHECK_OFFSET(KeyboardCondition, unk_0x00, 0x00); +WUT_CHECK_OFFSET(KeyboardCondition, unk_0x04, 0x04); +WUT_CHECK_SIZE(KeyboardCondition, 0x8); struct IEventReceiver; struct IControllerEventObj; diff --git a/include/nsyshid/hid.h b/include/nsyshid/hid.h index 1507fd1..1e28407 100644 --- a/include/nsyshid/hid.h +++ b/include/nsyshid/hid.h @@ -40,29 +40,29 @@ struct HIDDevice uint8_t interfaceIndex; uint8_t subClass; uint8_t protocol; - PADDING(1); + WUT_PADDING_BYTES(1); uint16_t maxPacketSizeRx; uint16_t maxPacketSizeTx; }; -CHECK_OFFSET(HIDDevice, 0x00, handle); -CHECK_OFFSET(HIDDevice, 0x04, physicalDeviceInst); -CHECK_OFFSET(HIDDevice, 0x08, vid); -CHECK_OFFSET(HIDDevice, 0x0A, pid); -CHECK_OFFSET(HIDDevice, 0x0C, interfaceIndex); -CHECK_OFFSET(HIDDevice, 0x0D, subClass); -CHECK_OFFSET(HIDDevice, 0x0E, protocol); -CHECK_OFFSET(HIDDevice, 0x10, maxPacketSizeRx); -CHECK_OFFSET(HIDDevice, 0x12, maxPacketSizeTx); -CHECK_SIZE(HIDDevice, 0x14); +WUT_CHECK_OFFSET(HIDDevice, 0x00, handle); +WUT_CHECK_OFFSET(HIDDevice, 0x04, physicalDeviceInst); +WUT_CHECK_OFFSET(HIDDevice, 0x08, vid); +WUT_CHECK_OFFSET(HIDDevice, 0x0A, pid); +WUT_CHECK_OFFSET(HIDDevice, 0x0C, interfaceIndex); +WUT_CHECK_OFFSET(HIDDevice, 0x0D, subClass); +WUT_CHECK_OFFSET(HIDDevice, 0x0E, protocol); +WUT_CHECK_OFFSET(HIDDevice, 0x10, maxPacketSizeRx); +WUT_CHECK_OFFSET(HIDDevice, 0x12, maxPacketSizeTx); +WUT_CHECK_SIZE(HIDDevice, 0x14); struct HIDClient { HIDClient *next; HIDAttachCallback attachCallback; }; -CHECK_OFFSET(HIDClient, 0x00, next); -CHECK_OFFSET(HIDClient, 0x04, attachCallback); -CHECK_SIZE(HIDClient, 0x08); +WUT_CHECK_OFFSET(HIDClient, 0x00, next); +WUT_CHECK_OFFSET(HIDClient, 0x04, attachCallback); +WUT_CHECK_SIZE(HIDClient, 0x08); int32_t diff --git a/include/padscore/kpad.h b/include/padscore/kpad.h index 7c6dbcd..5f0c587 100644 --- a/include/padscore/kpad.h +++ b/include/padscore/kpad.h @@ -28,9 +28,9 @@ struct KPADVec2D float x; float y; }; -CHECK_OFFSET(KPADVec2D, 0x00, x); -CHECK_OFFSET(KPADVec2D, 0x04, y); -CHECK_SIZE(KPADVec2D, 0x08); +WUT_CHECK_OFFSET(KPADVec2D, 0x00, x); +WUT_CHECK_OFFSET(KPADVec2D, 0x04, y); +WUT_CHECK_SIZE(KPADVec2D, 0x08); struct KPADStatus { @@ -43,15 +43,15 @@ struct KPADStatus //! Indicates what KPADButtons have been released since last sample uint32_t release; - UNKNOWN(5 * 4); + WUT_UNKNOWN_BYTES(5 * 4); KPADVec2D pos; - UNKNOWN(3 * 4); + WUT_UNKNOWN_BYTES(3 * 4); KPADVec2D angle; - UNKNOWN(8 * 4); + WUT_UNKNOWN_BYTES(8 * 4); //! Value from KPADExtensionType uint8_t extensionType; @@ -97,39 +97,39 @@ struct KPADStatus int32_t wired; } pro; - UNKNOWN(20 * 4); + WUT_UNKNOWN_BYTES(20 * 4); }; - UNKNOWN(16 * 4); + WUT_UNKNOWN_BYTES(16 * 4); }; -CHECK_OFFSET(KPADStatus, 0x00, hold); -CHECK_OFFSET(KPADStatus, 0x04, trigger); -CHECK_OFFSET(KPADStatus, 0x08, release); -CHECK_OFFSET(KPADStatus, 0x20, pos); -CHECK_OFFSET(KPADStatus, 0x34, angle); -CHECK_OFFSET(KPADStatus, 0x5C, extensionType); -CHECK_OFFSET(KPADStatus, 0x5D, error); -CHECK_OFFSET(KPADStatus, 0x5E, posValid); -CHECK_OFFSET(KPADStatus, 0x5F, format); +WUT_CHECK_OFFSET(KPADStatus, 0x00, hold); +WUT_CHECK_OFFSET(KPADStatus, 0x04, trigger); +WUT_CHECK_OFFSET(KPADStatus, 0x08, release); +WUT_CHECK_OFFSET(KPADStatus, 0x20, pos); +WUT_CHECK_OFFSET(KPADStatus, 0x34, angle); +WUT_CHECK_OFFSET(KPADStatus, 0x5C, extensionType); +WUT_CHECK_OFFSET(KPADStatus, 0x5D, error); +WUT_CHECK_OFFSET(KPADStatus, 0x5E, posValid); +WUT_CHECK_OFFSET(KPADStatus, 0x5F, format); // For WPAD_EXT_NUNCHUK -CHECK_OFFSET(KPADStatus, 0x60, nunchuck.stick); +WUT_CHECK_OFFSET(KPADStatus, 0x60, nunchuck.stick); // For WPAD_EXT_CLASSIC -CHECK_OFFSET(KPADStatus, 0x60, classic.hold); -CHECK_OFFSET(KPADStatus, 0x64, classic.trigger); -CHECK_OFFSET(KPADStatus, 0x68, classic.release); -CHECK_OFFSET(KPADStatus, 0x6C, classic.leftStick); -CHECK_OFFSET(KPADStatus, 0x74, classic.rightStick); -CHECK_OFFSET(KPADStatus, 0x7C, classic.leftTrigger); -CHECK_OFFSET(KPADStatus, 0x80, classic.rightTrigger); +WUT_CHECK_OFFSET(KPADStatus, 0x60, classic.hold); +WUT_CHECK_OFFSET(KPADStatus, 0x64, classic.trigger); +WUT_CHECK_OFFSET(KPADStatus, 0x68, classic.release); +WUT_CHECK_OFFSET(KPADStatus, 0x6C, classic.leftStick); +WUT_CHECK_OFFSET(KPADStatus, 0x74, classic.rightStick); +WUT_CHECK_OFFSET(KPADStatus, 0x7C, classic.leftTrigger); +WUT_CHECK_OFFSET(KPADStatus, 0x80, classic.rightTrigger); // For WPAD_EXT_PRO_CONTROLLER -CHECK_OFFSET(KPADStatus, 0x60, pro.hold); -CHECK_OFFSET(KPADStatus, 0x64, pro.trigger); -CHECK_OFFSET(KPADStatus, 0x68, pro.release); -CHECK_OFFSET(KPADStatus, 0x6C, pro.leftStick); -CHECK_OFFSET(KPADStatus, 0x74, pro.rightStick); -CHECK_OFFSET(KPADStatus, 0x7C, pro.charging); -CHECK_OFFSET(KPADStatus, 0x80, pro.wired); -CHECK_SIZE(KPADStatus, 0xF0); +WUT_CHECK_OFFSET(KPADStatus, 0x60, pro.hold); +WUT_CHECK_OFFSET(KPADStatus, 0x64, pro.trigger); +WUT_CHECK_OFFSET(KPADStatus, 0x68, pro.release); +WUT_CHECK_OFFSET(KPADStatus, 0x6C, pro.leftStick); +WUT_CHECK_OFFSET(KPADStatus, 0x74, pro.rightStick); +WUT_CHECK_OFFSET(KPADStatus, 0x7C, pro.charging); +WUT_CHECK_OFFSET(KPADStatus, 0x80, pro.wired); +WUT_CHECK_SIZE(KPADStatus, 0xF0); void KPADInit(); diff --git a/include/padscore/wpad.h b/include/padscore/wpad.h index f295a27..5c22f57 100644 --- a/include/padscore/wpad.h +++ b/include/padscore/wpad.h @@ -108,32 +108,32 @@ struct WPADVec2D int16_t x; int16_t y; }; -CHECK_OFFSET(WPADVec2D, 0x00, x); -CHECK_OFFSET(WPADVec2D, 0x02, y); -CHECK_SIZE(WPADVec2D, 0x04); +WUT_CHECK_OFFSET(WPADVec2D, 0x00, x); +WUT_CHECK_OFFSET(WPADVec2D, 0x02, y); +WUT_CHECK_SIZE(WPADVec2D, 0x04); struct WPADStatusProController { - UNKNOWN(0x28); + WUT_UNKNOWN_BYTES(0x28); //! A value from WPADExtensionType uint8_t extensionType; uint8_t err; - PADDING(2); + WUT_PADDING_BYTES(2); uint32_t buttons; WPADVec2D leftStick; WPADVec2D rightStick; - UNKNOWN(8); + WUT_UNKNOWN_BYTES(8); WPADDataFormat dataFormat; }; -CHECK_OFFSET(WPADStatusProController, 0x28, extensionType); -CHECK_OFFSET(WPADStatusProController, 0x29, err); -CHECK_OFFSET(WPADStatusProController, 0x2C, buttons); -CHECK_OFFSET(WPADStatusProController, 0x30, leftStick); -CHECK_OFFSET(WPADStatusProController, 0x34, rightStick); -CHECK_OFFSET(WPADStatusProController, 0x40, dataFormat); -CHECK_SIZE(WPADStatusProController, 0x44); +WUT_CHECK_OFFSET(WPADStatusProController, 0x28, extensionType); +WUT_CHECK_OFFSET(WPADStatusProController, 0x29, err); +WUT_CHECK_OFFSET(WPADStatusProController, 0x2C, buttons); +WUT_CHECK_OFFSET(WPADStatusProController, 0x30, leftStick); +WUT_CHECK_OFFSET(WPADStatusProController, 0x34, rightStick); +WUT_CHECK_OFFSET(WPADStatusProController, 0x40, dataFormat); +WUT_CHECK_SIZE(WPADStatusProController, 0x44); typedef void (*WPADSamplingCallback)(WPADChan chan); typedef void (*WPADExtensionCallback)(WPADChan chan, int32_t status); diff --git a/include/sndcore2/core.h b/include/sndcore2/core.h index 1cfd1bd..c4f1c73 100644 --- a/include/sndcore2/core.h +++ b/include/sndcore2/core.h @@ -44,12 +44,12 @@ struct AXProfile struct AXInitParams { AXInitRenderer renderer; - UNKNOWN(4); + WUT_UNKNOWN_BYTES(4); AXInitPipeline pipeline; }; -CHECK_OFFSET(AXInitParams, 0x00, renderer); -CHECK_OFFSET(AXInitParams, 0x08, pipeline); -CHECK_SIZE(AXInitParams, 0x0C); +WUT_CHECK_OFFSET(AXInitParams, 0x00, renderer); +WUT_CHECK_OFFSET(AXInitParams, 0x08, pipeline); +WUT_CHECK_SIZE(AXInitParams, 0x0C); void AXInit(); diff --git a/include/sndcore2/voice.h b/include/sndcore2/voice.h index 4eb0def..667b712 100644 --- a/include/sndcore2/voice.h +++ b/include/sndcore2/voice.h @@ -101,9 +101,9 @@ struct AXVoiceLink AXVoice *next; AXVoice *prev; }; -CHECK_OFFSET(AXVoiceLink, 0x0, next); -CHECK_OFFSET(AXVoiceLink, 0x4, prev); -CHECK_SIZE(AXVoiceLink, 0x8); +WUT_CHECK_OFFSET(AXVoiceLink, 0x0, next); +WUT_CHECK_OFFSET(AXVoiceLink, 0x4, prev); +WUT_CHECK_SIZE(AXVoiceLink, 0x8); struct AXVoiceOffsets { @@ -114,13 +114,13 @@ struct AXVoiceOffsets uint32_t currentOffset; const void *data; }; -CHECK_OFFSET(AXVoiceOffsets, 0x0, dataType); -CHECK_OFFSET(AXVoiceOffsets, 0x2, loopingEnabled); -CHECK_OFFSET(AXVoiceOffsets, 0x4, loopOffset); -CHECK_OFFSET(AXVoiceOffsets, 0x8, endOffset); -CHECK_OFFSET(AXVoiceOffsets, 0xc, currentOffset); -CHECK_OFFSET(AXVoiceOffsets, 0x10, data); -CHECK_SIZE(AXVoiceOffsets, 0x14); +WUT_CHECK_OFFSET(AXVoiceOffsets, 0x0, dataType); +WUT_CHECK_OFFSET(AXVoiceOffsets, 0x2, loopingEnabled); +WUT_CHECK_OFFSET(AXVoiceOffsets, 0x4, loopOffset); +WUT_CHECK_OFFSET(AXVoiceOffsets, 0x8, endOffset); +WUT_CHECK_OFFSET(AXVoiceOffsets, 0xc, currentOffset); +WUT_CHECK_OFFSET(AXVoiceOffsets, 0x10, data); +WUT_CHECK_SIZE(AXVoiceOffsets, 0x14); struct AXVoice { @@ -154,7 +154,7 @@ struct AXVoice //! A bitfield representing different things needing to be synced. uint32_t syncBits; - UNKNOWN(0x8); + WUT_UNKNOWN_BYTES(0x8); //! The current offset data! AXVoiceOffsets offsets; @@ -168,56 +168,56 @@ struct AXVoice float unk0; float unk1; }; -CHECK_OFFSET(AXVoice, 0x0, index); -CHECK_OFFSET(AXVoice, 0x4, state); -CHECK_OFFSET(AXVoice, 0x8, volume); -CHECK_OFFSET(AXVoice, 0xc, renderer); -CHECK_OFFSET(AXVoice, 0x10, link); -CHECK_OFFSET(AXVoice, 0x18, cbNext); -CHECK_OFFSET(AXVoice, 0x1c, priority); -CHECK_OFFSET(AXVoice, 0x20, callback); -CHECK_OFFSET(AXVoice, 0x24, userContext); -CHECK_OFFSET(AXVoice, 0x28, syncBits); -CHECK_OFFSET(AXVoice, 0x34, offsets); -CHECK_OFFSET(AXVoice, 0x48, callbackEx); -CHECK_OFFSET(AXVoice, 0x4c, callbackReason); -CHECK_OFFSET(AXVoice, 0x50, unk0); -CHECK_OFFSET(AXVoice, 0x54, unk1); -CHECK_SIZE(AXVoice, 0x58); +WUT_CHECK_OFFSET(AXVoice, 0x0, index); +WUT_CHECK_OFFSET(AXVoice, 0x4, state); +WUT_CHECK_OFFSET(AXVoice, 0x8, volume); +WUT_CHECK_OFFSET(AXVoice, 0xc, renderer); +WUT_CHECK_OFFSET(AXVoice, 0x10, link); +WUT_CHECK_OFFSET(AXVoice, 0x18, cbNext); +WUT_CHECK_OFFSET(AXVoice, 0x1c, priority); +WUT_CHECK_OFFSET(AXVoice, 0x20, callback); +WUT_CHECK_OFFSET(AXVoice, 0x24, userContext); +WUT_CHECK_OFFSET(AXVoice, 0x28, syncBits); +WUT_CHECK_OFFSET(AXVoice, 0x34, offsets); +WUT_CHECK_OFFSET(AXVoice, 0x48, callbackEx); +WUT_CHECK_OFFSET(AXVoice, 0x4c, callbackReason); +WUT_CHECK_OFFSET(AXVoice, 0x50, unk0); +WUT_CHECK_OFFSET(AXVoice, 0x54, unk1); +WUT_CHECK_SIZE(AXVoice, 0x58); struct AXVoiceDeviceBusMixData { uint16_t volume; int16_t delta; }; -CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x0, volume); -CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x2, delta); -CHECK_SIZE(AXVoiceDeviceBusMixData, 0x4); +WUT_CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x0, volume); +WUT_CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x2, delta); +WUT_CHECK_SIZE(AXVoiceDeviceBusMixData, 0x4); struct AXVoiceDeviceMixData { AXVoiceDeviceBusMixData bus[4]; }; -CHECK_OFFSET(AXVoiceDeviceMixData, 0x0, bus); -CHECK_SIZE(AXVoiceDeviceMixData, 0x10); +WUT_CHECK_OFFSET(AXVoiceDeviceMixData, 0x0, bus); +WUT_CHECK_SIZE(AXVoiceDeviceMixData, 0x10); struct AXVoiceVeData { uint16_t volume; int16_t delta; }; -CHECK_OFFSET(AXVoiceVeData, 0x0, volume); -CHECK_OFFSET(AXVoiceVeData, 0x2, delta); -CHECK_SIZE(AXVoiceVeData, 0x4); +WUT_CHECK_OFFSET(AXVoiceVeData, 0x0, volume); +WUT_CHECK_OFFSET(AXVoiceVeData, 0x2, delta); +WUT_CHECK_SIZE(AXVoiceVeData, 0x4); struct AXVoiceAdpcmLoopData { uint16_t predScale; int16_t prevSample[2]; }; -CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x0, predScale); -CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x2, prevSample); -CHECK_SIZE(AXVoiceAdpcmLoopData, 0x6); +WUT_CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x0, predScale); +WUT_CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x2, prevSample); +WUT_CHECK_SIZE(AXVoiceAdpcmLoopData, 0x6); struct AXVoiceAdpcm { @@ -226,11 +226,11 @@ struct AXVoiceAdpcm uint16_t predScale; int16_t prevSample[2]; }; -CHECK_OFFSET(AXVoiceAdpcm, 0x0, coefficients); -CHECK_OFFSET(AXVoiceAdpcm, 0x20, gain); -CHECK_OFFSET(AXVoiceAdpcm, 0x22, predScale); -CHECK_OFFSET(AXVoiceAdpcm, 0x24, prevSample); -CHECK_SIZE(AXVoiceAdpcm, 0x28); +WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x0, coefficients); +WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x20, gain); +WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x22, predScale); +WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x24, prevSample); +WUT_CHECK_SIZE(AXVoiceAdpcm, 0x28); #pragma pack(push, 1) @@ -246,10 +246,10 @@ struct AXVoiceSrc uint16_t currentOffsetFrac; int16_t lastSample[4]; }; -CHECK_OFFSET(AXVoiceSrc, 0x0, ratio); -CHECK_OFFSET(AXVoiceSrc, 0x4, currentOffsetFrac); -CHECK_OFFSET(AXVoiceSrc, 0x6, lastSample); -CHECK_SIZE(AXVoiceSrc, 0xe); +WUT_CHECK_OFFSET(AXVoiceSrc, 0x0, ratio); +WUT_CHECK_OFFSET(AXVoiceSrc, 0x4, currentOffsetFrac); +WUT_CHECK_OFFSET(AXVoiceSrc, 0x6, lastSample); +WUT_CHECK_SIZE(AXVoiceSrc, 0xe); #pragma pack(pop) diff --git a/include/vpad/input.h b/include/vpad/input.h index 7b2294c..22618ab 100644 --- a/include/vpad/input.h +++ b/include/vpad/input.h @@ -78,9 +78,9 @@ struct VPADVec2D float x; float y; }; -CHECK_OFFSET(VPADVec2D, 0x00, x); -CHECK_OFFSET(VPADVec2D, 0x04, y); -CHECK_SIZE(VPADVec2D, 0x08); +WUT_CHECK_OFFSET(VPADVec2D, 0x00, x); +WUT_CHECK_OFFSET(VPADVec2D, 0x04, y); +WUT_CHECK_SIZE(VPADVec2D, 0x08); struct VPADVec3D { @@ -88,10 +88,10 @@ struct VPADVec3D float y; float z; }; -CHECK_OFFSET(VPADVec3D, 0x00, x); -CHECK_OFFSET(VPADVec3D, 0x04, y); -CHECK_OFFSET(VPADVec3D, 0x08, z); -CHECK_SIZE(VPADVec3D, 0x0C); +WUT_CHECK_OFFSET(VPADVec3D, 0x00, x); +WUT_CHECK_OFFSET(VPADVec3D, 0x04, y); +WUT_CHECK_OFFSET(VPADVec3D, 0x08, z); +WUT_CHECK_SIZE(VPADVec3D, 0x0C); struct VPADTouchData { @@ -104,11 +104,11 @@ struct VPADTouchData //! Bitfield of VPADTouchPadValidity to indicate how touch sample accuracy uint16_t validity; }; -CHECK_OFFSET(VPADTouchData, 0x00, x); -CHECK_OFFSET(VPADTouchData, 0x02, y); -CHECK_OFFSET(VPADTouchData, 0x04, touched); -CHECK_OFFSET(VPADTouchData, 0x06, validity); -CHECK_SIZE(VPADTouchData, 0x08); +WUT_CHECK_OFFSET(VPADTouchData, 0x00, x); +WUT_CHECK_OFFSET(VPADTouchData, 0x02, y); +WUT_CHECK_OFFSET(VPADTouchData, 0x04, touched); +WUT_CHECK_OFFSET(VPADTouchData, 0x06, validity); +WUT_CHECK_SIZE(VPADTouchData, 0x08); struct VPADAccStatus { @@ -119,8 +119,8 @@ struct VPADAccStatus float unk5; VPADVec2D vertical; }; -CHECK_OFFSET(VPADAccStatus, 0x14, vertical); -CHECK_SIZE(VPADAccStatus, 0x1c); +WUT_CHECK_OFFSET(VPADAccStatus, 0x14, vertical); +WUT_CHECK_SIZE(VPADAccStatus, 0x1c); struct VPADGyroStatus { @@ -131,7 +131,7 @@ struct VPADGyroStatus float unk5; float unk6; }; -CHECK_SIZE(VPADGyroStatus, 0x18); +WUT_CHECK_SIZE(VPADGyroStatus, 0x18); struct VPADStatus { @@ -156,7 +156,7 @@ struct VPADStatus //! Status of DRC gyro VPADGyroStatus gyro; - UNKNOWN(2); + WUT_UNKNOWN_BYTES(2); //! Current touch position on DRC VPADTouchData tpNormal; @@ -167,7 +167,7 @@ struct VPADStatus //! Filtered touch position, second level of smoothing VPADTouchData tpFiltered2; - UNKNOWN(0x28); + WUT_UNKNOWN_BYTES(0x28); //! Status of DRC magnetometer VPADVec3D mag; @@ -184,24 +184,24 @@ struct VPADStatus //! Unknown volume related value uint8_t slideVolumeEx; - UNKNOWN(0x7); + WUT_UNKNOWN_BYTES(0x7); }; -CHECK_OFFSET(VPADStatus, 0x00, hold); -CHECK_OFFSET(VPADStatus, 0x04, trigger); -CHECK_OFFSET(VPADStatus, 0x08, release); -CHECK_OFFSET(VPADStatus, 0x0C, leftStick); -CHECK_OFFSET(VPADStatus, 0x14, rightStick); -CHECK_OFFSET(VPADStatus, 0x1C, accelorometer); -CHECK_OFFSET(VPADStatus, 0x38, gyro); -CHECK_OFFSET(VPADStatus, 0x52, tpNormal); -CHECK_OFFSET(VPADStatus, 0x5A, tpFiltered1); -CHECK_OFFSET(VPADStatus, 0x62, tpFiltered2); -CHECK_OFFSET(VPADStatus, 0x94, mag); -CHECK_OFFSET(VPADStatus, 0xA0, slideVolume); -CHECK_OFFSET(VPADStatus, 0xA1, battery); -CHECK_OFFSET(VPADStatus, 0xA2, micStatus); -CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx); -CHECK_SIZE(VPADStatus, 0xAC); +WUT_CHECK_OFFSET(VPADStatus, 0x00, hold); +WUT_CHECK_OFFSET(VPADStatus, 0x04, trigger); +WUT_CHECK_OFFSET(VPADStatus, 0x08, release); +WUT_CHECK_OFFSET(VPADStatus, 0x0C, leftStick); +WUT_CHECK_OFFSET(VPADStatus, 0x14, rightStick); +WUT_CHECK_OFFSET(VPADStatus, 0x1C, accelorometer); +WUT_CHECK_OFFSET(VPADStatus, 0x38, gyro); +WUT_CHECK_OFFSET(VPADStatus, 0x52, tpNormal); +WUT_CHECK_OFFSET(VPADStatus, 0x5A, tpFiltered1); +WUT_CHECK_OFFSET(VPADStatus, 0x62, tpFiltered2); +WUT_CHECK_OFFSET(VPADStatus, 0x94, mag); +WUT_CHECK_OFFSET(VPADStatus, 0xA0, slideVolume); +WUT_CHECK_OFFSET(VPADStatus, 0xA1, battery); +WUT_CHECK_OFFSET(VPADStatus, 0xA2, micStatus); +WUT_CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx); +WUT_CHECK_SIZE(VPADStatus, 0xAC); //! Deprecated void diff --git a/include/wut_structsize.h b/include/wut_structsize.h index ff1611f..f661235 100644 --- a/include/wut_structsize.h +++ b/include/wut_structsize.h @@ -4,29 +4,27 @@ // Ensure structs are correct size & offsets #if defined(static_assert) -# define CHECK_SIZE(Type, Size) \ +# define WUT_CHECK_SIZE(Type, Size) \ static_assert(sizeof(Type) == Size, \ #Type " must be " #Size " bytes") -# define CHECK_OFFSET(Type, Offset, Field) \ +# define WUT_CHECK_OFFSET(Type, Offset, Field) \ static_assert(offsetof(Type, Field) == Offset, \ #Type "::" #Field " must be at offset " #Offset) #else -# define CHECK_SIZE(Type, Size) -# define CHECK_OFFSET(Type, Offset, Field) +# define WUT_CHECK_SIZE(Type, Size) +# define WUT_CHECK_OFFSET(Type, Offset, Field) #endif // Workaround weird macro concat ## behaviour -#define PP_CAT(a, b) PP_CAT_I(a, b) -#define PP_CAT_I(a, b) PP_CAT_II(~, a ## b) -#define PP_CAT_II(p, res) res +#define WUT_PP_CAT(a, b) WUT_PP_CAT_I(a, b) +#define WUT_PP_CAT_I(a, b) WUT_PP_CAT_II(~, a ## b) +#define WUT_PP_CAT_II(p, res) res // Allow us to easily add UNKNOWN / PADDING bytes into our structs, // generates unique variable names using __COUNTER__ -#define UNKNOWN(Size) char PP_CAT(__unk, __COUNTER__) [Size] -#define PADDING(Size) UNKNOWN(Size) +#define WUT_UNKNOWN_BYTES(Size) char WUT_PP_CAT(__unk, __COUNTER__) [Size] +#define WUT_PADDING_BYTES(Size) WUT_UNKNOWN_BYTES(Size) -// Just some placeholder defines -#define UNKNOWN_ARG uint32_t -#define UNKNOWN_ARGS void -#define UNKNOWN_SIZE(x) +//! Unknown struct size +#define WUT_UNKNOWN_SIZE(x) diff --git a/libraries/libgfd/include/gfd.h b/libraries/libgfd/include/gfd.h index b0758b2..4610699 100644 --- a/libraries/libgfd/include/gfd.h +++ b/libraries/libgfd/include/gfd.h @@ -52,15 +52,15 @@ struct GFDHeader uint32_t unk1; uint32_t unk2; }; -CHECK_OFFSET(GFDHeader, 0x00, magic); -CHECK_OFFSET(GFDHeader, 0x04, headerSize); -CHECK_OFFSET(GFDHeader, 0x08, majorVersion); -CHECK_OFFSET(GFDHeader, 0x0C, minorVersion); -CHECK_OFFSET(GFDHeader, 0x10, gpuVersion); -CHECK_OFFSET(GFDHeader, 0x14, align); -CHECK_OFFSET(GFDHeader, 0x18, unk1); -CHECK_OFFSET(GFDHeader, 0x1C, unk2); -CHECK_SIZE(GFDHeader, 0x20); +WUT_CHECK_OFFSET(GFDHeader, 0x00, magic); +WUT_CHECK_OFFSET(GFDHeader, 0x04, headerSize); +WUT_CHECK_OFFSET(GFDHeader, 0x08, majorVersion); +WUT_CHECK_OFFSET(GFDHeader, 0x0C, minorVersion); +WUT_CHECK_OFFSET(GFDHeader, 0x10, gpuVersion); +WUT_CHECK_OFFSET(GFDHeader, 0x14, align); +WUT_CHECK_OFFSET(GFDHeader, 0x18, unk1); +WUT_CHECK_OFFSET(GFDHeader, 0x1C, unk2); +WUT_CHECK_SIZE(GFDHeader, 0x20); struct GFDBlockHeader { @@ -73,15 +73,15 @@ struct GFDBlockHeader uint32_t id; uint32_t index; }; -CHECK_OFFSET(GFDBlockHeader, 0x00, magic); -CHECK_OFFSET(GFDBlockHeader, 0x04, headerSize); -CHECK_OFFSET(GFDBlockHeader, 0x08, majorVersion); -CHECK_OFFSET(GFDBlockHeader, 0x0C, minorVersion); -CHECK_OFFSET(GFDBlockHeader, 0x10, type); -CHECK_OFFSET(GFDBlockHeader, 0x14, dataSize); -CHECK_OFFSET(GFDBlockHeader, 0x18, id); -CHECK_OFFSET(GFDBlockHeader, 0x1C, index); -CHECK_SIZE(GFDHeader, 0x20); +WUT_CHECK_OFFSET(GFDBlockHeader, 0x00, magic); +WUT_CHECK_OFFSET(GFDBlockHeader, 0x04, headerSize); +WUT_CHECK_OFFSET(GFDBlockHeader, 0x08, majorVersion); +WUT_CHECK_OFFSET(GFDBlockHeader, 0x0C, minorVersion); +WUT_CHECK_OFFSET(GFDBlockHeader, 0x10, type); +WUT_CHECK_OFFSET(GFDBlockHeader, 0x14, dataSize); +WUT_CHECK_OFFSET(GFDBlockHeader, 0x18, id); +WUT_CHECK_OFFSET(GFDBlockHeader, 0x1C, index); +WUT_CHECK_SIZE(GFDHeader, 0x20); struct GFDRelocationHeader { @@ -96,17 +96,17 @@ struct GFDRelocationHeader uint32_t patchCount; uint32_t patchOffset; }; -CHECK_OFFSET(GFDRelocationHeader, 0x00, magic); -CHECK_OFFSET(GFDRelocationHeader, 0x04, headerSize); -CHECK_OFFSET(GFDRelocationHeader, 0x08, unk1); -CHECK_OFFSET(GFDRelocationHeader, 0x0C, dataSize); -CHECK_OFFSET(GFDRelocationHeader, 0x10, dataOffset); -CHECK_OFFSET(GFDRelocationHeader, 0x14, textSize); -CHECK_OFFSET(GFDRelocationHeader, 0x18, textOffset); -CHECK_OFFSET(GFDRelocationHeader, 0x1C, patchBase); -CHECK_OFFSET(GFDRelocationHeader, 0x20, patchCount); -CHECK_OFFSET(GFDRelocationHeader, 0x24, patchOffset); -CHECK_SIZE(GFDRelocationHeader, 0x28); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x00, magic); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x04, headerSize); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x08, unk1); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x0C, dataSize); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x10, dataOffset); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x14, textSize); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x18, textOffset); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x1C, patchBase); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x20, patchCount); +WUT_CHECK_OFFSET(GFDRelocationHeader, 0x24, patchOffset); +WUT_CHECK_SIZE(GFDRelocationHeader, 0x28); char * GFDGetLastErrorString(); diff --git a/libraries/wutdevoptab_sd/devoptab_sd.h b/libraries/wutdevoptab_sd/devoptab_sd.h index 0defcbf..7a36faa 100644 --- a/libraries/wutdevoptab_sd/devoptab_sd.h +++ b/libraries/wutdevoptab_sd/devoptab_sd.h @@ -34,7 +34,7 @@ typedef struct typedef struct { //! Should be set to FS_DIRITER_MAGIC - u32 magic; + uint32_t magic; //! FS handle FSDirectoryHandle fd;