From 05149e41ad7486281ed3d65f7f5dd1f25fe930ae Mon Sep 17 00:00:00 2001 From: James Benton Date: Fri, 8 Jan 2016 16:38:38 +0000 Subject: [PATCH] Add lots of GX2 functions. --- include/gx2/clear.h | 77 +++++ include/gx2/context.h | 59 ++++ include/gx2/display.h | 93 ++++++ include/gx2/displaylist.h | 45 +++ include/gx2/draw.h | 57 ++++ include/gx2/event.h | 76 +++++ include/gx2/registers.h | 657 ++++++++++++++++++++++++++++++++++++++ include/gx2/sampler.h | 132 ++++++++ include/gx2/surface.h | 292 +++++++++++++++++ include/gx2/swap.h | 48 +++ include/gx2/texture.h | 56 ++++ rpl/libgx2/exports.h | 162 +++++++++- 12 files changed, 1753 insertions(+), 1 deletion(-) create mode 100644 include/gx2/clear.h create mode 100644 include/gx2/context.h create mode 100644 include/gx2/display.h create mode 100644 include/gx2/displaylist.h create mode 100644 include/gx2/draw.h create mode 100644 include/gx2/event.h create mode 100644 include/gx2/registers.h create mode 100644 include/gx2/sampler.h create mode 100644 include/gx2/surface.h create mode 100644 include/gx2/swap.h create mode 100644 include/gx2/texture.h diff --git a/include/gx2/clear.h b/include/gx2/clear.h new file mode 100644 index 0000000..cbe9b34 --- /dev/null +++ b/include/gx2/clear.h @@ -0,0 +1,77 @@ +#pragma once +#include + +/** + * \defgroup gx2_clear Clear + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct GX2ColorBuffer GX2ColorBuffer; +typedef struct GX2DepthBuffer GX2DepthBuffer; + +typedef enum GX2ClearFlags +{ + GX2_CLEAR_FLAGS_DEPTH = 1, + GX2_CLEAR_FLAGS_STENCIL = 2, +} GX2ClearFlags; + +void +GX2ClearColor(GX2ColorBuffer *colorBuffer, + float red, + float green, + float blue, + float alpha); + +void +GX2ClearDepthStencil(GX2DepthBuffer *depthBuffer, + GX2ClearFlags clearMode); + +void +GX2ClearDepthStencilEx(GX2DepthBuffer *depthBuffer, + float depth, + uint8_t stencil, + GX2ClearFlags clearMode); + +void +GX2ClearBuffers(GX2ColorBuffer *colorBuffer, + GX2DepthBuffer *depthBuffer, + float red, + float green, + float blue, + float alpha, + GX2ClearFlags clearMode); + +void +GX2ClearBuffersEx(GX2ColorBuffer *colorBuffer, + GX2DepthBuffer *depthBuffer, + float red, + float green, + float blue, + float alpha, + float depth, + uint8_t stencil, + GX2ClearFlags clearMode); + +void +GX2SetClearDepth(GX2DepthBuffer *depthBuffer, + float depth); + +void +GX2SetClearStencil(GX2DepthBuffer *depthBuffer, + uint8_t stencil); + +void +GX2SetClearDepthStencil(GX2DepthBuffer *depthBuffer, + float depth, + uint8_t stencil); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/context.h b/include/gx2/context.h new file mode 100644 index 0000000..3251875 --- /dev/null +++ b/include/gx2/context.h @@ -0,0 +1,59 @@ +#pragma once +#include + +/** + * \defgroup gx2_context Context State + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +struct GX2ShadowState +{ + uint32_t config[0xB00]; + uint32_t context[0x400]; + uint32_t alu[0x800]; + uint32_t loop[0x60]; + PADDING((0x80 - 0x60) * 4); + uint32_t resource[0xD9E]; + PADDING((0xDC0 - 0xD9E) * 4); + uint32_t sampler[0xA2]; + PADDING((0xC0 - 0xA2) * 4); +}; + +struct GX2ContextState +{ + GX2ShadowState shadowState; + UNKNOWN(4); + uint32_t shadowDisplayListSize; + UNKNOWN(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); + +void +GX2SetupContextStateEx(GX2ContextState *state, + BOOL unk1); + +void +GX2GetContextStateDisplayList(GX2ContextState *state, + void *outDisplayList, + uint32_t *outSize); + +void +GX2SetContextState(GX2ContextState *state); + +void +GX2SetDefaultState(); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/display.h b/include/gx2/display.h new file mode 100644 index 0000000..fb355b8 --- /dev/null +++ b/include/gx2/display.h @@ -0,0 +1,93 @@ +#pragma once +#include +#include "surface.h" + +/** + * \defgroup gx2_display Display + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum GX2TVRenderMode +{ + GX2_TV_RENDER_MODE_STANDARD_480P = 1, + GX2_TV_RENDER_MODE_WIDE_480P = 2, + GX2_TV_RENDER_MODE_WIDE_720P = 3, + GX2_TV_RENDER_MODE_WIDE_1080P = 5, +} GX2TVRenderMode; + +typedef enum GX2DrcRenderMode +{ + GX2_DRC_RENDER_MODE_DISABLED = 0, + GX2_DRC_RENDER_MODE_SINGLE = 1, +} GX2DrcRenderMode; + +typedef enum GX2BufferingMode +{ + GX2_BUFFERING_MODE_SINGLE = 1, + GX2_BUFFERING_MODE_DOUBLE = 2, + GX2_BUFFERING_MODE_TRIPLE = 3, +} GX2BufferingMode; + +typedef enum GX2TVScanMode +{ + GX2_TV_SCAN_MODE_NONE = 0, +} GX2TVScanMode; + +void +GX2SetTVEnable(BOOL enable); + +void +GX2SetDRCEnable(BOOL enable); + +void +GX2CalcTVSize(GX2TVRenderMode tvRenderMode, + GX2SurfaceFormat surfaceFormat, + GX2BufferingMode bufferingMode, + uint32_t *size, + uint32_t *unkOut); + +void +GX2CalcDRCSize(GX2DrcRenderMode drcRenderMode, + GX2SurfaceFormat surfaceFormat, + GX2BufferingMode bufferingMode, + uint32_t *size, + uint32_t *unkOut); + +void +GX2SetTVBuffer(void *buffer, + uint32_t size, + GX2TVRenderMode tvRenderMode, + GX2SurfaceFormat surfaceFormat, + GX2BufferingMode bufferingMode); + +void +GX2SetDRCBuffer(void *buffer, + uint32_t size, + GX2DrcRenderMode drcRenderMode, + GX2SurfaceFormat surfaceFormat, + GX2BufferingMode bufferingMode); + +void +GX2SetTVScale(uint32_t x, + uint32_t y); + +void +GX2SetDRCScale(uint32_t x, + uint32_t y); + +GX2TVScanMode +GX2GetSystemTVScanMode(); + +GX2DrcRenderMode +GX2GetSystemDRCMode(); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/displaylist.h b/include/gx2/displaylist.h new file mode 100644 index 0000000..eb6ab5d --- /dev/null +++ b/include/gx2/displaylist.h @@ -0,0 +1,45 @@ +#pragma once +#include + +/** + * \defgroup gx2_displaylist Display List + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +void +GX2BeginDisplayListEx(void *displayList, + uint32_t bytes, + BOOL unk1); + +uint32_t +GX2EndDisplayList(void *displayList); + +void +GX2DirectCallDisplayList(void *displayList, + uint32_t bytes); + +void +GX2CallDisplayList(void *displayList, + uint32_t bytes); + +BOOL +GX2GetDisplayListWriteStatus(); + +BOOL +GX2GetCurrentDisplayList(void **outDisplayList, + uint32_t *outSize); + +void +GX2CopyDisplayList(void *displayList, + uint32_t bytes); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/draw.h b/include/gx2/draw.h new file mode 100644 index 0000000..c2659a0 --- /dev/null +++ b/include/gx2/draw.h @@ -0,0 +1,57 @@ +#pragma once +#include + +/** + * \defgroup gx2_draw Draw + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum GX2PrimitiveMode +{ + GX2_PRIMITIVE_MODE_TRIANGLES = 4, + GX2_PRIMITIVE_MODE_TRIANGLE_STRIP = 6, + GX2_PRIMITIVE_MODE_QUADS = 19, + GX2_PRIMITIVE_MODE_QUAD_STRIP = 20, +} GX2PrimitiveMode; + +typedef enum GX2IndexType +{ + GX2_INDEX_TYPE_U16_LE = 0, + GX2_INDEX_TYPE_U32_LE = 1, + GX2_INDEX_TYPE_U16 = 4, + GX2_INDEX_TYPE_U32 = 9, +} GX2IndexType; + +void +GX2SetAttribBuffer(uint32_t index, + uint32_t size, + uint32_t stride, + void *buffer); + +void +GX2DrawEx(GX2PrimitiveMode mode, + uint32_t numVertices, + uint32_t offset, + uint32_t numInstances); + +void +GX2DrawIndexedEx(GX2PrimitiveMode mode, + uint32_t numVertices, + GX2IndexType indexType, + void *indices, + uint32_t offset, + uint32_t numInstances); + +void +GX2SetPrimitiveRestartIndex(uint32_t index); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/event.h b/include/gx2/event.h new file mode 100644 index 0000000..5aad7b1 --- /dev/null +++ b/include/gx2/event.h @@ -0,0 +1,76 @@ +#pragma once +#include +#include + +/** + * \defgroup gx2_event Event + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum GX2EventType +{ + GX2_EVENT_TYPE_VSYNC = 2, + GX2_EVENT_TYPE_FLIP = 3, + GX2_EVENT_TYPE_DISPLAY_LIST_OVERRUN = 4, +} GX2EventType; + +typedef void (*GX2EventCallbackFunction)(GX2EventType, void *); + +struct GX2DisplayListOverrunData +{ + void *oldList; + uint32_t oldSize; + void *newList; + uint32_t newSize; + UNKNOWN(8); +}; +CHECK_OFFSET(GX2DisplayListOverrunData, 0x00, oldList); +CHECK_OFFSET(GX2DisplayListOverrunData, 0x04, oldSize); +CHECK_OFFSET(GX2DisplayListOverrunData, 0x08, newList); +CHECK_OFFSET(GX2DisplayListOverrunData, 0x0C, newSize); +CHECK_SIZE(GX2DisplayListOverrunData, 0x18); + +BOOL +GX2DrawDone(); + +void +GX2WaitForVsync(); + +void +GX2WaitForFlip(); + +void +GX2SetEventCallback(GX2EventType type, + GX2EventCallbackFunction func, + void *userData); + +void +GX2GetEventCallback(GX2EventType type, + GX2EventCallbackFunction *funcOut, + void **userDataOut); + +OSTime +GX2GetRetiredTimeStamp(); + +OSTime +GX2GetLastSubmittedTimeStamp(); + +BOOL +GX2WaitTimeStamp(OSTime time); + +void +GX2GetSwapStatus(uint32_t *swapCount, + uint32_t *flipCount, + OSTime *lastFlip, + OSTime *lastVsync); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/registers.h b/include/gx2/registers.h new file mode 100644 index 0000000..d6b8f0b --- /dev/null +++ b/include/gx2/registers.h @@ -0,0 +1,657 @@ +#pragma once +#include + +/** + * \defgroup gx2_displaylist Display List + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum GX2CompareFunction +{ + GX2_COMPARE_FUNC_NEVER = 0, + GX2_COMPARE_FUNC_LESS = 1, + GX2_COMPARE_FUNC_EQUAL = 2, + GX2_COMPARE_FUNC_LEQUAL = 3, + GX2_COMPARE_FUNC_GREATER = 4, + GX2_COMPARE_FUNC_NOT_EQUAL = 5, + GX2_COMPARE_FUNC_GEQUAL = 6, + GX2_COMPARE_FUNC_ALWAYS = 7, +} GX2CompareFunction; + +typedef enum GX2AlphaToMaskMode +{ + GX2_ALPHA_TO_MASK_MODE_NON_DITHERED = 0, + GX2_ALPHA_TO_MASK_MODE_DITHER_0 = 1, + GX2_ALPHA_TO_MASK_MODE_DITHER_90 = 2, + GX2_ALPHA_TO_MASK_MODE_DITHER_180 = 3, + GX2_ALPHA_TO_MASK_MODE_DITHER_270 = 4, +} GX2AlphaToMaskMode; + +typedef enum GX2BlendMode +{ + GX2_BLEND_MODE_ZERO = 0, + GX2_BLEND_MODE_ONE = 1, + GX2_BLEND_MODE_SRC_COLOR = 2, + GX2_BLEND_MODE_INV_SRC_COLOR = 3, + GX2_BLEND_MODE_SRC_ALPHA = 4, + GX2_BLEND_MODE_INV_SRC_ALPHA = 5, + GX2_BLEND_MODE_DST_ALPHA = 6, + GX2_BLEND_MODE_INV_DST_ALPHA = 7, + GX2_BLEND_MODE_DST_COLOR = 8, + GX2_BLEND_MODE_INV_DST_COLOR = 9, + GX2_BLEND_MODE_SRC_ALPHA_SAT = 10, + GX2_BLEND_MODE_BOTH_SRC_ALPHA = 11, + GX2_BLEND_MODE_BOTH_INV_SRC_ALPHA = 12, + GX2_BLEND_MODE_BLEND_FACTOR = 13, + GX2_BLEND_MODE_INV_BLEND_FACTOR = 14, + GX2_BLEND_MODE_SRC1_COLOR = 15, + GX2_BLEND_MODE_INV_SRC1_COLOR = 16, + GX2_BLEND_MODE_SRC1_ALPHA = 17, + GX2_BLEND_MODE_INV_SRC1_ALPHA = 18, +} GX2BlendMode; + +typedef enum GX2BlendCombineMode +{ + GX2_BLEND_COMBINE_MODE_ADD = 0, + GX2_BLEND_COMBINE_MODE_SUB = 1, + GX2_BLEND_COMBINE_MODE_MIN = 2, + GX2_BLEND_COMBINE_MODE_MAX = 3, + GX2_BLEND_COMBINE_MODE_REV_SUB = 4, +} GX2BlendCombineMode; + +typedef enum GX2LogicOp +{ + GX2_LOGIC_OP_CLEAR = 0x00, + GX2_LOGIC_OP_NOR = 0x11, + GX2_LOGIC_OP_INV_AND = 0x22, + GX2_LOGIC_OP_INV_COPY = 0x33, + GX2_LOGIC_OP_REV_AND = 0x44, + GX2_LOGIC_OP_INV = 0x55, + GX2_LOGIC_OP_XOR = 0x66, + GX2_LOGIC_OP_NOT_AND = 0x77, + GX2_LOGIC_OP_AND = 0x88, + GX2_LOGIC_OP_EQUIV = 0x99, + GX2_LOGIC_OP_NOP = 0xAA, + GX2_LOGIC_OP_INV_OR = 0xBB, + GX2_LOGIC_OP_COPY = 0xCC, + GX2_LOGIC_OP_REV_OR = 0xDD, + GX2_LOGIC_OP_OR = 0xEE, + GX2_LOGIC_OP_SET = 0xFF, +} GX2LogicOp; + +typedef enum GX2StencilFunction +{ + GX2_STENCIL_FUNCTION_KEEP = 0, + GX2_STENCIL_FUNCTION_ZERO = 1, + GX2_STENCIL_FUNCTION_REPLACE = 2, + GX2_STENCIL_FUNCTION_INCR_CLAMP = 3, + GX2_STENCIL_FUNCTION_DECR_CLAMP = 4, + GX2_STENCIL_FUNCTION_INV = 5, + GX2_STENCIL_FUNCTION_INCR_WRAP = 6, + GX2_STENCIL_FUNCTION_DECR_WRAP = 7, +} GX2StencilFunction; + +typedef enum GX2PolygonMode +{ + GX2_POLYGON_MODE_POINT = 0, + GX2_POLYGON_MODE_LINE = 1, + GX2_POLYGON_MODE_TRIANGLE = 2, +} GX2PolygonMode; + + +typedef enum GX2ChannelMask +{ + GX2_CHANNEL_MASK_R = 1, + GX2_CHANNEL_MASK_G = 2, + GX2_CHANNEL_MASK_RG = 3, + GX2_CHANNEL_MASK_B = 4, + GX2_CHANNEL_MASK_RB = 5, + GX2_CHANNEL_MASK_GB = 6, + GX2_CHANNEL_MASK_RGB = 7, + GX2_CHANNEL_MASK_A = 8, + GX2_CHANNEL_MASK_RA = 9, + GX2_CHANNEL_MASK_GA = 10, + GX2_CHANNEL_MASK_RGA = 11, + GX2_CHANNEL_MASK_BA = 12, + GX2_CHANNEL_MASK_RBA = 13, + GX2_CHANNEL_MASK_GBA = 14, + GX2_CHANNEL_MASK_RGBA = 15, +} GX2ChannelMask; + +struct GX2AAMaskReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2AAMaskReg, 4); + +struct GX2AlphaTestReg +{ + uint32_t regs[2]; +}; +CHECK_SIZE(GX2AlphaTestReg, 8); + +struct GX2AlphaToMaskReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2AlphaToMaskReg, 4); + +struct GX2BlendControlReg +{ + uint32_t regs[2]; +}; +CHECK_SIZE(GX2BlendControlReg, 8); + +struct GX2BlendConstantColorReg +{ + uint32_t regs[4]; +}; +CHECK_SIZE(GX2BlendConstantColorReg, 16); + +struct GX2ColorControlReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2ColorControlReg, 4); + +struct GX2DepthStencilControlReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2DepthStencilControlReg, 4); + +struct GX2StencilMaskReg +{ + uint32_t regs[2]; +}; +CHECK_SIZE(GX2StencilMaskReg, 8); + +struct GX2LineWidthReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2LineWidthReg, 4); + +struct GX2PointSizeReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2PointSizeReg, 4); + +struct GX2PointLimitsReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2PointLimitsReg, 4); + +struct GX2PolygonControlReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2PolygonControlReg, 4); + +struct GX2PolygonOffsetReg +{ + uint32_t regs[5]; +}; +CHECK_SIZE(GX2PolygonOffsetReg, 20); + +struct GX2ScissorReg +{ + uint32_t regs[2]; +}; +CHECK_SIZE(GX2ScissorReg, 8); + +struct GX2TargetChannelMaskReg +{ + uint32_t regs[1]; +}; +CHECK_SIZE(GX2TargetChannelMaskReg, 4); + +struct GX2ViewportReg +{ + uint32_t regs[12]; +}; +CHECK_SIZE(GX2ViewportReg, 48); + +#pragma pack(pop) + +void +GX2SetAAMask(uint8_t upperLeft, + uint8_t upperRight, + uint8_t lowerLeft, + uint8_t lowerRight); + +void +GX2InitAAMaskReg(GX2AAMaskReg *reg, + uint8_t upperLeft, + uint8_t upperRight, + uint8_t lowerLeft, + uint8_t lowerRight); + +void +GX2GetAAMaskReg(GX2AAMaskReg *reg, + uint8_t *upperLeft, + uint8_t *upperRight, + uint8_t *lowerLeft, + uint8_t *lowerRight); + +void +GX2SetAAMaskReg(GX2AAMaskReg *reg); + +void +GX2SetAlphaTest(BOOL alphaTest, + GX2CompareFunction func, + float ref); + +void +GX2InitAlphaTestReg(GX2AlphaTestReg *reg, + BOOL alphaTest, + GX2CompareFunction func, + float ref); + +void +GX2GetAlphaTestReg(const GX2AlphaTestReg *reg, + BOOL *alphaTest, + GX2CompareFunction *func, + float *ref); + +void +GX2SetAlphaTestReg(GX2AlphaTestReg *reg); + +void +GX2SetAlphaToMask(BOOL alphaToMask, + GX2AlphaToMaskMode mode); + +void +GX2InitAlphaToMaskReg(GX2AlphaToMaskReg *reg, + BOOL alphaToMask, + GX2AlphaToMaskMode mode); + +void +GX2GetAlphaToMaskReg(const GX2AlphaToMaskReg *reg, + BOOL *alphaToMask, + GX2AlphaToMaskMode *mode); + +void +GX2SetAlphaToMaskReg(GX2AlphaToMaskReg *reg); + +void +GX2SetBlendConstantColor(float red, + float green, + float blue, + float alpha); + +void +GX2InitBlendConstantColorReg(GX2BlendConstantColorReg *reg, + float red, + float green, + float blue, + float alpha); + +void +GX2GetBlendConstantColorReg(GX2BlendConstantColorReg *reg, + float *red, + float *green, + float *blue, + float *alpha); + +void +GX2SetBlendConstantColorReg(GX2BlendConstantColorReg *reg); + +void +GX2SetBlendControl(GX2RenderTarget target, + GX2BlendMode colorSrcBlend, + GX2BlendMode colorDstBlend, + GX2BlendCombineMode colorCombine, + BOOL useAlphaBlend, + GX2BlendMode alphaSrcBlend, + GX2BlendMode alphaDstBlend, + GX2BlendCombineMode alphaCombine); + +void +GX2InitBlendControlReg(GX2BlendControlReg *reg, + GX2RenderTarget target, + GX2BlendMode colorSrcBlend, + GX2BlendMode colorDstBlend, + GX2BlendCombineMode colorCombine, + BOOL useAlphaBlend, + GX2BlendMode alphaSrcBlend, + GX2BlendMode alphaDstBlend, + GX2BlendCombineMode alphaCombine); + +void +GX2GetBlendControlReg(GX2BlendControlReg *reg, + GX2RenderTarget *target, + GX2BlendMode *colorSrcBlend, + GX2BlendMode *colorDstBlend, + GX2BlendCombineMode *colorCombine, + BOOL *useAlphaBlend, + GX2BlendMode *alphaSrcBlend, + GX2BlendMode *alphaDstBlend, + GX2BlendCombineMode *alphaCombine); + +void +GX2SetBlendControlReg(GX2BlendControlReg *reg); + +void +GX2SetColorControl(GX2LogicOp rop3, + uint8_t targetBlendEnable, + BOOL multiWriteEnable, + BOOL colorWriteEnable); + +void +GX2InitColorControlReg(GX2ColorControlReg *reg, + GX2LogicOp rop3, + uint8_t targetBlendEnable, + BOOL multiWriteEnable, + BOOL colorWriteEnable); + +void +GX2GetColorControlReg(GX2ColorControlReg *reg, + GX2LogicOp *rop3, + uint8_t *targetBlendEnable, + BOOL *multiWriteEnable, + BOOL *colorWriteEnable); + +void +GX2SetColorControlReg(GX2ColorControlReg *reg); + +void +GX2SetDepthOnlyControl(BOOL depthTest, + BOOL depthWrite, + GX2CompareFunction depthCompare); + +void +GX2SetDepthStencilControl(BOOL depthTest, + BOOL depthWrite, + GX2CompareFunction depthCompare, + BOOL stencilTest, + BOOL backfaceStencil, + GX2CompareFunction frontStencilFunc, + GX2StencilFunction frontStencilZPass, + GX2StencilFunction frontStencilZFail, + GX2StencilFunction frontStencilFail, + GX2CompareFunction backStencilFunc, + GX2StencilFunction backStencilZPass, + GX2StencilFunction backStencilZFail, + GX2StencilFunction backStencilFail); + +void +GX2InitDepthStencilControlReg(GX2DepthStencilControlReg *reg, + BOOL depthTest, + BOOL depthWrite, + GX2CompareFunction depthCompare, + BOOL stencilTest, + BOOL backfaceStencil, + GX2CompareFunction frontStencilFunc, + GX2StencilFunction frontStencilZPass, + GX2StencilFunction frontStencilZFail, + GX2StencilFunction frontStencilFail, + GX2CompareFunction backStencilFunc, + GX2StencilFunction backStencilZPass, + GX2StencilFunction backStencilZFail, + GX2StencilFunction backStencilFail); + +void +GX2GetDepthStencilControlReg(GX2DepthStencilControlReg *reg, + BOOL *depthTest, + BOOL *depthWrite, + GX2CompareFunction *depthCompare, + BOOL *stencilTest, + BOOL *backfaceStencil, + GX2CompareFunction *frontStencilFunc, + GX2StencilFunction *frontStencilZPass, + GX2StencilFunction *frontStencilZFail, + GX2StencilFunction *frontStencilFail, + GX2CompareFunction *backStencilFunc, + GX2StencilFunction *backStencilZPass, + GX2StencilFunction *backStencilZFail, + GX2StencilFunction *backStencilFail); + +void +GX2SetDepthStencilControlReg(GX2DepthStencilControlReg *reg); + +void +GX2SetStencilMask(uint8_t frontMask, + uint8_t frontWriteMask, + uint8_t frontRef, + uint8_t backMask, + uint8_t backWriteMask, + uint8_t backRef); + +void +GX2InitStencilMaskReg(GX2StencilMaskReg *reg, + uint8_t frontMask, + uint8_t frontWriteMask, + uint8_t frontRef, + uint8_t backMask, + uint8_t backWriteMask, + uint8_t backRef); + +void +GX2GetStencilMaskReg(GX2StencilMaskReg *reg, + uint8_t *frontMask, + uint8_t *frontWriteMask, + uint8_t *frontRef, + uint8_t *backMask, + uint8_t *backWriteMask, + uint8_t *backRef); + +void +GX2SetStencilMaskReg(GX2StencilMaskReg *reg); + +void +GX2SetLineWidth(float width); + +void +GX2InitLineWidthReg(GX2LineWidthReg *reg, + float width); + +void +GX2GetLineWidthReg(GX2LineWidthReg *reg, + float *width); + +void +GX2SetLineWidthReg(GX2LineWidthReg *reg); + +void +GX2SetPointSize(float width, + float height); + +void +GX2InitPointSizeReg(GX2PointSizeReg *reg, + float width, + float height); + +void +GX2GetPointSizeReg(GX2PointSizeReg *reg, + float *width, + float *height); + +void +GX2SetPointSizeReg(GX2PointSizeReg *reg); + +void +GX2SetPointLimits(float min, + float max); + +void +GX2InitPointLimitsReg(GX2PointLimitsReg *reg, + float min, + float max); + +void +GX2GetPointLimitsReg(GX2PointLimitsReg *reg, + float *min, + float *max); + +void +GX2SetPointLimitsReg(GX2PointLimitsReg *reg); + +void +GX2SetCullOnlyControl(GX2FrontFace frontFace, + BOOL cullFront, + BOOL cullBack); + +void +GX2SetPolygonControl(GX2FrontFace frontFace, + BOOL cullFront, + BOOL cullBack, + BOOL polyMode, + GX2PolygonMode polyModeFront, + GX2PolygonMode polyModeBack, + BOOL polyOffsetFrontEnable, + BOOL polyOffsetBackEnable, + BOOL polyOffsetParaEnable); + +void +GX2InitPolygonControlReg(GX2PolygonControlReg *reg, + GX2FrontFace frontFace, + BOOL cullFront, + BOOL cullBack, + BOOL polyMode, + GX2PolygonMode polyModeFront, + GX2PolygonMode polyModeBack, + BOOL polyOffsetFrontEnable, + BOOL polyOffsetBackEnable, + BOOL polyOffsetParaEnable); + +void +GX2GetPolygonControlReg(GX2PolygonControlReg *reg, + GX2FrontFace *frontFace, + BOOL *cullFront, + BOOL *cullBack, + BOOL *polyMode, + GX2PolygonMode *polyModeFront, + GX2PolygonMode *polyModeBack, + BOOL *polyOffsetFrontEnable, + BOOL *polyOffsetBackEnable, + BOOL *polyOffsetParaEnable); + +void +GX2SetPolygonControlReg(GX2PolygonControlReg *reg); + +void +GX2SetPolygonOffset(float frontOffset, + float frontScale, + float backOffset, + float backScale, + float clamp); + +void +GX2InitPolygonOffsetReg(GX2PolygonOffsetReg *reg, + float frontOffset, + float frontScale, + float backOffset, + float backScale, + float clamp); + +void +GX2GetPolygonOffsetReg(GX2PolygonOffsetReg *reg, + float *frontOffset, + float *frontScale, + float *backOffset, + float *backScale, + float *clamp); + +void +GX2SetPolygonOffsetReg(GX2PolygonOffsetReg *reg); + +void +GX2SetScissor(uint32_t x, + uint32_t y, + uint32_t width, + uint32_t height); + +void +GX2InitScissorReg(GX2ScissorReg *reg, + uint32_t x, + uint32_t y, + uint32_t width, + uint32_t height); + +void +GX2GetScissorReg(GX2ScissorReg *reg, + uint32_t *x, + uint32_t *y, + uint32_t *width, + uint32_t *height); + +void +GX2SetScissorReg(GX2ScissorReg *reg); + +void +GX2SetTargetChannelMasks(GX2ChannelMask mask0, + GX2ChannelMask mask1, + GX2ChannelMask mask2, + GX2ChannelMask mask3, + GX2ChannelMask mask4, + GX2ChannelMask mask5, + GX2ChannelMask mask6, + GX2ChannelMask mask7); + +void +GX2InitTargetChannelMasksReg(GX2TargetChannelMaskReg *reg, + GX2ChannelMask mask0, + GX2ChannelMask mask1, + GX2ChannelMask mask2, + GX2ChannelMask mask3, + GX2ChannelMask mask4, + GX2ChannelMask mask5, + GX2ChannelMask mask6, + GX2ChannelMask mask7); + +void +GX2GetTargetChannelMasksReg(GX2TargetChannelMaskReg *reg, + GX2ChannelMask *mask0, + GX2ChannelMask *mask1, + GX2ChannelMask *mask2, + GX2ChannelMask *mask3, + GX2ChannelMask *mask4, + GX2ChannelMask *mask5, + GX2ChannelMask *mask6, + GX2ChannelMask *mask7); + +void +GX2SetTargetChannelMasksReg(GX2TargetChannelMaskReg *reg); + +void +GX2SetViewport(float x, + float y, + float width, + float height, + float nearZ, + float farZ); + +void +GX2InitViewportReg(GX2ViewportReg *reg, + float x, + float y, + float width, + float height, + float nearZ, + float farZ); + +void +GX2GetViewportReg(GX2ViewportReg *reg, + float *x, + float *y, + float *width, + float *height, + float *nearZ, + float *farZ); + +void +GX2SetViewportReg(GX2ViewportReg *reg); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/sampler.h b/include/gx2/sampler.h new file mode 100644 index 0000000..b160fac --- /dev/null +++ b/include/gx2/sampler.h @@ -0,0 +1,132 @@ +#pragma once +#include + +/** + * \defgroup gx2_sampler Sampler + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +struct GX2Sampler +{ + uint32_t regs[3]; +}; +CHECK_SIZE(GX2Sampler, 12); + +typedef enum GX2TexBorderType +{ + GX2_TEX_BORDER_TYPE_TRANSPARENT_BLACK = 0, + GX2_TEX_BORDER_TYPE_BLACK = 1, + GX2_TEX_BORDER_TYPE_WHITE = 2, + GX2_TEX_BORDER_TYPE_VARIABLE = 3, +} GX2TexBorderType; + +typedef enum GX2TexClampMode +{ + GX2_TEX_CLAMP_MODE_WRAP = 0, + GX2_TEX_CLAMP_MODE_MIRROR = 1, + GX2_TEX_CLAMP_MODE_CLAMP = 2, + GX2_TEX_CLAMP_MODE_MIRROR_ONCE = 3, + GX2_TEX_CLAMP_MODE_CLAMP_BORDER = 6, +} GX2TexClampMode; + +typedef enum GX2TexMipFilterMode +{ + GX2_TEX_MIP_FILTER_MODE_NONE = 0, + GX2_TEX_MIP_FILTER_MODE_POINT = 1, + GX2_TEX_MIP_FILTER_MODE_LINEAR = 2, +} GX2TexMipFilterMode; + +typedef enum GX2TexMipPerfMode +{ + GX2_TEX_MIP_PERF_MODE_DISABLE = 0, +} GX2TexMipPerfMode; + +typedef enum GX2TexXYFilterMode +{ + GX2_TEX_XY_FILLTER_MODE_POINT = 0, + GX2_TEX_XY_FILLTER_MODE_LINEAR = 1, +} GX2TexXYFilterMode; + +typedef enum GX2TexAnisoRatio +{ + GX2_TEX_ANISO_RATIO_NONE = 0, +} GX2TexAnisoRatio; + +typedef enum GX2TexZFilterMode +{ + GX2_TEX_Z_FILTER_MODE_NONE = 0, + GX2_TEX_Z_FILTER_MODE_POINT = 1, + GX2_TEX_Z_FILTER_MODE_LINEAR = 2, +} GX2TexZFilterMode; + +typedef enum GX2TexZPerfMode +{ +} GX2TexZPerfMode; + +typedef enum GX2RoundingMode +{ + GX2_ROUNDING_MODE_ROUND_TO_EVEN = 0, + GX2_ROUNDING_MODE_TRUNCATE = 1, +} GX2RoundingMode; + +void +GX2InitSampler(GX2Sampler *sampler, + GX2TexClampMode clampMode, + GX2TexXYFilterMode minMagFilterMode); + +void +GX2InitSamplerBorderType(GX2Sampler *sampler, + GX2TexBorderType borderType); + +void +GX2InitSamplerClamping(GX2Sampler *sampler, + GX2TexClampMode clampX, + GX2TexClampMode clampY, + GX2TexClampMode clampZ); + +void +GX2InitSamplerDepthCompare(GX2Sampler *sampler, + GX2CompareFunction depthCompare); + +void +GX2InitSamplerFilterAdjust(GX2Sampler *sampler, + BOOL highPrecision, + GX2TexMipPerfMode perfMip, + GX2TexZPerfMode perfZ); + +void +GX2InitSamplerLOD(GX2Sampler *sampler, + float lodMin, + float lodMax, + float lodBias); + +void +GX2InitSamplerLODAdjust(GX2Sampler *sampler, + float unk1, + BOOL unk2); + +void +GX2InitSamplerRoundingMode(GX2Sampler *sampler, + GX2RoundingMode roundingMode); + +void +GX2InitSamplerXYFilter(GX2Sampler *sampler, + GX2TexXYFilterMode filterMag, + GX2TexXYFilterMode filterMin, + GX2TexAnisoRatio maxAniso); + +void +GX2InitSamplerZMFilter(GX2Sampler *sampler, + GX2TexZFilterMode filterZ, + GX2TexMipFilterMode filterMip); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/surface.h b/include/gx2/surface.h new file mode 100644 index 0000000..e38b381 --- /dev/null +++ b/include/gx2/surface.h @@ -0,0 +1,292 @@ +#pragma once +#include + +/** + * \defgroup gx2_surface Surface + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum +{ + GX2_SURFACE_DIM_TEXTURE_1D = 0, + GX2_SURFACE_DIM_TEXTURE_2D = 1, + GX2_SURFACE_DIM_TEXTURE_3D = 2, + GX2_SURFACE_DIM_TEXTURE_CUBE = 3, + GX2_SURFACE_DIM_TEXTURE_1D_ARRAY = 4, + GX2_SURFACE_DIM_TEXTURE_2D_ARRAY = 5, + GX2_SURFACE_DIM_TEXTURE_2D_MSAA = 6, + GX2_SURFACE_DIM_TEXTURE_2D_MSAA_ARRAY = 7, +} GX2SurfaceDim; + +typedef enum +{ + GX2_SURFACE_FORMAT_INVALID = 0x00, + GX2_SURFACE_FORMAT_UNORM_R4_G4 = 0x02, + GX2_SURFACE_FORMAT_UNORM_R4_G4_B4_A4 = 0x0b, + GX2_SURFACE_FORMAT_UNORM_R8 = 0x01, + GX2_SURFACE_FORMAT_UNORM_R8_G8 = 0x07, + GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8 = 0x01a, + GX2_SURFACE_FORMAT_UNORM_R16 = 0x05, + GX2_SURFACE_FORMAT_UNORM_R16_G16 = 0x0f, + GX2_SURFACE_FORMAT_UNORM_R16_G16_B16_A16 = 0x01f, + GX2_SURFACE_FORMAT_UNORM_R5_G6_B5 = 0x08, + GX2_SURFACE_FORMAT_UNORM_R5_G5_B5_A1 = 0x0a, + GX2_SURFACE_FORMAT_UNORM_A1_B5_G5_R5 = 0x0c, + GX2_SURFACE_FORMAT_UNORM_R24_X8 = 0x011, + GX2_SURFACE_FORMAT_UNORM_A2_B10_G10_R10 = 0x01b, + GX2_SURFACE_FORMAT_UNORM_R10_G10_B10_A2 = 0x019, + GX2_SURFACE_FORMAT_UNORM_BC1 = 0x031, + GX2_SURFACE_FORMAT_UNORM_BC2 = 0x032, + GX2_SURFACE_FORMAT_UNORM_BC3 = 0x033, + GX2_SURFACE_FORMAT_UNORM_BC4 = 0x034, + GX2_SURFACE_FORMAT_UNORM_BC5 = 0x035, + GX2_SURFACE_FORMAT_UNORM_NV12 = 0x081, + + GX2_SURFACE_FORMAT_UINT_R8 = 0x101, + GX2_SURFACE_FORMAT_UINT_R8_G8 = 0x107, + GX2_SURFACE_FORMAT_UINT_R8_G8_B8_A8 = 0x11a, + GX2_SURFACE_FORMAT_UINT_R16 = 0x105, + GX2_SURFACE_FORMAT_UINT_R16_G16 = 0x10f, + GX2_SURFACE_FORMAT_UINT_R16_G16_B16_A16 = 0x11f, + GX2_SURFACE_FORMAT_UINT_R32 = 0x10d, + GX2_SURFACE_FORMAT_UINT_R32_G32 = 0x11d, + GX2_SURFACE_FORMAT_UINT_R32_G32_B32_A32 = 0x122, + GX2_SURFACE_FORMAT_UINT_A2_B10_G10_R10 = 0x11b, + GX2_SURFACE_FORMAT_UINT_R10_G10_B10_A2 = 0x119, + GX2_SURFACE_FORMAT_UINT_X24_G8 = 0x111, + GX2_SURFACE_FORMAT_UINT_G8_X24 = 0x11c, + + GX2_SURFACE_FORMAT_SNORM_R8 = 0x201, + GX2_SURFACE_FORMAT_SNORM_R8_G8 = 0x207, + GX2_SURFACE_FORMAT_SNORM_R8_G8_B8_A8 = 0x21a, + GX2_SURFACE_FORMAT_SNORM_R16 = 0x205, + GX2_SURFACE_FORMAT_SNORM_R16_G16 = 0x20f, + GX2_SURFACE_FORMAT_SNORM_R16_G16_B16_A16 = 0x21f, + GX2_SURFACE_FORMAT_SNORM_R10_G10_B10_A2 = 0x219, + GX2_SURFACE_FORMAT_SNORM_BC4 = 0x234, + GX2_SURFACE_FORMAT_SNORM_BC5 = 0x235, + + GX2_SURFACE_FORMAT_SINT_R8 = 0x301, + GX2_SURFACE_FORMAT_SINT_R8_G8 = 0x307, + GX2_SURFACE_FORMAT_SINT_R8_G8_B8_A8 = 0x31a, + GX2_SURFACE_FORMAT_SINT_R16 = 0x305, + GX2_SURFACE_FORMAT_SINT_R16_G16 = 0x30f, + GX2_SURFACE_FORMAT_SINT_R16_G16_B16_A16 = 0x31f, + GX2_SURFACE_FORMAT_SINT_R32 = 0x30d, + GX2_SURFACE_FORMAT_SINT_R32_G32 = 0x31d, + GX2_SURFACE_FORMAT_SINT_R32_G32_B32_A32 = 0x322, + GX2_SURFACE_FORMAT_SINT_R10_G10_B10_A2 = 0x319, + + GX2_SURFACE_FORMAT_SRGB_R8_G8_B8_A8 = 0x41a, + GX2_SURFACE_FORMAT_SRGB_BC1 = 0x431, + GX2_SURFACE_FORMAT_SRGB_BC2 = 0x432, + GX2_SURFACE_FORMAT_SRGB_BC3 = 0x433, + + GX2_SURFACE_FORMAT_FLOAT_R32 = 0x80e, + GX2_SURFACE_FORMAT_FLOAT_R32_G32 = 0x81e, + GX2_SURFACE_FORMAT_FLOAT_R32_G32_B32_A32 = 0x823, + GX2_SURFACE_FORMAT_FLOAT_R16 = 0x806, + GX2_SURFACE_FORMAT_FLOAT_R16_G16 = 0x810, + GX2_SURFACE_FORMAT_FLOAT_R16_G16_B16_A16 = 0x820, + GX2_SURFACE_FORMAT_FLOAT_R11_G11_B10 = 0x816, + GX2_SURFACE_FORMAT_FLOAT_D24_S8 = 0x811, + GX2_SURFACE_FORMAT_FLOAT_X8_X24 = 0x81c, +} GX2SurfaceFormat; + +typedef enum GX2AAMode +{ + GX2_AA_MODE1X = 0, +} GX2AAMode; + +typedef enum GX2SurfaceUse +{ + GX2_SURFACE_USE_TEXTURE = 1 << 0, + GX2_SURFACE_USE_COLOR_BUFFER = 1 << 1, + GX2_SURFACE_USE_DEPTH_BUFFER = 1 << 2, + GX2_SURFACE_USE_SCAN_BUFFER = 1 << 3, +} GX2SurfaceUse; + +typedef enum GX2RResourceFlags +{ + GX2R_RESOURCE_FLAGS_BIND_TEXTURE = 1 << 0, + GX2R_RESOURCE_FLAGS_BIND_COLOR_BUFFER = 1 << 1, + GX2R_RESOURCE_FLAGS_BIND_DEPTH_BUFFER = 1 << 2, + GX2R_RESOURCE_FLAGS_BIND_SCAN_BUFFER = 1 << 3, + GX2R_RESOURCE_FLAGS_BIND_VERTEX_BUFFER = 1 << 4, + GX2R_RESOURCE_FLAGS_BIND_INDEX_BUFFER = 1 << 5, + GX2R_RESOURCE_FLAGS_BIND_UNIFORM_BLOCK = 1 << 6, + GX2R_RESOURCE_FLAGS_BIND_SHADER_PROGRAM = 1 << 7, + GX2R_RESOURCE_FLAGS_BIND_STREAM_OUTPUT = 1 << 8, + GX2R_RESOURCE_FLAGS_BIND_DISPLAY_LIST = 1 << 9, + GX2R_RESOURCE_FLAGS_BIND_GS_RING = 1 << 10, + GX2R_RESOURCE_FLAGS_USAGE_CPU_READ = 1 << 11, + GX2R_RESOURCE_FLAGS_USAGE_CPU_WRITE = 1 << 12, + GX2R_RESOURCE_FLAGS_USAGE_GPU_READ = 1 << 13, + GX2R_RESOURCE_FLAGS_USAGE_GPU_WRITE = 1 << 14, + GX2R_RESOURCE_FLAGS_USAGE_DMA_READ = 1 << 15, + GX2R_RESOURCE_FLAGS_USAGE_DMA_WRITE = 1 << 16, + GX2R_RESOURCE_FLAGS_USAGE_FORCE_MEM1 = 1 << 17, + GX2R_RESOURCE_FLAGS_USAGE_FORCE_MEM2 = 1 << 18, + GX2R_RESOURCE_FLAGS_USER_MEMORY = 1 << 29, + GX2R_RESOURCE_FLAGS_LOCKED = 1 << 30, +} GX2RResourceFlags; + +typedef enum GX2TileMode +{ + GX2_TILE_MODE_DEFAULT = 0, + GX2_TILE_MODE_LINEAR_ALIGNED = 1, + GX2_TILE_MODE_TILED_1D_THIN1 = 2, + GX2_TILE_MODE_TILED_1D_THICK = 3, + GX2_TILE_MODE_TILED_2D_THIN1 = 4, + GX2_TILE_MODE_TILED_2D_THIN2 = 5, + GX2_TILE_MODE_TILED_2D_THIN4 = 6, + GX2_TILE_MODE_TILED_2D_THICK = 7, + GX2_TILE_MODE_TILED_2B_THIN1 = 8, + GX2_TILE_MODE_TILED_2B_THIN2 = 9, + GX2_TILE_MODE_TILED_2B_THIN4 = 10, + GX2_TILE_MODE_TILED_2B_THICK = 11, + GX2_TILE_MODE_TILED_3D_THIN1 = 12, + GX2_TILE_MODE_TILED_3D_THICK = 13, + GX2_TILE_MODE_TILED_3B_THIN1 = 14, + GX2_TILE_MODE_TILED_3B_THICK = 15, + GX2_TILE_MODE_LINEAR_SPECIAL = 16, +} GX2TileMode; + +struct GX2Surface +{ + GX2SurfaceDim dim; + uint32_t width; + uint32_t height; + uint32_t depth; + uint32_t mipLevels; + GX2SurfaceFormat format; + GX2AAMode aa; + union + { + GX2SurfaceUse use; + GX2RResourceFlags resourceFlags; + }; + uint32_t imageSize; + void *image; + uint32_t mipmapSize; + void *mipmaps; + GX2TileMode tileMode; + uint32_t swizzle; + uint32_t alignment; + uint32_t pitch; + uint32_t mipLevelOffset[13]; +}; +CHECK_OFFSET(GX2Surface, 0x0, dim); +CHECK_OFFSET(GX2Surface, 0x4, width); +CHECK_OFFSET(GX2Surface, 0x8, height); +CHECK_OFFSET(GX2Surface, 0xc, depth); +CHECK_OFFSET(GX2Surface, 0x10, mipLevels); +CHECK_OFFSET(GX2Surface, 0x14, format); +CHECK_OFFSET(GX2Surface, 0x18, aa); +CHECK_OFFSET(GX2Surface, 0x1c, use); +CHECK_OFFSET(GX2Surface, 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); + +struct GX2DepthBuffer +{ + GX2Surface surface; + + uint32_t viewMip; + uint32_t viewFirstSlice; + uint32_t viewNumSlices; + void *hiZPtr; + uint32_t hiZSize; + float depthClear; + uint32_t stencilClear; + + uint32_t regs[7]; +}; +CHECK_OFFSET(GX2DepthBuffer, 0x74, viewMip); +CHECK_OFFSET(GX2DepthBuffer, 0x78, viewFirstSlice); +CHECK_OFFSET(GX2DepthBuffer, 0x7C, viewNumSlices); +CHECK_OFFSET(GX2DepthBuffer, 0x80, hiZPtr); +CHECK_OFFSET(GX2DepthBuffer, 0x84, hiZSize); +CHECK_OFFSET(GX2DepthBuffer, 0x88, depthClear); +CHECK_OFFSET(GX2DepthBuffer, 0x8C, stencilClear); +CHECK_OFFSET(GX2DepthBuffer, 0x90, regs); +CHECK_SIZE(GX2DepthBuffer, 0xAC); + +struct GX2ColorBuffer +{ + GX2Surface surface; + + uint32_t viewMip; + uint32_t viewFirstSlice; + uint32_t viewNumSlices; + void *aaBuffer; + uint32_t aaSize; + + uint32_t regs[5]; +}; +CHECK_OFFSET(GX2ColorBuffer, 0x74, viewMip); +CHECK_OFFSET(GX2ColorBuffer, 0x78, viewFirstSlice); +CHECK_OFFSET(GX2ColorBuffer, 0x7C, viewNumSlices); +CHECK_OFFSET(GX2ColorBuffer, 0x80, aaBuffer); +CHECK_OFFSET(GX2ColorBuffer, 0x84, aaSize); +CHECK_OFFSET(GX2ColorBuffer, 0x88, regs); +CHECK_SIZE(GX2ColorBuffer, 0x9C); + +void +GX2CalcSurfaceSizeAndAlignment(GX2Surface *surface); + +void +GX2CalcDepthBufferHiZInfo(GX2DepthBuffer *depthBuffer, + uint32_t *outSize, + uint32_t *outAlignment); + +void +GX2SetColorBuffer(GX2ColorBuffer *colorBuffer, + GX2RenderTarget target); + +void +GX2SetDepthBuffer(GX2DepthBuffer *depthBuffer); + +void +GX2InitColorBufferRegs(GX2ColorBuffer *colorBuffer); + +void +GX2InitDepthBufferRegs(GX2DepthBuffer *depthBuffer); + +void +GX2InitDepthBufferHiZEnable(GX2DepthBuffer *depthBuffer, + BOOL enable); + +uint32_t +GX2GetSurfaceSwizzle(GX2Surface *surface); + +void +GX2SetSurfaceSwizzle(GX2Surface *surface, + uint32_t swizzle); + +void +GX2CopySurface(GX2Surface *src, + uint32_t srcLevel, + uint32_t srcDepth, + GX2Surface *dst, + uint32_t dstLevel, + uint32_t dstDepth); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/swap.h b/include/gx2/swap.h new file mode 100644 index 0000000..b1f8d87 --- /dev/null +++ b/include/gx2/swap.h @@ -0,0 +1,48 @@ +#pragma once +#include + +/** + * \defgroup gx2_swap Swap + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum GX2ScanTarget +{ + GX2_SCAN_TARGET_TV = 1, + GX2_SCAN_TARGET_DRC = 4, +} GX2ScanTarget; + +typedef struct GX2ColorBuffer GX2ColorBuffer; +typedef struct GX2Texture GX2Texture; + +void +GX2CopyColorBufferToScanBuffer(GX2ColorBuffer *buffer, + GX2ScanTarget scanTarget); + +void +GX2SwapScanBuffers(); + +BOOL +GX2GetLastFrame(GX2ScanTarget scanTarget, + GX2Texture *texture); + +BOOL +GX2GetLastFrameGamma(GX2ScanTarget scanTarget, + float *gammaOut); + +uint32_t +GX2GetSwapInterval(); + +void +GX2SetSwapInterval(uint32_t interval); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/gx2/texture.h b/include/gx2/texture.h new file mode 100644 index 0000000..c7c2b53 --- /dev/null +++ b/include/gx2/texture.h @@ -0,0 +1,56 @@ +#pragma once +#include +#include "surface.h" + +/** + * \defgroup gx2_texture Texture + * \ingroup gx2 + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +struct GX2Texture +{ + GX2Surface surface; + uint32_t viewFirstMip; + uint32_t viewNumMips; + uint32_t viewFirstSlice; + uint32_t viewNumSlices; + uint32_t compMap; + + 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); + +#pragma pack(pop) + +void +GX2InitTextureRegs(GX2Texture *texture); + +void +GX2SetPixelTexture(GX2Texture *texture, + uint32_t unit); + +void +GX2SetVertexTexture(GX2Texture *texture, + uint32_t unit); + +void +GX2SetGeometryTexture(GX2Texture *texture, + uint32_t unit); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/rpl/libgx2/exports.h b/rpl/libgx2/exports.h index 3249192..f8fc061 100644 --- a/rpl/libgx2/exports.h +++ b/rpl/libgx2/exports.h @@ -1,3 +1,163 @@ +// gx2/clear.h +EXPORT(GX2ClearColor); +EXPORT(GX2ClearDepthStencil); +EXPORT(GX2ClearDepthStencilEx); +EXPORT(GX2ClearBuffers); +EXPORT(GX2ClearBuffersEx); +EXPORT(GX2SetClearDepth); +EXPORT(GX2SetClearStencil); +EXPORT(GX2SetClearDepthStencil); + +// gx2/context.h +EXPORT(GX2SetupContextState); +EXPORT(GX2SetupContextStateEx); +EXPORT(GX2GetContextStateDisplayList); +EXPORT(GX2SetContextState); +EXPORT(GX2SetDefaultState); + +// gx2/display.h +EXPORT(GX2SetTVEnable); +EXPORT(GX2SetDRCEnable); +EXPORT(GX2CalcTVSize); +EXPORT(GX2SetTVBuffer); +EXPORT(GX2SetTVScale); +EXPORT(GX2CalcDRCSize); +EXPORT(GX2SetDRCBuffer); +EXPORT(GX2SetDRCScale); +EXPORT(GX2GetSystemTVScanMode); +EXPORT(GX2GetSystemDRCMode); + +// gx2/displaylist.h +EXPORT(GX2BeginDisplayListEx); +EXPORT(GX2BeginDisplayList); +EXPORT(GX2EndDisplayList); +EXPORT(GX2DirectCallDisplayList); +EXPORT(GX2CallDisplayList); +EXPORT(GX2GetDisplayListWriteStatus); +EXPORT(GX2GetCurrentDisplayList); +EXPORT(GX2CopyDisplayList); + +// gx2/draw.h +EXPORT(GX2SetAttribBuffer); +EXPORT(GX2DrawEx); +EXPORT(GX2DrawIndexedEx); +EXPORT(GX2SetPrimitiveRestartIndex); + +// gx2/event.h +EXPORT(GX2DrawDone); +EXPORT(GX2WaitForVsync); +EXPORT(GX2WaitForFlip); +EXPORT(GX2SetEventCallback); +EXPORT(GX2GetEventCallback); +EXPORT(GX2GetRetiredTimeStamp); +EXPORT(GX2GetLastSubmittedTimeStamp); +EXPORT(GX2WaitTimeStamp); + +// gx2/registers.h +EXPORT(GX2SetAAMask); +EXPORT(GX2InitAAMaskReg); +EXPORT(GX2GetAAMaskReg); +EXPORT(GX2SetAAMaskReg); +EXPORT(GX2SetAlphaTest); +EXPORT(GX2InitAlphaTestReg); +EXPORT(GX2GetAlphaTestReg); +EXPORT(GX2SetAlphaTestReg); +EXPORT(GX2SetAlphaToMask); +EXPORT(GX2InitAlphaToMaskReg); +EXPORT(GX2GetAlphaToMaskReg); +EXPORT(GX2SetAlphaToMaskReg); +EXPORT(GX2SetBlendConstantColor); +EXPORT(GX2InitBlendConstantColorReg); +EXPORT(GX2GetBlendConstantColorReg); +EXPORT(GX2SetBlendConstantColorReg); +EXPORT(GX2SetBlendControl); +EXPORT(GX2InitBlendControlReg); +EXPORT(GX2GetBlendControlReg); +EXPORT(GX2SetBlendControlReg); +EXPORT(GX2SetColorControl); +EXPORT(GX2InitColorControlReg); +EXPORT(GX2GetColorControlReg); +EXPORT(GX2SetColorControlReg); +EXPORT(GX2SetDepthOnlyControl); +EXPORT(GX2SetDepthStencilControl); +EXPORT(GX2InitDepthStencilControlReg); +EXPORT(GX2GetDepthStencilControlReg); +EXPORT(GX2SetDepthStencilControlReg); +EXPORT(GX2SetStencilMask); +EXPORT(GX2InitStencilMaskReg); +EXPORT(GX2GetStencilMaskReg); +EXPORT(GX2SetStencilMaskReg); +EXPORT(GX2SetLineWidth); +EXPORT(GX2InitLineWidthReg); +EXPORT(GX2GetLineWidthReg); +EXPORT(GX2SetLineWidthReg); +EXPORT(GX2SetPointSize); +EXPORT(GX2InitPointSizeReg); +EXPORT(GX2GetPointSizeReg); +EXPORT(GX2SetPointSizeReg); +EXPORT(GX2SetPointLimits); +EXPORT(GX2InitPointLimitsReg); +EXPORT(GX2GetPointLimitsReg); +EXPORT(GX2SetPointLimitsReg); +EXPORT(GX2SetCullOnlyControl); +EXPORT(GX2SetPolygonControl); +EXPORT(GX2InitPolygonControlReg); +EXPORT(GX2SetPolygonControlReg); +EXPORT(GX2SetPolygonOffset); +EXPORT(GX2InitPolygonOffsetReg); +EXPORT(GX2GetPolygonOffsetReg); +EXPORT(GX2SetPolygonOffsetReg); +EXPORT(GX2SetScissor); +EXPORT(GX2InitScissorReg); +EXPORT(GX2GetScissorReg); +EXPORT(GX2SetScissorReg); +EXPORT(GX2SetTargetChannelMasks); +EXPORT(GX2InitTargetChannelMasksReg); +EXPORT(GX2GetTargetChannelMasksReg); +EXPORT(GX2SetTargetChannelMasksReg); +EXPORT(GX2SetViewport); +EXPORT(GX2InitViewportReg); +EXPORT(GX2GetViewportReg); +EXPORT(GX2SetViewportReg); + +// gx2/sampler.h +EXPORT(GX2InitSampler); +EXPORT(GX2InitSamplerBorderType); +EXPORT(GX2InitSamplerClamping); +EXPORT(GX2InitSamplerDepthCompare); +EXPORT(GX2InitSamplerFilterAdjust); +EXPORT(GX2InitSamplerLOD); +EXPORT(GX2InitSamplerLODAdjust); +EXPORT(GX2InitSamplerRoundingMode); +EXPORT(GX2InitSamplerXYFilter); +EXPORT(GX2InitSamplerZMFilter); + // gx2/state.h EXPORT(GX2Init); -EXPORT(GX2Shutdown); \ No newline at end of file +EXPORT(GX2Shutdown); + +// gx2/surface.h +EXPORT(GX2CalcSurfaceSizeAndAlignment); +EXPORT(GX2CalcDepthBufferHiZInfo); +EXPORT(GX2SetColorBuffer); +EXPORT(GX2SetDepthBuffer); +EXPORT(GX2InitColorBufferRegs); +EXPORT(GX2InitDepthBufferRegs); +EXPORT(GX2InitDepthBufferHiZEnable); +EXPORT(GX2GetSurfaceSwizzle); +EXPORT(GX2SetSurfaceSwizzle); +EXPORT(GX2CopySurface); + +// gx2/swap.h +EXPORT(GX2CopyColorBufferToScanBuffer); +EXPORT(GX2SwapScanBuffers); +EXPORT(GX2GetLastFrame); +EXPORT(GX2GetLastFrameGamma); +EXPORT(GX2GetSwapInterval); +EXPORT(GX2SetSwapInterval); + +// gx2/texture.h +EXPORT(GX2InitTextureRegs); +EXPORT(GX2SetPixelTexture); +EXPORT(GX2SetVertexTexture); +EXPORT(GX2SetGeometryTexture);