diff options
Diffstat (limited to 'third_party/citro3d.c')
| -rw-r--r-- | third_party/citro3d.c | 1720 |
1 files changed, 1720 insertions, 0 deletions
diff --git a/third_party/citro3d.c b/third_party/citro3d.c new file mode 100644 index 0000000..7aa0bad --- /dev/null +++ b/third_party/citro3d.c @@ -0,0 +1,1720 @@ +/* +Copyright (C) 2014-2018 fincs + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you + must not claim that you wrote the original software. If you use + this software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and + must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source + distribution. +*/ +#include <stdbool.h> +#include <stdint.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> + +typedef u32 C3D_IVec; + +typedef union +{ + struct + { + float w; ///< W-component + float z; ///< Z-component + float y; ///< Y-component + float x; ///< X-component + }; + float c[4]; +} C3D_FVec; + +typedef union +{ + C3D_FVec r[4]; ///< Rows are vectors + float m[4*4]; ///< Raw access +} C3D_Mtx; + + +typedef struct +{ + u32 flags[2]; + u64 permutation; + int attrCount; +} C3D_AttrInfo; + +static void AttrInfo_Init(C3D_AttrInfo* info); +static int AttrInfo_AddLoader(C3D_AttrInfo* info, int regId, GPU_FORMATS format, int count); + +static C3D_AttrInfo* C3D_GetAttrInfo(void); + + + + +typedef struct +{ + u32 offset; + u32 flags[2]; +} C3D_BufCfg; + + +typedef struct +{ + void* data; + GPU_TEXCOLOR fmt : 4; + size_t size : 28; + + union + { + u32 dim; + struct + { + u16 height; + u16 width; + }; + }; + + u32 param; + u32 border; + union + { + u32 lodParam; + struct + { + u16 lodBias; + u8 maxLevel; + u8 minLevel; + }; + }; +} C3D_Tex; + +static void C3D_TexLoadImage(C3D_Tex* tex, const void* data, GPU_TEXFACE face, int level); +static void C3D_TexGenerateMipmap(C3D_Tex* tex, GPU_TEXFACE face); +static void C3D_TexBind(int unitId, C3D_Tex* tex); +static void C3D_TexFlush(C3D_Tex* tex); +static void C3D_TexDelete(C3D_Tex* tex); + +static inline int C3D_TexCalcMaxLevel(u32 width, u32 height) +{ + return (31-__builtin_clz(width < height ? width : height)) - 3; // avoid sizes smaller than 8 +} + +static inline u32 C3D_TexCalcLevelSize(u32 size, int level) +{ + return size >> (2*level); +} + +static inline u32 C3D_TexCalcTotalSize(u32 size, int maxLevel) +{ + /* + S = s + sr + sr^2 + sr^3 + ... + sr^n + Sr = sr + sr^2 + sr^3 + ... + sr^(n+1) + S-Sr = s - sr^(n+1) + S(1-r) = s(1 - r^(n+1)) + S = s (1 - r^(n+1)) / (1-r) + + r = 1/4 + 1-r = 3/4 + + S = 4s (1 - (1/4)^(n+1)) / 3 + S = 4s (1 - 1/4^(n+1)) / 3 + S = (4/3) (s - s/4^(n+1)) + S = (4/3) (s - s/(1<<(2n+2))) + S = (4/3) (s - s>>(2n+2)) + */ + return (size - C3D_TexCalcLevelSize(size,maxLevel+1)) * 4 / 3; +} + +static inline void* C3D_TexGetImagePtr(C3D_Tex* tex, void* data, int level, u32* size) +{ + if (size) *size = level >= 0 ? C3D_TexCalcLevelSize(tex->size, level) : C3D_TexCalcTotalSize(tex->size, tex->maxLevel); + if (!level) return data; + return (u8*)data + (level > 0 ? C3D_TexCalcTotalSize(tex->size, level-1) : 0); +} + +static inline void* C3D_Tex2DGetImagePtr(C3D_Tex* tex, int level, u32* size) +{ + return C3D_TexGetImagePtr(tex, tex->data, level, size); +} + +static inline void C3D_TexUpload(C3D_Tex* tex, const void* data) +{ + C3D_TexLoadImage(tex, data, GPU_TEXFACE_2D, 0); +} + + + + + + + + + +static void C3D_DepthMap(bool bIsZBuffer, float zScale, float zOffset); +static void C3D_CullFace(GPU_CULLMODE mode); +static void C3D_StencilTest(void); +static void C3D_StencilOp(void); +static void C3D_EarlyDepthTest(bool enable, GPU_EARLYDEPTHFUNC function, u32 ref); +static void C3D_DepthTest(bool enable, GPU_TESTFUNC function, GPU_WRITEMASK writemask); +static void C3D_AlphaTest(bool enable, GPU_TESTFUNC function, int ref); +static void C3D_AlphaBlend(GPU_BLENDEQUATION colorEq, GPU_BLENDEQUATION alphaEq, GPU_BLENDFACTOR srcClr, GPU_BLENDFACTOR dstClr, GPU_BLENDFACTOR srcAlpha, GPU_BLENDFACTOR dstAlpha); +static void C3D_ColorLogicOp(GPU_LOGICOP op); +static void C3D_FragOpMode(GPU_FRAGOPMODE mode); +static void C3D_FragOpShadow(float scale, float bias); + + + + + + +#define C3D_DEFAULT_CMDBUF_SIZE 0x40000 + +enum +{ + C3D_UNSIGNED_BYTE = 0, + C3D_UNSIGNED_SHORT = 1, +}; + +static bool C3D_Init(size_t cmdBufSize); +static void C3D_Fini(void); + +static void C3D_BindProgram(shaderProgram_s* program); + +static void C3D_SetViewport(u32 x, u32 y, u32 w, u32 h); +static void C3D_SetScissor(GPU_SCISSORMODE mode, u32 left, u32 top, u32 right, u32 bottom); + +static void C3D_DrawElements(GPU_Primitive_t primitive, int count); + +// Immediate-mode vertex submission +static void C3D_ImmDrawBegin(GPU_Primitive_t primitive); +static void C3D_ImmSendAttrib(float x, float y, float z, float w); +static void C3D_ImmDrawEnd(void); + +static inline void C3D_ImmDrawRestartPrim(void) +{ + GPUCMD_AddWrite(GPUREG_RESTART_PRIMITIVE, 1); +} + + + + + +typedef struct +{ + u32 data[128]; +} C3D_FogLut; + +static inline float FogLut_CalcZ(float depth, float near, float far) +{ + return far*near/(depth*(far-near)+near); +} + +static void FogLut_FromArray(C3D_FogLut* lut, const float data[256]); + +static void C3D_FogGasMode(GPU_FOGMODE fogMode, GPU_GASMODE gasMode, bool zFlip); +static void C3D_FogColor(u32 color); +static void C3D_FogLutBind(C3D_FogLut* lut); + + + + + + + + + + + +typedef struct +{ + void* colorBuf; + void* depthBuf; + u16 width; + u16 height; + GPU_COLORBUF colorFmt; + GPU_DEPTHBUF depthFmt; + bool block32; + u8 colorMask : 4; + u8 depthMask : 4; +} C3D_FrameBuf; + +// Flags for C3D_FrameBufClear +typedef enum +{ + C3D_CLEAR_COLOR = BIT(0), + C3D_CLEAR_DEPTH = BIT(1), + C3D_CLEAR_ALL = C3D_CLEAR_COLOR | C3D_CLEAR_DEPTH, +} C3D_ClearBits; + +static u32 C3D_CalcColorBufSize(u32 width, u32 height, GPU_COLORBUF fmt); +static u32 C3D_CalcDepthBufSize(u32 width, u32 height, GPU_DEPTHBUF fmt); + +static C3D_FrameBuf* C3D_GetFrameBuf(void); +static void C3D_SetFrameBuf(C3D_FrameBuf* fb); +static void C3D_FrameBufClear(C3D_FrameBuf* fb, C3D_ClearBits clearBits, u32 clearColor, u32 clearDepth); +static void C3D_FrameBufTransfer(C3D_FrameBuf* fb, gfxScreen_t screen, gfx3dSide_t side, u32 transferFlags); + +static inline void C3D_FrameBufAttrib(C3D_FrameBuf* fb, u16 width, u16 height, bool block32) +{ + fb->width = width; + fb->height = height; + fb->block32 = block32; +} + +static inline void C3D_FrameBufColor(C3D_FrameBuf* fb, void* buf, GPU_COLORBUF fmt) +{ + if (buf) + { + fb->colorBuf = buf; + fb->colorFmt = fmt; + fb->colorMask = 0xF; + } else + { + fb->colorBuf = NULL; + fb->colorFmt = GPU_RB_RGBA8; + fb->colorMask = 0; + } +} + +static inline void C3D_FrameBufDepth(C3D_FrameBuf* fb, void* buf, GPU_DEPTHBUF fmt) +{ + if (buf) + { + fb->depthBuf = buf; + fb->depthFmt = fmt; + fb->depthMask = fmt == GPU_RB_DEPTH24_STENCIL8 ? 0x3 : 0x2; + } else + { + fb->depthBuf = NULL; + fb->depthFmt = GPU_RB_DEPTH24; + fb->depthMask = 0; + } +} + + + + + + + +typedef struct C3D_RenderTarget_tag C3D_RenderTarget; + +struct C3D_RenderTarget_tag +{ + C3D_FrameBuf frameBuf; + + bool used, linked; + gfxScreen_t screen; + gfx3dSide_t side; + u32 transferFlags; +}; + +// Flags for C3D_FrameBegin +enum +{ + C3D_FRAME_SYNCDRAW = BIT(0), // Perform C3D_FrameSync before checking the GPU status + C3D_FRAME_NONBLOCK = BIT(1), // Return false instead of waiting if the GPU is busy +}; + +static void C3D_FrameSync(void); + +static bool C3D_FrameBegin(u8 flags); +static bool C3D_FrameDrawOn(C3D_RenderTarget* target); +static void C3D_FrameSplit(u8 flags); +static void C3D_FrameEnd(u8 flags); + +static void C3D_RenderTargetCreate(C3D_RenderTarget* target, int width, int height, GPU_COLORBUF colorFmt, GPU_DEPTHBUF depthFmt); +static void C3D_RenderTargetDelete(C3D_RenderTarget* target); +static void C3D_RenderTargetSetOutput(C3D_RenderTarget* target, gfxScreen_t screen, gfx3dSide_t side, u32 transferFlags); + +static inline void C3D_RenderTargetDetachOutput(C3D_RenderTarget* target) +{ + C3D_RenderTargetSetOutput(NULL, target->screen, target->side, 0); +} + +static inline void C3D_RenderTargetClear(C3D_RenderTarget* target, C3D_ClearBits clearBits, u32 clearColor, u32 clearDepth) +{ + C3D_FrameBufClear(&target->frameBuf, clearBits, clearColor, clearDepth); +} + +static void C3D_SyncTextureCopy(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 size, u32 flags); + + + + +typedef struct +{ + u16 srcRgb, srcAlpha; + union + { + u32 opAll; + struct { u32 opRgb:12, opAlpha:12; }; + }; + u16 funcRgb, funcAlpha; + u32 color; + u16 scaleRgb, scaleAlpha; +} C3D_TexEnv; + +static inline void C3D_TexEnvInit(C3D_TexEnv* env) +{ + env->srcRgb = GPU_TEVSOURCES(GPU_PREVIOUS, 0, 0); + env->srcAlpha = GPU_TEVSOURCES(GPU_PREVIOUS, 0, 0); + env->opAll = 0; + env->funcRgb = GPU_REPLACE; + env->funcAlpha = GPU_REPLACE; + env->color = 0xFFFFFFFF; + env->scaleRgb = GPU_TEVSCALE_1; + env->scaleAlpha = GPU_TEVSCALE_1; +} + + +void Mtx_Multiply(C3D_Mtx* out, const C3D_Mtx* a, const C3D_Mtx* b) +{ + // http://www.wolframalpha.com/input/?i={{a,b,c,d},{e,f,g,h},{i,j,k,l},{m,n,o,p}}{{α,β,γ,δ},{ε,θ,ι,κ},{λ,μ,ν,ξ},{ο,π,ρ,σ}} + int i, j; + for (j = 0; j < 4; ++j) + for (i = 0; i < 4; ++i) + out->r[j].c[i] = a->r[j].x*b->r[0].c[i] + a->r[j].y*b->r[1].c[i] + a->r[j].z*b->r[2].c[i] + a->r[j].w*b->r[3].c[i]; +} + + + + +#define C3D_FVUNIF_COUNT 96 +#define C3D_IVUNIF_COUNT 4 + +static C3D_FVec C3D_FVUnif[C3D_FVUNIF_COUNT]; +static C3D_IVec C3D_IVUnif[C3D_IVUNIF_COUNT]; +static u16 C3D_BoolUnifs; + +static bool C3D_FVUnifDirty[C3D_FVUNIF_COUNT]; +static bool C3D_IVUnifDirty[C3D_IVUNIF_COUNT]; +static bool C3D_BoolUnifsDirty; + +static inline C3D_FVec* C3D_FVUnifWritePtr(int id, int size) +{ + int i; + for (i = 0; i < size; i ++) + C3D_FVUnifDirty[id+i] = true; + return &C3D_FVUnif[id]; +} + +static inline void C3D_FVUnifMtx4x4(int id, const C3D_Mtx* mtx) +{ + int i; + C3D_FVec* ptr = C3D_FVUnifWritePtr(id, 4); + for (i = 0; i < 4; i ++) + ptr[i] = mtx->r[i]; // Struct copy. +} + +static inline void C3D_FVUnifSet(int id, float x, float y, float z, float w) +{ + C3D_FVec* ptr = C3D_FVUnifWritePtr(id, 1); + ptr->x = x; + ptr->y = y; + ptr->z = z; + ptr->w = w; +} + +static void C3D_UpdateUniforms(void); + + + + + + +typedef struct +{ + u32 fragOpMode; + u32 fragOpShadow; + u32 zScale, zOffset; + GPU_CULLMODE cullMode; + bool zBuffer, earlyDepth; + GPU_EARLYDEPTHFUNC earlyDepthFunc; + u32 earlyDepthRef; + + u32 alphaTest; + u32 stencilMode, stencilOp; + u32 depthTest; + + u32 alphaBlend; + GPU_LOGICOP clrLogicOp; +} C3D_Effect; + +typedef struct +{ + gxCmdQueue_s gxQueue; + u32* cmdBuf; + size_t cmdBufSize; + + u32 flags; + shaderProgram_s* program; + + C3D_AttrInfo attrInfo; + C3D_Effect effect; + + u32 texConfig; + C3D_Tex* tex[3]; + + u32 texEnvBuf, texEnvBufClr; + u32 fogClr; + C3D_FogLut* fogLut; + + C3D_FrameBuf fb; + u32 viewport[5]; + u32 scissor[3]; +} C3D_Context; + +enum +{ + C3DiF_Active = BIT(0), + C3DiF_DrawUsed = BIT(1), + C3DiF_AttrInfo = BIT(2), + C3DiF_Effect = BIT(4), + C3DiF_FrameBuf = BIT(5), + C3DiF_Viewport = BIT(6), + C3DiF_Scissor = BIT(7), + C3DiF_Program = BIT(8), + C3DiF_TexEnvBuf = BIT(9), + C3DiF_VshCode = BIT(11), + C3DiF_GshCode = BIT(12), + C3DiF_TexStatus = BIT(14), + C3DiF_FogLut = BIT(17), + C3DiF_Gas = BIT(18), + + C3DiF_Reset = BIT(19), + +#define C3DiF_Tex(n) BIT(23+(n)) + C3DiF_TexAll = 7 << 23, +}; + +static C3D_Context __C3D_Context; +static inline C3D_Context* C3Di_GetContext(void) +{ + extern C3D_Context __C3D_Context; + return &__C3D_Context; +} + +static inline bool addrIsVRAM(const void* addr) +{ + u32 vaddr = (u32)addr; + return vaddr >= OS_VRAM_VADDR && vaddr < OS_VRAM_VADDR + OS_VRAM_SIZE; +} + +static inline vramAllocPos addrGetVRAMBank(const void* addr) +{ + u32 vaddr = (u32)addr; + return vaddr < OS_VRAM_VADDR + OS_VRAM_SIZE/2 ? VRAM_ALLOC_A : VRAM_ALLOC_B; +} + +static void C3Di_UpdateContext(void); +static void C3Di_AttrInfoBind(C3D_AttrInfo* info); +static void C3Di_FrameBufBind(C3D_FrameBuf* fb); +static void C3Di_TexEnvBind(int id, C3D_TexEnv* env); +static void C3Di_SetTex(int unit, C3D_Tex* tex); +static void C3Di_EffectBind(C3D_Effect* effect); + +static void C3Di_DirtyUniforms(void); +static void C3Di_LoadShaderUniforms(shaderInstance_s* si); +static void C3Di_ClearShaderUniforms(GPU_SHADER_TYPE type); + +static bool C3Di_SplitFrame(u32** pBuf, u32* pSize); + +static void C3Di_RenderQueueInit(void); +static void C3Di_RenderQueueExit(void); +static void C3Di_RenderQueueWaitDone(void); +static void C3Di_RenderQueueEnableVBlank(void); +static void C3Di_RenderQueueDisableVBlank(void); + + + + + + + + + +static void AttrInfo_Init(C3D_AttrInfo* info) +{ + memset(info, 0, sizeof(*info)); + info->flags[1] = 0xFFF << 16; +} + +static int AttrInfo_AddLoader(C3D_AttrInfo* info, int regId, GPU_FORMATS format, int count) +{ + if (info->attrCount == 12) return -1; + int id = info->attrCount++; + if (regId < 0) regId = id; + if (id < 8) + info->flags[0] |= GPU_ATTRIBFMT(id, count, format); + else + info->flags[1] |= GPU_ATTRIBFMT(id-8, count, format); + + info->flags[1] = (info->flags[1] &~ (0xF0000000 | BIT(id+16))) | (id << 28); + info->permutation |= regId << (id*4); + return id; +} + +static C3D_AttrInfo* C3D_GetAttrInfo(void) +{ + C3D_Context* ctx = C3Di_GetContext(); + + ctx->flags |= C3DiF_AttrInfo; + return &ctx->attrInfo; +} + +static void C3Di_AttrInfoBind(C3D_AttrInfo* info) +{ + GPUCMD_AddIncrementalWrites(GPUREG_ATTRIBBUFFERS_FORMAT_LOW, (u32*)info->flags, sizeof(info->flags)/sizeof(u32)); + GPUCMD_AddMaskedWrite(GPUREG_VSH_INPUTBUFFER_CONFIG, 0xB, 0xA0000000 | (info->attrCount - 1)); + GPUCMD_AddWrite(GPUREG_VSH_NUM_ATTR, info->attrCount - 1); + GPUCMD_AddIncrementalWrites(GPUREG_VSH_ATTRIBUTES_PERMUTATION_LOW, (u32*)&info->permutation, 2); +} + + + + + + + + + + + +#define BUFFER_BASE_PADDR 0x18000000 + + + +static void C3D_DrawElements(GPU_Primitive_t primitive, int count) +{ + C3Di_UpdateContext(); + + // Set primitive type + GPUCMD_AddMaskedWrite(GPUREG_PRIMITIVE_CONFIG, 2, primitive != GPU_TRIANGLES ? primitive : GPU_GEOMETRY_PRIM); + // Start a new primitive (breaks off a triangle strip/fan) + GPUCMD_AddWrite(GPUREG_RESTART_PRIMITIVE, 1); + // Number of vertices + GPUCMD_AddWrite(GPUREG_NUMVERTICES, count); + // First vertex + GPUCMD_AddWrite(GPUREG_VERTEX_OFFSET, 0); + // Enable triangle element drawing mode if necessary + GPUCMD_AddMaskedWrite(GPUREG_GEOSTAGE_CONFIG, 2, 0x100); + GPUCMD_AddMaskedWrite(GPUREG_GEOSTAGE_CONFIG2, 2, 0x100); + // Enable drawing mode + GPUCMD_AddMaskedWrite(GPUREG_START_DRAW_FUNC0, 1, 0); + // Trigger element drawing + GPUCMD_AddWrite(GPUREG_DRAWELEMENTS, 1); + // Go back to configuration mode + GPUCMD_AddMaskedWrite(GPUREG_START_DRAW_FUNC0, 1, 1); + // Disable triangle element drawing mode if necessary + GPUCMD_AddMaskedWrite(GPUREG_GEOSTAGE_CONFIG, 2, 0); + GPUCMD_AddMaskedWrite(GPUREG_GEOSTAGE_CONFIG2, 2, 0); + // Clear the post-vertex cache + GPUCMD_AddWrite(GPUREG_VTX_FUNC, 1); + GPUCMD_AddMaskedWrite(GPUREG_PRIMITIVE_CONFIG, 0x8, 0); + GPUCMD_AddMaskedWrite(GPUREG_PRIMITIVE_CONFIG, 0x8, 0); + + C3Di_GetContext()->flags |= C3DiF_DrawUsed; +} + + + + + + + + +static inline C3D_Effect* getEffect() +{ + C3D_Context* ctx = C3Di_GetContext(); + ctx->flags |= C3DiF_Effect; + return &ctx->effect; +} + +static void C3D_DepthMap(bool bIsZBuffer, float zScale, float zOffset) +{ + C3D_Effect* e = getEffect(); + e->zBuffer = bIsZBuffer; + e->zScale = f32tof24(zScale); + e->zOffset = f32tof24(zOffset); +} + +static void C3D_CullFace(GPU_CULLMODE mode) +{ + C3D_Effect* e = getEffect(); + e->cullMode = mode; +} + +static void C3D_StencilTest(void) +{ + C3D_Effect* e = getEffect(); + e->stencilMode = false | (GPU_ALWAYS << 4) | (0xFF << 24); +} + +static void C3D_StencilOp(void) +{ + C3D_Effect* e = getEffect(); + e->stencilOp = GPU_STENCIL_KEEP | (GPU_STENCIL_KEEP << 4) | (GPU_STENCIL_KEEP << 8); +} + +static void C3D_EarlyDepthTest(bool enable, GPU_EARLYDEPTHFUNC function, u32 ref) +{ + C3D_Effect* e = getEffect(); + e->earlyDepth = enable; + e->earlyDepthFunc = function; + e->earlyDepthRef = ref; +} + +static void C3D_DepthTest(bool enable, GPU_TESTFUNC function, GPU_WRITEMASK writemask) +{ + C3D_Effect* e = getEffect(); + e->depthTest = (!!enable) | ((function & 7) << 4) | (writemask << 8); +} + +static void C3D_AlphaTest(bool enable, GPU_TESTFUNC function, int ref) +{ + C3D_Effect* e = getEffect(); + e->alphaTest = (!!enable) | ((function & 7) << 4) | (ref << 8); +} + +static void C3D_AlphaBlend(GPU_BLENDEQUATION colorEq, GPU_BLENDEQUATION alphaEq, GPU_BLENDFACTOR srcClr, GPU_BLENDFACTOR dstClr, GPU_BLENDFACTOR srcAlpha, GPU_BLENDFACTOR dstAlpha) +{ + C3D_Effect* e = getEffect(); + e->alphaBlend = colorEq | (alphaEq << 8) | (srcClr << 16) | (dstClr << 20) | (srcAlpha << 24) | (dstAlpha << 28); + e->fragOpMode &= ~0xFF00; + e->fragOpMode |= 0x0100; +} + +static void C3D_ColorLogicOp(GPU_LOGICOP op) +{ + C3D_Effect* e = getEffect(); + e->fragOpMode &= ~0xFF00; + e->clrLogicOp = op; +} + +static void C3D_FragOpMode(GPU_FRAGOPMODE mode) +{ + C3D_Effect* e = getEffect(); + e->fragOpMode &= ~0xFF00FF; + e->fragOpMode |= 0xE40000 | mode; +} + +static void C3D_FragOpShadow(float scale, float bias) +{ + C3D_Effect* e = getEffect(); + e->fragOpShadow = f32tof16(scale+bias) | (f32tof16(-scale)<<16); +} + +static void C3Di_EffectBind(C3D_Effect* e) +{ + GPUCMD_AddWrite(GPUREG_DEPTHMAP_ENABLE, e->zBuffer ? 1 : 0); + GPUCMD_AddWrite(GPUREG_FACECULLING_CONFIG, e->cullMode & 0x3); + GPUCMD_AddIncrementalWrites(GPUREG_DEPTHMAP_SCALE, (u32*)&e->zScale, 2); + GPUCMD_AddIncrementalWrites(GPUREG_FRAGOP_ALPHA_TEST, (u32*)&e->alphaTest, 4); + GPUCMD_AddMaskedWrite(GPUREG_GAS_DELTAZ_DEPTH, 0x8, (u32)GPU_MAKEGASDEPTHFUNC((e->depthTest>>4)&7) << 24); + GPUCMD_AddWrite(GPUREG_BLEND_COLOR, 0); + GPUCMD_AddWrite(GPUREG_BLEND_FUNC, e->alphaBlend); + GPUCMD_AddWrite(GPUREG_LOGIC_OP, e->clrLogicOp); + GPUCMD_AddMaskedWrite(GPUREG_COLOR_OPERATION, 7, e->fragOpMode); + GPUCMD_AddWrite(GPUREG_FRAGOP_SHADOW, e->fragOpShadow); + GPUCMD_AddMaskedWrite(GPUREG_EARLYDEPTH_TEST1, 1, e->earlyDepth ? 1 : 0); + GPUCMD_AddWrite(GPUREG_EARLYDEPTH_TEST2, e->earlyDepth ? 1 : 0); + GPUCMD_AddMaskedWrite(GPUREG_EARLYDEPTH_FUNC, 1, e->earlyDepthFunc); + GPUCMD_AddMaskedWrite(GPUREG_EARLYDEPTH_DATA, 0x7, e->earlyDepthRef); +} + + + + + + + +static void FogLut_FromArray(C3D_FogLut* lut, const float data[256]) +{ + int i; + for (i = 0; i < 128; i ++) + { + float in = data[i], diff = data[i+128]; + + u32 val = 0; + if (in > 0.0f) + { + in *= 0x800; + val = (in < 0x800) ? (u32)in : 0x7FF; + } + + u32 val2 = 0; + if (diff != 0.0f) + { + diff *= 0x800; + if (diff < -0x1000) diff = -0x1000; + else if (diff > 0xFFF) diff = 0xFFF; + val2 = (s32)diff & 0x1FFF; + } + + lut->data[i] = val2 | (val << 13); + } +} + +static void C3D_FogGasMode(GPU_FOGMODE fogMode, GPU_GASMODE gasMode, bool zFlip) +{ + C3D_Context* ctx = C3Di_GetContext(); + + if (!(ctx->flags & C3DiF_Active)) + return; + + ctx->flags |= C3DiF_TexEnvBuf; + ctx->texEnvBuf &= ~0x100FF; + ctx->texEnvBuf |= (fogMode&7) | ((gasMode&1)<<3) | (zFlip ? BIT(16) : 0); +} + +static void C3D_FogColor(u32 color) +{ + C3D_Context* ctx = C3Di_GetContext(); + + if (!(ctx->flags & C3DiF_Active)) + return; + + ctx->flags |= C3DiF_TexEnvBuf; + ctx->fogClr = color; +} + +static void C3D_FogLutBind(C3D_FogLut* lut) +{ + C3D_Context* ctx = C3Di_GetContext(); + + if (!(ctx->flags & C3DiF_Active)) + return; + + if (lut) + { + ctx->flags |= C3DiF_FogLut; + ctx->fogLut = lut; + } else + ctx->flags &= ~C3DiF_FogLut; +} + + + + + + + + + + +static const u8 colorFmtSizes[] = {2,1,0,0,0}; +static const u8 depthFmtSizes[] = {0,0,1,2}; + +static u32 C3D_CalcColorBufSize(u32 width, u32 height, GPU_COLORBUF fmt) +{ + u32 size = width*height; + return size*(2+colorFmtSizes[fmt]); +} + +static u32 C3D_CalcDepthBufSize(u32 width, u32 height, GPU_DEPTHBUF fmt) +{ + u32 size = width*height; + return size*(2+depthFmtSizes[fmt]); +} + +static C3D_FrameBuf* C3D_GetFrameBuf(void) +{ + C3D_Context* ctx = C3Di_GetContext(); + + ctx->flags |= C3DiF_FrameBuf; + return &ctx->fb; +} + +static void C3D_SetFrameBuf(C3D_FrameBuf* fb) +{ + C3D_Context* ctx = C3Di_GetContext(); + + if (!(ctx->flags & C3DiF_Active)) + return; + + if (fb != &ctx->fb) + memcpy(&ctx->fb, fb, sizeof(*fb)); + ctx->flags |= C3DiF_FrameBuf; +} + +static void C3Di_FrameBufBind(C3D_FrameBuf* fb) +{ + u32 param[4] = { 0, 0, 0, 0 }; + + GPUCMD_AddWrite(GPUREG_FRAMEBUFFER_INVALIDATE, 1); + + param[0] = osConvertVirtToPhys(fb->depthBuf) >> 3; + param[1] = osConvertVirtToPhys(fb->colorBuf) >> 3; + param[2] = 0x01000000 | (((u32)(fb->height-1) & 0xFFF) << 12) | (fb->width & 0xFFF); + GPUCMD_AddIncrementalWrites(GPUREG_DEPTHBUFFER_LOC, param, 3); + + GPUCMD_AddWrite(GPUREG_RENDERBUF_DIM, param[2]); + GPUCMD_AddWrite(GPUREG_DEPTHBUFFER_FORMAT, fb->depthFmt); + GPUCMD_AddWrite(GPUREG_COLORBUFFER_FORMAT, colorFmtSizes[fb->colorFmt] | ((u32)fb->colorFmt << 16)); + GPUCMD_AddWrite(GPUREG_FRAMEBUFFER_BLOCK32, fb->block32 ? 1 : 0); + + // Enable or disable color/depth buffers + param[0] = param[1] = fb->colorBuf ? fb->colorMask : 0; + param[2] = param[3] = fb->depthBuf ? fb->depthMask : 0; + GPUCMD_AddIncrementalWrites(GPUREG_COLORBUFFER_READ, param, 4); +} + +static void C3D_FrameBufClear(C3D_FrameBuf* frameBuf, C3D_ClearBits clearBits, u32 clearColor, u32 clearDepth) +{ + u32 size = (u32)frameBuf->width * frameBuf->height; + u32 cfs = colorFmtSizes[frameBuf->colorFmt]; + u32 dfs = depthFmtSizes[frameBuf->depthFmt]; + void* colorBufEnd = (u8*)frameBuf->colorBuf + size*(2+cfs); + void* depthBufEnd = (u8*)frameBuf->depthBuf + size*(2+dfs); + + if (clearBits & C3D_CLEAR_COLOR) + { + if (clearBits & C3D_CLEAR_DEPTH) + GX_MemoryFill( + (u32*)frameBuf->colorBuf, clearColor, (u32*)colorBufEnd, BIT(0) | (cfs << 8), + (u32*)frameBuf->depthBuf, clearDepth, (u32*)depthBufEnd, BIT(0) | (dfs << 8)); + else + GX_MemoryFill( + (u32*)frameBuf->colorBuf, clearColor, (u32*)colorBufEnd, BIT(0) | (cfs << 8), + NULL, 0, NULL, 0); + } else + GX_MemoryFill( + (u32*)frameBuf->depthBuf, clearDepth, (u32*)depthBufEnd, BIT(0) | (dfs << 8), + NULL, 0, NULL, 0); +} + +static void C3D_FrameBufTransfer(C3D_FrameBuf* frameBuf, gfxScreen_t screen, gfx3dSide_t side, u32 transferFlags) +{ + u32* outputFrameBuf = (u32*)gfxGetFramebuffer(screen, side, NULL, NULL); + u32 dim = GX_BUFFER_DIM((u32)frameBuf->width, (u32)frameBuf->height); + GX_DisplayTransfer((u32*)frameBuf->colorBuf, dim, outputFrameBuf, dim, transferFlags); +} + + + + + + + +static void C3D_ImmDrawBegin(GPU_Primitive_t primitive) +{ + C3Di_UpdateContext(); + + // Set primitive type + GPUCMD_AddMaskedWrite(GPUREG_PRIMITIVE_CONFIG, 2, primitive); + // Start a new primitive (breaks off a triangle strip/fan) + GPUCMD_AddWrite(GPUREG_RESTART_PRIMITIVE, 1); + // Enable vertex submission mode + GPUCMD_AddMaskedWrite(GPUREG_GEOSTAGE_CONFIG2, 1, 1); + // Enable drawing mode + GPUCMD_AddMaskedWrite(GPUREG_START_DRAW_FUNC0, 1, 0); + // Begin immediate-mode vertex submission + GPUCMD_AddWrite(GPUREG_FIXEDATTRIB_INDEX, 0xF); +} + +static inline void write24(u8* p, u32 val) +{ + p[0] = val; + p[1] = val>>8; + p[2] = val>>16; +} + +static void C3D_ImmSendAttrib(float x, float y, float z, float w) +{ + union + { + u32 packed[3]; + struct + { + u8 x[3]; + u8 y[3]; + u8 z[3]; + u8 w[3]; + }; + } param; + + // Convert the values to float24 + write24(param.x, f32tof24(x)); + write24(param.y, f32tof24(y)); + write24(param.z, f32tof24(z)); + write24(param.w, f32tof24(w)); + + // Reverse the packed words + u32 p = param.packed[0]; + param.packed[0] = param.packed[2]; + param.packed[2] = p; + + // Send the attribute + GPUCMD_AddIncrementalWrites(GPUREG_FIXEDATTRIB_DATA0, param.packed, 3); +} + +static void C3D_ImmDrawEnd(void) +{ + // Go back to configuration mode + GPUCMD_AddMaskedWrite(GPUREG_START_DRAW_FUNC0, 1, 1); + // Disable vertex submission mode + GPUCMD_AddMaskedWrite(GPUREG_GEOSTAGE_CONFIG2, 1, 0); + // Clear the post-vertex cache + GPUCMD_AddWrite(GPUREG_VTX_FUNC, 1); + + C3Di_GetContext()->flags |= C3DiF_DrawUsed; +} + + + +static C3D_RenderTarget *linkedTarget[3]; + +static bool inFrame, inSafeTransfer; +static bool needSwapTop, needSwapBot, isTopStereo; +static u32 vblankCounter[2]; + +static void C3Di_RenderTargetDestroy(C3D_RenderTarget* target); + +static void onVBlank0(void* unused) +{ + vblankCounter[0]++; +} + +static void onVBlank1(void* unused) +{ + vblankCounter[1]++; +} + +static void onQueueFinish(gxCmdQueue_s* queue) +{ + if (inSafeTransfer) + { + inSafeTransfer = false; + if (inFrame) + { + gxCmdQueueStop(queue); + gxCmdQueueClear(queue); + } + } + else + { + if (needSwapTop) + { + gfxScreenSwapBuffers(GFX_TOP, isTopStereo); + needSwapTop = false; + } + if (needSwapBot) + { + gfxScreenSwapBuffers(GFX_BOTTOM, false); + needSwapBot = false; + } + } +} + +static void C3D_FrameSync(void) +{ + u32 cur[2]; + u32 start[2] = { vblankCounter[0], vblankCounter[1] }; + do + { + gspWaitForAnyEvent(); + cur[0] = vblankCounter[0]; + cur[1] = vblankCounter[1]; + } while (cur[0]==start[0] || cur[1]==start[1]); +} + +static bool C3Di_WaitAndClearQueue(s64 timeout) +{ + gxCmdQueue_s* queue = &C3Di_GetContext()->gxQueue; + if (!gxCmdQueueWait(queue, timeout)) + return false; + gxCmdQueueStop(queue); + gxCmdQueueClear(queue); + return true; +} + +static void C3Di_RenderQueueEnableVBlank(void) +{ + gspSetEventCallback(GSPGPU_EVENT_VBlank0, onVBlank0, NULL, false); + gspSetEventCallback(GSPGPU_EVENT_VBlank1, onVBlank1, NULL, false); +} + +static void C3Di_RenderQueueDisableVBlank(void) +{ + gspSetEventCallback(GSPGPU_EVENT_VBlank0, NULL, NULL, false); + gspSetEventCallback(GSPGPU_EVENT_VBlank1, NULL, NULL, false); +} + +static void C3Di_RenderQueueInit(void) +{ + C3D_Context* ctx = C3Di_GetContext(); + + C3Di_RenderQueueEnableVBlank(); + + GX_BindQueue(&ctx->gxQueue); + gxCmdQueueSetCallback(&ctx->gxQueue, onQueueFinish, NULL); + gxCmdQueueRun(&ctx->gxQueue); +} + +static void C3Di_RenderQueueExit(void) +{ + C3Di_WaitAndClearQueue(-1); + gxCmdQueueSetCallback(&C3Di_GetContext()->gxQueue, NULL, NULL); + GX_BindQueue(NULL); + + C3Di_RenderQueueDisableVBlank(); +} + +static void C3Di_RenderQueueWaitDone(void) +{ + C3Di_WaitAndClearQueue(-1); +} + +static bool C3D_FrameBegin(u8 flags) +{ + C3D_Context* ctx = C3Di_GetContext(); + if (inFrame) return false; + + if (!C3Di_WaitAndClearQueue((flags & C3D_FRAME_NONBLOCK) ? 0 : -1)) + return false; + + inFrame = true; + GPUCMD_SetBuffer(ctx->cmdBuf, ctx->cmdBufSize, 0); + return true; +} + +static bool C3D_FrameDrawOn(C3D_RenderTarget* target) +{ + if (!inFrame) return false; + + target->used = true; + C3D_SetFrameBuf(&target->frameBuf); + C3D_SetViewport(0, 0, target->frameBuf.width, target->frameBuf.height); + return true; +} + +static void C3D_FrameSplit(u8 flags) +{ + u32 *cmdBuf, cmdBufSize; + if (!inFrame) return; + if (C3Di_SplitFrame(&cmdBuf, &cmdBufSize)) + GX_ProcessCommandList(cmdBuf, cmdBufSize*4, flags); +} + +static void C3D_FrameEnd(u8 flags) +{ + C3D_Context* ctx = C3Di_GetContext(); + if (!inFrame) return; + + C3D_FrameSplit(flags); + GPUCMD_SetBuffer(NULL, 0, 0); + inFrame = false; + + // Flush the entire linear memory if the user did not explicitly mandate to flush the command list + if (!(flags & GX_CMDLIST_FLUSH)) + { + extern u32 __ctru_linear_heap; + extern u32 __ctru_linear_heap_size; + GSPGPU_FlushDataCache((void*)__ctru_linear_heap, __ctru_linear_heap_size); + } + + C3D_RenderTarget* target; + isTopStereo = false; + needSwapTop = true; + needSwapBot = true; + + for (int i = 2; i >= 0; i --) + { + target = linkedTarget[i]; + if (!target || !target->used) + continue; + + target->used = false; + C3D_FrameBufTransfer(&target->frameBuf, target->screen, target->side, target->transferFlags); + + if (target->screen == GFX_TOP && target->side == GFX_RIGHT) isTopStereo = true; + } + + gxCmdQueueRun(&ctx->gxQueue); +} + +void C3D_RenderTargetCreate(C3D_RenderTarget* target, int width, int height, GPU_COLORBUF colorFmt, GPU_DEPTHBUF depthFmt) +{ + size_t colorSize = C3D_CalcColorBufSize(width,height,colorFmt); + size_t depthSize = C3D_CalcDepthBufSize(width,height,depthFmt); + memset(target, 0, sizeof(C3D_RenderTarget)); + + void* depthBuf = NULL; + void* colorBuf = vramAlloc(colorSize); + if (!colorBuf) goto _fail; + + vramAllocPos vramBank = addrGetVRAMBank(colorBuf); + depthBuf = vramAllocAt(depthSize, vramBank ^ VRAM_ALLOC_ANY); // Attempt opposite bank first... + if (!depthBuf) depthBuf = vramAllocAt(depthSize, vramBank); // ... if that fails, attempt same bank + if (!depthBuf) goto _fail; + + C3D_FrameBuf* fb = &target->frameBuf; + C3D_FrameBufAttrib(fb, width, height, false); + C3D_FrameBufColor(fb, colorBuf, colorFmt); + C3D_FrameBufDepth(fb, depthBuf, depthFmt); + return; + +_fail: + if (depthBuf) vramFree(depthBuf); + if (colorBuf) vramFree(colorBuf); +} + +static void C3Di_RenderTargetDestroy(C3D_RenderTarget* target) +{ + vramFree(target->frameBuf.colorBuf); + vramFree(target->frameBuf.depthBuf); +} + +static void C3D_RenderTargetDelete(C3D_RenderTarget* target) +{ + if (inFrame) + svcBreak(USERBREAK_PANIC); // Shouldn't happen. + if (target->linked) + C3D_RenderTargetDetachOutput(target); + else + C3Di_WaitAndClearQueue(-1); + C3Di_RenderTargetDestroy(target); +} + +static void C3D_RenderTargetSetOutput(C3D_RenderTarget* target, gfxScreen_t screen, gfx3dSide_t side, u32 transferFlags) +{ + int id = 0; + if (screen==GFX_BOTTOM) id = 2; + else if (side==GFX_RIGHT) id = 1; + if (linkedTarget[id]) + { + linkedTarget[id]->linked = false; + if (!inFrame) + C3Di_WaitAndClearQueue(-1); + } + linkedTarget[id] = target; + if (target) + { + target->linked = true; + target->transferFlags = transferFlags; + target->screen = screen; + target->side = side; + } +} + +static void C3Di_SafeTextureCopy(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 size, u32 flags) +{ + C3Di_WaitAndClearQueue(-1); + inSafeTransfer = true; + GX_TextureCopy(inadr, indim, outadr, outdim, size, flags); + gxCmdQueueRun(&C3Di_GetContext()->gxQueue); +} + +static void C3D_SyncTextureCopy(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 size, u32 flags) +{ + if (inFrame) + { + C3D_FrameSplit(0); + GX_TextureCopy(inadr, indim, outadr, outdim, size, flags); + } else + { + C3Di_SafeTextureCopy(inadr, indim, outadr, outdim, size, flags); + gspWaitForPPF(); + } +} + + + + + + + +static void C3Di_TexEnvBind(int id, C3D_TexEnv* env) +{ + if (id >= 4) id += 2; + GPUCMD_AddIncrementalWrites(GPUREG_TEXENV0_SOURCE + id*8, (u32*)env, sizeof(C3D_TexEnv)/sizeof(u32)); +} + + + + + +static void C3D_TexLoadImage(C3D_Tex* tex, const void* data, GPU_TEXFACE face, int level) +{ + u32 size = 0; + void* out = C3D_TexGetImagePtr(tex, tex->data, level, &size); + + if (!addrIsVRAM(out)) + memcpy(out, data, size); + else + C3D_SyncTextureCopy((u32*)data, 0, (u32*)out, 0, size, 8); +} + +static void C3D_TexBind(int unitId, C3D_Tex* tex) +{ + C3D_Context* ctx = C3Di_GetContext(); + + ctx->flags |= C3DiF_Tex(unitId); + ctx->tex[unitId] = tex; +} + +static void C3D_TexFlush(C3D_Tex* tex) +{ + if (!addrIsVRAM(tex->data)) + GSPGPU_FlushDataCache(tex->data, C3D_TexCalcTotalSize(tex->size, tex->maxLevel)); +} + +static void C3D_TexDelete(C3D_Tex* tex) +{ + void* addr = tex->data; + if (addrIsVRAM(addr)) + vramFree(addr); + else + linearFree(addr); +} + +static void C3Di_SetTex(int unit, C3D_Tex* tex) +{ + u32 reg[10]; + u32 regcount = 5; + reg[0] = tex->border; + reg[1] = tex->dim; + reg[2] = tex->param; + reg[3] = tex->lodParam; + reg[4] = osConvertVirtToPhys(tex->data) >> 3; + + switch (unit) + { + case 0: + GPUCMD_AddIncrementalWrites(GPUREG_TEXUNIT0_BORDER_COLOR, reg, regcount); + GPUCMD_AddWrite(GPUREG_TEXUNIT0_TYPE, tex->fmt); + break; + case 1: + GPUCMD_AddIncrementalWrites(GPUREG_TEXUNIT1_BORDER_COLOR, reg, 5); + GPUCMD_AddWrite(GPUREG_TEXUNIT1_TYPE, tex->fmt); + break; + case 2: + GPUCMD_AddIncrementalWrites(GPUREG_TEXUNIT2_BORDER_COLOR, reg, 5); + GPUCMD_AddWrite(GPUREG_TEXUNIT2_TYPE, tex->fmt); + break; + } +} + + + + + + + + +static struct +{ + bool dirty; + int count; + float24Uniform_s* data; +} C3Di_ShaderFVecData; + +static bool C3Di_FVUnifEverDirty[C3D_FVUNIF_COUNT]; +static bool C3Di_IVUnifEverDirty[C3D_IVUNIF_COUNT]; + +static void C3D_UpdateUniforms(void) +{ + int i = 0; + + // Update FVec uniforms that come from shader constants + if (C3Di_ShaderFVecData.dirty) + { + while (i < C3Di_ShaderFVecData.count) + { + float24Uniform_s* u = &C3Di_ShaderFVecData.data[i++]; + GPUCMD_AddIncrementalWrites(GPUREG_VSH_FLOATUNIFORM_CONFIG, (u32*)u, 4); + C3D_FVUnifDirty[u->id] = false; + } + C3Di_ShaderFVecData.dirty = false; + i = 0; + } + + // Update FVec uniforms + while (i < C3D_FVUNIF_COUNT) + { + if (!C3D_FVUnifDirty[i]) + { + i ++; + continue; + } + + // Find the number of consecutive dirty uniforms + int j; + for (j = i; j < C3D_FVUNIF_COUNT && C3D_FVUnifDirty[j]; j ++); + + // Upload the uniforms + GPUCMD_AddWrite(GPUREG_VSH_FLOATUNIFORM_CONFIG, 0x80000000|i); + GPUCMD_AddWrites(GPUREG_VSH_FLOATUNIFORM_DATA, (u32*)&C3D_FVUnif[i], (j-i)*4); + + // Clear the dirty flag + int k; + for (k = i; k < j; k ++) + { + C3D_FVUnifDirty[k] = false; + C3Di_FVUnifEverDirty[k] = true; + } + + // Advance + i = j; + } + + // Update IVec uniforms + for (i = 0; i < C3D_IVUNIF_COUNT; i ++) + { + if (!C3D_IVUnifDirty[i]) continue; + + GPUCMD_AddWrite(GPUREG_VSH_INTUNIFORM_I0+i, C3D_IVUnif[i]); + C3D_IVUnifDirty[i] = false; + C3Di_IVUnifEverDirty[i] = false; + } + + // Update bool uniforms + if (C3D_BoolUnifsDirty) + { + GPUCMD_AddWrite(GPUREG_VSH_BOOLUNIFORM, 0x7FFF0000 | C3D_BoolUnifs); + C3D_BoolUnifsDirty = false; + } +} + +static void C3Di_DirtyUniforms(void) +{ + int i; + C3D_BoolUnifsDirty = true; + if (C3Di_ShaderFVecData.count) + C3Di_ShaderFVecData.dirty = true; + for (i = 0; i < C3D_FVUNIF_COUNT; i ++) + C3D_FVUnifDirty[i] = C3D_FVUnifDirty[i] || C3Di_FVUnifEverDirty[i]; + for (i = 0; i < C3D_IVUNIF_COUNT; i ++) + C3D_IVUnifDirty[i] = C3D_IVUnifDirty[i] || C3Di_IVUnifEverDirty[i]; +} + +static void C3Di_LoadShaderUniforms(shaderInstance_s* si) +{ + if (si->boolUniformMask) + { + C3D_BoolUnifs &= ~si->boolUniformMask; + C3D_BoolUnifs |= si->boolUniforms; + } + + C3D_BoolUnifsDirty = true; + + if (si->intUniformMask) + { + int i; + for (i = 0; i < 4; i ++) + { + if (si->intUniformMask & BIT(i)) + { + C3D_IVUnif[i] = si->intUniforms[i]; + C3D_IVUnifDirty[i] = true; + } + } + } + C3Di_ShaderFVecData.dirty = true; + C3Di_ShaderFVecData.count = si->numFloat24Uniforms; + C3Di_ShaderFVecData.data = si->float24Uniforms; +} + + + + + + + + +static aptHookCookie hookCookie; + +static void C3Di_AptEventHook(APT_HookType hookType, void* param) +{ + C3D_Context* ctx = C3Di_GetContext(); + + switch (hookType) + { + case APTHOOK_ONSUSPEND: + { + C3Di_RenderQueueWaitDone(); + C3Di_RenderQueueDisableVBlank(); + break; + } + case APTHOOK_ONRESTORE: + { + C3Di_RenderQueueEnableVBlank(); + ctx->flags |= C3DiF_AttrInfo | C3DiF_Effect | C3DiF_FrameBuf + | C3DiF_Viewport | C3DiF_Scissor | C3DiF_Program | C3DiF_VshCode | C3DiF_GshCode + | C3DiF_TexAll | C3DiF_TexEnvBuf | C3DiF_Gas | C3DiF_Reset; + + C3Di_DirtyUniforms(); + + if (ctx->fogLut) + ctx->flags |= C3DiF_FogLut; + break; + } + default: + break; + } +} + +static bool C3D_Init(size_t cmdBufSize) +{ + int i; + C3D_Context* ctx = C3Di_GetContext(); + + if (ctx->flags & C3DiF_Active) + return false; + + cmdBufSize = (cmdBufSize + 0xF) &~ 0xF; // 0x10-byte align + ctx->cmdBufSize = cmdBufSize/4; + ctx->cmdBuf = (u32*)linearAlloc(cmdBufSize); + if (!ctx->cmdBuf) + return false; + + ctx->gxQueue.maxEntries = 32; + ctx->gxQueue.entries = (gxCmdEntry_s*)malloc(ctx->gxQueue.maxEntries*sizeof(gxCmdEntry_s)); + if (!ctx->gxQueue.entries) + { + linearFree(ctx->cmdBuf); + return false; + } + + ctx->flags = C3DiF_Active | C3DiF_TexEnvBuf | C3DiF_Effect | C3DiF_TexStatus | C3DiF_TexAll | C3DiF_Reset; + + // TODO: replace with direct struct access + C3D_DepthMap(true, -1.0f, 0.0f); + C3D_CullFace(GPU_CULL_BACK_CCW); + C3D_StencilTest(); + C3D_StencilOp(); + C3D_EarlyDepthTest(false, GPU_EARLYDEPTH_GREATER, 0); + C3D_DepthTest(true, GPU_GREATER, GPU_WRITE_ALL); + C3D_AlphaTest(false, GPU_ALWAYS, 0x00); + C3D_AlphaBlend(GPU_BLEND_ADD, GPU_BLEND_ADD, GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA); + C3D_FragOpMode(GPU_FRAGOPMODE_GL); + C3D_FragOpShadow(0.0, 1.0); + + ctx->texConfig = BIT(12); + ctx->texEnvBuf = 0; + ctx->texEnvBufClr = 0xFFFFFFFF; + ctx->fogClr = 0; + ctx->fogLut = NULL; + + for (i = 0; i < 3; i ++) + ctx->tex[i] = NULL; + + C3Di_RenderQueueInit(); + aptHook(&hookCookie, C3Di_AptEventHook, NULL); + + return true; +} + +static void C3D_SetViewport(u32 x, u32 y, u32 w, u32 h) +{ + C3D_Context* ctx = C3Di_GetContext(); + ctx->flags |= C3DiF_Viewport | C3DiF_Scissor; + ctx->viewport[0] = f32tof24(w / 2.0f); + ctx->viewport[1] = f32tof31(2.0f / w) << 1; + ctx->viewport[2] = f32tof24(h / 2.0f); + ctx->viewport[3] = f32tof31(2.0f / h) << 1; + ctx->viewport[4] = (y << 16) | (x & 0xFFFF); + ctx->scissor[0] = GPU_SCISSOR_DISABLE; +} + +static void C3D_SetScissor(GPU_SCISSORMODE mode, u32 left, u32 top, u32 right, u32 bottom) +{ + C3D_Context* ctx = C3Di_GetContext(); + ctx->flags |= C3DiF_Scissor; + ctx->scissor[0] = mode; + if (mode == GPU_SCISSOR_DISABLE) return; + ctx->scissor[1] = (top << 16) | (left & 0xFFFF); + ctx->scissor[2] = ((bottom-1) << 16) | ((right-1) & 0xFFFF); +} + +static void C3Di_UpdateContext(void) +{ + int i; + C3D_Context* ctx = C3Di_GetContext(); + + if (ctx->flags & C3DiF_FrameBuf) + { + ctx->flags &= ~C3DiF_FrameBuf; + if (ctx->flags & C3DiF_DrawUsed) + { + ctx->flags &= ~C3DiF_DrawUsed; + GPUCMD_AddWrite(GPUREG_FRAMEBUFFER_FLUSH, 1); + GPUCMD_AddWrite(GPUREG_EARLYDEPTH_CLEAR, 1); + } + C3Di_FrameBufBind(&ctx->fb); + } + + if (ctx->flags & C3DiF_Viewport) + { + ctx->flags &= ~C3DiF_Viewport; + GPUCMD_AddIncrementalWrites(GPUREG_VIEWPORT_WIDTH, ctx->viewport, 4); + GPUCMD_AddWrite(GPUREG_VIEWPORT_XY, ctx->viewport[4]); + } + + if (ctx->flags & C3DiF_Scissor) + { + ctx->flags &= ~C3DiF_Scissor; + GPUCMD_AddIncrementalWrites(GPUREG_SCISSORTEST_MODE, ctx->scissor, 3); + } + + if (ctx->flags & C3DiF_Program) + { + shaderProgramConfigure(ctx->program, (ctx->flags & C3DiF_VshCode) != 0, (ctx->flags & C3DiF_GshCode) != 0); + ctx->flags &= ~(C3DiF_Program | C3DiF_VshCode | C3DiF_GshCode); + } + + if (ctx->flags & C3DiF_AttrInfo) + { + ctx->flags &= ~C3DiF_AttrInfo; + C3Di_AttrInfoBind(&ctx->attrInfo); + } + + if (ctx->flags & C3DiF_Effect) + { + ctx->flags &= ~C3DiF_Effect; + C3Di_EffectBind(&ctx->effect); + } + + if (ctx->flags & C3DiF_TexAll) + { + u32 units = 0; + for (i = 0; i < 3; i ++) + { + if (ctx->tex[i]) + { + units |= BIT(i); + if (ctx->flags & C3DiF_Tex(i)) + C3Di_SetTex(i, ctx->tex[i]); + } + } + + // Enable texture units and clear texture cache + ctx->texConfig &= ~7; + ctx->texConfig |= units | BIT(16); + ctx->flags &= ~C3DiF_TexAll; + ctx->flags |= C3DiF_TexStatus; + } + + if (ctx->flags & C3DiF_TexStatus) + { + ctx->flags &= ~C3DiF_TexStatus; + GPUCMD_AddMaskedWrite(GPUREG_TEXUNIT_CONFIG, 0xB, ctx->texConfig); + // Clear texture cache if requested *after* configuring texture units + if (ctx->texConfig & BIT(16)) + { + ctx->texConfig &= ~BIT(16); + GPUCMD_AddMaskedWrite(GPUREG_TEXUNIT_CONFIG, 0x4, BIT(16)); + } + GPUCMD_AddWrite(GPUREG_TEXUNIT0_SHADOW, BIT(0)); + } + + if (ctx->flags & C3DiF_TexEnvBuf) + { + ctx->flags &= ~C3DiF_TexEnvBuf; + GPUCMD_AddMaskedWrite(GPUREG_TEXENV_UPDATE_BUFFER, 0x7, ctx->texEnvBuf); + GPUCMD_AddWrite(GPUREG_TEXENV_BUFFER_COLOR, ctx->texEnvBufClr); + GPUCMD_AddWrite(GPUREG_FOG_COLOR, ctx->fogClr); + } + + if ((ctx->flags & C3DiF_FogLut) && (ctx->texEnvBuf&7) != GPU_NO_FOG) + { + ctx->flags &= ~C3DiF_FogLut; + if (ctx->fogLut) + { + GPUCMD_AddWrite(GPUREG_FOG_LUT_INDEX, 0); + GPUCMD_AddWrites(GPUREG_FOG_LUT_DATA0, ctx->fogLut->data, 128); + } + } + + if (ctx->flags & C3DiF_Reset) + { + // Reset texture environment + C3D_TexEnv texEnv; + C3D_TexEnvInit(&texEnv); + for (i = 0; i < 6; i++) + { + C3Di_TexEnvBind(i, &texEnv); + } + + // Reset lighting + GPUCMD_AddWrite(GPUREG_LIGHTING_ENABLE0, false); + GPUCMD_AddWrite(GPUREG_LIGHTING_ENABLE1, true); + + // Reset attirubte buffer info + C3D_BufCfg buffers[12] = { 0 }; + GPUCMD_AddWrite(GPUREG_ATTRIBBUFFERS_LOC, BUFFER_BASE_PADDR >> 3); + GPUCMD_AddIncrementalWrites(GPUREG_ATTRIBBUFFER0_OFFSET, (u32*)buffers, 12 * 3); + + ctx->flags &= ~C3DiF_Reset; + } + + C3D_UpdateUniforms(); +} + +static bool C3Di_SplitFrame(u32** pBuf, u32* pSize) +{ + C3D_Context* ctx = C3Di_GetContext(); + + if (!gpuCmdBufOffset) + return false; // Nothing was drawn + + if (ctx->flags & C3DiF_DrawUsed) + { + ctx->flags &= ~C3DiF_DrawUsed; + GPUCMD_AddWrite(GPUREG_FRAMEBUFFER_FLUSH, 1); + GPUCMD_AddWrite(GPUREG_FRAMEBUFFER_INVALIDATE, 1); + GPUCMD_AddWrite(GPUREG_EARLYDEPTH_CLEAR, 1); + } + + GPUCMD_Split(pBuf, pSize); + return true; +} + +static void C3D_Fini(void) +{ + C3D_Context* ctx = C3Di_GetContext(); + + if (!(ctx->flags & C3DiF_Active)) + return; + + aptUnhook(&hookCookie); + C3Di_RenderQueueExit(); + free(ctx->gxQueue.entries); + linearFree(ctx->cmdBuf); + ctx->flags = 0; +} + +static void C3D_BindProgram(shaderProgram_s* program) +{ + C3D_Context* ctx = C3Di_GetContext(); + + shaderProgram_s* oldProg = ctx->program; + if (oldProg != program) + { + ctx->program = program; + ctx->flags |= C3DiF_Program | C3DiF_AttrInfo; + + if (!oldProg) + ctx->flags |= C3DiF_VshCode | C3DiF_GshCode; + else + { + DVLP_s* oldProgV = oldProg->vertexShader->dvle->dvlp; + DVLP_s* newProgV = program->vertexShader->dvle->dvlp; + + if (oldProgV != newProgV) + ctx->flags |= C3DiF_VshCode | C3DiF_GshCode; + } + } + + C3Di_LoadShaderUniforms(program->vertexShader); +} |