The-Homebrew-Cloud/wut
2
0
Fork 0
mirror of https://github.com/wiiu-env/wut.git synced 2024-06-02 23:08:47 +02:00
Code Issues Packages Projects Releases Wiki Activity

Prefix structsize macros with WUT_

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

10
docs/CMakeLists.txt
View File

@ -23,11 +23,11 @@ if(DOXYGEN_FOUND)
set(DOXYGEN_EXCLUDE_PATTERNS
"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)

52
include/coreinit/alarm.h
View File

@ -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);
/**

10
include/coreinit/condition.h
View File

@ -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);
/**

54
include/coreinit/context.h
View File

@ -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
}

20
include/coreinit/coroutine.h
View File

@ -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,

14
include/coreinit/event.h
View File

@ -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);
/**

10
include/coreinit/fastcondition.h
View File

@ -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,

20
include/coreinit/fastmutex.h
View File

@ -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,

36
include/coreinit/filesystem.h
View File

@ -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();

8
include/coreinit/ios.h
View File

@ -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 *);

26
include/coreinit/mcp.h
View File

@ -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();

36
include/coreinit/memblockheap.h
View File

@ -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,

32
include/coreinit/memexpheap.h
View File

@ -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,

20
include/coreinit/memfrmheap.h
View File

@ -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,

18
include/coreinit/memheap.h
View File

@ -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);
/**

16
include/coreinit/memlist.h
View File

@ -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,

12
include/coreinit/memunitheap.h
View File

@ -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,

26
include/coreinit/messagequeue.h
View File

@ -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,

22
include/coreinit/mutex.h
View File

@ -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);
/**

6
include/coreinit/rendezvous.h
View File

@ -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);

12
include/coreinit/semaphore.h
View File

@ -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);
/**

10
include/coreinit/spinlock.h
View File

@ -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);

10
include/coreinit/systeminfo.h
View File

@ -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();

76
include/coreinit/taskqueue.h
View File

@ -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,

82
include/coreinit/thread.h
View File

@ -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);
/**

22
include/coreinit/threadqueue.h
View File

@ -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);

22
include/coreinit/time.h
View File

@ -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)

32
include/gx2/context.h
View File

@ -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,

12
include/gx2/event.h
View File

@ -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();

108
include/gx2/registers.h
View File

@ -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,

2
include/gx2/sampler.h
View File

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

258
include/gx2/shaders.h
View File

@ -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);

70
include/gx2/surface.h
View File

@ -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);

16
include/gx2/texture.h
View File

@ -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);

10
include/gx2r/buffer.h
View File

@ -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);

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

@ -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;

28
include/nsyshid/hid.h
View File

@ -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

66
include/padscore/kpad.h
View File

@ -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();

26
include/padscore/wpad.h
View File

@ -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);

8
include/sndcore2/core.h
View File

@ -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();

94
include/sndcore2/voice.h
View File

@ -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)

68
include/vpad/input.h
View File

@ -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

24
include/wut_structsize.h
View File

@ -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)

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

@ -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();

2
libraries/wutdevoptab_sd/devoptab_sd.h
View File

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