Leahnaya/pokeplatinum
1
0
Fork 0
mirror of https://github.com/pret/pokeplatinum.git synced 2026-04-25 07:29:01 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Match all of NitroSDK/gx

Browse Source
This commit is contained in:
Nomura 2023-01-09 15:58:05 -05:00
parent ddb4be6f62
commit 9cff2da302
38 changed files with 5303 additions and 4802 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
lib/NitroSDK/asm/gx/g2.s
View File

@ -1,124 +0,0 @@
.include "macros/function.inc"
.text
arm_func_start G2x_SetBGyAffine_
G2x_SetBGyAffine_: ; 0x020BF4AC
stmfd sp!, {r4, r5, r6, lr}
ldr r4, [r1, #4]
ldr r5, [r1, #0]
mov ip, r4, lsl #0xc
mov r4, ip, asr #0x10
mov ip, r5, lsl #0xc
mov lr, r4, lsl #0x10
mov r5, ip, asr #0x10
mov r4, lr, lsr #0x10
mov ip, r5, lsl #0x10
mov r4, r4, lsl #0x10
orr r4, r4, ip, lsr #16
str r4, [r0, #0]
ldr r4, [r1, #0xc]
ldr r5, [r1, #8]
mov ip, r4, lsl #0xc
mov r4, ip, asr #0x10
mov ip, r5, lsl #0xc
mov lr, r4, lsl #0x10
mov r6, ip, asr #0x10
mov r5, lr, lsr #0x10
ldr r4, [sp, #0x14]
mov ip, r6, lsl #0x10
mov r5, r5, lsl #0x10
orr r5, r5, ip, lsr #16
str r5, [r0, #4]
ldr r6, [sp, #0x10]
ldr ip, [r1, #4]
sub r5, r4, r3
ldr r4, [r1, #0xc]
mul lr, ip, r5
mul r5, r4, r5
ldr ip, [r1]
sub r6, r6, r2
ldr r4, [r1, #8]
mla r1, ip, r6, lr
mla r5, r4, r6, r5
add r1, r1, r2, lsl #12
add r2, r5, r3, lsl #12
mov r1, r1, asr #4
str r1, [r0, #8]
mov r1, r2, asr #4
str r1, [r0, #0xc]
ldmia sp!, {r4, r5, r6, pc}
arm_func_end G2x_SetBGyAffine_
arm_func_start G2x_SetBlendAlpha_
G2x_SetBlendAlpha_: ; 0x020BF55C
ldr ip, [sp]
orr r1, r1, #0x40
orr r2, r1, r2, lsl #8
orr r1, r3, ip, lsl #8
orr r1, r2, r1, lsl #16
str r1, [r0, #0]
bx lr
arm_func_end G2x_SetBlendAlpha_
arm_func_start G2x_SetBlendBrightness_
G2x_SetBlendBrightness_: ; 0x020BF578
cmp r2, #0
orrge r1, r1, #0x80
strgeh r1, [r0]
strgeh r2, [r0, #4]
bxge lr
orr r1, r1, #0xc0
strh r1, [r0]
rsb r1, r2, #0
strh r1, [r0, #4]
bx lr
arm_func_end G2x_SetBlendBrightness_
arm_func_start G2x_SetBlendBrightnessExt_
G2x_SetBlendBrightnessExt_: ; 0x020BF5A0
stmfd sp!, {r3, lr}
ldr lr, [sp, #8]
ldr ip, [sp, #0xc]
orr r3, r3, lr, lsl #8
strh r3, [r0, #2]
cmp ip, #0
bge _020BF5D4
orr r1, r1, #0xc0
orr r1, r1, r2, lsl #8
strh r1, [r0]
rsb r1, ip, #0
strh r1, [r0, #4]
ldmia sp!, {r3, pc}
_020BF5D4:
orr r1, r1, #0x80
orr r1, r1, r2, lsl #8
strh r1, [r0]
strh ip, [r0, #4]
ldmia sp!, {r3, pc}
arm_func_end G2x_SetBlendBrightnessExt_
arm_func_start G2x_ChangeBlendBrightness_
G2x_ChangeBlendBrightness_: ; 0x020BF5E8
ldrh r3, [r0]
cmp r1, #0
and r2, r3, #0xc0
bge _020BF614
cmp r2, #0x80
biceq r2, r3, #0xc0
orreq r2, r2, #0xc0
streqh r2, [r0]
rsb r1, r1, #0
strh r1, [r0, #4]
bx lr
_020BF614:
cmp r2, #0xc0
biceq r2, r3, #0xc0
orreq r2, r2, #0x80
streqh r2, [r0]
strh r1, [r0, #4]
bx lr
arm_func_end G2x_ChangeBlendBrightness_

121
lib/NitroSDK/asm/gx/g3_util.s
View File

@ -1,121 +0,0 @@
.include "macros/function.inc"
.include "include/g3_util.inc"
.text
arm_func_start G3i_OrthoW_
G3i_OrthoW_: ; 0x020BFF50
stmfd sp!, {r4, lr}
sub sp, sp, #0x50
ldr ip, [sp, #0x58]
ldr lr, [sp, #0x5c]
str ip, [sp]
ldr r4, [sp, #0x68]
ldr ip, [sp, #0x60]
str lr, [sp, #4]
cmp r4, #0
addeq r4, sp, #0x10
str ip, [sp, #8]
str r4, [sp, #0xc]
bl MTX_OrthoW
ldr r0, [sp, #0x64]
cmp r0, #0
addeq sp, sp, #0x50
ldmeqia sp!, {r4, pc}
ldr r1, _020BFFB0 ; =0x04000440
mov r2, #0
mov r0, r4
str r2, [r1, #0]
bl G3_LoadMtx44
add sp, sp, #0x50
ldmia sp!, {r4, pc}
; .align 2, 0
_020BFFB0: .word 0x04000440
arm_func_end G3i_OrthoW_
arm_func_start G3i_LookAt_
G3i_LookAt_: ; 0x020BFFB4
stmfd sp!, {r3, r4, r5, lr}
sub sp, sp, #0x30
ldr r4, [sp, #0x40]
mov r5, r3
cmp r4, #0
addeq r4, sp, #0
mov r3, r4
bl MTX_LookAt
cmp r5, #0
addeq sp, sp, #0x30
ldmeqia sp!, {r3, r4, r5, pc}
ldr r1, _020BFFFC ; =0x04000440
mov r2, #2
mov r0, r4
str r2, [r1, #0]
bl G3_LoadMtx43
add sp, sp, #0x30
ldmia sp!, {r3, r4, r5, pc}
; .align 2, 0
_020BFFFC: .word 0x04000440
arm_func_end G3i_LookAt_
arm_func_start G3_RotX
G3_RotX: ; 0x020C0000
ldr r3, _020C0038 ; =0x04000468
mov r2, #0x1000
str r2, [r3, #0]
mov r2, #0
str r2, [r3, #0]
str r2, [r3, #0]
str r2, [r3, #0]
str r1, [r3, #0]
str r0, [r3, #0]
str r2, [r3, #0]
rsb r0, r0, #0
str r0, [r3, #0]
str r1, [r3, #0]
bx lr
; .align 2, 0
_020C0038: .word 0x04000468
arm_func_end G3_RotX
arm_func_start G3_RotY
G3_RotY: ; 0x020C003C
ldr ip, _020C0074 ; =0x04000468
mov r3, #0
str r1, [ip]
str r3, [ip]
rsb r2, r0, #0
str r2, [ip]
str r3, [ip]
mov r2, #0x1000
str r2, [ip]
str r3, [ip]
str r0, [ip]
str r3, [ip]
str r1, [ip]
bx lr
; .align 2, 0
_020C0074: .word 0x04000468
arm_func_end G3_RotY
arm_func_start G3_RotZ
G3_RotZ: ; 0x020C0078
ldr r3, _020C00B0 ; =0x04000468
mov r2, #0
str r1, [r3, #0]
str r0, [r3, #0]
str r2, [r3, #0]
rsb r0, r0, #0
str r0, [r3, #0]
str r1, [r3, #0]
str r2, [r3, #0]
str r2, [r3, #0]
str r2, [r3, #0]
mov r0, #0x1000
str r0, [r3, #0]
bx lr
; .align 2, 0
_020C00B0: .word 0x04000468
arm_func_end G3_RotZ

261
lib/NitroSDK/asm/gx/g3b.s
View File

@ -1,261 +0,0 @@
.include "macros/function.inc"
.include "include/g3b.inc"
.text
arm_func_start G3BS_LoadMtx44
G3BS_LoadMtx44: ; 0x020BF62C
mov r3, r0
ldr r0, [r3, #0]
mov r2, #0x16
str r2, [r0, #0]
mov r0, r1
ldr ip, _020BF64C ; =MI_Copy64B
ldr r1, [r3, #4]
bx ip
; .align 2, 0
_020BF64C: .word MI_Copy64B
arm_func_end G3BS_LoadMtx44
arm_func_start G3B_PushMtx
G3B_PushMtx: ; 0x020BF650
ldr r1, [r0, #0]
mov r2, #0x11
str r2, [r1, #0]
ldr r1, [r0, #4]
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
bx lr
arm_func_end G3B_PushMtx
arm_func_start G3B_PopMtx
G3B_PopMtx: ; 0x020BF670
ldr r2, [r0, #0]
mov r3, #0x12
str r3, [r2, #0]
ldr r2, [r0, #4]
str r1, [r2, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
bx lr
arm_func_end G3B_PopMtx
arm_func_start G3B_LoadMtx44
G3B_LoadMtx44: ; 0x020BF69C
stmfd sp!, {r4, lr}
mov r4, r0
bl G3BS_LoadMtx44
ldr r0, [r4, #4]
add r0, r0, #0x40
str r0, [r4, #0]
add r0, r0, #4
str r0, [r4, #4]
ldmia sp!, {r4, pc}
arm_func_end G3B_LoadMtx44
arm_func_start G3B_Color
G3B_Color: ; 0x020BF6C0
ldr r2, [r0, #0]
mov r3, #0x20
str r3, [r2, #0]
ldr r2, [r0, #4]
str r1, [r2, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
bx lr
arm_func_end G3B_Color
arm_func_start G3B_Normal
G3B_Normal: ; 0x020BF6EC
stmfd sp!, {r4, lr}
mov r4, #0x21
ldr lr, [r0]
rsb ip, r4, #0x420
str r4, [lr]
mov lr, r3, asr #3
and r3, ip, r1, asr #3
mov r2, r2, asr #3
mov r1, r2, lsl #0x16
orr r2, r3, r1, lsr #12
mov ip, lr, lsl #0x16
ldr r1, [r0, #4]
orr r2, r2, ip, lsr #2
str r2, [r1, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
ldmia sp!, {r4, pc}
arm_func_end G3B_Normal
arm_func_start G3B_Vtx
G3B_Vtx: ; 0x020BF73C
stmfd sp!, {r3, lr}
ldr ip, [r0]
mov r2, r2, lsl #0x10
mov lr, #0x23
str lr, [ip]
mov r2, r2, lsr #0x10
mov ip, r2, lsl #0x10
mov r2, r3, lsl #0x10
mov r1, r1, lsl #0x10
ldr r3, [r0, #4]
orr r1, ip, r1, lsr #16
str r1, [r3, #0]
ldr r1, [r0, #4]
mov r2, r2, lsr #0x10
str r2, [r1, #4]
ldr r1, [r0, #4]
add r1, r1, #8
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
ldmia sp!, {r3, pc}
arm_func_end G3B_Vtx
arm_func_start G3B_PolygonAttr
G3B_PolygonAttr: ; 0x020BF790
orr r1, r1, r2, lsl #4
ldr r2, [r0, #0]
mov ip, #0x29
str ip, [r2]
orr r1, r1, r3, lsl #6
ldr r2, [sp, #8]
ldr r3, [sp]
orr r1, r2, r1
orr r2, r1, r3, lsl #24
ldr ip, [sp, #4]
ldr r1, [r0, #4]
orr r2, r2, ip, lsl #16
str r2, [r1, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
bx lr
arm_func_end G3B_PolygonAttr
arm_func_start G3B_MaterialColorDiffAmb
G3B_MaterialColorDiffAmb: ; 0x020BF7DC
stmfd sp!, {r3, lr}
ldr ip, [r0]
mov lr, #0x30
cmp r3, #0
movne r3, #1
str lr, [ip]
orr r2, r1, r2, lsl #16
moveq r3, #0
ldr r1, [r0, #4]
orr r2, r2, r3, lsl #15
str r2, [r1, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
ldmia sp!, {r3, pc}
arm_func_end G3B_MaterialColorDiffAmb
arm_func_start G3B_MaterialColorSpecEmi
G3B_MaterialColorSpecEmi: ; 0x020BF820
stmfd sp!, {r3, lr}
ldr ip, [r0]
mov lr, #0x31
cmp r3, #0
movne r3, #1
str lr, [ip]
orr r2, r1, r2, lsl #16
moveq r3, #0
ldr r1, [r0, #4]
orr r2, r2, r3, lsl #15
str r2, [r1, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
ldmia sp!, {r3, pc}
arm_func_end G3B_MaterialColorSpecEmi
arm_func_start G3B_LightVector
G3B_LightVector: ; 0x020BF864
stmfd sp!, {r3, r4, r5, lr}
ldrsh lr, [sp, #0x10]
ldr ip, _020BF8BC ; =0x000003FF
mov r3, r3, asr #3
and ip, ip, r2, asr #3
mov r2, r3, lsl #0x16
mov lr, lr, asr #3
ldr r4, [r0, #0]
mov r5, #0x32
str r5, [r4, #0]
mov r3, lr, lsl #0x16
orr r2, ip, r2, lsr #12
orr r3, r2, r3, lsr #2
ldr r2, [r0, #4]
orr r1, r3, r1, lsl #30
str r1, [r2, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
ldmia sp!, {r3, r4, r5, pc}
; .align 2, 0
_020BF8BC: .word 0x000003FF
arm_func_end G3B_LightVector
arm_func_start G3B_LightColor
G3B_LightColor: ; 0x020BF8C0
ldr r3, [r0, #0]
mov ip, #0x33
str ip, [r3]
ldr r3, [r0, #4]
orr r1, r2, r1, lsl #30
str r1, [r3, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
bx lr
arm_func_end G3B_LightColor
arm_func_start G3B_Begin
G3B_Begin: ; 0x020BF8F0
ldr r2, [r0, #0]
mov r3, #0x40
str r3, [r2, #0]
ldr r2, [r0, #4]
str r1, [r2, #0]
ldr r1, [r0, #4]
add r1, r1, #4
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
bx lr
arm_func_end G3B_Begin
arm_func_start G3B_End
G3B_End: ; 0x020BF91C
ldr r1, [r0, #0]
mov r2, #0x41
str r2, [r1, #0]
ldr r1, [r0, #4]
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
bx lr
arm_func_end G3B_End

55
lib/NitroSDK/asm/gx/g3imm.s
View File

@ -1,55 +0,0 @@
.include "macros/function.inc"
.include "include/g3imm.inc"
.text
arm_func_start G3_LoadMtx44
G3_LoadMtx44: ; 0x020BF93C
ldr r1, _020BF950 ; =0x04000400
mov r2, #0x16
ldr ip, _020BF954 ; =GX_SendFifo64B
str r2, [r1, #0]
bx ip
; .align 2, 0
_020BF950: .word 0x04000400
_020BF954: .word GX_SendFifo64B
arm_func_end G3_LoadMtx44
arm_func_start G3_LoadMtx43
G3_LoadMtx43: ; 0x020BF958
ldr r1, _020BF96C ; =0x04000400
mov r2, #0x17
ldr ip, _020BF970 ; =GX_SendFifo48B
str r2, [r1, #0]
bx ip
; .align 2, 0
_020BF96C: .word 0x04000400
_020BF970: .word GX_SendFifo48B
arm_func_end G3_LoadMtx43
arm_func_start G3_MultMtx43
G3_MultMtx43: ; 0x020BF974
ldr r1, _020BF988 ; =0x04000400
mov r2, #0x19
ldr ip, _020BF98C ; =GX_SendFifo48B
str r2, [r1, #0]
bx ip
; .align 2, 0
_020BF988: .word 0x04000400
_020BF98C: .word GX_SendFifo48B
arm_func_end G3_MultMtx43
arm_func_start G3_MultMtx33
G3_MultMtx33: ; 0x020BF990
ldr r1, _020BF9A4 ; =0x04000400
mov r2, #0x1a
ldr ip, _020BF9A8 ; =MI_Copy36B
str r2, [r1, #0]
bx ip
; .align 2, 0
_020BF9A4: .word 0x04000400
_020BF9A8: .word MI_Copy36B
arm_func_end G3_MultMtx33

463
lib/NitroSDK/asm/gx/g3x.s
View File

@ -1,463 +0,0 @@
.include "macros/function.inc"
.include "include/g3x.inc"
.extern GXi_DmaId
.text
arm_func_start G3X_Init
G3X_Init: ; 0x020BF9AC
stmfd sp!, {r3, lr}
bl G3X_ClearFifo
ldr r1, _020BFA98 ; =0x04000504
mov r0, #0
str r0, [r1, #0]
_020BF9C0:
ldr r0, [r1, #0xfc]
tst r0, #0x8000000
bne _020BF9C0
ldr r0, _020BFA9C ; =0x04000060
mov r2, #0
strh r2, [r0]
str r2, [r1, #0xfc]
str r2, [r0, #-0x50]
ldrh ip, [r0]
ldr r2, _020BFAA0 ; =0xFFFFCFFD
ldr r3, _020BFAA4 ; =0x0000CFFB
orr ip, ip, #0x2000
strh ip, [r0]
ldrh ip, [r0]
orr ip, ip, #0x1000
strh ip, [r0]
ldrh ip, [r0]
and r2, ip, r2
strh r2, [r0]
ldrh r2, [r0]
bic r2, r2, #0x3000
orr r2, r2, #0x10
strh r2, [r0]
ldrh r2, [r0]
and r2, r2, r3
strh r2, [r0]
ldr r0, [r1, #0xfc]
orr r0, r0, #0x8000
str r0, [r1, #0xfc]
ldr r0, [r1, #0xfc]
bic r0, r0, #0xc0000000
orr r0, r0, #0x80000000
str r0, [r1, #0xfc]
bl G3X_InitMtxStack
ldr r1, _020BFAA8 ; =0x04000350
mov r2, #0
ldr r0, _020BFAAC ; =0x00007FFF
str r2, [r1, #0]
strh r0, [r1, #4]
strh r2, [r1, #6]
str r2, [r1, #8]
strh r2, [r1, #0xc]
sub r1, r1, #0x348
ldrh r0, [r1]
bic r0, r0, #3
strh r0, [r1]
bl G3X_InitTable
ldr r2, _020BFAB0 ; =0x001F0080
ldr r1, _020BFAB4 ; =0x040004A4
mov r0, #0
str r2, [r1, #0]
str r0, [r1, #4]
str r0, [r1, #8]
ldmia sp!, {r3, pc}
; .align 2, 0
_020BFA98: .word 0x04000504
_020BFA9C: .word 0x04000060
_020BFAA0: .word 0xFFFFCFFD
_020BFAA4: .word 0x0000CFFB
_020BFAA8: .word 0x04000350
_020BFAAC: .word 0x00007FFF
_020BFAB0: .word 0x001F0080
_020BFAB4: .word 0x040004A4
arm_func_end G3X_Init
arm_func_start G3X_Reset
G3X_Reset: ; 0x020BFAB8
stmfd sp!, {r3, lr}
ldr r2, _020BFB14 ; =0x04000600
_020BFAC0:
ldr r0, [r2, #0]
tst r0, #0x8000000
bne _020BFAC0
ldr r0, [r2, #0]
ldr r1, _020BFB18 ; =0x04000060
orr r0, r0, #0x8000
str r0, [r2, #0]
ldrh r0, [r1]
orr r0, r0, #0x2000
strh r0, [r1]
ldrh r0, [r1]
orr r0, r0, #0x1000
strh r0, [r1]
bl G3X_ResetMtxStack
ldr r2, _020BFB1C ; =0x001F0080
ldr r1, _020BFB20 ; =0x040004A4
mov r0, #0
str r2, [r1, #0]
str r0, [r1, #4]
str r0, [r1, #8]
ldmia sp!, {r3, pc}
; .align 2, 0
_020BFB14: .word 0x04000600
_020BFB18: .word 0x04000060
_020BFB1C: .word 0x001F0080
_020BFB20: .word 0x040004A4
arm_func_end G3X_Reset
arm_func_start G3X_ClearFifo
G3X_ClearFifo: ; 0x020BFB24
stmfd sp!, {r3, lr}
ldr r0, _020BFB44 ; =0x04000400
bl GXi_NopClearFifo128_
ldr r1, _020BFB48 ; =0x04000600
_020BFB34:
ldr r0, [r1, #0]
tst r0, #0x8000000
bne _020BFB34
ldmia sp!, {r3, pc}
; .align 2, 0
_020BFB44: .word 0x04000400
_020BFB48: .word 0x04000600
arm_func_end G3X_ClearFifo
arm_func_start G3X_InitMtxStack
G3X_InitMtxStack: ; 0x020BFB4C
stmfd sp!, {r4, lr}
sub sp, sp, #8
ldr r1, _020BFBD8 ; =0x04000600
ldr r0, [r1, #0]
orr r0, r0, #0x8000
str r0, [r1, #0]
add r4, sp, #4
_020BFB68:
mov r0, r4
bl G3X_GetMtxStackLevelPV
cmp r0, #0
bne _020BFB68
add r4, sp, #0
_020BFB7C:
mov r0, r4
bl G3X_GetMtxStackLevelPJ
cmp r0, #0
bne _020BFB7C
ldr r1, _020BFBDC ; =0x04000440
mov r0, #3
str r0, [r1, #0]
mov r0, #0
str r0, [r1, #0x14]
str r0, [r1, #0]
ldr r0, [sp]
mov r2, #0
cmp r0, #0
strne r0, [r1, #8]
ldr r1, _020BFBE0 ; =0x04000454
mov r0, #2
str r2, [r1, #0]
str r0, [r1, #-0x14]
ldr r0, [sp, #4]
str r0, [r1, #-0xc]
str r2, [r1, #0]
add sp, sp, #8
ldmia sp!, {r4, pc}
; .align 2, 0
_020BFBD8: .word 0x04000600
_020BFBDC: .word 0x04000440
_020BFBE0: .word 0x04000454
arm_func_end G3X_InitMtxStack
arm_func_start G3X_ResetMtxStack
G3X_ResetMtxStack: ; 0x020BFBE4
stmfd sp!, {r4, lr}
sub sp, sp, #8
ldr r1, _020BFC6C ; =0x04000600
ldr r0, [r1, #0]
orr r0, r0, #0x8000
str r0, [r1, #0]
add r4, sp, #4
_020BFC00:
mov r0, r4
bl G3X_GetMtxStackLevelPV
cmp r0, #0
bne _020BFC00
add r4, sp, #0
_020BFC14:
mov r0, r4
bl G3X_GetMtxStackLevelPJ
cmp r0, #0
bne _020BFC14
ldr r1, _020BFC70 ; =0x04000440
mov r0, #3
str r0, [r1, #0]
mov r0, #0
str r0, [r1, #0x14]
str r0, [r1, #0]
ldr r0, [sp]
ldr r2, _020BFC70 ; =0x04000440
cmp r0, #0
strne r0, [r1, #8]
mov r0, #2
str r0, [r2, #0]
ldr r1, [sp, #4]
mov r0, #0
str r1, [r2, #8]
str r0, [r2, #0x14]
add sp, sp, #8
ldmia sp!, {r4, pc}
; .align 2, 0
_020BFC6C: .word 0x04000600
_020BFC70: .word 0x04000440
arm_func_end G3X_ResetMtxStack
arm_func_start G3X_SetFog
G3X_SetFog: ; 0x020BFC74
cmp r0, #0
beq _020BFCA8
ldr ip, _020BFCC0 ; =0x0400035C
mov r0, r1, lsl #6
strh r3, [ip]
sub r3, ip, #0x2fc
ldrh r1, [r3]
orr r0, r0, r2, lsl #8
orr r0, r0, #0x80
bic r1, r1, #0x3f40
orr r0, r1, r0
strh r0, [r3]
bx lr
_020BFCA8:
ldr r2, _020BFCC4 ; =0x04000060
ldr r0, _020BFCC8 ; =0x0000CF7F
ldrh r1, [r2]
and r0, r1, r0
strh r0, [r2]
bx lr
; .align 2, 0
_020BFCC0: .word 0x0400035C
_020BFCC4: .word 0x04000060
_020BFCC8: .word 0x0000CF7F
arm_func_end G3X_SetFog
arm_func_start G3X_GetClipMtx
G3X_GetClipMtx: ; 0x020BFCCC
stmfd sp!, {r3, lr}
ldr r2, _020BFCF8 ; =0x04000600
mov r1, r0
ldr r0, [r2, #0]
tst r0, #0x8000000
mvnne r0, #0
ldmneia sp!, {r3, pc}
add r0, r2, #0x40
bl MI_Copy64B
mov r0, #0
ldmia sp!, {r3, pc}
; .align 2, 0
_020BFCF8: .word 0x04000600
arm_func_end G3X_GetClipMtx
arm_func_start G3X_GetVectorMtx
G3X_GetVectorMtx: ; 0x020BFCFC
stmfd sp!, {r3, lr}
ldr r2, _020BFD28 ; =0x04000600
mov r1, r0
ldr r0, [r2, #0]
tst r0, #0x8000000
mvnne r0, #0
ldmneia sp!, {r3, pc}
add r0, r2, #0x80
bl MI_Copy36B
mov r0, #0
ldmia sp!, {r3, pc}
; .align 2, 0
_020BFD28: .word 0x04000600
arm_func_end G3X_GetVectorMtx
arm_func_start G3X_SetEdgeColorTable
G3X_SetEdgeColorTable: ; 0x020BFD2C
ldr ip, _020BFD3C ; =MIi_CpuCopy16
ldr r1, _020BFD40 ; =0x04000330
mov r2, #0x10
bx ip
; .align 2, 0
_020BFD3C: .word MIi_CpuCopy16
_020BFD40: .word 0x04000330
arm_func_end G3X_SetEdgeColorTable
arm_func_start G3X_SetFogTable
G3X_SetFogTable: ; 0x020BFD44
ldr ip, _020BFD50 ; =MI_Copy32B
ldr r1, _020BFD54 ; =0x04000360
bx ip
; .align 2, 0
_020BFD50: .word MI_Copy32B
_020BFD54: .word 0x04000360
arm_func_end G3X_SetFogTable
arm_func_start G3X_SetClearColor
G3X_SetClearColor: ; 0x020BFD58
ldr ip, [sp]
orr r0, r0, r1, lsl #16
orr r1, r0, r3, lsl #24
cmp ip, #0
ldr r0, _020BFD7C ; =0x04000350
orrne r1, r1, #0x8000
str r1, [r0, #0]
strh r2, [r0, #4]
bx lr
; .align 2, 0
_020BFD7C: .word 0x04000350
arm_func_end G3X_SetClearColor
arm_func_start G3X_InitTable
G3X_InitTable: ; 0x020BFD80
stmfd sp!, {r3, lr}
sub sp, sp, #8
ldr r0, _020BFE10 ; =0x02101148
mvn r1, #0
ldr r0, [r0, #0]
cmp r0, r1
ldr r1, _020BFE14 ; =0x04000330
beq _020BFDD0
mov r2, #0
str r2, [sp]
mov r3, #0x10
str r2, [sp, #4]
bl MI_DmaFill32Async
ldr r0, _020BFE10 ; =0x02101148
ldr r1, _020BFE18 ; =0x04000360
ldr r0, [r0, #0]
mov r2, #0
mov r3, #0x60
bl MI_DmaFill32
b _020BFDEC
_020BFDD0:
mov r0, #0
mov r2, #0x10
bl MIi_CpuClear32
ldr r1, _020BFE18 ; =0x04000360
mov r0, #0
mov r2, #0x60
bl MIi_CpuClear32
_020BFDEC:
mov r2, #0
ldr r0, _020BFE1C ; =0x040004D0
mov r1, r2
_020BFDF8:
add r2, r2, #1
str r1, [r0, #0]
cmp r2, #0x20
blt _020BFDF8
add sp, sp, #8
ldmia sp!, {r3, pc}
; .align 2, 0
_020BFE10: .word GXi_DmaId
_020BFE14: .word 0x04000330
_020BFE18: .word 0x04000360
_020BFE1C: .word 0x040004D0
arm_func_end G3X_InitTable
arm_func_start G3X_GetMtxStackLevelPV
G3X_GetMtxStackLevelPV: ; 0x020BFE20
ldr r2, _020BFE4C ; =0x04000600
ldr r1, [r2, #0]
tst r1, #0x4000
mvnne r0, #0
bxne lr
ldr r1, [r2, #0]
and r1, r1, #0x1f00
mov r1, r1, lsr #8
str r1, [r0, #0]
mov r0, #0
bx lr
; .align 2, 0
_020BFE4C: .word 0x04000600
arm_func_end G3X_GetMtxStackLevelPV
arm_func_start G3X_GetMtxStackLevelPJ
G3X_GetMtxStackLevelPJ: ; 0x020BFE50
ldr r2, _020BFE7C ; =0x04000600
ldr r1, [r2, #0]
tst r1, #0x4000
mvnne r0, #0
bxne lr
ldr r1, [r2, #0]
and r1, r1, #0x2000
mov r1, r1, lsr #0xd
str r1, [r0, #0]
mov r0, #0
bx lr
; .align 2, 0
_020BFE7C: .word 0x04000600
arm_func_end G3X_GetMtxStackLevelPJ
arm_func_start G3X_GetBoxTestResult
G3X_GetBoxTestResult: ; 0x020BFE80
ldr r2, _020BFEA8 ; =0x04000600
ldr r1, [r2, #0]
tst r1, #1
mvnne r0, #0
bxne lr
ldr r1, [r2, #0]
and r1, r1, #2
str r1, [r0, #0]
mov r0, #0
bx lr
; .align 2, 0
_020BFEA8: .word 0x04000600
arm_func_end G3X_GetBoxTestResult
arm_func_start G3X_SetHOffset
G3X_SetHOffset: ; 0x020BFEAC
ldr r1, _020BFEB8 ; =0x04000010
str r0, [r1, #0]
bx lr
; .align 2, 0
_020BFEB8: .word 0x04000010
arm_func_end G3X_SetHOffset
arm_func_start GXi_NopClearFifo128_
GXi_NopClearFifo128_: ; 0x020BFEBC
mov r1, #0
mov r2, #0
mov r3, #0
mov ip, #0
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
stmia r0, {r1, r2, r3, ip}
bx lr
arm_func_end GXi_NopClearFifo128_

262
lib/NitroSDK/asm/gx/gx.s
View File

@ -1,262 +0,0 @@
.include "macros/function.inc"
.include "include/gx.inc"
.extern Unk_021CCB9C
.text
arm_func_start GX_Init
GX_Init: ; 0x020BDC08
stmfd sp!, {r4, r5, r6, lr}
ldr r2, _020BDD30 ; =0x04000304
ldr r0, _020BDD34 ; =0xFFFFFDF1
ldrh r1, [r2]
orr r1, r1, #0x8000
strh r1, [r2]
ldrh r1, [r2]
and r0, r1, r0
orr r0, r0, #0xe
orr r0, r0, #0x200
strh r0, [r2]
ldrh r0, [r2]
orr r0, r0, #1
strh r0, [r2]
bl GX_InitGXState
ldr r5, _020BDD38 ; =0x021CCB9C
ldrh r0, [r5, #2]
cmp r0, #0
bne _020BDC7C
mvn r4, #2
_020BDC58:
bl OS_GetLockID
mov r6, r0
cmp r6, r4
bne _020BDC6C
bl OS_Terminate
_020BDC6C:
strh r6, [r5, #2]
ldrh r0, [r5, #2]
cmp r0, #0
beq _020BDC58
_020BDC7C:
ldr r0, _020BDD3C ; =0x04000004
mov r2, #0
mov r3, #0x4000000
strh r2, [r0]
ldr r0, _020BDD40 ; =0x02101144
str r2, [r3, #0]
ldr r0, [r0, #4]
sub r1, r3, #0x4000001
cmp r0, r1
beq _020BDCD4
add r1, r3, #8
mov r3, #0x60
bl MI_DmaFill32
ldr r1, _020BDD44 ; =0x0400006C
mov r2, #0
ldr r0, _020BDD40 ; =0x02101144
strh r2, [r1]
ldr r0, [r0, #4]
ldr r1, _020BDD48 ; =0x04001000
mov r3, #0x70
bl MI_DmaFill32
b _020BDCFC
_020BDCD4:
mov r0, r2
add r1, r3, #8
mov r2, #0x60
bl MIi_CpuClear32
ldr r3, _020BDD44 ; =0x0400006C
mov r0, #0
ldr r1, _020BDD48 ; =0x04001000
mov r2, #0x70
strh r0, [r3]
bl MIi_CpuClear32
_020BDCFC:
ldr r0, _020BDD4C ; =0x04000020
mov r2, #0x100
strh r2, [r0]
strh r2, [r0, #6]
strh r2, [r0, #0x10]
strh r2, [r0, #0x16]
add r1, r0, #0x1000
ldr r0, _020BDD50 ; =0x04001026
strh r2, [r1]
strh r2, [r0]
strh r2, [r0, #0xa]
strh r2, [r0, #0x10]
ldmia sp!, {r4, r5, r6, pc}
; .align 2, 0
_020BDD30: .word 0x04000304
_020BDD34: .word 0xFFFFFDF1
_020BDD38: .word Unk_021CCB9C
_020BDD3C: .word 0x04000004
_020BDD40: .word 0x02101144
_020BDD44: .word 0x0400006C
_020BDD48: .word 0x04001000
_020BDD4C: .word 0x04000020
_020BDD50: .word 0x04001026
arm_func_end GX_Init
arm_func_start GX_HBlankIntr
GX_HBlankIntr: ; 0x020BDD54
ldr r2, _020BDD84 ; =0x04000004
cmp r0, #0
ldrh r0, [r2]
ldreqh r1, [r2]
and r0, r0, #0x10
biceq r1, r1, #0x10
streqh r1, [r2]
bxeq lr
ldrh r1, [r2]
orr r1, r1, #0x10
strh r1, [r2]
bx lr
; .align 2, 0
_020BDD84: .word 0x04000004
arm_func_end GX_HBlankIntr
arm_func_start GX_VBlankIntr
GX_VBlankIntr: ; 0x020BDD88
ldr r2, _020BDDB8 ; =0x04000004
cmp r0, #0
ldrh r0, [r2]
ldreqh r1, [r2]
and r0, r0, #8
biceq r1, r1, #8
streqh r1, [r2]
bxeq lr
ldrh r1, [r2]
orr r1, r1, #8
strh r1, [r2]
bx lr
; .align 2, 0
_020BDDB8: .word 0x04000004
arm_func_end GX_VBlankIntr
arm_func_start GX_DispOff
GX_DispOff: ; 0x020BDDBC
stmfd sp!, {r3, lr}
mov lr, #0x4000000
ldr ip, [lr]
ldr r1, _020BDDF0 ; =0x02101144
and r2, ip, #0x30000
mov r3, #0
ldr r0, _020BDDF4 ; =0x021CCB9C
mov r2, r2, lsr #0x10
strh r3, [r1]
strh r2, [r0]
bic r0, ip, #0x30000
str r0, [lr]
ldmia sp!, {r3, pc}
; .align 2, 0
_020BDDF0: .word 0x02101144
_020BDDF4: .word Unk_021CCB9C
arm_func_end GX_DispOff
arm_func_start GX_DispOn
GX_DispOn: ; 0x020BDDF8
ldr r0, _020BDE38 ; =0x021CCB9C
ldr r1, _020BDE3C ; =0x02101144
ldrh r2, [r0]
mov r0, #1
strh r0, [r1]
mov r1, #0x4000000
cmp r2, #0
ldreq r0, [r1]
orreq r0, r0, #0x10000
streq r0, [r1]
bxeq lr
ldr r0, [r1, #0]
bic r0, r0, #0x30000
orr r0, r0, r2, lsl #16
str r0, [r1, #0]
bx lr
; .align 2, 0
_020BDE38: .word Unk_021CCB9C
_020BDE3C: .word 0x02101144
arm_func_end GX_DispOn
arm_func_start GX_SetGraphicsMode
GX_SetGraphicsMode: ; 0x020BDE40
stmfd sp!, {r3, lr}
ldr r3, _020BDE9C ; =0x02101144
mov lr, #0x4000000
ldrh ip, [r3]
ldr lr, [lr]
ldr r3, _020BDEA0 ; =0x021CCB9C
cmp ip, #0
strh r0, [r3]
ldr r3, _020BDEA4 ; =0xFFF0FFF0
moveq r0, #0
and r3, lr, r3
orr r0, r3, r0, lsl #16
orr r0, r1, r0
orr r1, r0, r2, lsl #3
mov ip, #0x4000000
ldr r0, _020BDEA0 ; =0x021CCB9C
str r1, [ip]
ldrh r0, [r0]
cmp r0, #0
ldreq r0, _020BDE9C ; =0x02101144
moveq r1, #0
streqh r1, [r0]
ldmia sp!, {r3, pc}
; .align 2, 0
_020BDE9C: .word 0x02101144
_020BDEA0: .word Unk_021CCB9C
_020BDEA4: .word 0xFFF0FFF0
arm_func_end GX_SetGraphicsMode
arm_func_start GXS_SetGraphicsMode
GXS_SetGraphicsMode: ; 0x020BDEA8
ldr r2, _020BDEC0 ; =0x04001000
ldr r1, [r2, #0]
bic r1, r1, #7
orr r0, r1, r0
str r0, [r2, #0]
bx lr
; .align 2, 0
_020BDEC0: .word 0x04001000
arm_func_end GXS_SetGraphicsMode
arm_func_start GXx_SetMasterBrightness_
GXx_SetMasterBrightness_: ; 0x020BDEC4
cmp r1, #0
moveq r1, #0
streqh r1, [r0]
bxeq lr
orrgt r1, r1, #0x4000
strgth r1, [r0]
rsble r1, r1, #0
orrle r1, r1, #0x8000
strleh r1, [r0]
bx lr
arm_func_end GXx_SetMasterBrightness_
.data
.global Unk_02101144
Unk_02101144: ; 0x02101144
.incbin "incbin/arm9_data.bin", 0x2464, 0x2468 - 0x2464
.global GXi_DmaId
GXi_DmaId: ; 0x02101148
.incbin "incbin/arm9_data.bin", 0x2468, 0x4
.bss
.global Unk_021CCB9C
Unk_021CCB9C: ; 0x021CCB9C
.space 0x2
.global Unk_021CCB9E
Unk_021CCB9E: ; 0x021CCB9E
.space 0x2

394
lib/NitroSDK/asm/gx/gx_bgcnt.s
View File

@ -1,394 +0,0 @@
.include "macros/function.inc"
.text
arm_func_start G2_GetBG0ScrPtr
G2_GetBG0ScrPtr: ; 0x020BF03C
ldr r1, _020BF06C ; =0x04000008
mov r0, #0x4000000
ldrh r1, [r1]
ldr r0, [r0, #0]
and r0, r0, #0x38000000
mov r0, r0, lsr #0x1b
and r1, r1, #0x1f00
mov r0, r0, lsl #0x10
mov r1, r1, asr #8
add r0, r0, #0x6000000
add r0, r0, r1, lsl #11
bx lr
; .align 2, 0
_020BF06C: .word 0x04000008
arm_func_end G2_GetBG0ScrPtr
arm_func_start G2S_GetBG0ScrPtr
G2S_GetBG0ScrPtr: ; 0x020BF070
ldr r0, _020BF08C ; =0x04001008
ldrh r0, [r0]
and r0, r0, #0x1f00
mov r0, r0, asr #8
mov r0, r0, lsl #0xb
add r0, r0, #0x6200000
bx lr
; .align 2, 0
_020BF08C: .word 0x04001008
arm_func_end G2S_GetBG0ScrPtr
arm_func_start G2_GetBG1ScrPtr
G2_GetBG1ScrPtr: ; 0x020BF090
ldr r1, _020BF0C0 ; =0x0400000A
mov r0, #0x4000000
ldrh r1, [r1]
ldr r0, [r0, #0]
and r0, r0, #0x38000000
mov r0, r0, lsr #0x1b
and r1, r1, #0x1f00
mov r0, r0, lsl #0x10
mov r1, r1, asr #8
add r0, r0, #0x6000000
add r0, r0, r1, lsl #11
bx lr
; .align 2, 0
_020BF0C0: .word 0x0400000A
arm_func_end G2_GetBG1ScrPtr
arm_func_start G2S_GetBG1ScrPtr
G2S_GetBG1ScrPtr: ; 0x020BF0C4
ldr r0, _020BF0E0 ; =0x0400100A
ldrh r0, [r0]
and r0, r0, #0x1f00
mov r0, r0, asr #8
mov r0, r0, lsl #0xb
add r0, r0, #0x6200000
bx lr
; .align 2, 0
_020BF0E0: .word 0x0400100A
arm_func_end G2S_GetBG1ScrPtr
arm_func_start G2_GetBG2ScrPtr
G2_GetBG2ScrPtr: ; 0x020BF0E4
mov r0, #0x4000000
ldr r1, [r0, #0]
ldrh r3, [r0, #0xc]
ldr r0, [r0, #0]
and ip, r1, #7
and r0, r0, #0x38000000
mov r1, r0, lsr #0x1b
and r0, r3, #0x1f00
mov r2, r1, lsl #0x10
cmp ip, #6
mov r1, r0, lsr #8
addls pc, pc, ip, lsl #2
b _020BF160
_020BF118: ; jump table
b _020BF134 ; case 0
b _020BF134 ; case 1
b _020BF134 ; case 2
b _020BF134 ; case 3
b _020BF134 ; case 4
b _020BF140 ; case 5
b _020BF158 ; case 6
_020BF134:
add r0, r2, #0x6000000
add r0, r0, r1, lsl #11
bx lr
_020BF140:
tst r3, #0x80
movne r0, r1, lsl #0xe
addne r0, r0, #0x6000000
addeq r0, r2, #0x6000000
addeq r0, r0, r1, lsl #11
bx lr
_020BF158:
mov r0, #0x6000000
bx lr
_020BF160:
mov r0, #0
bx lr
arm_func_end G2_GetBG2ScrPtr
arm_func_start G2S_GetBG2ScrPtr
G2S_GetBG2ScrPtr: ; 0x020BF168
ldr r1, _020BF1D8 ; =0x04001000
ldr r0, [r1, #0]
ldrh r1, [r1, #0xc]
and r2, r0, #7
cmp r2, #6
and r0, r1, #0x1f00
mov r0, r0, lsr #8
addls pc, pc, r2, lsl #2
b _020BF1D0
_020BF18C: ; jump table
b _020BF1A8 ; case 0
b _020BF1A8 ; case 1
b _020BF1A8 ; case 2
b _020BF1A8 ; case 3
b _020BF1A8 ; case 4
b _020BF1B4 ; case 5
b _020BF1C8 ; case 6
_020BF1A8:
mov r0, r0, lsl #0xb
add r0, r0, #0x6200000
bx lr
_020BF1B4:
tst r1, #0x80
movne r0, r0, lsl #0xe
moveq r0, r0, lsl #0xb
add r0, r0, #0x6200000
bx lr
_020BF1C8:
mov r0, #0
bx lr
_020BF1D0:
mov r0, #0
bx lr
; .align 2, 0
_020BF1D8: .word 0x04001000
arm_func_end G2S_GetBG2ScrPtr
arm_func_start G2_GetBG3ScrPtr
G2_GetBG3ScrPtr: ; 0x020BF1DC
mov r0, #0x4000000
ldr r1, [r0, #0]
ldrh r3, [r0, #0xe]
ldr r0, [r0, #0]
and ip, r1, #7
and r0, r0, #0x38000000
mov r1, r0, lsr #0x1b
and r0, r3, #0x1f00
mov r2, r1, lsl #0x10
cmp ip, #6
mov r1, r0, lsr #8
addls pc, pc, ip, lsl #2
b _020BF258
_020BF210: ; jump table
b _020BF22C ; case 0
b _020BF22C ; case 1
b _020BF22C ; case 2
b _020BF238 ; case 3
b _020BF238 ; case 4
b _020BF238 ; case 5
b _020BF250 ; case 6
_020BF22C:
add r0, r2, #0x6000000
add r0, r0, r1, lsl #11
bx lr
_020BF238:
tst r3, #0x80
movne r0, r1, lsl #0xe
addne r0, r0, #0x6000000
addeq r0, r2, #0x6000000
addeq r0, r0, r1, lsl #11
bx lr
_020BF250:
mov r0, #0
bx lr
_020BF258:
mov r0, #0
bx lr
arm_func_end G2_GetBG3ScrPtr
arm_func_start G2S_GetBG3ScrPtr
G2S_GetBG3ScrPtr: ; 0x020BF260
ldr r1, _020BF2D0 ; =0x04001000
ldr r0, [r1, #0]
ldrh r1, [r1, #0xe]
and r2, r0, #7
cmp r2, #6
and r0, r1, #0x1f00
mov r0, r0, lsr #8
addls pc, pc, r2, lsl #2
b _020BF2C8
_020BF284: ; jump table
b _020BF2A0 ; case 0
b _020BF2A0 ; case 1
b _020BF2A0 ; case 2
b _020BF2AC ; case 3
b _020BF2AC ; case 4
b _020BF2AC ; case 5
b _020BF2C0 ; case 6
_020BF2A0:
mov r0, r0, lsl #0xb
add r0, r0, #0x6200000
bx lr
_020BF2AC:
tst r1, #0x80
movne r0, r0, lsl #0xe
moveq r0, r0, lsl #0xb
add r0, r0, #0x6200000
bx lr
_020BF2C0:
mov r0, #0
bx lr
_020BF2C8:
mov r0, #0
bx lr
; .align 2, 0
_020BF2D0: .word 0x04001000
arm_func_end G2S_GetBG3ScrPtr
arm_func_start G2_GetBG0CharPtr
G2_GetBG0CharPtr: ; 0x020BF2D4
ldr r1, _020BF304 ; =0x04000008
mov r0, #0x4000000
ldrh r1, [r1]
ldr r0, [r0, #0]
and r0, r0, #0x7000000
mov r0, r0, lsr #0x18
and r1, r1, #0x3c
mov r0, r0, lsl #0x10
mov r1, r1, asr #2
add r0, r0, #0x6000000
add r0, r0, r1, lsl #14
bx lr
; .align 2, 0
_020BF304: .word 0x04000008
arm_func_end G2_GetBG0CharPtr
arm_func_start G2S_GetBG0CharPtr
G2S_GetBG0CharPtr: ; 0x020BF308
ldr r0, _020BF324 ; =0x04001008
ldrh r0, [r0]
and r0, r0, #0x3c
mov r0, r0, asr #2
mov r0, r0, lsl #0xe
add r0, r0, #0x6200000
bx lr
; .align 2, 0
_020BF324: .word 0x04001008
arm_func_end G2S_GetBG0CharPtr
arm_func_start G2_GetBG1CharPtr
G2_GetBG1CharPtr: ; 0x020BF328
ldr r1, _020BF358 ; =0x0400000A
mov r0, #0x4000000
ldrh r1, [r1]
ldr r0, [r0, #0]
and r0, r0, #0x7000000
mov r0, r0, lsr #0x18
and r1, r1, #0x3c
mov r0, r0, lsl #0x10
mov r1, r1, asr #2
add r0, r0, #0x6000000
add r0, r0, r1, lsl #14
bx lr
; .align 2, 0
_020BF358: .word 0x0400000A
arm_func_end G2_GetBG1CharPtr
arm_func_start G2S_GetBG1CharPtr
G2S_GetBG1CharPtr: ; 0x020BF35C
ldr r0, _020BF378 ; =0x0400100A
ldrh r0, [r0]
and r0, r0, #0x3c
mov r0, r0, asr #2
mov r0, r0, lsl #0xe
add r0, r0, #0x6200000
bx lr
; .align 2, 0
_020BF378: .word 0x0400100A
arm_func_end G2S_GetBG1CharPtr
arm_func_start G2_GetBG2CharPtr
G2_GetBG2CharPtr: ; 0x020BF37C
mov r1, #0x4000000
ldr r0, [r1, #0]
ldrh r2, [r1, #0xc]
and r0, r0, #7
cmp r0, #5
blt _020BF39C
tst r2, #0x80
bne _020BF3C4
_020BF39C:
mov r0, #0x4000000
ldr r1, [r0, #0]
and r0, r2, #0x3c
and r1, r1, #0x7000000
mov r1, r1, lsr #0x18
mov r1, r1, lsl #0x10
add r1, r1, #0x6000000
mov r0, r0, lsr #2
add r0, r1, r0, lsl #14
bx lr
_020BF3C4:
mov r0, #0
bx lr
arm_func_end G2_GetBG2CharPtr
arm_func_start G2S_GetBG2CharPtr
G2S_GetBG2CharPtr: ; 0x020BF3CC
ldr r1, _020BF408 ; =0x04001000
ldr r0, [r1, #0]
ldrh r1, [r1, #0xc]
and r0, r0, #7
cmp r0, #5
blt _020BF3EC
tst r1, #0x80
bne _020BF400
_020BF3EC:
and r0, r1, #0x3c
mov r0, r0, lsr #2
mov r0, r0, lsl #0xe
add r0, r0, #0x6200000
bx lr
_020BF400:
mov r0, #0
bx lr
; .align 2, 0
_020BF408: .word 0x04001000
arm_func_end G2S_GetBG2CharPtr
arm_func_start G2_GetBG3CharPtr
G2_GetBG3CharPtr: ; 0x020BF40C
mov r1, #0x4000000
ldr r0, [r1, #0]
ldrh r2, [r1, #0xe]
and r0, r0, #7
cmp r0, #3
blt _020BF434
cmp r0, #6
bge _020BF45C
tst r2, #0x80
bne _020BF45C
_020BF434:
mov r0, #0x4000000
ldr r1, [r0, #0]
and r0, r2, #0x3c
and r1, r1, #0x7000000
mov r1, r1, lsr #0x18
mov r1, r1, lsl #0x10
add r1, r1, #0x6000000
mov r0, r0, lsr #2
add r0, r1, r0, lsl #14
bx lr
_020BF45C:
mov r0, #0
bx lr
arm_func_end G2_GetBG3CharPtr
arm_func_start G2S_GetBG3CharPtr
G2S_GetBG3CharPtr: ; 0x020BF464
ldr r1, _020BF4A8 ; =0x04001000
ldr r0, [r1, #0]
ldrh r1, [r1, #0xe]
and r0, r0, #7
cmp r0, #3
blt _020BF48C
cmp r0, #6
bge _020BF4A0
tst r1, #0x80
bne _020BF4A0
_020BF48C:
and r0, r1, #0x3c
mov r0, r0, lsr #2
mov r0, r0, lsl #0xe
add r0, r0, #0x6200000
bx lr
_020BF4A0:
mov r0, #0
bx lr
; .align 2, 0
_020BF4A8: .word 0x04001000
arm_func_end G2S_GetBG3CharPtr

1058
lib/NitroSDK/asm/gx/gx_load2d.s
View File

File diff suppressed because it is too large Load Diff

408
lib/NitroSDK/asm/gx/gx_load3d.s
View File

@ -1,408 +0,0 @@
.include "macros/function.inc"
.include "include/gx_load3d.inc"
.extern Unk_021CCBD8
.extern GXi_DmaId
.text
arm_func_start GX_BeginLoadTex
GX_BeginLoadTex: ; 0x020C0D34
stmfd sp!, {r3, lr}
bl GX_ResetBankForTex
mov r1, #6
mul lr, r0, r1
ldr r2, _020C0D80 ; =0x020FD950
ldr r1, _020C0D84 ; =0x020FD952
ldrh ip, [r2, lr]
ldr r2, _020C0D88 ; =0x020FD954
ldrh r3, [r1, lr]
ldr r1, _020C0D8C ; =0x021CCBD8
ldrh r2, [r2, lr]
str r0, [r1, #0x14]
mov r0, ip, lsl #0xc
str r0, [r1, #4]
mov r0, r3, lsl #0xc
str r0, [r1, #0x18]
mov r0, r2, lsl #0xc
str r0, [r1, #0x1c]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C0D80: .word Unk_020FD950
_020C0D84: .word 0x020FD952
_020C0D88: .word 0x020FD954
_020C0D8C: .word Unk_021CCBD8
arm_func_end GX_BeginLoadTex
arm_func_start GX_LoadTex
GX_LoadTex: ; 0x020C0D90
stmfd sp!, {r3, r4, r5, r6, r7, lr}
sub sp, sp, #8
ldr r3, _020C0EC8 ; =0x021CCBD8
mov r7, r0
ldr r4, [r3, #0x18]
mov ip, r1
cmp r4, #0
ldreq r0, [r3, #4]
mov r6, r2
addeq r2, r0, ip
beq _020C0E7C
ldr r2, [r3, #0x1c]
add r0, ip, r6
cmp r0, r2
ldrlo r0, [r3, #4]
addlo r2, r0, ip
blo _020C0E7C
cmp ip, r2
addhs r0, r4, ip
subhs r2, r0, r2
bhs _020C0E7C
ldr r0, _020C0ECC ; =0x02101148
mvn r1, #0
ldr r0, [r0, #0]
sub r5, r2, ip
cmp r0, r1
ldr lr, [r3, #4]
beq _020C0E1C
cmp r5, #0x30
bls _020C0E1C
mov r1, r7
mov r3, r5
add r2, lr, ip
bl MI_DmaCopy32
b _020C0E2C
_020C0E1C:
mov r0, r7
mov r2, r5
add r1, lr, ip
bl MIi_CpuCopy32
_020C0E2C:
ldr r0, _020C0ECC ; =0x02101148
mvn r1, #0
ldr r0, [r0, #0]
cmp r0, r1
beq _020C0E64
mov ip, #0
str ip, [sp]
mov r2, r4
add r1, r7, r5
sub r3, r6, r5
str ip, [sp, #4]
bl MI_DmaCopy32Async
add sp, sp, #8
ldmia sp!, {r3, r4, r5, r6, r7, pc}
_020C0E64:
mov r1, r4
add r0, r7, r5
sub r2, r6, r5
bl MIi_CpuCopy32
add sp, sp, #8
ldmia sp!, {r3, r4, r5, r6, r7, pc}
_020C0E7C:
ldr r0, _020C0ECC ; =0x02101148
mvn r1, #0
ldr r0, [r0, #0]
cmp r0, r1
beq _020C0EB0
mov r4, #0
str r4, [sp]
mov r1, r7
mov r3, r6
str r4, [sp, #4]
bl MI_DmaCopy32Async
add sp, sp, #8
ldmia sp!, {r3, r4, r5, r6, r7, pc}
_020C0EB0:
mov r1, r2
mov r0, r7
mov r2, r6
bl MIi_CpuCopy32
add sp, sp, #8
ldmia sp!, {r3, r4, r5, r6, r7, pc}
; .align 2, 0
_020C0EC8: .word Unk_021CCBD8
_020C0ECC: .word GXi_DmaId
arm_func_end GX_LoadTex
arm_func_start GX_EndLoadTex
GX_EndLoadTex: ; 0x020C0ED0
stmfd sp!, {r3, lr}
ldr r0, _020C0F14 ; =0x02101148
mvn r1, #0
ldr r0, [r0, #0]
cmp r0, r1
beq _020C0EEC
bl MI_WaitDma
_020C0EEC:
ldr r0, _020C0F18 ; =0x021CCBD8
ldr r0, [r0, #0x14]
bl GX_SetBankForTex
ldr r0, _020C0F18 ; =0x021CCBD8
mov r1, #0
str r1, [r0, #0x1c]
str r1, [r0, #0x18]
str r1, [r0, #4]
str r1, [r0, #0x14]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C0F14: .word GXi_DmaId
_020C0F18: .word Unk_021CCBD8
arm_func_end GX_EndLoadTex
arm_func_start GX_BeginLoadTexPltt
GX_BeginLoadTexPltt: ; 0x020C0F1C
stmfd sp!, {r3, lr}
bl GX_ResetBankForTexPltt
mov r3, r0, asr #4
ldr r1, _020C0F48 ; =0x021CCBD8
ldr r2, _020C0F4C ; =0x020FD940
mov r3, r3, lsl #1
ldrh r2, [r2, r3]
str r0, [r1, #0xc]
mov r0, r2, lsl #0xc
str r0, [r1, #8]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C0F48: .word Unk_021CCBD8
_020C0F4C: .word Unk_020FD940
arm_func_end GX_BeginLoadTexPltt
arm_func_start GX_LoadTexPltt
GX_LoadTexPltt: ; 0x020C0F50
stmfd sp!, {r4, r5, r6, lr}
sub sp, sp, #8
ldr r3, _020C0FB4 ; =0x02101148
ldr lr, _020C0FB8 ; =0x021CCBD8
ldr r4, [r3, #0]
mvn ip, #0
mov r6, r0
mov r5, r1
mov r3, r2
cmp r4, ip
ldr lr, [lr, #8]
beq _020C0FA4
mov ip, #0
str ip, [sp]
mov r0, r4
mov r1, r6
add r2, lr, r5
str ip, [sp, #4]
bl MI_DmaCopy32Async
add sp, sp, #8
ldmia sp!, {r4, r5, r6, pc}
_020C0FA4:
add r1, lr, r5
bl MIi_CpuCopy32
add sp, sp, #8
ldmia sp!, {r4, r5, r6, pc}
; .align 2, 0
_020C0FB4: .word GXi_DmaId
_020C0FB8: .word Unk_021CCBD8
arm_func_end GX_LoadTexPltt
arm_func_start GX_EndLoadTexPltt
GX_EndLoadTexPltt: ; 0x020C0FBC
stmfd sp!, {r3, lr}
ldr r0, _020C0FF8 ; =0x02101148
mvn r1, #0
ldr r0, [r0, #0]
cmp r0, r1
beq _020C0FD8
bl MI_WaitDma
_020C0FD8:
ldr r0, _020C0FFC ; =0x021CCBD8
ldr r0, [r0, #0xc]
bl GX_SetBankForTexPltt
ldr r0, _020C0FFC ; =0x021CCBD8
mov r1, #0
str r1, [r0, #0xc]
str r1, [r0, #8]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C0FF8: .word GXi_DmaId
_020C0FFC: .word Unk_021CCBD8
arm_func_end GX_EndLoadTexPltt
arm_func_start GX_BeginLoadClearImage
GX_BeginLoadClearImage: ; 0x020C1000
stmfd sp!, {r3, lr}
bl GX_ResetBankForClearImage
ldr r1, _020C1080 ; =0x021CCBD8
cmp r0, #0xc
str r0, [r1, #0]
addls pc, pc, r0, lsl #2
ldmia sp!, {r3, pc}
_020C101C: ; jump table
ldmia sp!, {r3, pc} ; case 0
b _020C1068 ; case 1
b _020C1050 ; case 2
b _020C1050 ; case 3
b _020C1074 ; case 4
ldmia sp!, {r3, pc} ; case 5
ldmia sp!, {r3, pc} ; case 6
ldmia sp!, {r3, pc} ; case 7
b _020C105C ; case 8
ldmia sp!, {r3, pc} ; case 9
ldmia sp!, {r3, pc} ; case 10
ldmia sp!, {r3, pc} ; case 11
b _020C105C ; case 12
_020C1050:
mov r0, #0x6800000
str r0, [r1, #0x10]
ldmia sp!, {r3, pc}
_020C105C:
ldr r0, _020C1084 ; =0x06840000
str r0, [r1, #0x10]
ldmia sp!, {r3, pc}
_020C1068:
ldr r0, _020C1088 ; =0x067E0000
str r0, [r1, #0x10]
ldmia sp!, {r3, pc}
_020C1074:
ldr r0, _020C108C ; =0x06820000
str r0, [r1, #0x10]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C1080: .word Unk_021CCBD8
_020C1084: .word 0x06840000
_020C1088: .word 0x067E0000
_020C108C: .word 0x06820000
arm_func_end GX_BeginLoadClearImage
arm_func_start GX_LoadClearImageColor
GX_LoadClearImageColor: ; 0x020C1090
stmfd sp!, {r4, lr}
sub sp, sp, #8
ldr r2, _020C10F0 ; =0x02101148
ldr ip, _020C10F4 ; =0x021CCBD8
ldr lr, [r2]
mvn r2, #0
mov r4, r0
mov r3, r1
cmp lr, r2
ldr r2, [ip, #0x10]
beq _020C10DC
mov ip, #0
str ip, [sp]
mov r0, lr
mov r1, r4
str ip, [sp, #4]
bl MI_DmaCopy32Async
add sp, sp, #8
ldmia sp!, {r4, pc}
_020C10DC:
mov r1, r2
mov r2, r3
bl MIi_CpuCopy32
add sp, sp, #8
ldmia sp!, {r4, pc}
; .align 2, 0
_020C10F0: .word GXi_DmaId
_020C10F4: .word Unk_021CCBD8
arm_func_end GX_LoadClearImageColor
arm_func_start GX_LoadClearImageDepth
GX_LoadClearImageDepth: ; 0x020C10F8
stmfd sp!, {r3, r4, r5, lr}
sub sp, sp, #8
ldr r2, _020C115C ; =0x02101148
ldr ip, _020C1160 ; =0x021CCBD8
ldr lr, [r2]
mvn r2, #0
mov r5, r0
mov r3, r1
cmp lr, r2
ldr r4, [ip, #0x10]
beq _020C1148
mov ip, #0
str ip, [sp]
mov r0, lr
mov r1, r5
add r2, r4, #0x20000
str ip, [sp, #4]
bl MI_DmaCopy32Async
add sp, sp, #8
ldmia sp!, {r3, r4, r5, pc}
_020C1148:
mov r2, r3
add r1, r4, #0x20000
bl MIi_CpuCopy32
add sp, sp, #8
ldmia sp!, {r3, r4, r5, pc}
; .align 2, 0
_020C115C: .word GXi_DmaId
_020C1160: .word Unk_021CCBD8
arm_func_end GX_LoadClearImageDepth
arm_func_start GX_EndLoadClearImage
GX_EndLoadClearImage: ; 0x020C1164
stmfd sp!, {r3, lr}
ldr r0, _020C11A0 ; =0x02101148
mvn r1, #0
ldr r0, [r0, #0]
cmp r0, r1
beq _020C1180
bl MI_WaitDma
_020C1180:
ldr r0, _020C11A4 ; =0x021CCBD8
ldr r0, [r0, #0]
bl GX_SetBankForClearImage
ldr r0, _020C11A4 ; =0x021CCBD8
mov r1, #0
str r1, [r0, #0]
str r1, [r0, #0x10]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C11A0: .word GXi_DmaId
_020C11A4: .word Unk_021CCBD8
arm_func_end GX_EndLoadClearImage
.rodata
.global Unk_020FD940
Unk_020FD940: ; 0x020FD940
.incbin "incbin/arm9_rodata.bin", 0x18D00, 0x18D10 - 0x18D00
.global Unk_020FD950
Unk_020FD950: ; 0x020FD950
.incbin "incbin/arm9_rodata.bin", 0x18D10, 0x60
.bss
.global Unk_021CCBD8
Unk_021CCBD8: ; 0x021CCBD8
.space 0x4
.global Unk_021CCBDC
Unk_021CCBDC: ; 0x021CCBDC
.space 0x4
.global Unk_021CCBE0
Unk_021CCBE0: ; 0x021CCBE0
.space 0x4
.global Unk_021CCBE4
Unk_021CCBE4: ; 0x021CCBE4
.space 0x4
.global Unk_021CCBE8
Unk_021CCBE8: ; 0x021CCBE8
.space 0x4
.global Unk_021CCBEC
Unk_021CCBEC: ; 0x021CCBEC
.space 0x4
.global Unk_021CCBF0
Unk_021CCBF0: ; 0x021CCBF0
.space 0x4
.global Unk_021CCBF4
Unk_021CCBF4: ; 0x021CCBF4
.space 0x4

1425
lib/NitroSDK/asm/gx/gx_vramcnt.s
View File

File diff suppressed because it is too large Load Diff

30
lib/NitroSDK/asm/gx/gxasm.s
View File

@ -1,30 +0,0 @@
.include "macros/function.inc"
.text
arm_func_start GX_SendFifo48B
GX_SendFifo48B: ; 0x020C1274
ldmia r0!, {r2, r3, ip}
stmia r1, {r2, r3, ip}
ldmia r0!, {r2, r3, ip}
stmia r1, {r2, r3, ip}
ldmia r0!, {r2, r3, ip}
stmia r1, {r2, r3, ip}
ldmia r0!, {r2, r3, ip}
stmia r1, {r2, r3, ip}
bx lr
arm_func_end GX_SendFifo48B
arm_func_start GX_SendFifo64B
GX_SendFifo64B: ; 0x020C1298
stmfd sp!, {r4, r5, r6, r7, r8}
ldmia r0!, {r2, r3, r4, r5, r6, r7, r8, ip}
stmia r1, {r2, r3, r4, r5, r6, r7, r8, ip}
ldmia r0!, {r2, r3, r4, r5, r6, r7, r8, ip}
stmia r1, {r2, r3, r4, r5, r6, r7, r8, ip}
ldmia sp!, {r4, r5, r6, r7, r8}
bx lr
arm_func_end GX_SendFifo64B

44
lib/NitroSDK/asm/gx/gxstate.s
View File

@ -1,44 +0,0 @@
.include "macros/function.inc"
.extern Unk_021CCBA0
.text
arm_func_start GX_InitGXState
GX_InitGXState: ; 0x020BDEEC
ldr r0, _020BDF44 ; =0x021CCBA0
mov r2, #0
strh r2, [r0]
strh r2, [r0, #2]
strh r2, [r0, #4]
strh r2, [r0, #6]
strh r2, [r0, #8]
strh r2, [r0, #0xa]
strh r2, [r0, #0xc]
strh r2, [r0, #0xe]
strh r2, [r0, #0x10]
strh r2, [r0, #0x12]
strh r2, [r0, #0x14]
strh r2, [r0, #0x16]
ldr r1, _020BDF48 ; =0x04000240
strh r2, [r0, #0x18]
str r2, [r1, #0]
strb r2, [r1, #4]
strb r2, [r1, #5]
strb r2, [r1, #6]
strh r2, [r1, #8]
bx lr
; .align 2, 0
_020BDF44: .word Unk_021CCBA0
_020BDF48: .word 0x04000240
arm_func_end GX_InitGXState
.bss
.global Unk_021CCBA0
Unk_021CCBA0: ; 0x021CCBA0
.space 0x1A

4
lib/NitroSDK/asm/gx/include/g3_util.inc
View File

@ -1,4 +0,0 @@
.public MTX_LookAt
.public MTX_OrthoW
.public G3_LoadMtx44
.public G3_LoadMtx43

2
lib/NitroSDK/asm/gx/include/g3b.inc
View File

@ -1,2 +0,0 @@
.public G3BS_LoadMtx44
.public MI_Copy64B

3
lib/NitroSDK/asm/gx/include/g3imm.inc
View File

@ -1,3 +0,0 @@
.public GX_SendFifo48B
.public GX_SendFifo64B
.public MI_Copy36B

14
lib/NitroSDK/asm/gx/include/g3x.inc
View File

@ -1,14 +0,0 @@
.public G3X_ClearFifo
.public G3X_InitMtxStack
.public G3X_ResetMtxStack
.public G3X_InitTable
.public G3X_GetMtxStackLevelPV
.public G3X_GetMtxStackLevelPJ
.public GXi_NopClearFifo128_
.public MI_DmaFill32
.public MI_DmaFill32Async
.public MIi_CpuCopy16
.public MIi_CpuClear32
.public MI_Copy32B
.public MI_Copy36B
.public MI_Copy64B

5
lib/NitroSDK/asm/gx/include/gx.inc
View File

@ -1,5 +0,0 @@
.public GX_InitGXState
.public OS_GetLockID
.public OS_Terminate
.public MI_DmaFill32
.public MIi_CpuClear32

30
lib/NitroSDK/asm/gx/include/gx_load2d.inc
View File

@ -1,30 +0,0 @@
.public GX_SetBankForBGExtPltt
.public GX_SetBankForOBJExtPltt
.public GX_SetBankForSubBGExtPltt
.public GX_SetBankForSubOBJExtPltt
.public GX_ResetBankForBGExtPltt
.public GX_ResetBankForOBJExtPltt
.public GX_ResetBankForSubBGExtPltt
.public GX_ResetBankForSubOBJExtPltt
.public G2_GetBG0ScrPtr
.public G2S_GetBG0ScrPtr
.public G2_GetBG1ScrPtr
.public G2S_GetBG1ScrPtr
.public G2_GetBG2ScrPtr
.public G2S_GetBG2ScrPtr
.public G2_GetBG3ScrPtr
.public G2S_GetBG3ScrPtr
.public G2_GetBG0CharPtr
.public G2S_GetBG0CharPtr
.public G2_GetBG1CharPtr
.public G2S_GetBG1CharPtr
.public G2_GetBG2CharPtr
.public G2S_GetBG2CharPtr
.public G2_GetBG3CharPtr
.public G2S_GetBG3CharPtr
.public MI_DmaCopy32
.public MI_DmaCopy16
.public MI_DmaCopy32Async
.public MI_WaitDma
.public MIi_CpuCopy16
.public MIi_CpuCopy32

10
lib/NitroSDK/asm/gx/include/gx_load3d.inc
View File

@ -1,10 +0,0 @@
.public GX_SetBankForTex
.public GX_SetBankForTexPltt
.public GX_SetBankForClearImage
.public GX_ResetBankForTex
.public GX_ResetBankForTexPltt
.public GX_ResetBankForClearImage
.public MI_DmaCopy32
.public MI_DmaCopy32Async
.public MI_WaitDma
.public MIi_CpuCopy32

4
lib/NitroSDK/asm/gx/include/gx_vramcnt.inc
View File

@ -1,4 +0,0 @@
.public GX_VRAMCNT_SetLCDC_
.public resetBankForX_
.public disableBankForX_
.public OSi_UnlockVram

72
lib/NitroSDK/asm/gx/libgx.s
View File

@ -1,72 +0,0 @@
.include "macros/function.inc"
.text
arm_func_start G3_BeginMakeDL
G3_BeginMakeDL: ; 0x020C11A8
str r2, [r0, #0xc]
str r1, [r0, #8]
str r1, [r0, #0]
add r1, r1, #4
str r1, [r0, #4]
mov r1, #0
str r1, [r0, #0x10]
bx lr
arm_func_end G3_BeginMakeDL
arm_func_start G3_EndMakeDL
G3_EndMakeDL: ; 0x020C11C8
ldr r3, [r0, #0]
ldr r2, [r0, #8]
cmp r2, r3
moveq r0, #0
bxeq lr
and r1, r3, #3
cmp r1, #3
addls pc, pc, r1, lsl #2
b _020C123C
_020C11EC: ; jump table
b _020C11FC ; case 0
b _020C1204 ; case 1
b _020C1214 ; case 2
b _020C1228 ; case 3
_020C11FC:
sub r0, r3, r2
bx lr
_020C1204:
add r1, r3, #1
str r1, [r0, #0]
mov r1, #0
strb r1, [r3]
_020C1214:
ldr r3, [r0, #0]
mov r1, #0
add r2, r3, #1
str r2, [r0, #0]
strb r1, [r3]
_020C1228:
ldr r3, [r0, #0]
mov r1, #0
add r2, r3, #1
str r2, [r0, #0]
strb r1, [r3]
_020C123C:
ldr r1, [r0, #0x10]
cmp r1, #0
beq _020C1260
ldr r3, [r0, #4]
mov r1, #0
add r2, r3, #4
str r2, [r0, #4]
str r1, [r3, #0]
str r1, [r0, #0x10]
_020C1260:
ldr r1, [r0, #4]
str r1, [r0, #0]
ldr r0, [r0, #8]
sub r0, r1, r0
bx lr
arm_func_end G3_EndMakeDL

102
lib/NitroSDK/src/gx/g2.c Normal file
View File

@ -0,0 +1,102 @@
#include <nitro/gx/g2.h>
#include <nitro/fx/fx_const.h>
#include <nitro/code32.h>
void G2x_SetBGyAffine_ (u32 addr, const MtxFx22 * mtx, int centerX, int centerY, int x1, int y1) {
s32 dx, dy;
fx32 x2, y2;
SDK_NULL_ASSERT(mtx);
SDK_MINMAX_ASSERT(mtx->_00, -128 * FX32_ONE, 128 * FX32_ONE - 1);
SDK_MINMAX_ASSERT(mtx->_01, -128 * FX32_ONE, 128 * FX32_ONE - 1);
SDK_MINMAX_ASSERT(mtx->_10, -128 * FX32_ONE, 128 * FX32_ONE - 1);
SDK_MINMAX_ASSERT(mtx->_11, -128 * FX32_ONE, 128 * FX32_ONE - 1);
*((vu32 *)addr + 0) = (u32)((u16)(s16)(mtx->_00 >> 4) | (u16)(s16)(mtx->_01 >> 4) << 16);
*((vu32 *)addr + 1) = (u32)((u16)(s16)(mtx->_10 >> 4) | (u16)(s16)(mtx->_11 >> 4) << 16);
dx = x1 - centerX;
dy = y1 - centerY;
x2 = mtx->_00 * dx + mtx->_01 * dy + (centerX << FX32_SHIFT);
y2 = mtx->_10 * dx + mtx->_11 * dy + (centerY << FX32_SHIFT);
*((vu32 *)addr + 2) = (u32)(x2 >> 4);
*((vu32 *)addr + 3) = (u32)(y2 >> 4);
}
#include <nitro/codereset.h>
typedef enum {
G2_BLENDTYPE_NONE = 0x0000,
G2_BLENDTYPE_ALPHA = 0x0040,
G2_BLENDTYPE_FADEIN = 0x0080,
G2_BLENDTYPE_FADEOUT = 0x00c0
} G2_BLENDTYPE;
void G2x_SetBlendAlpha_ (u32 addr, int plane1, int plane2, int ev1, int ev2) {
SDK_MINMAX_ASSERT(plane1, 0, 0x20 - 1);
SDK_MINMAX_ASSERT(plane2, 0, 0x40 - 1);
SDK_MINMAX_ASSERT(ev1, 0, 31);
SDK_MINMAX_ASSERT(ev2, 0, 31);
*((vu32 *)addr + 0) =
(u32)((G2_BLENDTYPE_ALPHA | plane1 | plane2 << 8) | ((ev1 | ev2 << 8) << 16));
}
void G2x_SetBlendBrightness_ (u32 addr, int plane, int brightness) {
SDK_MINMAX_ASSERT(brightness, -31, 31);
SDK_MINMAX_ASSERT(plane, 0, 0x40 - 1);
if (brightness < 0) {
*((vu16 *)addr + 0) = (u16)(G2_BLENDTYPE_FADEOUT | plane);
*((vu16 *)addr + 2) = (u16) - brightness;
} else {
*((vu16 *)addr + 0) = (u16)(G2_BLENDTYPE_FADEIN | plane);
*((vu16 *)addr + 2) = (u16)brightness;
}
}
void G2x_SetBlendBrightnessExt_ (u32 addr, int plane1, int plane2, int ev1, int ev2, int brightness) {
SDK_MINMAX_ASSERT(brightness, -31, 31);
SDK_MINMAX_ASSERT(plane1, 0, 0x40 - 1);
SDK_MINMAX_ASSERT(plane2, 0, 0x40 - 1);
SDK_MINMAX_ASSERT(ev1, 0, 31);
SDK_MINMAX_ASSERT(ev2, 0, 31);
*((vu16 *)addr + 1) = (u16)(ev1 | (ev2 << 8));
if (brightness < 0) {
*((vu16 *)addr + 0) = (u16)(G2_BLENDTYPE_FADEOUT | plane1 | (plane2 << 8));
*((vu16 *)addr + 2) = (u16) - brightness;
} else {
*((vu16 *)addr + 0) = (u16)(G2_BLENDTYPE_FADEIN | plane1 | (plane2 << 8));
*((vu16 *)addr + 2) = (u16)brightness;
}
}
void G2x_ChangeBlendBrightness_ (u32 addr, int brightness) {
u16 tmp;
SDK_MINMAX_ASSERT(brightness, -31, 31);
tmp = *((vu16 *)addr + 0);
if (brightness < 0) {
if (G2_BLENDTYPE_FADEIN == (tmp & REG_G2_BLDCNT_EFFECT_MASK)) {
*((vu16 *)addr + 0) = (u16)((tmp & ~REG_G2_BLDCNT_EFFECT_MASK) | G2_BLENDTYPE_FADEOUT);
}
*((vu16 *)addr + 2) = (u16) - brightness;
} else {
if (G2_BLENDTYPE_FADEOUT == (tmp & REG_G2_BLDCNT_EFFECT_MASK)) {
*((vu16 *)addr + 0) = (u16)((tmp & ~REG_G2_BLDCNT_EFFECT_MASK) | G2_BLENDTYPE_FADEIN);
}
*((vu16 *)addr + 2) = (u16)brightness;
}
}

53
lib/NitroSDK/src/gx/g3.c Normal file
View File

@ -0,0 +1,53 @@
#include <nitro/gx/g3.h>
void G3_BeginMakeDL (GXDLInfo * info, void * ptr, u32 length) {
SDK_ALIGN4_ASSERT(ptr);
SDK_ALIGN4_ASSERT(length);
info->length = length;
info->bottom = (u32 *)ptr;
info->curr_cmd = (u8 *)ptr;
info->curr_param = (u32 *)ptr + 1;
info->param0_cmd_flg = FALSE;
}
#include <nitro/code32.h>
u32 G3_EndMakeDL (GXDLInfo * info) {
u32 sz;
if ((u8 *)info->bottom == info->curr_cmd) {
return 0;
}
switch ((u32)info->curr_cmd & 3) {
case 0:
SDK_ASSERT((u32)info->bottom < (u32)info->curr_cmd);
return (u32)((u32)info->curr_cmd - (u32)info->bottom);
case 1:
*info->curr_cmd++ = 0;
case 2:
*info->curr_cmd++ = 0;
case 3:
*info->curr_cmd++ = 0;
}
;
if (info->param0_cmd_flg) {
*(u32 *)(info->curr_param++) = 0;
info->param0_cmd_flg = FALSE;
}
info->curr_cmd = (u8 *)info->curr_param;
SDK_ASSERT((u32)info->bottom < (u32)info->curr_cmd);
SDK_ASSERTMSG(
((u32)info->curr_cmd - (u32)info->bottom <= info->length),
"Buffer overflow ! : Current DL buffer doesn't have enough capacity for new commands\n"
);
sz = (u32)((u32)info->curr_cmd - (u32)info->bottom);
return sz;
}
#include <nitro/codereset.h>

308
lib/NitroSDK/src/gx/g3_util.c Normal file
View File

@ -0,0 +1,308 @@
#include <nitro/gx/g3_util.h>
#include <nitro/gx/g3imm.h>
#include <nitro/gx/g3b.h>
#include <nitro/gx/g3c.h>
#include <nitro/gx/gx_vramcnt.h>
#include <nitro/fx/fx_cp.h>
#include <nitro/fx/fx_vec.h>
#include <nitro/hw/ARM9/mmap_global.h>
#include <nitro/mi/dma.h>
#include <nitro/mi/memory.h>
void G3i_FrustumW_ (fx32 t, fx32 b, fx32 l, fx32 r, fx32 n, fx32 f, fx32 scaleW, BOOL draw, MtxFx44 * mtx) {
MtxFx44 tmp[1];
if (mtx == NULL) {
mtx = tmp;
}
MTX_FrustumW(t, b, l, r, n, f, scaleW, mtx);
if (draw) {
G3_MtxMode(GX_MTXMODE_PROJECTION);
G3_LoadMtx44(mtx);
}
}
void G3i_PerspectiveW_ (fx32 fovySin, fx32 fovyCos, fx32 aspect, fx32 n, fx32 f, fx32 scaleW, BOOL draw, MtxFx44 * mtx) {
MtxFx44 tmp[1];
if (mtx == NULL) {
mtx = tmp;
}
MTX_PerspectiveW(fovySin, fovyCos, aspect, n, f, scaleW, mtx);
if (draw) {
G3_MtxMode(GX_MTXMODE_PROJECTION);
G3_LoadMtx44(mtx);
}
}
void G3i_OrthoW_ (fx32 t, fx32 b, fx32 l, fx32 r, fx32 n, fx32 f, fx32 scaleW, BOOL draw, MtxFx44 * mtx) {
MtxFx44 tmp[1];
if (mtx == NULL) {
mtx = tmp;
}
MTX_OrthoW(t, b, l, r, n, f, scaleW, mtx);
if (draw) {
G3_MtxMode(GX_MTXMODE_PROJECTION);
G3_LoadMtx44(mtx);
}
}
void G3i_LookAt_ (const VecFx32 * camPos, const VecFx32 * camUp, const VecFx32 * target, BOOL draw, MtxFx43 * mtx) {
MtxFx43 tmp[1];
if (mtx == NULL) {
mtx = tmp;
}
MTX_LookAt(camPos, camUp, target, mtx);
if (draw) {
G3_MtxMode(GX_MTXMODE_POSITION_VECTOR);
G3_LoadMtx43(mtx);
}
}
void G3_RotX (fx32 s, fx32 c) {
vs32 * p = (vs32 *)&reg_G3_MTX_MULT_3x3;
SDK_MINMAX_ASSERT(s, -FX32_ONE, FX32_ONE);
SDK_MINMAX_ASSERT(c, -FX32_ONE, FX32_ONE);
*p = FX32_ONE;
*p = 0;
*p = 0;
*p = 0;
*p = c;
*p = s;
*p = 0;
*p = -s;
*p = c;
}
void G3_RotY (fx32 s, fx32 c) {
vs32 * p = (vs32 *)&reg_G3_MTX_MULT_3x3;
SDK_MINMAX_ASSERT(s, -FX32_ONE, FX32_ONE);
SDK_MINMAX_ASSERT(c, -FX32_ONE, FX32_ONE);
*p = c;
*p = 0;
*p = -s;
*p = 0;
*p = FX32_ONE;
*p = 0;
*p = s;
*p = 0;
*p = c;
}
void G3_RotZ (fx32 s, fx32 c) {
vs32 * p = (vs32 *)&reg_G3_MTX_MULT_3x3;
SDK_MINMAX_ASSERT(s, -FX32_ONE, FX32_ONE);
SDK_MINMAX_ASSERT(c, -FX32_ONE, FX32_ONE);
*p = c;
*p = s;
*p = 0;
*p = -s;
*p = c;
*p = 0;
*p = 0;
*p = 0;
*p = FX32_ONE;
}
void G3_LoadTexMtxTexCoord (const MtxFx44 * mtx) {
vs32 * p = (vs32 *)&reg_G3_MTX_LOAD_4x4;
SDK_NULL_ASSERT(mtx);
G3_MtxMode(GX_MTXMODE_TEXTURE);
*p = mtx->_00;
*p = mtx->_01;
*p = mtx->_02;
*p = mtx->_03;
*p = mtx->_10;
*p = mtx->_11;
*p = mtx->_12;
*p = mtx->_13;
*p = mtx->_20 << 4;
*p = mtx->_21 << 4;
*p = mtx->_22 << 4;
*p = mtx->_23 << 4;
*p = mtx->_30 << 4;
*p = mtx->_31 << 4;
*p = mtx->_32 << 4;
*p = mtx->_33 << 4;
}
static void G3xx_LoadTexMtxTexCoord_ (u32 * param, const MtxFx44 * mtx) {
#if 1
MI_Copy32B(&mtx->_00, (void *)(param + 2));
#else
*(param + 2) = (u32)(mtx->_00);
*(param + 3) = (u32)(mtx->_01);
*(param + 4) = (u32)(mtx->_02);
*(param + 5) = (u32)(mtx->_03);
*(param + 6) = (u32)(mtx->_10);
*(param + 7) = (u32)(mtx->_11);
*(param + 8) = (u32)(mtx->_12);
*(param + 9) = (u32)(mtx->_13);
#endif
*(param + 10) = (u32)(mtx->_20 << 4);
*(param + 11) = (u32)(mtx->_21 << 4);
*(param + 12) = (u32)(mtx->_22 << 4);
*(param + 13) = (u32)(mtx->_23 << 4);
*(param + 14) = (u32)(mtx->_30 << 4);
*(param + 15) = (u32)(mtx->_31 << 4);
*(param + 16) = (u32)(mtx->_32 << 4);
*(param + 17) = (u32)(mtx->_33 << 4);
}
void G3BS_LoadTexMtxTexCoord (GXDLInfo * info, const MtxFx44 * mtx) {
SDK_NULL_ASSERT(mtx);
SDK_NULL_ASSERT(info);
*(u32 *)info->curr_cmd = (u32)G3OP_MTX_MODE;
*info->curr_param = (u32)(GX_MTXMODE_TEXTURE << REG_G3_MTX_MODE_M_SHIFT);
*(info->curr_param + 1) = (u32)G3OP_MTX_LOAD_4x4;
G3xx_LoadTexMtxTexCoord_(info->curr_param, mtx);
}
#include <nitro/code32.h>
void G3CS_LoadTexMtxTexCoord (GXDLInfo * info, const MtxFx44 * mtx) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(mtx);
switch ((u32)info->curr_cmd & 3) {
case 0:
break;
case 1:
*info->curr_cmd++ = 0;
case 2:
*info->curr_cmd++ = 0;
case 3:
*info->curr_cmd++ = 0;
++info->curr_param;
}
;
*(u32 *)info->curr_cmd = (G3OP_MTX_LOAD_4x4 << 8) | G3OP_MTX_MODE;
*info->curr_param = (u32)(GX_MTXMODE_TEXTURE << REG_G3_MTX_MODE_M_SHIFT);
*(info->curr_param + 1) = (u32)G3OP_MTX_LOAD_4x4;
G3xx_LoadTexMtxTexCoord_(info->curr_param, mtx);
}
#include <nitro/codereset.h>
void G3_LoadTexMtxEnv (const MtxFx44 * mtx) {
vs32 * p = (vs32 *)&reg_G3_MTX_LOAD_4x4;
SDK_NULL_ASSERT(mtx);
G3_MtxMode(GX_MTXMODE_TEXTURE);
*p = mtx->_00 << 4;
*p = mtx->_01 << 4;
*p = mtx->_02 << 4;
*p = mtx->_03 << 4;
*p = mtx->_10 << 4;
*p = mtx->_11 << 4;
*p = mtx->_12 << 4;
*p = mtx->_13 << 4;
*p = mtx->_20 << 4;
*p = mtx->_21 << 4;
*p = mtx->_22 << 4;
*p = mtx->_23 << 4;
*p = mtx->_30;
*p = mtx->_31;
*p = mtx->_32;
*p = mtx->_33;
}
void G3BS_LoadTexMtxEnv (GXDLInfo * info, const MtxFx44 * mtx) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(mtx);
*(u32 *)info->curr_cmd = (u32)G3OP_MTX_MODE;
*info->curr_param = (u32)(GX_MTXMODE_TEXTURE << REG_G3_MTX_MODE_M_SHIFT);
*(info->curr_param + 1) = (u32)G3OP_MTX_LOAD_4x4;
*(info->curr_param + 2) = (u32)(mtx->_00 << 4);
*(info->curr_param + 3) = (u32)(mtx->_01 << 4);
*(info->curr_param + 4) = (u32)(mtx->_02 << 4);
*(info->curr_param + 5) = (u32)(mtx->_03 << 4);
*(info->curr_param + 6) = (u32)(mtx->_10 << 4);
*(info->curr_param + 7) = (u32)(mtx->_11 << 4);
*(info->curr_param + 8) = (u32)(mtx->_12 << 4);
*(info->curr_param + 9) = (u32)(mtx->_13 << 4);
*(info->curr_param + 10) = (u32)(mtx->_20 << 4);
*(info->curr_param + 11) = (u32)(mtx->_21 << 4);
*(info->curr_param + 12) = (u32)(mtx->_22 << 4);
*(info->curr_param + 13) = (u32)(mtx->_23 << 4);
*(info->curr_param + 14) = (u32)mtx->_30;
*(info->curr_param + 15) = (u32)mtx->_31;
*(info->curr_param + 16) = (u32)mtx->_32;
*(info->curr_param + 17) = (u32)mtx->_33;
}
#include <nitro/code32.h>
void G3CS_LoadTexMtxEnv (GXDLInfo * info, const MtxFx44 * mtx) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(mtx);
switch ((u32)info->curr_cmd & 3) {
case 0:
break;
case 1:
*info->curr_cmd++ = 0;
case 2:
*info->curr_cmd++ = 0;
case 3:
*info->curr_cmd++ = 0;
++info->curr_param;
}
;
*(u32 *)info->curr_cmd = (G3OP_MTX_LOAD_4x4 << 8) | G3OP_MTX_MODE;
*info->curr_param = (u32)(GX_MTXMODE_TEXTURE << REG_G3_MTX_MODE_M_SHIFT);
*(info->curr_param + 1) = (u32)G3OP_MTX_LOAD_4x4;
*(info->curr_param + 2) = (u32)(mtx->_00 << 4);
*(info->curr_param + 3) = (u32)(mtx->_01 << 4);
*(info->curr_param + 4) = (u32)(mtx->_02 << 4);
*(info->curr_param + 5) = (u32)(mtx->_03 << 4);
*(info->curr_param + 6) = (u32)(mtx->_10 << 4);
*(info->curr_param + 7) = (u32)(mtx->_11 << 4);
*(info->curr_param + 8) = (u32)(mtx->_12 << 4);
*(info->curr_param + 9) = (u32)(mtx->_13 << 4);
*(info->curr_param + 10) = (u32)(mtx->_20 << 4);
*(info->curr_param + 11) = (u32)(mtx->_21 << 4);
*(info->curr_param + 12) = (u32)(mtx->_22 << 4);
*(info->curr_param + 13) = (u32)(mtx->_23 << 4);
*(info->curr_param + 14) = (u32)(mtx->_30);
*(info->curr_param + 15) = (u32)(mtx->_31);
*(info->curr_param + 16) = (u32)(mtx->_32);
*(info->curr_param + 17) = (u32)(mtx->_33);
}
#include <nitro/codereset.h>
void G3B_LoadTexMtxTexCoord (GXDLInfo * info, const MtxFx44 * mtx) {
G3BS_LoadTexMtxTexCoord(info, mtx);
G3B_UpdateGXDLInfo(info, G3OP_MTX_MODE_NPARAMS + G3OP_MTX_LOAD_4x4_NPARAMS + 1);
}
void G3C_LoadTexMtxTexCoord (GXDLInfo * info, const MtxFx44 * mtx) {
G3CS_LoadTexMtxTexCoord(info, mtx);
info->curr_param += G3OP_MTX_MODE_NPARAMS + G3OP_MTX_LOAD_4x4_NPARAMS + 1;
info->curr_cmd += 2;
}
void G3B_LoadTexMtxEnv (GXDLInfo * info, const MtxFx44 * mtx) {
G3BS_LoadTexMtxEnv(info, mtx);
G3B_UpdateGXDLInfo(info, G3OP_MTX_MODE_NPARAMS + G3OP_MTX_LOAD_4x4_NPARAMS + 1);
}
void G3C_LoadTexMtxEnv (GXDLInfo * info, const MtxFx44 * mtx) {
G3CS_LoadTexMtxEnv(info, mtx);
info->curr_param += G3OP_MTX_MODE_NPARAMS + G3OP_MTX_LOAD_4x4_NPARAMS + 1;
info->curr_cmd += 2;
}

427
lib/NitroSDK/src/gx/g3b.c Normal file
View File

@ -0,0 +1,427 @@
#ifdef SDK_WIN32
#include <nitro_win32.h>
#else
#include <nitro/gx/g3b.h>
#include <nitro/mi/dma.h>
#include <nitro/mi/memory.h>
#include "include/gxasm.h"
#endif
void G3BS_DirectN (GXDLInfo * info, int op, int nParams, const u32 * params) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(params);
SDK_NULL_ASSERT(info->curr_param);
SDK_ALIGN4_ASSERT(info->curr_cmd);
SDK_ASSERT(op >= 0 && op < 0x100);
*(u32 *)info->curr_cmd = (u32)op;
while (--nParams >= 0) {
*(info->curr_param + nParams) = *(params + nParams);
}
}
void G3BS_LoadMtx44 (GXDLInfo * info, const MtxFx44 * m) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(m);
SDK_NULL_ASSERT(info->curr_param);
SDK_ALIGN4_ASSERT(info->curr_cmd);
*(u32 *)info->curr_cmd = G3OP_MTX_LOAD_4x4;
#ifndef SDK_WIN32
MI_Copy64B(&m->_00, (void *)info->curr_param);
#else
*(info->curr_param + 0) = (u32)m->_00;
*(info->curr_param + 1) = (u32)m->_01;
*(info->curr_param + 2) = (u32)m->_02;
*(info->curr_param + 3) = (u32)m->_03;
*(info->curr_param + 4) = (u32)m->_10;
*(info->curr_param + 5) = (u32)m->_11;
*(info->curr_param + 6) = (u32)m->_12;
*(info->curr_param + 7) = (u32)m->_13;
*(info->curr_param + 8) = (u32)m->_20;
*(info->curr_param + 9) = (u32)m->_21;
*(info->curr_param + 10) = (u32)m->_22;
*(info->curr_param + 11) = (u32)m->_23;
*(info->curr_param + 12) = (u32)m->_30;
*(info->curr_param + 13) = (u32)m->_31;
*(info->curr_param + 14) = (u32)m->_32;
*(info->curr_param + 15) = (u32)m->_33;
#endif
}
void G3BS_LoadMtx43 (GXDLInfo * info, const MtxFx43 * m) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(m);
SDK_NULL_ASSERT(info->curr_param);
SDK_ALIGN4_ASSERT(info->curr_cmd);
*(u32 *)info->curr_cmd = G3OP_MTX_LOAD_4x3;
#ifndef SDK_WIN32
MI_Copy48B(&m->_00, (void *)info->curr_param);
#else
*(info->curr_param + 0) = (u32)m->_00;
*(info->curr_param + 1) = (u32)m->_01;
*(info->curr_param + 2) = (u32)m->_02;
*(info->curr_param + 3) = (u32)m->_10;
*(info->curr_param + 4) = (u32)m->_11;
*(info->curr_param + 5) = (u32)m->_12;
*(info->curr_param + 6) = (u32)m->_20;
*(info->curr_param + 7) = (u32)m->_21;
*(info->curr_param + 8) = (u32)m->_22;
*(info->curr_param + 9) = (u32)m->_30;
*(info->curr_param + 10) = (u32)m->_31;
*(info->curr_param + 11) = (u32)m->_32;
#endif
}
void G3BS_MultMtx44 (GXDLInfo * info, const MtxFx44 * m) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(m);
SDK_NULL_ASSERT(info->curr_param);
SDK_ALIGN4_ASSERT(info->curr_cmd);
*(u32 *)info->curr_cmd = G3OP_MTX_MULT_4x4;
#ifndef SDK_WIN32
MI_Copy64B(&m->_00, (void *)info->curr_param);
#else
*(info->curr_param + 0) = (u32)m->_00;
*(info->curr_param + 1) = (u32)m->_01;
*(info->curr_param + 2) = (u32)m->_02;
*(info->curr_param + 3) = (u32)m->_03;
*(info->curr_param + 4) = (u32)m->_10;
*(info->curr_param + 5) = (u32)m->_11;
*(info->curr_param + 6) = (u32)m->_12;
*(info->curr_param + 7) = (u32)m->_13;
*(info->curr_param + 8) = (u32)m->_20;
*(info->curr_param + 9) = (u32)m->_21;
*(info->curr_param + 10) = (u32)m->_22;
*(info->curr_param + 11) = (u32)m->_23;
*(info->curr_param + 12) = (u32)m->_30;
*(info->curr_param + 13) = (u32)m->_31;
*(info->curr_param + 14) = (u32)m->_32;
*(info->curr_param + 15) = (u32)m->_33;
#endif
}
void G3BS_MultMtx43 (GXDLInfo * info, const MtxFx43 * m) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(m);
SDK_NULL_ASSERT(info->curr_param);
SDK_ALIGN4_ASSERT(info->curr_cmd);
*(u32 *)info->curr_cmd = G3OP_MTX_MULT_4x3;
#ifndef SDK_WIN32
MI_Copy48B(&m->_00, (void *)info->curr_param);
#else
*(info->curr_param + 0) = (u32)m->_00;
*(info->curr_param + 1) = (u32)m->_01;
*(info->curr_param + 2) = (u32)m->_02;
*(info->curr_param + 3) = (u32)m->_10;
*(info->curr_param + 4) = (u32)m->_11;
*(info->curr_param + 5) = (u32)m->_12;
*(info->curr_param + 6) = (u32)m->_20;
*(info->curr_param + 7) = (u32)m->_21;
*(info->curr_param + 8) = (u32)m->_22;
*(info->curr_param + 9) = (u32)m->_30;
*(info->curr_param + 10) = (u32)m->_31;
*(info->curr_param + 11) = (u32)m->_32;
#endif
}
void G3BS_MultMtx33 (GXDLInfo * info, const MtxFx33 * m) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(m);
SDK_NULL_ASSERT(info->curr_param);
SDK_ALIGN4_ASSERT(info->curr_cmd);
*(u32 *)info->curr_cmd = G3OP_MTX_MULT_3x3;
#ifndef SDK_WIN32
MI_Copy36B(&m->_00, (void *)info->curr_param);
#else
*(info->curr_param + 0) = (u32)m->_00;
*(info->curr_param + 1) = (u32)m->_01;
*(info->curr_param + 2) = (u32)m->_02;
*(info->curr_param + 3) = (u32)m->_10;
*(info->curr_param + 4) = (u32)m->_11;
*(info->curr_param + 5) = (u32)m->_12;
*(info->curr_param + 6) = (u32)m->_20;
*(info->curr_param + 7) = (u32)m->_21;
*(info->curr_param + 8) = (u32)m->_22;
#endif
}
void G3BS_MultTransMtx33 (GXDLInfo * info, const MtxFx33 * mtx, const VecFx32 * trans) {
SDK_NULL_ASSERT(info);
SDK_NULL_ASSERT(mtx);
SDK_NULL_ASSERT(trans);
SDK_NULL_ASSERT(info->curr_param);
SDK_ALIGN4_ASSERT(info->curr_cmd);
*(u32 *)info->curr_cmd = G3OP_MTX_MULT_4x3;
#ifndef SDK_WIN32
MI_Copy36B(&mtx->_00, (void *)info->curr_param);
MI_CpuCopy32(trans, (u32 *)info->curr_param + 9, sizeof(VecFx32));
#else
*((u32 *)info->curr_param + 0) = (u32)mtx->_00;
*((u32 *)info->curr_param + 1) = (u32)mtx->_01;
*((u32 *)info->curr_param + 2) = (u32)mtx->_02;
*((u32 *)info->curr_param + 3) = (u32)mtx->_10;
*((u32 *)info->curr_param + 4) = (u32)mtx->_11;
*((u32 *)info->curr_param + 5) = (u32)mtx->_12;
*((u32 *)info->curr_param + 6) = (u32)mtx->_20;
*((u32 *)info->curr_param + 7) = (u32)mtx->_21;
*((u32 *)info->curr_param + 8) = (u32)mtx->_22;
*((u32 *)info->curr_param + 9) = trans->x;
*((u32 *)info->curr_param + 10) = trans->y;
*((u32 *)info->curr_param + 11) = trans->z;
#endif
}
void G3B_Direct0 (GXDLInfo * info, int op) {
G3BS_Direct0(info, op);
G3B_UpdateGXDLInfo(info, 0);
}
void G3B_Direct1 (GXDLInfo * info, int op, u32 param0) {
G3BS_Direct1(info, op, param0);
G3B_UpdateGXDLInfo(info, 1);
}
void G3B_Direct2 (GXDLInfo * info, int op, u32 param0, u32 param1) {
G3BS_Direct2(info, op, param0, param1);
G3B_UpdateGXDLInfo(info, 2);
}
void G3B_Direct3 (GXDLInfo * info, int op, u32 param0, u32 param1, u32 param2) {
G3BS_Direct3(info, op, param0, param1, param2);
G3B_UpdateGXDLInfo(info, 3);
}
void G3B_DirectN (GXDLInfo * info, int op, int nParams, const u32 * params) {
G3BS_DirectN(info, op, nParams, params);
G3B_UpdateGXDLInfo(info, nParams);
}
void G3B_Nop (GXDLInfo * info) {
G3BS_Nop(info);
G3B_UpdateGXDLInfo(info, G3OP_NOP_NPARAMS);
}
void G3B_MtxMode (GXDLInfo * info, GXMtxMode mode) {
G3BS_MtxMode(info, mode);
G3B_UpdateGXDLInfo(info, G3OP_MTX_MODE_NPARAMS);
}
void G3B_PushMtx (GXDLInfo * info) {
G3BS_PushMtx(info);
G3B_UpdateGXDLInfo(info, G3OP_MTX_PUSH_NPARAMS);
}
void G3B_PopMtx (GXDLInfo * info, int num) {
G3BS_PopMtx(info, num);
G3B_UpdateGXDLInfo(info, G3OP_MTX_POP_NPARAMS);
}
void G3B_StoreMtx (GXDLInfo * info, int num) {
G3BS_StoreMtx(info, num);
G3B_UpdateGXDLInfo(info, G3OP_MTX_STORE_NPARAMS);
}
void G3B_RestoreMtx (GXDLInfo * info, int num) {
G3BS_RestoreMtx(info, num);
G3B_UpdateGXDLInfo(info, G3OP_MTX_RESTORE_NPARAMS);
}
void G3B_Identity (GXDLInfo * info) {
G3BS_Identity(info);
G3B_UpdateGXDLInfo(info, G3OP_MTX_IDENTITY_NPARAMS);
}
void G3B_LoadMtx44 (GXDLInfo * info, const MtxFx44 * m) {
G3BS_LoadMtx44(info, m);
G3B_UpdateGXDLInfo(info, G3OP_MTX_LOAD_4x4_NPARAMS);
}
void G3B_LoadMtx43 (GXDLInfo * info, const MtxFx43 * m) {
G3BS_LoadMtx43(info, m);
G3B_UpdateGXDLInfo(info, G3OP_MTX_LOAD_4x3_NPARAMS);
}
void G3B_MultMtx44 (GXDLInfo * info, const MtxFx44 * m) {
G3BS_MultMtx44(info, m);
G3B_UpdateGXDLInfo(info, G3OP_MTX_MULT_4x4_NPARAMS);
}
void G3B_MultMtx43 (GXDLInfo * info, const MtxFx43 * m) {
G3BS_MultMtx43(info, m);
G3B_UpdateGXDLInfo(info, G3OP_MTX_MULT_4x3_NPARAMS);
}
void G3B_MultMtx33 (GXDLInfo * info, const MtxFx33 * m) {
G3BS_MultMtx33(info, m);
G3B_UpdateGXDLInfo(info, G3OP_MTX_MULT_3x3_NPARAMS);
}
void G3B_MultTransMtx33 (GXDLInfo * info, const MtxFx33 * mtx, const VecFx32 * trans) {
G3BS_MultTransMtx33(info, mtx, trans);
G3B_UpdateGXDLInfo(info, G3OP_MTX_MULT_4x3_NPARAMS);
}
void G3B_Scale (GXDLInfo * info, fx32 x, fx32 y, fx32 z) {
G3BS_Scale(info, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_MTX_SCALE_NPARAMS);
}
void G3B_Translate (GXDLInfo * info, fx32 x, fx32 y, fx32 z) {
G3BS_Translate(info, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_MTX_TRANS_NPARAMS);
}
void G3B_Color (GXDLInfo * info, GXRgb rgb) {
G3BS_Color(info, rgb);
G3B_UpdateGXDLInfo(info, G3OP_COLOR_NPARAMS);
}
void G3B_Normal (GXDLInfo * info, fx16 x, fx16 y, fx16 z) {
G3BS_Normal(info, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_NORMAL_NPARAMS);
}
void G3B_TexCoord (GXDLInfo * info, fx32 s, fx32 t) {
G3BS_TexCoord(info, s, t);
G3B_UpdateGXDLInfo(info, G3OP_TEXCOORD_NPARAMS);
}
void G3B_Vtx (GXDLInfo * info, fx16 x, fx16 y, fx16 z) {
G3BS_Vtx(info, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_VTX_16_NPARAMS);
}
void G3B_Vtx10 (GXDLInfo * info, fx16 x, fx16 y, fx16 z) {
G3BS_Vtx10(info, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_VTX_10_NPARAMS);
}
void G3B_VtxXY (GXDLInfo * info, fx16 x, fx16 y) {
G3BS_VtxXY(info, x, y);
G3B_UpdateGXDLInfo(info, G3OP_VTX_XY_NPARAMS);
}
void G3B_VtxXZ (GXDLInfo * info, fx16 x, fx16 z) {
G3BS_VtxXZ(info, x, z);
G3B_UpdateGXDLInfo(info, G3OP_VTX_XZ_NPARAMS);
}
void G3B_VtxYZ (GXDLInfo * info, fx16 y, fx16 z) {
G3BS_VtxYZ(info, y, z);
G3B_UpdateGXDLInfo(info, G3OP_VTX_YZ_NPARAMS);
}
void G3B_VtxDiff (GXDLInfo * info, fx16 x, fx16 y, fx16 z) {
G3BS_VtxDiff(info, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_VTX_DIFF_NPARAMS);
}
void G3B_PolygonAttr (GXDLInfo * info, int light, GXPolygonMode polyMode, GXCull cullMode, int polygonID, int alpha, int misc) {
G3BS_PolygonAttr(info, light, polyMode, cullMode, polygonID, alpha, misc);
G3B_UpdateGXDLInfo(info, G3OP_POLYGON_ATTR_NPARAMS);
}
void G3B_TexImageParam (GXDLInfo * info, GXTexFmt texFmt, GXTexGen texGen, GXTexSizeS s, GXTexSizeT t, GXTexRepeat repeat, GXTexFlip flip, GXTexPlttColor0 pltt0, u32 addr) {
G3BS_TexImageParam(info, texFmt, texGen, s, t, repeat, flip, pltt0, addr);
G3B_UpdateGXDLInfo(info, G3OP_TEXIMAGE_PARAM_NPARAMS);
}
void G3B_TexPlttBase (GXDLInfo * info, u32 addr, GXTexFmt texfmt) {
G3BS_TexPlttBase(info, addr, texfmt);
G3B_UpdateGXDLInfo(info, G3OP_TEXPLTT_BASE_NPARAMS);
}
void G3B_MaterialColorDiffAmb (GXDLInfo * info, GXRgb diffuse, GXRgb ambient, BOOL IsSetVtxColor) {
G3BS_MaterialColorDiffAmb(info, diffuse, ambient, IsSetVtxColor);
G3B_UpdateGXDLInfo(info, G3OP_DIF_AMB_NPARAMS);
}
void G3B_MaterialColorSpecEmi (GXDLInfo * info, GXRgb specular, GXRgb emission, BOOL IsShininess) {
G3BS_MaterialColorSpecEmi(info, specular, emission, IsShininess);
G3B_UpdateGXDLInfo(info, G3OP_SPE_EMI_NPARAMS);
}
void G3B_LightVector (GXDLInfo * info, GXLightId lightID, fx16 x, fx16 y, fx16 z) {
G3BS_LightVector(info, lightID, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_LIGHT_VECTOR_NPARAMS);
}
void G3B_LightColor (GXDLInfo * info, GXLightId lightID, GXRgb rgb) {
G3BS_LightColor(info, lightID, rgb);
G3B_UpdateGXDLInfo(info, G3OP_LIGHT_COLOR_NPARAMS);
}
void G3B_Shininess (GXDLInfo * info, const u32 * table) {
G3BS_Shininess(info, table);
G3B_UpdateGXDLInfo(info, G3OP_SHININESS_NPARAMS);
}
void G3B_Begin (GXDLInfo * info, GXBegin primitive) {
G3BS_Begin(info, primitive);
G3B_UpdateGXDLInfo(info, G3OP_BEGIN_NPARAMS);
}
void G3B_End (GXDLInfo * info) {
G3BS_End(info);
G3B_UpdateGXDLInfo(info, G3OP_END_NPARAMS);
}
void G3B_SwapBuffers (GXDLInfo * info, GXSortMode am, GXBufferMode zw) {
G3BS_SwapBuffers(info, am, zw);
G3B_UpdateGXDLInfo(info, G3OP_SWAP_BUFFERS_NPARAMS);
}
void G3B_ViewPort (GXDLInfo * info, int x1, int y1, int x2, int y2) {
G3BS_ViewPort(info, x1, y1, x2, y2);
G3B_UpdateGXDLInfo(info, G3OP_VIEWPORT_NPARAMS);
}
void G3B_BoxTest (GXDLInfo * info, const GXBoxTestParam * box) {
G3BS_BoxTest(info, box);
G3B_UpdateGXDLInfo(info, G3OP_BOX_TEST_NPARAMS);
}
void G3B_PositionTest (GXDLInfo * info, fx16 x, fx16 y, fx16 z) {
G3BS_PositionTest(info, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_POS_TEST_NPARAMS);
}
void G3B_VectorTest (GXDLInfo * info, fx16 x, fx16 y, fx16 z) {
G3BS_VectorTest(info, x, y, z);
G3B_UpdateGXDLInfo(info, G3OP_VEC_TEST_NPARAMS);
}

57
lib/NitroSDK/src/gx/g3imm.c Normal file
View File

@ -0,0 +1,57 @@
#include <nitro/gx/g3imm.h>
#include <nitro/mi/dma.h>
#include "include/gxasm.h"
void G3_LoadMtx44 (const MtxFx44 * m) {
SDK_NULL_ASSERT(m);
reg_G3X_GXFIFO = G3OP_MTX_LOAD_4x4;
GX_SendFifo64B(&m->_00, (void *)&reg_G3X_GXFIFO);
}
void G3_LoadMtx43 (const MtxFx43 * m) {
SDK_NULL_ASSERT(m);
reg_G3X_GXFIFO = G3OP_MTX_LOAD_4x3;
GX_SendFifo48B(&m->_00, (void *)&reg_G3X_GXFIFO);
}
void G3_MultMtx44 (const MtxFx44 * m) {
SDK_NULL_ASSERT(m);
reg_G3X_GXFIFO = G3OP_MTX_MULT_4x4;
GX_SendFifo64B(&m->_00, (void *)&reg_G3X_GXFIFO);
}
void G3_MultMtx43 (const MtxFx43 * m) {
SDK_NULL_ASSERT(m);
reg_G3X_GXFIFO = G3OP_MTX_MULT_4x3;
GX_SendFifo48B(&m->_00, (void *)&reg_G3X_GXFIFO);
}
void G3_MultMtx33 (const MtxFx33 * m) {
SDK_NULL_ASSERT(m);
reg_G3X_GXFIFO = G3OP_MTX_MULT_3x3;
GX_SendFifo36B(&m->_00, (void *)&reg_G3X_GXFIFO);
}
void G3_Shininess (const u32 * table) {
SDK_NULL_ASSERT(table);
reg_G3X_GXFIFO = G3OP_SHININESS;
GX_SendFifo128B(&table[0], (void *)&reg_G3X_GXFIFO);
}
void G3_MultTransMtx33 (const MtxFx33 * mtx, const VecFx32 * trans) {
SDK_NULL_ASSERT(mtx);
SDK_NULL_ASSERT(trans);
reg_G3X_GXFIFO = G3OP_MTX_MULT_4x3;
GX_SendFifo36B(&mtx->_00, (void *)&reg_G3X_GXFIFO);
reg_G3X_GXFIFO = (u32)trans->x;
reg_G3X_GXFIFO = (u32)trans->y;
reg_G3X_GXFIFO = (u32)trans->z;
}

392
lib/NitroSDK/src/gx/g3x.c Normal file
View File

@ -0,0 +1,392 @@
#include <nitro/gx/g3x.h>
#include <nitro/gx/g3imm.h>
#include <nitro/gx/gx.h>
#include <nitro/gx/gx_bgcnt.h>
#include <nitro/hw/ARM9/ioreg_GX.h>
#include <nitro/hw/ARM9/ioreg_G3.h>
#include <nitro/hw/ARM9/ioreg_G2.h>
#include <nitro/fx/fx_const.h>
#include <nitro/mi/dma.h>
#include <nitro/mi/memory.h>
#include "include/gxasm.h"
static asm void GXi_NopClearFifo128_(register void * pDest);
void G3X_Init () {
#ifdef SDK_DEBUG
{
GXPower power = GX_GetPower();
SDK_WARNING(power & GX_POWER_RE, "GX_POWER_RE is off now, registers for it not initialized.");
SDK_WARNING(power & GX_POWER_GE, "GX_POWER_GE is off now, registers for it not initialized.");
}
#endif
G3X_ClearFifo();
G3_End();
while (G3X_IsGeometryBusy()) {
}
reg_G3X_DISP3DCNT = 0;
reg_G3X_GXSTAT = 0;
reg_G2_BG0OFS = 0;
G3X_ResetListRamOverflow();
G3X_ResetLineBufferUnderflow();
G3X_SetShading(GX_SHADING_TOON);
G3X_AntiAlias(TRUE);
G3X_AlphaTest(FALSE, 0);
G3X_ResetMtxStackOverflow();
G3X_SetFifoIntrCond(GX_FIFOINTR_COND_EMPTY);
G3X_InitMtxStack();
reg_G3X_CLEAR_COLOR = 0;
reg_G3X_CLEAR_DEPTH = 0x7fff;
reg_G3X_CLRIMAGE_OFFSET = 0;
reg_G3X_FOG_COLOR = 0;
reg_G3X_FOG_OFFSET = 0;
G2_SetBG0Priority(0);
G3X_InitTable();
G3_PolygonAttr(GX_LIGHTMASK_NONE, GX_POLYGONMODE_MODULATE, GX_CULL_BACK, 0, 31, GX_POLYGON_ATTR_MISC_NONE);
G3_TexImageParam(
GX_TEXFMT_NONE,
GX_TEXGEN_NONE,
GX_TEXSIZE_S8, GX_TEXSIZE_T8, GX_TEXREPEAT_NONE, GX_TEXFLIP_NONE, GX_TEXPLTTCOLOR0_USE, 0
);
G3_Direct1(G3OP_TEXPLTT_BASE, 0);
}
void G3X_Reset () {
#ifdef SDK_DEBUG
{
GXPower power = GX_GetPower();
SDK_WARNING(
power & GX_POWER_RE,
"GX_POWER_RE is off now, registers for it not initialized."
);
SDK_WARNING(
power & GX_POWER_GE,
"GX_POWER_GE is off now, registers for it not initialized."
);
}
#endif
while (G3X_IsGeometryBusy()) {
}
G3X_ResetMtxStackOverflow();
G3X_ResetListRamOverflow();
G3X_ResetLineBufferUnderflow();
G3X_ResetMtxStack();
G3_PolygonAttr(
GX_LIGHTMASK_NONE, GX_POLYGONMODE_MODULATE, GX_CULL_BACK, 0, 31,
GX_POLYGON_ATTR_MISC_NONE
);
G3_TexImageParam(
GX_TEXFMT_NONE,
GX_TEXGEN_NONE,
GX_TEXSIZE_S8, GX_TEXSIZE_T8, GX_TEXREPEAT_NONE, GX_TEXFLIP_NONE,
GX_TEXPLTTCOLOR0_USE, 0
);
G3_Direct1(G3OP_TEXPLTT_BASE, 0);
}
void G3X_ClearFifo (void) {
GXi_NopClearFifo128_((void *)&reg_G3X_GXFIFO);
while (G3X_IsGeometryBusy()) {
}
}
void G3X_InitMtxStack () {
s32 levelPV;
s32 levelPJ;
#ifdef SDK_DEBUG
{
GXPower power = GX_GetPower();
SDK_WARNING(
power & GX_POWER_GE,
"GX_POWER_GE is off now, registers for it not initialized."
);
}
#endif
G3X_ResetMtxStackOverflow();
while (G3X_GetMtxStackLevelPV(&levelPV)) {
;
}
while (G3X_GetMtxStackLevelPJ(&levelPJ)) {
;
}
G3_MtxMode(GX_MTXMODE_TEXTURE);
G3_Identity();
G3_MtxMode(GX_MTXMODE_PROJECTION);
if (levelPJ != 0) {
G3_PopMtx(levelPJ);
}
G3_Identity();
G3_MtxMode(GX_MTXMODE_POSITION_VECTOR);
G3_PopMtx(levelPV);
G3_Identity();
}
void G3X_ResetMtxStack () {
s32 levelPV;
s32 levelPJ;
#ifdef SDK_DEBUG
{
GXPower power = GX_GetPower();
SDK_WARNING(power & GX_POWER_GE, "GX_POWER_GE is off now, registers for it not changes.");
}
#endif
G3X_ResetMtxStackOverflow();
while (G3X_GetMtxStackLevelPV(&levelPV)) {
;
}
while (G3X_GetMtxStackLevelPJ(&levelPJ)) {
;
}
G3_MtxMode(GX_MTXMODE_TEXTURE);
G3_Identity();
G3_MtxMode(GX_MTXMODE_PROJECTION);
if (levelPJ != 0) {
G3_PopMtx(levelPJ);
}
G3_MtxMode(GX_MTXMODE_POSITION_VECTOR);
G3_PopMtx(levelPV);
G3_Identity();
}
void G3X_SetFog (BOOL enable, GXFogBlend fogMode, GXFogSlope fogSlope, int fogOffset) {
if (enable) {
SDK_MINMAX_ASSERT(fogOffset, 0, 0x7fff);
SDK_MINMAX_ASSERT(fogSlope, GX_FOGSLOPE_0x8000, GX_FOGSLOPE_0x0020);
SDK_ASSERT(GX_FOGBLEND_COLOR_ALPHA == fogMode || GX_FOGBLEND_ALPHA == fogMode);
reg_G3X_FOG_OFFSET = (u16)fogOffset;
reg_G3X_DISP3DCNT = (u16)((reg_G3X_DISP3DCNT &
~(REG_G3X_DISP3DCNT_FOG_SHIFT_MASK
| REG_G3X_DISP3DCNT_FMOD_MASK
| REG_G3X_DISP3DCNT_RO_MASK
| REG_G3X_DISP3DCNT_GO_MASK))
| ((fogSlope << REG_G3X_DISP3DCNT_FOG_SHIFT_SHIFT)
| (fogMode << REG_G3X_DISP3DCNT_FMOD_SHIFT)
| (REG_G3X_DISP3DCNT_FME_MASK)));
} else {
reg_G3X_DISP3DCNT &= (u16) ~(REG_G3X_DISP3DCNT_FME_MASK
| REG_G3X_DISP3DCNT_RO_MASK | REG_G3X_DISP3DCNT_GO_MASK);
}
}
int G3X_GetClipMtx (MtxFx44 * m) {
SDK_NULL_ASSERT(m);
if (G3X_IsGeometryBusy()) {
return -1;
} else {
MI_Copy64B((void *)REG_CLIPMTX_RESULT_0_ADDR, &m->_00);
return 0;
}
}
int G3X_GetVectorMtx (MtxFx33 * m) {
SDK_NULL_ASSERT(m);
if (G3X_IsGeometryBusy()) {
return -1;
} else {
MI_Copy36B((void *)(REG_VECMTX_RESULT_0_ADDR), &m->_00);
return 0;
}
}
void G3X_SetEdgeColorTable (const GXRgb * rgb_8) {
SDK_NULL_ASSERT(rgb_8);
MI_CpuCopy16(rgb_8, (void *)REG_EDGE_COLOR_0_L_ADDR, 16);
}
void G3X_SetFogTable (const u32 * fogTable) {
SDK_NULL_ASSERT(fogTable);
MI_Copy32B(&fogTable[0], (void *)REG_FOG_TABLE_0_ADDR);
}
void G3X_SetToonTable (const GXRgb * rgb_32) {
SDK_NULL_ASSERT(rgb_32);
MI_CpuCopy16(rgb_32, (void *)REG_TOON_TABLE_0_L_ADDR, 64);
}
void G3X_SetClearColor (GXRgb rgb, int alpha, int depth, int polygonID, BOOL fog) {
u32 val;
GX_POLYGONID_ASSERT(polygonID);
GX_ALPHA_ASSERT(alpha);
GXRGB_ASSERT(rgb);
GX_DEPTH_ASSERT(depth);
val = (u32)(rgb | (alpha << REG_G3X_CLEAR_COLOR_ALPHA_SHIFT) |
(polygonID << REG_G3X_CLEAR_COLOR_POLYGONID_SHIFT));
if (fog) {
val |= REG_G3X_CLEAR_COLOR_F_MASK;
}
reg_G3X_CLEAR_COLOR = val;
reg_G3X_CLEAR_DEPTH = (u16)depth;
}
void G3X_InitTable () {
int i;
if (GXi_DmaId != GX_DMA_NOT_USE) {
MI_DmaFill32Async(GXi_DmaId, (void *)REG_EDGE_COLOR_0_L_ADDR, 0, 16, NULL, NULL);
MI_DmaFill32(GXi_DmaId, (void *)REG_FOG_TABLE_0_ADDR, 0, 96);
} else {
MI_CpuFill32((void *)REG_EDGE_COLOR_0_L_ADDR, 0, 16);
MI_CpuFill32((void *)REG_FOG_TABLE_0_ADDR, 0, 96);
}
for (i = 0; i < 32; ++i) {
reg_G3_SHININESS = 0;
}
}
int G3X_GetMtxStackLevelPV (s32 * level) {
SDK_NULL_ASSERT(level);
if (reg_G3X_GXSTAT & REG_G3X_GXSTAT_SB_MASK) {
return -1;
} else {
*level = (s32)((reg_G3X_GXSTAT & REG_G3X_GXSTAT_PV_MASK) >> REG_G3X_GXSTAT_PV_SHIFT);
return 0;
}
}
int G3X_GetMtxStackLevelPJ (s32 * level) {
SDK_NULL_ASSERT(level);
if (reg_G3X_GXSTAT & REG_G3X_GXSTAT_SB_MASK) {
return -1;
} else {
*level = (s32)((reg_G3X_GXSTAT & REG_G3X_GXSTAT_PJ_MASK) >> REG_G3X_GXSTAT_PJ_SHIFT);
return 0;
}
}
void G3X_SetDisp1DotDepth (fx32 w) {
SDK_MINMAX_ASSERT(w, 0, FX32_ONE * 0x1000 - 1);
reg_G3X_DISP_1DOT_DEPTH = (u16)((w >> 9) & 0x7fff);
}
int G3X_GetBoxTestResult (s32 * in) {
SDK_NULL_ASSERT(in);
if (reg_G3X_GXSTAT & REG_G3X_GXSTAT_TB_MASK) {
return -1;
} else {
*in = (s32)(reg_G3X_GXSTAT & REG_G3X_GXSTAT_TR_MASK);
return 0;
}
}
int G3X_GetPositionTestResult (VecFx32 * vec, fx32 * w) {
SDK_NULL_ASSERT(vec);
SDK_NULL_ASSERT(w);
if (reg_G3X_GXSTAT & REG_G3X_GXSTAT_TB_MASK) {
return -1;
} else {
vec->x = (fx32)reg_G3X_POS_RESULT_X;
vec->y = (fx32)reg_G3X_POS_RESULT_Y;
vec->z = (fx32)reg_G3X_POS_RESULT_Z;
*w = (fx32)reg_G3X_POS_RESULT_W;
return 0;
}
}
int G3X_GetVectorTestResult (fx16 * vec) {
SDK_NULL_ASSERT(vec);
if (reg_G3X_GXSTAT & REG_G3X_GXSTAT_TB_MASK) {
return -1;
} else {
*(vec + 0) = (fx16)reg_G3X_VEC_RESULT_X;
*(vec + 1) = (fx16)reg_G3X_VEC_RESULT_Y;
*(vec + 2) = (fx16)reg_G3X_VEC_RESULT_Z;
return 0;
}
}
void G3X_SetHOffset (int hOffset) {
SDK_WARNING(
(reg_GX_DISPCNT & REG_GX_DISPCNT_BG02D3D_MASK) != 0,
"BG0 is in 2D mode now. call \'G2_SetBG0Offset\'\n"
);
SDK_ASSERT(hOffset >= -256 && hOffset <= 255);
reg_G2_BG0OFS = (u32)hOffset;
}
#include <nitro/code32.h>
static asm void GXi_NopClearFifo128_ (register void * pDest) {
mov r1, #0
mov r2, #0
mov r3, #0
mov r12, #0
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
stmia r0, {r1 - r3, r12}
bx lr
}
#include <nitro/codereset.h>

323
lib/NitroSDK/src/gx/gx.c Normal file
View File

@ -0,0 +1,323 @@
#include <nitro/gx/gx.h>
#include <nitro/mi/dma.h>
#include "include/gxstate.h"
#ifdef SDK_ARM9
#include <nitro/os/ARM9/vramExclusive.h>
#endif
#ifdef SDK_TEG_WA_VBLANK
#include <nitro/os.h>
static void GXi_TEGWorkAround(void *);
#endif
u32 GXi_DmaId = GX_DEFAULT_DMAID;
#ifdef SDK_ARM9
vu16 GXi_VRamLockId = 0;
#endif
void GX_Init () {
const u16 bg_mtx_elem_one = 1 << 8;
reg_GX_POWCNT |= (1 << REG_GX_POWCNT_DSEL_SHIFT);
GX_SetPower(GX_POWER_ALL);
GXi_PowerLCD(TRUE);
GX_InitGXState();
#ifdef SDK_ARM9
{
s32 lockResult;
while (GXi_VRamLockId == 0) {
lockResult = OS_GetLockID();
if (lockResult == OS_LOCK_ID_ERROR) {
OS_Panic("Could not get lock ID for VRAM exclusive.\n");
}
GXi_VRamLockId = (u16)lockResult;
}
}
#endif
#if 1
reg_GX_DISPSTAT = 0;
reg_GX_DISPCNT = 0;
if (GXi_DmaId != GX_DMA_NOT_USE) {
MI_DmaFill32(
GXi_DmaId, (void *)REG_BG0CNT_ADDR, 0,
REG_DISP_MMEM_FIFO_ADDR - REG_BG0CNT_ADDR
);
reg_GX_MASTER_BRIGHT = 0;
MI_DmaFill32(
GXi_DmaId, (void *)REG_DB_DISPCNT_ADDR, 0,
REG_DB_MASTER_BRIGHT_ADDR - REG_DB_DISPCNT_ADDR + 4
);
} else {
MI_CpuFill32((void *)REG_BG0CNT_ADDR, 0, REG_DISP_MMEM_FIFO_ADDR - REG_BG0CNT_ADDR);
reg_GX_MASTER_BRIGHT = 0;
MI_CpuFill32(
(void *)REG_DB_DISPCNT_ADDR, 0,
REG_DB_MASTER_BRIGHT_ADDR - REG_DB_DISPCNT_ADDR + 4
);
}
reg_G2_BG2PA = bg_mtx_elem_one;
reg_G2_BG2PD = bg_mtx_elem_one;
reg_G2_BG3PA = bg_mtx_elem_one;
reg_G2_BG3PD = bg_mtx_elem_one;
reg_G2S_DB_BG2PA = bg_mtx_elem_one;
reg_G2S_DB_BG2PD = bg_mtx_elem_one;
reg_G2S_DB_BG3PA = bg_mtx_elem_one;
reg_G2S_DB_BG3PD = bg_mtx_elem_one;
#else
reg_GX_DISPSTAT = 0;
reg_GX_DISPCNT = 0;
reg_GX_DISPCAPCNT = 0;
reg_G2_BG0CNT = 0;
reg_G2_BG1CNT = 0;
reg_G2_BG2CNT = 0;
reg_G2_BG3CNT = 0;
reg_G2_BG0OFS = 0;
reg_G2_BG1OFS = 0;
reg_G2_BG2OFS = 0;
reg_G2_BG3OFS = 0;
reg_G2_BG2X = 0;
reg_G2_BG2Y = 0;
reg_G2_BG3X = 0;
reg_G2_BG3Y = 0;
reg_G2_BG2PA = bg_mtx_elem_one;
reg_G2_BG2PB = 0;
reg_G2_BG2PC = 0;
reg_G2_BG2PD = bg_mtx_elem_one;
reg_G2_BG3PA = bg_mtx_elem_one;
reg_G2_BG3PB = 0;
reg_G2_BG3PC = 0;
reg_G2_BG3PD = bg_mtx_elem_one;
reg_G2_WININ = 0;
reg_G2_WINOUT = 0;
reg_G2_WIN0H = 0;
reg_G2_WIN1H = 0;
reg_G2_WIN0V = 0;
reg_G2_WIN1V = 0;
reg_G2_MOSAIC = 0;
reg_G2_BLDCNT = 0;
reg_G2_BLDALPHA = 0;
reg_G2_BLDY = 0;
reg_GX_MASTER_BRIGHT = 0;
reg_GXS_DB_DISPCNT = 0;
reg_G2S_DB_BG0CNT = 0;
reg_G2S_DB_BG1CNT = 0;
reg_G2S_DB_BG2CNT = 0;
reg_G2S_DB_BG3CNT = 0;
reg_G2S_DB_BG0OFS = 0;
reg_G2S_DB_BG1OFS = 0;
reg_G2S_DB_BG2OFS = 0;
reg_G2S_DB_BG3OFS = 0;
reg_G2S_DB_BG2X = 0;
reg_G2S_DB_BG2Y = 0;
reg_G2S_DB_BG3X = 0;
reg_G2S_DB_BG3Y = 0;
reg_G2S_DB_BG2PA = bg_mtx_elem_one;
reg_G2S_DB_BG2PB = 0;
reg_G2S_DB_BG2PC = 0;
reg_G2S_DB_BG2PD = bg_mtx_elem_one;
reg_G2S_DB_BG3PA = bg_mtx_elem_one;
reg_G2S_DB_BG3PB = 0;
reg_G2S_DB_BG3PC = 0;
reg_G2S_DB_BG3PD = bg_mtx_elem_one;
reg_G2S_DB_WININ = 0;
reg_G2S_DB_WINOUT = 0;
reg_G2S_DB_WIN0H = 0;
reg_G2S_DB_WIN1H = 0;
reg_G2S_DB_WIN0V = 0;
reg_G2S_DB_WIN1V = 0;
reg_G2S_DB_MOSAIC = 0;
reg_G2S_DB_BLDCNT = 0;
reg_G2S_DB_BLDALPHA = 0;
reg_G2S_DB_BLDY = 0;
reg_GXS_DB_MASTER_BRIGHT = 0;
#endif
#ifdef SDK_TEG_WA_VBLANK
if (!OS_IsRunOnEmulator()) {
static OSVAlarm va;
static BOOL initialized = FALSE;
if (!initialized) {
OS_InitVAlarm();
OS_CreateVAlarm(&va);
OS_SetPeriodicVAlarm(&va, 190, (203 - 190), GXi_TEGWorkAround, NULL);
initialized = TRUE;
}
}
#endif
}
#ifdef SDK_TEG_WA_VBLANK
static void GXi_TEGWorkAround (void *) {
while (GX_GetVCount() < 203) {
}
}
#endif
void GX_SetVCountEqVal (s32 val) {
SDK_MINMAX_ASSERT(val, 0, 262);
reg_GX_DISPSTAT = (u16)((reg_GX_DISPSTAT & (REG_GX_DISPSTAT_VBLK_MASK |
REG_GX_DISPSTAT_HBLK_MASK |
REG_GX_DISPSTAT_LYC_MASK |
REG_GX_DISPSTAT_VBI_MASK |
REG_GX_DISPSTAT_HBI_MASK |
REG_GX_DISPSTAT_VQI_MASK)) |
((val & 0xff) << 8) | ((val & 0x100) >> 1));
}
s32 GX_HBlankIntr (BOOL enable) {
s32 rval = (reg_GX_DISPSTAT & REG_GX_DISPSTAT_HBI_MASK);
if (enable) {
reg_GX_DISPSTAT |= REG_GX_DISPSTAT_HBI_MASK;
} else {
reg_GX_DISPSTAT &= ~REG_GX_DISPSTAT_HBI_MASK;
}
return rval;
}
s32 GX_VBlankIntr (BOOL enable) {
s32 rval = (reg_GX_DISPSTAT & REG_GX_DISPSTAT_VBI_MASK);
if (enable) {
reg_GX_DISPSTAT |= REG_GX_DISPSTAT_VBI_MASK;
} else {
reg_GX_DISPSTAT &= ~REG_GX_DISPSTAT_VBI_MASK;
}
return rval;
}
static u16 sDispMode = 0;
static u16 sIsDispOn = TRUE;
BOOL GX_IsDispOn (void) {
return sIsDispOn;
}
void GX_DispOff (void) {
u32 tmp = reg_GX_DISPCNT;
sIsDispOn = FALSE;
sDispMode = (u16)((tmp & REG_GX_DISPCNT_MODE_MASK) >> REG_GX_DISPCNT_MODE_SHIFT);
reg_GX_DISPCNT = tmp & ~REG_GX_DISPCNT_MODE_MASK;
}
void GX_DispOn (void) {
sIsDispOn = TRUE;
if (sDispMode != (u16)GX_DISPMODE_OFF) {
reg_GX_DISPCNT =
((reg_GX_DISPCNT & ~REG_GX_DISPCNT_MODE_MASK) |
(sDispMode << REG_GX_DISPCNT_MODE_SHIFT));
} else {
reg_GX_DISPCNT = ((reg_GX_DISPCNT | (GX_DISPMODE_GRAPHICS << REG_GX_DISPCNT_MODE_SHIFT)));
}
}
void GX_SetGraphicsMode (GXDispMode dispMode, GXBGMode bgMode, GXBG0As bg0_2d3d) {
u32 cnt = reg_GX_DISPCNT;
GX_DISPMODE_ASSERT(dispMode);
SDK_WARNING(
dispMode != GX_DISPMODE_OFF,
"A parameter GX_DISPMODE_OFF is obsolete. Use GX_DispOff() instead."
);
sDispMode = (u16)dispMode;
if (!sIsDispOn) {
dispMode = GX_DISPMODE_OFF;
}
GX_BGMODE_ASSERT(bgMode);
GX_BG0_AS_ASSERT(bg0_2d3d);
cnt &= ~(REG_GX_DISPCNT_BGMODE_MASK |
REG_GX_DISPCNT_BG02D3D_MASK | REG_GX_DISPCNT_MODE_MASK | REG_GX_DISPCNT_VRAM_MASK);
reg_GX_DISPCNT = (u32)(cnt |
(dispMode << REG_GX_DISPCNT_MODE_SHIFT) |
(bgMode << REG_GX_DISPCNT_BGMODE_SHIFT) | (bg0_2d3d <<
REG_GX_DISPCNT_BG02D3D_SHIFT));
if (sDispMode == GX_DISPMODE_OFF) {
sIsDispOn = FALSE;
}
}
void GXS_SetGraphicsMode (GXBGMode bgMode) {
reg_GXS_DB_DISPCNT = ((reg_GXS_DB_DISPCNT & ~REG_GXS_DB_DISPCNT_BGMODE_MASK) |
(bgMode << REG_GXS_DB_DISPCNT_BGMODE_SHIFT));
}
void GXx_SetMasterBrightness_ (vu16 * reg, int brightness) {
SDK_MINMAX_ASSERT(brightness, -16, 16);
if (brightness == 0) {
*reg = 0;
} else if (brightness > 0) {
*reg = (u16)((1 << REG_GX_MASTER_BRIGHT_E_MOD_SHIFT) | brightness);
} else {
*reg = (u16)((2 << REG_GX_MASTER_BRIGHT_E_MOD_SHIFT) | (-brightness));
}
}
int GXx_GetMasterBrightness_ (vu16 * reg) {
u16 mode = (u16)(*reg & REG_GX_MASTER_BRIGHT_E_MOD_MASK);
if (mode == 0) {
return 0;
} else if (mode == (1 << REG_GX_MASTER_BRIGHT_E_MOD_SHIFT)) {
return *reg & REG_GX_MASTER_BRIGHT_E_VALUE_MASK;
} else if (mode == (2 << REG_GX_MASTER_BRIGHT_E_MOD_SHIFT)) {
return -(*reg & REG_GX_MASTER_BRIGHT_E_VALUE_MASK);
} else {
OS_TWarning("Illegal MasterBright mode!\n");
return 0;
}
}
u32 GX_SetDefaultDMA (u32 dma_no) {
u32 previous = GXi_DmaId;
OSIntrMode enabled;
SDK_ASSERT((dma_no <= MI_DMA_MAX_NUM) || (dma_no == GX_DMA_NOT_USE));
if (GXi_DmaId != GX_DMA_NOT_USE) {
MI_WaitDma(GXi_DmaId);
}
enabled = OS_DisableInterrupts();
GXi_DmaId = dma_no;
(void)OS_RestoreInterrupts(enabled);
return previous;
}

268
lib/NitroSDK/src/gx/gx_bgcnt.c Normal file
View File

@ -0,0 +1,268 @@
#include <nitro/gx/gx_bgcnt.h>
#include <nitro/gx/gx.h>
static inline int getBGScreenOffset_ (void) {
return (int)(0x10000 * ((reg_GX_DISPCNT & REG_GX_DISPCNT_BGSCREENOFFSET_MASK) >>
REG_GX_DISPCNT_BGSCREENOFFSET_SHIFT));
}
static inline int getBGCharOffset_ (void) {
return (int)(0x10000 * ((reg_GX_DISPCNT & REG_GX_DISPCNT_BGCHAROFFSET_MASK) >>
REG_GX_DISPCNT_BGCHAROFFSET_SHIFT));
}
void * G2_GetBG0ScrPtr (void) {
int baseBlock = 0x800 * ((reg_G2_BG0CNT & REG_G2_BG0CNT_SCREENBASE_MASK) >>
REG_G2_BG0CNT_SCREENBASE_SHIFT);
return (void *)(HW_BG_VRAM + getBGScreenOffset_() + baseBlock);
}
void * G2S_GetBG0ScrPtr (void) {
int baseBlock = 0x800 * ((reg_G2S_DB_BG0CNT & REG_G2S_DB_BG0CNT_SCREENBASE_MASK) >>
REG_G2S_DB_BG0CNT_SCREENBASE_SHIFT);
return (void *)(HW_DB_BG_VRAM + baseBlock);
}
void * G2_GetBG1ScrPtr (void) {
int baseBlock = 0x800 * ((reg_G2_BG1CNT & REG_G2_BG1CNT_SCREENBASE_MASK) >>
REG_G2_BG1CNT_SCREENBASE_SHIFT);
return (void *)(HW_BG_VRAM + getBGScreenOffset_() + baseBlock);
}
void * G2S_GetBG1ScrPtr (void) {
int baseBlock = 0x800 * ((reg_G2S_DB_BG1CNT & REG_G2S_DB_BG1CNT_SCREENBASE_MASK)
>> REG_G2S_DB_BG1CNT_SCREENBASE_SHIFT);
return (void *)(HW_DB_BG_VRAM + baseBlock);
}
#include <nitro/code32.h>
void * G2_GetBG2ScrPtr (void) {
GXBGMode bgMode = (GXBGMode)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >>
REG_GX_DISPCNT_BGMODE_SHIFT);
u32 bg = reg_G2_BG2CNT;
int offset = getBGScreenOffset_();
u32 blockID = (bg & REG_G2_BG2CNT_SCREENBASE_MASK) >> REG_G2_BG2CNT_SCREENBASE_SHIFT;
switch (bgMode) {
case GX_BGMODE_0:
case GX_BGMODE_1:
case GX_BGMODE_2:
case GX_BGMODE_3:
case GX_BGMODE_4:
return (void *)(HW_BG_VRAM + offset + 0x800 * blockID);
break;
case GX_BGMODE_5:
if (bg & REG_G2_BG2CNT_COLORMODE_MASK) {
return (void *)(HW_BG_VRAM + 0x4000 * blockID);
} else {
return (void *)(HW_BG_VRAM + offset + 0x800 * blockID);
}
break;
case GX_BGMODE_6:
return (void *)HW_BG_VRAM;
break;
default:
SDK_INTERNAL_ERROR("unknown BGMODE 0x%x", bgMode);
return NULL;
break;
}
}
#include <nitro/codereset.h>
void * G2S_GetBG2ScrPtr (void) {
GXBGMode bgMode = (GXBGMode)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >>
REG_GXS_DB_DISPCNT_BGMODE_SHIFT);
u32 bg = reg_G2S_DB_BG2CNT;
u32 blockID =
(bg & REG_G2S_DB_BG2CNT_SCREENBASE_MASK) >> REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT;
switch (bgMode) {
case GX_BGMODE_0:
case GX_BGMODE_1:
case GX_BGMODE_2:
case GX_BGMODE_3:
case GX_BGMODE_4:
return (void *)(HW_DB_BG_VRAM + 0x800 * blockID);
break;
case GX_BGMODE_5:
if (bg & REG_G2S_DB_BG2CNT_COLORMODE_MASK) {
return (void *)(HW_DB_BG_VRAM + 0x4000 * blockID);
} else {
return (void *)(HW_DB_BG_VRAM + 0x800 * blockID);
}
break;
case GX_BGMODE_6:
return NULL;
break;
default:
SDK_INTERNAL_ERROR("unknown BGMODE 0x%x", bgMode);
return NULL;
break;
}
}
#include <nitro/code32.h>
void * G2_GetBG3ScrPtr (void) {
GXBGMode bgMode = (GXBGMode)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >>
REG_GX_DISPCNT_BGMODE_SHIFT);
u32 bg = reg_G2_BG3CNT;
int offset = getBGScreenOffset_();
u32 blockID = (bg & REG_G2_BG3CNT_SCREENBASE_MASK) >> REG_G2_BG3CNT_SCREENBASE_SHIFT;
switch (bgMode) {
case GX_BGMODE_0:
case GX_BGMODE_1:
case GX_BGMODE_2:
return (void *)(HW_BG_VRAM + offset + 0x800 * blockID);
break;
case GX_BGMODE_3:
case GX_BGMODE_4:
case GX_BGMODE_5:
if (bg & REG_G2_BG3CNT_COLORMODE_MASK) {
return (void *)(HW_BG_VRAM + 0x4000 * blockID);
} else {
return (void *)(HW_BG_VRAM + offset + 0x800 * blockID);
}
break;
case GX_BGMODE_6:
return NULL;
break;
default:
SDK_INTERNAL_ERROR("unknown BGMODE 0x%x", bgMode);
return NULL;
break;
}
}
#include <nitro/codereset.h>
void * G2S_GetBG3ScrPtr (void) {
GXBGMode bgMode = (GXBGMode)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >>
REG_GXS_DB_DISPCNT_BGMODE_SHIFT);
u32 bg = reg_G2S_DB_BG3CNT;
u32 blockID =
(bg & REG_G2S_DB_BG3CNT_SCREENBASE_MASK) >> REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT;
switch (bgMode) {
case GX_BGMODE_0:
case GX_BGMODE_1:
case GX_BGMODE_2:
return (void *)(HW_DB_BG_VRAM + 0x800 * blockID);
break;
case GX_BGMODE_3:
case GX_BGMODE_4:
case GX_BGMODE_5:
if (bg & REG_G2S_DB_BG3CNT_COLORMODE_MASK) {
return (void *)(HW_DB_BG_VRAM + 0x4000 * blockID);
} else {
return (void *)(HW_DB_BG_VRAM + 0x800 * blockID);
}
break;
case GX_BGMODE_6:
return NULL;
break;
default:
SDK_INTERNAL_ERROR("unknown BGMODE 0x%x", bgMode);
return NULL;
break;
}
}
void * G2_GetBG0CharPtr (void) {
int baseBlock = 0x4000 * ((reg_G2_BG0CNT & REG_G2_BG0CNT_CHARBASE_MASK) >>
REG_G2_BG0CNT_CHARBASE_SHIFT);
return (void *)(HW_BG_VRAM + getBGCharOffset_() + baseBlock);
}
void * G2S_GetBG0CharPtr (void) {
int baseBlock = 0x4000 * ((reg_G2S_DB_BG0CNT & REG_G2S_DB_BG0CNT_CHARBASE_MASK) >>
REG_G2S_DB_BG0CNT_CHARBASE_SHIFT);
return (void *)(HW_DB_BG_VRAM + baseBlock);
}
void * G2_GetBG1CharPtr (void) {
int baseBlock = 0x4000 * ((reg_G2_BG1CNT & REG_G2_BG1CNT_CHARBASE_MASK) >>
REG_G2_BG1CNT_CHARBASE_SHIFT);
return (void *)(HW_BG_VRAM + getBGCharOffset_() + baseBlock);
}
void * G2S_GetBG1CharPtr (void) {
int baseBlock = 0x4000 * ((reg_G2S_DB_BG1CNT & REG_G2S_DB_BG1CNT_CHARBASE_MASK) >>
REG_G2S_DB_BG1CNT_CHARBASE_SHIFT);
return (void *)(HW_DB_BG_VRAM + baseBlock);
}
void * G2_GetBG2CharPtr (void) {
GXBGMode bgMode = (GXBGMode)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >>
REG_GX_DISPCNT_BGMODE_SHIFT);
u32 bg = reg_G2_BG2CNT;
if (bgMode < 5 || !(bg & REG_G2_BG2CNT_COLORMODE_MASK)) {
int offset = getBGCharOffset_();
u32 blockID = (bg & REG_G2_BG2CNT_CHARBASE_MASK) >> REG_G2_BG2CNT_CHARBASE_SHIFT;
return (void *)(HW_BG_VRAM + offset + 0x4000 * blockID);
} else {
return NULL;
}
}
void * G2S_GetBG2CharPtr (void) {
GXBGMode bgMode = (GXBGMode)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >>
REG_GXS_DB_DISPCNT_BGMODE_SHIFT);
u32 bg = reg_G2S_DB_BG2CNT;
if (bgMode < 5 || !(bg & REG_G2S_DB_BG2CNT_COLORMODE_MASK)) {
u32 blockID =
(bg & REG_G2S_DB_BG2CNT_CHARBASE_MASK) >> REG_G2S_DB_BG2CNT_CHARBASE_SHIFT;
return (void *)(HW_DB_BG_VRAM + 0x4000 * blockID);
} else {
return NULL;
}
}
void * G2_GetBG3CharPtr (void) {
GXBGMode bgMode = (GXBGMode)((reg_GX_DISPCNT & REG_GX_DISPCNT_BGMODE_MASK) >>
REG_GX_DISPCNT_BGMODE_SHIFT);
u32 bg = reg_G2_BG3CNT;
if (bgMode < 3 || (bgMode < 6 && !(bg & REG_G2_BG2CNT_COLORMODE_MASK))) {
u32 blockID = (bg & REG_G2_BG3CNT_CHARBASE_MASK) >> REG_G2_BG3CNT_CHARBASE_SHIFT;
int offset = getBGCharOffset_();
return (void *)(HW_BG_VRAM + offset + 0x4000 * blockID);
} else {
return NULL;
}
}
void * G2S_GetBG3CharPtr (void) {
GXBGMode bgMode = (GXBGMode)((reg_GXS_DB_DISPCNT & REG_GXS_DB_DISPCNT_BGMODE_MASK) >>
REG_GXS_DB_DISPCNT_BGMODE_SHIFT);
u32 bg = reg_G2S_DB_BG3CNT;
if (bgMode < 3 || (bgMode < 6 && !(bg & REG_G2S_DB_BG2CNT_COLORMODE_MASK))) {
u32 blockID =
(bg & REG_G2S_DB_BG3CNT_CHARBASE_MASK) >> REG_G2S_DB_BG3CNT_CHARBASE_SHIFT;
return (void *)(HW_DB_BG_VRAM + 0x4000 * blockID);
} else {
return NULL;
}
}

515
lib/NitroSDK/src/gx/gx_load2d.c Normal file
View File

@ -0,0 +1,515 @@
#include <nitro/gx/gx_load.h>
#include <nitro/gx/gx_vramcnt.h>
#include <nitro/gx/gx_bgcnt.h>
#include <nitro/hw/ARM9/mmap_global.h>
#include <nitro/mi/dma.h>
#include "include/gxstate.h"
#include "include/gxdma.h"
void GX_LoadBGPltt (const void * pSrc, u32 offset, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(offset + szByte <= HW_BG_PLTT_SIZE);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(HW_BG_PLTT + offset), szByte);
}
void GXS_LoadBGPltt (const void * pSrc, u32 offset, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(offset + szByte <= HW_DB_BG_PLTT_SIZE);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(HW_DB_BG_PLTT + offset), szByte);
}
void GX_LoadOBJPltt (const void * pSrc, u32 offset, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(offset + szByte <= HW_OBJ_PLTT_SIZE);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(HW_OBJ_PLTT + offset), szByte);
}
void GXS_LoadOBJPltt (const void * pSrc, u32 offset, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(offset + szByte <= HW_DB_OBJ_PLTT_SIZE);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(HW_DB_OBJ_PLTT + offset), szByte);
}
void GX_LoadOAM (const void * pSrc, u32 offset, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(offset + szByte <= HW_OAM_SIZE);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(HW_OAM + offset), szByte);
}
void GXS_LoadOAM (const void * pSrc, u32 offset, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(offset + szByte <= HW_DB_OAM_SIZE);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(HW_DB_OAM + offset), szByte);
}
void GX_LoadOBJ (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2_GetOBJCharPtr();
GX_RegionCheck_OBJ(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadOBJ (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2S_GetOBJCharPtr();
GX_RegionCheck_SubOBJ(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GX_LoadBG0Scr (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
ptr = (u32)G2_GetBG0ScrPtr();
GX_RegionCheck_BG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadBG0Scr (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
ptr = (u32)G2S_GetBG0ScrPtr();
GX_RegionCheck_SubBG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GX_LoadBG1Scr (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
ptr = (u32)G2_GetBG1ScrPtr();
GX_RegionCheck_BG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadBG1Scr (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
ptr = (u32)G2S_GetBG1ScrPtr();
GX_RegionCheck_SubBG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GX_LoadBG2Scr (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
ptr = (u32)G2_GetBG2ScrPtr();
GX_RegionCheck_BG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadBG2Scr (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
ptr = (u32)G2S_GetBG2ScrPtr();
GX_RegionCheck_SubBG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GX_LoadBG3Scr (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
ptr = (u32)G2_GetBG3ScrPtr();
GX_RegionCheck_BG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadBG3Scr (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN2_ASSERT(offset);
SDK_ALIGN2_ASSERT(szByte);
ptr = (u32)G2S_GetBG3ScrPtr();
GX_RegionCheck_SubBG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy16(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GX_LoadBG0Char (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2_GetBG0CharPtr();
GX_RegionCheck_BG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadBG0Char (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2S_GetBG0CharPtr();
GX_RegionCheck_SubBG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GX_LoadBG1Char (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2_GetBG1CharPtr();
GX_RegionCheck_BG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadBG1Char (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2S_GetBG1CharPtr();
GX_RegionCheck_SubBG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GX_LoadBG2Char (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2_GetBG2CharPtr();
GX_RegionCheck_BG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadBG2Char (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2S_GetBG2CharPtr();
GX_RegionCheck_SubBG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GX_LoadBG3Char (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2_GetBG3CharPtr();
GX_RegionCheck_BG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
void GXS_LoadBG3Char (const void * pSrc, u32 offset, u32 szByte) {
u32 ptr;
SDK_NULL_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(offset);
SDK_ALIGN4_ASSERT(szByte);
ptr = (u32)G2S_GetBG3CharPtr();
GX_RegionCheck_SubBG(ptr + offset, ptr + offset + szByte);
GXi_DmaCopy32(GXi_DmaId, pSrc, (void *)(ptr + offset), szByte);
}
static GXVRamBGExtPltt sBGExtPltt = (GXVRamBGExtPltt)(0);
static u32 sBGExtPlttLCDCBlk = 0;
static u32 sBGExtPlttLCDCOffset = 0;
void GX_BeginLoadBGExtPltt () {
SDK_ASSERT(0 == sBGExtPltt && 0 == sBGExtPlttLCDCBlk && 0 == sBGExtPlttLCDCOffset);
sBGExtPltt = GX_ResetBankForBGExtPltt();
switch (sBGExtPltt) {
case GX_VRAM_BGEXTPLTT_0123_E:
sBGExtPlttLCDCBlk = HW_LCDC_VRAM_E;
sBGExtPlttLCDCOffset = 0;
break;
case GX_VRAM_BGEXTPLTT_23_G:
sBGExtPlttLCDCBlk = HW_LCDC_VRAM_G;
sBGExtPlttLCDCOffset = 0x4000;
break;
case GX_VRAM_BGEXTPLTT_0123_FG:
case GX_VRAM_BGEXTPLTT_01_F:
sBGExtPlttLCDCBlk = HW_LCDC_VRAM_F;
sBGExtPlttLCDCOffset = 0;
break;
case GX_VRAM_BGEXTPLTT_NONE:
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", sBGExtPltt);
break;
}
}
void GX_LoadBGExtPltt (const void * pSrc, u32 destSlotAddr, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(sBGExtPltt != GX_VRAM_BGEXTPLTT_NONE);
SDK_ASSERT(sBGExtPlttLCDCBlk != 0);
SDK_ALIGN4_ASSERT(szByte);
SDK_ALIGN4_ASSERT(destSlotAddr);
SDK_ALIGN4_ASSERT(pSrc);
#ifdef SDK_DEBUG
switch (sBGExtPltt) {
case GX_VRAM_BGEXTPLTT_0123_E:
case GX_VRAM_BGEXTPLTT_0123_FG:
SDK_ASSERTMSG(
destSlotAddr + szByte <= 0x8000,
"Illegal address/size specified(0x%5x->0x%5x)",
destSlotAddr, destSlotAddr + szByte
);
break;
case GX_VRAM_BGEXTPLTT_23_G:
SDK_ASSERTMSG(
destSlotAddr + szByte <= 0x8000,
"Illegal address/size specified(0x%5x->0x%5x)",
destSlotAddr, destSlotAddr + szByte
);
SDK_ASSERTMSG(
destSlotAddr >= 0x4000,
"BGExtPltt 0x0000 - 0x4000 not available(0x%5x->0x%5x)",
destSlotAddr, destSlotAddr + szByte
);
break;
case GX_VRAM_BGEXTPLTT_01_F:
SDK_ASSERTMSG(
destSlotAddr + szByte <= 0x4000,
"BGExtPltt 0x4000 - 0x8000 not available(0x%5x->0x%5x)",
destSlotAddr, destSlotAddr + szByte
);
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", sBGExtPltt);
break;
}
#endif
GXi_DmaCopy32Async(
GXi_DmaId,
pSrc,
(void *)(sBGExtPlttLCDCBlk + destSlotAddr - sBGExtPlttLCDCOffset),
szByte, NULL, NULL
);
}
void GX_EndLoadBGExtPltt () {
GXi_WaitDma(GXi_DmaId);
GX_SetBankForBGExtPltt(sBGExtPltt);
sBGExtPltt = (GXVRamBGExtPltt)0;
sBGExtPlttLCDCBlk = 0;
sBGExtPlttLCDCOffset = 0;
}
static GXVRamOBJExtPltt sOBJExtPltt = (GXVRamOBJExtPltt)(0);
static u32 sOBJExtPlttLCDCBlk = 0;
void GX_BeginLoadOBJExtPltt () {
SDK_ASSERT(0 == sOBJExtPltt && 0 == sOBJExtPlttLCDCBlk);
sOBJExtPltt = GX_ResetBankForOBJExtPltt();
switch (sOBJExtPltt) {
case GX_VRAM_OBJEXTPLTT_0_F:
sOBJExtPlttLCDCBlk = HW_LCDC_VRAM_F;
break;
case GX_VRAM_OBJEXTPLTT_0_G:
sOBJExtPlttLCDCBlk = HW_LCDC_VRAM_G;
break;
case GX_VRAM_OBJEXTPLTT_NONE:
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", sOBJExtPltt);
break;
}
;
}
void GX_LoadOBJExtPltt (const void * pSrc, u32 destSlotAddr, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(GX_VRAM_OBJEXTPLTT_NONE != sOBJExtPltt);
SDK_ASSERT(0 != sOBJExtPlttLCDCBlk);
SDK_ALIGN4_ASSERT(szByte);
SDK_ALIGN4_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(destSlotAddr);
SDK_ASSERT(destSlotAddr + szByte <= 0x2000);
GXi_DmaCopy32Async(
GXi_DmaId,
pSrc, (void *)(sOBJExtPlttLCDCBlk + destSlotAddr), szByte, NULL, NULL
);
}
void GX_EndLoadOBJExtPltt () {
GXi_WaitDma(GXi_DmaId);
GX_SetBankForOBJExtPltt(sOBJExtPltt);
sOBJExtPltt = (GXVRamOBJExtPltt)0;
sOBJExtPlttLCDCBlk = 0;
}
static GXVRamSubBGExtPltt sSubBGExtPltt = (GXVRamSubBGExtPltt)(0);
void GXS_BeginLoadBGExtPltt () {
SDK_ASSERT(0 == sSubBGExtPltt);
sSubBGExtPltt = GX_ResetBankForSubBGExtPltt();
SDK_ASSERTMSG(GX_VRAM_SUB_BGEXTPLTT_0123_H == sSubBGExtPltt, "Sub BGExtPltt not allocated");
}
void GXS_LoadBGExtPltt (const void * pSrc, u32 destSlotAddr, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(GX_VRAM_SUB_BGEXTPLTT_0123_H == sSubBGExtPltt);
SDK_ALIGN4_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(destSlotAddr);
SDK_ALIGN4_ASSERT(szByte);
SDK_ASSERTMSG(
destSlotAddr + szByte <= 0x8000,
"Illegal address/size specified(0x%5x->0x%5x)",
destSlotAddr, destSlotAddr + szByte
);
GXi_DmaCopy32Async(
GXi_DmaId,
pSrc, (void *)(HW_LCDC_VRAM_H + destSlotAddr), szByte, NULL, NULL
);
}
void GXS_EndLoadBGExtPltt () {
GXi_WaitDma(GXi_DmaId);
GX_SetBankForSubBGExtPltt(sSubBGExtPltt);
sSubBGExtPltt = (GXVRamSubBGExtPltt)0;
}
static GXVRamSubOBJExtPltt sSubOBJExtPltt = (GXVRamSubOBJExtPltt)(0);
void GXS_BeginLoadOBJExtPltt () {
SDK_ASSERT(0 == sSubOBJExtPltt);
sSubOBJExtPltt = GX_ResetBankForSubOBJExtPltt();
SDK_ASSERTMSG(GX_VRAM_SUB_OBJEXTPLTT_0_I == sSubOBJExtPltt, "Sub OBJExtPltt not allocated");
}
void GXS_LoadOBJExtPltt (const void * pSrc, u32 destSlotAddr, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(GX_VRAM_SUB_OBJEXTPLTT_0_I == sSubOBJExtPltt);
SDK_ALIGN4_ASSERT(pSrc);
SDK_ALIGN4_ASSERT(destSlotAddr);
SDK_ALIGN4_ASSERT(szByte);
SDK_ASSERTMSG(
destSlotAddr + szByte <= 0x2000,
"Illegal address/size specified(0x%5x->0x%5x)",
destSlotAddr, destSlotAddr + szByte
);
GXi_DmaCopy32Async(
GXi_DmaId,
pSrc, (void *)(HW_LCDC_VRAM_I + destSlotAddr), szByte, NULL, NULL
);
}
void GXS_EndLoadOBJExtPltt () {
GXi_WaitDma(GXi_DmaId);
GX_SetBankForSubOBJExtPltt(sSubOBJExtPltt);
sSubOBJExtPltt = (GXVRamSubOBJExtPltt)0;
}

413
lib/NitroSDK/src/gx/gx_load3d.c Normal file
View File

@ -0,0 +1,413 @@
#include <nitro/gx/gx_load.h>
#include <nitro/gx/gx_vramcnt.h>
#include <nitro/hw/ARM9/mmap_global.h>
#include <nitro/mi/dma.h>
#include "include/gxstate.h"
#include "include/gxdma.h"
static u32 sTexLCDCBlk1 = 0;
static u32 sSzTexBlk1 = 0;
static u32 sTexLCDCBlk2 = 0;
static GXVRamTex sTex = (GXVRamTex)(0);
static const struct {
u16 blk1;
u16 blk2;
u16 szBlk1;
} sTexStartAddrTable[16] = {
{
0, 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_A >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_B >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_A >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_C >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_A >> 12), (u16)(HW_LCDC_VRAM_C >> 12), (u16)(HW_VRAM_A_SIZE >> 12)
}
,
{
(u16)(HW_LCDC_VRAM_B >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_A >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_D >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_A >> 12), (u16)(HW_LCDC_VRAM_D >> 12), (u16)(HW_VRAM_A_SIZE >> 12)
}
,
{
(u16)(HW_LCDC_VRAM_B >> 12), (u16)(HW_LCDC_VRAM_D >> 12), (u16)(HW_VRAM_B_SIZE >> 12)
}
,
{
(u16)(HW_LCDC_VRAM_A >> 12),
(u16)(HW_LCDC_VRAM_D >> 12), (u16)((HW_VRAM_A_SIZE + HW_VRAM_B_SIZE) >> 12)
}
,
{
(u16)(HW_LCDC_VRAM_C >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_A >> 12), (u16)(HW_LCDC_VRAM_C >> 12), (u16)(HW_VRAM_A_SIZE >> 12)
}
,
{
(u16)(HW_LCDC_VRAM_B >> 12), 0, 0
}
,
{
(u16)(HW_LCDC_VRAM_A >> 12), 0, 0
}
,
};
void GX_LoadTexEx (GXVRamTex tex, const void * pSrc, u32 destSlotAddr, u32 szByte) {
u32 base1, base2, szBlk1;
void * pLCDC;
SDK_ALIGN4_ASSERT(szByte);
SDK_ALIGN4_ASSERT(destSlotAddr);
SDK_ALIGN4_ASSERT(pSrc);
SDK_ASSERTMSG(
(GX_GetBankForLCDC() & tex) == tex,
"Banks specified by tex must be on LCDC space."
);
GX_VRAM_TEX_ASSERT(tex);
base1 = (u32)(sTexStartAddrTable[tex].blk1 << 12);
base2 = (u32)(sTexStartAddrTable[tex].blk2 << 12);
szBlk1 = (u32)(sTexStartAddrTable[tex].szBlk1 << 12);
SDK_ASSERT(0 != base1);
GX_RegionCheck_Tex(tex, destSlotAddr, destSlotAddr + szByte);
if (0 == base2) {
pLCDC = (void *)(base1 + destSlotAddr);
} else {
if (destSlotAddr + szByte < szBlk1) {
pLCDC = (void *)(base1 + destSlotAddr);
} else if (destSlotAddr >= szBlk1) {
pLCDC = (void *)(base2 + destSlotAddr - szBlk1);
} else {
void * pLCDC2 = (void *)base2;
u32 sz = szBlk1 - destSlotAddr;
pLCDC = (void *)(base1 + destSlotAddr);
GXi_DmaCopy32(GXi_DmaId, pSrc, pLCDC, sz);
GXi_DmaCopy32Async(
GXi_DmaId,
(void *)((u8 *)pSrc + sz), pLCDC2, szByte - sz, NULL, NULL
);
return;
}
}
GXi_DmaCopy32Async(GXi_DmaId, pSrc, pLCDC, szByte, NULL, NULL);
}
void GX_BeginLoadTex () {
#if 1
SDK_ASSERT(0 == sTex && 0 == sTexLCDCBlk1 && 0 == sSzTexBlk1 && 0 == sTexLCDCBlk2);
sTex = GX_ResetBankForTex();
GX_VRAM_TEX_ASSERT(sTex);
sTexLCDCBlk1 = (u32)(sTexStartAddrTable[sTex].blk1 << 12);
sTexLCDCBlk2 = (u32)(sTexStartAddrTable[sTex].blk2 << 12);
sSzTexBlk1 = (u32)(sTexStartAddrTable[sTex].szBlk1 << 12);
#else
SDK_ASSERT(sTex == 0 && sTexLCDCBlk1 == 0 && sSzTexBlk1 == 0 && sTexLCDCBlk2 == 0);
sTex = GX_ResetBankForTex();
switch (sTex) {
case GX_VRAM_TEX_01_AC:
case GX_VRAM_TEX_012_ACD:
sTexLCDCBlk2 = HW_LCDC_VRAM_C;
sSzTexBlk1 = HW_VRAM_A_SIZE;
case GX_VRAM_TEX_0_A:
case GX_VRAM_TEX_01_AB:
case GX_VRAM_TEX_012_ABC:
case GX_VRAM_TEX_0123_ABCD:
sTexLCDCBlk1 = HW_LCDC_VRAM_A;
break;
case GX_VRAM_TEX_01_BD:
sTexLCDCBlk2 = HW_LCDC_VRAM_D;
sSzTexBlk1 = HW_VRAM_B_SIZE;
case GX_VRAM_TEX_0_B:
case GX_VRAM_TEX_01_BC:
case GX_VRAM_TEX_012_BCD:
sTexLCDCBlk1 = HW_LCDC_VRAM_B;
break;
case GX_VRAM_TEX_0_C:
case GX_VRAM_TEX_01_CD:
sTexLCDCBlk1 = HW_LCDC_VRAM_C;
break;
case GX_VRAM_TEX_0_D:
sTexLCDCBlk1 = HW_LCDC_VRAM_D;
break;
case GX_VRAM_TEX_01_AD:
sTexLCDCBlk1 = HW_LCDC_VRAM_A;
sTexLCDCBlk2 = HW_LCDC_VRAM_D;
sSzTexBlk1 = HW_VRAM_A_SIZE;
break;
case GX_VRAM_TEX_012_ABD:
sTexLCDCBlk1 = HW_LCDC_VRAM_A;
sTexLCDCBlk2 = HW_LCDC_VRAM_D;
sSzTexBlk1 = HW_VRAM_A_SIZE + HW_VRAM_B_SIZE;
break;
case GX_VRAM_TEX_NONE:
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", sTex);
break;
}
;
#endif
}
void GX_LoadTex (const void * pSrc, u32 destSlotAddr, u32 szByte) {
void * pLCDC;
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(GX_VRAM_TEX_NONE != sTex);
SDK_ASSERT(0 != sTexLCDCBlk1);
SDK_ALIGN4_ASSERT(szByte);
SDK_ALIGN4_ASSERT(destSlotAddr);
SDK_ALIGN4_ASSERT(pSrc);
GX_RegionCheck_Tex(sTex, destSlotAddr, destSlotAddr + szByte);
if (0 == sTexLCDCBlk2) {
pLCDC = (void *)(sTexLCDCBlk1 + destSlotAddr);
} else {
if (destSlotAddr + szByte < sSzTexBlk1) {
pLCDC = (void *)(sTexLCDCBlk1 + destSlotAddr);
} else if (destSlotAddr >= sSzTexBlk1) {
pLCDC = (void *)(sTexLCDCBlk2 + destSlotAddr - sSzTexBlk1);
} else {
void * pLCDC2 = (void *)sTexLCDCBlk2;
u32 sz = sSzTexBlk1 - destSlotAddr;
pLCDC = (void *)(sTexLCDCBlk1 + destSlotAddr);
GXi_DmaCopy32(GXi_DmaId, pSrc, pLCDC, sz);
GXi_DmaCopy32Async(
GXi_DmaId,
(void *)((u8 *)pSrc + sz), pLCDC2, szByte - sz, NULL, NULL
);
return;
}
}
GXi_DmaCopy32Async(GXi_DmaId, pSrc, pLCDC, szByte, NULL, NULL);
}
void GX_EndLoadTex () {
GXi_WaitDma(GXi_DmaId);
GX_SetBankForTex(sTex);
sTexLCDCBlk1 = sTexLCDCBlk2 = sSzTexBlk1 = 0;
sTex = (GXVRamTex)0;
}
static GXVRamTexPltt sTexPltt = (GXVRamTexPltt)(0);
static u32 sTexPlttLCDCBlk = 0;
static const u16 sTexPlttStartAddrTable[8] = {
0,
(u16)(HW_LCDC_VRAM_E >> 12),
(u16)(HW_LCDC_VRAM_F >> 12),
(u16)(HW_LCDC_VRAM_E >> 12),
(u16)(HW_LCDC_VRAM_G >> 12),
0,
(u16)(HW_LCDC_VRAM_F >> 12),
(u16)(HW_LCDC_VRAM_E >> 12)
};
void GX_LoadTexPlttEx (GXVRamTexPltt texPltt, const void * pSrc, u32 destSlotAddr, u32 szByte) {
u32 base;
SDK_ASSERTMSG(
(GX_GetBankForLCDC() & texPltt) == texPltt,
"Banks specified by texPltt must be on LCDC space."
);
GX_VRAM_TEXPLTT_ASSERT(texPltt);
base = (u32)(sTexPlttStartAddrTable[texPltt >> 4] << 12);
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(0 != base);
SDK_ALIGN4_ASSERT(destSlotAddr);
SDK_ALIGN4_ASSERT(szByte);
SDK_ALIGN4_ASSERT(pSrc);
GX_RegionCheck_TexPltt(texPltt, destSlotAddr, destSlotAddr + szByte);
GXi_DmaCopy32Async(GXi_DmaId, pSrc, (void *)(base + destSlotAddr), szByte, NULL, NULL);
}
void GX_BeginLoadTexPltt () {
#if 1
SDK_ASSERT(0 == sTexPltt && 0 == sTexPlttLCDCBlk);
sTexPltt = GX_ResetBankForTexPltt();
GX_VRAM_TEXPLTT_ASSERT(sTexPltt);
sTexPlttLCDCBlk = (u32)(sTexPlttStartAddrTable[sTexPltt >> 4] << 12);
#else
SDK_ASSERT(sTexPltt == 0 && sTexPlttLCDCBlk == 0);
sTexPltt = GX_ResetBankForTexPltt();
switch (sTexPltt) {
case GX_VRAM_TEXPLTT_0_F:
case GX_VRAM_TEXPLTT_01_FG:
sTexPlttLCDCBlk = HW_LCDC_VRAM_F;
break;
case GX_VRAM_TEXPLTT_0_G:
sTexPlttLCDCBlk = HW_LCDC_VRAM_G;
break;
case GX_VRAM_TEXPLTT_0123_E:
case GX_VRAM_TEXPLTT_01234_EF:
case GX_VRAM_TEXPLTT_012345_EFG:
sTexPlttLCDCBlk = HW_LCDC_VRAM_E;
break;
case GX_VRAM_TEXPLTT_NONE:
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", sTexPltt);
break;
}
#endif
}
void GX_LoadTexPltt (const void * pSrc, u32 destSlotAddr, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(GX_VRAM_TEXPLTT_NONE != sTexPltt);
SDK_ASSERT(0 != sTexPlttLCDCBlk);
SDK_ALIGN4_ASSERT(destSlotAddr);
SDK_ALIGN4_ASSERT(szByte);
SDK_ALIGN4_ASSERT(pSrc);
GX_RegionCheck_TexPltt(sTexPltt, destSlotAddr, destSlotAddr + szByte);
GXi_DmaCopy32Async(
GXi_DmaId,
pSrc, (void *)(sTexPlttLCDCBlk + destSlotAddr), szByte, NULL, NULL
);
}
void GX_EndLoadTexPltt () {
GXi_WaitDma(GXi_DmaId);
GX_SetBankForTexPltt(sTexPltt);
sTexPltt = (GXVRamTexPltt)0;
sTexPlttLCDCBlk = 0;
}
static GXVRamClearImage sClrImg = (GXVRamClearImage)(0);
static u32 sClrImgLCDCBlk = 0;
void GX_BeginLoadClearImage () {
SDK_ASSERT(0 == sClrImg && 0 == sClrImgLCDCBlk);
sClrImg = GX_ResetBankForClearImage();
switch (sClrImg) {
case GX_VRAM_CLEARIMAGE_256_AB:
case GX_VRAM_CLEARDEPTH_128_B:
sClrImgLCDCBlk = HW_LCDC_VRAM_A;
break;
case GX_VRAM_CLEARIMAGE_256_CD:
case GX_VRAM_CLEARDEPTH_128_D:
sClrImgLCDCBlk = HW_LCDC_VRAM_C;
break;
case GX_VRAM_CLEARDEPTH_128_A:
sClrImgLCDCBlk = HW_LCDC_VRAM_A - 0x20000;
break;
case GX_VRAM_CLEARDEPTH_128_C:
sClrImgLCDCBlk = HW_LCDC_VRAM_C - 0x20000;
break;
case GX_VRAM_CLEARIMAGE_NONE:
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", sClrImg);
break;
}
}
void GX_LoadClearImageColor (const void * pSrc, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(GX_VRAM_CLEARIMAGE_256_AB == sClrImg || GX_VRAM_CLEARIMAGE_256_CD == sClrImg);
SDK_ASSERT(0 != sClrImgLCDCBlk);
SDK_ALIGN4_ASSERT(szByte);
SDK_ALIGN4_ASSERT(pSrc);
SDK_ASSERT(szByte <= 0x20000);
GXi_DmaCopy32Async(GXi_DmaId, pSrc, (void *)(sClrImgLCDCBlk), szByte, NULL, NULL);
}
void GX_LoadClearImageDepth (const void * pSrc, u32 szByte) {
SDK_NULL_ASSERT(pSrc);
SDK_ASSERT(GX_VRAM_CLEARIMAGE_NONE != sClrImg);
SDK_ASSERT(0 != sClrImgLCDCBlk);
SDK_ALIGN4_ASSERT(szByte);
SDK_ALIGN4_ASSERT(pSrc);
SDK_ASSERT(szByte <= 0x20000);
GXi_DmaCopy32Async(
GXi_DmaId,
pSrc,
(void *)(sClrImgLCDCBlk + 0x20000),
szByte, NULL, NULL
);
}
void GX_EndLoadClearImage () {
GXi_WaitDma(GXi_DmaId);
GX_SetBankForClearImage(sClrImg);
sClrImg = (GXVRamClearImage)0;
sClrImgLCDCBlk = 0;
}

1722
lib/NitroSDK/src/gx/gx_vramcnt.c Normal file
View File

File diff suppressed because it is too large Load Diff

81
lib/NitroSDK/src/gx/gxasm.c Normal file
View File

@ -0,0 +1,81 @@
#include <nitro/code32.h>
#include "include/gxasm.h"
asm void GX_SendFifo48B (register const void * pSrc, register void * pDest) {
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
bx lr
}
asm void GX_SendFifo64B (register const void * pSrc, register void * pDest) {
#ifdef SDK_TEG
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2}
stmia r1, {r2}
bx lr
#else
stmfd sp !, {r4 - r8}
ldmia r0 !, {r2 - r8, r12}
stmia r1, {r2 - r8, r12}
ldmia r0 !, {r2 - r8, r12}
stmia r1, {r2 - r8, r12}
ldmfd sp !, {r4 - r8}
bx lr
#endif
}
asm void GX_SendFifo128B (register const void * pSrc, register void * pDest) {
#ifdef SDK_TEG
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3, r12}
stmia r1, {r2, r3, r12}
ldmia r0 !, {r2, r3}
stmia r1, {r2, r3}
bx lr
#else
stmfd sp !, {r4 - r8}
ldmia r0 !, {r2 - r8, r12}
stmia r1, {r2 - r8, r12}
ldmia r0 !, {r2 - r8, r12}
stmia r1, {r2 - r8, r12}
ldmia r0 !, {r2 - r8, r12}
stmia r1, {r2 - r8, r12}
ldmia r0 !, {r2 - r8, r12}
stmia r1, {r2 - r8, r12}
ldmfd sp !, {r4 - r8}
bx lr
#endif
}

444
lib/NitroSDK/src/gx/gxstate.c Normal file
View File

@ -0,0 +1,444 @@
#include "include/gxstate.h"
#include <nitro/gx/gx_vramcnt.h>
GX_State gGXState;
#ifdef SDK_CW_WARNOFF_SAFESTRB
#include <nitro/code32.h>
#endif
void GX_InitGXState () {
gGXState.vramCnt.lcdc = 0;
gGXState.vramCnt.bg = 0;
gGXState.vramCnt.obj = 0;
gGXState.vramCnt.arm7 = 0;
gGXState.vramCnt.tex = 0;
gGXState.vramCnt.texPltt = 0;
gGXState.vramCnt.clrImg = 0;
gGXState.vramCnt.bgExtPltt = 0;
gGXState.vramCnt.objExtPltt = 0;
gGXState.vramCnt.sub_bg = 0;
gGXState.vramCnt.sub_obj = 0;
gGXState.vramCnt.sub_bgExtPltt = 0;
gGXState.vramCnt.sub_objExtPltt = 0;
reg_GX_VRAMCNT = 0;
*((u8 *)&reg_GX_WVRAMCNT + 0) = 0;
*((u8 *)&reg_GX_WVRAMCNT + 1) = 0;
*((u8 *)&reg_GX_WVRAMCNT + 2) = 0;
reg_GX_VRAM_HI_CNT = 0;
}
#ifdef SDK_CW_WARNOFF_SAFESTRB
#include <nitro/codereset.h>
#endif
#define SDK_CONFLICT_ASSERT(a, b, name1, name2) \
SDK_ASSERTMSG( \
!(a & b), \
"VRAM Bank conflicts between "#name1 " and "#name2 " (0x%02x, 0x%02x)\n", \
a, b \
)
#define SDK_CONFLICT_CHECK(val, bank) \
if (val & bank) goto SDK_VRAMCNT_ERROR; else val |= bank
#ifdef SDK_DEBUG
void GX_StateCheck_VRAMCnt_ () {
GX_VRAMCnt_ * p = &gGXState.vramCnt;
u16 tmp = p->lcdc;
SDK_CONFLICT_CHECK(tmp, p->bg);
SDK_CONFLICT_CHECK(tmp, p->obj);
SDK_CONFLICT_CHECK(tmp, p->arm7);
SDK_CONFLICT_CHECK(tmp, p->tex);
SDK_CONFLICT_CHECK(tmp, p->texPltt);
SDK_CONFLICT_CHECK(tmp, p->clrImg);
SDK_CONFLICT_CHECK(tmp, p->bgExtPltt);
SDK_CONFLICT_CHECK(tmp, p->objExtPltt);
SDK_CONFLICT_CHECK(tmp, p->sub_bg);
SDK_CONFLICT_CHECK(tmp, p->sub_obj);
SDK_CONFLICT_CHECK(tmp, p->sub_bgExtPltt);
SDK_CONFLICT_CHECK(tmp, p->sub_objExtPltt);
return;
SDK_VRAMCNT_ERROR:
SDK_CONFLICT_ASSERT(p->lcdc, p->bg, LCDC, BG);
SDK_CONFLICT_ASSERT(p->lcdc, p->obj, LCDC, OBJ);
SDK_CONFLICT_ASSERT(p->lcdc, p->arm7, LCDC, ARM7);
SDK_CONFLICT_ASSERT(p->lcdc, p->tex, LCDC, Tex);
SDK_CONFLICT_ASSERT(p->lcdc, p->texPltt, LCDC, TEXPltt);
SDK_CONFLICT_ASSERT(p->lcdc, p->clrImg, LCDC, ClearImage);
SDK_CONFLICT_ASSERT(p->lcdc, p->bgExtPltt, LCDC, BGExtPltt);
SDK_CONFLICT_ASSERT(p->lcdc, p->objExtPltt, LCDC, OBJExtPltt);
SDK_CONFLICT_ASSERT(p->lcdc, p->sub_bg, LCDC, SubBG);
SDK_CONFLICT_ASSERT(p->lcdc, p->sub_obj, LCDC, SubOBJ);
SDK_CONFLICT_ASSERT(p->lcdc, p->sub_bgExtPltt, LCDC, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->lcdc, p->sub_objExtPltt, LCDC, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->bg, p->obj, BG, OBJ);
SDK_CONFLICT_ASSERT(p->bg, p->arm7, BG, ARM7);
SDK_CONFLICT_ASSERT(p->bg, p->tex, BG, Tex);
SDK_CONFLICT_ASSERT(p->bg, p->texPltt, BG, TexPltt);
SDK_CONFLICT_ASSERT(p->bg, p->clrImg, BG, ClearImage);
SDK_CONFLICT_ASSERT(p->bg, p->bgExtPltt, BG, BGExtPltt);
SDK_CONFLICT_ASSERT(p->bg, p->objExtPltt, BG, OBJExtPltt);
SDK_CONFLICT_ASSERT(p->bg, p->sub_bg, BG, SubBG);
SDK_CONFLICT_ASSERT(p->bg, p->sub_obj, BG, SubOBJ);
SDK_CONFLICT_ASSERT(p->bg, p->sub_bgExtPltt, BG, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->bg, p->sub_objExtPltt, BG, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->obj, p->arm7, OBJ, ARM7);
SDK_CONFLICT_ASSERT(p->obj, p->tex, OBJ, Tex);
SDK_CONFLICT_ASSERT(p->obj, p->texPltt, OBJ, TexPltt);
SDK_CONFLICT_ASSERT(p->obj, p->clrImg, OBJ, ClearImage);
SDK_CONFLICT_ASSERT(p->obj, p->bgExtPltt, OBJ, BGExtPltt);
SDK_CONFLICT_ASSERT(p->obj, p->objExtPltt, OBJ, OBJExtPltt);
SDK_CONFLICT_ASSERT(p->obj, p->sub_bg, OBJ, SubBG);
SDK_CONFLICT_ASSERT(p->obj, p->sub_obj, OBJ, SubOBJ);
SDK_CONFLICT_ASSERT(p->obj, p->sub_bgExtPltt, OBJ, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->obj, p->sub_objExtPltt, OBJ, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->arm7, p->tex, ARM7, Tex);
SDK_CONFLICT_ASSERT(p->arm7, p->texPltt, ARM7, TexPltt);
SDK_CONFLICT_ASSERT(p->arm7, p->clrImg, ARM7, ClearImage);
SDK_CONFLICT_ASSERT(p->arm7, p->bgExtPltt, ARM7, BGExtPltt);
SDK_CONFLICT_ASSERT(p->arm7, p->objExtPltt, ARM7, OBJExtPltt);
SDK_CONFLICT_ASSERT(p->arm7, p->sub_bg, ARM7, SubBG);
SDK_CONFLICT_ASSERT(p->arm7, p->sub_obj, ARM7, SubOBJ);
SDK_CONFLICT_ASSERT(p->arm7, p->sub_bgExtPltt, ARM7, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->arm7, p->sub_objExtPltt, ARM7, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->tex, p->texPltt, Tex, TexPltt);
SDK_CONFLICT_ASSERT(p->tex, p->clrImg, Tex, ClearImage);
SDK_CONFLICT_ASSERT(p->tex, p->bgExtPltt, Tex, BGExtPltt);
SDK_CONFLICT_ASSERT(p->tex, p->objExtPltt, Tex, OBJExtPltt);
SDK_CONFLICT_ASSERT(p->tex, p->sub_bg, Tex, SubBG);
SDK_CONFLICT_ASSERT(p->tex, p->sub_obj, Tex, SubOBJ);
SDK_CONFLICT_ASSERT(p->tex, p->sub_bgExtPltt, Tex, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->tex, p->sub_objExtPltt, Tex, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->texPltt, p->clrImg, TexPltt, ClearImage);
SDK_CONFLICT_ASSERT(p->texPltt, p->bgExtPltt, TexPltt, BGExtPltt);
SDK_CONFLICT_ASSERT(p->texPltt, p->objExtPltt, TexPltt, OBJExtPltt);
SDK_CONFLICT_ASSERT(p->texPltt, p->sub_bg, TexPltt, SubBG);
SDK_CONFLICT_ASSERT(p->texPltt, p->sub_obj, TexPltt, SubOBJ);
SDK_CONFLICT_ASSERT(p->texPltt, p->sub_bgExtPltt, TexPltt, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->texPltt, p->sub_objExtPltt, TexPltt, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->clrImg, p->bgExtPltt, ClearImage, BGExtPltt);
SDK_CONFLICT_ASSERT(p->clrImg, p->objExtPltt, ClearImage, OBJExtPltt);
SDK_CONFLICT_ASSERT(p->clrImg, p->sub_bg, ClearImage, SubBG);
SDK_CONFLICT_ASSERT(p->clrImg, p->sub_obj, ClearImage, SubOBJ);
SDK_CONFLICT_ASSERT(p->clrImg, p->sub_bgExtPltt, ClearImage, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->clrImg, p->sub_objExtPltt, ClearImage, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->bgExtPltt, p->objExtPltt, BGExtPltt, OBJExtPltt);
SDK_CONFLICT_ASSERT(p->bgExtPltt, p->sub_bg, BGExtPltt, SubBG);
SDK_CONFLICT_ASSERT(p->bgExtPltt, p->sub_obj, BGExtPltt, SubOBJ);
SDK_CONFLICT_ASSERT(p->bgExtPltt, p->sub_bgExtPltt, BGExtPltt, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->bgExtPltt, p->sub_objExtPltt, BGExtPltt, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->objExtPltt, p->sub_bg, OBJExtPltt, SubBG);
SDK_CONFLICT_ASSERT(p->objExtPltt, p->sub_obj, OBJExtPltt, SubOBJ);
SDK_CONFLICT_ASSERT(p->objExtPltt, p->sub_bgExtPltt, OBJExtPltt, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->objExtPltt, p->sub_objExtPltt, OBJExtPltt, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->sub_bg, p->sub_obj, SubBG, SubOBJ);
SDK_CONFLICT_ASSERT(p->sub_bg, p->sub_bgExtPltt, SubBG, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->sub_bg, p->sub_objExtPltt, SubBG, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->sub_obj, p->sub_bgExtPltt, SubOBJ, SubBGExtPltt);
SDK_CONFLICT_ASSERT(p->sub_obj, p->sub_objExtPltt, SubOBJ, SubOBJExtPltt);
SDK_CONFLICT_ASSERT(p->sub_bgExtPltt, p->sub_objExtPltt, SubBGExtPltt, SubOBJExtPltt);
}
#define SDK_REGION_ASSERT(name, r1, r2, d1, d2) \
SDK_ASSERTMSG( \
((r1) <= (d1)) && ((r2) >= (d2)), \
"Region allocated to "#name " is (0x%08x -> 0x%08x),\n" \
"access occured (0x%08x -> 0x%08x).", r1, r2, d1, d2 \
)
#define SDK_REGION_ASSERT_EX(name, r1, r2, r3, r4, d1, d2) \
SDK_ASSERTMSG( \
(((r1) <= (d1)) && ((r2) >= (d2))) || (((r3) <= (d1)) && ((r4) >= (d2))), \
"Region allocated to "#name " is (0x%08x -> 0x%08x, 0x%08x -> 0x%08x),\n" \
"access occured (0x%08x -> 0x%08x).", r1, r2, r3, r4, d1, d2 \
)
void GX_RegionCheck_OBJ_ (u32 first, u32 last) {
switch (gGXState.vramCnt.obj) {
case GX_VRAM_OBJ_NONE:
SDK_REGION_ASSERT(OBJ, HW_OBJ_VRAM, HW_OBJ_VRAM, first, last);
break;
case GX_VRAM_OBJ_16_F:
case GX_VRAM_OBJ_16_G:
SDK_REGION_ASSERT(OBJ, HW_OBJ_VRAM, HW_OBJ_VRAM + HW_VRAM_F_SIZE, first, last);
break;
case GX_VRAM_OBJ_32_FG:
SDK_REGION_ASSERT(
OBJ, HW_OBJ_VRAM,
HW_OBJ_VRAM + HW_VRAM_F_SIZE + HW_VRAM_G_SIZE, first, last
);
break;
case GX_VRAM_OBJ_64_E:
SDK_REGION_ASSERT(OBJ, HW_OBJ_VRAM, HW_OBJ_VRAM + HW_VRAM_E_SIZE, first, last);
break;
case GX_VRAM_OBJ_80_EF:
SDK_REGION_ASSERT(
OBJ, HW_OBJ_VRAM,
HW_OBJ_VRAM + HW_VRAM_E_SIZE + HW_VRAM_F_SIZE, first, last
);
break;
case GX_VRAM_OBJ_80_EG:
SDK_REGION_ASSERT(
OBJ, HW_OBJ_VRAM,
HW_OBJ_VRAM + HW_VRAM_E_SIZE + HW_VRAM_G_SIZE, first, last
);
break;
case GX_VRAM_OBJ_96_EFG:
SDK_REGION_ASSERT(
OBJ, HW_OBJ_VRAM,
HW_OBJ_VRAM + HW_VRAM_E_SIZE + HW_VRAM_F_SIZE + HW_VRAM_G_SIZE,
first, last
);
break;
case GX_VRAM_OBJ_128_A:
case GX_VRAM_OBJ_128_B:
SDK_REGION_ASSERT(OBJ, HW_OBJ_VRAM, HW_OBJ_VRAM + HW_VRAM_A_SIZE, first, last);
break;
case GX_VRAM_OBJ_256_AB:
SDK_REGION_ASSERT(
OBJ, HW_OBJ_VRAM,
HW_OBJ_VRAM + HW_VRAM_A_SIZE + HW_VRAM_B_SIZE, first, last
);
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", gGXState.vramCnt.obj);
break;
}
}
void GX_RegionCheck_BG_ (u32 first, u32 last) {
u16 vram_abcd;
u16 vram_efg;
u32 abcd_size, efg_size;
SDK_ASSERT(
HW_VRAM_A_SIZE == HW_VRAM_B_SIZE &&
HW_VRAM_A_SIZE == HW_VRAM_C_SIZE && HW_VRAM_A_SIZE == HW_VRAM_D_SIZE
);
if (gGXState.vramCnt.bg & (GX_VRAM_H | GX_VRAM_I)) {
SDK_INTERNAL_ERROR("unknown case 0x%x", gGXState.vramCnt.bg);
return;
}
vram_abcd = (u16)(gGXState.vramCnt.bg & GX_VRAM_BG_512_ABCD);
vram_efg = (u16)(gGXState.vramCnt.bg & GX_VRAM_BG_96_EFG);
switch (vram_efg) {
case GX_VRAM_BG_NONE:
efg_size = 0;
break;
case GX_VRAM_BG_16_F:
case GX_VRAM_BG_16_G:
efg_size = HW_VRAM_F_SIZE;
break;
case GX_VRAM_BG_32_FG:
efg_size = HW_VRAM_F_SIZE + HW_VRAM_G_SIZE;
break;
case GX_VRAM_BG_64_E:
efg_size = HW_VRAM_E_SIZE;
break;
case GX_VRAM_BG_80_EF:
case GX_VRAM_BG_80_EG:
efg_size = HW_VRAM_E_SIZE + HW_VRAM_F_SIZE;
break;
case GX_VRAM_BG_96_EFG:
efg_size = HW_VRAM_E_SIZE + HW_VRAM_F_SIZE + HW_VRAM_G_SIZE;
break;
}
switch (vram_abcd) {
case GX_VRAM_BG_NONE:
abcd_size = 0;
break;
case GX_VRAM_BG_128_A:
case GX_VRAM_BG_128_B:
case GX_VRAM_BG_128_C:
case GX_VRAM_BG_128_D:
abcd_size = HW_VRAM_A_SIZE;
break;
case GX_VRAM_BG_256_AB:
case GX_VRAM_BG_256_BC:
case GX_VRAM_BG_256_CD:
case GX_VRAM_BG_256_AC:
case GX_VRAM_BG_256_AD:
case GX_VRAM_BG_256_BD:
abcd_size = HW_VRAM_A_SIZE + HW_VRAM_B_SIZE;
break;
case GX_VRAM_BG_384_ABC:
case GX_VRAM_BG_384_BCD:
case GX_VRAM_BG_384_ABD:
case GX_VRAM_BG_384_ACD:
abcd_size = HW_VRAM_A_SIZE + HW_VRAM_B_SIZE + HW_VRAM_C_SIZE;
break;
case GX_VRAM_BG_512_ABCD:
abcd_size = HW_VRAM_A_SIZE + HW_VRAM_B_SIZE + HW_VRAM_C_SIZE + HW_VRAM_D_SIZE;
break;
}
if (vram_abcd && vram_efg) {
if (vram_abcd == GX_VRAM_BG_512_ABCD) {
SDK_INTERNAL_ERROR("unknown case 0x%x", gGXState.vramCnt.bg);
return;
}
SDK_REGION_ASSERT_EX(
BG, HW_BG_VRAM, HW_BG_VRAM + efg_size,
HW_BG_VRAM + HW_VRAM_A_SIZE, HW_BG_VRAM + HW_VRAM_A_SIZE + abcd_size,
first, last
);
} else if (vram_abcd) {
SDK_REGION_ASSERT(BG, HW_BG_VRAM, HW_BG_VRAM + abcd_size, first, last);
} else {
SDK_REGION_ASSERT(BG, HW_BG_VRAM, HW_BG_VRAM + efg_size, first, last);
}
}
void GX_RegionCheck_SubOBJ_ (u32 first, u32 last) {
switch (gGXState.vramCnt.sub_obj) {
case GX_VRAM_SUB_OBJ_NONE:
SDK_REGION_ASSERT(SubOBJ, HW_DB_OBJ_VRAM, HW_DB_OBJ_VRAM, first, last);
break;
case GX_VRAM_SUB_OBJ_128_D:
SDK_REGION_ASSERT(SubOBJ, HW_DB_OBJ_VRAM, HW_DB_OBJ_VRAM + HW_VRAM_D_SIZE, first, last);
break;
case GX_VRAM_SUB_OBJ_16_I:
SDK_REGION_ASSERT(SubOBJ, HW_DB_OBJ_VRAM, HW_DB_OBJ_VRAM + HW_VRAM_I_SIZE, first, last);
break;
}
}
void GX_RegionCheck_SubBG_ (u32 first, u32 last) {
switch (gGXState.vramCnt.sub_bg) {
case GX_VRAM_SUB_BG_NONE:
SDK_REGION_ASSERT(SubBG, HW_DB_BG_VRAM, HW_DB_BG_VRAM, first, last);
break;
case GX_VRAM_SUB_BG_128_C:
SDK_REGION_ASSERT(SubBG, HW_DB_BG_VRAM, HW_DB_BG_VRAM + HW_VRAM_C_SIZE, first, last);
break;
case GX_VRAM_SUB_BG_32_H:
SDK_REGION_ASSERT(SubBG, HW_DB_BG_VRAM, HW_DB_BG_VRAM + HW_VRAM_H_SIZE, first, last);
break;
case GX_VRAM_SUB_BG_48_HI:
SDK_REGION_ASSERT(
SubBG, HW_DB_BG_VRAM,
HW_DB_BG_VRAM + HW_VRAM_H_SIZE + HW_VRAM_I_SIZE, first, last
);
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", gGXState.vramCnt.sub_bg);
break;
}
}
void GX_RegionCheck_TexPltt_ (GXVRamTexPltt texPltt, u32 first, u32 last) {
#if defined(SDK_NO_MESSAGE)
#pragma unused(first)
#endif
switch (texPltt) {
case GX_VRAM_TEXPLTT_0_F:
case GX_VRAM_TEXPLTT_0_G:
SDK_ASSERTMSG(
last <= 0x04000,
"Texture pallete 0x04000-0x18000 not available(0x%5x->0x%5x)", first, last
);
break;
case GX_VRAM_TEXPLTT_01_FG:
SDK_ASSERTMSG(
last <= 0x08000,
"Texture pallete 0x08000-0x18000 not available(0x%5x->0x%5x)", first, last
);
break;
case GX_VRAM_TEXPLTT_0123_E:
SDK_ASSERTMSG(
last <= 0x10000,
"Texture pallete 0x10000-0x18000 not available(0x%5x->0x%5x)", first, last
);
break;
case GX_VRAM_TEXPLTT_01234_EF:
SDK_ASSERTMSG(
last <= 0x14000,
"Texture pallete 0x14000-0x18000 not available(0x%5x->0x%5x)", first, last
);
break;
case GX_VRAM_TEXPLTT_012345_EFG:
SDK_ASSERTMSG(last <= 0x18000, "Illegal Address/size specified(0x%5x->0x%5x)", first, last);
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", texPltt);
break;
}
}
void GX_RegionCheck_Tex_ (GXVRamTex tex, u32 first, u32 last) {
#if defined(SDK_NO_MESSAGE)
#pragma unused(first)
#endif
switch (tex) {
case GX_VRAM_TEX_0_A:
case GX_VRAM_TEX_0_B:
case GX_VRAM_TEX_0_C:
case GX_VRAM_TEX_0_D:
SDK_ASSERTMSG(
last <= 0x20000,
"Texture slot 0x20000-0x80000 not available(0x%5x->0x%5x)", first, last
);
break;
case GX_VRAM_TEX_01_AB:
case GX_VRAM_TEX_01_BC:
case GX_VRAM_TEX_01_CD:
case GX_VRAM_TEX_01_AC:
case GX_VRAM_TEX_01_AD:
case GX_VRAM_TEX_01_BD:
SDK_ASSERTMSG(
last <= 0x40000,
"Texture slot 0x40000-0x80000 not available(0x%5x->0x%5x)", first, last
);
break;
case GX_VRAM_TEX_012_ABC:
case GX_VRAM_TEX_012_BCD:
case GX_VRAM_TEX_012_ABD:
case GX_VRAM_TEX_012_ACD:
SDK_ASSERTMSG(
last <= 0x60000,
"Texture slot 0x60000-0x80000 not available(0x%5x->0x%5x)", first, last
);
break;
case GX_VRAM_TEX_0123_ABCD:
SDK_ASSERTMSG(last <= 0x80000, "Illegal Address/size specified(0x%5x->0x%5x)", first, last);
break;
default:
SDK_INTERNAL_ERROR("unknown case 0x%x", tex);
break;
}
;
}
#endif

23
lib/NitroSDK/src/gx/include/gxasm.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef NITRO_GXASM_H_
#define NITRO_GXASM_H_
#include <nitro/mi/memory.h>
#ifdef __cplusplus
extern "C" {
#endif
void GX_SendFifo36B(register const void * pSrc, register void * pDest);
void GX_SendFifo48B(register const void * pSrc, register void * pDest);
void GX_SendFifo64B(register const void * pSrc, register void * pDest);
void GX_SendFifo128B(register const void * pSrc, register void * pDest);
static inline void GX_SendFifo36B (register const void * pSrc, register void * pDest) {
MI_Copy36B(pSrc, pDest);
}
#ifdef __cplusplus
}
#endif
#endif

53
lib/NitroSDK/src/gx/include/gxdma.h Normal file
View File

@ -0,0 +1,53 @@
#ifndef NITRO_GXDMA_H_
#define NITRO_GXDMA_H_
#include <nitro/gx/gx.h>
#include <nitro/mi.h>
#ifdef __cplusplus
extern "C" {
#endif
static void GXi_DmaCopy32(u32 dmaNo, const void * src, void * dest, u32 size);
static void GXi_DmaCopy16(u32 dmaNo, const void * src, void * dest, u32 size);
static void GXi_DmaCopy32Async(u32 dmaNo, const void * src, void * dest, u32 size, MIDmaCallback callback, void * arg);
static void GXi_WaitDma(u32 dmaNo);
#define GX_CPU_FASTER32_SIZE 48
#define GX_CPU_FASTER16_SIZE 28
static inline void GXi_DmaCopy32 (u32 dmaNo, const void * src, void * dest, u32 size) {
if (dmaNo != GX_DMA_NOT_USE && size > GX_CPU_FASTER32_SIZE) {
MI_DmaCopy32(dmaNo, src, dest, size);
} else {
MI_CpuCopy32(src, dest, size);
}
}
static inline void GXi_DmaCopy16 (u32 dmaNo, const void * src, void * dest, u32 size) {
if (dmaNo != GX_DMA_NOT_USE && size > GX_CPU_FASTER16_SIZE) {
MI_DmaCopy16(dmaNo, src, dest, size);
} else {
MI_CpuCopy16(src, dest, size);
}
}
static inline void GXi_DmaCopy32Async (u32 dmaNo, const void * src, void * dest, u32 size, MIDmaCallback callback, void * arg) {
if (dmaNo != GX_DMA_NOT_USE) {
MI_DmaCopy32Async(dmaNo, src, dest, size, callback, arg);
} else {
MI_CpuCopy32(src, dest, size);
}
}
static inline void GXi_WaitDma (u32 dmaNo) {
if (dmaNo != GX_DMA_NOT_USE) {
MI_WaitDma(dmaNo);
}
}
#ifdef __cplusplus
}
#endif
#endif

109
lib/NitroSDK/src/gx/include/gxstate.h Normal file
View File

@ -0,0 +1,109 @@
#ifndef NITRO_GXSTATE_H_
#define NITRO_GXSTATE_H_
#include <nitro/gx/gx.h>
#include <nitro/gx/gx_vramcnt.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
u16 lcdc;
u16 bg;
u16 obj;
u16 arm7;
u16 tex;
u16 texPltt;
u16 clrImg;
u16 bgExtPltt;
u16 objExtPltt;
u16 sub_bg;
u16 sub_obj;
u16 sub_bgExtPltt;
u16 sub_objExtPltt;
} GX_VRAMCnt_;
typedef struct {
GX_VRAMCnt_ vramCnt;
} GX_State;
extern GX_State gGXState;
void GX_InitGXState();
#ifdef SDK_DEBUG
void GX_StateCheck_VRAMCnt_();
void GX_RegionCheck_BG_(u32 first, u32 last);
void GX_RegionCheck_OBJ_(u32 first, u32 last);
void GX_RegionCheck_SubBG_(u32 first, u32 last);
void GX_RegionCheck_SubOBJ_(u32 first, u32 last);
void GX_RegionCheck_Tex_(GXVRamTex tex, u32 first, u32 last);
void GX_RegionCheck_TexPltt_(GXVRamTexPltt texPltt, u32 first, u32 last);
#endif
#ifdef SDK_DEBUG
static inline void GX_StateCheck_VRAMCnt () {
GX_StateCheck_VRAMCnt_();
}
static inline void GX_RegionCheck_BG (u32 first, u32 last) {
GX_RegionCheck_BG_(first, last);
}
static inline void GX_RegionCheck_OBJ (u32 first, u32 last) {
GX_RegionCheck_OBJ_(first, last);
}
static inline void GX_RegionCheck_SubBG (u32 first, u32 last) {
GX_RegionCheck_SubBG_(first, last);
}
static inline void GX_RegionCheck_SubOBJ (u32 first, u32 last) {
GX_RegionCheck_SubOBJ_(first, last);
}
static inline void GX_RegionCheck_Tex (GXVRamTex tex, u32 first, u32 last) {
GX_RegionCheck_Tex_(tex, first, last);
}
static inline void GX_RegionCheck_TexPltt (GXVRamTexPltt texPltt, u32 first, u32 last) {
GX_RegionCheck_TexPltt_(texPltt, first, last);
}
#else
static inline void GX_StateCheck_VRAMCnt (void) {
return;
}
static inline void GX_RegionCheck_BG (u32, u32) {
return;
}
static inline void GX_RegionCheck_OBJ (u32, u32) {
return;
}
static inline void GX_RegionCheck_SubBG (u32, u32) {
return;
}
static inline void GX_RegionCheck_SubOBJ (u32, u32) {
return;
}
static inline void GX_RegionCheck_Tex (GXVRamTex, u32, u32) {
return;
}
static inline void GX_RegionCheck_TexPltt (GXVRamTexPltt, u32, u32) {
return;
}
#endif
#ifdef __cplusplus
}
#endif
#endif

26
main.lsf
View File

@ -465,19 +465,19 @@ Static main
Object lib/NitroSDK/src/fx/fx_sincos.o
Object lib/NitroSDK/src/fx/fx_atanidx.o
Object lib/NitroSDK/src/fx/fx.o
Object lib/NitroSDK/asm/gx/gx.o
Object lib/NitroSDK/asm/gx/gxstate.o
Object lib/NitroSDK/asm/gx/gx_vramcnt.o
Object lib/NitroSDK/asm/gx/gx_bgcnt.o
Object lib/NitroSDK/asm/gx/g2.o
Object lib/NitroSDK/asm/gx/g3b.o
Object lib/NitroSDK/asm/gx/g3imm.o
Object lib/NitroSDK/asm/gx/g3x.o
Object lib/NitroSDK/asm/gx/g3_util.o
Object lib/NitroSDK/asm/gx/gx_load2d.o
Object lib/NitroSDK/asm/gx/gx_load3d.o
Object lib/NitroSDK/asm/gx/libgx.o
Object lib/NitroSDK/asm/gx/gxasm.o
Object lib/NitroSDK/src/gx/gx.o
Object lib/NitroSDK/src/gx/gxstate.o
Object lib/NitroSDK/src/gx/gx_vramcnt.o
Object lib/NitroSDK/src/gx/gx_bgcnt.o
Object lib/NitroSDK/src/gx/g2.o
Object lib/NitroSDK/src/gx/g3b.o
Object lib/NitroSDK/src/gx/g3imm.o
Object lib/NitroSDK/src/gx/g3x.o
Object lib/NitroSDK/src/gx/g3_util.o
Object lib/NitroSDK/src/gx/gx_load2d.o
Object lib/NitroSDK/src/gx/gx_load3d.o
Object lib/NitroSDK/src/gx/g3.o
Object lib/NitroSDK/src/gx/gxasm.o
Object lib/NitroSDK/asm/os/os_irqhandler.o
Object lib/NitroSDK/asm/os/os_irqtable.o
Object lib/NitroSDK/asm/os/os_interrupt.o