ninjdai/pokeemerald
1
0
Fork 0
mirror of https://github.com/Ninjdai1/pokeemerald.git synced 2024-09-29 01:04:28 +02:00
Code Issues Packages Projects Releases Wiki Activity
b839c21307
pokeemerald/include/gba/macro.h

221 lines
11 KiB
C
Raw Normal View History

reorganize headers and add CpuFill macros
2016-01-08 21:49:23 +01:00
#ifndef GUARD_GBA_MACRO_H
#define GUARD_GBA_MACRO_H
Ported task.c and others from pokeruby
2016-10-31 09:14:22 +01:00
#define CPU_FILL(value, dest, size, bit) \
{ \
reorganize headers and add CpuFill macros
2016-01-08 21:49:23 +01:00
vu##bit tmp = (vu##bit)(value); \
CpuSet((void *)&tmp, \
dest, \
CPU_SET_##bit##BIT | CPU_SET_SRC_FIXED | ((size)/(bit/8) & 0x1FFFFF)); \
Ported task.c and others from pokeruby
2016-10-31 09:14:22 +01:00
}
reorganize headers and add CpuFill macros
2016-01-08 21:49:23 +01:00
Ported task.c and others from pokeruby
2016-10-31 09:14:22 +01:00
#define CpuFill16(value, dest, size) CPU_FILL(value, dest, size, 16)
#define CpuFill32(value, dest, size) CPU_FILL(value, dest, size, 32)
#define CPU_COPY(src, dest, size, bit) CpuSet(src, dest, CPU_SET_##bit##BIT | ((size)/(bit/8) & 0x1FFFFF))
#define CpuCopy16(src, dest, size) CPU_COPY(src, dest, size, 16)
#define CpuCopy32(src, dest, size) CPU_COPY(src, dest, size, 32)
#define CpuFastFill(value, dest, size) \
{ \
vu32 tmp = (vu32)(value); \
CpuFastSet((void *)&tmp, \
dest, \
CPU_FAST_SET_SRC_FIXED | ((size)/(32/8) & 0x1FFFFF)); \
}
decompile multiboot
2017-01-14 02:40:03 +01:00
#define CpuFastFill16(value, dest, size) CpuFastFill(((value) << 16) | (value), (dest), (size))
Begin disassembling window.s
2017-03-30 02:02:15 +02:00
#define CpuFastFill8(value, dest, size) CpuFastFill(((value) << 24) | ((value) << 16) | ((value) << 8) | (value), (dest), (size))
Ported task.c and others from pokeruby
2016-10-31 09:14:22 +01:00
#define CpuFastCopy(src, dest, size) CpuFastSet(src, dest, ((size)/(32/8) & 0x1FFFFF))
#define DmaSet(dmaNum, src, dest, control) \
{ \
vu32 *dmaRegs = (vu32 *)REG_ADDR_DMA##dmaNum; \
dmaRegs[0] = (vu32)(src); \
dmaRegs[1] = (vu32)(dest); \
dmaRegs[2] = (vu32)(control); \
dmaRegs[2]; \
}
#define DMA_FILL(dmaNum, value, dest, size, bit) \
{ \
vu##bit tmp = (vu##bit)(value); \
DmaSet(dmaNum, \
&tmp, \
dest, \
(DMA_ENABLE | DMA_START_NOW | DMA_##bit##BIT | DMA_SRC_FIXED | DMA_DEST_INC) << 16 \
| ((size)/(bit/8))); \
}
#define DmaFill16(dmaNum, value, dest, size) DMA_FILL(dmaNum, value, dest, size, 16)
#define DmaFill32(dmaNum, value, dest, size) DMA_FILL(dmaNum, value, dest, size, 32)
// Note that the DMA clear macros cause the DMA control value to be calculated
// at runtime rather than compile time. The size is divided by the DMA transfer
// unit size (2 or 4 bytes) and then combined with the DMA control flags using a
// bitwise OR operation.
#define DMA_CLEAR(dmaNum, dest, size, bit) \
{ \
vu##bit *_dest = (vu##bit *)(dest); \
u32 _size = size; \
DmaFill##bit(dmaNum, 0, _dest, _size); \
}
#define DmaClear16(dmaNum, dest, size) DMA_CLEAR(dmaNum, dest, size, 16)
#define DmaClear32(dmaNum, dest, size) DMA_CLEAR(dmaNum, dest, size, 32)
#define DMA_COPY(dmaNum, src, dest, size, bit) \
DmaSet(dmaNum, \
src, \
dest, \
(DMA_ENABLE | DMA_START_NOW | DMA_##bit##BIT | DMA_SRC_INC | DMA_DEST_INC) << 16 \
| ((size)/(bit/8)))
#define DmaCopy16(dmaNum, src, dest, size) DMA_COPY(dmaNum, src, dest, size, 16)
#define DmaCopy32(dmaNum, src, dest, size) DMA_COPY(dmaNum, src, dest, size, 32)
LoadWallClockGraphics
2017-11-25 00:00:26 +01:00
#define DmaCopyLarge(dmaNum, src, dest, size, block, bit) \
{ \
const void *_src = src; \
void *_dest = dest; \
u32 _size = size; \
while (1) \
{ \
DmaCopy##bit(dmaNum, _src, _dest, (block)); \
_src += (block); \
_dest += (block); \
_size -= (block); \
if (_size <= (block)) \
{ \
DmaCopy##bit(dmaNum, _src, _dest, _size); \
break; \
} \
} \
}
#define DmaCopyLarge16(dmaNum, src, dest, size, block) DmaCopyLarge(dmaNum, src, dest, size, block, 16)
#define DmaCopyLarge32(dmaNum, src, dest, size, block) DmaCopyLarge(dmaNum, src, dest, size, block, 32)
#define DmaFillLarge(dmaNum, value, dest, size, block, bit) \
{ \
void *_dest = dest; \
u32 _size = size; \
while (1) \
{ \
DmaFill##bit(dmaNum, value, _dest, (block)); \
_dest += (block); \
_size -= (block); \
if (_size <= (block)) \
{ \
DmaFill##bit(dmaNum, value, _dest, _size); \
break; \
} \
} \
}
#define DmaFillLarge16(dmaNum, value, dest, size, block) DmaFillLarge(dmaNum, value, dest, size, block, 16)
#define DmaFillLarge32(dmaNum, value, dest, size, block) DmaFillLarge(dmaNum, value, dest, size, block, 32)
Decompile naming_screen.c
2018-01-24 04:30:13 +01:00
#define DmaClearLarge(dmaNum, dest, size, block, bit) \
{ \
void *_dest = dest; \
u32 _size = size; \
while (1) \
{ \
DmaFill##bit(dmaNum, 0, _dest, (block)); \
_dest += (block); \
_size -= (block); \
if (_size <= (block)) \
{ \
DmaFill##bit(dmaNum, 0, _dest, _size); \
break; \
} \
} \
}
#define DmaClearLarge16(dmaNum, dest, size, block) DmaClearLarge(dmaNum, dest, size, block, 16)
#define DmaClearLarge32(dmaNum, dest, size, block) DmaClearLarge(dmaNum, dest, size, block, 32)
LoadWallClockGraphics
2017-11-25 00:00:26 +01:00
#define DmaCopyDefvars(dmaNum, src, dest, size, bit) \
{ \
const void *_src = src; \
void *_dest = dest; \
u32 _size = size; \
DmaCopy##bit(dmaNum, _src, _dest, _size); \
}
#define DmaCopy16Defvars(dmaNum, src, dest, size) DmaCopyDefvars(dmaNum, src, dest, size, 16)
#define DmaCopy32Defvars(dmaNum, src, dest, size) DmaCopyDefvars(dmaNum, src, dest, size, 32)
#define DmaFillDefvars(dmaNum, value, dest, size, bit) \
{ \
void *_dest = dest; \
u32 _size = size; \
DmaFill##bit(dmaNum, value, _dest, _size); \
}
#define DmaFill16Defvars(dmaNum, value, dest, size) DmaFillDefvars(dmaNum, value, dest, size, 16)
#define DmaFill32Defvars(dmaNum, value, dest, size) DmaFillDefvars(dmaNum, value, dest, size, 32)
#define DmaClearDefvars(dmaNum, dest, size, bit) \
{ \
void *_dest = dest; \
u32 _size = size; \
DmaClear##bit(dmaNum, _dest, _size); \
}
#define DmaClear16Defvars(dmaNum, dest, size) DmaClearDefvars(dmaNum, dest, size, 16)
#define DmaClear32Defvars(dmaNum, dest, size) DmaClearDefvars(dmaNum, dest, size, 32)
Ported task.c and others from pokeruby
2016-10-31 09:14:22 +01:00
#define DmaStop(dmaNum) \
{ \
vu16 *dmaRegs = (vu16 *)REG_ADDR_DMA##dmaNum; \
dmaRegs[5] &= ~(DMA_START_MASK | DMA_DREQ_ON | DMA_REPEAT); \
dmaRegs[5] &= ~DMA_ENABLE; \
dmaRegs[5]; \
}
reorganize headers and add CpuFill macros
2016-01-08 21:49:23 +01:00
Begin librfu decompilation
2017-09-07 08:51:59 +02:00
#define IntrEnable(flags) \
{ \
u16 imeTemp; \
\
imeTemp = REG_IME; \
REG_IME = 0; \
REG_IE |= flags; \
REG_IME = imeTemp; \
} \
Modernize code Can compile with arm-none-eabi-gcc 8.3.0 gbafix correctly handles ELF input
2019-06-26 14:13:38 +02:00
#if MODERN
#define FLOAT_UNS(x, bit) ({ \
s##bit sx = x; \
float fx = (float)sx; \
if (sx < 0) fx += (1 << (bit - 1)) * 2.0f; \
fx; \
})
#define DOUBLE_UNS(x, bit) ({ \
s##bit sx = x; \
double dx = (double)sx; \
if (sx < 0) dx += (1 << (bit - 1)) * 2.0; \
dx; \
})
#else
#define FLOAT_UNS(x, bit) ((float)(x))
#define DOUBLE_UNS(x, bit) ((double)(x))
#endif //MODERN
#define FLOAT_U8(x) FLOAT_UNS(x, 8)
#define FLOAT_U16(x) FLOAT_UNS(x, 16)
#define FLOAT_U32(x) FLOAT_UNS(x, 32)
#define DOUBLE_U8(x) DOUBLE_UNS(x, 8)
#define DOUBLE_U16(x) DOUBLE_UNS(x, 16)
#define DOUBLE_U32(x) DOUBLE_UNS(x, 32)
reorganize headers and add CpuFill macros
2016-01-08 21:49:23 +01:00
#endif // GUARD_GBA_MACRO_H
Copy Permalink