registers.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include "enum.h"
#include "surface.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct GX2AAMaskReg GX2AAMaskReg;
typedef struct GX2AlphaTestReg GX2AlphaTestReg;
typedef struct GX2AlphaToMaskReg GX2AlphaToMaskReg;
typedef struct GX2BlendControlReg GX2BlendControlReg;
typedef struct GX2BlendConstantColorReg GX2BlendConstantColorReg;
typedef struct GX2ColorControlReg GX2ColorControlReg;
typedef struct GX2DepthStencilControlReg GX2DepthStencilControlReg;
typedef struct GX2StencilMaskReg GX2StencilMaskReg;
typedef struct GX2LineWidthReg GX2LineWidthReg;
typedef struct GX2PointSizeReg GX2PointSizeReg;
typedef struct GX2PointLimitsReg GX2PointLimitsReg;
typedef struct GX2PolygonControlReg GX2PolygonControlReg;
typedef struct GX2PolygonOffsetReg GX2PolygonOffsetReg;
typedef struct GX2ScissorReg GX2ScissorReg;
typedef struct GX2TargetChannelMaskReg GX2TargetChannelMaskReg;
typedef struct GX2ViewportReg GX2ViewportReg;
 
struct GX2AAMaskReg
{
 uint32_t pa_sc_aa_mask;
};
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;
};
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;
};
WUT_CHECK_OFFSET(GX2AlphaToMaskReg, 0, db_alpha_to_mask);
WUT_CHECK_SIZE(GX2AlphaToMaskReg, 4);
 
struct GX2BlendControlReg
{
 GX2RenderTarget target;
 uint32_t cb_blend_control;
};
WUT_CHECK_OFFSET(GX2BlendControlReg, 0, target);
WUT_CHECK_OFFSET(GX2BlendControlReg, 4, cb_blend_control);
WUT_CHECK_SIZE(GX2BlendControlReg, 8);
 
struct GX2BlendConstantColorReg
{
 float red;
 float green;
 float blue;
 float alpha;
};
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;
};
WUT_CHECK_OFFSET(GX2ColorControlReg, 0x00, cb_color_control);
WUT_CHECK_SIZE(GX2ColorControlReg, 4);
 
struct GX2DepthStencilControlReg
{
 uint32_t db_depth_control;
};
WUT_CHECK_OFFSET(GX2DepthStencilControlReg, 0, db_depth_control);
WUT_CHECK_SIZE(GX2DepthStencilControlReg, 4);
 
struct GX2StencilMaskReg
{
 uint32_t db_stencilrefmask;
 uint32_t db_stencilrefmask_bf;
};
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;
};
WUT_CHECK_OFFSET(GX2LineWidthReg, 0, pa_su_line_cntl);
WUT_CHECK_SIZE(GX2LineWidthReg, 4);
 
struct GX2PointSizeReg
{
 uint32_t pa_su_point_size;
};
WUT_CHECK_OFFSET(GX2PointSizeReg, 0, pa_su_point_size);
WUT_CHECK_SIZE(GX2PointSizeReg, 4);
 
struct GX2PointLimitsReg
{
 uint32_t pa_su_point_minmax;
};
WUT_CHECK_OFFSET(GX2PointLimitsReg, 0, pa_su_point_minmax);
WUT_CHECK_SIZE(GX2PointLimitsReg, 4);
 
struct GX2PolygonControlReg
{
 uint32_t pa_su_sc_mode_cntl;
};
WUT_CHECK_OFFSET(GX2PolygonControlReg, 0, pa_su_sc_mode_cntl);
WUT_CHECK_SIZE(GX2PolygonControlReg, 4);
 
struct GX2PolygonOffsetReg
{
 uint32_t pa_su_poly_offset_front_scale;
 uint32_t pa_su_poly_offset_front_offset;
 uint32_t pa_su_poly_offset_back_scale;
 uint32_t pa_su_poly_offset_back_offset;
 uint32_t pa_su_poly_offset_clamp;
};
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;
};
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;
};
WUT_CHECK_OFFSET(GX2TargetChannelMaskReg, 0x00, cb_target_mask);
WUT_CHECK_SIZE(GX2TargetChannelMaskReg, 4);
 
struct GX2ViewportReg
{
 uint32_t pa_cl_vport_xscale;
 uint32_t pa_cl_vport_xoffset;
 uint32_t pa_cl_vport_yscale;
 uint32_t pa_cl_vport_yoffset;
 uint32_t pa_cl_vport_zscale;
 uint32_t pa_cl_vport_zoffset;
 uint32_t pa_cl_gb_vert_clip_adj;
 uint32_t pa_cl_gb_vert_disc_adj;
 uint32_t pa_cl_gb_horz_clip_adj;
 uint32_t pa_cl_gb_horz_disc_adj;
 uint32_t pa_sc_vport_zmin;
 uint32_t pa_sc_vport_zmax;
};
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,
 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(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const GX2StencilMaskReg *reg);
 
void
GX2SetLineWidth(float width);
 
void
GX2InitLineWidthReg(GX2LineWidthReg *reg,
 float width);
 
void
GX2GetLineWidthReg(GX2LineWidthReg *reg,
 float *width);
 
void
GX2SetLineWidthReg(const 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(const 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(const 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(const 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(const 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(const 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(const 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(const GX2ViewportReg *reg);
 
void
GX2SetRasterizerClipControl(BOOL rasterizer,
 BOOL zclipEnable);
 
void
GX2SetRasterizerClipControlEx(BOOL rasterizer,
 BOOL zclipEnable,
 BOOL halfZ);
 
void
GX2SetRasterizerClipControlHalfZ(BOOL rasterizer,
 BOOL zclipEnable,
 BOOL halfZ);
 
#ifdef __cplusplus
}
#endif